From aeb89de300584c8ee9fcf88d0f612add37acfb68 Mon Sep 17 00:00:00 2001
From: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date: Sun, 19 Jan 2025 01:51:45 +0100
Subject: [PATCH 01/11] marked book references

---
 Cubical/Data/Fin/Properties.agda             |    2 +-
 Cubical/Data/Int/Order.agda                  |   43 +
 Cubical/Data/Int/Properties.agda             |   23 +-
 Cubical/Data/Nat/Mod.agda                    |  121 +-
 Cubical/Data/Nat/Order.agda                  |   44 +
 Cubical/Data/Nat/Order/Recursive.agda        |   28 +-
 Cubical/Data/Nat/Properties.agda             |    4 +
 Cubical/Data/Rationals/Order.agda            |  315 +++-
 Cubical/Data/Rationals/Order/Properties.agda | 1506 ++++++++++++++++++
 Cubical/Data/Rationals/Properties.agda       |  266 +++-
 Cubical/Foundations/HLevels.agda             |   22 +
 Cubical/HITs/CauchyReals/Base.agda           |  348 ++++
 Cubical/HITs/CauchyReals/Closeness.agda      |  880 ++++++++++
 Cubical/HITs/CauchyReals/Continuous.agda     |  970 +++++++++++
 Cubical/HITs/CauchyReals/Derivative.agda     |  165 ++
 Cubical/HITs/CauchyReals/Inverse.agda        | 1135 +++++++++++++
 Cubical/HITs/CauchyReals/Lems.agda           |  280 ++++
 Cubical/HITs/CauchyReals/Lipschitz.agda      |  673 ++++++++
 Cubical/HITs/CauchyReals/Multiplication.agda |  709 +++++++++
 Cubical/HITs/CauchyReals/Order.agda          |  466 ++++++
 Cubical/HITs/CauchyReals/Sequence.agda       |  513 ++++++
 Cubical/HITs/SetQuotients/Properties.agda    |  120 ++
 22 files changed, 8537 insertions(+), 96 deletions(-)
 create mode 100644 Cubical/Data/Rationals/Order/Properties.agda
 create mode 100644 Cubical/HITs/CauchyReals/Base.agda
 create mode 100644 Cubical/HITs/CauchyReals/Closeness.agda
 create mode 100644 Cubical/HITs/CauchyReals/Continuous.agda
 create mode 100644 Cubical/HITs/CauchyReals/Derivative.agda
 create mode 100644 Cubical/HITs/CauchyReals/Inverse.agda
 create mode 100644 Cubical/HITs/CauchyReals/Lems.agda
 create mode 100644 Cubical/HITs/CauchyReals/Lipschitz.agda
 create mode 100644 Cubical/HITs/CauchyReals/Multiplication.agda
 create mode 100644 Cubical/HITs/CauchyReals/Order.agda
 create mode 100644 Cubical/HITs/CauchyReals/Sequence.agda

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..98ddca2e15 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..11b8c5ca18 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..a406893d45 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..a876ef2fff 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..761f31fd87 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..c2a5a3a130
--- /dev/null
+++ b/Cubical/Data/Rationals/Order/Properties.agda
@@ -0,0 +1,1506 @@
+{-# 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'
+
+
+
+
+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'))
+
+
+
+
+≤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))
+
+
+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≡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 
+
+
+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..bb4fa75e39 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..86ba7dba82 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/Base.agda b/Cubical/HITs/CauchyReals/Base.agda
new file mode 100644
index 0000000000..a664c259c4
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Base.agda
@@ -0,0 +1,348 @@
+{-# OPTIONS --safe #-}
+module Cubical.HITs.CauchyReals.Base 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.Isomorphism
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Nat.Order.Recursive as OR
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Unit
+open import Cubical.Data.Int as ℤ
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Maybe as Mb
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.List as L
+open import Cubical.Data.List using () renaming (List to ⟦_⟧)
+open import Cubical.Foundations.Interpolate
+open import Cubical.Relation.Nullary
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+
+open import Cubical.Data.Rationals as ℚ
+open import Cubical.Data.Rationals.Order as ℚ
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+open import Cubical.HITs.CauchyReals.Lems
+
+import Agda.Builtin.Reflection as R
+open import Cubical.Reflection.Base
+
+
+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..3fd47f4e73
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Closeness.agda
@@ -0,0 +1,880 @@
+{-# 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.Isomorphism
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Nat.Order.Recursive as OR
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Unit
+open import Cubical.Data.Int as ℤ
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Maybe as Mb
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.List as L
+open import Cubical.Data.List using () renaming (List to ⟦_⟧)
+open import Cubical.Foundations.Interpolate
+open import Cubical.Relation.Nullary
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+
+open import Cubical.Data.Rationals as ℚ
+open import Cubical.Data.Rationals.Order as ℚ
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+
+import Agda.Builtin.Reflection as R
+open import Cubical.Reflection.Base
+
+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..280bc2bb1f
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Continuous.agda
@@ -0,0 +1,970 @@
+{-# OPTIONS --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 hiding (_■)
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+open import Cubical.Algebra.CommRing.Instances.Int
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Nat.Order.Recursive as OR
+import Cubical.Data.Nat.Order as ℕ
+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)
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Maybe as Mb
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.List as L
+open import Cubical.Data.List using () renaming (List to ⟦_⟧)
+open import Cubical.Foundations.Interpolate
+open import Cubical.Relation.Nullary
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+
+open import Cubical.Data.Rationals using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+
+import Cubical.Data.Rationals as ℚ
+import Cubical.Data.Rationals.Order as ℚ
+open import Cubical.Data.Rationals.Order.Properties as ℚ using (invℚ₊)
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+
+import Agda.Builtin.Reflection as R
+open import Cubical.Reflection.Base
+
+
+import Cubical.Algebra.CommRing as CR
+
+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]n/k≡y-[y-x]m/k : ∀ x y n m k → (n ℕ.+ m ≡ ℕ₊₁→ℕ k) → 
+--   x ℚ.+ (y ℚ.- x) ℚ.· [ pos n / k ] 
+--    ≡ y ℚ.- ((y ℚ.- x) ℚ.· [ pos m / k ])
+-- x+[y-x]n/k≡y-[y-x]m/k u v n m k p =
+--   ((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 ℚ.· [ pos m / k ]))
+--                   (ℚ.- ((ℚ.- u) ℚ.· [ pos m / k ])))
+--             ∙ cong (ℚ._+_ v)
+--                 (sym (ℚ.·DistL+ -1 _ _)) ∙ cong (ℚ._-_ v)
+--            (sym (ℚ.·DistR+ v (ℚ.- u) [ pos m / k ])) ))
+
+
+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..27bb4c2c74
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -0,0 +1,165 @@
+{-# OPTIONS --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Derivative where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv hiding (_■)
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.Function
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+open import Cubical.Algebra.CommRing.Instances.Int
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+import Cubical.Data.Nat.Mod as ℕ
+open import Cubical.Data.Nat.Order.Recursive as OR
+import Cubical.Data.Nat.Order as ℕ
+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)
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Maybe as Mb
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.List as L
+open import Cubical.Data.List using () renaming (List to ⟦_⟧)
+open import Cubical.Foundations.Interpolate
+open import Cubical.Relation.Nullary
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+
+open import Cubical.Data.Rationals using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+
+import Cubical.Data.Rationals as ℚ
+import Cubical.Data.Rationals.Order as ℚ
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+open import Cubical.Data.Rationals using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+
+import Cubical.Data.Rationals as ℚ
+import Cubical.Data.Rationals.Order as ℚ
+open import Cubical.Data.Rationals.Order.Properties as ℚ using (invℚ₊;/2₊;x/2<x;/4₊;invℚ)
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+
+import Agda.Builtin.Reflection as R
+open import Cubical.Reflection.Base
+
+
+import Cubical.Algebra.CommRing as CR
+
+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
+
+import Cubical.Algebra.CommRing as CR
+import Cubical.Algebra.Ring as RP
+
+
+
+-- Rℝ = (CR.CommRing→Ring
+--                (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ))
+-- -- module CRℝ = ? 
+
+-- module 𝐑 = CR.CommRingTheory (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ)
+-- module 𝐑' = RP.RingTheory Rℝ
+               
+
+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 ε)
+
+
+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 )  ∣₁
+
+_$[_]$_ : {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 {!u!})
+    (fL (ε ₊／ᵣ₊ 2))
+     (gL (ε ₊／ᵣ₊ 2))
+
+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-^ⁿ : ∀ n x →
+--    derivativeOf (_^ⁿ (suc n)) at x is (fromNat n ·ᵣ (x ^ⁿ n))
+-- derivative-^ⁿ zero x ε = {!!}
+-- derivative-^ⁿ (suc n) x ε = {!!}
+
+
diff --git a/Cubical/HITs/CauchyReals/Inverse.agda b/Cubical/HITs/CauchyReals/Inverse.agda
new file mode 100644
index 0000000000..b067ce4f06
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Inverse.agda
@@ -0,0 +1,1135 @@
+{-# OPTIONS --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Inverse where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv hiding (_■)
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.Function
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+open import Cubical.Algebra.CommRing.Instances.Int
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Nat.Order.Recursive as OR
+import Cubical.Data.Nat.Order as ℕ
+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)
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Maybe as Mb
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.List as L
+open import Cubical.Data.List using () renaming (List to ⟦_⟧)
+open import Cubical.Foundations.Interpolate
+open import Cubical.Relation.Nullary
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+
+open import Cubical.Data.Rationals using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+
+import Cubical.Data.Rationals as ℚ
+import Cubical.Data.Rationals.Order as ℚ
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+open import Cubical.Data.Rationals using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+
+import Cubical.Data.Rationals as ℚ
+import Cubical.Data.Rationals.Order as ℚ
+open import Cubical.Data.Rationals.Order.Properties as ℚ using (invℚ₊;/2₊;x/2<x;/4₊;invℚ)
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+
+import Agda.Builtin.Reflection as R
+open import Cubical.Reflection.Base
+
+
+import Cubical.Algebra.CommRing as CR
+
+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
+
+import Cubical.Algebra.CommRing as CR
+import Cubical.Algebra.Ring as RP
+
+
+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 : ℚ₊) →  m ≤ᵣ n → (m ·ᵣ rat (fst o) ) ≤ᵣ (n ·ᵣ rat (fst o))
+≤ᵣ-·o m n o p = sym (·ᵣMaxDistrPos m n (fst o) (snd o)) ∙
+  cong (_·ᵣ rat (fst o)) p
+
+≤ᵣ-o· : ∀ m n (o : ℚ₊) →  m ≤ᵣ n → (rat (fst o) ·ᵣ m ) ≤ᵣ (rat (fst o) ·ᵣ n)
+≤ᵣ-o· m n o p =
+    cong₂ maxᵣ (·ᵣComm _ _ ) (·ᵣComm _ _ ) ∙ ≤ᵣ-·o m n o 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
+
+
+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 (isTrans≤ᵣ _ _ _
+                   limRestr'' (≤ᵣ-·o _ _ ([ 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)
+invℝ : ∀ r → 0 ＃ r → ℝ
+invℝ r 0＃r = signᵣ r 0＃r ·ᵣ fst invℝ' (absᵣ r) (0＃→0<abs r 0＃r) 
+
+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))
+  
+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 _ _) 
+
+-ᵣ≡[-1·ᵣ] : ∀ x → -ᵣ x ≡ (-1) ·ᵣ x
+-ᵣ≡[-1·ᵣ] = ≡Continuous _ _
+   IsContinuous-ᵣ
+   (IsContinuous·ᵣL -1)
+   λ r → 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)
+
+
+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 
+
+
+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
+
+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 
+
+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 
diff --git a/Cubical/HITs/CauchyReals/Lems.agda b/Cubical/HITs/CauchyReals/Lems.agda
new file mode 100644
index 0000000000..b172562c23
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Lems.agda
@@ -0,0 +1,280 @@
+{-# 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
+
+
+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..ff0e0826cc
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Lipschitz.agda
@@ -0,0 +1,673 @@
+{-# OPTIONS --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.Equiv hiding (_■)
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+open import Cubical.Algebra.CommRing.Instances.Int
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Nat.Order.Recursive as OR
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Unit
+open import Cubical.Data.Int as ℤ
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Maybe as Mb
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.List as L
+open import Cubical.Data.List using () renaming (List to ⟦_⟧)
+open import Cubical.Foundations.Interpolate
+open import Cubical.Relation.Nullary
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+
+open import Cubical.Data.Rationals using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+
+import Cubical.Data.Rationals as ℚ
+open import Cubical.Data.Rationals.Order as ℚ
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+
+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)
+
+
+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))
+
+
+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..0353b22a5c
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Multiplication.agda
@@ -0,0 +1,709 @@
+{-# OPTIONS --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 hiding (_■)
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+open import Cubical.Algebra.CommRing.Instances.Int
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Nat.Order.Recursive as OR
+import Cubical.Data.Nat.Order as ℕ
+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)
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Maybe as Mb
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.List as L
+open import Cubical.Data.List using () renaming (List to ⟦_⟧)
+open import Cubical.Foundations.Interpolate
+open import Cubical.Relation.Nullary
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+
+open import Cubical.Data.Rationals using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+
+import Cubical.Data.Rationals as ℚ
+import Cubical.Data.Rationals.Order as ℚ
+open import Cubical.Data.Rationals.Order.Properties as ℚ using (invℚ₊)
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+
+import Agda.Builtin.Reflection as R
+open import Cubical.Reflection.Base
+
+
+import Cubical.Algebra.CommRing as CR
+
+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
+
+_·ᵣ_ : ℝ → ℝ → ℝ
+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 
+
+
+-ᵣ· : ∀ x y →  ((-ᵣ x) ·ᵣ y) ≡  -ᵣ (x ·ᵣ y)
+-ᵣ· x y = ·ᵣComm _ _ ∙∙ ·-ᵣ y x ∙∙ cong -ᵣ_ (·ᵣComm _ _)
+
+
+_^ⁿ_ : ℝ → ℕ → ℝ
+x ^ⁿ zero = 1
+x ^ⁿ suc n = (x ^ⁿ n) ·ᵣ x 
diff --git a/Cubical/HITs/CauchyReals/Order.agda b/Cubical/HITs/CauchyReals/Order.agda
new file mode 100644
index 0000000000..466061042f
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Order.agda
@@ -0,0 +1,466 @@
+{-# OPTIONS --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 hiding (_■)
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+open import Cubical.Algebra.CommRing.Instances.Int
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Nat.Order.Recursive as OR
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Unit
+open import Cubical.Data.Int as ℤ
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Maybe as Mb
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.List as L
+open import Cubical.Data.List using () renaming (List to ⟦_⟧)
+open import Cubical.Foundations.Interpolate
+open import Cubical.Relation.Nullary
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+
+open import Cubical.Data.Rationals using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+
+import Cubical.Data.Rationals as ℚ
+import Cubical.Data.Rationals.Order as ℚ
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+
+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
+
+
+
+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}))
+
+_+ᵣ_ : ℝ → ℝ → ℝ
+_+ᵣ_ = 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
+
+-ᵣ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 (ℚ.<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..fd4b92f5cd
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -0,0 +1,513 @@
+{-# OPTIONS --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Sequence where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv hiding (_■)
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.Function
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+open import Cubical.Algebra.CommRing.Instances.Int
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+import Cubical.Data.Nat.Mod as ℕ
+open import Cubical.Data.Nat.Order.Recursive as OR
+import Cubical.Data.Nat.Order as ℕ
+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)
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Maybe as Mb
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.List as L
+open import Cubical.Data.List using () renaming (List to ⟦_⟧)
+open import Cubical.Foundations.Interpolate
+open import Cubical.Relation.Nullary
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+
+open import Cubical.Data.Rationals using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+
+import Cubical.Data.Rationals as ℚ
+import Cubical.Data.Rationals.Order as ℚ
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+open import Cubical.Data.Rationals using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+
+import Cubical.Data.Rationals as ℚ
+import Cubical.Data.Rationals.Order as ℚ
+open import Cubical.Data.Rationals.Order.Properties as ℚ using (invℚ₊;/2₊;x/2<x;/4₊;invℚ)
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+
+import Agda.Builtin.Reflection as R
+open import Cubical.Reflection.Base
+
+
+import Cubical.Algebra.CommRing as CR
+
+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
+
+import Cubical.Algebra.CommRing as CR
+import Cubical.Algebra.Ring as RP
+
+               
+Seq : Type
+Seq = ℕ → ℝ
+
+
+
+
+≤ᵣ-·ᵣo : ∀ m n (o : ℝ₊) →  m ≤ᵣ n → (m ·ᵣ (fst o) ) ≤ᵣ (n ·ᵣ (fst o))
+≤ᵣ-·ᵣo m n o p =
+  ≡ContinuousWithPred _ _
+     (openPred< 0) (openPred< 0)
+     (λ o _ → maxᵣ (m ·ᵣ o) (n ·ᵣ o) )
+     (λ o _ → n ·ᵣ o)
+     (contDiagNE₂WP maxR _
+        _ _
+       (cont₂·ᵣWP _ _ _ ((AsContinuousWithPred _ _ (IsContinuousConst _)))
+          (AsContinuousWithPred _ _ (IsContinuousId)))
+       ((cont₂·ᵣWP _ _ _ (AsContinuousWithPred _ _ (IsContinuousConst _))
+         (AsContinuousWithPred _ _ (IsContinuousId)))))
+     ((cont₂·ᵣWP _ _ _ (AsContinuousWithPred _ _ (IsContinuousConst _))
+       (AsContinuousWithPred _ _ (IsContinuousId))))
+     (λ r 0<r _ → ≤ᵣ-·o m n (r , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<r)) p)
+       (fst o) (snd o) (snd o)
+
+
+≤ᵣ-o·ᵣ : ∀ m n (o : ℝ₊) →  m ≤ᵣ n → ((fst o) ·ᵣ m   ) ≤ᵣ ((fst o) ·ᵣ n)
+≤ᵣ-o·ᵣ m n o p = subst2 _≤ᵣ_
+  (·ᵣComm _ _)
+  (·ᵣComm _ _)
+  (≤ᵣ-·ᵣo m n o p)
+
+≤ᵣ₊Monotone·ᵣ : ∀ m (n : ℝ₊) (o : ℝ₊) s
+       → m ≤ᵣ (fst n) → fst o ≤ᵣ s
+       → (m ·ᵣ fst o) ≤ᵣ (fst n ·ᵣ s)
+≤ᵣ₊Monotone·ᵣ m (n , 0<n) (o , 0<o) s 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 , 0<m) (rat r' , <ℚ→<ᵣ _ _ 0<r') n
+                             q'≤m r'≤n) ) 0<m 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 = ℝ₊·
+  (_ , 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)
+
+
+
+/nᵣ : ℕ₊₁ → ℝ → ℝ
+/nᵣ n = fst (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)))
+
+
+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
+
+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 ε   )
+
+
+IsConvSeries : Seq → Type
+IsConvSeries s =
+    ∀ (ε : ℝ₊) →
+     Σ[ N ∈ ℕ ] ∀ n m → 
+       absᵣ (seqΣ (s ∘ (ℕ._+ (n ℕ.+ (suc N)))) m) <ᵣ 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)
+
+
+
+isCauchyAprox : (ℚ₊ → ℝ) → Type
+isCauchyAprox f = (δ ε : ℚ₊) →
+  (absᵣ (f δ +ᵣ (-ᵣ  f ε)) <ᵣ rat (fst (δ ℚ₊+ ε)))
+
+lim' : ∀ x → isCauchyAprox x → ℝ
+lim' x y = lim x λ δ ε  → (invEq (∼≃abs<ε _ _ _)) (y δ ε)  
+
+
+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ₙ→∞ : Seq → Type
+Limₙ→∞ s = Σ _ (limₙ→∞ s is_) 
diff --git a/Cubical/HITs/SetQuotients/Properties.agda b/Cubical/HITs/SetQuotients/Properties.agda
index f2327a424d..b741a97e7c 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

From 0f85a79b63c5e3ba4dff3d5f9d6d84ad9fbba056 Mon Sep 17 00:00:00 2001
From: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date: Sun, 19 Jan 2025 01:55:27 +0100
Subject: [PATCH 02/11] fixed whitespace violations

---
 Cubical/Data/Int/Order.agda                  |   4 +-
 Cubical/Data/Int/Properties.agda             |   2 +-
 Cubical/Data/Nat/Mod.agda                    |  14 +-
 Cubical/Data/Nat/Order.agda                  |   6 +-
 Cubical/Data/Rationals/Order.agda            |  80 +++---
 Cubical/Data/Rationals/Order/Properties.agda | 250 +++++++++----------
 Cubical/Data/Rationals/Properties.agda       |  10 +-
 Cubical/Foundations/HLevels.agda             |   2 +-
 Cubical/HITs/CauchyReals/Base.agda           |  52 ++--
 Cubical/HITs/CauchyReals/Closeness.agda      | 148 +++++------
 Cubical/HITs/CauchyReals/Continuous.agda     |  96 +++----
 Cubical/HITs/CauchyReals/Derivative.agda     |  15 +-
 Cubical/HITs/CauchyReals/Inverse.agda        | 210 ++++++++--------
 Cubical/HITs/CauchyReals/Lems.agda           |  68 ++---
 Cubical/HITs/CauchyReals/Lipschitz.agda      | 100 ++++----
 Cubical/HITs/CauchyReals/Multiplication.agda |  78 +++---
 Cubical/HITs/CauchyReals/Order.agda          |  80 +++---
 Cubical/HITs/CauchyReals/Sequence.agda       |  76 +++---
 Cubical/HITs/SetQuotients/Properties.agda    |  22 +-
 19 files changed, 656 insertions(+), 657 deletions(-)

diff --git a/Cubical/Data/Int/Order.agda b/Cubical/Data/Int/Order.agda
index 98ddca2e15..e728308348 100644
--- a/Cubical/Data/Int/Order.agda
+++ b/Cubical/Data/Int/Order.agda
@@ -512,7 +512,7 @@ isProp0< (pos (suc _)) _ _ = refl
 ·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<·ℕ₊₁ : ∀ 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)
@@ -533,7 +533,7 @@ 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 → 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
 
 
diff --git a/Cubical/Data/Int/Properties.agda b/Cubical/Data/Int/Properties.agda
index 11b8c5ca18..088182ed42 100644
--- a/Cubical/Data/Int/Properties.agda
+++ b/Cubical/Data/Int/Properties.agda
@@ -1506,7 +1506,7 @@ 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 : ∀ n → pos (abs n) ≡ max n (- n)
 abs-max (pos zero) = refl
 abs-max (pos (suc n)) = refl
 abs-max (negsuc n) = refl
diff --git a/Cubical/Data/Nat/Mod.agda b/Cubical/Data/Nat/Mod.agda
index a406893d45..1d53e66990 100644
--- a/Cubical/Data/Nat/Mod.agda
+++ b/Cubical/Data/Nat/Mod.agda
@@ -37,7 +37,7 @@ 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 : (n x : ℕ) → x < (suc n) → x mod (suc n) ≡ x
 <→mod = modIndBase
 
 mod-rUnit : (n x : ℕ) → x mod n ≡ ((x + n) mod n)
@@ -208,7 +208,7 @@ private
 ·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) → 
+ ·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)
@@ -236,10 +236,10 @@ private
  ·mod' (suc N) n x (inr x₁) =
    modIndBase _ _ (
      subst2 _<_ (·-comm n (suc k)) (·-comm _ (suc k))
-      (<-·sk {n} {suc m} {k = k} x₁) ) 
+      (<-·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 → 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))
@@ -270,10 +270,10 @@ private
 -- -- 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 
+-- log2ℕ n = w n n ≤-refl
 --  where
-   
---   w : ∀ N n → n ≤ N 
+
+--   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 ,
diff --git a/Cubical/Data/Nat/Order.agda b/Cubical/Data/Nat/Order.agda
index a876ef2fff..0b6808ac7c 100644
--- a/Cubical/Data/Nat/Order.agda
+++ b/Cubical/Data/Nat/Order.agda
@@ -499,7 +499,7 @@ 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 = 
+[n-m]+m (suc m) (suc n) p =
   +-suc _ _ ∙ cong suc ([n-m]+m m n (pred-≤-pred p))
 
 -- automation
@@ -573,14 +573,14 @@ elimBy≤ : ∀ {ℓ} {A : ℕ → ℕ → Type ℓ}
   → (∀ 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 _ _ )  
+  (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')  
+ elimBy≤ s λ x y (y' , p) → subst (A x) p (f x y')
 
 module Minimal where
   Least : ∀{ℓ} → (ℕ → Type ℓ) → (ℕ → Type ℓ)
diff --git a/Cubical/Data/Rationals/Order.agda b/Cubical/Data/Rationals/Order.agda
index 761f31fd87..78828b1a2a 100644
--- a/Cubical/Data/Rationals/Order.agda
+++ b/Cubical/Data/Rationals/Order.agda
@@ -443,20 +443,20 @@ isTrans≤< =
 
 <≤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₁)  
+   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₁)  
+   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) 
+<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) 
+<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
@@ -680,7 +680,7 @@ minus-< m n p =
                ((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) ) 
+           (cong (ℚ._+ - m) (+InvR n) ∙ +IdL (- m) )
   in subst2 _<_ p q z
 
 
@@ -694,15 +694,15 @@ minus-≤ m n p =
                ((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) ) 
+           (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 = 
+minus-<' : ∀ n m → - n < - m → m < n
+minus-<' n m p =
   subst2 _<_ (-Invol m) (-Invol n)
    (minus-< (ℚ.- n) (ℚ.- m) p)
 
@@ -712,7 +712,7 @@ minus-<' n m p =
  where
  w : Rec (hProp ℓ-zero)
  w .Rec.isSetB = isSetHProp
- w .Rec.f (x , _) = ℤ.0< x , ℤ.isProp0< x 
+ w .Rec.f (x , _) = ℤ.0< x , ℤ.isProp0< x
  w .Rec.f∼ (x , y) (x' , y') p =
   ⇔toPath --0<·ℕ₊₁
      (λ u → ℤ.0<·ℕ₊₁ x' y
@@ -728,22 +728,22 @@ minus-<' n m p =
 ·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'  
+  λ (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' → 
+  λ (x , y) (x' , y')  p p' →
     ℤ.+0< (x ℤ.· ℕ₊₁→ℤ y') (x' ℤ.· ℕ₊₁→ℤ y)
-      (ℤ.·0< x (ℕ₊₁→ℤ y') p tt) (ℤ.·0< x' (ℕ₊₁→ℤ y) p' tt)  
+      (ℤ.·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 x y z = +0< (m ℚ.+ n) o (+0< m n x y) z
 
-+₃0<' : ∀ m n o o' → 0< m → 0< n → 0< o 
++₃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)
 
@@ -754,25 +754,25 @@ minus-<' n m p =
 
 instance
   fromNatℚ₊ : HasFromNat ℚ₊
-  fromNatℚ₊ = 
+  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<→< : ∀ 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))))
@@ -784,17 +784,17 @@ _ℚ₊+_ x x₁ = ((fst x) ℚ.+ (fst x₁)) ,
 0≤ℚ₊ ε = <Weaken≤ 0 (fst ε) (uncurry 0<→< ε)
 
 
-<→0< : ∀ q → 0 < q → 0< q 
-<→0< = elimProp (λ x → isProp→ (snd (0<ₚ x))) 
+<→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 = 
+ 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))  
+    (ℤ.pos+ 1 (x .fst) ∙  snd x ∙ ℤ.·IdR (ℤ.negsuc n))
 
 0<-min : ∀ x y → 0< x → 0< y → 0< (ℚ.min x y)
 0<-min = elimProp2
@@ -803,7 +803,7 @@ _ℚ₊+_ x x₁ = ((fst x) ℚ.+ (fst 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₊ : ℚ₊ → ℚ₊ → ℚ₊
@@ -834,18 +834,18 @@ max₊ (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₁ = 
+<+ℚ₊ 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₁ = 
+<+ℚ₊' 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₁ = 
+≤+ℚ₊ x y ε x₁ =
  subst (_≤ y ℚ.+ fst ε)
    (ℚ.+IdR x) (≤Monotone+ x y 0 (fst ε) x₁ (0≤ℚ₊ ε))
 
@@ -862,28 +862,28 @@ 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₁ = 
+<-ℚ₊ : ∀ 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₁ = 
+<-ℚ₊' : ∀ 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₁ = 
+≤-ℚ₊ : ∀ 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<ℚ₊ ε') 
+-ℚ₊<ℚ₊ ε ε' = isTrans< (ℚ.- (fst ε)) 0 (fst ε') (-ℚ₊<0 ε) (0<ℚ₊ ε')
 
 -ℚ₊≤ℚ₊ : (ε ε' : ℚ₊) → ℚ.- (fst ε) ≤ fst ε'
--ℚ₊≤ℚ₊ ε ε' = isTrans≤ (ℚ.- fst ε) 0 (fst ε') (-ℚ₊≤0 ε) (0≤ℚ₊ ε') 
+-ℚ₊≤ℚ₊ ε ε' = isTrans≤ (ℚ.- fst ε) 0 (fst ε') (-ℚ₊≤0 ε) (0≤ℚ₊ ε')
 
 
 absCases : (q : ℚ) → (abs q ≡ - q) ⊎ (abs q ≡ q)
@@ -896,7 +896,7 @@ absCases q with (- q) ≟ q
 absFrom≤×≤ : ∀ ε q →
                 - ε ≤ q
                 → q ≤ ε
-                → abs 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₁
@@ -904,7 +904,7 @@ absFrom≤×≤ ε q x x₁ with absCases q
 absFrom<×< : ∀ ε q →
                 - ε < q
                 → q < ε
-                → abs 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₁
@@ -923,7 +923,7 @@ clamp d u x = ℚ.min (ℚ.max d x) u
 ... | 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 → q ≤ r → (q ≡ r) ⊎ (q < r)
 ≤→≡⊎< q r y with q ≟ r
 ... | lt x = inr x
 ... | eq x = inl x
diff --git a/Cubical/Data/Rationals/Order/Properties.agda b/Cubical/Data/Rationals/Order/Properties.agda
index c2a5a3a130..ae3a1301f5 100644
--- a/Cubical/Data/Rationals/Order/Properties.agda
+++ b/Cubical/Data/Rationals/Order/Properties.agda
@@ -39,13 +39,13 @@ open import Cubical.HITs.CauchyReals.Lems
 
 open import Cubical.Algebra.CommRing.Instances.Int
 
-decℚ? : ∀ {x y} → {𝟚.True (discreteℚ x y)} →  (x ≡ y) 
+decℚ? : ∀ {x y} → {𝟚.True (discreteℚ x y)} →  (x ≡ y)
 decℚ? {_} {_} {p} = 𝟚.toWitness p
 
-decℚ<? : ∀ {x y} → {𝟚.True (<Dec x y)} →  (x < y) 
+decℚ<? : ∀ {x y} → {𝟚.True (<Dec x y)} →  (x < y)
 decℚ<? {_} {_} {p} = 𝟚.toWitness p
 
-decℚ≤? : ∀ {x y} → {𝟚.True (≤Dec x y)} →  (x ≤ y) 
+decℚ≤? : ∀ {x y} → {𝟚.True (≤Dec x y)} →  (x ≤ y)
 decℚ≤? {_} {_} {p} = 𝟚.toWitness p
 
 
@@ -53,7 +53,7 @@ decℚ≤? {_} {_} {p} = 𝟚.toWitness p
 
 floor-lemma : ∀ p q → fromNat (ℕ.quotient p / (suc q))
                    ℚ.+ [ ℤ.pos (ℕ.remainder p / (suc q)) / 1+ q ]
-                   ≡ [ ℤ.pos p / 1+ q ] 
+                   ≡ [ ℤ.pos p / 1+ q ]
 floor-lemma p q = eq/ _ _
      (cong (ℤ._· q') w ∙ cong (ℤ.pos p ℤ.·_)
      (cong ℚ.ℕ₊₁→ℤ (sym (·₊₁-identityˡ (1+ q)))))
@@ -67,9 +67,9 @@ floor-lemma p q = eq/ _ _
        ∙ sym (ℤ.pos+ _ _) ∙ cong ℤ.pos
           (ℕ.+-comm _ _  ∙ ℕ.≡remainder+quotient (suc q) p)
 
-      
+
 floor-fracℚ₊ : ∀ (x : ℚ₊) → Σ (ℕ × ℚ) λ (k , q) →
-                       (fromNat k + q ≡ fst x ) × ((0 ≤ q)  × (q < 1))  
+                       (fromNat k + q ≡ fst x ) × ((0 ≤ q)  × (q < 1))
 floor-fracℚ₊ = uncurry (SQ.Elim.go w)
  where
 
@@ -93,7 +93,7 @@ floor-fracℚ₊ = uncurry (SQ.Elim.go w)
               (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ℚ)
@@ -109,7 +109,7 @@ floor-fracℚ₊ = uncurry (SQ.Elim.go w)
       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 _))
@@ -163,7 +163,7 @@ 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 _)) ,
@@ -179,16 +179,16 @@ ceil-[1-frac]ℚ₊ x =
                  (<-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 
+                       ([ 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 
-  
+  in (ℤ.pos c , fr') , e
+
 ... | eq x₁ = (0 , 0) , (x₁ , isRefl≤ 0 , decℚ<? )
 ... | gt x₁ =
   let ((c , fr') , e , e') = ceil-[1-frac]ℚ₊
@@ -196,7 +196,7 @@ floor-frac x with 0 ≟ x
       fl = (ℤ.- ℤ.pos c)
       p : [ fl , 1 ] + fr' ≡ x
       p = (sym (-Invol _)
-             ∙ cong (-_) (-Distr _ _ 
+             ∙ cong (-_) (-Distr _ _
                  ∙ cong (_- fr')
                     (cong [_/ 1 ] (ℤ.-Involutive _) )))
               ∙ sym (cong -_ (+CancelL- _ _ _ e)) ∙ -Invol _
@@ -242,21 +242,21 @@ sign = Rec.go w
 <≃sign = ElimProp.go w
  where
  w : ElimProp _
- w .ElimProp.isPropB _ = 
+ w .ElimProp.isPropB _ =
   isProp× (isOfHLevel≃ 1 (isProp< _ _) (isSetℚ _ _))
-     (isProp× (isOfHLevel≃ 1 (isSetℚ _ _) (isSetℚ _ _)) 
+     (isProp× (isOfHLevel≃ 1 (isSetℚ _ _) (isSetℚ _ _))
          (isOfHLevel≃ 1 (isProp< _ _) (isSetℚ _ _))
        )
- w .ElimProp.f (ℤ.pos zero , (1+ n)) = 
+ w .ElimProp.f (ℤ.pos zero , (1+ n)) =
   propBiimpl→Equiv (isProp< _ _) (isSetℚ _ _)
-    ((λ x₁ → ⊥.rec $ ℤ.isIrrefl< x₁)) 
+    ((λ 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₁ ] _) ,
@@ -290,7 +290,7 @@ sign = Rec.go w
 <→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
@@ -310,7 +310,7 @@ absPos x 0<x = abs≡sign· x ∙∙ cong (x ℚ.·_) (fst (<→sign x) 0<x)  
 
 absNonNeg : ∀ x → 0 ≤ x → abs x ≡ x
 absNonNeg x 0<x with x ≟ 0
-... | lt x₁ = ⊥.rec $ ≤→≯ 0 x 0<x x₁ 
+... | lt x₁ = ⊥.rec $ ≤→≯ 0 x 0<x x₁
 ... | eq x₁ = cong abs x₁ ∙ sym x₁
 ... | gt x₁ = absPos x x₁
 
@@ -341,7 +341,7 @@ abs+pos x y x₁ with y ≟ 0
              (<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) 
+   (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)
@@ -376,7 +376,7 @@ data Trichotomy0· (m n : ℚ) : Type₀ where
   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-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
@@ -392,7 +392,7 @@ trichotomy0· m n with m ≟ 0 | n ≟ 0
  (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 → sign x ℚ.· sign y ≡ sign (x ℚ.· y)
 sign·sign x y = h $ trichotomy0· x y
 
  where
@@ -400,7 +400,7 @@ sign·sign x y = h $ trichotomy0· x y
  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))
@@ -427,9 +427,9 @@ 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) 
+      ((λ 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 → abs x ℚ.· abs y ≡ abs (x ℚ.· y)
 abs·abs x y = cong₂ ℚ._·_ (abs≡sign· x) (abs≡sign· y)
  ∙∙ (sym (ℚ.·Assoc _ _ _)) ∙∙
   cong (x ℚ.·_) (( (ℚ.·Assoc _ _ _)) ∙∙
@@ -440,7 +440,7 @@ 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 →  abs (x ℚ.· y) ≡ x ℚ.· (abs y)
 pos·abs x y 0≤x = sym (abs·abs x y) ∙ cong (ℚ._· (abs y))
   (absNonNeg x 0≤x)
 
@@ -448,7 +448,7 @@ 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 → (x ≤ y) ⊎ (y ≤ x)
 ≤cases x y with x ≟ y
 ... | lt x₁ = inl (<Weaken≤ _ _ x₁)
 ... | eq x₁ = inl (≡Weaken≤ _ _ x₁)
@@ -459,7 +459,7 @@ elimBy≤ : ∀ {ℓ} {A : ℚ → ℚ → Type ℓ}
   → (∀ x y → x ≤ y → A x y)
   → ∀ x y → A x y
 elimBy≤ s f x y = ⊎.rec
-  (f _ _ ) (s _ _ ∘ f _ _ ) (≤cases x y) 
+  (f _ _ ) (s _ _ ∘ f _ _ ) (≤cases x y)
 
 elimBy≡⊎< : ∀ {ℓ} {A : ℚ → ℚ → Type ℓ}
   → (∀ x y → A x y → A y x)
@@ -470,7 +470,7 @@ 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 : ∀ 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 _ _ )
@@ -484,18 +484,18 @@ 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')) 
+      (≤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')) 
+      ∙ 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 = 
+≤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')
@@ -508,7 +508,7 @@ inClamps L L' x u v =
     ∙ ≤→min x L' v
 
 ≤abs : ∀ x → x ≤ abs x
-≤abs x = ≤max x (ℚ.- x) 
+≤abs x = ≤max x (ℚ.- x)
 
 ≤abs' : ∀ x → x ≤ abs' x
 ≤abs' x = subst (x ≤_) (abs'≡abs x) (≤abs x)
@@ -538,18 +538,18 @@ sign·abs x with 0 ≟ 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 → 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 → 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' → 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₁) =
@@ -560,7 +560,7 @@ sign·abs x with 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₁)))))) 
+       ((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₁)))) )
@@ -569,7 +569,7 @@ sign·abs x with 0 ≟ x
 
 0#sign : ∀ q → 0 # q ≃ 0 # (sign q)
 0#sign q =
- propBiimpl→Equiv (isProp# _ _) (isProp# _ _) 
+ propBiimpl→Equiv (isProp# _ _) (isProp# _ _)
    (⊎.map (((flip (subst (0 <_))
      (𝟚.toWitness {Q = <Dec 0 1} _)) ∘ sym) ∘S fst (<→sign q))
      ((((flip (subst (_< 0))
@@ -581,23 +581,23 @@ sign·abs x with 0 ≟ x
 
 
 -- floor-fracℚ₊ : ∀ (x : ℚ₊) → Σ (ℕ × ℚ) λ (k , q) →
---                        (fromNat k + q ≡ fst x ) × (q < 1)  
+--                        (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)  
+--                        (fromNat k + q ≡ fst x ) × (q < 1)
 -- ceil-fracℚ₊ = uncurry (SQ.Elim.go w)
 
-boundℕ : ∀ q → Σ[ k ∈ ℕ₊₁ ] (abs q < ([ ℕ₊₁→ℤ k , 1 ]))  
+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 = 
+... | 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))
 
@@ -614,8 +614,8 @@ invℚ₊ = uncurry (Elim.go w)
   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))) ) ) 
-       
+             (ℤ.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₁))
@@ -631,7 +631,7 @@ invℚ₊-invol = uncurry (ElimProp.go w)
   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
@@ -653,7 +653,7 @@ invℚ₊[x]·x x = cong (fst (invℚ₊ x) ·_) (sym $ invℚ₊-invol 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) 
+     ∙∙ 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
@@ -682,7 +682,7 @@ invℚ₊Dist· = uncurry (flip ∘ uncurry ∘ ElimProp2.go w)
            ( 1 ℤ.·  ((x .fst) ℤ.· (y .fst)))
                ℤ.+
                 pos (y .snd .ℕ₊₁.n ℕ.+ x .snd .ℕ₊₁.n ℕ.· suc (y .snd .ℕ₊₁.n))
-             ℤ.· (((x .fst) ℤ.· (y .fst))) 
+             ℤ.· (((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))}
@@ -697,16 +697,16 @@ invℚ₊Dist· = uncurry (flip ∘ uncurry ∘ ElimProp2.go w)
          ∙ ℤ.·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))
@@ -731,7 +731,7 @@ invℚ₊Dist· = uncurry (flip ∘ uncurry ∘ ElimProp2.go w)
 /4₊+/4₊≡/2₊ ε = ℚ₊≡ (sym (·DistL+ (fst ε) [ 1 / 4 ] [ 1 / 4 ])
    ∙ cong (fst ε ·_) decℚ?)
 
-weak0< : ∀ q (ε δ : ℚ₊) 
+weak0< : ∀ q (ε δ : ℚ₊)
              →  q < (fst ε - fst δ)
              → q < fst ε
 weak0< q ε δ x =
@@ -741,10 +741,10 @@ weak0< q ε δ x =
 
 
 
-weak0<' : ∀ q (ε δ : ℚ₊) 
+weak0<' : ∀ q (ε δ : ℚ₊)
              → - (fst ε - fst δ) < q
-             → - (fst ε) < q  
-weak0<' q ε δ x = 
+             → - (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 δ)}
@@ -757,11 +757,11 @@ n/k+m/k n m k = let k' = pos (suc (k .ℕ₊₁.n)) in
     sym (ℤ.·Assoc (n ℤ.+ m) k' k') ∙∙
      cong ((n ℤ.+ m) ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ k) (ℕ₊₁→ℕ k))))
 
-k/k : ∀ k → [ ℕ₊₁→ℤ k / k ] ≡ 1  
+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 / 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) ]
@@ -770,13 +770,13 @@ k/k (1+ k) = eq/ _ _ (ℤ.·IdR (ℕ₊₁→ℤ (1+ k)))
 
 0</k : ∀ (q q' : ℚ₊) (k : ℕ₊₁) →
           0< ((fst q - fst q') )
-           → 0< ((fst q - fst (q' ℚ₊· ([ 1 / (suc₊₁ k) ] , tt))) ) 
+           → 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')) ∙ 
+     (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))))
@@ -821,22 +821,22 @@ x/2<x ε =
       (ε/2+ε/2≡ε (fst ε)) z
 
 
-getθ : ∀ (ε : ℚ₊) q → (((- fst ε) < q) × (q < fst ε)) → 
+getθ : ∀ (ε : ℚ₊) q → (((- fst ε) < q) × (q < fst ε)) →
    Σ ℚ₊ λ θ → (0< (fst ε - fst θ))
-     × ((- (fst ε - fst θ) < q) × (q < (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 = (/2₊ (fst ε + q ,
                    m1<))
      m2< = <→0< (fst ε - q) $ subst (_< fst ε + (- q))
-              ((+InvR q)) (<-+o q (fst ε) (- q) x')              
+              ((+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 ])
@@ -846,7 +846,7 @@ getθ ε q (x , x') =
                   (x/2<x ((fst ε + q) , m1<))
      z'2 : fst mm < (fst ε - q)
 
-     z'2 = 
+     z'2 =
         isTrans≤< (fst mm)
             _
             (fst ε - q)
@@ -871,7 +871,7 @@ getθ ε q (x , x') =
                      zz' = subst2 _<_
                              (·DistR+ (fst mm) (fst mm) [ pos 1 / 1+ 1 ]
                                 ∙ ε/2+ε/2≡ε (fst mm))
-                              (cong 
+                              (cong
                                 {x = ((fst ε + q) + (fst ε - q))}
                                 {y = (fst ε + fst ε)}
                                 (_· [ pos 1 / 1+ 1 ])
@@ -905,10 +905,10 @@ strength-lem-01 ε q' a'' x =
 
 x/2+[y-x]=y-x/2 : ∀ (x y : ℚ₊) →
    fst (/2₊ x) + (fst y - fst x) ≡
-     fst y - fst (/2₊ 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) 
+    ∙ lem-05 (fst (/2₊ x)) (fst y)
 
 
 
@@ -923,14 +923,14 @@ elimBy≡⊎<' {A = A} s r f' =
  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 
+ data GExpr : Type where
   ge[_] : ℚ → GExpr
   neg-ge_ : GExpr → GExpr
   _+ge_ : GExpr → GExpr → GExpr
@@ -955,7 +955,7 @@ module HLP where
  evGE (x ·ge x₁) = evGE x · evGE x₁
  evGE ge1 = 1
 
- ·mapGE : ∀ ε e → ε · evGE e ≡ evGE (·GE ε e) 
+ ·mapGE : ∀ ε e → ε · evGE e ≡ evGE (·GE ε e)
  ·mapGE ε ge[ x ] = refl
  ·mapGE ε (neg-ge e) = ·Assoc _ _ _ ∙∙
    cong (_· evGE e) (·Comm ε -1) ∙
@@ -997,7 +997,7 @@ module HLP where
     → {𝟚.True (<Dec 0 (evGE rhs))}
      →  0< (evGE (·GE (fst ε) rhs))
  distℚ0<! ε rhs {p} =
-  <→0< _ 
+  <→0< _
    (subst2 _<_ (·mapGE (fst ε) ge[ 0 ] ∙ ·AnnihilR (fst ε))
     (·mapGE (fst ε) rhs)
      (<-o· _ _ (fst ε) (0<ℚ₊ ε) (𝟚.toWitness p)))
@@ -1011,13 +1011,13 @@ open HLP public
  (+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 → 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ℚ : ∀ 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' →
@@ -1047,7 +1047,7 @@ riseQandD p q r =
         ∙∙ (sym (·IdR z*) ∙ cong (z* ·_)
             (eq/ _ ( ℕ₊₁→ℤ c' , c' )
           (ℤ.·Comm _ _)) ) ∙∙
-         congS (SQ.[_]) 
+         congS (SQ.[_])
           (cong₂ _,_
           ((ℤ.·DistPosLMax
                  ((a ℤ.· pos (suc (ℕ₊₁.n c')) ℤ.+ c ℤ.· ℕ₊₁→ℤ a') ℤ.· ℕ₊₁→ℤ b')
@@ -1065,9 +1065,9 @@ riseQandD p q r =
             (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ℚ : ∀ 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' →
@@ -1084,8 +1084,8 @@ riseQandD p q r =
             ∙ ℤ.+DistLMin _ _ _ ) ∙
             ℤ.·DistPosLMin _ _ _ ∙ cong₂ ℤ.min
               (Lems.lem--042 ℤCommRing )
-              (Lems.lem--043 ℤCommRing)     
-   in riseQandD  
+              (Lems.lem--043 ℤCommRing)
+   in riseQandD
          (ℤ.min (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a') ℤ.· ℕ₊₁→ℤ c' ℤ.+
                c ℤ.· ℕ₊₁→ℤ (a' ·₊₁ b')) ( a' ·₊₁ b' ·₊₁ c') c'
             ∙ congS (SQ.[_])
@@ -1106,17 +1106,17 @@ riseQandD p q r =
 
 clampDiff : ∀ L L' x → clamp L L' x ≡
                (x + clamp (L - x) (L' - x) 0)
-clampDiff L L' x = 
+clampDiff L L' x =
      cong₂ min
        (cong₂ max (lem--035 {L} {x})
          (sym $ +IdL x) ∙ sym (+MaxDistrℚ _ _ x))
-       (lem--035 {L'} {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) 
+    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)
@@ -1129,28 +1129,28 @@ clampDist' L L' x y z =
      (+IdR (y - x))
      (≤-o+ ((a' - a)) 0 (y - x)
       (subst (_≤ 0) (-[x-y]≡y-x a a')
-       $ minus-≤ 0 (a - a') (-≤ a' a zz'))  )) 
+       $ 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' : 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' 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') 
+    (absComm- y x)) (clampDist' L L')
 
-maxDist : ∀ M x y → 
-    abs (max M y - max M x) ≤ abs (y - x) 
+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)}
@@ -1166,7 +1166,7 @@ maxDist M x y =
     (clampDist M (max M (max x y)) x y)
 
 
-≤→<⊎≡ : ∀ p q → p ≤ q → (p ≡ q) ⊎ (p < q) 
+≤→<⊎≡ : ∀ p q → p ≤ q → (p ≡ q) ⊎ (p < q)
 ≤→<⊎≡ p q x with p ≟ q
 ... | lt x₁ = inr x₁
 ... | eq x₁ = inl x₁
@@ -1174,7 +1174,7 @@ maxDist M x y =
 
 
 getPosRatio : (L₁ L₂ : ℚ₊) → (fst ((invℚ₊ L₁) ℚ₊·  L₂) ≤ 1)
-                           ⊎ (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)
@@ -1191,7 +1191,7 @@ getPosRatio L₁ L₂ =
      (fst L₁) (fst L₂) (snd L₁) (snd L₂)
 
 
-·MaxDistrℚ : ∀ x y z → 0< z → (max x y) · z ≡ max (x · z) (y · z)   
+·MaxDistrℚ : ∀ x y z → 0< z → (max x y) · z ≡ max (x · z) (y · z)
 ·MaxDistrℚ = SQ.elimProp3 (λ _ _ _ → isPropΠ λ _ → isSetℚ _ _)
   www
 
@@ -1204,15 +1204,15 @@ getPosRatio L₁ L₂ =
     wwww
   where
 
-   wwww' : ∀ a b' →  a ℤ.· ℕ₊₁→ℤ b' ℤ.· pos (suc n) ℤ.· pos (ℕ₊₁→ℕ c') 
+   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'))
@@ -1229,7 +1229,7 @@ getPosRatio L₁ L₂ =
          (ℤ.·DistPosLMax (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a') (suc n))
          ∙ ℤ.·DistPosLMax
               ((a ℤ.· ℕ₊₁→ℤ b') ℤ.· pos (suc n))
-              ((b ℤ.· ℕ₊₁→ℤ a') ℤ.· pos (suc n)) (ℕ₊₁→ℕ c') 
+              ((b ℤ.· ℕ₊₁→ℤ a') ℤ.· pos (suc n)) (ℕ₊₁→ℕ c')
           ∙ cong₂ ℤ.max
           (wwww' a b') (wwww' b a'))
            (cong ℕ₊₁→ℤ (·₊₁-assoc a' b' c'))
@@ -1245,7 +1245,7 @@ getPosRatio L₁ L₂ =
    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') 
+   (≤-o· y y' x' (isTrans≤ 0 _ _ 0≤x x≤x') y≤y')
 
 <Monotone·-onPos : ∀ x x' y y' →
   x < x' →
@@ -1268,7 +1268,7 @@ getPosRatio L₁ L₂ =
 
 
 
-invℚ : ∀ q → 0 # q → ℚ  
+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)
@@ -1277,7 +1277,7 @@ invℚ₊≡invℚ q p = cong₂ _·_ (fst (<→sign (fst q)) (0<ℚ₊ q)
      absPos (fst q) ((0<ℚ₊ q))))) ∙ ·IdL (fst (invℚ₊ q))
 
 
-invℚ-pos : ∀ x y → 0 < x → 0 < invℚ x y 
+invℚ-pos : ∀ x y → 0 < x → 0 < invℚ x y
 invℚ-pos x y z =
   subst (0 <_)
     (sym (invℚ₊≡invℚ (x , <→0< _ z) y))
@@ -1299,14 +1299,14 @@ invℚ-pos x y z =
       (·Assoc _ _ _
        ∙∙ cong (_· fst (invℚ₊ (0#→ℚ₊ y 0#y)))
          (·Comm _ _) ∙∙
-       sym (·Assoc _ _ _)) 
+       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 0#q → sign q ≡ (invℚ (sign q) 0#q)
 invℚ-sign q =
   ⊎.rec (λ p → p ∙ cong (uncurry invℚ)
     (Σ≡Prop  (λ _ → isProp# _ _)
@@ -1316,19 +1316,19 @@ invℚ-sign q =
      {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)) ))) 
+    (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  → ℚ 
+_／ℚ[_,_] : ℚ → ∀ r → 0 # r  → ℚ
 q ／ℚ[ r , 0＃r ] = q · (invℚ r 0＃r)
 
 
@@ -1342,23 +1342,23 @@ q ／ℚ[ r , 0＃r ] = q · (invℚ r 0＃r)
    ∙ 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 _ _ _) ∙∙ 
+ℚ-[x·y]/y x r 0#r = sym (·Assoc _ _ _) ∙∙
   cong (x ·_) (ℚ-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 
+    sym (ℚ-[x·y]/y x r 0＃r ) ∙ cong (_／ℚ[ r , 0＃r ]) p
 
 
-invℚ≤invℚ : ∀ (p q : ℚ₊) → fst q ≤ fst p → fst (invℚ₊ p) ≤ fst (invℚ₊ q) 
-invℚ≤invℚ p q x = 
+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) 
+     (0≤ℚ₊ ((invℚ₊ p) ℚ₊· (invℚ₊ q))) x)
 
 maxWithPos : ℚ₊ → ℚ → ℚ₊
 maxWithPos ε q .fst = max (fst ε) q
@@ -1368,7 +1368,7 @@ maxWithPos ε q .snd = <→0< (max (fst ε) q)
 
 1/p+1/q : (p q : ℚ₊) → fst (invℚ₊ p) - fst (invℚ₊ q) ≡
                        fst (invℚ₊ (p ℚ₊· q))
-                        · (fst q - fst p)  
+                        · (fst q - fst p)
 1/p+1/q (p , p') (q , q') =
   ElimProp2.go w p q p' q'
  where
@@ -1401,12 +1401,12 @@ maxWithPos ε q .snd = <→0< (max (fst ε) q)
                  ∙ ℤ.·Comm _ _) ∙ cong ((ℕ₊₁→ℤ
                (fst (ℤ.0<→ℕ₊₁ (ℕ₊₁→ℤ ((1+ x') ·₊₁ (1+ y'))) tt))
             ℤ.· ((pos (suc y) ℤ.· ℕ₊₁→ℤ ((1+ x')))
-                 ℤ.+ (ℤ.- (ℤ.pos (suc x) ℤ.· ℕ₊₁→ℤ (1+ y'))))) 
+                 ℤ.+ (ℤ.- (ℤ.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)))) 
+                 ℤ.+ (ℤ.negsuc·pos x (suc y') (~ i))))
           ℤ.· ℕ₊₁→ℤ ((1+ x) ·₊₁ (·₊₁-identityˡ (1+ y) (~ i))))
 
 invℚ₊≤invℚ₊ : ∀ x y
@@ -1433,13 +1433,13 @@ invℚ₊≤invℚ₊ x y p =
   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)) 
+     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 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)
@@ -1447,7 +1447,7 @@ invℚ₊≤invℚ₊ x y p =
 
 _ℚ^ⁿ_ : ℚ → ℕ → ℚ
 x ℚ^ⁿ zero = 1
-x ℚ^ⁿ suc n = (x ℚ^ⁿ n) · x 
+x ℚ^ⁿ suc n = (x ℚ^ⁿ n) · x
 
 0<ℚ^ⁿ : ∀ q (0<q : 0< q) n → 0< (q ℚ^ⁿ n)
 0<ℚ^ⁿ q 0<q zero = tt
@@ -1463,7 +1463,7 @@ x ℚ^ⁿ suc n = (x ℚ^ⁿ n) · x
 
 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 = 
+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
 
@@ -1484,7 +1484,7 @@ 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 n → fst (invℚ₊ (q ℚ₊^ⁿ n)) ≡ (fst (invℚ₊ q)) ℚ^ⁿ n
 invℚ₊-ℚ^ⁿ q zero = refl
 invℚ₊-ℚ^ⁿ q (suc n) =
   cong fst (sym (invℚ₊Dist· _ _))
@@ -1493,7 +1493,7 @@ invℚ₊-ℚ^ⁿ q (suc n) =
 
 
 invℚ₊-<-invℚ₊ : ∀ q r → ((fst q) < (fst r))
-             ≃ (fst (invℚ₊ r) < fst (invℚ₊ q)) 
+             ≃ (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) ≃
diff --git a/Cubical/Data/Rationals/Properties.agda b/Cubical/Data/Rationals/Properties.agda
index bb4fa75e39..66cf5e0c55 100644
--- a/Cubical/Data/Rationals/Properties.agda
+++ b/Cubical/Data/Rationals/Properties.agda
@@ -112,7 +112,7 @@ record OnCommonDenomSym : Type where
   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 ] 
+  w .SetQuotient.ElimProp2.f (a , b) (c , d) i = [ g-sym (a , b) (c , d) i / ·₊₁-comm b d i ]
 
 
 -- basic arithmetic operations on ℚ
@@ -138,7 +138,7 @@ minR .OnCommonDenomSym.g-sym (a , b) (c , d) = ℤ.minComm (a ℤ.· ℕ₊₁
 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)
@@ -177,7 +177,7 @@ maxR .OnCommonDenomSym.g (a , b) (c , d) = ℤ.max (a ℤ.· ℕ₊₁→ℤ d)
 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)
@@ -212,7 +212,7 @@ maxR .OnCommonDenomSym.g-eql = eq
 
 max = OnCommonDenomSym.go maxR
 
-   
+
 minComm : ∀ x y → min x y ≡ min y x
 minComm = OnCommonDenomSym.go-comm minR
 
@@ -371,7 +371,7 @@ maxAbsorbLMin = SetQuotient.elimProp2 (λ _ _ → isSetℚ _ _)
 
 _+_ : ℚ → ℚ → ℚ
 _+_ = OnCommonDenomSym.go +Rec
-   
+
 +Comm : ∀ x y → x + y ≡ y + x
 +Comm = OnCommonDenomSym.go-comm +Rec
 
diff --git a/Cubical/Foundations/HLevels.agda b/Cubical/Foundations/HLevels.agda
index 86ba7dba82..523b385abb 100644
--- a/Cubical/Foundations/HLevels.agda
+++ b/Cubical/Foundations/HLevels.agda
@@ -873,7 +873,7 @@ lem722 : {A : Type ℓ} (R : A → A → Type ℓ')
   → 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))) 
+          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 →
diff --git a/Cubical/HITs/CauchyReals/Base.agda b/Cubical/HITs/CauchyReals/Base.agda
index a664c259c4..93b5ecbf77 100644
--- a/Cubical/HITs/CauchyReals/Base.agda
+++ b/Cubical/HITs/CauchyReals/Base.agda
@@ -32,7 +32,7 @@ open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary
 
 open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
 
 open import Cubical.Data.Rationals as ℚ
 open import Cubical.Data.Rationals.Order as ℚ
@@ -53,9 +53,9 @@ private
 
 -- HoTT Definition 11.3.2.
 
-data ℝ : Type 
- 
-data _∼[_]_  : ℝ → ℚ₊ → ℝ → Type 
+data ℝ : Type
+
+data _∼[_]_  : ℝ → ℚ₊ → ℝ → Type
 
 data ℝ where
  rat : ℚ → ℝ
@@ -65,7 +65,7 @@ data ℝ where
  -- HoTT (11.3.4)
  eqℝ : ∀ x y → (∀ ε → x ∼[ ε ] y) → x ≡ y
 
-data _∼[_]_   where 
+data _∼[_]_   where
  rat-rat : ∀ q r ε
    → (ℚ.- fst ε) ℚ.< (q ℚ.- r)
    → (q ℚ.- r) ℚ.< fst ε → (rat q) ∼[ ε ] (rat r)
@@ -114,7 +114,7 @@ instance
 
 
 record Elimℝ {ℓ} {ℓ'} (A : ℝ → Type ℓ)
-               (B : ∀ {x y : ℝ} → 
+               (B : ∀ {x y : ℝ} →
                   A x → A y →
                 ∀ ε → x ∼[ ε ] y → Type ℓ') : Type (ℓ-max ℓ ℓ') where
  field
@@ -124,30 +124,30 @@ record Elimℝ {ℓ} {ℓ'} (A : ℝ → Type ℓ)
              (∀ δ ε → 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' 
+   → 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) (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'' 
+  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     
+         B (go x) (go x') ε r
 
  go (rat x) = ratA x
  go (lim x x₁) = limA x x₁ (λ q → go (x q))
-   λ _ _ → go∼ _  
+   λ _ _ → go∼ _
  go (eqℝ x x₁ x₂ i) =
    eqA x₂ (go x) (go x₁) (λ _ _ → go∼  _)
       (λ ε → go∼ (x₂ ε)) i
@@ -160,7 +160,7 @@ record Elimℝ {ℓ} {ℓ'} (A : ℝ → Type ℓ)
  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) = 
+ go∼ (lim-lim x y ε δ η p p' v r) =
    lim-lim-B x y ε δ η p p' v r
     (λ q → go (x q))
        (λ _ _ → go∼ (p _ _))
@@ -195,12 +195,12 @@ 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-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
@@ -211,7 +211,7 @@ record Elimℝ-Prop2 {ℓ} (A : ℝ → ℝ → Type ℓ) : Type ℓ 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.isPropA _ = isPropA _ _
   w .Elimℝ-Prop.limA x p x₁ = Elimℝ-Prop.go w'
    where
    w' : Elimℝ-Prop _
@@ -250,15 +250,15 @@ record Recℝ {ℓ} {ℓ'} (A : Type ℓ)
   ratA : ℚ → A
   limA : (a : ℚ₊ → A) →
              (∀ δ ε → B (a δ) (a ε) (δ ℚ₊+ ε)) → A
-  eqA : ∀ a a' → (∀ ε → B a 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) ε 
+       (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) ε
@@ -289,13 +289,13 @@ record Recℝ {ℓ} {ℓ'} (A : Type ℓ)
 
  go~ = Elimℝ.go∼ d
 
-subst∼ : ∀ {u v ε ε'} → fst ε ≡ fst ε' → u ∼[ ε ] v → u ∼[ ε' ] v  
+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 
+               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
@@ -303,7 +303,7 @@ record Casesℝ {ℓ} {ℓ'} (A : Type ℓ)
   ratA : ℚ → A
   limA : (x : ℚ₊ → ℝ) →
              ((δ ε : ℚ₊) → x δ ∼[ δ ℚ₊+ ε ] x ε) → A
-  eqA : ∀ a a' → (∀ ε → B a a' ε) → a ≡ a' 
+  eqA : ∀ a a' → (∀ ε → B a a' ε) → a ≡ a'
 
   rat-rat-B : (q r : ℚ) (ε : ℚ₊) (x : (ℚ.- fst ε) ℚ.< (q ℚ.- r))
       (x₁ : (q ℚ.- r) ℚ.< fst ε) →
@@ -332,14 +332,14 @@ record Casesℝ {ℓ} {ℓ'} (A : Type ℓ)
  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ℝ.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') ε
diff --git a/Cubical/HITs/CauchyReals/Closeness.agda b/Cubical/HITs/CauchyReals/Closeness.agda
index 3fd47f4e73..c8f2c8898e 100644
--- a/Cubical/HITs/CauchyReals/Closeness.agda
+++ b/Cubical/HITs/CauchyReals/Closeness.agda
@@ -32,7 +32,7 @@ open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary
 
 open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
 
 open import Cubical.Data.Rationals as ℚ
 open import Cubical.Data.Rationals.Order as ℚ
@@ -62,7 +62,7 @@ refl∼ = Elimℝ-Prop.go w
        (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 _ ε = 
+ w .Elimℝ-Prop.limA x p _ ε =
   let e1 = /2₊ (/2₊ ε)
       zz = +CancelL- (fst (/2₊ ε)) (fst (/2₊ ε)) (fst ε)
             (ε/2+ε/2≡ε (fst ε))
@@ -77,7 +77,7 @@ refl∼ = Elimℝ-Prop.go w
 
 
 -- HoTT Lemma (11.3.12)
-sym∼ : ∀ r r' ε → r ∼[ ε ] r' → r' ∼[ ε ] r  
+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₁))
@@ -105,13 +105,13 @@ isSetℝ = lem722 (λ r r' → ∀ ε →  r ∼[ ε ] r')
    eqℝ
    refl∼
 
-∼≃≡ : ∀ r r' → (∀ ε → r ∼[ ε ] r') ≃  (r ≡ r') 
+∼≃≡ : ∀ 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 ε 
-    
+≡→∼ {ε} {r} {r'} p = invEq (∼≃≡ r r') p ε
+
 
 
 
@@ -121,7 +121,7 @@ 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 → ⟨ 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))
@@ -143,8 +143,8 @@ lim-lim' ε a =
       Σ< (fst ∘ a δ η) ((fst ε) ℚ.- (fst δ ℚ.+ fst η)) ) , squash₁
 
 
-w-prop' : (ℚ₊ → hProp ℓ-zero) → Type 
-w-prop' = λ △ → ∀ ε → ⟨ 
+w-prop' : (ℚ₊ → hProp ℓ-zero) → Type
+w-prop' = λ △ → ∀ ε → ⟨
                ( △ ε ) L.⇔ (L.∃[ θ ∶ ℚ₊ ]
                   (L.∃[ v ] (△ (((fst ε) ℚ.- (fst θ)) , v)))) ⟩
 
@@ -160,23 +160,23 @@ pre-w-rel' : Σ (ℚ₊ → hProp ℓ-zero) w-prop' →
 w-rel'  : Σ (ℚ₊ → hProp ℓ-zero) w-prop' →
            Σ (ℚ₊ → hProp ℓ-zero) w-prop' → ℚ₊ → Type
 
-pre-w-rel' = λ (△ , _) (◻ , _) ε η 
+pre-w-rel' = λ (△ , _) (◻ , _) ε η
        → (⟨ △ η ⟩ →  ⟨ ◻ (ε ℚ₊+ η) ⟩)
 
 
 w-rel' = λ △ ◻ ε →
-     ∀ η → pre-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 ε ⟩  
+          → ⟨ fst x ε ⟩ → ⟨ fst y ε ⟩
 w-rel'⇒ x y x₁ ε x₂ =
  let z = fst (snd x ε) x₂
      z' = PT.map (λ (δ , xx) →
-              /2₊ δ , PT.map 
+              /2₊ δ , PT.map
                   (λ (xxx , xxx') →
                     substΣ< y
                       (cong (λ zz → fst (/2₊ δ) ℚ.+ (fst ε ℚ.- zz))
@@ -215,14 +215,14 @@ r-r q r .snd ε .snd =
 r-l : (a : ℚ₊ → Σ _ w-prop')
 
         → Σ _ w-prop'
-r-l a .fst ε = rat-lim' ε (fst ∘ a) 
+r-l a .fst ε = rat-lim' ε (fst ∘ a)
 r-l a .snd ε .fst =
-  PT.rec 
+  PT.rec
       squash₁
        λ (q' , v , pp) →
-          let aa = fst ((snd (a q')) ((fst ε ℚ.- fst q') , v)) pp  
+          let aa = fst ((snd (a q')) ((fst ε ℚ.- fst q') , v)) pp
           in PT.map
-              (map-snd λ {a''} → 
+              (map-snd λ {a''} →
                (PT.map
                 λ x₂ →
                   strength-lem-01 ε q' a'' (fst x₂) ,
@@ -237,7 +237,7 @@ r-l a .snd ε .fst =
               aa
 
 r-l a .snd ε .snd =
-       PT.rec 
+       PT.rec
       squash₁
         (uncurry λ q' →
            PT.rec squash₁ (uncurry λ v →
@@ -252,7 +252,7 @@ r-l a .snd ε .snd =
                       ∙∙ cong (fst ε ℚ.+_)
                             (ℚ.+Comm (ℚ.- (fst q')) (ℚ.- (fst q'')))
                       ∙∙ (ℚ.+Assoc (fst ε) (ℚ.- (fst q'')) (ℚ.- (fst q')))))
-                         zz ∣₁ ∣₁ 
+                         zz ∣₁ ∣₁
                 in q'' , _ , zzz))
 
 
@@ -269,7 +269,7 @@ l-l 𝕒 .snd ε .fst =
             subst (Σ< (fst ∘ (fst (𝕒 δ η))))
               (+AssocCommR (fst ε) (ℚ.- (fst δ ℚ.+ fst η))
                 (ℚ.- fst q'))
-                (x , x') 
+                (x , x')
             ∣₁ )))
               (fst (snd (𝕒 δ η) _) y))
 l-l 𝕒 .snd ε .snd =
@@ -277,7 +277,7 @@ l-l 𝕒 .snd ε .snd =
      (uncurry λ q' →
        PT.rec squash₁ (uncurry λ v →
          PT.map (map-snd
-           λ {(δ , η)} (x , x') → strength-lem-01 ε q' (δ ℚ₊+ η) x , 
+           λ {(δ , η)} (x , x') → strength-lem-01 ε q' (δ ℚ₊+ η) x ,
             (snd (snd (𝕒 δ η) _) ∣ q' , ∣
               subst (Σ< (fst ∘ (fst (𝕒 δ η))))
                (sym ((+AssocCommR (fst ε) (ℚ.- (fst δ ℚ.+ fst η))
@@ -332,7 +332,7 @@ rel-r-l 𝕢 q y ε p δ v₁ x η .fst xx' =
 rel-r-l 𝕢 q y ε p δ v₁ x η .snd =
    PT.rec (snd (rat-rat' 𝕢 (ε ℚ₊+ η) q))
     λ (σ* , (xx , xx')) →
-      let z = fst (p _ _ _) xx' 
+      let z = fst (p _ _ _) xx'
           z' = snd (x _) z
       in subst
               {x = (((fst ε ℚ.- fst δ) , v₁) ℚ₊+
@@ -350,9 +350,9 @@ rel-l-l' : (x y : ℚ₊ → Σ (ℚ₊ → hProp ℓ-zero) w-prop') (ε δ η :
      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 η , 
+       let zz = fst (p a δ _) xx'
+           zz' = x₁ _ zz
+       in η ,
             subst (ℚ.0<_)
                 (lem-02  (fst ε) (fst δ) (fst η) (fst η'))
                   (+0< (fst ε ℚ.- (fst δ ℚ.+ fst η))
@@ -387,7 +387,7 @@ rel-l-l x y ε δ η p p' v₁ x₁ η₁ =
      in rel-l-l' y x ε η δ  p' p (fst zz) η₁ (snd zz)
 
 w-prop : (ℚ₊ → ℝ → hProp ℓ-zero) → Type
-w-prop = 
+w-prop =
  λ ♢ → (∀ u ε → ⟨ (♢ ε u)  L.⇔ (L.∃[ θ ∶ ℚ₊ ]
                      L.∃[ v ] ♢ (((fst ε) ℚ.- (fst θ)) , v) u)
                     ⟩ ) ×
@@ -444,7 +444,7 @@ rel-l-l-l : ∀ {𝕒 : ℚ₊ → Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop
               (v₁ : 0< (fst ε ℚ.- (fst δ ℚ.+ fst η)))
               (r : x δ ∼[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v₁ ] y η)
 
-    → 
+    →
               w-rel'
      (l-l
       (λ q η₁ → (λ ε₁ → fst (𝕒 q) ε₁ (x η₁)) , fst (snd (𝕒 q)) (x η₁)))
@@ -455,8 +455,8 @@ 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 η*)) 
+         z' = snd (snd (𝕒 δ*)) _ _ _ _ r z
+     in (δ* , η) , (+₃0<' (fst η₁ ℚ.- (fst δ* ℚ.+ fst η*))
                    (fst ε ℚ.- (fst δ ℚ.+ fst η))
                     (fst δ ℚ.+ fst η*)
                    (fst (ε ℚ₊+ η₁) ℚ.- (fst δ* ℚ.+ fst η))
@@ -465,14 +465,14 @@ rel-l-l-l {𝕒} x y ε δ η p p' v₁ r η₁ .fst =
             subst (λ xx → ⟨ 𝕒 δ* .fst xx (y η)⟩)
               (ℚ₊≡ (lem-03 (fst ε) (fst η₁)
                  (fst δ) (fst η) (fst δ*) (fst η*)))
-                 z') 
+                 z')
 rel-l-l-l {𝕒}  x y ε δ η p p' v₁ r  η₁ .snd =
-  PT.map λ ((δ* , η*) , (xx , xx')) → 
+  PT.map λ ((δ* , η*) , (xx , xx')) →
      let z = snd (snd (𝕒 δ*)) (y η*) _ _ _ (p' _ η) xx'
          z' = snd (snd (𝕒 δ*)) _ _ _ _ (sym∼ _ _ _ r) z
 
      in (δ* , δ) , (
-            +₃0<' (fst η₁ ℚ.- (fst δ* ℚ.+ fst η*)) 
+            +₃0<' (fst η₁ ℚ.- (fst δ* ℚ.+ fst η*))
                    (fst ε ℚ.- (fst δ ℚ.+ fst η))
                     (fst η ℚ.+ fst η*)
                    (fst (ε ℚ₊+ η₁) ℚ.- (fst δ* ℚ.+ fst δ))
@@ -497,10 +497,10 @@ module ∼' where
       (w-rel'-sym (x δ) (r-r 𝕢 r) ((fst ε ℚ.- fst δ) , v₁) x₁))
 
  w' 𝕢 .Recℝ.lim-lim-B = rel-l-l
- w' 𝕢 .Recℝ.isPropB a a' ε = 
+ w' 𝕢 .Recℝ.isPropB a a' ε =
   isPropΠ λ x →
      isProp× (isProp→ (snd (a' .fst (ε ℚ₊+ x))))
-             (isProp→ (snd (a .fst (ε ℚ₊+ x))))          
+             (isProp→ (snd (a .fst (ε ℚ₊+ x))))
 
 
 
@@ -526,7 +526,7 @@ module ∼' where
      (uncurry λ q' →
       λ (xx , xx') →
        let z = snd (snd (𝕒 q')) _ _ _ _
-               (rat-rat q r ε x x₁) xx'  
+               (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 =
@@ -534,7 +534,7 @@ module ∼' where
      (uncurry λ q' →
       λ (xx , xx') →
        let z = snd (snd (𝕒 q')) _ _ _ _
-               (sym∼ _ _ ε (rat-rat q r ε x x₁)) xx'  
+               (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 =
@@ -562,11 +562,11 @@ module ∼' where
       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' ε = 
+ 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))))          
+             (isProp→ (snd (a .fst (ε ℚ₊+ x))))
 
  isPropHlp : {P  Q  : ℝ → ℚ₊ →  Type} (P' Q' : ℝ → ℚ₊ →  hProp ℓ-zero) →
          (x₂ : ℝ) → isProp ((η₂ : ℚ₊) →
@@ -596,7 +596,7 @@ module ∼' where
       ∘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 
+      rat-rat'-sym r η x
   www .Elimℝ-Prop.limA x p x₁ η =
        PT.map (λ (δ* , (xx , xx'))
          → δ* , substΣ< (Elimℝ.go (Recℝ.d (w' r)) (x δ*))
@@ -628,7 +628,7 @@ module ∼' where
             {y = (ε ℚ₊+ η)} (fst ∘ fst (Recℝ.go (w' q) (rat x*)))
              (ℚ₊≡ (lem--023 {fst ε} {fst δ} {fst δ*} {fst η})) zz'
 
-  www .Elimℝ-Prop.limA x* p* x₁* η* .fst = 
+  www .Elimℝ-Prop.limA x* p* x₁* η* .fst =
     PT.map λ (δ* , (xx , xx')) →
        let z = fst (x (x* δ*) (_ , xx)) xx'
 
@@ -643,7 +643,7 @@ module ∼' where
 
   www .Elimℝ-Prop.isPropA = isPropHlp
       (λ x η → fst (Casesℝ.go (w'' y p) x) (ε ℚ₊+ η))
-      λ x η → fst (Recℝ.go (w' q) x) (ε ℚ₊+ η) 
+      λ x η → fst (Recℝ.go (w' q) x) (ε ℚ₊+ η)
 
  w .Recℝ.lim-rat-B x r ε δ p v₁ x₁  = Elimℝ-Prop.go www
   where
@@ -653,7 +653,7 @@ module ∼' where
       λ (δ* , (xx , xx')) →
        let zz = snd (p δ _ (rat x') _) xx'
            zz' = fst (x₁ (rat x') _) zz
-       in subst 
+       in subst
             {x = (((fst ε ℚ.- fst δ) , v₁) ℚ₊+
              ((δ ℚ₊+ δ*) ℚ₊+ ((fst η' ℚ.- fst δ*) , xx)))}
              {(ε ℚ₊+ η')}
@@ -677,20 +677,20 @@ module ∼' where
           (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₂) (ε ℚ₊+ η) 
+      λ 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'   
+     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'   
+     let z = fst ((p' _ _) _ _) xx'
          z' = snd (x₁ _ _) z
      in δ , substΣ<' (x δ) _
          (lem--031 {fst ε} {fst δ} {fst η} {δ*}  {fst η'} ) (_ , z')
@@ -703,7 +703,7 @@ module ∼' where
                 ((δ* ℚ₊+ δ) ℚ₊+ ((fst η₁ ℚ.- (fst δ* ℚ.+ fst η*)) , xx)))
                (x* η*))
        z' = fst (x₁ _ _) z
-   in (η , η*) , 
+   in (η , η*) ,
           substΣ<' (y η) _
         (lem--032 {fst ε} {fst δ} {fst η} {fst δ*}  {fst η₁} {fst η*})
            (_ , z')
@@ -720,7 +720,7 @@ module ∼' where
 
  w .Recℝ.isPropB a a' ε = isPropΠ2 λ u x →
      isProp× (isProp→ (snd (a' .fst (ε ℚ₊+ x) u)))
-             (isProp→ (snd (a .fst (ε ℚ₊+ x) u)))          
+             (isProp→ (snd (a .fst (ε ℚ₊+ x) u)))
 
 
  -- pre-~' : ℝ → Σ (ℚ₊ → ℝ → (hProp ℓ-zero)) _
@@ -730,10 +730,10 @@ module ∼' where
 -- HoTT Theorem (11.3.16)
 
 _∼'[_]_ : ℝ → ℚ₊ → ℝ → Type
-x ∼'[ ε ] y = ⟨ fst (Recℝ.go ∼'.w x) ε y ⟩  
+x ∼'[ ε ] y = ⟨ fst (Recℝ.go ∼'.w x) ε y ⟩
 
 _∼'[_]ₚ_ : ℝ → ℚ₊ → ℝ → hProp ℓ-zero
-x ∼'[ ε ]ₚ y = fst (Recℝ.go ∼'.w x) ε y  
+x ∼'[ ε ]ₚ y = fst (Recℝ.go ∼'.w x) ε y
 
 
 -- (11.3.17)
@@ -744,26 +744,26 @@ _ = λ r r' ε → refl
 
 -- (11.3.18)
 _ : ∀ r x y ε → (rat r) ∼'[ ε ] (lim x y) ≡
-              (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ] ((rat r) ∼'[ (fst ε ℚ.- fst δ) , v ] x δ)) 
+              (∃[ δ ∈ ℚ₊ ] Σ[ 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 )) 
+                ((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 δ) ∼'[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v ] (x' η) ))
 _ = λ x y x' y' ε → refl
 
 -- (11.3.23)
 triangle∼' : ∀ u v w ε η
-      → u ∼[ ε ] v  
+      → u ∼[ ε ] v
       → v ∼'[ η ] w
-      → u ∼'[ ε ℚ₊+ η ] w  
+      → u ∼'[ ε ℚ₊+ η ] w
 triangle∼' u v w ε η x =
   snd ((Recℝ.go~ ∼'.w {x = u} {v} {ε} x w η ))
 
@@ -772,11 +772,11 @@ triangle∼' u v w ε η x =
 rounded∼' : ∀ u v ε →
              ⟨ (u ∼'[ ε ]ₚ v) L.⇔
               (L.∃[ δ ]
-                L.∃[ _ ] u ∼'[ (fst ε ℚ.- fst δ) , _ ]ₚ v) ⟩ 
-rounded∼' u v ε = fst (snd (Recℝ.go ∼'.w u)) v ε 
+                L.∃[ _ ] u ∼'[ (fst ε ℚ.- fst δ) , _ ]ₚ v) ⟩
+rounded∼' u v ε = fst (snd (Recℝ.go ∼'.w u)) v ε
 
 
-∼→∼' : ∀ x y ε → x ∼[ ε ] y → x ∼'[ ε ] y     
+∼→∼' : ∀ 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₁ ∣₁
@@ -787,7 +787,7 @@ rounded∼' u v ε = fst (snd (Recℝ.go ∼'.w u)) v ε
 ∼→∼' x y ε (isProp∼ .x .ε .y x₁ x₂ i) =
   snd (x ∼'[ ε ]ₚ y) (∼→∼' x y ε x₁) (∼→∼' x y ε x₂) i
 
-∼'→∼ : ∀ x y ε → x ∼'[ ε ] y → x ∼[ ε ] y     
+∼'→∼ : ∀ x y ε → x ∼'[ ε ] y → x ∼[ ε ] y
 ∼'→∼ = Elimℝ-Prop2.go w
  where
  w : Elimℝ-Prop2 _
@@ -795,19 +795,19 @@ rounded∼' u v ε = fst (snd (Recℝ.go ∼'.w u)) v ε
    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') 
+      λ (δ , (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') 
+      λ (δ , (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∼ _ _ _ 
+        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' → r' ∼'[ ε ] r
 sym∼' r r' ε =
   ∼→∼' r' r ε ∘S sym∼ r r' ε ∘S ∼'→∼ r r' ε
 
@@ -815,15 +815,15 @@ sym∼' r r' ε =
 
 -- (11.3.22)
 triangle∼'' : ∀ u v w ε η
-      → u ∼'[ ε ] v  
+      → u ∼'[ ε ] v
       → v ∼[ η ] w
-      → u ∼'[ ε ℚ₊+ η ] 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 ε → ⟨ x ∼'[ ε ]ₚ y L.⇔ x ∼[ ε ]ₚ y ⟩
 ∼'⇔∼ x y z = ∼'→∼ x y z , ∼→∼' x y z
 
 
@@ -846,8 +846,8 @@ sym⇔ (x , y) = y , x
 rounded∼ : ∀ u v ε →
              ⟨ (u ∼[ ε ]ₚ v) L.⇔
               (L.∃[ δ ]
-                L.∃[ p ] u ∼[ (fst ε ℚ.- fst δ) , p ]ₚ v) ⟩ 
-rounded∼ u v ε = sym⇔ 
+                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 _))))))
@@ -855,26 +855,26 @@ rounded∼ u v ε = sym⇔
 -- HoTT (11.3.36)
 
 triangle∼ : ∀ {u v w ε η}
-      → u ∼[ ε ] v  
+      → u ∼[ ε ] v
       → v ∼[ η ] w
       → u ∼[ ε ℚ₊+ η ] w
 triangle∼ {u} {v} {w} {ε} {η} x  =
-  ∼'→∼ u w (ε ℚ₊+ η) ∘ triangle∼' u v w ε η x ∘ ∼→∼' v w _ 
+  ∼'→∼ u w (ε ℚ₊+ η) ∘ triangle∼' u v w ε η x ∘ ∼→∼' v w _
 
 
 
 -- _ : ∀ r x y ε → (rat r) ∼'[ ε ] (lim x y) ≡
---               (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ] ((rat r) ∼'[ (fst ε ℚ.- fst δ) , v ] x δ)) 
+--               (∃[ δ ∈ ℚ₊ ] Σ[ 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 )) 
+--                 ((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 δ) ∼'[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v ] (x' η) ))
 -- _ = λ x y x' y' ε → refl
 
diff --git a/Cubical/HITs/CauchyReals/Continuous.agda b/Cubical/HITs/CauchyReals/Continuous.agda
index 280bc2bb1f..d9dba5df19 100644
--- a/Cubical/HITs/CauchyReals/Continuous.agda
+++ b/Cubical/HITs/CauchyReals/Continuous.agda
@@ -35,7 +35,7 @@ open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary
 
 open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
 
 open import Cubical.Data.Rationals using (ℚ ; [_/_])
 open import Cubical.Data.Rationals.Order using
@@ -90,7 +90,7 @@ open import Cubical.HITs.CauchyReals.Order
  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)) 
+     λ q → x₁ _ ∙ cong x (ℚ₊≡ (λ i → ℚ.·IdL (ℚ.·IdL (fst q) i) i))
  w .Elimℝ-Prop.isPropA x = isSetℝ (-ᵣ (-ᵣ x)) x
 
 
@@ -106,11 +106,11 @@ open import Cubical.HITs.CauchyReals.Order
     ∙  (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₁ =  
+
+ 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')) ∙ 
+      (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))
@@ -144,7 +144,7 @@ open import Cubical.HITs.CauchyReals.Order
 
 
 -[x-y]≡y-x : ∀ x y → -ᵣ ( x +ᵣ (-ᵣ y) ) ≡ y +ᵣ (-ᵣ x)
--[x-y]≡y-x x y = 
+-[x-y]≡y-x x y =
      -ᵣDistr x (-ᵣ y)
      ∙ λ i → +ᵣComm (-ᵣ x) (-ᵣInvol y i) i
 
@@ -165,7 +165,7 @@ denseℚinℝ u v =
                 , (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 ℚ.+_)
@@ -198,10 +198,10 @@ denseℚinℝ u v =
                             (cong₂ ℚ._+_
                               distℚ! u ·[
                                (ge1 +ge ((neg-ge ge1) ·ge
-                                        ge[ [ pos 3 / 1+ 3 ] ]))  
+                                        ge[ [ pos 3 / 1+ 3 ] ]))
                                      ≡ (neg-ge ((neg-ge ge1) ·ge
                                         ge[ [ pos 1 / 1+ 3 ] ]))   ]
-                             distℚ! v ·[ (( ge[ [ pos 3 / 1+ 3 ] ]))  
+                             distℚ! v ·[ (( ge[ [ pos 3 / 1+ 3 ] ]))
                                      ≡ (ge1 +ge neg-ge (
                                         ge[ [ pos 1 / 1+ 3 ] ]))   ])
                             ∙∙ (ℚ.+Comm _ _ ∙ sym (ℚ.+Assoc v
@@ -220,7 +220,7 @@ denseℚinℝ u v =
                                   )) , (
                    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'')) ∣₁  
+                       (ℚ.-ℚ₊<0 (ℚ.<→ℚ₊ u v z' ℚ₊· ([ pos 1 / 1+ 3 ] , _)))) , z'')) ∣₁
 
 
 
@@ -230,12 +230,12 @@ denseℚinℝ u v =
 
 
 ∼→≤ : ∀ u q → u ≤ᵣ (rat q) → ∀ v ε → u ∼'[ ε ] v → v ≤ᵣ rat (q ℚ.+ fst ε)
-∼→≤ u q u≤q v ε u∼v = 
+∼→≤ 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) 
+     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
@@ -263,7 +263,7 @@ denseℚinℝ u v =
                   xx'* = xx'
 
                   yy : (δ : ℚ₊) → fst δ ℚ.< fst θ →
-                          rat r ∼[ ε ] x δ  
+                          rat r ∼[ ε ] x δ
                   yy δ δ<θ =
                     let z = triangle∼ {rat r}
                               {x η} {x δ}
@@ -281,7 +281,7 @@ denseℚinℝ u v =
                                             (fst θ) (fst η)
                                             δ<θ)) uu
                     in subst∼ lem--054 z
-                  
+
               in sym (eqℝ _ _ λ ε' →
                     let ε* = ℚ.min₊ (ℚ./2₊ ε') (ℚ./2₊ θ)
                         ε*<ε' = snd
@@ -289,7 +289,7 @@ denseℚinℝ u v =
                              (
                              ℚ.isTrans≤< (fst ε*) (fst (ℚ./2₊ ε')) (fst ε')
                               (ℚ.min≤ (fst (ℚ./2₊ ε')) (fst (ℚ./2₊ θ)))
-                               (ℚ.x/2<x ε') )) 
+                               (ℚ.x/2<x ε') ))
 
                         ε*<θ = ℚ.isTrans≤< (fst ε*) (fst (ℚ./2₊ θ)) (fst θ)
                               (ℚ.min≤' (fst (ℚ./2₊ ε')) (fst (ℚ./2₊ θ)))
@@ -306,7 +306,7 @@ denseℚinℝ u v =
   w .Elimℝ-Prop.isPropA _ = isPropΠ2 λ _ _ → isSetℝ _ _
 
 
- 
+
 -- 11.3.43-i
 
 ∼→< : ∀ u q → u <ᵣ (rat q) → ∀ v ε → u ∼'[ ε ] v → v <ᵣ rat (q ℚ.+ fst ε)
@@ -321,8 +321,8 @@ denseℚinℝ u v =
 
 
 
--- x+[y-x]n/k≡y-[y-x]m/k : ∀ x y n m k → (n ℕ.+ m ≡ ℕ₊₁→ℕ k) → 
---   x ℚ.+ (y ℚ.- x) ℚ.· [ pos n / k ] 
+-- x+[y-x]n/k≡y-[y-x]m/k : ∀ x y n m k → (n ℕ.+ m ≡ ℕ₊₁→ℕ k) →
+--   x ℚ.+ (y ℚ.- x) ℚ.· [ pos n / k ]
 --    ≡ y ℚ.- ((y ℚ.- x) ℚ.· [ pos m / k ])
 -- x+[y-x]n/k≡y-[y-x]m/k u v n m k p =
 --   ((cong (u ℚ.+_) (ℚ.·DistR+ _ _ _ ∙ ℚ.+Comm _ _)
@@ -332,10 +332,10 @@ denseℚinℝ u v =
 --              {!!}
 --            --  distℚ! u ·[
 --            --   (ge1 +ge ((neg-ge ge1) ·ge
---            --            ge[ [ pos 1 / 1+ 1 ] ]))  
+--            --            ge[ [ pos 1 / 1+ 1 ] ]))
 --            --         ≡ (neg-ge ((neg-ge ge1) ·ge
 --            --            ge[ [ pos 1 / 1+ 1 ] ]))   ]
---            -- distℚ! v ·[ (( 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
@@ -347,7 +347,7 @@ denseℚinℝ u v =
 
 
 x+[y-x]/2≡y-[y-x]/2 : ∀ x y →
-  x ℚ.+ (y ℚ.- x) ℚ.· [ 1 / 2 ] 
+  x ℚ.+ (y ℚ.- x) ℚ.· [ 1 / 2 ]
    ≡ y ℚ.- ((y ℚ.- x) ℚ.· [ 1 / 2 ])
 x+[y-x]/2≡y-[y-x]/2 u v =
   ((cong (u ℚ.+_) (ℚ.·DistR+ _ _ _ ∙ ℚ.+Comm _ _)
@@ -355,10 +355,10 @@ x+[y-x]/2≡y-[y-x]/2 u v =
           cong₂ ℚ._+_
             distℚ! u ·[
              (ge1 +ge ((neg-ge ge1) ·ge
-                      ge[ [ pos 1 / 1+ 1 ] ]))  
+                      ge[ [ pos 1 / 1+ 1 ] ]))
                    ≡ (neg-ge ((neg-ge ge1) ·ge
                       ge[ [ pos 1 / 1+ 1 ] ]))   ]
-           distℚ! v ·[ (( 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
@@ -406,7 +406,7 @@ lem-11-3-44 = Elimℝ-Prop.go w
            (subst (ℚ._< (fst ε)) ((ℚ.+IdR x)) x₂)))
  w .Elimℝ-Prop.limA x p x₁ ε =
    (PT.rec squash₁
-     $ uncurry λ θ → PT.rec squash₁ λ (xx , xx') → 
+     $ uncurry λ θ → PT.rec squash₁ λ (xx , xx') →
        let zqz = ((subst∼ {ε' = (θ ℚ₊· ([ pos 1 / 1+ 2 ] , _))}
                               (ℚ.ε/6+ε/6≡ε/3 (fst θ))
                             (𝕣-lim-self
@@ -462,15 +462,15 @@ lem-11-3-44 = Elimℝ-Prop.go w
                                (ℚ.+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)) <ᵣ rat (fst ε)) → (u ∼[ ε ] v)
+
 ∼≃abs<ε⇐ u v ε = Elimℝ-Prop2Sym.go w u v ε
  where
   w : Elimℝ-Prop2Sym λ u v → ∀ ε →
@@ -485,7 +485,7 @@ lem-11-3-44 = Elimℝ-Prop.go w
                        (isTrans≤<ᵣ 0 _ (rat θ)
                          (0≤absᵣ _) xx))
               ww : ∀ δ η → absᵣ (rat q +ᵣ (-ᵣ lim x y))
-                          ∼[ δ ℚ₊+ η ] absᵣ (rat q +ᵣ (-ᵣ (x δ))) 
+                          ∼[ δ ℚ₊+ η ] absᵣ (rat q +ᵣ (-ᵣ (x δ)))
               ww δ η =
                 let uu : ⟨ NonExpandingₚ (absᵣ ∘S (rat q +ᵣ_) ∘S -ᵣ_) ⟩
                     uu = NonExpandingₚ∘ absᵣ ((rat q +ᵣ_) ∘S -ᵣ_)
@@ -502,7 +502,7 @@ lem-11-3-44 = Elimℝ-Prop.go w
                       xx ((absᵣ (rat q +ᵣ (-ᵣ (x δ)))))
                          (δ ℚ₊+ δ)
                       (∼→∼' _ _ (δ ℚ₊+ δ) (ww δ δ))
-                      
+
               wwwR = R δ ((θ , 0<θ) ℚ₊+ (δ ℚ₊+ δ)) www
               zz : fst (δ ℚ₊+ δ) ℚ.+ (fst δ ℚ.+ fst δ) ≡
                      fst ε ℚ.- θ
@@ -520,7 +520,7 @@ lem-11-3-44 = Elimℝ-Prop.go w
                          (0≤absᵣ _) xx))
             ww : ∀ δ η → absᵣ (lim x y +ᵣ (-ᵣ lim x' y'))
                         ∼[ (δ ℚ₊+ η) ℚ₊+ (δ ℚ₊+ η) ]
-                         absᵣ ((x δ) +ᵣ (-ᵣ (x' δ))) 
+                         absᵣ ((x δ) +ᵣ (-ᵣ (x' δ)))
             ww δ η =
               let uu = absᵣ-nonExpanding
                     ((lim x y +ᵣ (-ᵣ lim x' y')))
@@ -563,10 +563,10 @@ lem-11-3-44 = Elimℝ-Prop.go w
     (absᵣ (u +ᵣ (-ᵣ  v)) <ᵣ rat (fst ε))
 ∼≃abs<ε u v ε =
   propBiimpl→Equiv (isProp∼ _ _ _) (squash₁)
-   (λ x → 
+   (λ x →
     lem-11-3-44 ((u +ᵣ (-ᵣ v))) ε
       (∼→∼' _ _ _ $  (subst ((u +ᵣ (-ᵣ v)) ∼[ ε ]_) (+-ᵣ v)
-       (+ᵣ-∼ u v (-ᵣ v) ε x)))) 
+       (+ᵣ-∼ u v (-ᵣ v) ε x))))
    (∼≃abs<ε⇐ u v ε)
 
 getClampsOnQ : (a : ℚ) →
@@ -589,8 +589,8 @@ getClamps = Elimℝ-Prop.go w
               (∼→∼' _ _ _
                (∼-monotone< (ℚ.x/2<x 1) (absᵣ-nonExpanding _ _ _ z')) )
 
-       uu = ℤ.·IdR _ ∙ (sym $ ℤ.+Comm 1 (pos 1 ℤ.+ pos n ℤ.· pos 1))  
-       
+       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₁
 
@@ -599,7 +599,7 @@ restrSq : ∀ n → Lipschitz-ℚ→ℚ-restr (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
 
@@ -613,7 +613,7 @@ restrSq n q r x x₁ ε x₂ =
 
   z : ℚ.abs (q ℚ.+ r) ℚ.· ℚ.abs (q ℚ.- r) ℚ.<
         2 ℚ.· fst (fromNat (suc n)) ℚ.· fst ε
-  z = ℚ.<Monotone·-onPos _ _ _ _ 
+  z = ℚ.<Monotone·-onPos _ _ _ _
       zz x₂ (ℚ.0≤abs (q ℚ.+ r)) ((ℚ.0≤abs (q ℚ.- r)))
 
 
@@ -628,8 +628,8 @@ restrSq n q r x x₁ ε x₂ =
 <Δ n = 1/n<sucK 3 (1+ n)
 
 
-clampedSq : ∀ (n : ℕ) → Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ (2 ℚ₊· fromNat (suc n)))  
-clampedSq n = 
+clampedSq : ∀ (n : ℕ) → Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ (2 ℚ₊· fromNat (suc n)))
+clampedSq n =
   let ex = Lipschitz-ℚ→ℚ-extend _
              _ _ (ℚ.[ (1 , 4) ] , _) (<Δ n) (restrSq n)
   in fromLipschitz _ (_ , Lipschitz-rat∘ _ _ ex)
@@ -653,7 +653,7 @@ 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 ε) 
+  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)
@@ -722,7 +722,7 @@ openPred P = (∀ x → ⟨ P x ⟩ → ∃[ δ ∈ ℚ₊ ] (∀ y → x ∼[ 
     (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 → [ 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))))
@@ -775,7 +775,7 @@ abs'q≤Δ₁' q n n< = (ℚ.isTrans≤ (ℚ.abs' q) (fromNat (suc n)) _
 
 
 ℚabs-abs≤abs- : (x y : ℚ) → (ℚ.abs x ℚ.- ℚ.abs y) ℚ.≤ ℚ.abs (x ℚ.- y)
-ℚabs-abs≤abs- x y = 
+ℚabs-abs≤abs- x y =
  subst2 ℚ._≤_
    (cong ((ℚ._+ (ℚ.- (ℚ.abs y))) ∘ ℚ.abs) lem--00 )
    (sym lem--034)
@@ -811,7 +811,7 @@ 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 ε = 
+contDiagNE₂ ne f g fC gC u ε =
   PT.map2
     (λ (x , x') (y , y') →
       ℚ.min₊ x y , (λ v z →
@@ -829,7 +829,7 @@ contDiagNE₂WP : ∀ {h} → (ne : NonExpanding₂ h)
 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₊ ε)
@@ -866,7 +866,7 @@ IsContinuous+ᵣL x u ε =
 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))
@@ -910,7 +910,7 @@ IsContinuousConst x u ε = ∣ ε , (λ _ _ → refl∼ _ _ ) ∣₁
   (cong rat ∘ ℚ.+IdR)
 
 
-+ᵣMaxDistr : ∀ x y z → (maxᵣ x y) +ᵣ z ≡ maxᵣ (x +ᵣ z) (y +ᵣ z)   
++ᵣMaxDistr : ∀ x y z → (maxᵣ x y) +ᵣ z ≡ maxᵣ (x +ᵣ z) (y +ᵣ z)
 +ᵣMaxDistr x y z =
   ≡Continuous _ _
      (IsContinuous∘ _ _ (IsContinuous+ᵣR z) (IsContinuousMaxR y))
@@ -944,11 +944,11 @@ IsContinuousConst x u ε = ∣ ε , (λ _ _ → refl∼ _ _ ) ∣₁
 
 
 
- 
+
 lem--05ᵣ : ∀ δ q →  δ +ᵣ (q +ᵣ (-ᵣ δ)) ≡ q
 lem--05ᵣ δ q = cong (δ +ᵣ_) (+ᵣComm _ _) ∙∙
    +ᵣAssoc _ _ _  ∙∙
-    (cong (_+ᵣ q) (+-ᵣ δ) ∙ +IdL q) 
+    (cong (_+ᵣ q) (+-ᵣ δ) ∙ +IdL q)
 
 abs-max : ∀ x → absᵣ x ≡ maxᵣ x (-ᵣ x)
 abs-max = ≡Continuous _ _
diff --git a/Cubical/HITs/CauchyReals/Derivative.agda b/Cubical/HITs/CauchyReals/Derivative.agda
index 27bb4c2c74..4082c43f78 100644
--- a/Cubical/HITs/CauchyReals/Derivative.agda
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -37,7 +37,7 @@ open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary
 
 open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
 
 open import Cubical.Data.Rationals using (ℚ ; [_/_])
 open import Cubical.Data.Rationals.Order using
@@ -86,11 +86,11 @@ import Cubical.Algebra.Ring as RP
 
 -- Rℝ = (CR.CommRing→Ring
 --                (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ))
--- -- module CRℝ = ? 
+-- -- module CRℝ = ?
 
 -- module 𝐑 = CR.CommRingTheory (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ)
 -- module 𝐑' = RP.RingTheory Rℝ
-               
+
 
 at_limitOf_is_ : (x : ℝ) → (∀ r → x ＃ r → ℝ)  → ℝ → Type
 at x limitOf f is L =
@@ -105,12 +105,12 @@ const-lim C x ε = ∣ (1 , decℚ<ᵣ?) ,
 id-lim : ∀ x → at x limitOf (λ r _ → r) is x
 id-lim x ε = ∣ ε , (λ r x＃r p → p )  ∣₁
 
-_$[_]$_ : {x : ℝ} 
+_$[_]$_ : {x : ℝ}
         → (∀ r → x ＃ r → ℝ)
         → (ℝ → ℝ → ℝ)
         → (∀ r → x ＃ r → ℝ)
         → (∀ r → x ＃ r → ℝ)
-f $[ _op_ ]$ g = λ r x → (f r x) op (g r x) 
+f $[ _op_ ]$ g = λ r x → (f r x) op (g r x)
 
 +-lim : ∀ x f g F G
         → at x limitOf f is F
@@ -142,14 +142,14 @@ 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 → 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 → 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)))
@@ -162,4 +162,3 @@ idDerivative x =  subst (at 0 limitOf_is 1)
 -- derivative-^ⁿ zero x ε = {!!}
 -- derivative-^ⁿ (suc n) x ε = {!!}
 
-
diff --git a/Cubical/HITs/CauchyReals/Inverse.agda b/Cubical/HITs/CauchyReals/Inverse.agda
index b067ce4f06..eadb4162a8 100644
--- a/Cubical/HITs/CauchyReals/Inverse.agda
+++ b/Cubical/HITs/CauchyReals/Inverse.agda
@@ -36,7 +36,7 @@ open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary
 
 open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
 
 open import Cubical.Data.Rationals using (ℚ ; [_/_])
 open import Cubical.Data.Rationals.Order using
@@ -82,7 +82,7 @@ import Cubical.Algebra.Ring as RP
 
 Rℝ = (CR.CommRing→Ring
                (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ))
--- module CRℝ = ? 
+-- module CRℝ = ?
 
 module 𝐑 = CR.CommRingTheory (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ)
 module 𝐑' = RP.RingTheory Rℝ
@@ -95,10 +95,10 @@ module L𝐑 = Lems ((_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ)
 Invᵣ-restrℚ : (η : ℚ₊) →
   Σ (ℚ → ℚ) (Lipschitz-ℚ→ℚ (invℚ₊ (η ℚ₊· η)))
 
-Invᵣ-restrℚ η = f , 
-  Lipschitz-ℚ→ℚ'→Lipschitz-ℚ→ℚ _ _ w 
+Invᵣ-restrℚ η = f ,
+  Lipschitz-ℚ→ℚ'→Lipschitz-ℚ→ℚ _ _ w
  where
- 
+
  f = fst ∘ invℚ₊ ∘ ℚ.maxWithPos η
 
  w : ∀ q r → ℚ.abs (f q ℚ.- f r) ℚ.≤
@@ -124,7 +124,7 @@ Invᵣ-restrℚ η = f ,
 
 Invᵣ-restr : (η : ℚ₊) → Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ (invℚ₊ (η ℚ₊· η)))
 Invᵣ-restr η = (fromLipschitz (invℚ₊ (η ℚ₊· η)))
-                   (_ , Lipschitz-rat∘ _ _ (snd (Invᵣ-restrℚ η))) 
+                   (_ , Lipschitz-rat∘ _ _ (snd (Invᵣ-restrℚ η)))
 
 
 lowerℚBound : ∀ u → 0 <ᵣ u → ∃[ ε ∈ ℚ₊ ] (rat (fst ε) <ᵣ u)
@@ -151,9 +151,9 @@ from-abs< x y z p = isTrans≤<ᵣ _ _ _ (≤absᵣ _) p ,
    , isTrans≤<ᵣ _ _ _ (≤absᵣ _) (subst (((_<ᵣ z) ∘ absᵣ)) (+ᵣComm x (-ᵣ y)) p)
 
 open ℚ.HLP
- 
+
 ∃rationalApprox≤ : ∀ u → (ε : ℚ₊) →
-   ∃[ q ∈ ℚ ] (((rat q) +ᵣ (-ᵣ u)) ≤ᵣ rat (fst ε)) × (u ≤ᵣ rat q)     
+   ∃[ q ∈ ℚ ] (((rat q) +ᵣ (-ᵣ u)) ≤ᵣ rat (fst ε)) × (u ≤ᵣ rat q)
 ∃rationalApprox≤ = Elimℝ-Prop.go w
  where
  w : Elimℝ-Prop _
@@ -166,12 +166,12 @@ open ℚ.HLP
             (ℚ.<Weaken≤ _ _ (x/2<x (ε))) )
      in zz)
        , ≤ℚ→≤ᵣ _ _ (ℚ.≤+ℚ₊ r r (/2₊ ε) (ℚ.isRefl≤ r)) ∣₁
- w .Elimℝ-Prop.limA x y 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₊ ε)) 
-               
+                     (𝕣-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₊ ε))
@@ -186,7 +186,7 @@ open ℚ.HLP
                         { -ᵣ 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) 
+                       +ᵣComm (-ᵣ lim x y)
                         (rat q +ᵣ rat (fst (/2₊ ε) ℚ.+ fst (/2₊ (/4₊ ε))))
                          ∙ cong (_+ᵣ (-ᵣ lim x y))
                            (+ᵣAssoc (rat q) (rat (fst (/2₊ ε)))
@@ -218,7 +218,7 @@ open ℚ.HLP
  w .Elimℝ-Prop.isPropA _ = isPropΠ λ _ → squash₁
 
 
-ℚmax-min-minus : ∀ x y → ℚ.max (ℚ.- x) (ℚ.- y) ≡ ℚ.- (ℚ.min x y) 
+ℚ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 →
@@ -238,7 +238,7 @@ open ℚ.HLP
        (ℚ.- q' , ℚ.- q) , -ᵣ≤ᵣ _ _ z'' , ((ℚ.minus-< _ _ z') , -ᵣ≤ᵣ _ _ z)
 
 ∃rationalApprox< : ∀ u → (ε : ℚ₊) →
-   ∃[ q ∈ ℚ ] (((rat q) +ᵣ (-ᵣ u)) <ᵣ rat (fst ε)) × (u <ᵣ rat q)     
+   ∃[ q ∈ ℚ ] (((rat q) +ᵣ (-ᵣ u)) <ᵣ rat (fst ε)) × (u <ᵣ rat q)
 ∃rationalApprox< u ε =
   PT.map (uncurry (λ q (x , x') →
      q ℚ.+ (fst (/4₊ ε))  ,
@@ -257,7 +257,7 @@ open ℚ.HLP
 
 ∃rationalApprox : ∀ u → (ε : ℚ₊) →
    ∃[ (q , q') ∈ (ℚ × ℚ) ] (q' ℚ.- q ℚ.< fst ε) ×
-                           ((rat q <ᵣ u) × (u <ᵣ rat q'))     
+                           ((rat q <ᵣ u) × (u <ᵣ rat q'))
 ∃rationalApprox u ε =
   PT.map2 (uncurry (λ q (x , x') → uncurry (λ q' (y , y') →
       ((ℚ.- (q ℚ.+ (fst (/4₊ ε)))) , q' ℚ.+ (fst (/4₊ ε))) ,
@@ -293,7 +293,7 @@ open ℚ.HLP
      )
      )) (∃rationalApprox≤ (-ᵣ u) (/2₊ (/4₊ ε)))
         (∃rationalApprox≤ u (/2₊ (/4₊ ε)))
-        
+
 
 
 <ᵣ-+o-pre : ∀ m n o  → m ℚ.< n  → (rat m +ᵣ o) <ᵣ (rat n +ᵣ o)
@@ -301,10 +301,10 @@ open ℚ.HLP
   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) 
+                (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₊ Δ))
@@ -327,15 +327,15 @@ open ℚ.HLP
                        (-ᵣ rat (fst (/4₊ Δ))) i) ∙
                       sym (-ᵣDistr (rat (fst (/4₊ Δ))) ((-ᵣ (rat n +ᵣ o)))) )
               (≤ᵣ-+o _ _ (rat m +ᵣ (o +ᵣ (-ᵣ (rat (fst (/4₊ Δ))))))
-                (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ (x/2<x Δ)))) 
-         
+                (≤ℚ→≤ᵣ _ _ (ℚ.<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''))))
@@ -349,20 +349,20 @@ open ℚ.HLP
      ((∃rationalApprox (rat n +ᵣ o) (/4₊ Δ)))
 
  where
- Δ = ℚ.<→ℚ₊ m n m<n 
+ Δ = ℚ.<→ℚ₊ 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'' : (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)
@@ -400,22 +400,22 @@ isAsym<ᵣ x y =
 _＃_ : ℝ → ℝ → Type
 x ＃ y = (x <ᵣ y) ⊎ (y <ᵣ x)
 
-isProp＃ : ∀ x y → isProp (x ＃ y) 
+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' → (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)    
+decCut x 0<absX =
+  PT.rec (isProp＃ 0 x)
     (λ (Δ , Δ<absX) →
       PT.rec (isProp＃ 0 x)
          (λ (q , q-x<Δ/2 , x<q) →
@@ -463,7 +463,7 @@ decCut x 0<absX =
 
 
 
-＃≃0<dist : ∀ x y → x ＃ y ≃ (0 <ᵣ (absᵣ (x +ᵣ (-ᵣ y)))) 
+＃≃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)))
@@ -474,7 +474,7 @@ decCut x 0<absX =
          (inl ∘S subst2 _<ᵣ_ L𝐑.lem--05 (+IdR _) ∘S <ᵣ-o+ _ _ y)
           ∘S decCut (x +ᵣ (-ᵣ y)))
 
--- ＃≃abs< : ∀ x y → absᵣ x <ᵣ y ≃  
+-- ＃≃abs< : ∀ x y → absᵣ x <ᵣ y ≃
 -- ＃≃abs< : ?
 
 isSym＃ : BinaryRelation.isSym _＃_
@@ -491,9 +491,9 @@ isSym＃ _ _ = fst ⊎-swap-≃
 
 ≤ᵣ-o· : ∀ m n (o : ℚ₊) →  m ≤ᵣ n → (rat (fst o) ·ᵣ m ) ≤ᵣ (rat (fst o) ·ᵣ n)
 ≤ᵣ-o· m n o p =
-    cong₂ maxᵣ (·ᵣComm _ _ ) (·ᵣComm _ _ ) ∙ ≤ᵣ-·o m n o p ∙ ·ᵣComm _ _ 
+    cong₂ maxᵣ (·ᵣComm _ _ ) (·ᵣComm _ _ ) ∙ ≤ᵣ-·o m n o p ∙ ·ᵣComm _ _
 
--- max≤-lem : ∀ x x' → x <ᵣ y → x' <ᵣ y → maxᵣ x x' ≤ᵣ x 
+-- 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)
@@ -502,10 +502,10 @@ isSym＃ _ _ = fst ⊎-swap-≃
                 let zz = isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ a') a''
                     zz' = -ᵣ≤ᵣ _ _ a
                     zz'' = ≤ᵣMonotone+ᵣ _ _ _ _ a'' zz'
-                in isTrans<≤ᵣ _ _ _ 
+                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})
@@ -536,7 +536,7 @@ a-b<c⇒a-c<b a 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)) 
+  subst (_<ᵣ (c +ᵣ b))
     (L𝐑.lem--00 {a} {b})
      (<ᵣ-+o _ _ b p)
 
@@ -547,17 +547,17 @@ a-b<c⇒a<c+b a b c 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) 
+  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) 
+  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 → 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) 
+    (<ᵣ-+o 0 (y +ᵣ (-ᵣ x)) x p)
 
 
 
@@ -583,12 +583,12 @@ min-lem x x' y = minᵣAssoc _ _ _ ∙ cong (flip minᵣ y) (minᵣComm _ _)
      ∙ 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 → x ≤ᵣ y → x' ≤ᵣ y → maxᵣ x x' ≤ᵣ y
 max≤-lem x x' y p p' =
-  sym (max-lem _ _ _) 
+  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 → 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'')) →
@@ -621,12 +621,12 @@ minDistMaxᵣ x y y' = ≡Continuous _ _
 ≤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' → 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 → 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'')) →
@@ -635,7 +635,7 @@ minDistMaxᵣ x y y' = ≡Continuous _ _
             ≤min-lem (rat (ℚ.min q' r')) x x'
              (isTrans≤ᵣ _ _ _ (≤ℚ→≤ᵣ _ _ (ℚ.min≤ q' r')) a'')
              (isTrans≤ᵣ _ _ _ (≤ℚ→≤ᵣ _ _ (ℚ.min≤' q' r')) b'')
-          
+
 
 
 
@@ -646,10 +646,10 @@ minDistMaxᵣ x y y' = ≡Continuous _ _
 invℝ'' : Σ (∀ r → ∃[ σ ∈ ℚ₊ ] (rat (fst σ) <ᵣ r) → ℝ)
       λ _ → Σ (∀ r → 0 <ᵣ r → ℝ) (IsContinuousWithPred (λ r → _ , squash₁))
 invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
-   ctnF  
- 
+   ctnF
+
  where
- 
+
  2co : ∀ σ σ' r
     → (rat (fst σ ) <ᵣ r)
     → (rat (fst σ') <ᵣ r)
@@ -675,45 +675,45 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
 
            φ* : ℚ₊
            φ* = ℚ.min₊ (/2₊ φ*ε) φ*σ
-                         
+
 
 
            limRestr'' : rat (fst φ*)
-               ≤ᵣ (rat q +ᵣ (-ᵣ rat (fst σ⊔))) ·ᵣ rat [ 1 / 2 ]  
+               ≤ᵣ (rat q +ᵣ (-ᵣ rat (fst σ⊔))) ·ᵣ rat [ 1 / 2 ]
            limRestr'' =
              let zz = ((ℚ.min≤'
                     ((fst (/2₊ ((invℚ₊ ((invℚ₊ (σ ℚ₊· σ))
                                    ℚ₊+ (invℚ₊ (σ' ℚ₊· σ'))))
                                    ℚ₊· ε))))
                                     (fst (/2₊
-                             (ℚ.<→ℚ₊ (fst σ⊔) q (<ᵣ→<ℚ _ _ σ⊔<q)) 
+                             (ℚ.<→ℚ₊ (fst σ⊔) q (<ᵣ→<ℚ _ _ σ⊔<q))
                           ))))
              in subst (rat (fst φ*) ≤ᵣ_)
                 (rat·ᵣrat _ _)
                   (≤ℚ→≤ᵣ (fst φ*)
                     (fst (/2₊
-                             (ℚ.<→ℚ₊ (fst σ⊔) q (<ᵣ→<ℚ _ _ σ⊔<q)) 
+                             (ℚ.<→ℚ₊ (fst σ⊔) q (<ᵣ→<ℚ _ _ σ⊔<q))
                           )) zz)
-                 
+
 
            limRestr' : rat (fst φ* ℚ.+ fst φ*)
-               ≤ᵣ (lim x y +ᵣ (-ᵣ rat (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 _ _) ∙ 
+                  (sym (rat·ᵣrat _ _) ∙
                    cong rat (distℚ! (fst φ*) ·[ ge[ 2 ]  ≡ ge1 +ge ge1 ]))
-                    (sym (·ᵣAssoc _ _ _) ∙∙ 
+                    (sym (·ᵣAssoc _ _ _) ∙∙
                       cong ((lim x y +ᵣ (-ᵣ rat (fst σ⊔))) ·ᵣ_)
                        (sym (rat·ᵣrat _ _)
                          ∙ (cong rat (𝟚.toWitness {Q = ℚ.discreteℚ
                            ([ 1 / 2 ] ℚ.· 2) 1} tt))) ∙∙
                       ·IdR _ )
                    (≤ᵣ-·o _ _ 2 (isTrans≤ᵣ _ _ _
-                   limRestr'' (≤ᵣ-·o _ _ ([ 1 / 2 ] , _) zz)))             
+                   limRestr'' (≤ᵣ-·o _ _ ([ 1 / 2 ] , _) zz)))
 
 
            limRestr : rat (fst σ⊔)
@@ -725,14 +725,14 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
              (≤ᵣ-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<ε _ _ (φ* ℚ₊+ φ*)) 
+                   (fst (∼≃abs<ε _ _ (φ* ℚ₊+ φ*))
                    $ 𝕣-lim-self x y φ* φ*))
              in subst2 _<ᵣ_ (L𝐑.lem--060 {lim x y} {x φ*}
                            {rat (fst φ* ℚ.+ fst φ*)})
@@ -746,7 +746,7 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
            φ' : ℚ₊
            φ' = (invℚ₊ (σ' ℚ₊· σ')) ℚ₊·  φ*
            σ⊔<Xφ* : rat (fst σ⊔) <ᵣ x φ*
-           σ⊔<Xφ* = isTrans≤<ᵣ _ _ _ limRestr ∣x-limX∣ 
+           σ⊔<Xφ* = isTrans≤<ᵣ _ _ _ limRestr ∣x-limX∣
            σ<Xφ* : rat (fst σ) <ᵣ x φ*
            σ<Xφ* = isTrans≤<ᵣ _ _ _
               (≤ℚ→≤ᵣ _ _ (ℚ.≤max (fst σ) (fst σ'))) σ⊔<Xφ*
@@ -768,26 +768,26 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
                               (ℚ.0≤ℚ₊ ((invℚ₊ (σ ℚ₊· σ))
                                    ℚ₊+ (invℚ₊ (σ' ℚ₊· σ'))))
                              (
-                               (ℚ.min≤ (fst (/2₊ φ*ε)) (fst φ*σ)))) 
-           
+                               (ℚ.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)
@@ -795,11 +795,11 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<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ℝ _ _
 
@@ -808,12 +808,12 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
 
  f : ∀ r → ∃[ σ ∈ ℚ₊ ] (rat (fst σ) <ᵣ r) → ℝ
  f r = PT.rec→Set {B = ℝ} isSetℝ (f' r)
-          λ (σ , σ<r) (σ' , σ'<r) → 2co σ σ' r σ<r σ'<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)) 
+                  f u (lowerℚBound u u∈) ∼[ ε ] f v (lowerℚBound v v∈P))
  ctnF u ε u∈ = ctnF' (lowerℚBound u u∈)
 
   where
@@ -823,7 +823,7 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
   ctnF' = PT.elim (λ _ → squash₁)
     λ (σ , σ<u) →
      let zz : ∃[ δ ∈ ℚ₊ ] ((v₁ : ℝ) →  u ∼[ δ ] v₁
-                      → f u ∣ σ , σ<u ∣₁ ∼[ ε ] Invᵣ-restr σ .fst v₁) 
+                      → f u ∣ σ , σ<u ∣₁ ∼[ ε ] Invᵣ-restr σ .fst v₁)
          zz = Lipschitz→IsContinuous (invℚ₊ (σ ℚ₊· σ))
                  (λ z → Invᵣ-restr σ .fst z)
                  (snd (Invᵣ-restr σ) ) u ε
@@ -833,18 +833,18 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
                   f u ∣ σ , σ<u ∣₁ ∼[ ε ] f v (lowerℚBound v v∈))
          zz' = PT.rec2 squash₁
              (uncurry (λ δ R (η , η<u-σ)  →
-               let δ' = ℚ.min₊ δ η 
+               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 η) 
+                             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)
@@ -870,9 +870,9 @@ invℝ'-rat : ∀ q p' 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) 
+                        (ww x)) (lowerℚBound (rat q) p)
 
- where 
+ where
  ww : ∀ x → (ℚ.maxWithPos (fst x) q) ≡ (q , p')
  ww x = ℚ₊≡ (ℚ.≤→max (fst (fst x)) q (ℚ.<Weaken≤ _ _ (<ᵣ→<ℚ _ _ (snd x))))
 
@@ -895,7 +895,7 @@ invℝ'-pos u p = PT.rec squash₁
                  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'
@@ -904,7 +904,7 @@ invℝ'-pos u p = PT.rec squash₁
                             (≤ℚ→≤ᵣ _ _ (
                              ℚ.invℚ≤invℚ ([ ℚ.ℕ₊₁→ℤ n / 1 ] , _)
                                (q' , ℚ.<→0< q' (<ᵣ→<ℚ [ pos 0 / 1 ] q' 0<q'))
-                                ((ℚ.min≤' q'* [ pos (ℕ₊₁→ℕ n) / 1 ])))) 
+                                ((ℚ.min≤' q'* [ pos (ℕ₊₁→ℕ n) / 1 ]))))
                  z : ((invℝ' .fst (rat q') 0<q') +ᵣ (-ᵣ rat [ 1 / n ]))
                        <ᵣ
                        (invℝ' .fst u p)
@@ -918,7 +918,7 @@ invℝ'-pos u p = PT.rec squash₁
                                 (x≤y→0≤y-x _ _ (<ᵣWeaken≤ᵣ _ _ x''))))
                               (≤ᵣ-o+ _ _ _ (-ᵣ≤ᵣ _ _ (<ᵣWeaken≤ᵣ _ _ x'))))
                            (<ℚ→<ᵣ _ _ x))))))))
-                 
+
              in isTrans≤<ᵣ _ _ _ (x≤y→0≤y-x _ _ z') z
              )
            (∃rationalApprox u σ))
@@ -926,7 +926,7 @@ invℝ'-pos u p = PT.rec squash₁
   (getClamps u)
 
 signᵣ : ∀ r → 0 ＃ r → ℝ
-signᵣ _ = ⊎.rec (λ _ → rat 1) (λ _ → rat -1) 
+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} _))
@@ -941,10 +941,10 @@ signᵣ-rat r (inr x) = cong rat (sym (snd (snd (ℚ.<→sign r)) (<ᵣ→<ℚ _
 
 -- HoTT Theorem (11.3.47)
 invℝ : ∀ r → 0 ＃ r → ℝ
-invℝ r 0＃r = signᵣ r 0＃r ·ᵣ fst invℝ' (absᵣ r) (0＃→0<abs r 0＃r) 
+invℝ r 0＃r = signᵣ r 0＃r ·ᵣ fst invℝ' (absᵣ r) (0＃→0<abs r 0＃r)
 
 IsContinuousWithPredSignᵣ : IsContinuousWithPred 0＃ₚ signᵣ
-IsContinuousWithPredSignᵣ u ε = 
+IsContinuousWithPredSignᵣ u ε =
  ⊎.elim
   (λ 0<u → PT.map (λ (q , 0<q , q<u) →
              ((q , ℚ.<→0< q (<ᵣ→<ℚ _ _ 0<q))) ,
@@ -969,21 +969,21 @@ IsContinuousWithPredSignᵣ u ε =
                           (fst (∼≃abs<ε _ _ _) (sym∼ _ _ _ v∼u))))))))
                   (λ _ → refl∼ _ _) v∈P)
              (denseℚinℝ u 0 u<0))
-  
+
 IsContinuousWithPredInvℝ : IsContinuousWithPred (λ _ → _ , isProp＃ _ _) invℝ
 IsContinuousWithPredInvℝ =
    IsContinuousWP∘ 0＃ₚ 0＃ₚ _ _ (λ r x → x)
-   (cont₂·ᵣWP 0＃ₚ _ _ 
+   (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' → invℝ (rat q) p ≡ rat (ℚ.invℚ q p')
 invℝ-rat q p p' =
-  cong₂ _·ᵣ_ (signᵣ-rat q p) (invℝ'-rat _ _ _) ∙ sym (rat·ᵣrat _ _) 
+  cong₂ _·ᵣ_ (signᵣ-rat q p) (invℝ'-rat _ _ _) ∙ sym (rat·ᵣrat _ _)
 
 -ᵣ≡[-1·ᵣ] : ∀ x → -ᵣ x ≡ (-1) ·ᵣ x
 -ᵣ≡[-1·ᵣ] = ≡Continuous _ _
@@ -998,7 +998,7 @@ invℝ-pos x p = subst (0 <ᵣ_) (sym (·IdL _))
 
 
 invℝ-neg : ∀ x → (p : x <ᵣ 0) → invℝ x (inr p) <ᵣ 0
-invℝ-neg x p = 
+invℝ-neg x p =
      subst (_<ᵣ 0)
        (-ᵣ≡[-1·ᵣ] _)
        (-ᵣ<ᵣ 0 _ (invℝ'-pos (absᵣ x) (0＃→0<abs x (inr p))))
@@ -1008,7 +1008,7 @@ invℝ0＃ r = ⊎.elim (inl ∘ invℝ-pos r)
                    (inr ∘ invℝ-neg r)
 
 
-openPred< : ∀ x → ⟨ openPred (λ y → (x <ᵣ y) , squash₁)  ⟩ 
+openPred< : ∀ x → ⟨ openPred (λ y → (x <ᵣ y) , squash₁)  ⟩
 openPred< x y =
      PT.map (map-snd (λ {q} a<y-x v
         →   isTrans<ᵣ _ _ _
@@ -1019,7 +1019,7 @@ openPred< x y =
   ∘S lowerℚBound (y +ᵣ (-ᵣ x))
   ∘S x<y→0<y-x x y
 
-openPred> : ∀ x → ⟨ openPred (λ y → (y <ᵣ x) , squash₁)  ⟩ 
+openPred> : ∀ x → ⟨ openPred (λ y → (y <ᵣ x) , squash₁)  ⟩
 openPred> x y =
        PT.map (map-snd (λ {q} q<x-y v
         →     flip (isTrans<ᵣ _ _ _)
@@ -1032,7 +1032,7 @@ openPred> x y =
   ∘S x<y→0<y-x y x
 
 
-isOpenPred0＃ : ⟨ openPred 0＃ₚ ⟩ 
+isOpenPred0＃ : ⟨ openPred 0＃ₚ ⟩
 isOpenPred0＃ x =
  ⊎.rec
    (PT.map (map-snd ((inl ∘_) ∘_)) ∘ openPred< 0 x)
@@ -1049,7 +1049,7 @@ isOpenPred0＃ x =
         (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 
+            (r , ℚ.<→0< _ (<ᵣ→<ℚ _ _ r∈)))) r
 
 
 invℝInvol : ∀ r 0＃r → invℝ (invℝ r 0＃r) (invℝ0＃ r 0＃r) ≡ r
@@ -1062,10 +1062,10 @@ invℝInvol r 0＃r = ≡ContinuousWithPred
        _ IsContinuousId)
         (λ r 0＃r 0＃r' →
           let 0#r = (fst (rat＃ 0 r) 0＃r)
-              0#InvR = ℚ.0#invℚ 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))
@@ -1090,7 +1090,7 @@ sign·absᵣ r = ∘diag $
         (λ 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 
+           ∙ ℚ.sign·abs r) ) r
 
 x·invℝ[x] : ∀ r 0＃r → r ·ᵣ (invℝ r 0＃r) ≡ 1
 x·invℝ[x] r 0＃r =
@@ -1101,10 +1101,10 @@ x·invℝ[x] 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  → ℝ 
+_／ᵣ[_,_] : ℝ → ∀ 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) →
@@ -1117,7 +1117,7 @@ q ／ᵣ₊ (r , 0<r) = q ／ᵣ[ r , inl (0<r) ]
 
 [x/y]·yᵣ : ∀ q r → (0＃r : 0 ＃ r) →
                (q ／ᵣ[ r , 0＃r ]) ·ᵣ r ≡ q
-[x/y]·yᵣ q r 0＃r = 
+[x/y]·yᵣ q r 0＃r =
       sym (·ᵣAssoc _ _ _)
    ∙∙ cong (q ·ᵣ_) (·ᵣComm _ _ ∙ x·invℝ[x] r 0＃r)
    ∙∙ ·IdR q
@@ -1126,10 +1126,10 @@ 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 
+    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 
+    sym ([x·y]/yᵣ _ _ _) ∙ cong (_／ᵣ[ r , 0＃r ]) p
diff --git a/Cubical/HITs/CauchyReals/Lems.agda b/Cubical/HITs/CauchyReals/Lems.agda
index b172562c23..5919f2c711 100644
--- a/Cubical/HITs/CauchyReals/Lems.agda
+++ b/Cubical/HITs/CauchyReals/Lems.agda
@@ -15,7 +15,7 @@ module Lems (R : CR.CommRing ℓ-zero) where
  open CR.CommRingStr (snd R)
 
 
- lem-01 : ∀ ε δ η η' a → 
+ lem-01 : ∀ ε δ η η' a →
        (ε - (δ + η)) +
        ((a + δ) + (η' - a))
       ≡ (ε + η') - η
@@ -39,7 +39,7 @@ module Lems (R : CR.CommRing ℓ-zero) where
 
  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
 
@@ -49,100 +49,100 @@ module Lems (R : CR.CommRing ℓ-zero) where
 
  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
 
@@ -161,7 +161,7 @@ module Lems (R : CR.CommRing ℓ-zero) where
  lem--037 = solve! R
 
  lem--038 : (ε - η) · (ε + η) ≡
-             (ε · ε) - (η · η) 
+             (ε · ε) - (η · η)
  lem--038 = solve! R
 
  lem--039 : (x' - x) · (y' - y) + (x' · y + x · (y' - y))
@@ -201,10 +201,10 @@ module Lems (R : CR.CommRing ℓ-zero) where
     ((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 : ((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 : ((ε · x) · y) + ((η · x) · y) ≡ (((ε + η) · x) · y)
  lem--049 = solve! R
 
  lem--050 : (- ε) ≡ (x - (x + ε))
diff --git a/Cubical/HITs/CauchyReals/Lipschitz.agda b/Cubical/HITs/CauchyReals/Lipschitz.agda
index ff0e0826cc..d2bd708c87 100644
--- a/Cubical/HITs/CauchyReals/Lipschitz.agda
+++ b/Cubical/HITs/CauchyReals/Lipschitz.agda
@@ -34,7 +34,7 @@ open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary
 
 open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
 
 open import Cubical.Data.Rationals using (ℚ ; [_/_])
 open import Cubical.Data.Rationals.Order using
@@ -109,7 +109,7 @@ sΣℚ<' {u} {v} {ε} p x =
 
 
 -- HoTT Lemma (11.3.10)
-lim-surj : ∀ r → ∃[ x ∈ _ ] (r ≡ (uncurry lim x) )  
+lim-surj : ∀ r → ∃[ x ∈ _ ] (r ≡ (uncurry lim x) )
 lim-surj = PT.map (map-snd (eqℝ _ _)) ∘ (Elimℝ-Prop.go w)
  where
  w : Elimℝ-Prop _
@@ -128,15 +128,15 @@ lim-surj = PT.map (map-snd (eqℝ _ _)) ∘ (Elimℝ-Prop.go w)
 -- TODO : (Lemma 11.3.11)
 
 
-Lipschitz-ℚ→ℚ : ℚ₊ → (ℚ → ℚ) → Type 
+Lipschitz-ℚ→ℚ : ℚ₊ → (ℚ → ℚ) → Type
 Lipschitz-ℚ→ℚ L f =
-  (∀ q r → (ε : ℚ₊) → 
+  (∀ q r → (ε : ℚ₊) →
     ℚ.abs (q ℚ.- r) ℚ.< (fst ε) → ℚ.abs (f q ℚ.- f r) ℚ.< fst (L ℚ₊· ε  ))
 
 
-Lipschitz-ℚ→ℚ' : ℚ₊ → (ℚ → ℚ) → Type 
+Lipschitz-ℚ→ℚ' : ℚ₊ → (ℚ → ℚ) → Type
 Lipschitz-ℚ→ℚ' L f =
-  ∀ q r →  
+  ∀ q r →
     ℚ.abs (f q ℚ.- f r) ℚ.≤ fst L ℚ.· ℚ.abs (q ℚ.- r)
 
 Lipschitz-ℚ→ℚ'→Lipschitz-ℚ→ℚ : ∀ L f →
@@ -145,20 +145,20 @@ Lipschitz-ℚ→ℚ'→Lipschitz-ℚ→ℚ L f P q r ε <ε =
   ℚ.isTrans≤< _ _ _ (P q r)
     (ℚ.<-o· (ℚ.abs (q ℚ.- r)) (fst ε) _ (ℚ.0<ℚ₊ L) <ε)
 
-Lipschitz-ℚ→ℚ-restr : ℚ₊ → ℚ₊ → (ℚ → ℚ) → Type 
+Lipschitz-ℚ→ℚ-restr : ℚ₊ → ℚ₊ → (ℚ → ℚ) → Type
 Lipschitz-ℚ→ℚ-restr Δ L f =
-  (∀ q r → ℚ.abs q ℚ.< fst Δ → ℚ.abs r ℚ.< fst Δ → (ε : ℚ₊) → 
+  (∀ q r → ℚ.abs q ℚ.< fst Δ → ℚ.abs r ℚ.< fst Δ → (ε : ℚ₊) →
     ℚ.abs (q ℚ.- r) ℚ.< (fst ε) → ℚ.abs (f q ℚ.- f r) ℚ.< fst (L ℚ₊· ε  ))
 
-Lipschitz-ℚ→ℚ-restr' : ℚ₊ → ℚ₊ → (ℚ → ℚ) → Type 
+Lipschitz-ℚ→ℚ-restr' : ℚ₊ → ℚ₊ → (ℚ → ℚ) → Type
 Lipschitz-ℚ→ℚ-restr' Δ L f =
-  (∀ q r → fst Δ ℚ.< ℚ.abs q → fst Δ  ℚ.< ℚ.abs r → (ε : ℚ₊) → 
+  (∀ 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-ℚ→ℚ 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 Δ
@@ -183,40 +183,40 @@ Lipschitz-ℚ→ℚ-extend Δ L f δ δ<Δ x q r ε v =
 
 
 -- HoTT Definition (11.3.14)
-Lipschitz-ℚ→ℝ : ℚ₊ → (ℚ → ℝ) → Type 
+Lipschitz-ℚ→ℝ : ℚ₊ → (ℚ → ℝ) → Type
 Lipschitz-ℚ→ℝ L f =
-  (∀ q r → (ε : ℚ₊) → 
+  (∀ 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 → Lipschitz-ℚ→ℚ l f → Lipschitz-ℚ→ℝ l (rat ∘ f)
 Lipschitz-rat∘ l f x =
   λ q r ε x₁ x₂ →
-    rat-rat-fromAbs _ _ _ 
+    rat-rat-fromAbs _ _ _
        $ x q r ε (ℚ.absFrom<×< (fst ε) (q ℚ.- r) x₁ x₂)
 
-Lipschitz-ℝ→ℝ : ℚ₊ → (ℝ → ℝ) → Type 
+Lipschitz-ℝ→ℝ : ℚ₊ → (ℝ → ℝ) → Type
 Lipschitz-ℝ→ℝ L f =
-  (∀ u v → (ε : ℚ₊) → 
+  (∀ 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 → 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 → Σ _ (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 = 
+ rl q y ε δ p v r v' u' z =
   𝕣-lim' (f q) (v' ∘ (invℚ₊ L) ℚ₊·_)
             (L ℚ₊· ε) (L ℚ₊· δ)
           (λ δ₁ ε₁ →
@@ -258,7 +258,7 @@ fromLipschitz L (f , fL) = f' ,
                         (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ℝ.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₁ =
@@ -267,7 +267,7 @@ fromLipschitz L (f , fL) = f' ,
        (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₁)
@@ -306,7 +306,7 @@ lipschConstIrrel L₁ 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 _)) ∙
@@ -324,14 +324,14 @@ lipschConstIrrel L₁ L₂ =
                   (ℚ.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) 
+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 
+fst (NonExpandingₚ f) = ∀ u v ε →  u ∼[ ε ] v → f u ∼[ ε ] f v
 snd (NonExpandingₚ f) = isPropΠ4 λ _ _ _ _ → isProp∼ _ _ _
 
 NonExpandingₚ∘ : ∀ f g → ⟨ NonExpandingₚ f ⟩ → ⟨ NonExpandingₚ g ⟩ →
@@ -350,7 +350,7 @@ 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 
+   congLim x y x' _ p
 
 -- HoTT Lemma (11.3.40)
 record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
@@ -358,11 +358,11 @@ record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
  field
 
   cL : ∀ q r s →
-       ℚ.abs (g q s ℚ.- g r s) ℚ.≤ ℚ.abs (q ℚ.- r) 
+       ℚ.abs (g q s ℚ.- g r s) ℚ.≤ ℚ.abs (q ℚ.- r)
 
   cR : ∀ q r s →
       (ℚ.abs (g q r ℚ.- g q s) ℚ.≤ ℚ.abs (r ℚ.- s))
-      
+
 
 
 
@@ -370,8 +370,8 @@ record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
  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 _ _ _ 
+          zz = cR q q₁ r₁
+      in rat-rat-fromAbs _ _ _
            (ℚ.isTrans≤<
              (ℚ.abs (g q q₁ ℚ.- g q r₁)) (ℚ.abs (q₁ ℚ.- r₁))
              _ zz
@@ -385,7 +385,7 @@ record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
        _ λ 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 → 
+ 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 =
@@ -412,7 +412,7 @@ record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
   where
   rr :  Elimℝ-Prop λ u → (ε : ℚ₊) (x : (ℚ.- fst ε) ℚ.< (q ℚ.- r))
          (x₁ : (q ℚ.- r) ℚ.< fst ε) →
-               fst (zz q) u ∼[ ε ] fst (zz r) u 
+               fst (zz q) u ∼[ ε ] fst (zz r) u
   rr .Elimℝ-Prop.ratA qq ε x₁ x₂ =
     rat-rat-fromAbs _ _ _
       (ℚ.isTrans≤<
@@ -434,7 +434,7 @@ record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
                      fst (zz r) (x xx))
                        (ℚ₊≡ $ sym (ℚ.·IdL (fst θ/2)))
                        (ℚ₊≡ (cong (λ θ → fst ε ℚ.- θ)
-                              (sym (ε/2+ε/2≡ε θ)))) zzz)) 
+                              (sym (ε/2+ε/2≡ε θ)))) zzz))
   rr .Elimℝ-Prop.isPropA _ = isPropΠ3 λ _ _ _ → isProp∼ _ _ _
 
  w .Elimℝ.rat-lim-B _ _ ε δ _ _ _ _ _ x _ =
@@ -451,10 +451,10 @@ record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
 
 
  go : ℝ → ℝ → ℝ
- go x = fst (preF x) 
+ 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∼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
@@ -486,7 +486,7 @@ record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
                          lim (λ q → go (x (/2₊ q)) (x' (/2₊ q)))
                           yy')
  β-lim-lim/2 x y x' y' =
-   let 
+   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)))
@@ -545,8 +545,8 @@ NonExpanding₂-flip g ne .NonExpanding₂.cR q r s =
 
 
 
-isPropNonExpanding₂ : ∀ g → isProp (NonExpanding₂ g) 
-isPropNonExpanding₂ g x y i .NonExpanding₂.cL = 
+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)
@@ -557,7 +557,7 @@ isPropNonExpanding₂ g x y i .NonExpanding₂.cR =
      (λ q r s → x .NonExpanding₂.cR q r s)
     (λ q r s → y .NonExpanding₂.cR q r s) i
 
-nonExpanding₂Ext : (g g' : _) 
+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
@@ -575,27 +575,27 @@ 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₁ = 
+ 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 
+      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)) 
+        x' y' x y))
  w .Elimℝ-Prop2.isPropA _ _ = isSetℝ _ _
 
 module NonExpanding₂-Lemmas
@@ -636,10 +636,10 @@ module NonExpanding₂-Lemmas
            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 ε)   
+            (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)) 
+                 NE.go (lim x x') (NE.go (rat p) (rat q))
           hhh ε =
            let zzz = R (/4₊ ε) (/2₊ ε)
            in uncurry (lim-lim _ _ ε (/4₊ ε)
@@ -649,7 +649,7 @@ module NonExpanding₂-Lemmas
                       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₊ ε)
@@ -668,6 +668,6 @@ module NonExpanding₂-Lemmas
 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
index 0353b22a5c..8244a1524d 100644
--- a/Cubical/HITs/CauchyReals/Multiplication.agda
+++ b/Cubical/HITs/CauchyReals/Multiplication.agda
@@ -35,7 +35,7 @@ open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary
 
 open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
 
 open import Cubical.Data.Rationals using (ℚ ; [_/_])
 open import Cubical.Data.Rationals.Order using
@@ -66,7 +66,7 @@ open import Cubical.HITs.CauchyReals.Continuous
 -- HoTT (11.3.46)
 sqᵣ' : Σ (ℝ → ℝ) IsContinuous
 sqᵣ'  = (λ r → f r (getClamps r))
-  , λ u ε → 
+  , λ u ε →
      PT.elim2 {P = λ gcr _ →
         ∃[ δ ∈ ℚ₊ ] (∀ v → u ∼[ δ ] v
             → f u gcr ∼[ ε ] (f v (getClamps v)))}
@@ -89,7 +89,7 @@ sqᵣ'  = (λ r → f r (getClamps r))
                         {l = (n' ℕ.+ suc (suc (n' ℕ.+ zero)))} )))
 
             δ = (invℚ₊ L) ℚ₊· ε
-        in ∣ δ , (λ v → 
+        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 →
@@ -107,7 +107,7 @@ sqᵣ'  = (λ r → f r (getClamps r))
                                    (ℚ.0<ℚ₊ ε)
                                      (subst (1 ℤ.<_)
                                        (sym (ℤ.·IdL _))
-                                        1<L )))) 
+                                        1<L ))))
                          zz* = (sym (absᵣNonNeg (absᵣ u +ᵣ rat (fst ε))
                                 (subst (_≤ᵣ (absᵣ u +ᵣ rat (fst ε)))
                                  (+IdR 0)
@@ -139,7 +139,7 @@ sqᵣ'  = (λ r → f r (getClamps r))
                                ((≤ℚ→≤ᵣ _ _ $ ℚ.0≤ℚ₊ ε)))) n'L) nL
                          subst∼[ ℚ₊≡ (ℚ.y·[x/y] L (fst ε)) ]
                          2co (1+ n') (1+ n*) v
-                          
+
                           ((isTrans≤<ᵣ (absᵣ v) _ _
                             zz' n'L))
                             n*L)
@@ -165,7 +165,7 @@ sqᵣ'  = (λ r → f r (getClamps r))
         Δ n = ℚ.<→ℚ₊
              (_//_.[ 1 , 4 ])
              (_//_.[ pos (suc (suc (n))) , 1 ])
-             
+
              ((<Δ (suc (n))))
         q* : ℕ → ℚ
         q* n = ℚ.clamp (ℚ.- (fst (Δ n))) (fst (Δ n)) q
@@ -192,13 +192,13 @@ sqᵣ'  = (λ r → f r (getClamps r))
     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<'
@@ -219,14 +219,14 @@ sqᵣ'  = (λ r → f r (getClamps r))
      Δ = ℚ.<→ℚ₊ q q' q<q'
      θ = ℚ.min₊ (ℚ./3₊ ε) Δ
 
-     3θ≤ε : (fst θ) ℚ.+ ((fst θ) ℚ.+ (fst θ)) ℚ.≤ fst ε 
+     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 Δ))) 
-       
-       
+                (fst (ℚ./3₊ ε)) 3 ((ℚ.0≤ℚ₊ 3)) (ℚ.min≤ (fst (ℚ./3₊ ε)) (fst Δ)))
+
+
      δ = (([ pos (suc (suc n)) / 1+ (suc n⊔) ] , _)
                                     ℚ₊· θ)
      η = (([ pos (suc (suc n')) / 1+ (suc n⊔) ] , _)
@@ -248,7 +248,7 @@ sqᵣ'  = (λ r → f r (getClamps r))
              ([ 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<≤ _ _ _
@@ -279,7 +279,7 @@ sqᵣ'  = (λ r → f r (getClamps r))
                in subst (ℚ._<
                      fst θ ℚ.+ (fst θ ℚ.+ fst θ))
                        (ℚ.+IdL (fst δ ℚ.+ (fst η))) z')
-            
+
                      3θ≤ε))
 
      R' :
@@ -297,7 +297,7 @@ sqᵣ'  = (λ r → f r (getClamps r))
              (fst (invℚ₊ (2 ℚ₊· fromNat (suc (suc n⊔)))))
              (fst (invℚ₊ (2 ℚ₊· fromNat (suc (suc n⊔)))))
              (fst θ))
-             (ℚ.·IdL (fst θ))             
+             (ℚ.·IdL (fst θ))
              ((ℚ.<-·o
                (((fst (invℚ₊ (2 ℚ₊· fromNat (suc (suc n⊔))))))
                 ℚ.+
@@ -306,11 +306,11 @@ sqᵣ'  = (λ r → f r (getClamps r))
               (ℚ.0<ℚ₊ θ)
                (subst (ℚ._< 1)
                  (sym (ℚ.ε/2+ε/2≡ε _) ∙ cong (λ x → x ℚ.+ x)
-                   (ℚ.·Comm _ _ ∙ cong fst 
+                   (ℚ.·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⊓)))
@@ -325,7 +325,7 @@ sqᵣ'  = (λ r → f r (getClamps r))
                             (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⊓ (≤ℚ→≤ᵣ _ _
@@ -350,7 +350,7 @@ sqᵣ'  = (λ r → f r (getClamps r))
      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 → _ → ℝ
@@ -358,8 +358,8 @@ sqᵣ'  = (λ r → f r (getClamps 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') 
+    (f' r)
+    (λ (n , u) (n' , u') → 2co n n' r u u')
 
 sqᵣ : ℝ → ℝ
 sqᵣ = fst sqᵣ'
@@ -392,17 +392,17 @@ sqᵣ-rat = ElimProp.go w
        (λ 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'))
 
@@ -412,7 +412,7 @@ sqᵣ-rat = ElimProp.go w
                ∙ 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
@@ -430,7 +430,7 @@ sqᵣ-rat = ElimProp.go w
 open ℚ.HLP
 
 
-rat·ᵣrat : ∀ r q → rat (r ℚ.· q) ≡ rat r ·ᵣ rat q 
+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 ] ] ]
@@ -462,7 +462,7 @@ IsContinuous·ᵣR x =
 
 IsContinuous·ᵣL : ∀ x → IsContinuous (x ·ᵣ_)
 IsContinuous·ᵣL x = subst IsContinuous
-  (funExt λ z → ·ᵣComm z x) (IsContinuous·ᵣR x) 
+  (funExt λ z → ·ᵣComm z x) (IsContinuous·ᵣR x)
 
 
 
@@ -537,8 +537,8 @@ IsCommRingℝ = CR.makeIsCommRing
 
 
 
-·ᵣMaxDistrPos : ∀ x y z → ℚ.0< z →  (maxᵣ x y) ·ᵣ (rat z) ≡ maxᵣ (x ·ᵣ rat z) (y ·ᵣ rat z)   
-·ᵣMaxDistrPos x y z 0<z = 
+·ᵣ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
@@ -550,7 +550,7 @@ IsCommRingℝ = CR.makeIsCommRing
                                 (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)))                    
+              (cong₂ maxᵣ (rat·ᵣrat x' z) (rat·ᵣrat y' z)))
          y)
      x
 
@@ -603,7 +603,7 @@ IsCommRingℝ = CR.makeIsCommRing
                            ) (ℚ.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') 
+                  (R _ xδ∈P xδ∈P')
                  (θ∼ _ _ (∼-monotone≤
                     ((subst (ℚ._≤ fst θ)
                         (sym (ℚ.ε/2+ε/2≡ε
@@ -623,11 +623,11 @@ IsCommRingℝ = CR.makeIsCommRing
                        (ℚ.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∈') 
+        f' g') (oP (lim x p) x∈) (oP' (lim x p) x∈')
 
  w .Elimℝ-Prop.isPropA _ = isPropΠ2 λ _ _ → isSetℝ _ _
 
@@ -684,20 +684,20 @@ cont₂·ᵣWP P f g fC gC = IsContinuousWP∘' P _
           (contDiagNE₂WP sumR P _ _
             (IsContinuousWP∘' P _ _ IsContinuousSqᵣ fC)
             ((IsContinuousWP∘' P _ _ IsContinuousSqᵣ gC))))))
-    
 
-·-ᵣ : ∀ x y → x ·ᵣ (-ᵣ y) ≡ -ᵣ (x ·ᵣ y)  
+
+·-ᵣ : ∀ x y → x ·ᵣ (-ᵣ y) ≡ -ᵣ (x ·ᵣ y)
 ·-ᵣ x =
   ≡Continuous _ _ (IsContinuous∘ _ _
        (IsContinuous·ᵣL x) IsContinuous-ᵣ)
       (IsContinuous∘ _ _ IsContinuous-ᵣ (IsContinuous·ᵣL x))
-       λ y' → 
+       λ y' →
          ≡Continuous _ _
              (IsContinuous·ᵣR (-ᵣ (rat y')))
               ((IsContinuous∘ _ _ IsContinuous-ᵣ (IsContinuous·ᵣR (rat y'))))
           (λ x' → sym (rat·ᵣrat _ _) ∙∙ cong rat (·- x' y') ∙∙
               (cong -ᵣ_ (rat·ᵣrat _ _)))
-          x 
+          x
 
 
 -ᵣ· : ∀ x y →  ((-ᵣ x) ·ᵣ y) ≡  -ᵣ (x ·ᵣ y)
@@ -706,4 +706,4 @@ cont₂·ᵣWP P f g fC gC = IsContinuousWP∘' P _
 
 _^ⁿ_ : ℝ → ℕ → ℝ
 x ^ⁿ zero = 1
-x ^ⁿ suc n = (x ^ⁿ n) ·ᵣ x 
+x ^ⁿ suc n = (x ^ⁿ n) ·ᵣ x
diff --git a/Cubical/HITs/CauchyReals/Order.agda b/Cubical/HITs/CauchyReals/Order.agda
index 466061042f..d32702d4e2 100644
--- a/Cubical/HITs/CauchyReals/Order.agda
+++ b/Cubical/HITs/CauchyReals/Order.agda
@@ -34,7 +34,7 @@ open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary
 
 open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
 
 open import Cubical.Data.Rationals using (ℚ ; [_/_])
 open import Cubical.Data.Rationals.Order using
@@ -59,17 +59,17 @@ open import Cubical.HITs.CauchyReals.Lipschitz
 
 
 sumR : NonExpanding₂ ℚ._+_
-sumR .NonExpanding₂.cL q r s = 
+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 = 
+sumR .NonExpanding₂.cR q r s =
    ℚ.≡Weaken≤ (ℚ.abs ((q ℚ.+ r) ℚ.- (q ℚ.+ s))) (ℚ.abs (r ℚ.- s))
    (sym $ cong ℚ.abs (lem--037 {r} {s} {q}))
 
 _+ᵣ_ : ℝ → ℝ → ℝ
 _+ᵣ_ = NonExpanding₂.go sumR
 
-+ᵣ-∼ : ∀ u v r ε → u ∼[ ε ] v → (u +ᵣ r) ∼[ ε ] (v +ᵣ r)  
++ᵣ-∼ : ∀ u v r ε → u ∼[ ε ] v → (u +ᵣ r) ∼[ ε ] (v +ᵣ r)
 +ᵣ-∼ u v r =
   NonExpanding₂.go∼L sumR r u v
 
@@ -114,7 +114,7 @@ maxR = w
 
  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) 
+  let s' = ℚ.max s (ℚ.max r q)
   in subst (ℚ._≤ (ℚ.abs (q ℚ.- r)))
        ( cong {x = ℚ.min (ℚ.max s q) s' ℚ.-
                    ℚ.min (ℚ.max s r) s'}
@@ -125,7 +125,7 @@ maxR = w
               (cong (ℚ.min (ℚ.max s r))
                  (cong (ℚ.max s) (ℚ.maxComm r q))
                 ∙ h r q s)) )
-       (ℚ.clampDist s s' r q ) 
+       (ℚ.clampDist s s' r q )
 
  w : NonExpanding₂ ℚ.max
  w .NonExpanding₂.cL = w'
@@ -148,25 +148,25 @@ Lipschitz-ℝ→ℝ-1→NonExpanding f x _ _ _ =
 
 maxᵣComm : ∀ x y → NonExpanding₂.go maxR x y ≡ NonExpanding₂.go maxR y x
 maxᵣComm x y =
-  nonExpanding₂Ext ℚ.max (flip ℚ.max) 
+  nonExpanding₂Ext ℚ.max (flip ℚ.max)
     maxR (NonExpanding₂-flip ℚ.max maxR) ℚ.maxComm x y ∙
    (NonExpanding₂-flip-go ℚ.max maxR
-     (NonExpanding₂-flip ℚ.max maxR) x y )   
+     (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) 
+  nonExpanding₂Ext ℚ.min (flip ℚ.min)
     minR (NonExpanding₂-flip ℚ.min minR) ℚ.minComm x y ∙
    (NonExpanding₂-flip-go ℚ.min minR
-     (NonExpanding₂-flip ℚ.min minR) x y )   
+     (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 ℚ._+_) 
+  nonExpanding₂Ext ℚ._+_ (flip ℚ._+_)
     sumR (NonExpanding₂-flip ℚ._+_ sumR) ℚ.+Comm x y ∙
    (NonExpanding₂-flip-go ℚ._+_ sumR
-     (NonExpanding₂-flip ℚ._+_ sumR) x y )   
+     (NonExpanding₂-flip ℚ._+_ sumR) x y )
 
 
 
@@ -181,25 +181,25 @@ inj-rat q r x with (ℚ.discreteℚ q r)
         (ℚ.absFrom<×< (ℚ.abs (q ℚ.- r)) (q ℚ.- r)
           zz zz'))
 
-≤ℚ→≤ᵣ : ∀ q r → q ℚ.≤ r → rat q ≤ᵣ rat r 
+≤ℚ→≤ᵣ : ∀ 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 → 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 → (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.ratA = cong rat ∘ ℚ.maxIdem
  w .Elimℝ-Prop.limA x p x₁ =
    snd (NonExpanding₂.β-lim-lim/2 maxR x p x p)
     ∙ eqℝ _ _
@@ -216,13 +216,13 @@ maxᵣIdem = Elimℝ-Prop.go w
                          (fst ε ℚ.· 1)
                        (ℚ.<-o· _ _ (fst ε)
                          (ℚ.0<ℚ₊ ε) ℚ.decℚ<?))))
-                  (invEq (∼≃≡  _ _ ) (x₁ (/2₊ (/2₊ ε))) _)  
+                  (invEq (∼≃≡  _ _ ) (x₁ (/2₊ (/2₊ ε))) _)
 
  w .Elimℝ-Prop.isPropA _ = isSetℝ _ _
 
 
 
-≤ᵣ-refl : ∀ x → x ≤ᵣ x 
+≤ᵣ-refl : ∀ x → x ≤ᵣ x
 ≤ᵣ-refl x = maxᵣIdem x
 
 
@@ -239,12 +239,12 @@ isProp≤ᵣ : ∀ x y → isProp (x ≤ᵣ y)
 isProp≤ᵣ _ _ = isSetℝ _ _
 
 
-<ℚ→<ᵣ : ∀ q r → q ℚ.< r → rat q <ᵣ rat r 
+<ℚ→<ᵣ : ∀ 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)) 
+      x' = x ℚ.+ fst (/3₊ (y-x))
       y' = x' ℚ.+ fst (/3₊ (y-x))
   in ∣ (x' , y') ,
           ≤ℚ→≤ᵣ x x' (
@@ -260,13 +260,13 @@ isProp≤ᵣ _ _ = isSetℝ _ _
                  ∙∙
                   cong {x = ℚ.[ 1 / 3 ] ℚ.+ ℚ.[ 1 / 3 ] ℚ.+ ℚ.[ 1 / 3 ]}
                     {1} (λ a → x ℚ.+ a ℚ.· (y ℚ.- x))
-                   ℚ.decℚ? 
+                   ℚ.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 
+<ᵣ→<ℚ : ∀ q r → rat q <ᵣ rat r → q ℚ.< r
 <ᵣ→<ℚ = ElimProp2.go w
  where
  w : ElimProp2 (λ z z₁ → rat z <ᵣ rat z₁ → z ℚ.< z₁)
@@ -278,7 +278,7 @@ isProp≤ᵣ _ _ = isSetℝ _ _
       (ℚ.isTrans≤< _//_.[ x ] x' y' (≤ᵣ→≤ℚ _ _ a) b)
         (≤ᵣ→≤ℚ _ _ c)
 
-<ᵣ≃<ℚ : ∀ q r → (rat q <ᵣ rat r) ≃ (q ℚ.< r) 
+<ᵣ≃<ℚ : ∀ q r → (rat q <ᵣ rat r) ≃ (q ℚ.< r)
 <ᵣ≃<ℚ q r = propBiimpl→Equiv
  squash₁ (ℚ.isProp< _ _)
   (<ᵣ→<ℚ q r) (<ℚ→<ᵣ q r)
@@ -286,22 +286,22 @@ isProp≤ᵣ _ _ = isSetℝ _ _
 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) 
+    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) 
+    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) 
+    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 
+  ∙ 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 =
@@ -318,7 +318,7 @@ isTrans≤<ᵣ x y z u =
    → isTrans≤ᵣ x y _ u v  , v' , v''
 
 isTrans<≤ᵣ : ∀ x y z → x <ᵣ y → y ≤ᵣ z → x <ᵣ z
-isTrans<≤ᵣ x y z = flip λ u → 
+isTrans<≤ᵣ x y z = flip λ u →
  PT.map $ map-snd λ (v , v' , v'')
    → v  , v' , isTrans≤ᵣ _ y z v'' u
 
@@ -350,8 +350,8 @@ open ℚ.HLP
  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₁ ε = 
-  
+ 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∼
@@ -366,7 +366,7 @@ open ℚ.HLP
 
 
 
-abs-dist : ∀ q r → ℚ.abs (ℚ.abs' q ℚ.- ℚ.abs' r) ℚ.≤ ℚ.abs (q ℚ.- r) 
+abs-dist : ∀ q r → ℚ.abs (ℚ.abs' q ℚ.- ℚ.abs' r) ℚ.≤ ℚ.abs (q ℚ.- r)
 abs-dist =
   ℚ.elimBy≡⊎<'
     (λ x y → subst2 ℚ._≤_ (ℚ.absComm- _ _) (ℚ.absComm- _ _))
@@ -375,7 +375,7 @@ abs-dist =
       (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
@@ -406,7 +406,7 @@ abs-dist =
             (ℚ.- ℚ.abs' (x ℚ.+ fst ε))
             (ℚ.abs+≤abs+abs (x ℚ.+ fst ε) (ℚ.- (fst ε))))))
 
- 
+
 
 absᵣL : Σ _ _
 absᵣL = fromLipschitz 1 (rat ∘ ℚ.abs' , h )
@@ -415,10 +415,10 @@ absᵣL = fromLipschitz 1 (rat ∘ ℚ.abs' , h )
  h q r ε x x₁ = subst∼ {ε = ε} (sym (ℚ.·IdL (fst ε)))
     (rat-rat-fromAbs _ _ _ (
       ℚ.isTrans≤< _ _ (fst ε) ((abs-dist q r))
-        (ℚ.absFrom<×< (fst ε) (q ℚ.- r) x x₁))) 
-    
+        (ℚ.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
@@ -451,16 +451,16 @@ maxᵣ-lem u v r ε xx x =
 ℚ₊→ℝ₊ : ℚ₊ → ℝ₊
 ℚ₊→ℝ₊ (x , y) = rat x , <ℚ→<ᵣ 0 x (ℚ.0<→< x y)
 
-decℚ<ᵣ? : ∀ {x y} → {𝟚.True (ℚ.<Dec x y)} →  (rat x <ᵣ rat y) 
+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} → {𝟚.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 } 
+     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
index fd4b92f5cd..b6497a7aca 100644
--- a/Cubical/HITs/CauchyReals/Sequence.agda
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -37,7 +37,7 @@ open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary
 
 open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_) 
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
 
 open import Cubical.Data.Rationals using (ℚ ; [_/_])
 open import Cubical.Data.Rationals.Order using
@@ -81,7 +81,7 @@ open import Cubical.HITs.CauchyReals.Inverse
 import Cubical.Algebra.CommRing as CR
 import Cubical.Algebra.Ring as RP
 
-               
+
 Seq : Type
 Seq = ℕ → ℝ
 
@@ -131,15 +131,15 @@ Seq = ℕ → ℝ
                ℚ₊· (r' , ℚ.<→0< _ 0<r')
     in (fst (/2₊ qr₊) , fst qr₊) ,
          ≤ℚ→≤ᵣ _ _ (ℚ.0≤ℚ₊ (/2₊ qr₊)) ,
-           x/2<x qr₊ , 
+           x/2<x qr₊ ,
            subst (_≤ᵣ (m ·ᵣ n))
              (sym (rat·ᵣrat q' r'))
               (≤ᵣ₊Monotone·ᵣ (rat q')
                 (m , 0<m) (rat r' , <ℚ→<ᵣ _ _ 0<r') n
-                             q'≤m r'≤n) ) 0<m 0<n    
+                             q'≤m r'≤n) ) 0<m 0<n
 
 
-_₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊ 
+_₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊
 (q , 0<q) ₊／ᵣ₊ (r , 0<r) = (q ／ᵣ[ r , inl (0<r) ] ,
   ℝ₊· (q , 0<q) (_ , invℝ-pos r 0<r) )
 
@@ -152,14 +152,14 @@ _₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊
   (_ , 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 = 
+<ᵣ-·ᵣ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 = 
+<ᵣ-o·ᵣ m n (o , 0<o) p =
   subst2 (_<ᵣ_)
     (·ᵣComm _ _) (·ᵣComm _ _) (<ᵣ-·ᵣo m n (o , 0<o) p)
 
@@ -177,7 +177,7 @@ _₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊
         ∙ cong ((q ℚ.· [ 1 / n ]) ℚ.+_)
             (sym (ℚ.·Assoc -1 r [ 1 / n ]))))
       (ℚ.<-o· (ℚ.abs (q ℚ.- r)) (fst ε) [ 1 / n ]
-       ((ℚ.0<→< [ 1 / n ] _)) 
+       ((ℚ.0<→< [ 1 / n ] _))
        x)))
 
 
@@ -185,9 +185,9 @@ 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 n → seqSumUpTo s n ·ᵣ r ≡ seqSumUpTo ((_·ᵣ r) ∘ s) n
 seqSumUpTo· s r zero = 𝐑'.0LeftAnnihilates r
-seqSumUpTo· s r (suc n) = 
+seqSumUpTo· s r (suc n) =
   ·DistR+ (s zero) (seqSumUpTo (s ∘ suc) n) r ∙
    cong ((s zero ·ᵣ r) +ᵣ_) (seqSumUpTo· (s ∘ suc) r n)
 
@@ -195,7 +195,7 @@ seqSumUpTo· s r (suc n) =
 
 seqSumUpTo' : (ℕ → ℝ) → ℕ →  ℝ
 seqSumUpTo' s zero = 0
-seqSumUpTo' s (suc n) = seqSumUpTo' s n +ᵣ s n 
+seqSumUpTo' s (suc n) = seqSumUpTo' s n +ᵣ s n
 
 seqΣ : Seq → Seq
 seqΣ = seqSumUpTo'
@@ -206,10 +206,10 @@ 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 zero = +ᵣComm _ _
 seqSumUpTo-suc f (suc n) =
   sym (+ᵣAssoc _ _ _) ∙
-    cong ((f zero) +ᵣ_ ) (seqSumUpTo-suc _ _) 
+    cong ((f zero) +ᵣ_ ) (seqSumUpTo-suc _ _)
 
 seqSumUpTo≡seqSumUpTo' : ∀ f n → seqSumUpTo' f n ≡ seqSumUpTo f n
 seqSumUpTo≡seqSumUpTo' f zero = refl
@@ -225,10 +225,10 @@ seqSumUpTo≡seqSumUpTo' f (suc 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 → 0 ℕ.< (ℕ.quotient (2 ℕ.+ n) / 2)
 2≤x→1<quotient[x/2] n =
- let z : 0 ℕ.< 
+ let z : 0 ℕ.<
              ((ℕ.quotient (2 ℕ.+ n) / 2) ℕ.· 2)
      z = subst (0 ℕ.<_) (ℕ.·-comm _ _)
           (ℕ.≤<-trans ℕ.zero-≤ (ℕ.<-k+-cancel (subst (ℕ._< 2 ℕ.+
@@ -243,10 +243,10 @@ seqSumUpTo≡seqSumUpTo' f (suc n) =
 open ℕ.Minimal
 
 log2ℕ : ∀ n → Σ _ (Least (λ k → n ℕ.< 2 ^ k))
-log2ℕ n = w n n ℕ.≤-refl 
+log2ℕ n = w n n ℕ.≤-refl
  where
-   
-  w : ∀ N n → n ℕ.≤ N 
+
+  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 ,
@@ -281,7 +281,7 @@ log2ℕ n = w n n ℕ.≤-refl
                     (subst2 ℕ._<_ (ℕ.·-comm _ _) (ℕ.·-comm _ _)
                       (ℕ.≤<-trans (_ , z)
                          2+n<2^k' )))}
-    
+
 
 
 
@@ -307,7 +307,7 @@ 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) = 
+geometricProgression-suc a r (suc n) =
   cong (_·ᵣ r) (geometricProgression-suc a r n)
 
 
@@ -325,7 +325,7 @@ Sₙ-suc a r n = cong (a +ᵣ_) (sym (seqSumUpTo· (geometricProgression a r) r
 
 
 SₙLem' : ∀ a n r → (Sₙ a r n) ·ᵣ (1 +ᵣ (-ᵣ r))  ≡
-                   a ·ᵣ (1 +ᵣ (-ᵣ (r ^ⁿ n)))  
+                   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))
@@ -352,7 +352,7 @@ SₙLem' a n r =
 SₙLem : ∀ a r (0＃1-r : 0 ＃ (1 +ᵣ (-ᵣ r))) n →
               (Sₙ a r n)   ≡
                    a ·ᵣ ((1 +ᵣ (-ᵣ (r ^ⁿ n)))
-                     ／ᵣ[ (1 +ᵣ (-ᵣ r)) , 0＃1-r ])  
+                     ／ᵣ[ (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))))
@@ -373,10 +373,10 @@ Sₙ-sup a r n a<0 0<r r<1  =
                (<ᵣ-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)  
+   ∀ 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+ᵣ _ _ _ _
@@ -384,23 +384,23 @@ Seq<→Σ< s s' x (suc n) = <ᵣMonotone+ᵣ _ _ _ _
 
 Seq≤→Σ≤ : (s s' : Seq) →
   (∀ n → s n ≤ᵣ s' n) →
-   ∀ n → seqSumUpTo s n ≤ᵣ seqSumUpTo 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  
+   ∀ n → seqSumUpTo' s n ≤ᵣ seqSumUpTo' s' n
 Seq'≤→Σ≤ s s' x zero = ≤ᵣ-refl _
 Seq'≤→Σ≤ s s' x (suc n) =
- ≤ᵣMonotone+ᵣ _ _ _ _ 
+ ≤ᵣ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) = 
+0≤seqΣ s x (suc n) =
   ≤ᵣMonotone+ᵣ _ _ _ _ (0≤seqΣ s x n) (x n)
 
 seriesDiff : (s : Seq)  →
@@ -423,12 +423,12 @@ IsCauchySequence s =
 IsConvSeries : Seq → Type
 IsConvSeries s =
     ∀ (ε : ℝ₊) →
-     Σ[ N ∈ ℕ ] ∀ n m → 
-       absᵣ (seqΣ (s ∘ (ℕ._+ (n ℕ.+ (suc N)))) m) <ᵣ fst ε  
+     Σ[ N ∈ ℕ ] ∀ n m →
+       absᵣ (seqΣ (s ∘ (ℕ._+ (n ℕ.+ (suc N)))) m) <ᵣ fst ε
 
 
 IsoIsConvSeriesIsCauchySequenceSum : (s : Seq) →
-  Iso (IsConvSeries s) (IsCauchySequence (seqΣ s)) 
+  Iso (IsConvSeries s) (IsCauchySequence (seqΣ s))
 IsoIsConvSeriesIsCauchySequenceSum s =
    codomainIsoDep λ ε →
      Σ-cong-iso-snd λ N →
@@ -452,11 +452,11 @@ IsoIsConvSeriesIsCauchySequenceSum s =
                (f (n ℕ.+ (suc N)) (m ℕ.+ (n ℕ.+ suc N))
                (subst (N ℕ.<_) (sym (ℕ.+-assoc _ _ _))
                  (ℕ.≤SumRight {suc N} {m ℕ.+ n}))
-               (ℕ.≤SumRight {suc N} {n})) 
+               (ℕ.≤SumRight {suc N} {n}))
 
 
 IsConvSeries≃IsCauchySequenceSum : (s : Seq) →
-  IsConvSeries s ≃ IsCauchySequence (seqΣ s) 
+  IsConvSeries s ≃ IsCauchySequence (seqΣ s)
 IsConvSeries≃IsCauchySequenceSum s =
   isoToEquiv (IsoIsConvSeriesIsCauchySequenceSum s)
 
@@ -467,7 +467,7 @@ isCauchyAprox f = (δ ε : ℚ₊) →
   (absᵣ (f δ +ᵣ (-ᵣ  f ε)) <ᵣ rat (fst (δ ℚ₊+ ε)))
 
 lim' : ∀ x → isCauchyAprox x → ℝ
-lim' x y = lim x λ δ ε  → (invEq (∼≃abs<ε _ _ _)) (y δ ε)  
+lim' x y = lim x λ δ ε  → (invEq (∼≃abs<ε _ _ _)) (y δ ε)
 
 
 fromCauchySequence : ∀ s → IsCauchySequence s → ℝ
@@ -491,7 +491,7 @@ fromCauchySequence s ics =
               ℕ.≤-refl  (ℕ.suc-≤-suc δₙ≤εₙ )
    in isTrans<ᵣ (absᵣ (x δ +ᵣ (-ᵣ x ε)))
            (rat (fst (δ))) (rat (fst (δ ℚ₊+ ε)))
-           z (<ℚ→<ᵣ _ _ (ℚ.<+ℚ₊' (fst δ) (fst δ) ε (ℚ.isRefl≤ (fst δ)))) 
+           z (<ℚ→<ᵣ _ _ (ℚ.<+ℚ₊' (fst δ) (fst δ) ε (ℚ.isRefl≤ (fst δ))))
   ww (inr εₙ<δₙ) =
     let z = snd (ics (ℚ₊→ℝ₊ ε)) (suc εₙ) (suc δₙ)
                (ℕ.≤-suc εₙ<δₙ) ℕ.≤-refl
@@ -502,7 +502,7 @@ fromCauchySequence s ics =
                (ℚ.<+ℚ₊' (fst ε) (fst ε) δ (ℚ.isRefl≤ (fst ε))))))
 
 limₙ→∞_is_ : Seq → ℝ → Type
-limₙ→∞ s is x = 
+limₙ→∞ s is x =
   ∀ (ε : ℝ₊) → Σ[ N ∈ ℕ ]
     (∀ n → N ℕ.< n →
       absᵣ ((s n) +ᵣ (-ᵣ x)) <ᵣ (fst ε))
@@ -510,4 +510,4 @@ limₙ→∞ s is x =
 
 
 Limₙ→∞ : Seq → Type
-Limₙ→∞ s = Σ _ (limₙ→∞ s is_) 
+Limₙ→∞ s = Σ _ (limₙ→∞ s is_)
diff --git a/Cubical/HITs/SetQuotients/Properties.agda b/Cubical/HITs/SetQuotients/Properties.agda
index b741a97e7c..abee1c3f3c 100644
--- a/Cubical/HITs/SetQuotients/Properties.agda
+++ b/Cubical/HITs/SetQuotients/Properties.agda
@@ -360,8 +360,8 @@ record Rec {A : Type ℓ} {R : A → A → Type ℓ'} (B : Type ℓ'') :
  field
   isSetB : isSet B
   f : A → B
-  f∼ : ∀ a a' → R a a' → f a ≡ f a' 
-  
+  f∼ : ∀ a a' → R a a' → f a ≡ f a'
+
 
  go : _ / R → B
  go [ a ] = f a
@@ -376,8 +376,8 @@ record Elim {A : Type ℓ} {R : A → A → Type ℓ'} (B : A / R →  Type ℓ'
  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') 
-  
+  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
@@ -393,7 +393,7 @@ record ElimProp {A : Type ℓ} {R : A → A → Type ℓ'} (B : A / R →  Type
  field
   isPropB : ∀ x → isProp (B x)
   f : ∀ x → B [ x ]
-  
+
  go : ∀ x → B x
  go = Elim.go w
   where
@@ -412,8 +412,8 @@ record Rec2 {A : Type ℓ} {R : A → A → Type ℓ'} (B : Type ℓ'') :
   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
@@ -424,7 +424,7 @@ record Rec2 {A : Type ℓ} {R : A → A → Type ℓ'} (B : Type ℓ'') :
      where
       w' : Rec _
       w' .Rec.isSetB = isSetB
-      w' .Rec.f x' = f x x' 
+      w' .Rec.f x' = f x x'
       w' .Rec.f∼ = f∼ x
   w .Rec.f∼ a a' r = funExt
     (ElimProp.go w')
@@ -440,12 +440,12 @@ record ElimProp2 {A : Type ℓ} {R : A → A → Type ℓ'} (B : A / R → A / R
  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.isPropB _ = isPropΠ λ _ → isPropB _ _
   w .ElimProp.f x = ElimProp.go w'
    where
    w' : ElimProp (λ z → B [ x ] z)
@@ -460,7 +460,7 @@ record ElimProp3 {A : Type ℓ} {R : A → A → Type ℓ'}
  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

From 6d82e88d69e2fc27d9c1f092db81dd5a535f69b1 Mon Sep 17 00:00:00 2001
From: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date: Sun, 19 Jan 2025 03:53:55 +0100
Subject: [PATCH 03/11] wip

---
 Cubical/HITs/CauchyReals/Derivative.agda     | 100 ++++++++++++++++---
 Cubical/HITs/CauchyReals/Inverse.agda        |  25 +++++
 Cubical/HITs/CauchyReals/Multiplication.agda |   8 ++
 Cubical/HITs/CauchyReals/Order.agda          |   7 ++
 Cubical/HITs/CauchyReals/Sequence.agda       |   2 +
 5 files changed, 128 insertions(+), 14 deletions(-)

diff --git a/Cubical/HITs/CauchyReals/Derivative.agda b/Cubical/HITs/CauchyReals/Derivative.agda
index 4082c43f78..44854dc7ef 100644
--- a/Cubical/HITs/CauchyReals/Derivative.agda
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -105,26 +105,53 @@ const-lim C x ε = ∣ (1 , decℚ<ᵣ?) ,
 id-lim : ∀ x → at x limitOf (λ r _ → r) is x
 id-lim x ε = ∣ ε , (λ r x＃r p → p )  ∣₁
 
-_$[_]$_ : {x : ℝ}
+_$[_]$_ : (ℝ → ℝ)
+        → (ℝ → ℝ → ℝ)
+        → (ℝ → ℝ)
+        → (ℝ → ℝ)
+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)
+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)
+        → 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 {!u!})
-    (fL (ε ₊／ᵣ₊ 2))
-     (gL (ε ₊／ᵣ₊ 2))
+         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.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 {!!})
+    (fL ε)
+     (gL ε)
+
 
 At_limitOf_ : (x : ℝ) → (∀ r → x ＃ r → ℝ) → Type
 At x limitOf f = Σ _ (at x limitOf f is_)
@@ -155,10 +182,55 @@ idDerivative x =  subst (at 0 limitOf_is 1)
     cong (_·ᵣ (invℝ r 0＃r)) (sym (L𝐑.lem--063)))
    (const-lim 1 0)
 
-
-
--- derivative-^ⁿ : ∀ n x →
---    derivativeOf (_^ⁿ (suc n)) at x is (fromNat n ·ᵣ (x ^ⁿ n))
--- derivative-^ⁿ zero x ε = {!!}
--- derivative-^ⁿ (suc n) x ε = {!!}
++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 = {!!}
+
+·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) +ᵣ (f x) ·ᵣ g'x)
+·Derivative x f f'x g g'x F G =
+   let z = +Derivative x {!!} (f'x ·ᵣ (g x))
+                          {!!} ((f x) ·ᵣ g'x)
+                           {!substDer ?
+                              (C·Derivative (g x) x f f'x F)!}
+                           (C·Derivative (f x) x g g'x G)
+   in {!!}
+   -- let z = {!subst {x = (differenceAt f x) #[ _+ᵣ_ ]$ (differenceAt g x)}
+   --          {y = (differenceAt (f $[ _+ᵣ_ ]$ g) x)}
+   --    (at 0 limitOf_is (f'x +ᵣ g'x))!}
+   -- in {!!}
+
+-- -- derivative-^ⁿ : ∀ n x →
+-- --    derivativeOf (_^ⁿ (suc n)) at x is (fromNat n ·ᵣ (x ^ⁿ n))
+-- -- derivative-^ⁿ zero x ε = {!!}
+-- -- derivative-^ⁿ (suc n) x ε = {!!}
 
diff --git a/Cubical/HITs/CauchyReals/Inverse.agda b/Cubical/HITs/CauchyReals/Inverse.agda
index eadb4162a8..770f9b103b 100644
--- a/Cubical/HITs/CauchyReals/Inverse.agda
+++ b/Cubical/HITs/CauchyReals/Inverse.agda
@@ -642,6 +642,23 @@ minDistMaxᵣ x y y' = ≡Continuous _ _
 ℝ₊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₁))
@@ -1133,3 +1150,11 @@ x·y≡z→x≡z/y : ∀ x q r → (0＃r : 0 ＃ r)
                → 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/Multiplication.agda b/Cubical/HITs/CauchyReals/Multiplication.agda
index 8244a1524d..20acbe5801 100644
--- a/Cubical/HITs/CauchyReals/Multiplication.agda
+++ b/Cubical/HITs/CauchyReals/Multiplication.agda
@@ -379,6 +379,9 @@ sqᵣ = fst sqᵣ'
 
 /2ᵣ = fst /2ᵣ-L
 
+
+infixl 7 _·ᵣ_
+
 _·ᵣ_ : ℝ → ℝ → ℝ
 u ·ᵣ v = /2ᵣ ((sqᵣ (u +ᵣ v)) +ᵣ (-ᵣ (sqᵣ u +ᵣ sqᵣ v)))
 
@@ -524,6 +527,7 @@ IsContinuous·ᵣL x = subst IsContinuous
                     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
@@ -700,6 +704,10 @@ cont₂·ᵣWP P f g fC gC = IsContinuousWP∘' P _
           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 _ _)
 
diff --git a/Cubical/HITs/CauchyReals/Order.agda b/Cubical/HITs/CauchyReals/Order.agda
index d32702d4e2..41264beacc 100644
--- a/Cubical/HITs/CauchyReals/Order.agda
+++ b/Cubical/HITs/CauchyReals/Order.agda
@@ -66,6 +66,10 @@ 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
 
@@ -451,6 +455,9 @@ maxᵣ-lem u v r ε xx x =
 ℚ₊→ℝ₊ : ℚ₊ → ℝ₊
 ℚ₊→ℝ₊ (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})
 
diff --git a/Cubical/HITs/CauchyReals/Sequence.agda b/Cubical/HITs/CauchyReals/Sequence.agda
index b6497a7aca..0e1ef73c3f 100644
--- a/Cubical/HITs/CauchyReals/Sequence.agda
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -138,6 +138,8 @@ Seq = ℕ → ℝ
                 (m , 0<m) (rat r' , <ℚ→<ᵣ _ _ 0<r') n
                              q'≤m r'≤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) ] ,

From 91f837ca32b0a5c3e762dace1a9b0cc6e63fb33b Mon Sep 17 00:00:00 2001
From: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date: Mon, 20 Jan 2025 17:36:29 +0100
Subject: [PATCH 04/11] derivative

---
 Cubical/Data/Rationals/Order/Properties.agda  |   7 +-
 Cubical/HITs/CauchyReals/Derivative.agda      | 212 ++++++++++++++----
 Cubical/HITs/CauchyReals/Inverse.agda         | 155 +++++++------
 Cubical/HITs/CauchyReals/Lems.agda            |   9 +-
 Cubical/HITs/CauchyReals/Multiplication.agda  |   5 +-
 Cubical/HITs/CauchyReals/Order.agda           |  13 ++
 Cubical/HITs/CauchyReals/Sequence.agda        | 127 ++++++++---
 .../PropositionalTruncation/Properties.agda   |   5 +-
 8 files changed, 386 insertions(+), 147 deletions(-)

diff --git a/Cubical/Data/Rationals/Order/Properties.agda b/Cubical/Data/Rationals/Order/Properties.agda
index ae3a1301f5..a899394064 100644
--- a/Cubical/Data/Rationals/Order/Properties.agda
+++ b/Cubical/Data/Rationals/Order/Properties.agda
@@ -1235,7 +1235,12 @@ getPosRatio L₁ L₂ =
            (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' →
diff --git a/Cubical/HITs/CauchyReals/Derivative.agda b/Cubical/HITs/CauchyReals/Derivative.agda
index 44854dc7ef..d7d6b920d9 100644
--- a/Cubical/HITs/CauchyReals/Derivative.agda
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -1,4 +1,4 @@
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --lossy-unification #-} 
 
 module Cubical.HITs.CauchyReals.Derivative where
 
@@ -84,19 +84,36 @@ import Cubical.Algebra.Ring as RP
 
 
 
--- Rℝ = (CR.CommRing→Ring
---                (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ))
--- -- module CRℝ = ?
-
--- module 𝐑 = CR.CommRingTheory (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ)
--- module 𝐑' = RP.RingTheory Rℝ
-
-
 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 ε)
 
+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)
+
+IsContinuousLim : ∀ f x → IsContinuous f →
+                    at x limitOf (λ r _ → f r) is (f x)
+IsContinuousLim f x cx = uncurry
+  λ ε → (PT.rec squash₁
+   λ (q , 0<q , q<ε) →
+     PT.map (λ (δ , X) →
+       (ℚ₊→ℝ₊ δ) ,
+         λ r 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 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ℚ<ᵣ?) ,
@@ -142,23 +159,100 @@ f #[ _op_ ]$ g = λ r x → (f r x) op (g r x)
         → 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 {!!})
-    (fL ε)
-     (gL ε)
-
+·-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 ]
 
@@ -210,27 +304,67 @@ C·Derivative C x f f'x F =
 substDer : ∀ {x f' f g} → (∀ r → f r ≡ g r) 
      → derivativeOf f at x is f'
      → derivativeOf g at x is f'
-substDer = {!!}
+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 F G =
-   let z = +Derivative x {!!} (f'x ·ᵣ (g x))
-                          {!!} ((f x) ·ᵣ g'x)
-                           {!substDer ?
-                              (C·Derivative (g x) x f f'x F)!}
-                           (C·Derivative (f x) x g g'x G)
-   in {!!}
-   -- let z = {!subst {x = (differenceAt f x) #[ _+ᵣ_ ]$ (differenceAt g x)}
-   --          {y = (differenceAt (f $[ _+ᵣ_ ]$ g) x)}
-   --    (at 0 limitOf_is (f'x +ᵣ g'x))!}
-   -- in {!!}
-
--- -- derivative-^ⁿ : ∀ n x →
--- --    derivativeOf (_^ⁿ (suc n)) at x is (fromNat n ·ᵣ (x ^ⁿ n))
--- -- derivative-^ⁿ zero x ε = {!!}
--- -- derivative-^ⁿ (suc n) 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)  
+
+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))
+ 
diff --git a/Cubical/HITs/CauchyReals/Inverse.agda b/Cubical/HITs/CauchyReals/Inverse.agda
index 770f9b103b..bb8b50bc08 100644
--- a/Cubical/HITs/CauchyReals/Inverse.agda
+++ b/Cubical/HITs/CauchyReals/Inverse.agda
@@ -485,13 +485,14 @@ isSym＃ _ _ = fst ⊎-swap-≃
   subst (rat 0 <ᵣ_) (cong absᵣ (+IdR r))
     (fst (＃≃0<dist r 0) (isSym＃ 0 r 0＃r))
 
-≤ᵣ-·o : ∀ m n (o : ℚ₊) →  m ≤ᵣ n → (m ·ᵣ rat (fst o) ) ≤ᵣ (n ·ᵣ rat (fst o))
-≤ᵣ-·o m n o p = sym (·ᵣMaxDistrPos m n (fst o) (snd o)) ∙
-  cong (_·ᵣ rat (fst o)) p
+≤ᵣ-·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 : ℚ₊) →  m ≤ᵣ n → (rat (fst o) ·ᵣ m ) ≤ᵣ (rat (fst o) ·ᵣ n)
-≤ᵣ-o· m n o p =
-    cong₂ maxᵣ (·ᵣComm _ _ ) (·ᵣComm _ _ ) ∙ ≤ᵣ-·o m n o p ∙ ·ᵣComm _ _
+
+≤ᵣ-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 = {!!}
@@ -729,8 +730,9 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
                          ∙ (cong rat (𝟚.toWitness {Q = ℚ.discreteℚ
                            ([ 1 / 2 ] ℚ.· 2) 1} tt))) ∙∙
                       ·IdR _ )
-                   (≤ᵣ-·o _ _ 2 (isTrans≤ᵣ _ _ _
-                   limRestr'' (≤ᵣ-·o _ _ ([ 1 / 2 ] , _) zz)))
+                   (≤ᵣ-·o _ _ 2 (ℚ.decℚ≤? {0} {2}) (isTrans≤ᵣ _ _ _
+                   limRestr'' (≤ᵣ-·o _ _ [ 1 / 2 ] (ℚ.decℚ≤? {0} {[ 1 / 2 ]})
+                         zz)))
 
 
            limRestr : rat (fst σ⊔)
@@ -957,8 +959,6 @@ signᵣ-rat r (inr x) = cong rat (sym (snd (snd (ℚ.<→sign r)) (<ᵣ→<ℚ _
 0＃ₚ r = 0 ＃ r , isProp＃ _ _
 
 -- HoTT Theorem (11.3.47)
-invℝ : ∀ r → 0 ＃ r → ℝ
-invℝ r 0＃r = signᵣ r 0＃r ·ᵣ fst invℝ' (absᵣ r) (0＃→0<abs r 0＃r)
 
 IsContinuousWithPredSignᵣ : IsContinuousWithPred 0＃ₚ signᵣ
 IsContinuousWithPredSignᵣ u ε =
@@ -987,20 +987,7 @@ IsContinuousWithPredSignᵣ u ε =
                   (λ _ → refl∼ _ _) v∈P)
              (denseℚinℝ u 0 u<0))
 
-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 _ _)
 
 -ᵣ≡[-1·ᵣ] : ∀ x → -ᵣ x ≡ (-1) ·ᵣ x
 -ᵣ≡[-1·ᵣ] = ≡Continuous _ _
@@ -1009,22 +996,6 @@ invℝ-rat q p p' =
    λ r → 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)
-
-
 openPred< : ∀ x → ⟨ openPred (λ y → (x <ᵣ y) , squash₁)  ⟩
 openPred< x y =
      PT.map (map-snd (λ {q} a<y-x v
@@ -1069,27 +1040,6 @@ isOpenPred0＃ x =
             (r , ℚ.<→0< _ (<ᵣ→<ℚ _ _ r∈)))) 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
-
 sign²=1 :  ∀ r 0＃r → (signᵣ r 0＃r) ·ᵣ (signᵣ r 0＃r) ≡ 1
 sign²=1 r = ⊎.elim
     (λ _ → sym (rat·ᵣrat _ _))
@@ -1109,14 +1059,83 @@ sign·absᵣ r = ∘diag $
           ∙ cong rat (cong (ℚ._· ℚ.sign r) (sym (ℚ.abs'≡abs r))
            ∙ ℚ.sign·abs r) ) 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))
+
+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)
diff --git a/Cubical/HITs/CauchyReals/Lems.agda b/Cubical/HITs/CauchyReals/Lems.agda
index 5919f2c711..e5cf68edca 100644
--- a/Cubical/HITs/CauchyReals/Lems.agda
+++ b/Cubical/HITs/CauchyReals/Lems.agda
@@ -252,7 +252,14 @@ module Lems (R : CR.CommRing ℓ-zero) where
  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 ℚ
 
 
diff --git a/Cubical/HITs/CauchyReals/Multiplication.agda b/Cubical/HITs/CauchyReals/Multiplication.agda
index 20acbe5801..5fcab18379 100644
--- a/Cubical/HITs/CauchyReals/Multiplication.agda
+++ b/Cubical/HITs/CauchyReals/Multiplication.agda
@@ -541,7 +541,7 @@ IsCommRingℝ = CR.makeIsCommRing
 
 
 
-·ᵣMaxDistrPos : ∀ x y z → ℚ.0< z →  (maxᵣ x y) ·ᵣ (rat z) ≡ maxᵣ (x ·ᵣ rat z) (y ·ᵣ rat z)
+·ᵣ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))
@@ -553,7 +553,7 @@ IsCommRingℝ = CR.makeIsCommRing
          ((IsContinuous∘ _ _ (IsContinuousMaxL (rat x' ·ᵣ (rat z)))
                                 (IsContinuous·ᵣR (rat z))))
          (λ y' → sym (rat·ᵣrat _ _)
-             ∙∙ cong rat (ℚ.·MaxDistrℚ x' y' z 0<z) ∙∙
+             ∙∙ cong rat (ℚ.·MaxDistrℚ' x' y' z 0<z) ∙∙
               (cong₂ maxᵣ (rat·ᵣrat x' z) (rat·ᵣrat y' z)))
          y)
      x
@@ -703,7 +703,6 @@ cont₂·ᵣWP P f g fC gC = IsContinuousWP∘' P _
               (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) +ᵣ_) (·-ᵣ _ _)
 
diff --git a/Cubical/HITs/CauchyReals/Order.agda b/Cubical/HITs/CauchyReals/Order.agda
index 41264beacc..7879d3e97e 100644
--- a/Cubical/HITs/CauchyReals/Order.agda
+++ b/Cubical/HITs/CauchyReals/Order.agda
@@ -326,6 +326,19 @@ 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₁ →
diff --git a/Cubical/HITs/CauchyReals/Sequence.agda b/Cubical/HITs/CauchyReals/Sequence.agda
index 0e1ef73c3f..4f83e29a10 100644
--- a/Cubical/HITs/CauchyReals/Sequence.agda
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -81,43 +81,74 @@ open import Cubical.HITs.CauchyReals.Inverse
 import Cubical.Algebra.CommRing as CR
 import Cubical.Algebra.Ring as RP
 
+·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
 
 Seq : Type
 Seq = ℕ → ℝ
 
 
-
-
-≤ᵣ-·ᵣo : ∀ m n (o : ℝ₊) →  m ≤ᵣ n → (m ·ᵣ (fst o) ) ≤ᵣ (n ·ᵣ (fst o))
-≤ᵣ-·ᵣo m n o p =
-  ≡ContinuousWithPred _ _
-     (openPred< 0) (openPred< 0)
-     (λ o _ → maxᵣ (m ·ᵣ o) (n ·ᵣ o) )
-     (λ o _ → n ·ᵣ o)
-     (contDiagNE₂WP maxR _
-        _ _
-       (cont₂·ᵣWP _ _ _ ((AsContinuousWithPred _ _ (IsContinuousConst _)))
-          (AsContinuousWithPred _ _ (IsContinuousId)))
-       ((cont₂·ᵣWP _ _ _ (AsContinuousWithPred _ _ (IsContinuousConst _))
-         (AsContinuousWithPred _ _ (IsContinuousId)))))
-     ((cont₂·ᵣWP _ _ _ (AsContinuousWithPred _ _ (IsContinuousConst _))
-       (AsContinuousWithPred _ _ (IsContinuousId))))
-     (λ r 0<r _ → ≤ᵣ-·o m n (r , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<r)) p)
-       (fst o) (snd o) (snd o)
-
-
-≤ᵣ-o·ᵣ : ∀ m n (o : ℝ₊) →  m ≤ᵣ n → ((fst o) ·ᵣ m   ) ≤ᵣ ((fst o) ·ᵣ n)
-≤ᵣ-o·ᵣ m n o p = subst2 _≤ᵣ_
+≤ᵣ-·ᵣ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 p)
+  (≤ᵣ-·ᵣo m n o 0≤o p)
 
-≤ᵣ₊Monotone·ᵣ : ∀ m (n : ℝ₊) (o : ℝ₊) s
-       → m ≤ᵣ (fst n) → fst o ≤ᵣ s
-       → (m ·ᵣ fst o) ≤ᵣ (fst n ·ᵣ s)
-≤ᵣ₊Monotone·ᵣ m (n , 0<n) (o , 0<o) s m≤n o≤s =
-  isTrans≤ᵣ _ _ _ (≤ᵣ-·ᵣo m n (o , 0<o) m≤n)
-    (≤ᵣ-o·ᵣ o s (n , 0<n) o≤s)
+≤ᵣ₊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)
 
 
 
@@ -133,11 +164,15 @@ Seq = ℕ → ℝ
          ≤ℚ→≤ᵣ _ _ (ℚ.0≤ℚ₊ (/2₊ qr₊)) ,
            x/2<x qr₊ ,
            subst (_≤ᵣ (m ·ᵣ n))
-             (sym (rat·ᵣrat q' r'))
-              (≤ᵣ₊Monotone·ᵣ (rat q')
-                (m , 0<m) (rat r' , <ℚ→<ᵣ _ _ 0<r') 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)
 
@@ -149,9 +184,9 @@ _₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊
 
 
 0<1/x : ∀ x 0＃x → 0 <ᵣ x → 0 <ᵣ invℝ x 0＃x
-0<1/x x 0＃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))
+  (_ , 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 =
@@ -167,6 +202,30 @@ _₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊
 
 
 
+<ᵣ₊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ᵣ : ℕ₊₁ → ℝ → ℝ
 /nᵣ n = fst (fromLipschitz ([ 1 / n ] , _)
   (_ , Lipschitz-rat∘ ([ 1 / n ] , _) (ℚ._· [ 1 / n ])
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:

From 1c7db7ec101c7f72d9bdb7380ab851697774bfc2 Mon Sep 17 00:00:00 2001
From: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date: Mon, 20 Jan 2025 17:36:51 +0100
Subject: [PATCH 05/11] derivative

---
 Cubical/HITs/CauchyReals/Derivative.agda     | 38 ++++++++++----------
 Cubical/HITs/CauchyReals/Inverse.agda        |  6 ++--
 Cubical/HITs/CauchyReals/Lems.agda           |  6 ++--
 Cubical/HITs/CauchyReals/Multiplication.agda |  2 +-
 Cubical/HITs/CauchyReals/Sequence.agda       | 14 ++++----
 5 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/Cubical/HITs/CauchyReals/Derivative.agda b/Cubical/HITs/CauchyReals/Derivative.agda
index d7d6b920d9..7bec390bcb 100644
--- a/Cubical/HITs/CauchyReals/Derivative.agda
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -1,4 +1,4 @@
-{-# OPTIONS --lossy-unification #-} 
+{-# OPTIONS --lossy-unification #-}
 
 module Cubical.HITs.CauchyReals.Derivative where
 
@@ -91,7 +91,7 @@ at x limitOf f is L =
 
 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     
+  → 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)
 
 IsContinuousLim : ∀ f x → IsContinuous f →
@@ -104,13 +104,13 @@ IsContinuousLim f x cx = uncurry
          λ r x＃r x₁ → isTrans<ᵣ _ _ _
            (fst (∼≃abs<ε _ _ _) (X r (invEq (∼≃abs<ε _ _ _) x₁)))
             q<ε  )
-       (cx x (q , ℚ.<→0< q (<ᵣ→<ℚ 0 q 0<q)))) ∘ denseℚinℝ 0 ε  
+       (cx x (q , ℚ.<→0< q (<ᵣ→<ℚ 0 q 0<q)))) ∘ denseℚinℝ 0 ε
 
 IsContinuousLimΔ : ∀ f x → IsContinuous f →
                     at 0 limitOf (λ Δx _ → f (x +ᵣ Δx)) is (f x)
-IsContinuousLimΔ f x cx = 
+IsContinuousLimΔ f x cx =
   subst (at rat [ pos 0 / 1+ 0 ] limitOf (λ Δx _ → f (x +ᵣ Δx)) is_)
-   (cong f (+IdR x)) 
+   (cong f (+IdR x))
   (IsContinuousLim (λ Δx → f (x +ᵣ Δx)) 0
     (IsContinuous∘ _ _ cx (IsContinuous+ᵣL x)))
 
@@ -163,11 +163,11 @@ f #[ _op_ ]$ g = λ r x → (f r x) op (g r x)
 
  where
 
- ε'f : ℝ₊ 
+ ε'f : ℝ₊
  ε'f = (ε ₊／ᵣ₊ 2) ₊／ᵣ₊ (1 +ᵣ absᵣ G ,
           <≤ᵣMonotone+ᵣ 0 1 0 (absᵣ G) decℚ<ᵣ? (0≤absᵣ G))
 
- ε'g : ℝ₊ 
+ ε'g : ℝ₊
  ε'g = (ε ₊／ᵣ₊ 2) ₊／ᵣ₊ (1 +ᵣ absᵣ F ,
           <≤ᵣMonotone+ᵣ 0 1 0 (absᵣ F) decℚ<ᵣ? (0≤absᵣ F))
 
@@ -188,7 +188,7 @@ f #[ _op_ ]$ g = λ r x → (f r x) op (g r x)
         yy
         (isTrans≤<ᵣ _ _ _
           ((absᵣ-triangle _ _) )
-          (<ᵣMonotone+ᵣ _ _ _ _ 
+          (<ᵣMonotone+ᵣ _ _ _ _
             (isTrans≡<ᵣ _ _ _
               (·absᵣ _ _)
               (<ᵣ₊Monotone·ᵣ _ _ _ _
@@ -199,19 +199,19 @@ f #[ _op_ ]$ g = λ r x → (f r x) op (g r x)
                (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≤ᵣ' _ _)             
+      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< = 
+      gx< =
          subst (_<ᵣ (1 +ᵣ absᵣ G))
             (cong absᵣ (sym (L𝐑.lem--035)))
 
@@ -222,7 +222,7 @@ f #[ _op_ ]$ g = λ r x → (f r x) op (g r x)
       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 : _ ≡ _
       yy = (cong₂ _+ᵣ_
           (cong ((1 +ᵣ absᵣ G) ·ᵣ_)
             (cong ((fst (ε ₊／ᵣ₊ 2)) ·ᵣ_)
@@ -238,14 +238,14 @@ f #[ _op_ ]$ g = λ r x → (f r x) op (g r x)
             (invℝ (1 +ᵣ absᵣ F)
                 (inl 0<1+f))) ∙
              ·ᵣAssoc _ _ _) ∙
-          sym (·DistR+ _ _ (fst (ε ₊／ᵣ₊ 2))) 
+          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 _))
 
@@ -289,7 +289,7 @@ idDerivative x =  subst (at 0 limitOf_is 1)
           cong (_·ᵣ (invℝ h 0＃h))
            (sym L𝐑.lem--041)) (+-lim _ _ _ _ _ F G)
 
-C·Derivative : ∀ C x f f'x 
+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 =
@@ -301,7 +301,7 @@ C·Derivative C x f f'x F =
            cong (_·ᵣ (invℝ h 0＃h)) (·DistL- _ _ _))
        (·-lim _ _ _ _ _ (const-lim C 0) F)
 
-substDer : ∀ {x f' f g} → (∀ r → f r ≡ g r) 
+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
@@ -313,7 +313,7 @@ substDer₂ : ∀ {x f' g' f g} →
 substDer₂ p q = subst2 (derivativeOf_at _ is_) (funExt p) q
 
 
-C·Derivative' : ∀ C x f f'x 
+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 =
@@ -348,7 +348,7 @@ C·Derivative' C x f f'x F =
             cong (f (x +ᵣ h) ·ᵣ g (x +ᵣ h) +ᵣ_) (-ᵣ· _ _))
            (·DistL+ _ _ _ ∙
              cong (f x ·ᵣ g (x +ᵣ h) +ᵣ_) (·-ᵣ _ _))
-           ∙ L𝐑.lem--060)  
+           ∙ L𝐑.lem--060)
 
 derivative-^ⁿ : ∀ n x →
    derivativeOf (_^ⁿ (suc n)) at x
@@ -367,4 +367,4 @@ derivative-^ⁿ (suc n) x =
          (cong rat (ℚ.ℕ+→ℚ+ _ _)))
     (·Derivative _ _ _ _ _ IsContinuousId
        (derivative-^ⁿ n x) (idDerivative x))
- 
+
diff --git a/Cubical/HITs/CauchyReals/Inverse.agda b/Cubical/HITs/CauchyReals/Inverse.agda
index bb8b50bc08..7138656c08 100644
--- a/Cubical/HITs/CauchyReals/Inverse.agda
+++ b/Cubical/HITs/CauchyReals/Inverse.agda
@@ -655,10 +655,10 @@ maxAbsorbLMinᵣ x =
         IsContinuousId
          (λ x' → cong rat (ℚ.maxAbsorbLMin x' y')) x
 
-min≤ᵣ : ∀ m n → minᵣ m n ≤ᵣ m 
+min≤ᵣ : ∀ m n → minᵣ m n ≤ᵣ m
 min≤ᵣ m n = maxᵣComm _ _ ∙ maxAbsorbLMinᵣ _ _
 
-min≤ᵣ' : ∀ m n → minᵣ m n ≤ᵣ n 
+min≤ᵣ' : ∀ m n → minᵣ m n ≤ᵣ n
 min≤ᵣ' m n = subst (_≤ᵣ n) (minᵣComm n m) (min≤ᵣ n m)
 
 invℝ'' : Σ (∀ r → ∃[ σ ∈ ℚ₊ ] (rat (fst σ) <ᵣ r) → ℝ)
@@ -1069,7 +1069,7 @@ abstract
              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＃ _ _ _ _)
diff --git a/Cubical/HITs/CauchyReals/Lems.agda b/Cubical/HITs/CauchyReals/Lems.agda
index e5cf68edca..5bf319e904 100644
--- a/Cubical/HITs/CauchyReals/Lems.agda
+++ b/Cubical/HITs/CauchyReals/Lems.agda
@@ -253,13 +253,13 @@ module Lems (R : CR.CommRing ℓ-zero) where
  lem--063 = solve! R
 
  lem--064 : (x · (ε · x')) + (y · (ε · y'))
-               ≡ ((x · x') + (y · y')) · ε  
+               ≡ ((x · x') + (y · y')) · ε
  lem--064 = solve! R
 
- lem--065 : (x' · y') - (x · y)  
+ lem--065 : (x' · y') - (x · y)
               ≡ y · (x' - x) + x' · (y' - y)
  lem--065 = solve! R
- 
+
 open import Cubical.Data.Rationals as ℚ
 
 
diff --git a/Cubical/HITs/CauchyReals/Multiplication.agda b/Cubical/HITs/CauchyReals/Multiplication.agda
index 5fcab18379..a1a27e3231 100644
--- a/Cubical/HITs/CauchyReals/Multiplication.agda
+++ b/Cubical/HITs/CauchyReals/Multiplication.agda
@@ -527,7 +527,7 @@ IsContinuous·ᵣL x = subst IsContinuous
                     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
diff --git a/Cubical/HITs/CauchyReals/Sequence.agda b/Cubical/HITs/CauchyReals/Sequence.agda
index 4f83e29a10..b171cbd258 100644
--- a/Cubical/HITs/CauchyReals/Sequence.agda
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -81,7 +81,7 @@ open import Cubical.HITs.CauchyReals.Inverse
 import Cubical.Algebra.CommRing as CR
 import Cubical.Algebra.Ring as RP
 
-·absᵣ : ∀ x y → absᵣ (x ·ᵣ y) ≡ absᵣ x ·ᵣ absᵣ y 
+·absᵣ : ∀ x y → absᵣ (x ·ᵣ y) ≡ absᵣ x ·ᵣ absᵣ y
 ·absᵣ x = ≡Continuous _ _
   ((IsContinuous∘ _ _  IsContinuousAbsᵣ (IsContinuous·ᵣL x)
                     ))
@@ -102,7 +102,7 @@ Seq = ℕ → ℝ
 
 
 ≤ᵣ-·ᵣo : ∀ m n o → 0 ≤ᵣ o  →  m ≤ᵣ n → (m ·ᵣ o ) ≤ᵣ (n ·ᵣ o)
-≤ᵣ-·ᵣo m n o 0≤o m≤n = subst (λ 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
@@ -134,7 +134,7 @@ Seq = ℕ → ℝ
                  (cong₂ maxᵣ (sym (rat·ᵣrat _ _)) (sym (rat·ᵣrat _ _)))
                   ∙∙ cong rat (sym (ℚ.·MaxDistrℚ' m' n' (ℚ.max 0 o')
                       (ℚ.≤max 0 o'))) ∙∙
-                  rat·ᵣrat _ _ 
+                  rat·ᵣrat _ _
                  ) n) m) o
 
 ≤ᵣ-o·ᵣ : ∀ m n o → 0 ≤ᵣ o →  m ≤ᵣ n → (o ·ᵣ m   ) ≤ᵣ (o ·ᵣ n)
@@ -164,8 +164,8 @@ Seq = ℕ → ℝ
          ≤ℚ→≤ᵣ _ _ (ℚ.0≤ℚ₊ (/2₊ qr₊)) ,
            x/2<x qr₊ ,
            subst (_≤ᵣ (m ·ᵣ n))
-             (sym (rat·ᵣrat q' r')) 
-              (≤ᵣ₊Monotone·ᵣ (rat q') 
+             (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
@@ -202,7 +202,7 @@ _₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊
 
 
 
-<ᵣ₊Monotone·ᵣ : ∀ m n o s → (0 ≤ᵣ m) → (0 ≤ᵣ o) 
+<ᵣ₊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
@@ -211,7 +211,7 @@ _₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊
     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 ∣₁) 
+        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)

From d9599d0e1b74bf8b2b2ff16b0e3b817eff304869 Mon Sep 17 00:00:00 2001
From: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date: Wed, 22 Jan 2025 12:03:12 +0100
Subject: [PATCH 06/11] sequences

---
 Cubical/Data/Rationals/Order/Properties.agda |   8 +
 Cubical/HITs/CauchyReals/Base.agda           |  36 ---
 Cubical/HITs/CauchyReals/Closeness.agda      |  31 +--
 Cubical/HITs/CauchyReals/Continuous.agda     |  79 +------
 Cubical/HITs/CauchyReals/Derivative.agda     | 163 +++++++------
 Cubical/HITs/CauchyReals/Inverse.agda        |  65 +----
 Cubical/HITs/CauchyReals/Lipschitz.agda      |  71 ++----
 Cubical/HITs/CauchyReals/Multiplication.agda |  48 +---
 Cubical/HITs/CauchyReals/Order.agda          |  33 +--
 Cubical/HITs/CauchyReals/Sequence.agda       | 235 +++++++++++++++----
 10 files changed, 344 insertions(+), 425 deletions(-)

diff --git a/Cubical/Data/Rationals/Order/Properties.agda b/Cubical/Data/Rationals/Order/Properties.agda
index a899394064..eae8aa3ff8 100644
--- a/Cubical/Data/Rationals/Order/Properties.agda
+++ b/Cubical/Data/Rationals/Order/Properties.agda
@@ -204,6 +204,14 @@ floor-frac x with 0 ≟ x
         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 : ℚ → ℚ
diff --git a/Cubical/HITs/CauchyReals/Base.agda b/Cubical/HITs/CauchyReals/Base.agda
index 93b5ecbf77..387d29eaf2 100644
--- a/Cubical/HITs/CauchyReals/Base.agda
+++ b/Cubical/HITs/CauchyReals/Base.agda
@@ -2,50 +2,14 @@
 module Cubical.HITs.CauchyReals.Base 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.Isomorphism
-open import Cubical.Foundations.GroupoidLaws
 open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Univalence
-open import Cubical.Functions.FunExtEquiv
 
-import Cubical.Functions.Logic as L
-
-
-open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
-open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
-open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
-open import Cubical.Data.Nat.Order.Recursive as OR
-open import Cubical.Data.Empty as ⊥
-open import Cubical.Data.Sum as ⊎
-open import Cubical.Data.Unit
 open import Cubical.Data.Int as ℤ
-import Cubical.Data.Int.Order as ℤ
-open import Cubical.Data.Maybe as Mb
-open import Cubical.Data.Sigma hiding (Path)
-open import Cubical.Data.List as L
-open import Cubical.Data.List using () renaming (List to ⟦_⟧)
-open import Cubical.Foundations.Interpolate
-open import Cubical.Relation.Nullary
-open import Cubical.Relation.Binary
-
-open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
-
 open import Cubical.Data.Rationals as ℚ
 open import Cubical.Data.Rationals.Order as ℚ
 
 open import Cubical.Data.NatPlusOne
-open import Cubical.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
-
-open import Cubical.HITs.CauchyReals.Lems
-
-import Agda.Builtin.Reflection as R
-open import Cubical.Reflection.Base
-
 
 private
   variable
diff --git a/Cubical/HITs/CauchyReals/Closeness.agda b/Cubical/HITs/CauchyReals/Closeness.agda
index c8f2c8898e..979c90f6e1 100644
--- a/Cubical/HITs/CauchyReals/Closeness.agda
+++ b/Cubical/HITs/CauchyReals/Closeness.agda
@@ -5,46 +5,17 @@ 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.Isomorphism
-open import Cubical.Foundations.GroupoidLaws
 open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Univalence
 open import Cubical.Functions.FunExtEquiv
 
 import Cubical.Functions.Logic as L
 
-
-open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
-open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
-open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
-open import Cubical.Data.Nat.Order.Recursive as OR
-open import Cubical.Data.Empty as ⊥
-open import Cubical.Data.Sum as ⊎
-open import Cubical.Data.Unit
-open import Cubical.Data.Int as ℤ
-import Cubical.Data.Int.Order as ℤ
-open import Cubical.Data.Maybe as Mb
 open import Cubical.Data.Sigma hiding (Path)
-open import Cubical.Data.List as L
-open import Cubical.Data.List using () renaming (List to ⟦_⟧)
-open import Cubical.Foundations.Interpolate
-open import Cubical.Relation.Nullary
-open import Cubical.Relation.Binary
-
-open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
-
 open import Cubical.Data.Rationals as ℚ
 open import Cubical.Data.Rationals.Order as ℚ
 open import Cubical.Data.Rationals.Order.Properties as ℚ
 
-open import Cubical.Data.NatPlusOne
-open import Cubical.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
-
-
-import Agda.Builtin.Reflection as R
-open import Cubical.Reflection.Base
+open import Cubical.HITs.PropositionalTruncation as PT
 
 open import Cubical.HITs.CauchyReals.Base
 open import Cubical.HITs.CauchyReals.Lems
diff --git a/Cubical/HITs/CauchyReals/Continuous.agda b/Cubical/HITs/CauchyReals/Continuous.agda
index d9dba5df19..ed2a299cb6 100644
--- a/Cubical/HITs/CauchyReals/Continuous.agda
+++ b/Cubical/HITs/CauchyReals/Continuous.agda
@@ -5,56 +5,26 @@ 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 hiding (_■)
-open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Univalence
-open import Cubical.Functions.FunExtEquiv
-
-import Cubical.Functions.Logic as L
-
-open import Cubical.Algebra.CommRing.Instances.Int
 
 open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
-open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
 open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
-open import Cubical.Data.Nat.Order.Recursive as OR
-import Cubical.Data.Nat.Order as ℕ
-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)
 import Cubical.Data.Int.Order as ℤ
-open import Cubical.Data.Maybe as Mb
-open import Cubical.Data.Sigma hiding (Path)
-open import Cubical.Data.List as L
-open import Cubical.Data.List using () renaming (List to ⟦_⟧)
-open import Cubical.Foundations.Interpolate
-open import Cubical.Relation.Nullary
-open import Cubical.Relation.Binary
+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 using (ℚ ; [_/_])
-open import Cubical.Data.Rationals.Order using
-  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
 
-import Cubical.Data.Rationals as ℚ
-import Cubical.Data.Rationals.Order as ℚ
-open import Cubical.Data.Rationals.Order.Properties as ℚ using (invℚ₊)
+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.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
-
-
-import Agda.Builtin.Reflection as R
-open import Cubical.Reflection.Base
-
-
-import Cubical.Algebra.CommRing as CR
 
 open import Cubical.HITs.CauchyReals.Base
 open import Cubical.HITs.CauchyReals.Lems
@@ -76,7 +46,7 @@ open import Cubical.HITs.CauchyReals.Order
 
       zz = sym (congLim' _ _ _
                 λ q →
-                   sym $ x₁ (ℚ.invℚ₊ (_//_.[ pos 1 , (1+ 0) ] , tt) ℚ₊· q))
+                   sym $ x₁ (ℚ.invℚ₊ ([ pos 1 / (1+ 0) ] , tt) ℚ₊· q))
   in _∙_ {x = maxᵣ 0 (lim (λ q → (absᵣ (x (ℚ.invℚ₊ 1 ℚ₊· q)))) y0)}
        zz0 zz
 
@@ -321,31 +291,6 @@ denseℚinℝ u v =
 
 
 
--- x+[y-x]n/k≡y-[y-x]m/k : ∀ x y n m k → (n ℕ.+ m ≡ ℕ₊₁→ℕ k) →
---   x ℚ.+ (y ℚ.- x) ℚ.· [ pos n / k ]
---    ≡ y ℚ.- ((y ℚ.- x) ℚ.· [ pos m / k ])
--- x+[y-x]n/k≡y-[y-x]m/k u v n m k p =
---   ((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 ℚ.· [ pos m / k ]))
---                   (ℚ.- ((ℚ.- u) ℚ.· [ pos m / k ])))
---             ∙ cong (ℚ._+_ v)
---                 (sym (ℚ.·DistL+ -1 _ _)) ∙ cong (ℚ._-_ v)
---            (sym (ℚ.·DistR+ v (ℚ.- u) [ pos m / k ])) ))
-
-
 x+[y-x]/2≡y-[y-x]/2 : ∀ x y →
   x ℚ.+ (y ℚ.- x) ℚ.· [ 1 / 2 ]
    ≡ y ℚ.- ((y ℚ.- x) ℚ.· [ 1 / 2 ])
@@ -617,14 +562,14 @@ restrSq n q r x x₁ ε x₂ =
       zz x₂ (ℚ.0≤abs (q ℚ.+ r)) ((ℚ.0≤abs (q ℚ.- r)))
 
 
-0<ℕ₊₁ : ∀ n m → 0 ℚ.< (_//_.[ ℚ.ℕ₊₁→ℤ n , m ])
-0<ℕ₊₁ n m = ℚ.0<→< (_//_.[ ℚ.ℕ₊₁→ℤ n , m ]) tt
+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 → ℚ.[ 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 / 4 ] ℚ.< ([ pos (suc n) / 1 ])
 <Δ n = 1/n<sucK 3 (1+ n)
 
 
diff --git a/Cubical/HITs/CauchyReals/Derivative.agda b/Cubical/HITs/CauchyReals/Derivative.agda
index 7bec390bcb..6b67110850 100644
--- a/Cubical/HITs/CauchyReals/Derivative.agda
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -3,71 +3,25 @@
 module Cubical.HITs.CauchyReals.Derivative where
 
 open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.Structure
 open import Cubical.Foundations.Function
-open import Cubical.Foundations.Equiv hiding (_■)
-open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Univalence
-open import Cubical.Foundations.Function
 open import Cubical.Functions.FunExtEquiv
 
-import Cubical.Functions.Logic as L
-
-open import Cubical.Algebra.CommRing.Instances.Int
-
-open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
-open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
-open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
-import Cubical.Data.Nat.Mod as ℕ
-open import Cubical.Data.Nat.Order.Recursive as OR
-import Cubical.Data.Nat.Order as ℕ
-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)
-import Cubical.Data.Int.Order as ℤ
-open import Cubical.Data.Maybe as Mb
-open import Cubical.Data.Sigma hiding (Path)
-open import Cubical.Data.List as L
-open import Cubical.Data.List using () renaming (List to ⟦_⟧)
-open import Cubical.Foundations.Interpolate
-open import Cubical.Relation.Nullary
-open import Cubical.Relation.Binary
+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 using (ℚ ; [_/_])
-open import Cubical.Data.Rationals.Order using
-  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
-
-import Cubical.Data.Rationals as ℚ
-import Cubical.Data.Rationals.Order as ℚ
-
 open import Cubical.Data.NatPlusOne
-open import Cubical.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
 
-open import Cubical.Data.Rationals using (ℚ ; [_/_])
-open import Cubical.Data.Rationals.Order using
-  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
-
-import Cubical.Data.Rationals as ℚ
-import Cubical.Data.Rationals.Order as ℚ
-open import Cubical.Data.Rationals.Order.Properties as ℚ using (invℚ₊;/2₊;x/2<x;/4₊;invℚ)
-
-open import Cubical.Data.NatPlusOne
-open import Cubical.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
-
-
-import Agda.Builtin.Reflection as R
-open import Cubical.Reflection.Base
 
+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ℚ)
 
-import Cubical.Algebra.CommRing as CR
 
 open import Cubical.HITs.CauchyReals.Base
 open import Cubical.HITs.CauchyReals.Lems
@@ -79,8 +33,6 @@ open import Cubical.HITs.CauchyReals.Multiplication
 open import Cubical.HITs.CauchyReals.Inverse
 open import Cubical.HITs.CauchyReals.Sequence
 
-import Cubical.Algebra.CommRing as CR
-import Cubical.Algebra.Ring as RP
 
 
 
@@ -89,23 +41,64 @@ 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)
 
-IsContinuousLim : ∀ f x → IsContinuous f →
-                    at x limitOf (λ r _ → f r) is (f x)
-IsContinuousLim f x cx = uncurry
+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＃r x₁ → isTrans<ᵣ _ _ _
+         λ 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 =
@@ -115,6 +108,7 @@ IsContinuousLimΔ f x cx =
     (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 ε)) ∣₁
@@ -350,21 +344,36 @@ C·Derivative' C x f f'x F =
              cong (f x ·ᵣ g (x +ᵣ h) +ᵣ_) (·-ᵣ _ _))
            ∙ L𝐑.lem--060)
 
-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))
-
+-- 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
index 7138656c08..fa8d23a00a 100644
--- a/Cubical/HITs/CauchyReals/Inverse.agda
+++ b/Cubical/HITs/CauchyReals/Inverse.agda
@@ -4,69 +4,33 @@ module Cubical.HITs.CauchyReals.Inverse where
 
 open import Cubical.Foundations.Prelude
 open import Cubical.Foundations.Structure
-open import Cubical.Foundations.Function
-open import Cubical.Foundations.Equiv hiding (_■)
-open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Univalence
 open import Cubical.Foundations.Function
-open import Cubical.Functions.FunExtEquiv
-
-import Cubical.Functions.Logic as L
-
-open import Cubical.Algebra.CommRing.Instances.Int
 
 open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
-open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
-open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
-open import Cubical.Data.Nat.Order.Recursive as OR
-import Cubical.Data.Nat.Order as ℕ
 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)
-import Cubical.Data.Int.Order as ℤ
-open import Cubical.Data.Maybe as Mb
-open import Cubical.Data.Sigma hiding (Path)
-open import Cubical.Data.List as L
-open import Cubical.Data.List using () renaming (List to ⟦_⟧)
-open import Cubical.Foundations.Interpolate
-open import Cubical.Relation.Nullary
-open import Cubical.Relation.Binary
-
-open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
-
-open import Cubical.Data.Rationals using (ℚ ; [_/_])
-open import Cubical.Data.Rationals.Order using
-  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
-
-import Cubical.Data.Rationals as ℚ
-import Cubical.Data.Rationals.Order as ℚ
-
+open import Cubical.Data.Sigma
 open import Cubical.Data.NatPlusOne
-open import Cubical.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
 
-open import Cubical.Data.Rationals using (ℚ ; [_/_])
-open import Cubical.Data.Rationals.Order using
-  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
 
-import Cubical.Data.Rationals as ℚ
-import Cubical.Data.Rationals.Order as ℚ
-open import Cubical.Data.Rationals.Order.Properties as ℚ using (invℚ₊;/2₊;x/2<x;/4₊;invℚ)
+import Cubical.Algebra.CommRing as CR
+import Cubical.Algebra.Ring as RP
 
-open import Cubical.Data.NatPlusOne
-open import Cubical.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
 
+open import Cubical.Relation.Binary
 
-import Agda.Builtin.Reflection as R
-open import Cubical.Reflection.Base
+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ℚ)
 
-import Cubical.Algebra.CommRing as CR
 
 open import Cubical.HITs.CauchyReals.Base
 open import Cubical.HITs.CauchyReals.Lems
@@ -76,13 +40,10 @@ open import Cubical.HITs.CauchyReals.Order
 open import Cubical.HITs.CauchyReals.Continuous
 open import Cubical.HITs.CauchyReals.Multiplication
 
-import Cubical.Algebra.CommRing as CR
-import Cubical.Algebra.Ring as RP
-
 
 Rℝ = (CR.CommRing→Ring
                (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ))
--- module CRℝ = ?
+
 
 module 𝐑 = CR.CommRingTheory (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ)
 module 𝐑' = RP.RingTheory Rℝ
@@ -163,7 +124,7 @@ open ℚ.HLP
      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 (ε))) )
+            (ℚ.<Weaken≤ _ _ (ℚ.x/2<x (ε))) )
      in zz)
        , ≤ℚ→≤ᵣ _ _ (ℚ.≤+ℚ₊ r r (/2₊ ε) (ℚ.isRefl≤ r)) ∣₁
  w .Elimℝ-Prop.limA x y R ε =
diff --git a/Cubical/HITs/CauchyReals/Lipschitz.agda b/Cubical/HITs/CauchyReals/Lipschitz.agda
index d2bd708c87..da6a06b6d6 100644
--- a/Cubical/HITs/CauchyReals/Lipschitz.agda
+++ b/Cubical/HITs/CauchyReals/Lipschitz.agda
@@ -5,50 +5,21 @@ 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.Equiv hiding (_■)
-open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.GroupoidLaws
 open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Univalence
-open import Cubical.Functions.FunExtEquiv
 
-import Cubical.Functions.Logic as L
-
-open import Cubical.Algebra.CommRing.Instances.Int
-
-open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
-open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
-open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
-open import Cubical.Data.Nat.Order.Recursive as OR
-open import Cubical.Data.Empty as ⊥
 open import Cubical.Data.Sum as ⊎
-open import Cubical.Data.Unit
 open import Cubical.Data.Int as ℤ
-import Cubical.Data.Int.Order as ℤ
-open import Cubical.Data.Maybe as Mb
-open import Cubical.Data.Sigma hiding (Path)
-open import Cubical.Data.List as L
-open import Cubical.Data.List using () renaming (List to ⟦_⟧)
-open import Cubical.Foundations.Interpolate
-open import Cubical.Relation.Nullary
-open import Cubical.Relation.Binary
+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 using (ℚ ; [_/_])
-open import Cubical.Data.Rationals.Order using
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
   ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
-
-import Cubical.Data.Rationals as ℚ
-open import Cubical.Data.Rationals.Order as ℚ
+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.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
-
-
-open import Cubical.Data.Rationals.Order.Properties as ℚ
 
 open import Cubical.HITs.CauchyReals.Base
 open import Cubical.HITs.CauchyReals.Lems
@@ -169,16 +140,16 @@ Lipschitz-ℚ→ℚ-extend Δ L f δ δ<Δ x q r ε v =
                      (ℚ.+IdR _) (ℚ.+Comm _ _
                       ∙ (sym $ ℚ.-[x-y]≡y-x (fst Δ) (fst δ)))
                      ((ℚ.<-o+ 0 (fst δ) (ℚ.- (fst Δ)) (ℚ.0<ℚ₊ δ))))
-                 ((≤clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) u
+                 ((ℚ.≤clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) u
                     (( ℚ.pos[-x≤x] (ℚ.<→ℚ₊ (fst δ) (fst Δ) δ<Δ))))) )
-               (ℚ.isTrans≤< _ _ _ (clamp≤ _ _ _)
+               (ℚ.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)
+               (ℚ.clampDist (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) r q)
                v)
 
 
@@ -225,7 +196,7 @@ fromLipschitz L (f , fL) = f' ,
            ((λ 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 (δ₁ ℚ₊+ ε₁)) ∙
+            ((λ i → ℚ.x·invℚ₊[x] L i ℚ.· fst (δ₁ ℚ₊+ ε₁)) ∙
              ℚ.·IdL (fst (δ₁ ℚ₊+ ε₁)))))
           (u' (invℚ₊ L ℚ₊· δ₁) (invℚ₊ L ℚ₊· ε₁)))
           (subst {x = fst L ℚ.· (fst ε ℚ.+ (ℚ.- fst δ))}
@@ -233,7 +204,7 @@ fromLipschitz L (f , fL) = f' ,
                 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)
+                 (cong v' (ℚ₊≡ (sym $ ℚ.[y·x]/y L (fst δ)))) z)
 
  w : Elimℝ (λ _ → ℝ) λ u v ε _ → u ∼[ L ℚ₊· ε  ] v
  w .Elimℝ.ratA = f
@@ -246,7 +217,7 @@ fromLipschitz L (f , fL) = f' ,
                  ∙∙ ℚ.·Assoc (fst L) (fst (invℚ₊ L))
                       ((fst δ) ℚ.+ (fst ε)) ∙∙
                        (cong (ℚ._· fst (δ ℚ₊+ ε))
-                        (x·invℚ₊[x] L) ∙ ℚ.·IdL (fst (δ ℚ₊+ ε)))))
+                        (ℚ.x·invℚ₊[x] L) ∙ ℚ.·IdL (fst (δ ℚ₊+ ε)))))
 
           v'
  w .Elimℝ.eqA p a a' x y =
@@ -255,7 +226,7 @@ fromLipschitz L (f , fL) = f' ,
         (ℚ₊≡ $
           ℚ.·Assoc (fst L) (fst (invℚ₊ L)) (fst ε) ∙
             (cong (ℚ._· fst (ε))
-                        (x·invℚ₊[x] L) ∙ ℚ.·IdL (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
@@ -268,9 +239,9 @@ fromLipschitz L (f , fL) = f' ,
          $ ℚ.·0< (fst L) (fst ε ℚ.- (fst δ ℚ.+ fst η))
               (snd L) v₁)
 
-        ((cong v' (ℚ₊≡ $ sym ([y·x]/y L (fst δ)))
+        ((cong v' (ℚ₊≡ $ sym (ℚ.[y·x]/y L (fst δ)))
           subst∼[ ℚ₊≡ e ]
-           cong v'' (ℚ₊≡ $ sym ([y·x]/y L (fst η)))) x₁)
+           cong v'' (ℚ₊≡ $ sym (ℚ.[y·x]/y L (fst η)))) x₁)
  w .Elimℝ.isPropB _ _ _ _ = isProp∼ _ _ _
 
 
@@ -282,13 +253,13 @@ fromLipschitz L (f , fL) = f' ,
 ∼-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)))
+   (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
+     $ ℚ.≤→<⊎≡ (fst ε) (fst ε') x
 
 
 lipschConstIrrel : ∀ L₁ L₂ (x : ℚ₊ → ℝ) → ∀  p₁ p₂ →
@@ -296,7 +267,7 @@ lipschConstIrrel : ∀ L₁ L₂ (x : ℚ₊ → ℝ) → ∀  p₁ 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₂)
+     sym (w L₂ L₁ x x₁ p₂ p₁)) (ℚ.getPosRatio L₁ L₂)
 
 
  where
@@ -317,7 +288,7 @@ lipschConstIrrel L₁ L₂ =
                 cong (ℚ._· (fst (/4₊ ε)))
                   (ℚ.·Assoc _ _ _ ∙
                    cong (ℚ._· (fst L₂))
-                     (x·invℚ₊[x] L₁) ∙ ℚ.·IdL (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₊ ε))
@@ -346,6 +317,8 @@ congLim x y x' y' p =
            (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)
@@ -422,7 +395,7 @@ record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
         (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₃)
+    let ((θ , θ<) , (x₂' , x₃'))  = ℚ.getθ ε ((q ℚ.- r)) (x₂ , x₃)
         θ/2 = /2₊ (θ , θ<)
         zzz : fst (zz q) (x θ/2) ∼[ (fst ε ℚ.- θ) , x₂' ]
                fst (zz r) (x θ/2)
@@ -531,7 +504,7 @@ record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
                           ((∼-monotone< {ε = /2₊ ε/4 ℚ₊+ /2₊ ε/4}
                                {(fst ε ℚ.- ((((fst ε) ℚ.· [ 1 / 4 ])
                                   ℚ.· ℚ.[ 1 / 2 ]) ℚ.+ fst ε/4))
-                                , _} (((-<⁻¹ _ _ v)))
+                                , _} (((ℚ.-<⁻¹ _ _ v)))
                                    $ sym∼ _ _ _ (𝕣-lim-self x' y'
                              (/2₊ ε/4) (/2₊ ε/4)))))))
    in _ , zz
diff --git a/Cubical/HITs/CauchyReals/Multiplication.agda b/Cubical/HITs/CauchyReals/Multiplication.agda
index a1a27e3231..7bc59279c0 100644
--- a/Cubical/HITs/CauchyReals/Multiplication.agda
+++ b/Cubical/HITs/CauchyReals/Multiplication.agda
@@ -5,57 +5,29 @@ 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 hiding (_■)
-open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Univalence
-open import Cubical.Functions.FunExtEquiv
-
-import Cubical.Functions.Logic as L
-
-open import Cubical.Algebra.CommRing.Instances.Int
 
 open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
-open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
 open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
-open import Cubical.Data.Nat.Order.Recursive as OR
-import Cubical.Data.Nat.Order as ℕ
-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)
 import Cubical.Data.Int.Order as ℤ
-open import Cubical.Data.Maybe as Mb
-open import Cubical.Data.Sigma hiding (Path)
-open import Cubical.Data.List as L
-open import Cubical.Data.List using () renaming (List to ⟦_⟧)
-open import Cubical.Foundations.Interpolate
-open import Cubical.Relation.Nullary
-open import Cubical.Relation.Binary
+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 using (ℚ ; [_/_])
-open import Cubical.Data.Rationals.Order using
-  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
-
-import Cubical.Data.Rationals as ℚ
-import Cubical.Data.Rationals.Order as ℚ
-open import Cubical.Data.Rationals.Order.Properties as ℚ using (invℚ₊)
-
 open import Cubical.Data.NatPlusOne
-open import Cubical.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
-
-
-import Agda.Builtin.Reflection as R
-open import Cubical.Reflection.Base
-
 
 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
@@ -163,8 +135,8 @@ sqᵣ'  = (λ r → f r (getClamps r))
   w .Elimℝ-Prop.ratA q n< n<' =
     let Δ : ℕ → ℚ₊
         Δ n = ℚ.<→ℚ₊
-             (_//_.[ 1 , 4 ])
-             (_//_.[ pos (suc (suc (n))) , 1 ])
+             ([ 1 / 4 ])
+             ([ pos (suc (suc (n))) / 1 ])
 
              ((<Δ (suc (n))))
         q* : ℕ → ℚ
diff --git a/Cubical/HITs/CauchyReals/Order.agda b/Cubical/HITs/CauchyReals/Order.agda
index 7879d3e97e..d41ae8f99d 100644
--- a/Cubical/HITs/CauchyReals/Order.agda
+++ b/Cubical/HITs/CauchyReals/Order.agda
@@ -5,52 +5,35 @@ 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 hiding (_■)
-open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Univalence
-open import Cubical.Functions.FunExtEquiv
-
-import Cubical.Functions.Logic as L
-
-open import Cubical.Algebra.CommRing.Instances.Int
 
 open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
-open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
 open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
-open import Cubical.Data.Nat.Order.Recursive as OR
 open import Cubical.Data.Empty as ⊥
 open import Cubical.Data.Sum as ⊎
-open import Cubical.Data.Unit
 open import Cubical.Data.Int as ℤ
 import Cubical.Data.Int.Order as ℤ
-open import Cubical.Data.Maybe as Mb
-open import Cubical.Data.Sigma hiding (Path)
-open import Cubical.Data.List as L
-open import Cubical.Data.List using () renaming (List to ⟦_⟧)
-open import Cubical.Foundations.Interpolate
+open import Cubical.Data.Sigma
 open import Cubical.Relation.Nullary
-open import Cubical.Relation.Binary
 
 open import Cubical.HITs.PropositionalTruncation as PT
 open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
 
-open import Cubical.Data.Rationals using (ℚ ; [_/_])
-open import Cubical.Data.Rationals.Order using
+
+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₊)
 
-import Cubical.Data.Rationals as ℚ
-import Cubical.Data.Rationals.Order as ℚ
+open import Cubical.Data.NatPlusOne
 
 open import Cubical.Data.NatPlusOne
 open import Cubical.Foundations.Path
 open import Cubical.Foundations.CartesianKanOps
 
 
-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
diff --git a/Cubical/HITs/CauchyReals/Sequence.agda b/Cubical/HITs/CauchyReals/Sequence.agda
index b171cbd258..44b5043a38 100644
--- a/Cubical/HITs/CauchyReals/Sequence.agda
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -3,71 +3,31 @@
 module Cubical.HITs.CauchyReals.Sequence where
 
 open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.Structure
-open import Cubical.Foundations.Function
-open import Cubical.Foundations.Equiv hiding (_■)
+open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.GroupoidLaws
 open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Univalence
 open import Cubical.Foundations.Function
-open import Cubical.Functions.FunExtEquiv
-
-import Cubical.Functions.Logic as L
-
-open import Cubical.Algebra.CommRing.Instances.Int
 
 open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
-open import Cubical.Data.Bool.Base using () renaming (Bool to 𝟚 ; true to 1̂ ; false to 0̂)
 open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
 import Cubical.Data.Nat.Mod as ℕ
-open import Cubical.Data.Nat.Order.Recursive as OR
 import Cubical.Data.Nat.Order as ℕ
 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)
 import Cubical.Data.Int.Order as ℤ
-open import Cubical.Data.Maybe as Mb
-open import Cubical.Data.Sigma hiding (Path)
-open import Cubical.Data.List as L
-open import Cubical.Data.List using () renaming (List to ⟦_⟧)
-open import Cubical.Foundations.Interpolate
-open import Cubical.Relation.Nullary
-open import Cubical.Relation.Binary
+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 using (ℚ ; [_/_])
-open import Cubical.Data.Rationals.Order using
-  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
-
-import Cubical.Data.Rationals as ℚ
-import Cubical.Data.Rationals.Order as ℚ
 
 open import Cubical.Data.NatPlusOne
-open import Cubical.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
 
-open import Cubical.Data.Rationals using (ℚ ; [_/_])
-open import Cubical.Data.Rationals.Order using
+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ℚ;_ℚ^ⁿ_;_ℚ₊^ⁿ_)
 
-import Cubical.Data.Rationals as ℚ
-import Cubical.Data.Rationals.Order as ℚ
-open import Cubical.Data.Rationals.Order.Properties as ℚ using (invℚ₊;/2₊;x/2<x;/4₊;invℚ)
-
-open import Cubical.Data.NatPlusOne
-open import Cubical.Foundations.Path
-open import Cubical.Foundations.CartesianKanOps
-
-
-import Agda.Builtin.Reflection as R
-open import Cubical.Reflection.Base
-
-
-import Cubical.Algebra.CommRing as CR
 
 open import Cubical.HITs.CauchyReals.Base
 open import Cubical.HITs.CauchyReals.Lems
@@ -78,9 +38,6 @@ open import Cubical.HITs.CauchyReals.Continuous
 open import Cubical.HITs.CauchyReals.Multiplication
 open import Cubical.HITs.CauchyReals.Inverse
 
-import Cubical.Algebra.CommRing as CR
-import Cubical.Algebra.Ring as RP
-
 ·absᵣ : ∀ x y → absᵣ (x ·ᵣ y) ≡ absᵣ x ·ᵣ absᵣ y
 ·absᵣ x = ≡Continuous _ _
   ((IsContinuous∘ _ _  IsContinuousAbsᵣ (IsContinuous·ᵣL x)
@@ -226,8 +183,8 @@ _₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊
 
 
 
-/nᵣ : ℕ₊₁ → ℝ → ℝ
-/nᵣ n = fst (fromLipschitz ([ 1 / n ] , _)
+/nᵣ-L : (n : ℕ₊₁) → Σ _ (Lipschitz-ℝ→ℝ _)
+/nᵣ-L n = (fromLipschitz ([ 1 / n ] , _)
   (_ , Lipschitz-rat∘ ([ 1 / n ] , _) (ℚ._· [ 1 / n ])
    λ q r ε x →
      subst (ℚ._< ([ 1 / n ]) ℚ.· (fst ε))
@@ -241,6 +198,22 @@ _₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊
        ((ℚ.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
@@ -572,3 +545,163 @@ limₙ→∞ s is x =
 
 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)
+
+
+-- 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 ½ᵣ
+ ε/2 : ℝ₊
+ ε/2 = (ε ·ᵣ rat [ 1 / 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) <ᵣ ε
+ 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)) <ᵣ fst ε/2
+  s<ε = subst (_<ᵣ fst ε/2) (+IdR _) (isTrans≤<ᵣ _ _ _
+          (≤absᵣ ((s (m ℕ.+ N)) +ᵣ (-ᵣ 0))) (snd Nε _
+           (ℕ.≤<-trans ℕ.right-≤-max ℕ.≤SumRight)))
+
+  pp : (seqΣ (λ x → s (x ℕ.+ (m ℕ.+ suc N))) n) <ᵣ ε
+  pp =
+      subst {x = ℕ._+ suc (m ℕ.+ N) } {y = λ z → z ℕ.+ (m ℕ.+ suc N)}
+           (λ h → seqΣ (s ∘S h) n <ᵣ ε)
+         
+          (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≤ᵣ _ _ (snd ε/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 (·ᵣAssoc _ _ _) ∙∙
+                       cong (ε ·ᵣ_) (sym (rat·ᵣrat _ _)
+                         ∙ cong rat (𝟚.toWitness {Q = ℚ.discreteℚ
+                           ([ 1 / 2 ] ℚ.· 2) 1} tt))
+                        ∙∙ ·IdR ε))))))
+
+
+expSeq : ℝ → Seq
+expSeq x zero = 1
+expSeq x (suc n) = /nᵣ (1+ n) (expSeq x n ·ᵣ x)
+
+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ₙ→∞[expSeq]=0 : ∀ x → limₙ→∞ expSeq (rat x) is 0
+limₙ→∞[expSeq]=0 = {!!}
+
+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)
+    w'
+
+ where
+ 0<ᵣx = <ℚ→<ᵣ 0 x 0<x
+ w : ∀ n → /nᵣ (1+ (suc n)) (rat x) ≡ (expSeq (rat x) (suc n) ／ᵣ[ expSeq (rat x) n ,
+                    inl (expSeqPos (rat x) 0<ᵣx n) ])
+ w = {!!}
+
+ w' : limₙ→∞ (λ x₁ → /nᵣ (2+ x₁) (rat x)) is 0
+ w' ε =
+  let cN = ℚ.ceilℚ₊
+  in {!!} , (λ n' <n' → isTrans≡<ᵣ _ _ _
+      (cong absᵣ (+IdR _) ∙ absᵣPos _ (/nᵣ-pos _ _ 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) (limₙ→∞[expSeqRatio]=0 x 0<x)

From 8a6e91bd0f71ef0b36957fdac88d66116fabf2c5 Mon Sep 17 00:00:00 2001
From: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date: Wed, 22 Jan 2025 17:28:32 +0100
Subject: [PATCH 07/11] exp

---
 Cubical/Data/Rationals/Order/Properties.agda |  19 ++
 Cubical/HITs/CauchyReals/Sequence.agda       | 331 ++++++++++++++++---
 2 files changed, 309 insertions(+), 41 deletions(-)

diff --git a/Cubical/Data/Rationals/Order/Properties.agda b/Cubical/Data/Rationals/Order/Properties.agda
index eae8aa3ff8..71c6fee18c 100644
--- a/Cubical/Data/Rationals/Order/Properties.agda
+++ b/Cubical/Data/Rationals/Order/Properties.agda
@@ -1289,6 +1289,9 @@ 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 =
@@ -1358,12 +1361,28 @@ q ／ℚ[ r , 0＃r ] = q · (invℚ r 0＃r)
 ℚ-[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 =
diff --git a/Cubical/HITs/CauchyReals/Sequence.agda b/Cubical/HITs/CauchyReals/Sequence.agda
index 44b5043a38..425f61a5cc 100644
--- a/Cubical/HITs/CauchyReals/Sequence.agda
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -38,6 +38,10 @@ open import Cubical.HITs.CauchyReals.Continuous
 open import Cubical.HITs.CauchyReals.Multiplication
 open import Cubical.HITs.CauchyReals.Inverse
 
+
+
+
+
 ·absᵣ : ∀ x y → absᵣ (x ·ᵣ y) ≡ absᵣ x ·ᵣ absᵣ y
 ·absᵣ x = ≡Continuous _ _
   ((IsContinuous∘ _ _  IsContinuousAbsᵣ (IsContinuous·ᵣL x)
@@ -274,8 +278,12 @@ seqSumUpTo≡seqSumUpTo' f (suc n) =
      z
 
 
+
 open ℕ.Minimal
 
+-- invFacℕ : ∀ n → Σ _ (Least (λ k → n ℕ.< 2 !))
+-- invFacℕ = {!!}
+
 log2ℕ : ∀ n → Σ _ (Least (λ k → n ℕ.< 2 ^ k))
 log2ℕ n = w n n ℕ.≤-refl
  where
@@ -453,6 +461,11 @@ 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 =
@@ -460,6 +473,12 @@ 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))
@@ -494,8 +513,40 @@ IsConvSeries≃IsCauchySequenceSum : (s : Seq) →
 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 (δ ℚ₊+ ε)))
@@ -535,12 +586,50 @@ fromCauchySequence s ics =
                (subst ((fst ε) ℚ.<_) (ℚ.+Comm _ _)
                (ℚ.<+ℚ₊' (fst ε) (fst ε) δ (ℚ.isRefl≤ (fst ε))))))
 
+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
@@ -565,25 +654,110 @@ Limₙ→∞ s = Σ _ (limₙ→∞ s is_)
            (sym (ℚ.invℚ₊-ℚ^ⁿ ([ 1 / 2 ] , _) n)) 1/ε<n)
 
 
+
+-- ratio→seqLimit : ∀ (s : Seq)
+--   → (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 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 δ₊ = {!!}
+--          p = {!!}
+--          (m½ , q) = 1/2ⁿ<ε δ₊
+--          pp : rat ([ 1 / 2 ] ℚ^ⁿ m½)  <ᵣ
+--                  ((rat ε ·ᵣ invℝ (s (suc N)) (inl (sPos _))))
+--          pp = isTrans<ᵣ _ _ _ (<ℚ→<ᵣ _ {!fst δ₊!} q) p
+--          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<ε) =
+     → 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 ½ᵣ
- ε/2 : ℝ₊
- ε/2 = (ε ·ᵣ rat [ 1 / 2 ]) , ℝ₊· ε₊ ½ᵣ 
- Nε = (l' (ε/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) <ᵣ ε
+ 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)
@@ -628,15 +802,17 @@ ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) =
   p' = Seq'≤→Σ≤ s' (geometricProgression (s (m ℕ.+ N)) (fst ½ᵣ))
         p 
 
-  s<ε : (s (m ℕ.+ N)) <ᵣ fst ε/2
-  s<ε = subst (_<ᵣ fst ε/2) (+IdR _) (isTrans≤<ᵣ _ _ _
+  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)))
+           (ℕ.≤<-trans ℕ.right-≤-max ℕ.≤SumRight))))
+              
 
-  pp : (seqΣ (λ x → s (x ℕ.+ (m ℕ.+ suc N))) n) <ᵣ ε
+  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 <ᵣ ε)
+           (λ h → seqΣ (s ∘S h) n <ᵣ rat ε)
          
           (funExt (λ x → cong (x ℕ.+_) (sym (ℕ.+-suc _ _)) ))
           (isTrans≤<ᵣ _ _ _ (p' n)
@@ -648,7 +824,7 @@ ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) =
                     (<ℚ→<ᵣ _ _ ((𝟚.toWitness {Q = ℚ.<Dec [ 1 / 2 ] 1} tt))))
                 (isTrans≤ᵣ _ _ _
                   (≤ᵣ₊Monotone·ᵣ _ _ _ 2
-                        (<ᵣWeaken≤ᵣ _ _ (snd ε/2))
+                        (<ᵣWeaken≤ᵣ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<ℚ₊ ε/2)))
                           (<ᵣWeaken≤ᵣ _ _
                              ((0<1/x _ _ (
                        <ℚ→<ᵣ _ _
@@ -658,12 +834,11 @@ ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) =
                     (≡ᵣWeaken≤ᵣ _ _
                        (invℝ-rat _ _
                         (inl ((𝟚.toWitness {Q = ℚ.<Dec 0 [ 1 / 2 ]} tt))))))
-                  (≡ᵣWeaken≤ᵣ _ _
-                     (sym (·ᵣAssoc _ _ _) ∙∙
-                       cong (ε ·ᵣ_) (sym (rat·ᵣrat _ _)
-                         ∙ cong rat (𝟚.toWitness {Q = ℚ.discreteℚ
-                           ([ 1 / 2 ] ℚ.· 2) 1} tt))
-                        ∙∙ ·IdR ε))))))
+                        (≡ᵣWeaken≤ᵣ _ _ (sym (rat·ᵣrat _  _) ∙
+                          cong rat (sym (ℚ.·Assoc _ _ _) ∙
+                            cong (ε ℚ.·_) ℚ.decℚ? ∙ ℚ.·IdR _)))
+                  
+                        ))))
 
 
 expSeq : ℝ → Seq
@@ -675,33 +850,107 @@ expSeqPos x 0<x zero = decℚ<ᵣ?
 expSeqPos x 0<x (suc n) =
  /nᵣ-pos (1+ n) _ (ℝ₊· (_ , expSeqPos x 0<x n) (_ , 0<x)) 
 
-limₙ→∞[expSeq]=0 : ∀ x → limₙ→∞ expSeq (rat x) is 0
-limₙ→∞[expSeq]=0 = {!!}
-
-limₙ→∞[expSeqRatio]=0 : ∀ x → ∀ (0<x : 0 ℚ.< x)  → limₙ→∞
+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)
+limₙ→∞[expSeqRatio]=0 x 0<x = 
+  subst (lim'ₙ→∞_is 0)
+    (funExt (w (rat x) _))
     w'
 
  where
- 0<ᵣx = <ℚ→<ᵣ 0 x 0<x
- w : ∀ n → /nᵣ (1+ (suc n)) (rat x) ≡ (expSeq (rat x) (suc n) ／ᵣ[ expSeq (rat x) n ,
-                    inl (expSeqPos (rat x) 0<ᵣx n) ])
- w = {!!}
+ x₊ : ℚ₊
+ x₊ = x , ℚ.<→0< _ 0<x
 
- w' : limₙ→∞ (λ x₁ → /nᵣ (2+ x₁) (rat x)) is 0
+ 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 = ℚ.ceilℚ₊
-  in {!!} , (λ n' <n' → isTrans≡<ᵣ _ _ _
-      (cong absᵣ (+IdR _) ∙ absᵣPos _ (/nᵣ-pos _ _ 0<ᵣx))
-       {!!} )
-
-expSeriesConvergesAtℚ : ∀ x → 0 ℚ.< x → IsConvSeries (expSeq (rat x))
-expSeriesConvergesAtℚ x 0<x =
+  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 =
+  {!!}
+
+
+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) (limₙ→∞[expSeqRatio]=0 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)))
+
+
+test : ℕ
+test = fst ((expSeriesConvergesAtℚ₊ 1 (ℚ.decℚ<? {0} {1})) 1)
+
+𝑒 : ℝ
+𝑒 = fromCauchySequence' _
+  (fst (IsConvSeries'≃IsCauchySequence'Sum (expSeq 1))
+    (expSeriesConvergesAtℚ₊ 1 (ℚ.decℚ<? {0} {1})))

From 522673c42f246ba3b906e4a9af00feb197917d69 Mon Sep 17 00:00:00 2001
From: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date: Wed, 22 Jan 2025 19:59:27 +0100
Subject: [PATCH 08/11] whitespace fix

---
 Cubical/Data/Rationals/Order/Properties.agda |   4 +-
 Cubical/HITs/CauchyReals/Derivative.agda     |   2 +-
 Cubical/HITs/CauchyReals/Sequence.agda       | 248 ++++++++++---------
 3 files changed, 139 insertions(+), 115 deletions(-)

diff --git a/Cubical/Data/Rationals/Order/Properties.agda b/Cubical/Data/Rationals/Order/Properties.agda
index 71c6fee18c..a2a610e84d 100644
--- a/Cubical/Data/Rationals/Order/Properties.agda
+++ b/Cubical/Data/Rationals/Order/Properties.agda
@@ -1374,7 +1374,7 @@ q ／ℚ[ r , 0＃r ] = q · (invℚ r 0＃r)
 
 ℚ-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 ／ℚ[ 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 _ _) ∙
@@ -1382,7 +1382,7 @@ q ／ℚ[ r , 0＃r ] = q · (invℚ r 0＃r)
       ℚ-[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) 
+     (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 =
diff --git a/Cubical/HITs/CauchyReals/Derivative.agda b/Cubical/HITs/CauchyReals/Derivative.agda
index 6b67110850..e1df521a55 100644
--- a/Cubical/HITs/CauchyReals/Derivative.agda
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -97,7 +97,7 @@ IsContinuousInclLim≃IsContinuous : ∀ f  →
 IsContinuousInclLim≃IsContinuous f =
   propBiimpl→Equiv (isPropΠ2 λ _ _ → squash₁) (isPropIsContinuous f)
     (IsContinuousInclLim→IsContinuous f)
-     λ fc x → IsContinuousInclLim f x fc   
+     λ fc x → IsContinuousInclLim f x fc
 
 IsContinuousLimΔ : ∀ f x → IsContinuous f →
                     at 0 limitOf (λ Δx _ → f (x +ᵣ Δx)) is (f x)
diff --git a/Cubical/HITs/CauchyReals/Sequence.agda b/Cubical/HITs/CauchyReals/Sequence.agda
index 425f61a5cc..fae5d31605 100644
--- a/Cubical/HITs/CauchyReals/Sequence.agda
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -520,7 +520,7 @@ IsoIsConvSeries'IsCauchySequenceSum' s =
      Σ-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))
@@ -636,7 +636,7 @@ Limₙ→∞ : Seq → Type
 Limₙ→∞ s = Σ _ (limₙ→∞ s is_)
 
 
-ε<2ⁿ : (ε : ℚ₊) → Σ[ n ∈ ℕ ] fst ε ℚ.< 2 ℚ^ⁿ n 
+ε<2ⁿ : (ε : ℚ₊) → Σ[ n ∈ ℕ ] fst ε ℚ.< 2 ℚ^ⁿ n
 ε<2ⁿ ε = let n = fst (log2ℕ (fst (ℚ.ceilℚ₊ ε))) in n ,
          subst (fst ε ℚ.<_) (sym (ℚ.fromNat-^ _ _))
           (ℚ.isTrans< _ _ (fromNat (2 ^ n))
@@ -655,95 +655,105 @@ Limₙ→∞ s = Σ _ (limₙ→∞ s is_)
 
 
 
--- ratio→seqLimit : ∀ (s : Seq)
---   → (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 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 δ₊ = {!!}
---          p = {!!}
---          (m½ , q) = 1/2ⁿ<ε δ₊
---          pp : rat ([ 1 / 2 ] ℚ^ⁿ m½)  <ᵣ
---                  ((rat ε ·ᵣ invℝ (s (suc N)) (inl (sPos _))))
---          pp = isTrans<ᵣ _ _ _ (<ℚ→<ᵣ _ {!fst δ₊!} q) p
---          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 
+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)     
+     → (lim'ₙ→∞ (λ n →  s (suc n) ／ᵣ[ s n , inl ((sPos n)) ]) is 0)
      → IsConvSeries' s
-ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) = 
+ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) =
   N , ww
 
  where
@@ -781,39 +791,39 @@ ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) =
            (isTrans≤<ᵣ _ _ _ (≤absᵣ _)
              (snd N½ n (
               ℕ.<-trans (ℕ.left-≤-max {suc (fst N½)} {fst Nε})
-               n<)))))) 
+               n<))))))
 
 
-  p : ∀ n → s' n ≤ᵣ geometricProgression (s (m ℕ.+ N)) (fst ½ᵣ) 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} _))))) 
+                  (≤ℚ→≤ᵣ _ _ ((𝟚.toWitness {Q = ℚ.≤Dec ([ 1 / 2 ]) 1} _)))))
 
-  p (suc n) = 
+  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 
+        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≤<ᵣ _ _ _
@@ -829,7 +839,7 @@ ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) =
                              ((0<1/x _ _ (
                        <ℚ→<ᵣ _ _
                        (𝟚.toWitness {Q = ℚ.<Dec 0 [ 1 / 2 ]} tt)))))
-                         
+
                     (<ᵣWeaken≤ᵣ _ _ s<ε)
                     (≡ᵣWeaken≤ᵣ _ _
                        (invℝ-rat _ _
@@ -837,7 +847,7 @@ ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) =
                         (≡ᵣWeaken≤ᵣ _ _ (sym (rat·ᵣrat _  _) ∙
                           cong rat (sym (ℚ.·Assoc _ _ _) ∙
                             cong (ε ℚ.·_) ℚ.decℚ? ∙ ℚ.·IdR _)))
-                  
+
                         ))))
 
 
@@ -845,17 +855,32 @@ 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)) 
+ /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 = 
+limₙ→∞[expSeqRatio]=0 x 0<x =
   subst (lim'ₙ→∞_is 0)
     (funExt (w (rat x) _))
     w'
@@ -868,16 +893,16 @@ limₙ→∞[expSeqRatio]=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 _ 
+        (( 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' = _
@@ -899,12 +924,12 @@ limₙ→∞[expSeqRatio]=0 x 0<x =
  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 ε)
@@ -918,7 +943,7 @@ limₙ→∞[expSeqRatio]=0 x 0<x =
       in isTrans≡<ᵣ _ _ _
           (cong absᵣ (+IdR _) ∙ absᵣPos _
             (ℝ₊· (_ , <ℚ→<ᵣ 0 x 0<x)
-                       (_ , 
+                       (_ ,
                           <ℚ→<ᵣ _ _
                            (ℚ.invℚ-pos [ pos (suc n') / 1 ]
                             (inl 0<n') 0<n')))
@@ -932,7 +957,8 @@ limₙ→∞[expSeqRatio]=0 x 0<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))
@@ -947,10 +973,8 @@ expℚ₊ q = fromCauchySequence' _
     (expSeriesConvergesAtℚ₊ (fst q) (ℚ.0<ℚ₊ q)))
 
 
-test : ℕ
-test = fst ((expSeriesConvergesAtℚ₊ 1 (ℚ.decℚ<? {0} {1})) 1)
+expSeriesVal : ℕ → ℚ
+expSeriesVal n = fst (expSeries-rat 1 n)
 
 𝑒 : ℝ
-𝑒 = fromCauchySequence' _
-  (fst (IsConvSeries'≃IsCauchySequence'Sum (expSeq 1))
-    (expSeriesConvergesAtℚ₊ 1 (ℚ.decℚ<? {0} {1})))
+𝑒 = expℚ₊ 1

From 0f5b3fc9b1371ab727ef1a6f24e7846f100f7b1d Mon Sep 17 00:00:00 2001
From: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date: Thu, 23 Jan 2025 00:22:45 +0100
Subject: [PATCH 09/11] whitespace fix

---
 Cubical/HITs/CauchyReals.agda                | 12 +++++++++++
 Cubical/HITs/CauchyReals/Continuous.agda     |  2 +-
 Cubical/HITs/CauchyReals/Derivative.agda     |  2 +-
 Cubical/HITs/CauchyReals/Inverse.agda        |  5 +++--
 Cubical/HITs/CauchyReals/Lipschitz.agda      |  9 +++++++-
 Cubical/HITs/CauchyReals/Multiplication.agda | 19 ++++++++++++++++-
 Cubical/HITs/CauchyReals/Order.agda          |  2 +-
 Cubical/HITs/CauchyReals/Sequence.agda       | 22 +++++---------------
 8 files changed, 49 insertions(+), 24 deletions(-)
 create mode 100644 Cubical/HITs/CauchyReals.agda

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/Continuous.agda b/Cubical/HITs/CauchyReals/Continuous.agda
index ed2a299cb6..2f5ab88109 100644
--- a/Cubical/HITs/CauchyReals/Continuous.agda
+++ b/Cubical/HITs/CauchyReals/Continuous.agda
@@ -1,4 +1,4 @@
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --safe --lossy-unification #-}
 
 module Cubical.HITs.CauchyReals.Continuous where
 
diff --git a/Cubical/HITs/CauchyReals/Derivative.agda b/Cubical/HITs/CauchyReals/Derivative.agda
index e1df521a55..b628d33591 100644
--- a/Cubical/HITs/CauchyReals/Derivative.agda
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -1,4 +1,4 @@
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --safe --lossy-unification #-}
 
 module Cubical.HITs.CauchyReals.Derivative where
 
diff --git a/Cubical/HITs/CauchyReals/Inverse.agda b/Cubical/HITs/CauchyReals/Inverse.agda
index fa8d23a00a..bcdd9b9648 100644
--- a/Cubical/HITs/CauchyReals/Inverse.agda
+++ b/Cubical/HITs/CauchyReals/Inverse.agda
@@ -1,4 +1,4 @@
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --lossy-unification --safe #-}
 
 module Cubical.HITs.CauchyReals.Inverse where
 
@@ -43,7 +43,7 @@ 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ℝ
@@ -1020,6 +1020,7 @@ sign·absᵣ r = ∘diag $
           ∙ cong rat (cong (ℚ._· ℚ.sign r) (sym (ℚ.abs'≡abs r))
            ∙ ℚ.sign·abs r) ) r
 
+-- HoTT Theorem (11.3.47)
 
 abstract
  invℝ : ∀ r → 0 ＃ r → ℝ
diff --git a/Cubical/HITs/CauchyReals/Lipschitz.agda b/Cubical/HITs/CauchyReals/Lipschitz.agda
index da6a06b6d6..45592123f6 100644
--- a/Cubical/HITs/CauchyReals/Lipschitz.agda
+++ b/Cubical/HITs/CauchyReals/Lipschitz.agda
@@ -1,4 +1,4 @@
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --safe --lossy-unification #-}
 
 module Cubical.HITs.CauchyReals.Lipschitz where
 
@@ -98,6 +98,13 @@ lim-surj = PT.map (map-snd (eqℝ _ _)) ∘ (Elimℝ-Prop.go w)
 
 -- 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 =
diff --git a/Cubical/HITs/CauchyReals/Multiplication.agda b/Cubical/HITs/CauchyReals/Multiplication.agda
index 7bc59279c0..d11378d2f6 100644
--- a/Cubical/HITs/CauchyReals/Multiplication.agda
+++ b/Cubical/HITs/CauchyReals/Multiplication.agda
@@ -1,4 +1,4 @@
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --safe --lossy-unification #-}
 
 module Cubical.HITs.CauchyReals.Multiplication where
 
@@ -686,3 +686,20 @@ cont₂·ᵣWP P f g fC gC = IsContinuousWP∘' P _
 _^ⁿ_ : ℝ → ℕ → ℝ
 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
index d41ae8f99d..bd88e12a10 100644
--- a/Cubical/HITs/CauchyReals/Order.agda
+++ b/Cubical/HITs/CauchyReals/Order.agda
@@ -1,4 +1,4 @@
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --safe --lossy-unification #-}
 
 module Cubical.HITs.CauchyReals.Order where
 
diff --git a/Cubical/HITs/CauchyReals/Sequence.agda b/Cubical/HITs/CauchyReals/Sequence.agda
index fae5d31605..fd7054d972 100644
--- a/Cubical/HITs/CauchyReals/Sequence.agda
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -1,4 +1,4 @@
-{-# OPTIONS --lossy-unification #-}
+{-# OPTIONS --safe --lossy-unification #-}
 
 module Cubical.HITs.CauchyReals.Sequence where
 
@@ -42,22 +42,6 @@ open import Cubical.HITs.CauchyReals.Inverse
 
 
 
-·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
-
 Seq : Type
 Seq = ℕ → ℝ
 
@@ -554,6 +538,7 @@ isCauchyAprox f = (δ ε : ℚ₊) →
 lim' : ∀ x → isCauchyAprox x → ℝ
 lim' x y = lim x λ δ ε  → (invEq (∼≃abs<ε _ _ _)) (y δ ε)
 
+-- HoTT 11.3.49
 
 fromCauchySequence : ∀ s → IsCauchySequence s → ℝ
 fromCauchySequence s ics =
@@ -586,6 +571,9 @@ fromCauchySequence s ics =
                (subst ((fst ε) ℚ.<_) (ℚ.+Comm _ _)
                (ℚ.<+ℚ₊' (fst ε) (fst ε) δ (ℚ.isRefl≤ (fst ε))))))
 
+
+-- TODO HoTT 11.3.50.
+
 fromCauchySequence' : ∀ s → IsCauchySequence' s → ℝ
 fromCauchySequence' s ics =
   lim x y

From 1143bc9cf9e83727cc7cca78c27574280cf75762 Mon Sep 17 00:00:00 2001
From: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date: Thu, 23 Jan 2025 00:40:22 +0100
Subject: [PATCH 10/11] uncomment some working code

---
 Cubical/HITs/CauchyReals/Derivative.agda | 36 ++++++++++++------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/Cubical/HITs/CauchyReals/Derivative.agda b/Cubical/HITs/CauchyReals/Derivative.agda
index b628d33591..59778e28ba 100644
--- a/Cubical/HITs/CauchyReals/Derivative.agda
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -14,7 +14,7 @@ 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
@@ -354,23 +354,23 @@ C·Derivative' C x f f'x F =
 --   → 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))
+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

From 18f833478487b581732fc2884f102453e2e3fd62 Mon Sep 17 00:00:00 2001
From: Marcin Jan Turek-Grzybowski <marcinjangrzybowski@gmail.com>
Date: Fri, 27 Jun 2025 00:24:12 +0200
Subject: [PATCH 11/11] Squashed commit of the following:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

commit d08dabfacb486fb77a2ded077a3f0593968412e8
Author: Marcin Jan Turek-Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Thu Jun 26 22:32:26 2025 +0200

    works

commit 74b6ee0df2aaba26be3f09f81b2020470b27cc44
Author: Marcin Jan Turek-Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Thu Jun 26 22:29:59 2025 +0200

    gi

commit f89d4d7f172ae7da24a385efdd783209a5b2bdea
Author: Marcin Jan Turek-Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Thu Jun 26 22:29:15 2025 +0200

    gi

commit 3528c1128f48573748c240b3b5d3ea27fee5e0e5
Author: Marcin Jan Turek-Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Thu Jun 26 20:04:00 2025 +0200

    cleanup

commit 4028c0010c1f0f48f54577ce418185648b2b9902
Author: Marcin Jan Turek-Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Thu Jun 26 20:02:46 2025 +0200

    cleanup

commit 02f1aa892a739e61be52f2a609d0bd5891133639
Merge: 07914eea ac62dd4f
Author: Marcin Jan Turek-Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Thu Jun 26 19:09:38 2025 +0200

    pre-merge

commit 07914eeae43b77109983039e6d2e6c67fbae3f2f
Author: Marcin Jan Turek-Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Thu Jun 26 18:59:53 2025 +0200

    integration done

commit ac62dd4f433ed1a45f9bf944e9acb7beb8a4a7c9
Author: anshwad10 <109362320+anshwad10@users.noreply.github.com>
Date:   Wed Jun 25 17:16:13 2025 +0530

    Add Rezk Completion by HIT (#1188)

    * Add Rezk Completion by HIT

    * Update Construction.agda

    * Removed trailing whitespaces

    * Remove trailing whitespace

    * Replace HIT with GroupoidQuotient

    * shorter proof of `inc-surj`

    * fix whitespace

    * Forgot to import GroupoidQuotients

    * add implicit argument

commit b15ec4ebde4bc5bf98c3bc671683e85fc02044b3
Author: Marcin Jan Turek-Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Tue Jun 24 06:45:56 2025 +0200

    wip

commit 55479efdb10a2999dfec0bec50e4411a788d44ab
Author: Marcin Jan Turek-Grzybowski <marcin@Marcins-MacBook-Pro.local>
Date:   Wed May 28 16:00:42 2025 +0200

    wip - dirty

commit ecf1bbbfc2231f7700684255a85646a8a3e2e8c4
Author: Laine Taffin Altman <alexanderaltman@me.com>
Date:   Fri May 23 03:17:16 2025 -0700

    Fix makefile race condition (#1210)

    If you use `make -j gen-everythings listings`, currently there is a near-certainty that the `listings` task will fail because the Everythings modules haven't been generated yet.  This PR enforces the dependency.

commit 43183c8037a67f1f29b45dff86050dbc39ca290e
Author: michael <1700346+mzhang28@users.noreply.github.com>
Date:   Thu May 22 17:01:37 2025 -0500

    Five lemma (#1166)

    * exact sequences

    * complete five proof

    * make five safe

    * fix newline

    * exactness over a successor structure

    * working again

    * fix whitespace...

    * clean up, just five

    * clean up

    * make implicit + rename isExact so the names are more descriptive

    * fix whitespace

commit 63d187dc6f1d6dca388f60dc7fc94f81072ad2cf
Author: anshwad10 <109362320+anshwad10@users.noreply.github.com>
Date:   Tue May 20 22:52:24 2025 +0530

    Formalize Theorem 7.2.2 in the HoTT Book (#1180)

    * Formalize Theorem 7.2.2 in the HoTT Book

    * move Theorem 7.2.2 to Cubical.Relation.Binary.Properties

    * Remove a few extra spaces

    This is not really necessary but it looks better

commit 06e62f4cfabb0e693e3c399d24a10348fa578eab
Author: michael <1700346+mzhang28@users.noreply.github.com>
Date:   Tue May 20 07:24:54 2025 -0500

    Composition of left module homomorphisms (#1176)

    * implement composition of left module homomorphisms

    * pull out to top level

    * fix whitespace

commit 78203ee8e494275bf1b8b90c78b3851a28d8e150
Author: anshwad10 <109362320+anshwad10@users.noreply.github.com>
Date:   Mon May 19 21:41:29 2025 +0530

    Remove duplicated lemma (#1189)

    * Remove duplicated lemma

    #1017

    * Insert brackets

commit 2738401afdec79dbaf580131e27b0cee8d16b7b0
Author: LorenzoMolena <164308953+LorenzoMolena@users.noreply.github.com>
Date:   Mon May 19 17:52:30 2025 +0200

    Strict order equational reasoning (#1203)

    * Add QuosetReasoning.agda

    Co-authored-by: Ettore Forigo <ettore.forigo@gmail.com>

    * add missing `no-eta-equality` in SubRelation, make SubRelation instance private

    ---------

    Co-authored-by: Ettore Forigo <ettore.forigo@gmail.com>

commit 69b70a2fbad125a7737221540c4f0bb9a5b54f9b
Author: anshwad10 <109362320+anshwad10@users.noreply.github.com>
Date:   Mon May 19 21:19:57 2025 +0530

    Add inducedFun for EM1 (#1208)

    * Add files via upload

    * Delete Base.agda

    No idea what this file is doing here

    * Delete Properties.agda

    Must have accidentally put this here when I was editing dagger-cat

    * Add inducedFun for EM1

commit 22458b709ee5609daab0a58ef5c80fc232ce42d7
Author: LeeeeT <me@LeeeeT.dev>
Date:   Mon May 19 18:46:33 2025 +0300

    Add missing minus symbol (#1207)

commit 3291fc1d8cae1409cc54d4f9cca7366158b573d7
Author: Felix Cherubini <felix.cherubini@posteo.de>
Date:   Mon May 19 17:24:35 2025 +0200

    Release for agda 2.7 (#1206)

    * test new ci script

    * fix

    * use fix-whitespace action

    * blindly try stuff

    * blindly try stuff

    * blindly try stuff

    * untabify...

    * Revert "blindly try stuff"

    This reverts commit 6fe71f3e792cd31cf807509a6ba66ca2f5560eec.

    # Conflicts:
    #	.github/workflows/ci-ubuntu.yml

    * use fix-whitespace action

    * whitespace

    * whitespace

    * fix

    * fix

    * fix

    * fix

    * Fix path of fix-whitespace

    * Remove unnecessary step to generate user-manual.pdf

    * Bump base in cubical-utils.cabal

    * bump version number everywhere, update README and RELEASE

    * trailing newline needed?

    * update flake

    ---------

    Co-authored-by: Andreas Abel <andreas.abel@ifi.lmu.de>
    Co-authored-by: Naïm Favier <n@monade.li>

commit eef2ed612ad858f790b802d83ddf7a95946d80f1
Author: Marcin Jan Turek-Grzybowski <marcin@Marcins-MacBook-Pro.local>
Date:   Thu May 15 07:17:58 2025 +0200

    wip

commit 71f32f05da9aaa85c2f5c4ef760d0304522aec55
Author: Andreas Abel <andreas.abel@ifi.lmu.de>
Date:   Fri May 9 21:51:25 2025 +0200

    Prep for Agda 2.8.0: remove some spurious `private`

commit d5b7bcec99497e2b409a84c5d55fa512b10fdb47
Author: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Mon Apr 21 20:46:48 2025 +0200

    sync

commit 35d29193477fe168edfe4bff66af984068bf85e4
Merge: 385066b8 cb0510c9
Author: Evan Cavallo <evanc@chalmers.se>
Date:   Fri Mar 21 06:08:36 2025 +0100

    Merge pull request #1157 from Trebor-Huang/devalapurkar-haine

    Devalapurkar & Haine

commit cb0510c90297244bfb527788d292d7ea565a1927
Author: ecavallo <evancavallo@gmail.com>
Date:   Thu Mar 20 18:40:56 2025 +0100

    cosmetic changes

commit 52cf2a1725f7d8a35528368ac59d204aa768c6ed
Author: ecavallo <evancavallo@gmail.com>
Date:   Thu Mar 20 18:40:42 2025 +0100

    more informative type signatures

commit 01c36f4846e396da0868c8eb3f3c8f9f36bfa960
Author: ecavallo <evancavallo@gmail.com>
Date:   Thu Mar 20 18:40:23 2025 +0100

    prefer copattern matching to record syntax

commit fa0eba6064f0d7eb38f0332e41803339c491254b
Author: ecavallo <evancavallo@gmail.com>
Date:   Thu Mar 20 13:59:26 2025 +0100

    make pushout to wedge equivalence opaque

commit 4155afda46ffc7ed0eacc49e5b22dad8eefb3f70
Merge: 01fa4208 385066b8
Author: ecavallo <evancavallo@gmail.com>
Date:   Tue Mar 18 14:01:34 2025 +0100

    Merge branch 'master' into devalapurkar-haine

commit 385066b8128a8cedcc53133bc1ccaa27f00dfa03
Author: Loïc Pujet <38562414+loic-p@users.noreply.github.com>
Date:   Tue Mar 4 16:53:03 2025 +0100

    Reduced homology of CW complexes (#1175)

    * Reduced homology of CW complexes

    * explicit description of the augmentation map

commit 90c3244f4ea0da5dccee314d60f34e1aacb1a9dd
Author: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Fri Feb 14 16:53:06 2025 +0100

    wip

commit e8ff0c1e18fd200d0c6a2d70f07811134df7d3cf
Author: anshwad10 <109362320+anshwad10@users.noreply.github.com>
Date:   Fri Feb 14 21:06:39 2025 +0530

    Move `factorial` from `Cubical.Data.Fin.LehmerCode` to `Cubical.Data.Nat.Properties` (#1184)

    * Update LehmerCode.agda

    * Update Properties.agda

    add `factorial` here

    * Update LehmerCode.agda

    made it export `factorial` so nothing else in the library that depends on `factorial` being exported breaks

    * Removed dependency on LehmerCode exporting `factorial`

    * Removed dependency on LehmerCode exporting `factorial`

    * Removed dependency on LehmerCode exporting `factorial`

    * Remove the public export of `factorial` from LehmerCode.agda

commit 3d5bb7d6bf32d4b6835a8b6fd99fa0eb0985f914
Author: Brad Dragun <35275808+LuuBluum@users.noreply.github.com>
Date:   Tue Feb 11 23:02:11 2025 -0700

    Fix missed rename of StrictPoset to Quoset (#1185)

commit c16edadee9ca56448546574ab14e34c1f2f875b8
Author: anshwad10 <109362320+anshwad10@users.noreply.github.com>
Date:   Sat Feb 8 21:32:52 2025 +0530

    Remove duplicated factorial function (#1183)

    `_!` is defined in `Cubical.Data.Nat.Properties`, `factorial` is defined in `Cubical.Data.Fin.LehmerCode`, and they both have identical definitions.

commit f717d461c5ac05db4d4325ff1ef45ea6f728efd3
Author: Brad Dragun <35275808+LuuBluum@users.noreply.github.com>
Date:   Fri Feb 7 09:27:29 2025 -0700

    Basic Order Theory (#1154)

    * Add inverses to monoids/comm monoids

    * Add meets and joins to order properties

    * Rewrite isConnected and rename isStronglyConnected

    * Decidable total and linear orders imply discrete

    * Remove discrete requirement

    * Move decidable->discrete from toset to poset

    * Define binary meets/joins and prove properties

    * The negation of a linear order is a poset

    * Define bounds on a poset

    * Mild refactoring

    Rename preorder to proset; rename strict poset
    to quoset (quasiorder) and add strict orders
    as quasiorders with weak linearity

    * Remove unnecessary constructors

    * Define tight relations

    * Reintroduce constructors

    * Lattice basics

    * Distributive lattices

    * Replace compEquiv usages

    * Total orders are distributive pseudolattices

    * Add pseudolattice assumption to make more useful

    * Mappings on posets

    * Downsets and upsets are preserved

    * Defined complete lattices

    * Duals and closures

    * Embeddings form a complete lattice

    * Dual closures

    * Bicomplete subsets

    * Poset equivalences

    * Galois connections

    * Fix typo

    * Fix whitespace

    * Fix build failures

    * Move PosetDownset to where principalDownsets are

    * Fix build failures

    * Split mappings and subsets

    * Fix whitespace

    * Proofs regarding residuals and involutions

    * Cleaner proof

commit f3444859771d09cde7b5483415ed141ae78eefd4
Author: Marcin Grzybowski <marcinjangrzybowski@gmail.com>
Date:   Thu Jan 30 15:55:08 2025 +0100

    wip

commit 01fa4208b2110765b2cdf93219756124550eff4d
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Thu Sep 19 22:16:54 2024 +0800

    safe flags

commit 54a2b1fa49ef4a26a62ff52f0f3ba9fa412ebe36
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Thu Sep 19 21:42:05 2024 +0800

    Fix whitespace

commit a181af86d2afc3f756f164ccd95b24e02550ac77
Merge: f0d49bc4 53e400ec
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Thu Sep 19 21:36:50 2024 +0800

    Merge remote-tracking branch 'origin/master' into devalapurkar-haine

commit f0d49bc456b0798603ef0ed6e9bdc88b9a12ff84
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Thu Sep 19 21:27:40 2024 +0800

    James

commit d99570a63326ea5471a694e0f55a00aefef93d45
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Thu Sep 19 21:10:57 2024 +0800

    Hilton–Milnor

commit c983de796ea23119cfdc910eb41c3d7a77525962
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Thu Sep 19 20:36:36 2024 +0800

    Splitting of loopspace

commit 08a56c498329612d3d6e9d4ae27b6655a91b2873
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Thu Sep 19 20:21:45 2024 +0800

    Oddly specific sigma lemma

commit 51fa7d02ec85a68ec34a0fb4c405e2298b1cecf9
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Thu Sep 19 20:12:35 2024 +0800

    Remove my version in favor of the other

commit dee0c5608ea276a7c97744ecbacc9eee05260df1
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Sun Aug 18 00:08:50 2024 +0800

    extend commutative squares

commit 98bbb7a28cdb7d3465455615ad5fadf98970dfaf
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Sun Aug 18 00:08:43 2024 +0800

    tweak

commit a4b23dd2b9dd08b3d614d447aee9ba435a47977f
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Thu Aug 15 17:45:42 2024 +0800

    Rename

commit dac0c0ef7abc0c21de26287154dba5c5f5e0f028
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Tue Aug 13 02:07:32 2024 +0800

    Pushout using Unit*

commit f9fc7e32263dfe5f5f23b26d2bac87fb9a9c0e86
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Mon Aug 12 13:50:15 2024 +0800

    Use PushoutSquare instead

commit 72a75579ac9152673b56bda44f67c9352f7483d1
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Mon Aug 12 03:58:36 2024 +0800

    Universes

commit 9d50340ea6072c87a4207d38077740545c08585b
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Mon Aug 12 03:18:06 2024 +0800

    Susp (X∙ ⋀ Y∙) ≡ join X Y

commit 4bc6517beba1c4ad1cd5a79b6364acf1dd748e50
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Mon Aug 12 02:51:38 2024 +0800

    Pushout⋁≃Unit

commit 90f1ca9f37e5b2587f34f55e879cfbcc3d1fe78c
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Mon Aug 12 02:50:52 2024 +0800

    Remove redundant definition

commit fa2da1a05ecd55bd99203ece9c4cbc1781794cb2
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Mon Aug 12 02:50:36 2024 +0800

    projection functions

commit 54038ae9fb28f9a30810c7518246c9819e5bf18f
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Mon Aug 12 02:31:37 2024 +0800

    join inclusions are null

commit 313b74e0dead200f337708449f2cb1dca68d1cd3
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Mon Aug 12 00:22:40 2024 +0800

    Use pushout squares for cofibInl-⋁

commit d0a06cdb284a25dd095c93c78ca78121ed9e05d9
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Sun Aug 11 21:40:16 2024 +0800

    pushout along identity

commit b4e74c14767031ec00ebbb43696186a53b3b030c
Author: Trebor-Huang <treborhuang@foxmail.com>
Date:   Sun Aug 11 21:08:23 2024 +0800

    Susp is Pushout 1 <- X -> 1

commit 5dae63277ab3ff9ae977d2747d33597a08973a08
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Sep 17 01:01:18 2024 +0200

    fixes

commit e13f9abc2333c0281f21b4d2237e4cb7f8030ad2
Merge: 10aea90c e2370fbb
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Sep 16 22:22:28 2024 +0200

    Merge remote-tracking branch 'master/master' into cellular_pointed

commit 10aea90c18c24d09626a0ec1c7d317c7e0fb5f2f
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jun 4 14:42:34 2024 +0200

    minor

commit 1dff2d524093f32c9d05500463c09ee781f2c30e
Merge: 46482afb a0b4ba3e
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jun 4 14:39:52 2024 +0200

    merge

commit 46482afb26dd76ebaa06e2b57c1134e98b541990
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jun 4 14:22:49 2024 +0200

    connected clean

commit 787f34f42311454c48db5def54b9154b6d564842
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jun 4 14:12:57 2024 +0200

    connected done?

commit 73afa8ec3c639433f8d6b701c7d72b9083e6f9dc
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jun 4 02:59:48 2024 +0200

    cleaning

commit 0cb567811fcf46b77da666ac4eac2522039d9f89
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jun 4 02:59:42 2024 +0200

    cleaning

commit 6bc36641e78cc27c04811c24236e6eb792ee9656
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Fri May 31 18:51:51 2024 +0200

    pretty much done

commit e4f400342907ec03159b741b3a43900777e1b819
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Fri May 31 04:09:48 2024 +0200

    almost

commit c7acbeee22598a9dc201e68b79e659bd8b394ad0
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Wed May 29 18:11:46 2024 +0200

    stuff

commit 77623bb0a40f5be302202c60e9f3ae5791082c90
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon May 27 03:16:45 2024 +0200

    wip...

commit dac2fd33e3aaabcb936104afc4e0685f130c0dc6
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Thu May 23 18:08:06 2024 +0200

    stuff

commit afe51a465bd2d086d2461e1d80b44719d539bb5b
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Wed May 8 18:20:52 2024 +0200

    p2

commit 87fa4c021063e4ec37fa39d4b7bfe78e2c44a881
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue May 7 18:15:55 2024 +0200

    done?

commit eb6b12e6b4d9c7b00ffe4dec96d86f17320dd173
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue May 7 10:12:34 2024 +0200

    Pointed

commit 3784dcd118ef25e2123535a01df66d95097b2de6
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Thu May 2 11:34:11 2024 +0200

    comments

commit beccacd97a903f3140d19c9ac50dfcff40f89b2e
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Mar 4 12:03:53 2024 +0100

    ojdå

commit 3e53282ae92499ae69f28596cd195e55055a76b3
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Mar 4 11:31:38 2024 +0100

    broken code

commit ac5249e76295d97d20f3f827158e0f7b994e5150
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Mar 4 09:39:57 2024 +0100

    wups

commit 1b005a64708be0b27eceefd6c5f1628385f00ae7
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Mar 4 02:22:00 2024 +0100

    ugh

commit 2d3fe1c02ac12dcbebc159a47f37a7fb11d08580
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Mar 4 01:48:45 2024 +0100

    wups

commit b1f9e1dbc9c857a821f8be5b24ac1ec46ef51724
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Mar 4 01:30:09 2024 +0100

    readme

commit 6e259aff9109e5c799b9eb15ef45578ffb3965cb
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Mar 4 00:38:02 2024 +0100

    cleanup

commit a3f6a9e42ef58043ebf485f00085137f64d1ffc4
Merge: 6ce70a49 f4745a23 4ba3c8eb
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Sun Mar 3 21:13:21 2024 +0100

    merge

commit 4ba3c8eb525864245fa8d2e532827e3bc0631b55
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Sun Mar 3 20:55:52 2024 +0100

    stuff

commit a3bb47e1a71da858c66ee029b4a5dd53a9bfd620
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Sun Mar 3 20:48:17 2024 +0100

    done?

commit 53bb0f29ffe6bfe80f6e4256081b2531b21de3d0
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Sun Mar 3 03:52:29 2024 +0100

    stuff

commit 54c7919a18c48e72ccf111c9179fe0f5c3da0a4a
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Fri Mar 1 19:08:20 2024 +0100

    stuff

commit 42d6b770bb45031ce19e5f486000dc946cb9ecfe
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Thu Feb 29 15:34:05 2024 +0100

    stuff

commit df55d5508e8e8029cb3d147636f8a454a008aed9
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Thu Feb 29 02:49:34 2024 +0100

    More

commit ae6e813d48cb6620094243de4d03e2afaad907be
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Feb 27 00:10:56 2024 +0100

    stuf

commit b6941207463c57b23399f97d1709f0d635845e16
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Feb 26 16:42:26 2024 +0100

    stuff

commit ea5fefdda2f7ceb38d0cd1bc799ec4cdff448dac
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Sun Feb 25 23:02:26 2024 +0100

    stuff

commit f4745a23aa8462ca80e936c25ccc41c648fe980d
Merge: 1c0396ca 227b10b9
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Wed Jan 31 10:49:17 2024 +0100

    Merge remote-tracking branch 'origin/master'

commit 90714817e9e9115cdcc0d50fb9f839d17bfef30d
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Wed Jan 31 10:46:56 2024 +0100

    stuff

commit e47bad54dc36571f9fc7f41f551e347131991430
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Wed Jan 24 19:53:25 2024 +0100

    wups

commit f7524ebc3fed41d408c158e93748ec2f3bbae462
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jan 23 19:44:57 2024 +0100

    ugh...

commit b7716a46e9017d052b7d0a6bd1b2db4db16d40a4
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jan 23 19:19:56 2024 +0100

    fixes

commit 7313a311f150ab352c767dc716c9f115bce8d46a
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jan 23 15:04:18 2024 +0100

    wups

commit 7875e3ee00816291bf03351f0ea3bfce3fc356fb
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jan 23 14:51:05 2024 +0100

    wups

commit 74a85212fdbfedc27cc2f3c9e2c846246065ec3d
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jan 23 14:47:14 2024 +0100

    wups

commit 5e8b305aec47a6cac3167a2262d0874de6884643
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jan 23 14:17:35 2024 +0100

    done?

commit 74596b53b1c3b6d96b13ad5f468386ea76769155
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Jan 23 03:52:06 2024 +0100

    ..

commit 2b8b5fda7e43eb304284c54383710752de3b2f10
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Jan 22 18:50:46 2024 +0100

    more

commit 2fef4ef8ccaf61ec6105bb9c6201281bd305eb47
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Jan 22 18:36:10 2024 +0100

    stuff

commit c0345787321d5730595763e4d0f1dc706eebd6af
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Thu Jan 18 17:17:24 2024 +0100

    stuff

commit 9d1915dd861102c72f1a497bf2d7e9b9e0295edf
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Wed Jan 17 02:53:26 2024 +0100

    fix

commit 227b10b9d16e0bdb866941a1eb9195e481c13999
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Thu Jun 8 09:45:56 2023 +0200

    w

commit 3acc6b862989c2d0e5d0f58137d1b9c2a144a48a
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Thu Jun 8 09:45:28 2023 +0200

    w

commit ea75092e20dc74fd00e788088ad7a35cbe5dfc97
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Thu Jun 8 09:44:37 2023 +0200

    w

commit 52429ff1823be41f0ae64830314d4c8e07906d94
Merge: 93417102 814d54b0
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Thu Jun 8 09:38:02 2023 +0200

    Merge branch 'newM'

commit 934171020cab0a9fc68f298d4c34a9958c621ca1
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Fri Jun 2 15:04:54 2023 +0200

    ganea stuff

commit 17f3fc1f5dbed5cf98bb5f8f58d9d4ed56aa81b5
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Apr 24 17:13:52 2023 +0200

    rme

commit aadde33a93f44d140376682ec774a7d460ac183f
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Apr 24 17:12:41 2023 +0200

    wups

commit e8244ac1f3364abe7adb794f27d805d466437524
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Apr 24 17:10:45 2023 +0200

    duplicate

commit cc6ced25804997022e855a458511bf6ce1b38247
Merge: b4b6efb7 f0ad815d
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Mon Apr 24 17:10:10 2023 +0200

    done

commit b4b6efb72c8bce27d4ae6c9b5275a846868349c1
Merge: 93d7248f 9acdecfa
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Feb 1 04:02:50 2022 +0100

    m

commit 93d7248fb129e34702bd7d6a472a4eb9ba55072a
Author: aljungstrom <axel.ljungstrom@hotmail.com>
Date:   Tue Feb 1 04:00:15 2022 +0100

    t
---
 .github/workflows/ci-ubuntu.yml               |   37 +-
 CITATION.cff                                  |    4 +-
 .../AbGroup/Instances/FreeAbGroup.agda        |   47 +
 Cubical/Algebra/Algebra/Properties.agda       |    2 +-
 Cubical/Algebra/ChainComplex/Homology.agda    |   42 +-
 Cubical/Algebra/CommMonoid/Properties.agda    |   16 +
 .../Localisation/UniversalProperty.agda       |   10 +-
 Cubical/Algebra/DistLattice/Downset.agda      |    1 +
 Cubical/Algebra/Group/Exact.agda              |   30 +-
 Cubical/Algebra/Group/Five.agda               |  265 ++
 Cubical/Algebra/Group/MorphismProperties.agda |   15 +
 Cubical/Algebra/Module/Properties.agda        |   49 +
 Cubical/Algebra/Monoid/Base.agda              |   10 +
 Cubical/Algebra/Ring/Properties.agda          |   43 +
 .../ZariskiLattice/Properties.agda            |    1 +
 .../ZariskiLattice/StructureSheaf.agda        |    3 +-
 .../StructureSheafPullback.agda               |    3 +-
 Cubical/CW/ChainComplex.agda                  |  102 +-
 Cubical/CW/Homology.agda                      |  228 +-
 Cubical/CW/Homotopy.agda                      |  267 +-
 Cubical/CW/Map.agda                           |   82 +-
 Cubical/CW/Subcomplex.agda                    |   51 +-
 .../Categories/Constructions/SubObject.agda   |   14 +-
 .../DistLatticeSheaf/Extension.agda           |    9 +-
 .../RezkCompletion/Construction.agda          |  387 ++-
 Cubical/Data/Cardinal/Properties.agda         |    7 +-
 Cubical/Data/Fin/Inductive/Properties.agda    |    6 +
 Cubical/Data/Fin/LehmerCode.agda              |    6 +-
 Cubical/Data/FinSet/Cardinality.agda          |    2 +-
 Cubical/Data/FinSet/Constructors.agda         |    2 +-
 Cubical/Data/Int/Base.agda                    |   19 +-
 Cubical/Data/Int/Order.agda                   |   16 +-
 Cubical/Data/Int/Properties.agda              |   21 +-
 Cubical/Data/Nat/Order.agda                   |  111 +
 Cubical/Data/Nat/Properties.agda              |    8 +-
 Cubical/Data/Ordinal/Properties.agda          |   10 +-
 Cubical/Data/Rationals/Order.agda             |  116 +-
 Cubical/Data/Rationals/Order/Properties.agda  |  278 +-
 Cubical/Data/Rationals/Properties.agda        |  117 +
 Cubical/Data/Sum/Properties.agda              |   17 +-
 Cubical/Data/SumFin/Properties.agda           |    2 +-
 .../ZCohomologyOld/Properties.agda            |    2 +-
 Cubical/Foundations/HLevels.agda              |    9 +
 Cubical/Foundations/Pointed/Properties.agda   |    8 +
 Cubical/Foundations/Prelude.agda              |    4 +
 Cubical/Foundations/Transport.agda            |    4 +
 Cubical/Functions/Embedding.agda              |   76 +-
 Cubical/Functions/Image.agda                  |    7 +-
 Cubical/Functions/Preimage.agda               |   58 +
 Cubical/HITs/CauchyReals/Base.agda            |    2 +-
 Cubical/HITs/CauchyReals/Bisect.agda          | 1338 +++++++++
 Cubical/HITs/CauchyReals/BisectApprox.agda    | 1775 +++++++++++
 Cubical/HITs/CauchyReals/Closeness.agda       |   22 +-
 Cubical/HITs/CauchyReals/Continuous.agda      | 1457 ++++++---
 Cubical/HITs/CauchyReals/Derivative.agda      |  721 ++++-
 Cubical/HITs/CauchyReals/ExpLog.agda          |  209 ++
 Cubical/HITs/CauchyReals/Exponentiation.agda  | 2331 +++++++++++++++
 .../HITs/CauchyReals/ExponentiationDer.agda   | 1584 ++++++++++
 .../HITs/CauchyReals/ExponentiationMore.agda  | 2252 ++++++++++++++
 Cubical/HITs/CauchyReals/Integration.agda     | 2608 +++++++++++++++++
 Cubical/HITs/CauchyReals/IntegrationMore.agda | 1266 ++++++++
 Cubical/HITs/CauchyReals/Inverse.agda         | 1814 ++++++++----
 Cubical/HITs/CauchyReals/Lems.agda            |   89 +
 Cubical/HITs/CauchyReals/Lipschitz.agda       |   20 +
 Cubical/HITs/CauchyReals/MeanValue.agda       |  610 ++++
 Cubical/HITs/CauchyReals/Multiplication.agda  | 1267 ++++----
 Cubical/HITs/CauchyReals/NthRoot.agda         |  581 ++++
 Cubical/HITs/CauchyReals/Order.agda           |  798 +++--
 Cubical/HITs/CauchyReals/Sequence.agda        | 1259 +++++---
 Cubical/HITs/James/Stable.agda                |   87 +
 Cubical/HITs/Join/Properties.agda             |    9 +
 Cubical/HITs/Pushout/Properties.agda          |   64 +
 Cubical/HITs/SetTruncation/Properties.agda    |   35 +-
 Cubical/HITs/SmashProduct/Base.agda           |    7 +-
 Cubical/HITs/Susp/Properties.agda             |   44 +
 Cubical/HITs/Susp/SuspProduct.agda            |  236 ++
 Cubical/HITs/Wedge/Base.agda                  |    8 +
 Cubical/HITs/Wedge/Properties.agda            |  102 +-
 .../Homotopy/EilenbergMacLane/Properties.agda |   28 +
 Cubical/Homotopy/HiltonMilnor.agda            |   96 +
 Cubical/Homotopy/Loopspace.agda               |   78 +
 Cubical/README.agda                           |    2 +-
 Cubical/Relation/Binary/Base.agda             |   30 +-
 Cubical/Relation/Binary/Order.agda            |    6 +-
 .../Relation/Binary/Order/Apartness/Base.agda |    4 +-
 .../Binary/Order/Apartness/Properties.agda    |   18 +
 Cubical/Relation/Binary/Order/Loset/Base.agda |    6 +-
 .../Binary/Order/Loset/Properties.agda        |   93 +-
 Cubical/Relation/Binary/Order/Poset/Base.agda |   20 +-
 .../Order/Poset/Instances/Embedding.agda      |  145 +
 .../Relation/Binary/Order/Poset/Mappings.agda | 1228 ++++++++
 .../Binary/Order/Poset/Properties.agda        |  583 +++-
 .../Relation/Binary/Order/Poset/Subset.agda   |  249 ++
 Cubical/Relation/Binary/Order/Preorder.agda   |    5 -
 .../Relation/Binary/Order/Preorder/Base.agda  |  135 -
 .../Binary/Order/Preorder/Properties.agda     |   57 -
 Cubical/Relation/Binary/Order/Properties.agda |  302 --
 Cubical/Relation/Binary/Order/Proset.agda     |    5 +
 .../Relation/Binary/Order/Proset/Base.agda    |  138 +
 .../Binary/Order/Proset/Properties.agda       |  434 +++
 Cubical/Relation/Binary/Order/Quoset.agda     |    5 +
 .../Relation/Binary/Order/Quoset/Base.agda    |  126 +
 .../Binary/Order/Quoset/Properties.agda       |   80 +
 .../Binary/Order/QuosetReasoning.agda         |  138 +
 .../Relation/Binary/Order/StrictOrder.agda    |    5 +
 .../Binary/Order/StrictOrder/Base.agda        |  130 +
 .../Binary/Order/StrictOrder/Properties.agda  |  120 +
 .../Relation/Binary/Order/StrictPoset.agda    |    5 -
 .../Binary/Order/StrictPoset/Base.agda        |  126 -
 .../Binary/Order/StrictPoset/Properties.agda  |   94 -
 Cubical/Relation/Binary/Order/Toset/Base.agda |    6 +-
 .../Binary/Order/Toset/Properties.agda        |  337 ++-
 .../Binary/Order/Woset/Properties.agda        |   32 +-
 .../Binary/Order/Woset/Simulation.agda        |    2 +-
 Cubical/Relation/Binary/Properties.agda       |   28 +-
 GNUmakefile                                   |    2 +-
 README.md                                     |    6 +-
 RELEASE.md                                    |    2 +
 cubical-utils.cabal                           |    4 +-
 cubical.agda-lib                              |    2 +-
 flake.lock                                    |   66 +-
 flake.nix                                     |    7 +-
 122 files changed, 26705 insertions(+), 3499 deletions(-)
 create mode 100644 Cubical/Algebra/Group/Five.agda
 create mode 100644 Cubical/Functions/Preimage.agda
 create mode 100644 Cubical/HITs/CauchyReals/Bisect.agda
 create mode 100644 Cubical/HITs/CauchyReals/BisectApprox.agda
 create mode 100644 Cubical/HITs/CauchyReals/ExpLog.agda
 create mode 100644 Cubical/HITs/CauchyReals/Exponentiation.agda
 create mode 100644 Cubical/HITs/CauchyReals/ExponentiationDer.agda
 create mode 100644 Cubical/HITs/CauchyReals/ExponentiationMore.agda
 create mode 100644 Cubical/HITs/CauchyReals/Integration.agda
 create mode 100644 Cubical/HITs/CauchyReals/IntegrationMore.agda
 create mode 100644 Cubical/HITs/CauchyReals/MeanValue.agda
 create mode 100644 Cubical/HITs/CauchyReals/NthRoot.agda
 create mode 100644 Cubical/HITs/James/Stable.agda
 create mode 100644 Cubical/HITs/Susp/SuspProduct.agda
 create mode 100644 Cubical/Homotopy/HiltonMilnor.agda
 create mode 100644 Cubical/Relation/Binary/Order/Poset/Instances/Embedding.agda
 create mode 100644 Cubical/Relation/Binary/Order/Poset/Mappings.agda
 create mode 100644 Cubical/Relation/Binary/Order/Poset/Subset.agda
 delete mode 100644 Cubical/Relation/Binary/Order/Preorder.agda
 delete mode 100644 Cubical/Relation/Binary/Order/Preorder/Base.agda
 delete mode 100644 Cubical/Relation/Binary/Order/Preorder/Properties.agda
 delete mode 100644 Cubical/Relation/Binary/Order/Properties.agda
 create mode 100644 Cubical/Relation/Binary/Order/Proset.agda
 create mode 100644 Cubical/Relation/Binary/Order/Proset/Base.agda
 create mode 100644 Cubical/Relation/Binary/Order/Proset/Properties.agda
 create mode 100644 Cubical/Relation/Binary/Order/Quoset.agda
 create mode 100644 Cubical/Relation/Binary/Order/Quoset/Base.agda
 create mode 100644 Cubical/Relation/Binary/Order/Quoset/Properties.agda
 create mode 100644 Cubical/Relation/Binary/Order/QuosetReasoning.agda
 create mode 100644 Cubical/Relation/Binary/Order/StrictOrder.agda
 create mode 100644 Cubical/Relation/Binary/Order/StrictOrder/Base.agda
 create mode 100644 Cubical/Relation/Binary/Order/StrictOrder/Properties.agda
 delete mode 100644 Cubical/Relation/Binary/Order/StrictPoset.agda
 delete mode 100644 Cubical/Relation/Binary/Order/StrictPoset/Base.agda
 delete mode 100644 Cubical/Relation/Binary/Order/StrictPoset/Properties.agda

diff --git a/.github/workflows/ci-ubuntu.yml b/.github/workflows/ci-ubuntu.yml
index d8b3b347c4..011f755977 100644
--- a/.github/workflows/ci-ubuntu.yml
+++ b/.github/workflows/ci-ubuntu.yml
@@ -42,9 +42,9 @@ on:
 ########################################################################
 
 env:
-  AGDA_BRANCH: v2.6.4.1
-  GHC_VERSION: 9.4.7
-  CABAL_VERSION: 3.6.2.0
+  AGDA_BRANCH: v2.7.0.1
+  GHC_VERSION: 9.10.2
+  CABAL_VERSION: 3.12.1.0
   CABAL_INSTALL: cabal install --overwrite-policy=always --ghc-options='-O1 +RTS -M6G -RTS'
   CACHE_PATHS: |
     ~/.cabal/packages
@@ -67,7 +67,7 @@ jobs:
       # absolutely necessary i.e. if we change either the version of Agda,
       # ghc, or cabal that we want to use for the build.
       - name: Restore external dependencies cache
-        uses: actions/cache/restore@v3
+        uses: actions/cache/restore@v4
         id: cache-external-restore
         with:
           path: ${{ env.CACHE_PATHS }}
@@ -82,23 +82,13 @@ jobs:
         run: |
           git clone https://github.com/agda/agda --branch ${{ env.AGDA_BRANCH }} --depth=1
           cd agda
-          mkdir -p doc
-          touch doc/user-manual.pdf
           ${{ env.CABAL_INSTALL }}
           cd ..
           rm -rf agda
 
-      - name: Download and install fix-whitespace
-        if: steps.cache-external-restore.outputs.cache-hit != 'true'
-        run: |
-          git clone https://github.com/agda/fix-whitespace --depth=1
-          cd fix-whitespace
-          ${{ env.CABAL_INSTALL }} fix-whitespace.cabal
-          cd ..
-
       - name: Save external dependencies cache
         if: steps.cache-external-restore.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v3
+        uses: actions/cache/save@v4
         id: cache-external-save
         with:
           path: ${{ env.CACHE_PATHS }}
@@ -110,14 +100,17 @@ jobs:
 
       # By default github actions do not pull the repo
       - name: Checkout cubical
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
+
+      - name: Get and run fix-whitespace
+        uses: andreasabel/fix-whitespace-action@v1
 
       ########################################################################
       ## TESTING
       ########################################################################
 
       - name: Restore library cache
-        uses: actions/cache/restore@v3
+        uses: actions/cache/restore@v4
         id: cache-library-restore
         with:
           path: ./_build
@@ -125,19 +118,19 @@ jobs:
           restore-keys: |
             library-${{ runner.os }}-${{ env.GHC_VERSION }}-${{ env.CABAL_VERSION }}-${{ env.AGDA_BRANCH }}-
 
-      - name: Put cabal programs in PATH
+      - name: Put installed programs in PATH
         run: echo "~/.cabal/bin" >> "${GITHUB_PATH}"
 
       - name: Test cubical
         run: |
           make test \
             AGDA_EXEC='~/.cabal/bin/agda -WnoUnsupportedIndexedMatch -W error' \
-            FIX_WHITESPACE='~/.cabal/bin/fix-whitespace' \
+            FIX_WHITESPACE='~/.local/fix-whitespace/bin/fix-whitespace' \
             EVERYTHINGS='cabal run Everythings'
 
       - name: Save library cache
         if: steps.cache-library-restore.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v3
+        uses: actions/cache/save@v4
         id: cache-library-save
         with:
           path: ./_build
@@ -152,12 +145,12 @@ jobs:
         run: |
           make listings \
             AGDA_EXEC='~/.cabal/bin/agda -WnoUnsupportedIndexedMatch -W error' \
-            FIX_WHITESPACE='~/.cabal/bin/fix-whitespace' \
+            FIX_WHITESPACE='~/.local/fix-whitespace/bin/fix-whitespace' \
             EVERYTHINGS='cabal run Everythings'
 
       - name: Deploy to GitHub Pages
         if: github.event_name == 'push' && github.ref_name == 'master'
-        uses: JamesIves/github-pages-deploy-action@4.1.8
+        uses: JamesIves/github-pages-deploy-action@v4
         with:
           branch: gh-pages
           folder: html
diff --git a/CITATION.cff b/CITATION.cff
index 048a89cdaf..da5f7ddd2c 100644
--- a/CITATION.cff
+++ b/CITATION.cff
@@ -3,6 +3,6 @@ message: "If you use this software, please cite it as below."
 authors:
 - name: "The Agda Community"
 title: "Cubical Agda Library"
-version: 0.7
-date-released: 2024-02-12
+version: 0.8
+date-released: 2025-05-09
 url: "https://github.com/agda/cubical"
diff --git a/Cubical/Algebra/AbGroup/Instances/FreeAbGroup.agda b/Cubical/Algebra/AbGroup/Instances/FreeAbGroup.agda
index 53f6b48a79..f16052a98e 100644
--- a/Cubical/Algebra/AbGroup/Instances/FreeAbGroup.agda
+++ b/Cubical/Algebra/AbGroup/Instances/FreeAbGroup.agda
@@ -19,6 +19,7 @@ open import Cubical.HITs.FreeAbGroup
 open import Cubical.Algebra.AbGroup
 open import Cubical.Algebra.AbGroup.Instances.Pi
 open import Cubical.Algebra.AbGroup.Instances.Int
+open import Cubical.Algebra.AbGroup.Instances.DirectProduct
 open import Cubical.Algebra.Group
 open import Cubical.Algebra.Group.Morphisms
 open import Cubical.Algebra.Group.MorphismProperties
@@ -413,3 +414,49 @@ agreeOnℤFinGenerator→≡ {n} {m} {ϕ} {ψ} idr =
       λ f p → IsGroupHom.presinv (snd ϕ) f
            ∙∙ (λ i x → -ℤ (p i x))
            ∙∙ sym (IsGroupHom.presinv (snd ψ) f)))
+
+--
+sumCoefficients : (n : ℕ) → AbGroupHom (ℤ[Fin n ]) (ℤ[Fin 1 ])
+fst (sumCoefficients n) v = λ _ → sumFinℤ v
+snd (sumCoefficients n) = makeIsGroupHom (λ x y → funExt λ _ → sumFinℤHom x y)
+
+ℤFinProductIso : (n m : ℕ) → Iso (ℤ[Fin (n +ℕ m) ] .fst) ((AbDirProd ℤ[Fin n ] ℤ[Fin m ]) .fst)
+ℤFinProductIso n m = iso sum→product product→sum product→sum→product sum→product→sum
+  where
+    sum→product : (ℤ[Fin (n +ℕ m) ] .fst) → ((AbDirProd ℤ[Fin n ] ℤ[Fin m ]) .fst)
+    sum→product x = ((λ (a , Ha) → x (a , <→<ᵗ (≤-trans (<ᵗ→< Ha) (≤SumLeft {n}{m}))))
+                    , λ (a , Ha) → x (n +ℕ a , <→<ᵗ (<-k+ {a}{m}{n} (<ᵗ→< Ha))))
+
+    product→sum : ((AbDirProd ℤ[Fin n ] ℤ[Fin m ]) .fst) → (ℤ[Fin (n +ℕ m) ] .fst)
+    product→sum (x , y) (a , Ha) with (a ≟ᵗ n)
+    ... | lt H = x (a , H)
+    ... | eq H = y (a ∸ n , <→<ᵗ (subst (a ∸ n <_) (∸+ m n) (<-∸-< a (n +ℕ m) n (<ᵗ→< Ha) (subst (λ a → a < n +ℕ m) H (<ᵗ→< Ha)))))
+    ... | gt H = y (a ∸ n , <→<ᵗ (subst (a ∸ n <_) (∸+ m n) (<-∸-< a (n +ℕ m) n (<ᵗ→< Ha) (<ᵗ→< (<ᵗ-trans {n}{a}{n +ℕ m} H Ha)))))
+
+    product→sum→product : ∀ x → sum→product (product→sum x) ≡ x
+    product→sum→product (x , y) = ≡-× (funExt (λ (a , Ha) → lemx a Ha)) (funExt (λ (a , Ha) → lemy a Ha))
+      where
+        lemx : (a : ℕ) (Ha : a <ᵗ n) → fst (sum→product (product→sum (x , y))) (a , Ha) ≡ x (a , Ha)
+        lemx a Ha with (a ≟ᵗ n)
+        ... | lt H = cong x (Fin≡ (a , H) (a , Ha) refl)
+        ... | eq H = rec (¬m<ᵗm (subst (λ a → a <ᵗ n) H Ha))
+        ... | gt H = rec (¬m<ᵗm (<ᵗ-trans Ha H))
+
+        lemy : (a : ℕ) (Ha : a <ᵗ m) → snd (sum→product (product→sum (x , y))) (a , Ha) ≡ y (a , Ha)
+        lemy a Ha with ((n +ℕ a) ≟ᵗ n)
+        ... | lt H = rec (¬m<m (≤<-trans (≤SumLeft {n}{a}) (<ᵗ→< H)))
+        ... | eq H = cong y (Fin≡ _ _ (∸+ a n))
+        ... | gt H = cong y (Fin≡ _ _ (∸+ a n))
+
+    sum→product→sum : ∀ x → product→sum (sum→product x) ≡ x
+    sum→product→sum x = funExt (λ (a , Ha) → lem a Ha)
+      where
+        lem : (a : ℕ) (Ha : a <ᵗ (n +ℕ m)) → product→sum (sum→product x) (a , Ha) ≡ x (a , Ha)
+        lem a Ha with (a ≟ᵗ n)
+        ... | lt H = cong x (Fin≡ _ _ refl)
+        ... | eq H = cong x (Fin≡ _ _ ((+-comm n (a ∸ n)) ∙ ≤-∸-+-cancel (subst (n ≤_) (sym H) ≤-refl)))
+        ... | gt H = cong x (Fin≡ _ _ ((+-comm n (a ∸ n)) ∙ ≤-∸-+-cancel (<-weaken (<ᵗ→< H))))
+
+ℤFinProduct : (n m : ℕ) → AbGroupIso ℤ[Fin (n +ℕ m) ] (AbDirProd ℤ[Fin n ] ℤ[Fin m ])
+fst (ℤFinProduct n m) = ℤFinProductIso n m
+snd (ℤFinProduct n m) = makeIsGroupHom (λ x y → refl)
diff --git a/Cubical/Algebra/Algebra/Properties.agda b/Cubical/Algebra/Algebra/Properties.agda
index 0bffb60665..1631e45053 100644
--- a/Cubical/Algebra/Algebra/Properties.agda
+++ b/Cubical/Algebra/Algebra/Properties.agda
@@ -110,7 +110,7 @@ module AlgebraEquivs where
     (invAlgebraEquiv {A = A} {B = B} f').snd = hom
       where
         open AlgebraStr {{...}}
-        private instance
+        instance
           _ = snd A
           _ = snd B
 
diff --git a/Cubical/Algebra/ChainComplex/Homology.agda b/Cubical/Algebra/ChainComplex/Homology.agda
index 99d4dffd2d..fb9bd798f0 100644
--- a/Cubical/Algebra/ChainComplex/Homology.agda
+++ b/Cubical/Algebra/ChainComplex/Homology.agda
@@ -35,42 +35,30 @@ open ChainComplex
 open finChainComplexMap
 open IsGroupHom
 
--- Definition of homology
-homology : (n : ℕ) → ChainComplex ℓ → Group ℓ
-homology n C = ker∂n / img∂+1⊂ker∂n
-  where
-  Cn+2 = AbGroup→Group (chain C (suc (suc n)))
-  ∂n = bdry C n
-  ∂n+1 = bdry C (suc n)
-  ker∂n = kerGroup ∂n
-
-  -- Restrict ∂n+1 to ker∂n
-  ∂'-fun : Cn+2 .fst → ker∂n .fst
-  fst (∂'-fun x) = ∂n+1 .fst x
-  snd (∂'-fun x) = t
-    where
-    opaque
-     t : ⟨ fst (kerSubgroup ∂n) (∂n+1 .fst x) ⟩
-     t = funExt⁻ (cong fst (bdry²=0 C n)) x
+module _ (n : ℕ) (C : ChainComplex ℓ) where
+  ker∂n = kerGroup (bdry C n)
 
-  ∂' : GroupHom Cn+2 ker∂n
-  fst ∂' = ∂'-fun
-  snd ∂' = isHom
+  ∂ker : GroupHom (AbGroup→Group (chain C (suc (suc n)))) ker∂n
+  ∂ker .fst x = (bdry C (suc n) .fst x) , t
     where
     opaque
-      isHom : IsGroupHom (Cn+2 .snd) ∂'-fun (ker∂n .snd)
-      isHom = makeIsGroupHom λ x y
-        → kerGroup≡ ∂n (∂n+1 .snd .pres· x y)
+     t : ⟨ fst (kerSubgroup (bdry C n)) (bdry C (suc n) .fst x) ⟩
+     t = funExt⁻ (cong fst (bdry²=0 C n)) x
+  ∂ker .snd = makeIsGroupHom (λ x y → kerGroup≡ (bdry C n) ((bdry C (suc n) .snd .pres· x y)))
 
   img∂+1⊂ker∂n : NormalSubgroup ker∂n
-  fst img∂+1⊂ker∂n = imSubgroup ∂'
+  fst img∂+1⊂ker∂n = imSubgroup ∂ker
   snd img∂+1⊂ker∂n = isNormalImSubGroup
     where
     opaque
       module C1 = AbGroupStr (chain C (suc n)  .snd)
-      isNormalImSubGroup : isNormal (imSubgroup ∂')
-      isNormalImSubGroup = isNormalIm ∂'
-        (λ x y → kerGroup≡ ∂n (C1.+Comm (fst x) (fst y)))
+      isNormalImSubGroup : isNormal (imSubgroup ∂ker)
+      isNormalImSubGroup = isNormalIm ∂ker
+        (λ x y → kerGroup≡ (bdry C n) (C1.+Comm (fst x) (fst y)))
+
+-- Definition of homology
+homology : (n : ℕ) → ChainComplex ℓ → Group ℓ
+homology n C = (ker∂n n C) / (img∂+1⊂ker∂n n C)
 
 -- Induced maps on cohomology by finite chain complex maps/homotopies
 module _ where
diff --git a/Cubical/Algebra/CommMonoid/Properties.agda b/Cubical/Algebra/CommMonoid/Properties.agda
index 4926c3dc0b..c6e7ec1b9e 100644
--- a/Cubical/Algebra/CommMonoid/Properties.agda
+++ b/Cubical/Algebra/CommMonoid/Properties.agda
@@ -57,3 +57,19 @@ module CommMonoidTheory (M' : CommMonoid ℓ) where
  commAssocSwap : (x y z w : M) → (x · y) · (z · w) ≡ (x · z) · (y · w)
  commAssocSwap x y z w = ·Assoc (x · y) z w ∙∙ cong (_· w) (commAssocr x y z)
                                                ∙∙ sym (·Assoc (x · z) y w)
+
+ hasInverse : (x : M) → Type ℓ
+ hasInverse x = Σ[ -x ∈ M ] -x · x ≡ ε
+
+ isPropHasInverse : ∀ x → isProp (hasInverse x)
+ isPropHasInverse x yinv zinv
+   = Σ≡Prop (λ a → is-set (a · x) ε)
+    (PathPΣ (MonoidTheory.isPropHasInverse (CommMonoid→Monoid M') x
+                                           (hasInverseToMonoid x yinv)
+                                           (hasInverseToMonoid x zinv))
+                                               .fst)
+   where
+     hasInverseToMonoid : ∀ x
+                        → hasInverse x
+                        → MonoidTheory.hasInverse (CommMonoid→Monoid M') x
+     hasInverseToMonoid x (y , yinv) = y , yinv , ·Comm x y ∙ yinv
diff --git a/Cubical/Algebra/CommRing/Localisation/UniversalProperty.agda b/Cubical/Algebra/CommRing/Localisation/UniversalProperty.agda
index 0c89652f21..1a11d384dd 100644
--- a/Cubical/Algebra/CommRing/Localisation/UniversalProperty.agda
+++ b/Cubical/Algebra/CommRing/Localisation/UniversalProperty.agda
@@ -373,12 +373,10 @@ module _ (R' : CommRing ℓ) (S' : ℙ (fst R')) (SMultClosedSubset : isMultClos
                                       ; ·IdR to ·A-rid)
   open Units A' renaming (Rˣ to Aˣ ; RˣInvClosed to AˣInvClosed)
   open PathToS⁻¹R ⦃...⦄
-  private
-   A = fst A'
-   instance
-    _ = cond
-   χ = (S⁻¹RHasUniversalProp A' φ φS⊆Aˣ .fst .fst)
-   open RingHomTheory χ
+  A = fst A'
+  instance _ = cond
+  χ = (S⁻¹RHasUniversalProp A' φ φS⊆Aˣ .fst .fst)
+  open RingHomTheory χ
 
   S⁻¹R≃A : S⁻¹R ≃ A
   S⁻¹R≃A = fst χ , isEmbedding×isSurjection→isEquiv (Embχ , Surχ)
diff --git a/Cubical/Algebra/DistLattice/Downset.agda b/Cubical/Algebra/DistLattice/Downset.agda
index 907c419732..3c52245edf 100644
--- a/Cubical/Algebra/DistLattice/Downset.agda
+++ b/Cubical/Algebra/DistLattice/Downset.agda
@@ -16,6 +16,7 @@ open import Cubical.Algebra.Lattice
 open import Cubical.Algebra.DistLattice.Base
 
 open import Cubical.Relation.Binary.Order.Poset
+open import Cubical.Relation.Binary.Order.Poset.Subset
 
 open Iso
 
diff --git a/Cubical/Algebra/Group/Exact.agda b/Cubical/Algebra/Group/Exact.agda
index 6ba146876a..c894961f1b 100644
--- a/Cubical/Algebra/Group/Exact.agda
+++ b/Cubical/Algebra/Group/Exact.agda
@@ -1,11 +1,22 @@
 {-# OPTIONS --safe #-}
+
 module Cubical.Algebra.Group.Exact where
 
 open import Cubical.Foundations.Prelude
 open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Isomorphism
 open import Cubical.Foundations.Function
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.HLevels
 
+open import Cubical.Data.Empty
+open import Cubical.Data.Fin
+open import Cubical.Data.Nat
+open import Cubical.Data.Nat.Order
+open import Cubical.Data.Sigma
+open import Cubical.Data.Sum
 open import Cubical.Data.Unit
+open import Cubical.Data.Vec
 
 open import Cubical.Algebra.Group.Base
 open import Cubical.Algebra.Group.Morphisms
@@ -15,11 +26,23 @@ open import Cubical.Algebra.Group.Instances.Unit
 
 open import Cubical.HITs.PropositionalTruncation as PT
 
+private
+  variable
+    ℓ ℓ' : Level
+
+record IsExactAt {ℓ ℓ' ℓ'' : Level}
+                 {A : Group ℓ} {B : Group ℓ'} {C : Group ℓ''}
+                 (f : GroupHom A B) (g : GroupHom B C) (b : ⟨ B ⟩)
+                 : Type (ℓ-max ℓ (ℓ-max ℓ' ℓ'')) where
+  field
+    im∈ker : isInIm f b → isInKer g b
+    ker∈im : isInKer g b → isInIm f b
+open IsExactAt public
 
--- TODO : Define exact sequences
--- (perhaps short, finite, ℕ-indexed and ℤ-indexed)
+IsExact : {A B C : Group ℓ} (f : GroupHom A B) (g : GroupHom B C) → Type ℓ
+IsExact {B = B} f g = (b : ⟨ B ⟩) → IsExactAt f g b
 
-SES→isEquiv : ∀ {ℓ ℓ'} {L R : Group ℓ-zero}
+SES→isEquiv : {L R : Group ℓ-zero}
   → {G : Group ℓ} {H : Group ℓ'}
   → UnitGroup₀ ≡ L
   → UnitGroup₀ ≡ R
@@ -138,3 +161,4 @@ transportExact4 {G = G} {G₂ = G₂} {H = H} {H₂ = H₂} {L = L} {L₂ = L₂
       (J (λ z q → (r : x₃ ≡ w) (s : x₄ ≡ u) → B x z w u refl q r s)
         (J (λ w r → (s : x₄ ≡ u) → B x x₂ w u refl refl r s)
           (J (λ u s → B x x₂ x₃ u refl refl refl s) b)))
+
diff --git a/Cubical/Algebra/Group/Five.agda b/Cubical/Algebra/Group/Five.agda
new file mode 100644
index 0000000000..b8975036f5
--- /dev/null
+++ b/Cubical/Algebra/Group/Five.agda
@@ -0,0 +1,265 @@
+{-# OPTIONS --safe #-}
+
+-- This module proves the Five lemma[1] over group homomorphisms.
+--
+-- [1]: https://en.wikipedia.org/wiki/Five_lemma
+
+module Cubical.Algebra.Group.Five where
+
+open import Agda.Primitive
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Isomorphism
+
+open import Cubical.HITs.PropositionalTruncation.Base
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.Algebra.Group.Base
+open import Cubical.Algebra.Group.Exact
+open import Cubical.Algebra.Group.MorphismProperties
+open import Cubical.Algebra.Group.Morphisms
+
+open BijectionIso
+open IsGroupHom
+
+private
+  variable
+    ℓ ℓ' : Level
+
+module _
+  {A B C D E A' B' C' D' E' : Group ℓ}
+  {f : GroupHom A B} {g : GroupHom B C} {h : GroupHom C D} {j : GroupHom D E}
+  {l : GroupHom A A'} {m : BijectionIso B B'} {n : GroupHom C C'} {p : BijectionIso D D'} {q : GroupHom E E'}
+  {r : GroupHom A' B'} {s : GroupHom B' C'} {t : GroupHom C' D'} {u : GroupHom D' E'}
+  (fg : IsExact f g) (gh : IsExact g h) (hj : IsExact h j)
+  (rs : IsExact r s) (st : IsExact s t) (tu : IsExact t u)
+  (lSurj : isSurjective l)
+  (qInj : isInjective q)
+  (sq1 : (a : fst A) → r .fst (l .fst a) ≡ m .fun .fst (f .fst a))
+  (sq2 : (b : fst B) → s .fst (m .fun .fst b) ≡ n .fst (g .fst b))
+  (sq3 : (c : fst C) → t .fst (n .fst c) ≡ p .fun .fst (h .fst c))
+  (sq4 : (d : fst D) → u .fst (p .fun .fst d) ≡ q .fst (j .fst d))
+  where
+    module _ where
+      nInjective : isInjective n
+      nInjective c c-in-ker[n] = goal where
+        goalTy = c ≡ C .snd .GroupStr.1g
+        goalTyIsProp = let open GroupStr (C .snd) in is-set c 1g
+        untrunc = λ (p : ∥ goalTy ∥₁) → PT.rec goalTyIsProp (λ x → x) p
+
+        t[n[c]]≡0 : t .fst (n .fst c) ≡ D' .snd .GroupStr.1g
+        t[n[c]]≡0 = cong (t .fst) c-in-ker[n] ∙ t .snd .pres1
+
+        t[n[c]]≡p[h[c]] : t .fst (n .fst c) ≡ p .fun .fst (h .fst c)
+        t[n[c]]≡p[h[c]] = sq3 c
+
+        p[h[c]]≡0 : p .fun .fst (h .fst c) ≡ D' .snd .GroupStr.1g
+        p[h[c]]≡0 = sym t[n[c]]≡p[h[c]] ∙ t[n[c]]≡0
+
+        h[c]≡0 : h .fst c ≡ D .snd .GroupStr.1g
+        h[c]≡0 = p .inj (h .fst c) p[h[c]]≡0
+
+        c-in-ker[h] : isInKer h c
+        c-in-ker[h] = h[c]≡0
+
+        c-in-im[g] : isInIm g c
+        c-in-im[g] = gh c .ker∈im c-in-ker[h]
+
+        rest : (b : ⟨ B ⟩) → (g .fst b ≡ c) → goalTy
+
+        goal = untrunc (PT.map (λ x → rest (fst x) (snd x)) c-in-im[g])
+
+        rest b g[b]≡c = goal2 where
+
+          n[g[b]]≡0 : n .fst (g .fst b) ≡ C' .snd .GroupStr.1g
+          n[g[b]]≡0 = cong (n .fst) g[b]≡c ∙ c-in-ker[n]
+
+          m[b] : ⟨ B' ⟩
+          m[b] = m .fun .fst b
+
+          s[m[b]]≡n[g[b]] : s .fst m[b] ≡ n .fst (g .fst b)
+          s[m[b]]≡n[g[b]] = sq2 b
+
+          s[m[b]]≡0 : s .fst m[b] ≡ C' .snd .GroupStr.1g
+          s[m[b]]≡0 = s[m[b]]≡n[g[b]] ∙ n[g[b]]≡0
+
+          m[b]-in-ker[s] : isInKer s m[b]
+          m[b]-in-ker[s] = s[m[b]]≡0
+
+          m[b]-in-im[r] : isInIm r m[b]
+          m[b]-in-im[r] = rs m[b] .ker∈im m[b]-in-ker[s]
+
+          rest2 : (a' : ⟨ A' ⟩) → (r .fst a' ≡ m[b]) → (a : ⟨ A ⟩) → l .fst a ≡ a' → goalTy
+
+          goal2 =
+            let inner = λ x → untrunc (PT.map (λ y → rest2 (x .fst) (x .snd) (y .fst) (y .snd)) (lSurj (x .fst))) in
+            untrunc (PT.map inner m[b]-in-im[r])
+
+          rest2 a' r[a']≡m[b] a l[a]≡a' = c≡0 where
+
+            m[f[a]] : ⟨ B' ⟩
+            m[f[a]] = m .fun .fst (f .fst a)
+
+            r[l[a]]≡m[f[a]] : r .fst (l .fst a) ≡ m[f[a]]
+            r[l[a]]≡m[f[a]] = sq1 a
+
+            m[f[a]]≡m[b] : m[f[a]] ≡ m[b]
+            m[f[a]]≡m[b] = sym r[l[a]]≡m[f[a]] ∙ cong (r .fst) l[a]≡a' ∙ r[a']≡m[b]
+
+            f[a]≡b : f .fst a ≡ b
+            f[a]≡b = isInjective→isMono (m .fun) (m .inj) m[f[a]]≡m[b]
+
+            g[f[a]]≡c : g .fst (f .fst a) ≡ c
+            g[f[a]]≡c = cong (g .fst) f[a]≡b ∙ g[b]≡c
+
+            f[a]-in-im[f] : isInIm f (f .fst a)
+            f[a]-in-im[f] = ∣ a , refl ∣₁
+
+            f[a]-in-ker[g] : isInKer g (f .fst a)
+            f[a]-in-ker[g] = fg (f .fst a) .im∈ker f[a]-in-im[f]
+
+            g[f[a]]≡0 : g .fst (f .fst a) ≡ C .snd .GroupStr.1g
+            g[f[a]]≡0 = f[a]-in-ker[g]
+
+            c≡0 : c ≡ C .snd .GroupStr.1g
+            c≡0 = sym g[f[a]]≡c ∙ g[f[a]]≡0
+
+    module _ where
+      nSurjective : isSurjective n
+      nSurjective c' = goal where
+        goalTy = isInIm n c'
+        untrunc = λ (p : ∥ goalTy ∥₁) → PT.rec (isPropIsInIm n c') (λ x → x) p
+
+        d' : ⟨ D' ⟩
+        d' = t .fst c'
+
+        pGroupIso = BijectionIso→GroupIso p
+        pIso = pGroupIso .fst
+        pInv = Iso.inv pIso
+
+        d : ⟨ D ⟩
+        d = pInv d'
+
+        p[d]≡t[c'] : p .fun .fst d ≡ t .fst c'
+        p[d]≡t[c'] = Iso.rightInv pIso d'
+
+        u[p[d]] : ⟨ E' ⟩
+        u[p[d]] = u .fst (p .fun .fst d)
+
+        j[d] : ⟨ E ⟩
+        j[d] = j .fst d
+
+        q[j[d]] : ⟨ E' ⟩
+        q[j[d]] = q .fst j[d]
+
+        u[p[d]]≡q[j[d]] : u[p[d]] ≡ q[j[d]]
+        u[p[d]]≡q[j[d]] = sq4 d
+
+        d'-in-ker[u] : isInKer u d'
+        d'-in-ker[u] = tu d' .im∈ker ∣ (c' , refl) ∣₁
+
+        u[p[d]]≡0 : u[p[d]] ≡ E' .snd .GroupStr.1g
+        u[p[d]]≡0 = cong (u .fst) p[d]≡t[c'] ∙ d'-in-ker[u]
+
+        q[j[d]]≡0 : q[j[d]] ≡ E' .snd .GroupStr.1g
+        q[j[d]]≡0 = sym u[p[d]]≡q[j[d]] ∙ u[p[d]]≡0
+
+        j[d]≡0 : j[d] ≡ E .snd .GroupStr.1g
+        j[d]≡0 = qInj j[d] q[j[d]]≡0
+
+        d-in-ker[j] : isInKer j d
+        d-in-ker[j] = j[d]≡0
+
+        d-in-im[h] : isInIm h d
+        d-in-im[h] = hj d .ker∈im d-in-ker[j]
+
+        rest : (c : ⟨ C ⟩) → h .fst c ≡ d → goalTy
+
+        goal = untrunc (PT.map (λ x → rest (x .fst) (x .snd)) d-in-im[h])
+
+        rest c h[c]≡d = goal2 where
+          n[c] : ⟨ C' ⟩
+          n[c] = n .fst c
+
+          t[n[c]]≡p[h[c]] : t .fst n[c] ≡ p .fun .fst (h .fst c)
+          t[n[c]]≡p[h[c]] = sq3 c
+
+          t[n[c]]≡t[c'] : t .fst n[c] ≡ t .fst c'
+          t[n[c]]≡t[c'] =
+            t .fst n[c]             ≡⟨ t[n[c]]≡p[h[c]] ⟩
+            p .fun .fst (h .fst c)  ≡⟨ cong (p .fun .fst) h[c]≡d ⟩
+            p .fun .fst d           ≡⟨ p[d]≡t[c'] ⟩
+            t .fst c' ∎
+
+          c'-n[c] : ⟨ C' ⟩
+          c'-n[c] = let open GroupStr (C' .snd) in c' · (inv n[c])
+
+          t[c'-n[c]]≡0 : t .fst c'-n[c] ≡ D' .snd .GroupStr.1g
+          t[c'-n[c]]≡0 =
+            let open GroupStr (C' .snd) renaming (_·_ to _·ᶜ_; inv to invᶜ; 1g to 1gᶜ) in
+            let open GroupStr (D' .snd) renaming (_·_ to _·ᵈ_; inv to invᵈ; 1g to 1gᵈ) hiding (isGroup) in
+            t .fst (c' ·ᶜ (invᶜ n[c]))          ≡⟨ t .snd .pres· c' (invᶜ n[c]) ⟩
+            (t .fst c') ·ᵈ (t .fst (invᶜ n[c])) ≡⟨ cong ((t .fst c') ·ᵈ_) (t .snd .presinv n[c]) ⟩
+            (t .fst c') ·ᵈ (invᵈ (t .fst n[c])) ≡⟨ cong (λ z → (t .fst c') ·ᵈ (invᵈ z)) t[n[c]]≡t[c'] ⟩
+            (t .fst c') ·ᵈ (invᵈ (t .fst c'))   ≡⟨ cong ((t .fst c') ·ᵈ_) (sym (t .snd .presinv c')) ⟩
+            (t .fst c') ·ᵈ (t .fst (invᶜ c'))   ≡⟨ sym (t .snd .pres· c' (invᶜ c')) ⟩
+            t .fst (c' ·ᶜ (invᶜ c'))            ≡⟨ cong (t .fst) (IsGroup.·InvR isGroup c') ⟩
+            t .fst 1gᶜ                          ≡⟨ t .snd .pres1 ⟩
+            1gᵈ ∎
+
+          [c'-n[c]]-in-ker[t] : isInKer t c'-n[c]
+          [c'-n[c]]-in-ker[t] = t[c'-n[c]]≡0
+
+          [c'-n[c]]-in-im[s] : isInIm s c'-n[c]
+          [c'-n[c]]-in-im[s] = st c'-n[c] .ker∈im [c'-n[c]]-in-ker[t]
+
+          rest2 : (b' : ⟨ B' ⟩) → s .fst b' ≡ c'-n[c] → goalTy
+
+          goal2 = untrunc (PT.map (λ x → rest2 (x .fst) (x .snd)) [c'-n[c]]-in-im[s])
+
+          rest2 b' s[b']≡c'-n[c] = goal3 where
+            mGroupIso = BijectionIso→GroupIso m
+            mIso = mGroupIso .fst
+            mInv = Iso.inv mIso
+
+            b : ⟨ B ⟩
+            b = mInv b'
+
+            m[b]≡b' : m .fun .fst b ≡ b'
+            m[b]≡b' = Iso.rightInv mIso b'
+
+            s[m[b]]≡s[b'] : s .fst (m .fun .fst b) ≡ s .fst b'
+            s[m[b]]≡s[b'] = cong (s .fst) m[b]≡b'
+
+            s[m[b]]≡c'-n[c] : s .fst (m .fun .fst b) ≡ c'-n[c]
+            s[m[b]]≡c'-n[c] = s[m[b]]≡s[b'] ∙ s[b']≡c'-n[c]
+
+            g[b] : ⟨ C ⟩
+            g[b] = g .fst b
+
+            g[b]+c : ⟨ C ⟩
+            g[b]+c = C .snd .GroupStr._·_ g[b] c
+
+            n[g[b]] : ⟨ C' ⟩
+            n[g[b]] = n .fst g[b]
+
+            n[g[b]]≡s[m[b]] : n[g[b]] ≡ s .fst (m .fun .fst b)
+            n[g[b]]≡s[m[b]] = sym (sq2 b)
+
+            n[g[b]]≡c'-n[c] : n[g[b]] ≡ c'-n[c]
+            n[g[b]]≡c'-n[c] = n[g[b]]≡s[m[b]] ∙ s[m[b]]≡c'-n[c]
+
+            n[g[b]]+n[c]≡c' : C' .snd .GroupStr._·_ n[g[b]] n[c] ≡ c'
+            n[g[b]]+n[c]≡c' =
+              let open GroupStr (C' .snd) in
+              cong (_· n[c]) n[g[b]]≡c'-n[c] ∙ sym (·Assoc c' (inv n[c]) n[c]) ∙ cong (c' ·_) (·InvL n[c]) ∙ ·IdR c'
+
+            n[g[b]+c]≡c' : n .fst g[b]+c ≡ c'
+            n[g[b]+c]≡c' = n .snd .pres· g[b] c ∙ n[g[b]]+n[c]≡c'
+
+            goal3 = ∣ (g[b]+c , n[g[b]+c]≡c') ∣₁
+
+    lemma : BijectionIso C C'
+    lemma = bijIso n nInjective nSurjective
diff --git a/Cubical/Algebra/Group/MorphismProperties.agda b/Cubical/Algebra/Group/MorphismProperties.agda
index bc5f285f7d..3bf92551e9 100644
--- a/Cubical/Algebra/Group/MorphismProperties.agda
+++ b/Cubical/Algebra/Group/MorphismProperties.agda
@@ -310,3 +310,18 @@ BijectionIso→GroupIso {G = G} {H = H} i = grIso
 
 BijectionIsoToGroupEquiv : BijectionIso G H → GroupEquiv G H
 BijectionIsoToGroupEquiv i = GroupIso→GroupEquiv (BijectionIso→GroupIso i)
+
+Aut[_] : Group ℓ → Group ℓ
+Aut[ Ĝ@(G , Gstr) ] =
+  makeGroup {G = GroupIso Ĝ Ĝ}
+    idGroupIso compGroupIso
+      invGroupIso  (isSetΣ (isSet-SetsIso (is-set Gstr) (is-set Gstr)) (λ _ → isProp→isSet (isPropIsGroupHom _ _)))
+        (λ _ _ _ → GroupIso≡ (i≡ refl))
+         (λ _ → GroupIso≡ (i≡ refl))
+         (λ _ → GroupIso≡ (i≡ refl))
+         (λ (x , _) → GroupIso≡ (i≡ (funExt (Iso.leftInv x))))
+         (λ (x , _) → GroupIso≡ (i≡ (funExt (Iso.rightInv x))))
+ where
+ open GroupStr Gstr
+
+ i≡ = SetsIso≡fun (is-set Gstr) (is-set Gstr)
diff --git a/Cubical/Algebra/Module/Properties.agda b/Cubical/Algebra/Module/Properties.agda
index ded3e46c7e..8b90ba0747 100644
--- a/Cubical/Algebra/Module/Properties.agda
+++ b/Cubical/Algebra/Module/Properties.agda
@@ -3,6 +3,7 @@ module Cubical.Algebra.Module.Properties where
 
 open import Cubical.Foundations.Prelude
 open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function using (idfun; _∘_)
 
 open import Cubical.Algebra.Module.Base
 open import Cubical.Algebra.Ring
@@ -43,3 +44,51 @@ module ModuleTheory (R : Ring ℓ') (M : LeftModule R ℓ) where
        (R.1r R.+ (R.- R.1r))  ⋆ x  ≡⟨ congL _⋆_ (R.+InvR R.1r) ⟩
        R.0r                   ⋆ x  ≡⟨ ⋆AnnihilL x ⟩
        0m ∎)
+
+module _ {R : Ring ℓ'} (M : LeftModule R ℓ) where
+  idLeftModuleHom : LeftModuleHom M M
+  idLeftModuleHom = (idfun ⟨ M ⟩) , isLeftModuleHom where
+    open IsLeftModuleHom
+    isLeftModuleHom : IsLeftModuleHom (M .snd) (idfun ⟨ M ⟩) (M .snd)
+    isLeftModuleHom .pres0 = refl
+    isLeftModuleHom .pres+ x y = refl
+    isLeftModuleHom .pres- x = refl
+    isLeftModuleHom .pres⋆ r y = refl
+
+module _ {R : Ring ℓ'} {M N P : LeftModule R ℓ} where
+  -- Composition of left module homomorphisms
+  compLeftModuleHom : LeftModuleHom M N → LeftModuleHom N P → LeftModuleHom M P
+  compLeftModuleHom f g =
+    fg , record { pres0 = pres0 ; pres+ = pres+ ; pres- = pres- ; pres⋆ = pres⋆ } where
+      open LeftModuleStr (M .snd) using () renaming (0m to 0M; _+_ to _+M_; -_ to -M_; _⋆_ to _⋆M_)
+      open LeftModuleStr (N .snd) using () renaming (0m to 0N; _+_ to _+N_; -_ to -N_; _⋆_ to _⋆N_)
+      open LeftModuleStr (P .snd) using () renaming (0m to 0P; _+_ to _+P_; -_ to -P_; _⋆_ to _⋆P_)
+
+      fg = g .fst ∘ f .fst
+
+      pres0 : fg 0M ≡ 0P
+      pres0 = cong (g .fst) (f .snd .IsLeftModuleHom.pres0) ∙ g .snd .IsLeftModuleHom.pres0
+
+      pres+ : (x y : M .fst) → fg (x +M y) ≡ fg x +P fg y
+      -- g(f(x+y)) ≡ g(f(x)+f(y)) ≡ g(f(x))+g(f(y))
+      pres+ x y =
+        let p = refl {x = g .fst (f .fst (x +M y))} in
+        let p = p ∙ cong (g .fst) (f .snd .IsLeftModuleHom.pres+ x y) in
+        let p = p ∙ g .snd .IsLeftModuleHom.pres+ (f .fst x) (f .fst y) in
+        p
+
+      pres- : (x : M .fst) → fg (-M x) ≡ -P (fg x)
+      -- g(f(-x)) ≡ g(-f(x)) ≡ -g(f(x))
+      pres- x =
+        let p = refl {x = g .fst (f .fst (-M x))} in
+        let p = p ∙ cong (g .fst) (f .snd .IsLeftModuleHom.pres- x) in
+        let p = p ∙ g .snd .IsLeftModuleHom.pres- (f .fst x) in
+        p
+
+      pres⋆ : (r : ⟨ R ⟩) (y : M .fst) → fg (r ⋆M y) ≡ r ⋆P fg y
+      -- g(f(r⋆y)) ≡ g(r⋆f(y)) ≡ r⋆g(f(y))
+      pres⋆ r y =
+        let p = refl {x = g .fst (f .fst (r ⋆M y))} in
+        let p = p ∙ cong (g .fst) (f .snd .IsLeftModuleHom.pres⋆ r y) in
+        let p = p ∙ g .snd .IsLeftModuleHom.pres⋆ r (f .fst y) in
+        p
diff --git a/Cubical/Algebra/Monoid/Base.agda b/Cubical/Algebra/Monoid/Base.agda
index dbf68fb538..27491a8937 100644
--- a/Cubical/Algebra/Monoid/Base.agda
+++ b/Cubical/Algebra/Monoid/Base.agda
@@ -140,3 +140,13 @@ module MonoidTheory {ℓ} (M : Monoid ℓ) where
     (y · x) · z ≡⟨ congL _·_ left-inverse ⟩
     ε · z       ≡⟨ ·IdL z ⟩
     z ∎
+
+  -- Added for its use in division rings
+  hasInverse : (x : ⟨ M ⟩) → Type ℓ
+  hasInverse x = Σ[ -x ∈ ⟨ M ⟩ ] (-x · x ≡ ε) × (x · -x ≡ ε)
+
+  isPropHasInverse : ∀ x → isProp (hasInverse x)
+  isPropHasInverse x (y , invly , _) (z , _ , invrz)
+    = Σ≡Prop (λ a → isProp× (is-set (a · x) ε)
+                             (is-set (x · a) ε))
+              (inv-lemma x y z invly invrz)
diff --git a/Cubical/Algebra/Ring/Properties.agda b/Cubical/Algebra/Ring/Properties.agda
index afe940f880..f3bb310188 100644
--- a/Cubical/Algebra/Ring/Properties.agda
+++ b/Cubical/Algebra/Ring/Properties.agda
@@ -90,6 +90,13 @@ module RingTheory (R' : Ring ℓ) where
                     (0r · x) + (0r · x)  ∎
               in +Idempotency→0 _ 0·x-is-idempotent
 
+
+  0RightAnnihilates' : (x y : R) → y ≡ 0r → x · y ≡ 0r
+  0RightAnnihilates' x y p = cong (x ·_) p ∙ 0RightAnnihilates x
+
+  0LeftAnnihilates' : (x y : R) → x ≡ 0r → x · y ≡ 0r
+  0LeftAnnihilates' x y p = cong (_· y) p ∙ 0LeftAnnihilates y
+
   -DistR· : (x y : R) →  x · (- y) ≡ - (x · y)
   -DistR· x y = implicitInverse (x · y) (x · (- y))
 
@@ -152,6 +159,42 @@ module RingTheory (R' : Ring ℓ) where
   ·-assoc2 : (x y z w : R) → (x · y) · (z · w) ≡ x · (y · z) · w
   ·-assoc2 x y z w = ·Assoc (x · y) z w ∙ congL _·_ (sym (·Assoc x y z))
 
+  +IdR' : ∀ x y → y ≡ 0r → x + y ≡ x
+  +IdR' x y y=0 = cong (x +_) y=0 ∙ +IdR x
+
+  +IdL' : ∀ x y → x ≡ 0r → x + y ≡ y
+  +IdL' x y x=0 = cong (_+ y) x=0 ∙ +IdL y
+
+  +InvL' : ∀ x y → x ≡ y → - x + y ≡ 0r
+  +InvL' x y x=y = cong (- x +_) (sym x=y) ∙ (+InvL x)
+
+  +InvR' : ∀ x y → x ≡ y → x + - y ≡ 0r
+  +InvR' x y x=y = cong (_+ - y) x=y ∙ (+InvR y)
+
+  plusMinus : ∀ x y → (x + y) - y ≡ x
+  plusMinus x y = sym (+Assoc _ _ _) ∙ +IdR' _ _ (+InvR y)
+
+  plusMinus' : ∀ x y y' → y ≡ y' → (x + y) - y' ≡ x
+  plusMinus' x y y' p = sym (+Assoc _ _ _) ∙ +IdR' _ _ (+InvR' y y' p)
+
+  minusPlus : ∀ x y → (x - y) + y ≡ x
+  minusPlus x y = sym (+Assoc _ _ _) ∙ +IdR' _ _ (+InvL y)
+
+  minusPlus' : ∀ x y y' → y ≡ y' → (x - y) + y' ≡ x
+  minusPlus' x y y' p = sym (+Assoc _ _ _) ∙ +IdR' _ _ (+InvL' y y' p)
+
+  ·IdR' : ∀ x y → y ≡ 1r → x · y ≡ x
+  ·IdR' x y y=0 = cong (x ·_) y=0 ∙ ·IdR x
+
+  ·IdL' : ∀ x y → x ≡ 1r → x · y ≡ y
+  ·IdL' x y x=0 = cong (_· y) x=0 ∙ ·IdL y
+
+  ·DistR- : (x y z : R) → x · (y - z) ≡ (x · y) - (x · z)
+  ·DistR- _ _ _ = ·DistR+ _ _ _ ∙ cong (_ +_) (-DistR· _ _)
+
+  ·DistL- : (x y z : R) → (x - y) · z ≡ (x · z) - (y · z)
+  ·DistL- _ _ _ = ·DistL+ _ _ _ ∙ cong (_ +_) (-DistL· _ _)
+
 Ring→Semiring : Ring ℓ → Semiring ℓ
 Ring→Semiring R =
   let open RingStr (snd R)
diff --git a/Cubical/AlgebraicGeometry/ZariskiLattice/Properties.agda b/Cubical/AlgebraicGeometry/ZariskiLattice/Properties.agda
index f2dc3d1f52..5427849bf4 100644
--- a/Cubical/AlgebraicGeometry/ZariskiLattice/Properties.agda
+++ b/Cubical/AlgebraicGeometry/ZariskiLattice/Properties.agda
@@ -13,6 +13,7 @@ open import Cubical.Data.Nat using (ℕ)
 open import Cubical.Data.Sigma.Properties
 open import Cubical.Data.FinData
 open import Cubical.Relation.Binary.Order.Poset
+open import Cubical.Relation.Binary.Order.Poset.Subset
 
 open import Cubical.Algebra.CommRing
 open import Cubical.Algebra.CommRing.Localisation
diff --git a/Cubical/AlgebraicGeometry/ZariskiLattice/StructureSheaf.agda b/Cubical/AlgebraicGeometry/ZariskiLattice/StructureSheaf.agda
index 0ca7597380..a86dd5be80 100644
--- a/Cubical/AlgebraicGeometry/ZariskiLattice/StructureSheaf.agda
+++ b/Cubical/AlgebraicGeometry/ZariskiLattice/StructureSheaf.agda
@@ -137,8 +137,7 @@ module _ {ℓ : Level} (R' : CommRing ℓ) where
     open S⁻¹RUniversalProp R' [ f ⁿ|n≥0] (powersFormMultClosedSubset f) using (_/1)
     open RadicalIdeal R'
 
-    private
-     instance
+    instance
       _ = snd R[1/ f ]AsCommRing
 
     f∈√⟨g⟩ : f ∈ √ ⟨ g ⟩ₛ
diff --git a/Cubical/AlgebraicGeometry/ZariskiLattice/StructureSheafPullback.agda b/Cubical/AlgebraicGeometry/ZariskiLattice/StructureSheafPullback.agda
index 41695c786a..452bcd4fbd 100644
--- a/Cubical/AlgebraicGeometry/ZariskiLattice/StructureSheafPullback.agda
+++ b/Cubical/AlgebraicGeometry/ZariskiLattice/StructureSheafPullback.agda
@@ -158,8 +158,7 @@ module _ (R' : CommRing ℓ) where
     open S⁻¹RUniversalProp R' [ f ⁿ|n≥0] (powersFormMultClosedSubset f) using (_/1)
     open RadicalIdeal R'
 
-    private
-     instance
+    instance
       _ = snd R[1/ f ]AsCommRing
 
     Df≤Dg : D f ≤ D g
diff --git a/Cubical/CW/ChainComplex.agda b/Cubical/CW/ChainComplex.agda
index 54d32db729..359928c542 100644
--- a/Cubical/CW/ChainComplex.agda
+++ b/Cubical/CW/ChainComplex.agda
@@ -10,11 +10,17 @@ open import Cubical.Foundations.Isomorphism
 open import Cubical.Foundations.Function
 
 open import Cubical.Data.Nat
+open import Cubical.Data.Nat.Order.Inductive
+open import Cubical.Data.Int renaming (_+_ to _+ℤ_ ; _·_ to _·ℤ_)
+open import Cubical.Data.Bool
+open import Cubical.Data.Empty renaming (rec to emptyrec)
 open import Cubical.Data.Fin.Inductive.Base
 open import Cubical.Data.Fin.Inductive.Properties
 open import Cubical.Data.Sigma
 
+open import Cubical.HITs.S1
 open import Cubical.HITs.Sn
+open import Cubical.HITs.Sn.Degree renaming (degreeConst to degree-const)
 open import Cubical.HITs.Pushout
 open import Cubical.HITs.Susp
 open import Cubical.HITs.SphereBouquet
@@ -23,6 +29,7 @@ open import Cubical.HITs.SphereBouquet.Degree
 open import Cubical.Algebra.Group.Base
 open import Cubical.Algebra.Group.MorphismProperties
 open import Cubical.Algebra.AbGroup
+open import Cubical.Algebra.AbGroup.Instances.FreeAbGroup
 open import Cubical.Algebra.ChainComplex
 
 
@@ -63,6 +70,9 @@ module _ {ℓ} (C : CWskel ℓ) where
     isoCofBouquet : cofibCW n C → SphereBouquet n (Fin An)
     isoCofBouquet = Iso.fun (BouquetIso-gen n An αn (snd C .snd .snd .snd n))
 
+    isoCofBouquetInv : SphereBouquet n (Fin An) → cofibCW n C
+    isoCofBouquetInv = Iso.inv (BouquetIso-gen n An αn (snd C .snd .snd .snd n))
+
     isoCofBouquetInv↑ : SphereBouquet (suc n) (Fin An+1) → cofibCW (suc n) C
     isoCofBouquetInv↑ = Iso.inv (BouquetIso-gen (suc n) An+1 αn+1 (snd C .snd .snd .snd (suc n)))
 
@@ -179,14 +189,90 @@ module _ {ℓ} (C : CWskel ℓ) where
         ∂≡∂↑ : ∂ n ≡ ∂↑
         ∂≡∂↑ = bouquetDegreeSusp (pre∂ n)
 
+  -- alternative description of the boundary for 1-dimensional cells
+  module ∂₀ where
+    src₀ : Fin (C .snd .fst 1) → Fin (C .snd .fst 0)
+    src₀ x = CW₁-discrete C .fst (C .snd .snd .fst 1 (x , true))
 
-  open ChainComplex
+    dest₀ : Fin (C .snd .fst 1) → Fin (C .snd .fst 0)
+    dest₀ x = CW₁-discrete C .fst (C .snd .snd .fst 1 (x , false))
+
+    src : AbGroupHom (ℤ[A 1 ]) (ℤ[A 0 ])
+    src = ℤFinFunct src₀
+
+    dest : AbGroupHom (ℤ[A 1 ]) (ℤ[A 0 ])
+    dest = ℤFinFunct dest₀
+
+    ∂₀ : AbGroupHom (ℤ[A 1 ]) (ℤ[A 0 ])
+    ∂₀ = subtrGroupHom (ℤ[A 1 ]) (ℤ[A 0 ]) dest src
+
+    -- ∂₀-alt : ∂ 0 ≡ ∂₀
+    -- ∂₀-alt = agreeOnℤFinGenerator→≡ λ x → funExt λ a → {!!}
+
+  -- augmentation map, in order to define reduced homology
+  module augmentation where
+    ε : Susp (cofibCW 0 C) → SphereBouquet 1 (Fin 1)
+    ε north = inl tt
+    ε south = inl tt
+    ε (merid (inl tt) i) = inl tt
+    ε (merid (inr x) i) = (push fzero ∙∙ (λ i → inr (fzero , loop i)) ∙∙ (λ i → push fzero (~ i))) i
+    ε (merid (push x i₁) i) with (C .snd .snd .snd .fst x)
+    ε (merid (push x i₁) i) | ()
+
+    εδ : ∀ (x : cofibCW 1 C) → (ε ∘ (suspFun (to_cofibCW 0 C)) ∘ (δ 1 C)) x ≡ inl tt
+    εδ (inl tt) = refl
+    εδ (inr x) i = (push fzero ∙∙ (λ i → inr (fzero , loop i)) ∙∙ (λ i → push fzero (~ i))) (~ i)
+    εδ (push a i) j = (push fzero ∙∙ (λ i → inr (fzero , loop i)) ∙∙ (λ i → push fzero (~ i))) (i ∧ (~ j))
 
-  CW-ChainComplex : ChainComplex ℓ-zero
-  chain CW-ChainComplex n = ℤ[A n ]
-  bdry CW-ChainComplex n = ∂ n
-  bdry²=0 CW-ChainComplex n = ∂∂≡0 n
+    preϵ : SphereBouquet 1 (Fin (preboundary.An 0)) → SphereBouquet 1 (Fin 1)
+    preϵ = ε ∘ (suspFun isoCofBouquetInv) ∘ isoSuspBouquetInv
+      where
+        open preboundary 0
+
+    opaque
+      preϵpre∂≡0 : ∀ (x : SphereBouquet 1 (Fin (preboundary.An+1 0))) → (preϵ ∘ preboundary.pre∂ 0) x ≡ inl tt
+      preϵpre∂≡0 x = cong (ε ∘ (suspFun isoCofBouquetInv))
+                          (Iso.leftInv sphereBouquetSuspIso
+                                       (((suspFun isoCofBouquet) ∘ (suspFun (to_cofibCW 0 C)) ∘ (δ 1 C) ∘ isoCofBouquetInv↑) x))
+                   ∙ cong ε (aux (((suspFun (to_cofibCW 0 C)) ∘ (δ 1 C) ∘ isoCofBouquetInv↑) x))
+                   ∙ εδ (isoCofBouquetInv↑ x)
+        where
+          open preboundary 0
+          aux : ∀ (x : Susp (cofibCW 0 C)) → (suspFun (isoCofBouquetInv) ∘ (suspFun isoCofBouquet)) x ≡ x
+          aux north = refl
+          aux south = refl
+          aux (merid a i) j = merid (Iso.leftInv (BouquetIso-gen 0 An αn (snd C .snd .snd .snd 0)) a j) i
+
+    ϵ : AbGroupHom (ℤ[A 0 ]) (ℤ[Fin 1 ])
+    ϵ = bouquetDegree preϵ
+
+    ϵ-alt : ϵ ≡ sumCoefficients _
+    ϵ-alt = GroupHom≡ (funExt λ (x : ℤ[A 0 ] .fst) → funExt λ y → cong sumFinℤ (funExt (lem1 x y)))
+      where
+        An = snd C .fst 0
+
+        lem0 : (y : Fin 1) (a : Fin An) → (degree _ (pickPetal {k = 1} y ∘ preϵ ∘ inr ∘ (a ,_))) ≡ pos 1
+        lem0 (zero , y₁) a = refl
+
+        lem1 : (x : ℤ[A 0 ] .fst) (y : Fin 1) (a : Fin An) → x a ·ℤ (degree _ (pickPetal {k = 1} y ∘ preϵ ∘ inr ∘ (a ,_))) ≡ x a
+        lem1 x y a = cong (x a ·ℤ_) (lem0 y a) ∙ ·IdR (x a)
+
+    opaque
+      ϵ∂≡0 : compGroupHom (∂ 0) ϵ ≡ trivGroupHom
+      ϵ∂≡0 = sym (bouquetDegreeComp (preϵ) (preboundary.pre∂ 0))
+           ∙ cong bouquetDegree (funExt preϵpre∂≡0)
+           ∙ bouquetDegreeConst _ _ _
+
+  open ChainComplex
 
-  -- Cellular homology
-  Hˢᵏᵉˡ : (n : ℕ) → Group₀
-  Hˢᵏᵉˡ n = homology n CW-ChainComplex
+  CW-AugChainComplex : ChainComplex ℓ-zero
+  chain CW-AugChainComplex (zero) = ℤ[Fin 1 ]
+  chain CW-AugChainComplex (suc n) = ℤ[A n ]
+  bdry CW-AugChainComplex (zero) = augmentation.ϵ
+  bdry CW-AugChainComplex (suc n) = ∂ n
+  bdry²=0 CW-AugChainComplex (zero) = augmentation.ϵ∂≡0
+  bdry²=0 CW-AugChainComplex (suc n) = ∂∂≡0 n
+
+  -- Reduced cellular homology
+  H̃ˢᵏᵉˡ : (n : ℕ) → Group₀
+  H̃ˢᵏᵉˡ n = homology n CW-AugChainComplex
diff --git a/Cubical/CW/Homology.agda b/Cubical/CW/Homology.agda
index c216a36d01..98cedb90a9 100644
--- a/Cubical/CW/Homology.agda
+++ b/Cubical/CW/Homology.agda
@@ -36,56 +36,56 @@ private
   variable
     ℓ ℓ' ℓ'' : Level
 
------- Part 1. Functoriality of Hˢᵏᵉˡ ------
-Hˢᵏᵉˡ→-pre : (C : CWskel ℓ) (D : CWskel ℓ') (m : ℕ)
+------ Part 1. Functoriality of H̃ˢᵏᵉˡ ------
+H̃ˢᵏᵉˡ→-pre : (C : CWskel ℓ) (D : CWskel ℓ') (m : ℕ)
   (f : finCellMap (suc (suc (suc m))) C D)
-  → GroupHom (Hˢᵏᵉˡ C m) (Hˢᵏᵉˡ D m)
-Hˢᵏᵉˡ→-pre C D m f = finCellMap→HomologyMap m f
+  → GroupHom (H̃ˢᵏᵉˡ C m) (H̃ˢᵏᵉˡ D m)
+H̃ˢᵏᵉˡ→-pre C D m f = finCellMap→HomologyMap m f
 
 private
-  Hˢᵏᵉˡ→-pre' : (C : CWskel ℓ) (D : CWskel ℓ') (m : ℕ)
+  H̃ˢᵏᵉˡ→-pre' : (C : CWskel ℓ) (D : CWskel ℓ') (m : ℕ)
     → (f : realise C → realise D)
     → ∥ finCellApprox C D f (suc (suc (suc m))) ∥₁
-    → GroupHom (Hˢᵏᵉˡ C m) (Hˢᵏᵉˡ D m)
-  Hˢᵏᵉˡ→-pre' C D m f =
+    → GroupHom (H̃ˢᵏᵉˡ C m) (H̃ˢᵏᵉˡ D m)
+  H̃ˢᵏᵉˡ→-pre' C D m f =
     rec→Set isSetGroupHom
-    (λ f → Hˢᵏᵉˡ→-pre C D m (f .fst))
+    (λ f → H̃ˢᵏᵉˡ→-pre C D m (f .fst))
     main
     where
-    main : 2-Constant (λ f₁ → Hˢᵏᵉˡ→-pre C D m (f₁ .fst))
+    main : 2-Constant (λ f₁ → H̃ˢᵏᵉˡ→-pre C D m (f₁ .fst))
     main f g = PT.rec (isSetGroupHom _ _)
       (λ q → finChainHomotopy→HomologyPath _ _
         (cellHom-to-ChainHomotopy _ q) flast)
       (pathToCellularHomotopy _ (fst f) (fst g)
         λ x → funExt⁻ (snd f ∙ sym (snd g)) (fincl flast x))
 
-Hˢᵏᵉˡ→ : {C : CWskel ℓ} {D : CWskel ℓ'} (m : ℕ)
+H̃ˢᵏᵉˡ→ : {C : CWskel ℓ} {D : CWskel ℓ'} (m : ℕ)
   (f : realise C → realise D)
-  → GroupHom (Hˢᵏᵉˡ C m) (Hˢᵏᵉˡ D m)
-Hˢᵏᵉˡ→ {C = C} {D} m f =
-  Hˢᵏᵉˡ→-pre' C D m f
+  → GroupHom (H̃ˢᵏᵉˡ C m) (H̃ˢᵏᵉˡ D m)
+H̃ˢᵏᵉˡ→ {C = C} {D} m f =
+  H̃ˢᵏᵉˡ→-pre' C D m f
     (CWmap→finCellMap C D f (suc (suc (suc m))))
 
-Hˢᵏᵉˡ→β : (C : CWskel ℓ) (D : CWskel ℓ') (m : ℕ)
+H̃ˢᵏᵉˡ→β : (C : CWskel ℓ) (D : CWskel ℓ') (m : ℕ)
   {f : realise C → realise D}
   (ϕ : finCellApprox C D f (suc (suc (suc m))))
-  → Hˢᵏᵉˡ→ {C = C} {D} m f ≡ Hˢᵏᵉˡ→-pre C D m (ϕ .fst)
-Hˢᵏᵉˡ→β C D m {f = f} ϕ =
-  cong (Hˢᵏᵉˡ→-pre' C D m f) (squash₁ _ ∣ ϕ ∣₁)
-
-Hˢᵏᵉˡ→id : (m : ℕ) {C : CWskel ℓ}
-  → Hˢᵏᵉˡ→ {C = C} m (idfun _) ≡ idGroupHom
-Hˢᵏᵉˡ→id m {C = C} =
-  Hˢᵏᵉˡ→β C C m {idfun _} (idFinCellApprox (suc (suc (suc m))))
+  → H̃ˢᵏᵉˡ→ {C = C} {D} m f ≡ H̃ˢᵏᵉˡ→-pre C D m (ϕ .fst)
+H̃ˢᵏᵉˡ→β C D m {f = f} ϕ =
+  cong (H̃ˢᵏᵉˡ→-pre' C D m f) (squash₁ _ ∣ ϕ ∣₁)
+
+H̃ˢᵏᵉˡ→id : (m : ℕ) {C : CWskel ℓ}
+  → H̃ˢᵏᵉˡ→ {C = C} m (idfun _) ≡ idGroupHom
+H̃ˢᵏᵉˡ→id m {C = C} =
+  H̃ˢᵏᵉˡ→β C C m {idfun _} (idFinCellApprox (suc (suc (suc m))))
   ∙ finCellMap→HomologyMapId _
 
-Hˢᵏᵉˡ→comp : (m : ℕ)
+H̃ˢᵏᵉˡ→comp : (m : ℕ)
   {C : CWskel ℓ} {D : CWskel ℓ'} {E : CWskel ℓ''}
   (g : realise D → realise E)
   (f : realise C → realise D)
-  → Hˢᵏᵉˡ→ m (g ∘ f)
-  ≡ compGroupHom (Hˢᵏᵉˡ→ m f) (Hˢᵏᵉˡ→ m g)
-Hˢᵏᵉˡ→comp m {C = C} {D = D} {E = E} g f =
+  → H̃ˢᵏᵉˡ→ m (g ∘ f)
+  ≡ compGroupHom (H̃ˢᵏᵉˡ→ m f) (H̃ˢᵏᵉˡ→ m g)
+H̃ˢᵏᵉˡ→comp m {C = C} {D = D} {E = E} g f =
   PT.rec2 (isSetGroupHom _ _)
     main
     (CWmap→finCellMap C D f (suc (suc (suc m))))
@@ -97,148 +97,148 @@ Hˢᵏᵉˡ→comp m {C = C} {D = D} {E = E} g f =
     comps : finCellApprox C E (g ∘ f) (suc (suc (suc m)))
     comps = compFinCellApprox _ {g = g} {f} G F
 
-    eq1 : Hˢᵏᵉˡ→ m (g ∘ f)
-        ≡ Hˢᵏᵉˡ→-pre C E m (composeFinCellMap _ (fst G) (fst F))
-    eq1 = Hˢᵏᵉˡ→β C E m {g ∘ f} comps
+    eq1 : H̃ˢᵏᵉˡ→ m (g ∘ f)
+        ≡ H̃ˢᵏᵉˡ→-pre C E m (composeFinCellMap _ (fst G) (fst F))
+    eq1 = H̃ˢᵏᵉˡ→β C E m {g ∘ f} comps
 
-    eq2 : compGroupHom (Hˢᵏᵉˡ→ m f) (Hˢᵏᵉˡ→ m g)
-        ≡ compGroupHom (Hˢᵏᵉˡ→-pre C D m (fst F)) (Hˢᵏᵉˡ→-pre D E m (fst G))
-    eq2 = cong₂ compGroupHom (Hˢᵏᵉˡ→β C D m {f = f} F) (Hˢᵏᵉˡ→β D E m {f = g} G)
+    eq2 : compGroupHom (H̃ˢᵏᵉˡ→ m f) (H̃ˢᵏᵉˡ→ m g)
+        ≡ compGroupHom (H̃ˢᵏᵉˡ→-pre C D m (fst F)) (H̃ˢᵏᵉˡ→-pre D E m (fst G))
+    eq2 = cong₂ compGroupHom (H̃ˢᵏᵉˡ→β C D m {f = f} F) (H̃ˢᵏᵉˡ→β D E m {f = g} G)
 
-    main : Hˢᵏᵉˡ→ m (g ∘ f) ≡ compGroupHom (Hˢᵏᵉˡ→ m f) (Hˢᵏᵉˡ→ m g)
+    main : H̃ˢᵏᵉˡ→ m (g ∘ f) ≡ compGroupHom (H̃ˢᵏᵉˡ→ m f) (H̃ˢᵏᵉˡ→ m g)
     main = eq1 ∙∙ finCellMap→HomologyMapComp _ _ _ ∙∙ sym eq2
 
 -- preservation of equivalence
-Hˢᵏᵉˡ→Iso : {C : CWskel ℓ} {D : CWskel ℓ'} (m : ℕ)
-  (e : realise C ≃ realise D) → GroupIso (Hˢᵏᵉˡ C m) (Hˢᵏᵉˡ D m)
-Iso.fun (fst (Hˢᵏᵉˡ→Iso m e)) = fst (Hˢᵏᵉˡ→ m (fst e))
-Iso.inv (fst (Hˢᵏᵉˡ→Iso m e)) = fst (Hˢᵏᵉˡ→ m (invEq e))
-Iso.rightInv (fst (Hˢᵏᵉˡ→Iso m e)) =
-  funExt⁻ (cong fst (sym (Hˢᵏᵉˡ→comp m (fst e) (invEq e))
-       ∙∙ cong (Hˢᵏᵉˡ→ m) (funExt (secEq e))
-       ∙∙ Hˢᵏᵉˡ→id m))
-Iso.leftInv (fst (Hˢᵏᵉˡ→Iso m e)) =
-  funExt⁻ (cong fst (sym (Hˢᵏᵉˡ→comp m (invEq e) (fst e))
-       ∙∙ cong (Hˢᵏᵉˡ→ m) (funExt (retEq e))
-       ∙∙ Hˢᵏᵉˡ→id m))
-snd (Hˢᵏᵉˡ→Iso m e) = snd (Hˢᵏᵉˡ→ m (fst e))
-
-Hˢᵏᵉˡ→Equiv : {C : CWskel ℓ} {D : CWskel ℓ'} (m : ℕ)
-  (e : realise C ≃ realise D) → GroupEquiv (Hˢᵏᵉˡ C m) (Hˢᵏᵉˡ D m)
-Hˢᵏᵉˡ→Equiv m e = GroupIso→GroupEquiv (Hˢᵏᵉˡ→Iso m e)
+H̃ˢᵏᵉˡ→Iso : {C : CWskel ℓ} {D : CWskel ℓ'} (m : ℕ)
+  (e : realise C ≃ realise D) → GroupIso (H̃ˢᵏᵉˡ C m) (H̃ˢᵏᵉˡ D m)
+Iso.fun (fst (H̃ˢᵏᵉˡ→Iso m e)) = fst (H̃ˢᵏᵉˡ→ m (fst e))
+Iso.inv (fst (H̃ˢᵏᵉˡ→Iso m e)) = fst (H̃ˢᵏᵉˡ→ m (invEq e))
+Iso.rightInv (fst (H̃ˢᵏᵉˡ→Iso m e)) =
+  funExt⁻ (cong fst (sym (H̃ˢᵏᵉˡ→comp m (fst e) (invEq e))
+       ∙∙ cong (H̃ˢᵏᵉˡ→ m) (funExt (secEq e))
+       ∙∙ H̃ˢᵏᵉˡ→id m))
+Iso.leftInv (fst (H̃ˢᵏᵉˡ→Iso m e)) =
+  funExt⁻ (cong fst (sym (H̃ˢᵏᵉˡ→comp m (invEq e) (fst e))
+       ∙∙ cong (H̃ˢᵏᵉˡ→ m) (funExt (retEq e))
+       ∙∙ H̃ˢᵏᵉˡ→id m))
+snd (H̃ˢᵏᵉˡ→Iso m e) = snd (H̃ˢᵏᵉˡ→ m (fst e))
+
+H̃ˢᵏᵉˡ→Equiv : {C : CWskel ℓ} {D : CWskel ℓ'} (m : ℕ)
+  (e : realise C ≃ realise D) → GroupEquiv (H̃ˢᵏᵉˡ C m) (H̃ˢᵏᵉˡ D m)
+H̃ˢᵏᵉˡ→Equiv m e = GroupIso→GroupEquiv (H̃ˢᵏᵉˡ→Iso m e)
 
 
 ------ Part 2. Definition of cellular homology ------
-Hᶜʷ : ∀ (C : CW ℓ) (n : ℕ) → Group₀
-Hᶜʷ (C , CWstr) n =
+H̃ᶜʷ : ∀ (C : CW ℓ) (n : ℕ) → Group₀
+H̃ᶜʷ (C , CWstr) n =
   PropTrunc→Group
-      (λ Cskel → Hˢᵏᵉˡ (Cskel .fst) n)
+      (λ Cskel → H̃ˢᵏᵉˡ (Cskel .fst) n)
       (λ Cskel Dskel
-        → Hˢᵏᵉˡ→Equiv n (compEquiv (invEquiv (snd Cskel)) (snd Dskel)))
+        → H̃ˢᵏᵉˡ→Equiv n (compEquiv (invEquiv (snd Cskel)) (snd Dskel)))
       coh
       CWstr
   where
-  coh : (Cskel Dskel Eskel : isCW C) (t : fst (Hˢᵏᵉˡ (Cskel .fst) n))
-    → fst (fst (Hˢᵏᵉˡ→Equiv n (compEquiv (invEquiv (snd Dskel)) (snd Eskel))))
-        (fst (fst (Hˢᵏᵉˡ→Equiv n (compEquiv (invEquiv (snd Cskel)) (snd Dskel)))) t)
-    ≡ fst (fst (Hˢᵏᵉˡ→Equiv n (compEquiv (invEquiv (snd Cskel)) (snd Eskel)))) t
+  coh : (Cskel Dskel Eskel : isCW C) (t : fst (H̃ˢᵏᵉˡ (Cskel .fst) n))
+    → fst (fst (H̃ˢᵏᵉˡ→Equiv n (compEquiv (invEquiv (snd Dskel)) (snd Eskel))))
+        (fst (fst (H̃ˢᵏᵉˡ→Equiv n (compEquiv (invEquiv (snd Cskel)) (snd Dskel)))) t)
+    ≡ fst (fst (H̃ˢᵏᵉˡ→Equiv n (compEquiv (invEquiv (snd Cskel)) (snd Eskel)))) t
   coh (C' , e) (D , f) (E , h) =
     funExt⁻ (cong fst
-          (sym (Hˢᵏᵉˡ→comp n (fst (compEquiv (invEquiv f) h))
+          (sym (H̃ˢᵏᵉˡ→comp n (fst (compEquiv (invEquiv f) h))
                            (fst (compEquiv (invEquiv e) f)))
-          ∙ cong (Hˢᵏᵉˡ→ n) (funExt λ x → cong (fst h) (retEq f _))))
+          ∙ cong (H̃ˢᵏᵉˡ→ n) (funExt λ x → cong (fst h) (retEq f _))))
 
 -- lemmas for functoriality
 private
   module _ {C : Type ℓ} {D : Type ℓ'} (f : C → D) (n : ℕ) where
     right : (cwC : isCW C) (cwD1 : isCW D) (cwD2 : isCW D)
-      → PathP (λ i → GroupHom (Hᶜʷ (C , ∣ cwC ∣₁) n)
-                         (Hᶜʷ (D , squash₁ ∣ cwD1 ∣₁ ∣ cwD2 ∣₁ i) n))
-        (Hˢᵏᵉˡ→ n (λ x → fst (snd cwD1) (f (invEq (snd cwC) x))))
-        (Hˢᵏᵉˡ→ n (λ x → fst (snd cwD2) (f (invEq (snd cwC) x))))
+      → PathP (λ i → GroupHom (H̃ᶜʷ (C , ∣ cwC ∣₁) n)
+                         (H̃ᶜʷ (D , squash₁ ∣ cwD1 ∣₁ ∣ cwD2 ∣₁ i) n))
+        (H̃ˢᵏᵉˡ→ n (λ x → fst (snd cwD1) (f (invEq (snd cwC) x))))
+        (H̃ˢᵏᵉˡ→ n (λ x → fst (snd cwD2) (f (invEq (snd cwC) x))))
     right cwC cwD1 cwD2 =
       PathPGroupHomₗ _
-        (cong (Hˢᵏᵉˡ→ n) (funExt (λ s
+        (cong (H̃ˢᵏᵉˡ→ n) (funExt (λ s
           → cong (fst (snd cwD2)) (sym (retEq (snd cwD1) _))))
-        ∙ Hˢᵏᵉˡ→comp n _ _)
+        ∙ H̃ˢᵏᵉˡ→comp n _ _)
 
     left : (cwC1 : isCW C) (cwC2 : isCW C) (cwD : isCW D)
-      → PathP (λ i → GroupHom (Hᶜʷ (C , squash₁ ∣ cwC1 ∣₁ ∣ cwC2 ∣₁ i) n)
-                                  (Hᶜʷ (D , ∣ cwD ∣₁) n))
-                 (Hˢᵏᵉˡ→ n (λ x → fst (snd cwD) (f (invEq (snd cwC1) x))))
-                 (Hˢᵏᵉˡ→ n (λ x → fst (snd cwD) (f (invEq (snd cwC2) x))))
+      → PathP (λ i → GroupHom (H̃ᶜʷ (C , squash₁ ∣ cwC1 ∣₁ ∣ cwC2 ∣₁ i) n)
+                                  (H̃ᶜʷ (D , ∣ cwD ∣₁) n))
+                 (H̃ˢᵏᵉˡ→ n (λ x → fst (snd cwD) (f (invEq (snd cwC1) x))))
+                 (H̃ˢᵏᵉˡ→ n (λ x → fst (snd cwD) (f (invEq (snd cwC2) x))))
     left cwC1 cwC2 cwD =
-      PathPGroupHomᵣ (Hˢᵏᵉˡ→Equiv n (compEquiv (invEquiv (snd cwC1)) (snd cwC2)))
-            (sym (Hˢᵏᵉˡ→comp n (λ x → fst (snd cwD) (f (invEq (snd cwC2) x)))
+      PathPGroupHomᵣ (H̃ˢᵏᵉˡ→Equiv n (compEquiv (invEquiv (snd cwC1)) (snd cwC2)))
+            (sym (H̃ˢᵏᵉˡ→comp n (λ x → fst (snd cwD) (f (invEq (snd cwC2) x)))
                              (compEquiv (invEquiv (snd cwC1)) (snd cwC2) .fst))
-           ∙ cong (Hˢᵏᵉˡ→ n) (funExt (λ x
+           ∙ cong (H̃ˢᵏᵉˡ→ n) (funExt (λ x
               → cong (fst (snd cwD) ∘ f)
                   (retEq (snd cwC2) _))))
 
     left-right : (x y : isCW C) (v w : isCW D) →
       SquareP
       (λ i j →
-         GroupHom (Hᶜʷ (C , squash₁ ∣ x ∣₁ ∣ y ∣₁ i) n)
-         (Hᶜʷ (D , squash₁ ∣ v ∣₁ ∣ w ∣₁ j) n))
+         GroupHom (H̃ᶜʷ (C , squash₁ ∣ x ∣₁ ∣ y ∣₁ i) n)
+         (H̃ᶜʷ (D , squash₁ ∣ v ∣₁ ∣ w ∣₁ j) n))
       (right x v w) (right y v w) (left x y v) (left x y w)
     left-right _ _ _ _ = isSet→SquareP
        (λ _ _ → isSetGroupHom) _ _ _ _
 
-    Hᶜʷ→pre : (cwC : ∥ isCW C ∥₁) (cwD : ∥ isCW D ∥₁)
-      → GroupHom (Hᶜʷ (C , cwC) n) (Hᶜʷ (D , cwD) n)
-    Hᶜʷ→pre =
+    H̃ᶜʷ→pre : (cwC : ∥ isCW C ∥₁) (cwD : ∥ isCW D ∥₁)
+      → GroupHom (H̃ᶜʷ (C , cwC) n) (H̃ᶜʷ (D , cwD) n)
+    H̃ᶜʷ→pre =
       elim2→Set (λ _ _ → isSetGroupHom)
-        (λ cwC cwD → Hˢᵏᵉˡ→ n (fst (snd cwD) ∘ f ∘ invEq (snd cwC)))
+        (λ cwC cwD → H̃ˢᵏᵉˡ→ n (fst (snd cwD) ∘ f ∘ invEq (snd cwC)))
         left right
         (λ _ _ _ _ → isSet→SquareP
          (λ _ _ → isSetGroupHom) _ _ _ _)
 
 -- functoriality
-Hᶜʷ→ : {C : CW ℓ} {D : CW ℓ'} (n : ℕ) (f : C →ᶜʷ D)
-    → GroupHom (Hᶜʷ C n) (Hᶜʷ D n)
-Hᶜʷ→ {C = C , cwC} {D = D , cwD} n f = Hᶜʷ→pre f n cwC cwD
+H̃ᶜʷ→ : {C : CW ℓ} {D : CW ℓ'} (n : ℕ) (f : C →ᶜʷ D)
+    → GroupHom (H̃ᶜʷ C n) (H̃ᶜʷ D n)
+H̃ᶜʷ→ {C = C , cwC} {D = D , cwD} n f = H̃ᶜʷ→pre f n cwC cwD
 
-Hᶜʷ→id : {C : CW ℓ} (n : ℕ)
-    → Hᶜʷ→ {C = C} {C} n (idfun (fst C))
+H̃ᶜʷ→id : {C : CW ℓ} (n : ℕ)
+    → H̃ᶜʷ→ {C = C} {C} n (idfun (fst C))
      ≡ idGroupHom
-Hᶜʷ→id {C = C , cwC} n =
+H̃ᶜʷ→id {C = C , cwC} n =
   PT.elim {P = λ cwC
-    → Hᶜʷ→ {C = C , cwC} {C , cwC} n (idfun C) ≡ idGroupHom}
+    → H̃ᶜʷ→ {C = C , cwC} {C , cwC} n (idfun C) ≡ idGroupHom}
     (λ _ → isSetGroupHom _ _)
-    (λ cwC* → cong (Hˢᵏᵉˡ→ n) (funExt (secEq (snd cwC*)))
-              ∙ Hˢᵏᵉˡ→id n) cwC
+    (λ cwC* → cong (H̃ˢᵏᵉˡ→ n) (funExt (secEq (snd cwC*)))
+              ∙ H̃ˢᵏᵉˡ→id n) cwC
 
-Hᶜʷ→comp : {C : CW ℓ} {D : CW ℓ'} {E : CW ℓ''} (n : ℕ)
+H̃ᶜʷ→comp : {C : CW ℓ} {D : CW ℓ'} {E : CW ℓ''} (n : ℕ)
       (g : D →ᶜʷ E) (f : C →ᶜʷ D)
-    → Hᶜʷ→ {C = C} {E} n (g ∘ f)
-     ≡ compGroupHom (Hᶜʷ→ {C = C} {D} n f) (Hᶜʷ→ {C = D} {E} n g)
-Hᶜʷ→comp {C = C , cwC} {D = D , cwD} {E = E , cwE} n g f =
+    → H̃ᶜʷ→ {C = C} {E} n (g ∘ f)
+     ≡ compGroupHom (H̃ᶜʷ→ {C = C} {D} n f) (H̃ᶜʷ→ {C = D} {E} n g)
+H̃ᶜʷ→comp {C = C , cwC} {D = D , cwD} {E = E , cwE} n g f =
   PT.elim3 {P = λ cwC cwD cwE
-    → Hᶜʷ→ {C = C , cwC} {E , cwE} n (g ∘ f)
-     ≡ compGroupHom (Hᶜʷ→ {C = C , cwC} {D , cwD} n f)
-                    (Hᶜʷ→ {C = D , cwD} {E , cwE} n g)}
+    → H̃ᶜʷ→ {C = C , cwC} {E , cwE} n (g ∘ f)
+     ≡ compGroupHom (H̃ᶜʷ→ {C = C , cwC} {D , cwD} n f)
+                    (H̃ᶜʷ→ {C = D , cwD} {E , cwE} n g)}
      (λ _ _ _ → isSetGroupHom _ _)
      (λ cwC cwD cwE
-       → cong (Hˢᵏᵉˡ→ n) (funExt (λ x → cong (fst (snd cwE) ∘ g)
+       → cong (H̃ˢᵏᵉˡ→ n) (funExt (λ x → cong (fst (snd cwE) ∘ g)
                           (sym (retEq (snd cwD) _))))
-       ∙ Hˢᵏᵉˡ→comp n _ _)
+       ∙ H̃ˢᵏᵉˡ→comp n _ _)
      cwC cwD cwE
 
 -- preservation of equivalence
-Hᶜʷ→Iso : {C : CW ℓ} {D : CW ℓ'} (m : ℕ)
-  (e : fst C ≃ fst D) → GroupIso (Hᶜʷ C m) (Hᶜʷ D m)
-Iso.fun (fst (Hᶜʷ→Iso m e)) = fst (Hᶜʷ→ m (fst e))
-Iso.inv (fst (Hᶜʷ→Iso m e)) = fst (Hᶜʷ→ m (invEq e))
-Iso.rightInv (fst (Hᶜʷ→Iso m e)) =
-  funExt⁻ (cong fst (sym (Hᶜʷ→comp m (fst e) (invEq e))
-       ∙∙ cong (Hᶜʷ→ m) (funExt (secEq e))
-       ∙∙ Hᶜʷ→id m))
-Iso.leftInv (fst (Hᶜʷ→Iso m e)) =
-  funExt⁻ (cong fst (sym (Hᶜʷ→comp m (invEq e) (fst e))
-       ∙∙ cong (Hᶜʷ→ m) (funExt (retEq e))
-       ∙∙ Hᶜʷ→id m))
-snd (Hᶜʷ→Iso m e) = snd (Hᶜʷ→ m (fst e))
-
-Hᶜʷ→Equiv : {C : CW ℓ} {D : CW ℓ'} (m : ℕ)
-  (e : fst C ≃ fst D) → GroupEquiv (Hᶜʷ C m) (Hᶜʷ D m)
-Hᶜʷ→Equiv m e = GroupIso→GroupEquiv (Hᶜʷ→Iso m e)
+H̃ᶜʷ→Iso : {C : CW ℓ} {D : CW ℓ'} (m : ℕ)
+  (e : fst C ≃ fst D) → GroupIso (H̃ᶜʷ C m) (H̃ᶜʷ D m)
+Iso.fun (fst (H̃ᶜʷ→Iso m e)) = fst (H̃ᶜʷ→ m (fst e))
+Iso.inv (fst (H̃ᶜʷ→Iso m e)) = fst (H̃ᶜʷ→ m (invEq e))
+Iso.rightInv (fst (H̃ᶜʷ→Iso m e)) =
+  funExt⁻ (cong fst (sym (H̃ᶜʷ→comp m (fst e) (invEq e))
+       ∙∙ cong (H̃ᶜʷ→ m) (funExt (secEq e))
+       ∙∙ H̃ᶜʷ→id m))
+Iso.leftInv (fst (H̃ᶜʷ→Iso m e)) =
+  funExt⁻ (cong fst (sym (H̃ᶜʷ→comp m (invEq e) (fst e))
+       ∙∙ cong (H̃ᶜʷ→ m) (funExt (retEq e))
+       ∙∙ H̃ᶜʷ→id m))
+snd (H̃ᶜʷ→Iso m e) = snd (H̃ᶜʷ→ m (fst e))
+
+H̃ᶜʷ→Equiv : {C : CW ℓ} {D : CW ℓ'} (m : ℕ)
+  (e : fst C ≃ fst D) → GroupEquiv (H̃ᶜʷ C m) (H̃ᶜʷ D m)
+H̃ᶜʷ→Equiv m e = GroupIso→GroupEquiv (H̃ᶜʷ→Iso m e)
diff --git a/Cubical/CW/Homotopy.agda b/Cubical/CW/Homotopy.agda
index 430437223a..2ab2efae3b 100644
--- a/Cubical/CW/Homotopy.agda
+++ b/Cubical/CW/Homotopy.agda
@@ -20,6 +20,7 @@ open import Cubical.Foundations.Function
 open import Cubical.Foundations.GroupoidLaws
 
 open import Cubical.Data.Nat renaming (_+_ to _+ℕ_)
+open import Cubical.Data.Nat.Order.Inductive
 open import Cubical.Data.Int renaming (_·_ to _·ℤ_ ; -_ to -ℤ_)
 open import Cubical.Data.Fin.Inductive.Base
 open import Cubical.Data.Fin.Inductive.Properties
@@ -85,7 +86,6 @@ finCellHom↓ : {m : ℕ} {C : CWskel ℓ} {D : CWskel ℓ'}
 fhom (finCellHom↓ ϕ) n x = fhom ϕ (injectSuc n) x
 fcoh (finCellHom↓ {m = suc m} ϕ) n x = fcoh ϕ (injectSuc n) x
 
--- Extracting a map between sphere bouquets from a MMmap
 cofibIso : (n : ℕ) (C : CWskel ℓ)
   → Iso (Susp (cofibCW n C)) (SphereBouquet (suc n) (CWskel-fields.A C n))
 cofibIso n C =
@@ -197,7 +197,6 @@ module MMchainHomotopy* (m : ℕ) (C : CWskel ℓ) (D : CWskel ℓ')
         ∙∙ (cong inr (fhom H (injectSuc n) x))
         ∙∙ (cong inr (g .fcomm n x))
 
-  ww = MMΣcellMap
   -- the suspension of f as a MMmap
   MMΣf : MMmap m n merid-f merid-tt
   MMΣf = MMΣcellMap m n f
@@ -390,8 +389,7 @@ module realiseMMmap (C : CWskel ℓ) (D : CWskel ℓ') (m : ℕ)
                                 (cong inr (g .fcomm n x)) (~ l) i) (~ k) })
          south
 
-  -- realisation of MMΣH∂ is equal to Susp H∂
-  -- TODO: it is the same code as before. factorise!
+-- realisation of MMΣH∂ (suc n) is equal to Susp H∂
 realiseMMΣH∂ : (C : CWskel ℓ) (D : CWskel ℓ') (m : ℕ)
   (f g : finCellMap (suc m) C D) (H : finCellHom (suc m) f g)
       (n : Fin m) (x : Susp (cofibCW (suc (fst n)) C)) →
@@ -438,6 +436,40 @@ realiseMMΣH∂ C D (suc m) f g H n x =
                      (i ∨ (~ k))})
      south
 
+-- realisation of MMΣH∂ zero is constant
+realiseMMΣH∂₀ : (C : CWskel ℓ) (D : CWskel ℓ') (m : ℕ)
+  (f g : finCellMap (suc m) C D) (H : finCellHom (suc m) f g)
+      (x : Susp (cofibCW zero C)) →
+       MMmaps.realiseMMmap C D (suc m) fzero (λ x → inl tt) (λ x → inl tt)
+         (MMchainHomotopy*.MMΣH∂ (suc m) C D f g H fzero) x
+      ≡ north
+realiseMMΣH∂₀ C D m f g H x =
+  realiseMMmap1≡2 fzero fzero (λ x → inl tt)
+    (λ x → inl tt) (MMΣH∂ fzero) x ∙ aux x
+  where
+  open FinSequenceMap
+  open MMmaps C D
+  open MMchainHomotopy* (suc m) C D f g H
+  open preChainHomotopy (suc m) C D f g H
+  open realiseMMmap C D (suc m) f g H
+
+  aux : (x : Susp (cofibCW zero C)) →
+    realiseMMmap.realiseMMmap2 C D (suc m) f g H fzero fzero
+      (λ x₁ → inl tt) (λ x₁ → inl tt)
+      (MMchainHomotopy*.MMΣH∂ (suc m) C D f g H fzero) x
+    ≡ north
+  aux north = refl
+  aux south = refl
+  aux (merid (inl x) i) = refl
+  aux (merid (inr x) i) j =
+    hcomp (λ k → λ { (j = i0) → doubleCompPath-filler (merid (inl tt)) (λ _ → south) (λ i → merid (inl tt) (~ i)) k i
+                   ; (j = i1) → north
+                   ; (i = i0) → merid (inl tt) ((~ j) ∧ (~ k))
+                   ; (i = i1) → merid (inl tt) ((~ j) ∧ (~ k)) })
+          (merid (inl tt) (~ j))
+  aux (merid (push a i₁) i) with (C .snd .snd .snd .fst a)
+  aux (merid (push a i₁) i) | ()
+
 -- Then, we connect the addition of MMmaps to the addition of abelian maps
 module bouquetAdd where
   open MMmaps
@@ -591,24 +623,24 @@ module bouquetAdd where
 
 -- Now we have all the ingredients, we can get the chain homotopy equation
 module chainHomEquation (m : ℕ) (C : CWskel ℓ) (D : CWskel ℓ')
-  (f g : finCellMap (suc m) C D) (H : finCellHom (suc m) f g) (n : Fin m) where
+  (f g : finCellMap m C D) (H : finCellHom m f g) (n : Fin m) where
   open SequenceMap
-  open MMmaps C D (suc m) (fsuc n)
-  open MMchainHomotopy* (suc m) C D f g H (fsuc n)
-  open preChainHomotopy (suc m) C D f g H
-  -- open realiseMMmap m C D f g H
+  open MMmaps C D m n
+  open MMchainHomotopy* m C D f g H n
+  open preChainHomotopy m C D f g H
 
   private
     ℤ[AC_] = CWskel-fields.ℤ[A_] C
     ℤ[AD_] = CWskel-fields.ℤ[A_] D
 
   -- The four abelian group maps that are involved in the equation
-  ∂H H∂ fn+1 gn+1 : AbGroupHom (ℤ[AC (suc (fst n))]) (ℤ[AD (suc (fst n)) ])
+  ∂H H∂ fn gn : AbGroupHom (ℤ[AC (fst n) ]) (ℤ[AD (fst n) ])
 
-  ∂H = compGroupHom (chainHomotopy (fsuc n)) (∂ D (suc (fst n)))
-  H∂ = compGroupHom (∂ C (fst n)) (chainHomotopy (injectSuc n))
-  fn+1 = prefunctoriality.chainFunct (suc m) f (fsuc n)
-  gn+1 = prefunctoriality.chainFunct (suc m) g (fsuc n)
+  ∂H = compGroupHom (chainHomotopy n) (∂ D (fst n))
+  -- H∂ = compGroupHom (∂ C (fst n)) (chainHomotopy (injectSuc n))
+  H∂ = bouquetDegree (bouquetMMmap merid-tt merid-tt MMΣH∂)
+  fn = prefunctoriality.chainFunct m f n
+  gn = prefunctoriality.chainFunct m g n
 
   -- Technical lemma regarding suspensions of Iso's
   suspIso-suspFun : ∀ {ℓ ℓ' ℓ'' ℓ'''} {A : Type ℓ} {B : Type ℓ'}
@@ -639,79 +671,52 @@ module chainHomEquation (m : ℕ) (C : CWskel ℓ) (D : CWskel ℓ')
   -- connecting MM∂H to ∂H
   bouquet∂H : bouquetDegree (bouquetMMmap merid-f merid-g MM∂H) ≡ ∂H
   bouquet∂H =
-    cong (λ X → bouquetDegree ((Iso.fun (cofibIso (suc (fst n)) D))
-                ∘ X ∘ (Iso.inv (cofibIso (suc (fst n)) C))))
-         (funExt (realiseMMmap.realiseMM∂H C D (suc m) f g H (fsuc n)))
+    cong (λ X → bouquetDegree ((Iso.fun (cofibIso (fst n) D))
+                ∘ X ∘ (Iso.inv (cofibIso (fst n) C))))
+         (funExt (realiseMMmap.realiseMM∂H C D m f g H n))
       ∙ cong bouquetDegree ιδH≡pre∂∘H
-      ∙ bouquetDegreeComp (preboundary.pre∂ D (suc (fst n)))
-                          (bouquetHomotopy (fsuc n))
+      ∙ bouquetDegreeComp (preboundary.pre∂ D (fst n))
+                          (bouquetHomotopy n)
     where
-      ιδH : SphereBouquet (suc (suc (fst n)))
-              (Fin (CWskel-fields.card C (suc (fst n))))
-          → SphereBouquet (suc (suc (fst n)))
-              (Fin (CWskel-fields.card D (suc (fst n))))
-      ιδH = Iso.fun (cofibIso (suc (fst n)) D)
-           ∘ suspFun (to_cofibCW (suc (fst n)) D)
-           ∘ δ (suc (suc (fst n))) D
-           ∘ Hn+1/Hn (fsuc n)
-           ∘ Iso.inv (cofibIso (suc (fst n)) C)
-
-      ιδH≡pre∂∘H : ιδH ≡ (preboundary.pre∂ D (suc (fst n)))
-                        ∘ bouquetHomotopy (fsuc n)
+      ιδH : SphereBouquet (suc (fst n))
+              (Fin (CWskel-fields.card C (fst n)))
+          → SphereBouquet (suc (fst n))
+              (Fin (CWskel-fields.card D (fst n)))
+      ιδH = Iso.fun (cofibIso (fst n) D)
+           ∘ suspFun (to_cofibCW (fst n) D)
+           ∘ δ (suc (fst n)) D
+           ∘ Hn+1/Hn n
+           ∘ Iso.inv (cofibIso (fst n) C)
+
+      ιδH≡pre∂∘H : ιδH ≡ (preboundary.pre∂ D (fst n))
+                        ∘ bouquetHomotopy n
       ιδH≡pre∂∘H =
-        cong (λ X → Iso.fun (cofibIso (suc (fst n)) D)
-                     ∘ suspFun (to_cofibCW (suc (fst n)) D)
-                     ∘ δ (suc (suc (fst n))) D ∘ X ∘ Hn+1/Hn (fsuc n)
-                     ∘ Iso.inv (cofibIso (suc (fst n)) C))
-              (sym (funExt (Iso.leftInv (BouquetIso D (suc (suc (fst n)))))))
-
-  -- connecting MMΣH∂ to H∂
-  bouquetΣH∂ : bouquetDegree (bouquetMMmap merid-tt merid-tt MMΣH∂) ≡ H∂
-  bouquetΣH∂ =
-     cong (λ X → bouquetDegree ((Iso.fun (cofibIso (suc (fst n)) D))
-                ∘ X ∘ (Iso.inv (cofibIso (suc (fst n)) C))))
-         (funExt (realiseMMΣH∂ C D m f g H n))
-      ∙ cong bouquetDegree (cofibIso-suspFun _ C D (Hn+1/Hn (injectSuc n)
-                          ∘ suspFun (to_cofibCW (fst n) C) ∘ δ (suc (fst n)) C))
-      ∙ sym (bouquetDegreeSusp Hιδ)
-      ∙ cong bouquetDegree Hιδ≡H∘pre∂
-      ∙ bouquetDegreeComp (bouquetHomotopy (injectSuc n))
-                          (preboundary.pre∂ C (fst n))
-    where
-    Hιδ : SphereBouquet (suc (fst n)) (Fin (CWskel-fields.card C (suc (fst n))))
-        → SphereBouquet (suc (fst n)) (Fin (CWskel-fields.card D (suc (fst n))))
-    Hιδ = Iso.fun (BouquetIso D (suc (fst n)))
-                ∘ (Hn+1/Hn (injectSuc n))
-                ∘ suspFun (to_cofibCW (fst n) C)
-          ∘ δ (suc (fst n)) C ∘ Iso.inv (BouquetIso C (suc (fst n)))
-
-    Hιδ≡H∘pre∂ : Hιδ ≡ bouquetHomotopy (injectSuc n) ∘ (preboundary.pre∂ C (fst n))
-    Hιδ≡H∘pre∂ = cong (λ X → Iso.fun (BouquetIso D (suc (fst n)))
-                             ∘ (Hn+1/Hn (injectSuc n)) ∘ X
-                             ∘ suspFun (to_cofibCW (fst n) C) ∘ δ (suc (fst n)) C
-                             ∘ Iso.inv (BouquetIso C (suc (fst n))))
-                      (sym (funExt (Iso.leftInv (cofibIso (fst n) C))))
+        cong (λ X → Iso.fun (cofibIso (fst n) D)
+                     ∘ suspFun (to_cofibCW (fst n) D)
+                     ∘ δ (suc (fst n)) D ∘ X ∘ Hn+1/Hn n
+                     ∘ Iso.inv (cofibIso (fst n) C))
+              (sym (funExt (Iso.leftInv (BouquetIso D (suc (fst n))))))
 
   -- connecting MMΣf to fn+1
-  bouquetΣf : bouquetDegree (bouquetMMmap merid-f merid-tt MMΣf) ≡ fn+1
-  bouquetΣf = cong (λ X → bouquetDegree ((Iso.fun (cofibIso (suc (fst n)) D))
-                         ∘ X ∘ (Iso.inv (cofibIso (suc (fst n)) C))))
-         (funExt (realiseMMmap.realiseMMΣf C D (suc m) f g H (fsuc n)))
-    ∙ (cong bouquetDegree (cofibIso-suspFun (suc (fst n)) C D
-                           (prefunctoriality.fn+1/fn (suc m) f (fsuc n))))
-    ∙ sym (bouquetDegreeSusp (prefunctoriality.bouquetFunct (suc m) f (fsuc n)))
+  bouquetΣf : bouquetDegree (bouquetMMmap merid-f merid-tt MMΣf) ≡ fn
+  bouquetΣf = cong (λ X → bouquetDegree ((Iso.fun (cofibIso (fst n) D))
+                         ∘ X ∘ (Iso.inv (cofibIso (fst n) C))))
+         (funExt (realiseMMmap.realiseMMΣf C D m f g H n))
+    ∙ (cong bouquetDegree (cofibIso-suspFun (fst n) C D
+                           (prefunctoriality.fn+1/fn m f n)))
+    ∙ sym (bouquetDegreeSusp (prefunctoriality.bouquetFunct m f n))
 
   -- connecting MMΣg to gn+1
-  bouquetΣg : bouquetDegree (bouquetMMmap merid-g merid-tt MMΣg) ≡ gn+1
-  bouquetΣg = cong (λ X → bouquetDegree ((Iso.fun (cofibIso (suc (fst n)) D))
-                          ∘ X ∘ (Iso.inv (cofibIso (suc (fst n)) C))))
-         (funExt (realiseMMmap.realiseMMΣg C D (suc m) f g H (fsuc n)))
-    ∙ (cong bouquetDegree (cofibIso-suspFun (suc (fst n)) C D
-                            (prefunctoriality.fn+1/fn (suc m) g (fsuc n))))
-    ∙ sym (bouquetDegreeSusp (prefunctoriality.bouquetFunct (suc m) g (fsuc n)))
+  bouquetΣg : bouquetDegree (bouquetMMmap merid-g merid-tt MMΣg) ≡ gn
+  bouquetΣg = cong (λ X → bouquetDegree ((Iso.fun (cofibIso (fst n) D))
+                          ∘ X ∘ (Iso.inv (cofibIso (fst n) C))))
+         (funExt (realiseMMmap.realiseMMΣg C D m f g H n))
+    ∙ (cong bouquetDegree (cofibIso-suspFun (fst n) C D
+                            (prefunctoriality.fn+1/fn m g n)))
+    ∙ sym (bouquetDegreeSusp (prefunctoriality.bouquetFunct m g n))
 
   -- Alternative formulation of the chain homotopy equation
-  chainHomotopy1 : addGroupHom _ _ (addGroupHom _ _ ∂H gn+1) H∂ ≡ fn+1
+  chainHomotopy1 : addGroupHom _ _ (addGroupHom _ _ ∂H gn) H∂ ≡ fn
   chainHomotopy1 =
       cong (λ X → addGroupHom _ _ X H∂) aux
     ∙ aux2
@@ -719,32 +724,29 @@ module chainHomEquation (m : ℕ) (C : CWskel ℓ) (D : CWskel ℓ')
       (funExt MMchainHomotopy)
     ∙ bouquetΣf
     where
-      module T = MMchainHomotopy* (suc m) C D f g H (fsuc n)
+      module T = MMchainHomotopy* m C D f g H n
       MM∂H+MMΣg = MMmap-add T.merid-f T.merid-g T.merid-tt T.MM∂H T.MMΣg
       MM∂H+MMΣg+MMΣH∂ = MMmap-add merid-f merid-tt merid-tt MM∂H+MMΣg MMΣH∂
 
-      aux : addGroupHom _ _ ∂H gn+1
+      aux : addGroupHom _ _ ∂H gn
         ≡ bouquetDegree (bouquetMMmap merid-f merid-tt MM∂H+MMΣg)
       aux = cong₂ (λ X Y → addGroupHom _ _ X Y) (sym bouquet∂H) (sym bouquetΣg)
-            ∙ sym (bouquetAdd.realiseMMmap-hom C D (suc m) (fsuc n)
+            ∙ sym (bouquetAdd.realiseMMmap-hom C D m n
                     T.merid-f T.merid-g T.merid-tt T.MM∂H T.MMΣg)
 
       aux2 : addGroupHom _ _
                 (bouquetDegree (bouquetMMmap merid-f merid-tt MM∂H+MMΣg)) H∂
            ≡ bouquetDegree (bouquetMMmap merid-f merid-tt MM∂H+MMΣg+MMΣH∂)
-      aux2 = cong (addGroupHom _ _ (bouquetDegree
-                                     (bouquetMMmap merid-f merid-tt MM∂H+MMΣg)))
-                  (sym bouquetΣH∂)
-             ∙ sym (bouquetAdd.realiseMMmap-hom C D (suc m) (fsuc n)
+      aux2 = sym (bouquetAdd.realiseMMmap-hom C D m n
                      T.merid-f T.merid-tt T.merid-tt MM∂H+MMΣg T.MMΣH∂)
 
   -- Standard formulation of the chain homotopy equation
-  chainHomotopy2 : subtrGroupHom _ _ fn+1 gn+1 ≡ addGroupHom _ _ ∂H H∂
+  chainHomotopy2 : subtrGroupHom _ _ fn gn ≡ addGroupHom _ _ ∂H H∂
   chainHomotopy2 =
-    GroupHom≡ (funExt λ x → aux (fn+1 .fst x) (∂H .fst x) (gn+1 .fst x)
+    GroupHom≡ (funExt λ x → aux (fn .fst x) (∂H .fst x) (gn .fst x)
                (H∂ .fst x) (cong (λ X → X .fst x) chainHomotopy1))
      where
-      open AbGroupStr (snd (ℤ[AD (suc (fst n)) ]))
+      open AbGroupStr (snd (ℤ[AD (fst n) ]))
         renaming (_+_ to _+G_ ; -_ to -G_ ; +Assoc to +AssocG ; +Comm to +CommG)
       aux : ∀ w x y z → (x +G y) +G z ≡ w → w +G (-G y) ≡ x +G z
       aux w x y z H = cong (λ X → X +G (-G y)) (sym H)
@@ -755,12 +757,87 @@ module chainHomEquation (m : ℕ) (C : CWskel ℓ) (D : CWskel ℓ')
                               ∙ cong (λ X → x +G X) (+InvR y)
                               ∙ +IdR x)
 
+module chainHomEquationSuc (m : ℕ) (C : CWskel ℓ) (D : CWskel ℓ')
+  (f g : finCellMap (suc m) C D) (H : finCellHom (suc m) f g) (n : Fin m) where
+  open SequenceMap
+  open MMmaps C D (suc m) (fsuc n)
+  open MMchainHomotopy* (suc m) C D f g H (fsuc n)
+  open preChainHomotopy (suc m) C D f g H
+  open chainHomEquation (suc m) C D f g H (fsuc n)
+
+  private
+    ℤ[AC_] = CWskel-fields.ℤ[A_] C
+    ℤ[AD_] = CWskel-fields.ℤ[A_] D
+
+  H∂' : AbGroupHom (ℤ[AC (suc (fst n)) ]) (ℤ[AD (suc (fst n)) ])
+  H∂' = compGroupHom (∂ C (fst n)) (chainHomotopy (injectSuc n))
+
+  -- connecting MMΣH∂ to H∂'
+  bouquetΣH∂ : H∂ ≡ H∂'
+  bouquetΣH∂ =
+     cong (λ X → bouquetDegree ((Iso.fun (cofibIso (suc (fst n)) D))
+                ∘ X ∘ (Iso.inv (cofibIso (suc (fst n)) C))))
+         (funExt (realiseMMΣH∂ C D m f g H n))
+      ∙ cong bouquetDegree (cofibIso-suspFun _ C D (Hn+1/Hn (injectSuc n)
+                          ∘ suspFun (to_cofibCW (fst n) C) ∘ δ (suc (fst n)) C))
+      ∙ sym (bouquetDegreeSusp Hιδ)
+      ∙ cong bouquetDegree Hιδ≡H∘pre∂
+      ∙ bouquetDegreeComp (bouquetHomotopy (injectSuc n))
+                          (preboundary.pre∂ C (fst n))
+    where
+    Hιδ : SphereBouquet (suc (fst n)) (Fin (CWskel-fields.card C (suc (fst n))))
+        → SphereBouquet (suc (fst n)) (Fin (CWskel-fields.card D (suc (fst n))))
+    Hιδ = Iso.fun (BouquetIso D (suc (fst n)))
+                ∘ (Hn+1/Hn (injectSuc n))
+                ∘ suspFun (to_cofibCW (fst n) C)
+          ∘ δ (suc (fst n)) C ∘ Iso.inv (BouquetIso C (suc (fst n)))
+
+    Hιδ≡H∘pre∂ : Hιδ ≡ bouquetHomotopy (injectSuc n) ∘ (preboundary.pre∂ C (fst n))
+    Hιδ≡H∘pre∂ = cong (λ X → Iso.fun (BouquetIso D (suc (fst n)))
+                             ∘ (Hn+1/Hn (injectSuc n)) ∘ X
+                             ∘ suspFun (to_cofibCW (fst n) C) ∘ δ (suc (fst n)) C
+                             ∘ Iso.inv (BouquetIso C (suc (fst n))))
+                      (sym (funExt (Iso.leftInv (cofibIso (fst n) C))))
+
+  chainHomotopySuc : subtrGroupHom _ _ fn gn ≡ addGroupHom _ _ ∂H H∂'
+  chainHomotopySuc = chainHomotopy2 ∙ cong (addGroupHom _ _ ∂H) bouquetΣH∂
+
+module chainHomEquationZero (m : ℕ) (C : CWskel ℓ) (D : CWskel ℓ')
+  (f g : finCellMap (suc m) C D) (H : finCellHom (suc m) f g) where
+  open SequenceMap
+  open MMmaps C D (suc m) fzero
+  open MMchainHomotopy* (suc m) C D f g H fzero
+  open preChainHomotopy (suc m) C D f g H
+  open chainHomEquation (suc m) C D f g H fzero
+
+  private
+    ℤ[AC_] = CWskel-fields.ℤ[A_] C
+    ℤ[AD_] = CWskel-fields.ℤ[A_] D
+
+  H∂' : AbGroupHom (ℤ[AC 0 ]) (ℤ[AD 0 ])
+  H∂' = compGroupHom (augmentation.ϵ C) trivGroupHom
+
+  MMΣH∂-const : ∀ x → bouquetMMmap merid-tt merid-tt MMΣH∂ x ≡ inl tt
+  MMΣH∂-const x = cong (Iso.fun (cofibIso 0 D)) (realiseMMΣH∂₀ C D m f g H (Iso.inv (cofibIso 0 C) x))
+
+  bouquetΣH∂ : H∂ ≡ H∂'
+  bouquetΣH∂ = cong bouquetDegree (funExt MMΣH∂-const)
+             ∙ bouquetDegreeConst _ _ _
+             ∙ GroupHom≡ refl
+
+  chainHomotopyZero : subtrGroupHom _ _ fn gn ≡ addGroupHom _ _ ∂H H∂'
+  chainHomotopyZero = chainHomotopy2 ∙ cong (addGroupHom _ _ ∂H) bouquetΣH∂
+
 -- Going from a cell homotopy to a chain homotopy
 cellHom-to-ChainHomotopy : {C : CWskel ℓ} {D : CWskel ℓ'} (m : ℕ)
-  {f g : finCellMap (suc m) C D} (H : finCellHom (suc m) f g)
-  → finChainHomotopy m (finCellMap→finChainComplexMap m f)
-                        (finCellMap→finChainComplexMap m g)
-cellHom-to-ChainHomotopy {C = C} {D} m {f} {g} H .finChainHomotopy.fhtpy n =
-  preChainHomotopy.chainHomotopy (suc m) C D f g H n
-cellHom-to-ChainHomotopy {C = C} {D} m {f} {g} H .finChainHomotopy.fbdryhtpy n =
-  chainHomEquation.chainHomotopy2 m C D f g H n
+  {f g : finCellMap (suc (suc m)) C D} (H : finCellHom (suc (suc m)) f g)
+  → finChainHomotopy (suc m) (finCellMap→finChainComplexMap m f)
+                             (finCellMap→finChainComplexMap m g)
+cellHom-to-ChainHomotopy {C = C} {D} m {f} {g} H .finChainHomotopy.fhtpy (zero , _) =
+  trivGroupHom
+cellHom-to-ChainHomotopy {C = C} {D} m {f} {g} H .finChainHomotopy.fhtpy (suc n , n<m) =
+  preChainHomotopy.chainHomotopy (suc (suc m)) C D f g H (injectSuc (n , n<m))
+cellHom-to-ChainHomotopy {C = C} {D} m {f} {g} H .finChainHomotopy.fbdryhtpy (zero , _) =
+  chainHomEquationZero.chainHomotopyZero (suc m) C D f g H
+cellHom-to-ChainHomotopy {C = C} {D} m {f} {g} H .finChainHomotopy.fbdryhtpy (suc n , n<m) =
+  chainHomEquationSuc.chainHomotopySuc (suc m) C D f g H (n , <ᵗ-trans-suc n<m)
diff --git a/Cubical/CW/Map.agda b/Cubical/CW/Map.agda
index b057c67666..ae44795d59 100644
--- a/Cubical/CW/Map.agda
+++ b/Cubical/CW/Map.agda
@@ -31,6 +31,7 @@ open import Cubical.CW.Base
 open import Cubical.CW.Properties
 open import Cubical.CW.ChainComplex
 
+open import Cubical.HITs.S1
 open import Cubical.HITs.Sn.Degree
 open import Cubical.HITs.Pushout
 open import Cubical.HITs.Susp
@@ -320,34 +321,85 @@ module functoriality (m : ℕ) (f : finCellMap (suc m) C D) where
       degree-pre∂∘funct n =
         bouquetDegreeComp (preboundary.pre∂ D (fst n)) (bouquetFunct (fsuc n))
 
+-- Now we prove the commutativity condition for the augmentation map
+module augmentationFunct (m : ℕ) (f : finCellMap (suc m) C D) where
+  open CWskel-fields
+  open SequenceMap
+  module pf* = prefunctoriality m (finCellMap↓ f)
+  open prefunctoriality (suc m) f
+  open FinSequenceMap
+
+  commε : (x : Susp (cofibCW 0 C))
+    → ((augmentation.ε D) ∘ (suspFun (fn+1/fn fzero))) x
+     ≡ augmentation.ε C x
+  commε north = refl
+  commε south = refl
+  commε (merid (inl x) i) = refl
+  commε (merid (inr x) i) = refl
+  commε (merid (push x i₁) i) with (C .snd .snd .snd .fst x)
+  commε (merid (push x i₁) i) | ()
+
+  commPreϵ : (x : SphereBouquet 1 (A C 0))
+           → ((augmentation.preϵ D) ∘ (bouquetSusp→ (bouquetFunct fzero))) x ≡ augmentation.preϵ C x
+  commPreϵ x = cong ((ε D) ∘ (suspFun (inv (iso2 D)))) (leftInv (iso1 D) (((suspFun (bouquetFunct fzero)) ∘ (inv (iso1 C))) x))
+             ∙ cong (ε D) (funExt⁻ aux (inv (iso1 C) x))
+             ∙ commε (((suspFun (inv (iso2 C))) ∘ (inv (iso1 C))) x)
+    where
+      open Iso
+      open augmentation
+
+      bouquet : (C : CWskel ℓ) (n : ℕ) → Type
+      bouquet = λ C n → SphereBouquet n (Fin (snd C .fst 0))
+
+      iso1 : (C : CWskel ℓ) → Iso (Susp (bouquet C 0)) (bouquet C 1)
+      iso1 C = sphereBouquetSuspIso
+
+      iso2 : (C : CWskel ℓ) → Iso (cofibCW 0 C) (bouquet C 0)
+      iso2 C = BouquetIso-gen 0 (snd C .fst 0) (snd C .snd .fst 0) (snd C .snd .snd .snd 0)
+
+      aux : (suspFun (inv (iso2 D))) ∘ (suspFun (bouquetFunct fzero))
+             ≡ (suspFun (fn+1/fn fzero)) ∘ (suspFun (inv (iso2 C)))
+      aux = (sym (suspFunComp (inv (iso2 D)) (bouquetFunct fzero)))
+          ∙ cong suspFun (funExt (λ x → leftInv (iso2 D) (((fn+1/fn fzero) ∘ (inv (iso2 C))) x)))
+          ∙ (suspFunComp (fn+1/fn fzero) (inv (iso2 C)))
+
+  commϵFunct : compGroupHom (chainFunct fzero) (augmentation.ϵ D)
+               ≡ compGroupHom (augmentation.ϵ C) (idGroupHom)
+  commϵFunct = (λ i → compGroupHom (bouquetDegreeSusp (bouquetFunct fzero) i) (augmentation.ϵ D))
+             ∙ sym (bouquetDegreeComp (augmentation.preϵ D) (bouquetSusp→ (bouquetFunct fzero)))
+             ∙ cong bouquetDegree (funExt commPreϵ)
+             ∙ sym (compGroupHomId (augmentation.ϵ C))
+
 open finChainComplexMap
+
 -- Main statement of functoriality
--- From a cellMap, we can get a ChainComplexMap
-finCellMap→finChainComplexMap : (m : ℕ) (f : finCellMap (suc m) C D)
-  → finChainComplexMap m (CW-ChainComplex C) (CW-ChainComplex D)
-fchainmap (finCellMap→finChainComplexMap m f) n =
-  prefunctoriality.chainFunct (suc m) f n
-fbdrycomm (finCellMap→finChainComplexMap m f) n = functoriality.comm∂Funct m f n
+-- From a cellMap, we can get a ChainComplexMap between augmented chain complexes
+finCellMap→finChainComplexMap : (m : ℕ) (f : finCellMap (suc (suc m)) C D)
+  → finChainComplexMap (suc m) (CW-AugChainComplex C) (CW-AugChainComplex D)
+fchainmap (finCellMap→finChainComplexMap m f) (zero , _) = idGroupHom
+fchainmap (finCellMap→finChainComplexMap m f) (suc n , n<m) = prefunctoriality.chainFunct (suc (suc m)) f (injectSuc (n , n<m))
+fbdrycomm (finCellMap→finChainComplexMap m f) (zero , _) = augmentationFunct.commϵFunct (suc m) f
+fbdrycomm (finCellMap→finChainComplexMap m f) (suc n , n<m) = functoriality.comm∂Funct (suc m) f (n , <ᵗ-trans-suc n<m)
 
 finCellMap→finChainComplexMapId : (m : ℕ)
-  → finCellMap→finChainComplexMap m (idFinCellMap (suc m) C)
-   ≡ idFinChainMap m (CW-ChainComplex C)
+  → finCellMap→finChainComplexMap m (idFinCellMap (suc (suc m)) C)
+   ≡ idFinChainMap (suc m) (CW-AugChainComplex C)
 finCellMap→finChainComplexMapId m = finChainComplexMap≡
-  λ x → cong bouquetDegree (bouquetFunct-id _ _ x) ∙ bouquetDegreeId
+  λ { (zero , _) → refl
+    ; (suc n , n<m) → cong bouquetDegree (bouquetFunct-id _ _ (injectSuc (n , n<m))) ∙ bouquetDegreeId }
 
 finCellMap→finChainComplexMapComp : (m : ℕ)
-  (g : finCellMap (suc m) D E) (f : finCellMap (suc m) C D)
+  (g : finCellMap (suc (suc m)) D E) (f : finCellMap (suc (suc m)) C D)
   → finCellMap→finChainComplexMap m (composeFinCellMap _ g f)
    ≡ compFinChainMap (finCellMap→finChainComplexMap m f)
                      (finCellMap→finChainComplexMap m g)
-finCellMap→finChainComplexMapComp m g f =
-  finChainComplexMap≡ λ x
-    → cong bouquetDegree (sym (bouquetFunct-comp _ g f x))
-     ∙ bouquetDegreeComp _ _
+finCellMap→finChainComplexMapComp m g f = finChainComplexMap≡
+  λ { (zero , _) → sym (compGroupHomId idGroupHom)
+    ; (suc n , n<m) → cong bouquetDegree (sym (bouquetFunct-comp _ g f (injectSuc (n , n<m)))) ∙ bouquetDegreeComp _ _ }
 
 -- And thus a map of homology
 finCellMap→HomologyMap : (m : ℕ) (f : finCellMap (suc (suc (suc m))) C D)
-  → GroupHom (Hˢᵏᵉˡ C m) (Hˢᵏᵉˡ D m)
+  → GroupHom (H̃ˢᵏᵉˡ C m) (H̃ˢᵏᵉˡ D m)
 finCellMap→HomologyMap {C = C} {D = D} m f =
   finChainComplexMap→HomologyMap (suc m)
     (finCellMap→finChainComplexMap _ f) flast
diff --git a/Cubical/CW/Subcomplex.agda b/Cubical/CW/Subcomplex.agda
index 37fbed2618..1495d8f4a6 100644
--- a/Cubical/CW/Subcomplex.agda
+++ b/Cubical/CW/Subcomplex.agda
@@ -214,47 +214,38 @@ module _ (C : CWskel ℓ) where
   ... | gt x = ⊥.rec (¬m<ᵗm (<ᵗ-trans x p))
 
 subChainIso : (C : CWskel ℓ) (n : ℕ) (m : Fin n)
-  → AbGroupIso (CWskel-fields.ℤ[A_] C (fst m))
-                (CWskel-fields.ℤ[A_] (subComplex C n) (fst m))
-subChainIso C n (m , p) with (m ≟ᵗ n)
+  → AbGroupIso (CW-AugChainComplex C .ChainComplex.chain (fst m))
+                (CW-AugChainComplex (subComplex C n) .ChainComplex.chain (fst m))
+subChainIso C n (zero , p) = idGroupIso
+subChainIso C n (suc m , p) with (m ≟ᵗ n)
 ... | lt x = idGroupIso
-... | eq x = ⊥.rec (¬m<ᵗm (subst (m <ᵗ_) (sym x) p))
-... | gt x = ⊥.rec (¬m<ᵗm (<ᵗ-trans x p))
+... | eq x = ⊥.rec (¬-suc-n<ᵗn ((subst (suc m <ᵗ_) (sym x) p)))
+... | gt x = ⊥.rec (¬-suc-n<ᵗn ((<ᵗ-trans p x)))
 
 -- main result
 subComplexHomology : (C : CWskel ℓ) (n m : ℕ) (p : suc (suc m) <ᵗ n)
-  → GroupIso (Hˢᵏᵉˡ C m) (Hˢᵏᵉˡ (subComplex C n) m)
+  → GroupIso (H̃ˢᵏᵉˡ C m) (H̃ˢᵏᵉˡ (subComplex C n) m)
 subComplexHomology C n m p =
   homologyIso m _ _
     (subChainIso C n (suc (suc m) , p))
     (subChainIso C n (suc m , <ᵗ-trans <ᵗsucm p))
     (subChainIso C n (m , <ᵗ-trans <ᵗsucm (<ᵗ-trans <ᵗsucm p)))
-    lem₁
-    lem₂
+    (lem₁ m)
+    (lem₁ (suc m))
   where
-  lem₁ : {q : _} {r : _}
-    → Iso.fun (subChainIso C n (m , q) .fst) ∘ ∂ C m .fst
-    ≡ ∂ (subComplex C n) m .fst
+  lem₁ : (m : ℕ) {q : _} {r : _}
+    → Iso.fun (subChainIso C n (m , q) .fst) ∘ CW-AugChainComplex C .ChainComplex.bdry m .fst
+    ≡ CW-AugChainComplex (subComplex C n) .ChainComplex.bdry m .fst
      ∘ Iso.fun (subChainIso C n (suc m , r) .fst)
-  lem₁ {q} {r} with (m ≟ᵗ n) | (suc m ≟ᵗ n) | (suc (suc m) ≟ᵗ n)
-  ... | lt x | lt x₁ | lt x₂ = refl
-  ... | lt x | lt x₁ | eq x₂ = refl
-  ... | lt x | lt x₁ | gt x₂ = ⊥.rec (¬squeeze (x₁ , x₂))
-  ... | lt x | eq x₁ | t = ⊥.rec (¬m<ᵗm (subst (_<ᵗ n) x₁ r))
-  ... | lt x | gt x₁ | t = ⊥.rec (¬m<ᵗm (<ᵗ-trans x₁ r))
-  ... | eq x | s | t = ⊥.rec (¬-suc-n<ᵗn (subst (suc m <ᵗ_) (sym x) r))
-  ... | gt x | s | t = ⊥.rec (¬-suc-n<ᵗn (<ᵗ-trans r x))
-
-  lem₂ : {q : suc m <ᵗ n} {r : (suc (suc m)) <ᵗ n}
-    → Iso.fun (subChainIso C n (suc m , q) .fst)
-     ∘ ∂ C (suc m) .fst
-     ≡ ∂ (subComplex C n) (suc m) .fst
-     ∘ Iso.fun (subChainIso C n (suc (suc m) , r) .fst)
-  lem₂ {q} with (suc m ≟ᵗ n) | (suc (suc m) ≟ᵗ n) | (suc (suc (suc m)) ≟ᵗ n)
+  lem₁ zero with (0 ≟ᵗ n)
+  ... | lt x = refl
+  ... | eq x = ⊥.rec (subst (suc (suc m) <ᵗ_) (sym x) p)
+  ... | gt x = ⊥.rec x
+  lem₁ (suc m) {q} {r} with (m ≟ᵗ n) | (suc m ≟ᵗ n) | (suc (suc m) ≟ᵗ n)
   ... | lt x | lt x₁ | lt x₂ = refl
   ... | lt x | lt x₁ | eq x₂ = refl
   ... | lt x | lt x₁ | gt x₂ = ⊥.rec (¬squeeze (x₁ , x₂))
-  ... | lt x | eq x₁ | t = ⊥.rec (¬m<ᵗm (subst (_<ᵗ n) x₁ p))
-  ... | lt x | gt x₁ | t = ⊥.rec (¬m<ᵗm (<ᵗ-trans x₁ p))
-  ... | eq x | s | t = ⊥.rec (¬m<ᵗm (subst (suc m <ᵗ_) (sym x) q))
-  ... | gt x | s | t = ⊥.rec (¬-suc-n<ᵗn (<ᵗ-trans p x))
+  ... | lt x | eq x₁ | t = ⊥.rec ((¬m<ᵗm (subst (_<ᵗ n) x₁ q)))
+  ... | lt x | gt x₁ | t = ⊥.rec ((¬m<ᵗm (<ᵗ-trans x₁ q)))
+  ... | eq x | s | t = ⊥.rec (¬-suc-n<ᵗn (subst (suc m <ᵗ_) (sym x) q))
+  ... | gt x | s | t = ⊥.rec ((¬-suc-n<ᵗn (<ᵗ-trans q x)))
diff --git a/Cubical/Categories/Constructions/SubObject.agda b/Cubical/Categories/Constructions/SubObject.agda
index 2a5040bd49..2e94416488 100644
--- a/Cubical/Categories/Constructions/SubObject.agda
+++ b/Cubical/Categories/Constructions/SubObject.agda
@@ -11,7 +11,7 @@ open import Cubical.Categories.Category
 open import Cubical.Categories.Functor
 open import Cubical.Categories.Morphism
 
-open import Cubical.Relation.Binary.Order.Preorder
+open import Cubical.Relation.Binary.Order.Proset
 
 open Category
 
@@ -83,9 +83,9 @@ SliceHom.S-comm
     ∎
 
 module _ (isSetCOb : isSet (C .ob)) where
-  subObjCatPreorderStr : PreorderStr _ (SubObjCat .ob)
-  PreorderStr._≲_ subObjCatPreorderStr x y = SubObjCat [ x , y ]
-  IsPreorder.is-set (PreorderStr.isPreorder subObjCatPreorderStr) = isSetΣ (isSetSliceOb isSetCOb) λ x → isProp→isSet (∈-isProp isSubObj x)
-  IsPreorder.is-prop-valued (PreorderStr.isPreorder subObjCatPreorderStr) = isPropSubObjMor
-  IsPreorder.is-refl (PreorderStr.isPreorder subObjCatPreorderStr) = isReflSubObjMor
-  IsPreorder.is-trans (PreorderStr.isPreorder subObjCatPreorderStr) = isTransSubObjMor
+  subObjCatPreorderStr : ProsetStr _ (SubObjCat .ob)
+  ProsetStr._≲_ subObjCatPreorderStr x y = SubObjCat [ x , y ]
+  IsProset.is-set (ProsetStr.isProset subObjCatPreorderStr) = isSetΣ (isSetSliceOb isSetCOb) λ x → isProp→isSet (∈-isProp isSubObj x)
+  IsProset.is-prop-valued (ProsetStr.isProset subObjCatPreorderStr) = isPropSubObjMor
+  IsProset.is-refl (ProsetStr.isProset subObjCatPreorderStr) = isReflSubObjMor
+  IsProset.is-trans (ProsetStr.isProset subObjCatPreorderStr) = isTransSubObjMor
diff --git a/Cubical/Categories/DistLatticeSheaf/Extension.agda b/Cubical/Categories/DistLatticeSheaf/Extension.agda
index 4687ad8189..417e43b762 100644
--- a/Cubical/Categories/DistLatticeSheaf/Extension.agda
+++ b/Cubical/Categories/DistLatticeSheaf/Extension.agda
@@ -736,11 +736,10 @@ module PreSheafExtension (L : DistLattice ℓ) (C : Category ℓ' ℓ'')
       s₁ (cospanPath i) = DLRan F .F-hom (≤m→≤j _ _ (∧≤LCancel _ _))
       s₂ (cospanPath i) = DLRan F .F-hom (≤m→≤j _ _ (∧≤RCancel _ _))
 
-      private
-        F[⋁β]Cone = limitC _ (F* (⋁ β)) .limCone
-        F[⋁γ]Cone = limitC _ (F* (⋁ γ)) .limCone
-        F[⋁β∧⋁γ]Cone = limitC _ (F* (⋁ β ∧l ⋁ γ)) .limCone
-        F[⋁β++γ]Cone = limitC _ (F* (⋁ (β ++Fin γ))) .limCone
+      F[⋁β]Cone = limitC _ (F* (⋁ β)) .limCone
+      F[⋁γ]Cone = limitC _ (F* (⋁ γ)) .limCone
+      F[⋁β∧⋁γ]Cone = limitC _ (F* (⋁ β ∧l ⋁ γ)) .limCone
+      F[⋁β++γ]Cone = limitC _ (F* (⋁ (β ++Fin γ))) .limCone
 
       -- the family of squares we need to construct cones over β++γ
       to++ConeSquare : {c : ob C} (f : C [ c , ⋁Cospan .l ]) (g : C [ c , ⋁Cospan .r ])
diff --git a/Cubical/Categories/RezkCompletion/Construction.agda b/Cubical/Categories/RezkCompletion/Construction.agda
index 26f420355e..415d33e4c9 100644
--- a/Cubical/Categories/RezkCompletion/Construction.agda
+++ b/Cubical/Categories/RezkCompletion/Construction.agda
@@ -8,6 +8,18 @@ The Construction of Rezk Completion
 module Cubical.Categories.RezkCompletion.Construction where
 
 open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Transport hiding (pathToIso)
+open import Cubical.Foundations.Isomorphism using (isoToPath; Iso; isoToIsEquiv; iso)
+open import Cubical.Foundations.Univalence using (uaβ)
+open import Cubical.Foundations.Equiv.Base
+open import Cubical.Functions.FunExtEquiv
+open import Cubical.Functions.Surjection
+open import Cubical.HITs.PropositionalTruncation using (∥_∥₁; ∣_∣₁; isPropPropTrunc)
+open import Cubical.HITs.GroupoidQuotients as GQ using (_//_; [_]; eq//; comp//; squash//)
 
 open import Cubical.Categories.Category
 open import Cubical.Categories.Functor
@@ -15,12 +27,12 @@ open import Cubical.Categories.Equivalence.WeakEquivalence
 open import Cubical.Categories.Constructions.EssentialImage
 open import Cubical.Categories.Presheaf.Base
 open import Cubical.Categories.Yoneda
+open import Cubical.Categories.Isomorphism
 
 open import Cubical.Categories.RezkCompletion.Base
 
-private
-  variable
-    ℓ ℓ' : Level
+private variable
+  ℓ ℓ' ℓ'' ℓ''' : Level
 
 open isWeakEquivalence
 
@@ -61,5 +73,372 @@ module RezkByYoneda (C : Category ℓ ℓ) where
 {- The Construction by Higher Inductive Type -}
 
 module RezkByHIT (C : Category ℓ ℓ') where
+  module C = Category C
+  open Category hiding (_∘_)
+  open isUnivalent
+  open Functor
+  open isIso
 
-  -- TODO: Write the HIT construction of Rezk completion here.
+  private
+    variable
+      x y z w : ob C
+
+    IsoC : ob C → ob C → Type ℓ'
+    IsoC = CatIso C
+
+    ⋆IsoC : ∀ x y z → IsoC x y → IsoC y z → IsoC x z
+    ⋆IsoC x y z = ⋆Iso
+
+  RezkOb : Type (ℓ-max ℓ ℓ')
+  RezkOb = ob C // ⋆IsoC
+
+  inc : ob C → RezkOb
+  inc = [_]
+
+  inc-ua : IsoC x y → inc x ≡ inc y
+  inc-ua = eq//
+
+  inc-sq : (f : IsoC x y) (g : IsoC y z) → Square (inc-ua f) (inc-ua (⋆Iso f g)) refl (inc-ua g)
+  inc-sq = comp//
+
+  squash : isGroupoid RezkOb
+  squash = squash//
+
+  elim : {P : RezkOb → Type ℓ''} → _ → (f : _) → (feq : _) → _ → ∀ x → P x
+  elim = GQ.elim {A = ob C} ⋆IsoC
+
+  elimSet : {P : RezkOb → Type ℓ''} → _ → (f : _) → _ → ∀ x → P x
+  elimSet = GQ.elimSet {A = ob C} ⋆IsoC
+
+  elimProp : {P : RezkOb → Type ℓ''} → _ → _ → ∀ x → P x
+  elimProp = GQ.elimProp {A = ob C} ⋆IsoC
+
+  rec : {P : Type ℓ''} → _ → (f : _) → (feq : _) → _ → RezkOb → P
+  rec = GQ.rec {A = ob C} ⋆IsoC
+
+  module _ {P : RezkOb → RezkOb → Type ℓ''}
+    (P-Set : ∀ x y → isSet (P x y))
+    (P-inc : ∀ x y → P (inc x) (inc y))
+    (P-inc-ua : ∀ {x y z} f
+              → PathP (λ i → P (inc x) (inc-ua f i)) (P-inc x y) (P-inc x z))
+    (P-ua-inc : ∀ {x y z} f
+              → PathP (λ i → P (inc-ua f i) (inc z)) (P-inc x z) (P-inc y z))
+    where
+
+    elimSet₂ : ∀ x y → P x y
+    elimSet₂ = elimSet (λ x → isSetΠ (P-Set x)) (λ x → elimSet (P-Set (inc x)) (P-inc x) P-inc-ua) λ f →
+      funExt (elimProp (λ x → isOfHLevelPathP' 1 (P-Set _ _) _ _) λ x → P-ua-inc f)
+
+  module _ {P : RezkOb → RezkOb → Type ℓ''}
+    (P-Prop : ∀ x y → isProp (P x y))
+    (P-inc : ∀ x y → P (inc x) (inc y))
+    where
+
+    elimProp₂ : ∀ x y → P x y
+    elimProp₂ = elimProp (λ x → isPropΠ (P-Prop x)) λ x → elimProp (P-Prop (inc x)) (P-inc x)
+
+  module _ {P : RezkOb → RezkOb → RezkOb → Type ℓ''}
+    (P-Set : ∀ x y z → isSet (P x y z))
+    (P-inc : ∀ x y z → P (inc x) (inc y) (inc z))
+    (P-ua₁ : ∀ {x y z w} f
+           → PathP (λ i → P (inc x) (inc y) (inc-ua f i)) (P-inc x y z) (P-inc x y w))
+    (P-ua₂ : ∀ {x y z w} f
+           → PathP (λ i → P (inc x) (inc-ua f i) (inc w)) (P-inc x y w) (P-inc x z w))
+    (P-ua₃ : ∀ {x y z w} f
+           → PathP (λ i → P (inc-ua f i) (inc z) (inc w)) (P-inc x z w) (P-inc y z w))
+    where
+
+    elimSet₃ : ∀ x y z → P x y z
+    elimSet₃ = elimSet (λ x → isSetΠ2 (P-Set x)) (λ x → elimSet₂ (P-Set (inc x)) (P-inc x) P-ua₁ P-ua₂) λ f → funExt₂ $
+      elimProp₂ (λ x y → isOfHLevelPathP' 1 (P-Set _ _ _) _ _) λ x y → P-ua₃ f
+
+  module _ {P : Type ℓ''}
+    (P-Grpd : isGroupoid P)
+    (P-inc : ob C → ob C → P)
+    (P-inc-ua : ∀ {x y z} → IsoC y z → P-inc x y ≡ P-inc x z)
+    (P-ua-inc : ∀ {x y z} → IsoC x y → P-inc x z ≡ P-inc y z)
+    (P-ua-inc-ua : ∀ {x y z w} (g : IsoC z w) (f : IsoC x y)
+      → Square (P-ua-inc g) (P-ua-inc g) (P-inc-ua f) (P-inc-ua f))
+    (P-inc-sq : ∀ {x y z w} (f : IsoC y z) (g : IsoC z w)
+      → Square (P-inc-ua {x = x} f) (P-inc-ua (⋆Iso f g)) refl (P-inc-ua g))
+    (P-sq-inc : ∀ {x y z w} (f : IsoC x y) (g : IsoC y z)
+      → Square (P-ua-inc {z = w} f) (P-ua-inc (⋆Iso f g)) refl (P-ua-inc g))
+    where
+
+    rec₂ : RezkOb → RezkOb → P
+    rec₂ = rec (isGroupoidΠ λ _ → P-Grpd)
+      (λ x → rec P-Grpd (P-inc x) P-inc-ua P-inc-sq)
+      (λ f → funExt (elimSet (λ _ → P-Grpd _ _) (λ _ → P-ua-inc f) (P-ua-inc-ua f)))
+      (λ f g → congP (λ _ → funExt) (funExt (elimProp (λ x → isOfHLevelPathP' 1 (P-Grpd _ _) _ _) λ x → P-sq-inc f g)))
+
+  module _ (P : Category ℓ'' ℓ''') (P-univ : isUnivalent P) (P-inc : Functor C P)
+    where
+
+    recCat : RezkOb → ob P
+    recCat = rec (isGroupoid-ob P-univ) (P-inc .F-ob)
+                 (CatIsoToPath P-univ ∘ F-Iso {F = P-inc}) λ f g →
+      congP (λ _ → CatIsoToPath P-univ) $
+        subst⁻ (PathP _ (F-Iso {F = P-inc} f)) (F-Iso-Pres⋆ f g) $
+          transportIsoToPathIso P-univ _ _
+
+  inc-⋆ : (f : IsoC x y) (g : IsoC y z) → inc-ua (⋆Iso f g) ≡ inc-ua f ∙ inc-ua g
+  inc-⋆ = GQ.comp'// _ ⋆IsoC
+
+  inc-id : inc-ua (idCatIso {x = x}) ≡ refl
+  inc-id =
+    incId ≡⟨ sym (compPathr-cancel (sym incId) incId) ⟩
+    (incId ∙ incId) ∙ sym incId ≡⟨ congL _∙_ (sym (inc-⋆ idCatIso idCatIso)) ⟩
+    inc-ua (⋆Iso idCatIso idCatIso) ∙ sym incId ≡⟨ congL _∙_ (cong inc-ua (⋆IsoIdL _)) ⟩
+    incId ∙ sym incId ≡⟨ rCancel incId ⟩
+    refl ∎
+    where incId = inc-ua idCatIso
+
+  inc-inv : (f : IsoC x y) → inc-ua (invIso f) ≡ sym (inc-ua f)
+  inc-inv f =
+    inc-ua (invIso f) ≡⟨ sym (compPathr-cancel (sym (inc-ua f)) (inc-ua (invIso f))) ⟩
+    (inc-ua (invIso f) ∙ inc-ua f) ∙ sym (inc-ua f) ≡⟨ congL _∙_ (sym (inc-⋆ (invIso f) f)) ⟩
+    inc-ua (⋆Iso (invIso f) f) ∙ sym (inc-ua f) ≡⟨ congL _∙_ (cong inc-ua (CatIso≡ _ _ (f .snd .sec))) ⟩
+    inc-ua idCatIso ∙ sym (inc-ua f) ≡⟨ congL _∙_ inc-id ⟩
+    refl ∙ sym (inc-ua f) ≡⟨ sym (lUnit (sym (inc-ua f))) ⟩
+    sym (inc-ua f) ∎
+
+  inc-pathToIso : (p : x ≡ y) → inc-ua (pathToIso p) ≡ cong inc p
+  inc-pathToIso = J (λ y p → inc-ua (pathToIso p) ≡ cong inc p) (cong inc-ua pathToIso-refl ∙ inc-id)
+
+  inc-surj : isSurjection inc
+  inc-surj = GQ.isSurjective[] ⋆IsoC
+
+  RezkHomSet : RezkOb → RezkOb → hSet ℓ'
+  RezkHomSet =
+    rec₂ isGroupoidHSet H-inc H-inc-ua H-ua-inc H-ua-inc-ua H-inc-sq H-sq-inc where
+
+    H-inc : ob C → ob C → hSet ℓ'
+    H-inc x y = C .Hom[_,_] x y , C .isSetHom
+
+    H-inc-ua : ∀ {x y z} → IsoC y z → H-inc x y ≡ H-inc x z
+    H-inc-ua f = TypeOfHLevel≡ 2 $ isoToPath λ where
+      .Iso.fun → C._⋆ f .fst
+      .Iso.inv → C._⋆ f .snd .inv
+      .Iso.rightInv _ → C.⋆Assoc _ _ _ ∙∙ congR C._⋆_ (f .snd .sec) ∙∙ C.⋆IdR _
+      .Iso.leftInv  _ → C.⋆Assoc _ _ _ ∙∙ congR C._⋆_ (f .snd .ret) ∙∙ C.⋆IdR _
+
+    H-ua-inc : ∀ {x y z} → IsoC x y → H-inc x z ≡ H-inc y z
+    H-ua-inc f = TypeOfHLevel≡ 2 $ isoToPath λ where
+      .Iso.fun → f .snd .inv C.⋆_
+      .Iso.inv → f .fst C.⋆_
+      .Iso.rightInv _ → sym (C.⋆Assoc _ _ _) ∙∙ congL C._⋆_ (f .snd .sec) ∙∙ C.⋆IdL _
+      .Iso.leftInv  _ → sym (C.⋆Assoc _ _ _) ∙∙ congL C._⋆_ (f .snd .ret) ∙∙ C.⋆IdL _
+
+    typeSquare : ∀ {A B C D : Type ℓ''} {P : A ≡ B} {Q : C ≡ D} {R S}
+               → (∀ x → transport S (transport P x) ≡ transport Q (transport R x))
+               → Square P Q R S
+    typeSquare h = compPath→Square $ isInjectiveTransport $ funExt λ x →
+      transportComposite _ _ x ∙∙ sym (h x) ∙∙ sym (transportComposite _ _ x)
+
+    H-ua-inc-ua : ∀ {x y z w} (g : IsoC z w) (f : IsoC x y)
+                → Square (H-ua-inc g) (H-ua-inc g) (H-inc-ua f) (H-inc-ua f)
+    H-ua-inc-ua g f = ΣSquareSet (λ _ → isProp→isSet isPropIsSet) $ typeSquare λ h →
+      transport (cong fst (H-inc-ua f)) (transport (cong fst (H-ua-inc g)) h)
+        ≡⟨ uaβ _ _ ⟩
+      transport (cong fst (H-ua-inc g)) h C.⋆ f .fst
+        ≡⟨ congL C._⋆_ (uaβ _ _) ⟩
+      (g .snd .inv C.⋆ h) C.⋆ f .fst
+        ≡⟨ C.⋆Assoc (g .snd .inv) h (f .fst) ⟩
+      g .snd .inv C.⋆ (h C.⋆ f .fst)
+        ≡⟨ congR C._⋆_ (sym (uaβ _ _)) ⟩
+      g .snd .inv C.⋆ (transport (cong fst (H-inc-ua f)) h)
+        ≡⟨ sym (uaβ _ _) ⟩
+      transport (cong fst (H-ua-inc g)) (transport (cong fst (H-inc-ua f)) h) ∎
+
+    H-inc-sq : ∀ {x y z w} (f : IsoC y z) (g : IsoC z w)
+             → Square (H-inc-ua {x = x} f) (H-inc-ua (⋆Iso f g)) refl (H-inc-ua g)
+    H-inc-sq f g = ΣSquareSet (λ _ → isProp→isSet isPropIsSet) $ typeSquare λ h →
+      transport (cong fst (H-inc-ua g)) (transport (cong fst (H-inc-ua f)) h)
+        ≡⟨ uaβ _ _ ⟩
+      transport (cong fst (H-inc-ua f)) h C.⋆ g .fst
+        ≡⟨ congL C._⋆_ (uaβ _ _) ⟩
+      (h C.⋆ f .fst) C.⋆ g .fst
+        ≡⟨ C.⋆Assoc _ _ _ ⟩
+      h C.⋆ (f .fst C.⋆ g .fst)
+        ≡⟨ congL C._⋆_ (sym (transportRefl h)) ⟩
+      transport refl h C.⋆ (f .fst C.⋆ g .fst)
+        ≡⟨ sym (uaβ _ _) ⟩
+      transport (cong fst (H-inc-ua (⋆Iso f g))) (transport refl h) ∎
+
+    H-sq-inc : ∀ {x y z w} (f : IsoC x y) (g : IsoC y z)
+             → Square (H-ua-inc {z = w} f) (H-ua-inc (⋆Iso f g)) refl (H-ua-inc g)
+    H-sq-inc f g = ΣSquareSet (λ _ → isProp→isSet isPropIsSet) $ typeSquare λ h →
+      transport (cong fst (H-ua-inc g)) (transport (cong fst (H-ua-inc f)) h)
+        ≡⟨ uaβ _ _ ⟩
+      g .snd .inv C.⋆ transport (cong fst (H-ua-inc f)) h
+        ≡⟨ congR C._⋆_ (uaβ _ _) ⟩
+      g .snd .inv C.⋆ (f .snd .inv C.⋆ h)
+        ≡⟨ sym (C.⋆Assoc _ _ _) ⟩
+      (g .snd .inv C.⋆ f .snd .inv) C.⋆ h
+        ≡⟨ congR C._⋆_ (sym (transportRefl h)) ⟩
+      (g .snd .inv C.⋆ f .snd .inv) C.⋆ transport refl h
+        ≡⟨ sym (uaβ _ _) ⟩
+      transport (cong fst (H-ua-inc (⋆Iso f g))) (transport refl h) ∎
+
+  RezkHom : RezkOb → RezkOb → Type ℓ'
+  RezkHom x y = RezkHomSet x y .fst
+
+  isSetRezkHom : ∀ x y → isSet (RezkHom x y)
+  isSetRezkHom x y = RezkHomSet x y .snd
+
+  private
+    tr : {A : Type ℓ''} → transport refl ≡ idfun A
+    tr = funExt transportRefl
+
+  RezkId : ∀ x → RezkHom x x
+  RezkId = elimSet (λ x → isSetRezkHom x x) (λ x → C.id) λ f → toPathP $
+    subst2 RezkHom (inc-ua f) (inc-ua f) C.id
+      ≡[ i ]⟨ tr i (tr i (tr i (tr i (f .snd .inv C.⋆ tr i (tr i (tr i (tr i C.id)) C.⋆ f .fst))))) ⟩
+    f .snd .inv C.⋆ (C.id C.⋆ f .fst)
+      ≡⟨ congR C._⋆_ (C.⋆IdL _) ⟩
+    f .snd .inv C.⋆ f .fst
+      ≡⟨ f .snd .sec ⟩
+    C.id ∎
+
+  Rezk⋆ : ∀ x y z → RezkHom x y → RezkHom y z → RezkHom x z
+  Rezk⋆ = elimSet₃ (λ x y z → isSet→ (isSet→ (isSetRezkHom x z))) (λ x y z → C._⋆_)
+    lem₁ lem₂ lem₃ where
+
+    lem₁ : ∀ {x y z w} (f : Σ C.Hom[ z , w ] (isIso C))
+         → PathP (λ i → RezkHom (inc x) (inc y) →
+             RezkHom (inc y) (inc-ua f i) → RezkHom (inc x) (inc-ua f i)) C._⋆_ C._⋆_
+    lem₁ e = funExt λ f → toPathP $ funExt λ g →
+      transport refl ((f C.⋆ (transport refl g C.⋆ e .snd .inv)) C.⋆ e .fst)
+        ≡⟨ transportRefl _ ⟩
+      (f C.⋆ transport refl g C.⋆ e .snd .inv) C.⋆ e .fst
+        ≡⟨ C.⋆Assoc _ _ _ ⟩
+      f C.⋆ (transport refl g C.⋆ e .snd .inv) C.⋆ e .fst
+        ≡⟨ congR C._⋆_ (
+          (transport refl g C.⋆ e .snd .inv) C.⋆ e .fst
+            ≡⟨ C.⋆Assoc _ _ _ ⟩
+          transport refl g C.⋆ e. snd .inv C.⋆ e .fst
+            ≡⟨ cong₂ C._⋆_ (transportRefl g) (e .snd .sec) ⟩
+          g C.⋆ C.id
+            ≡⟨ C.⋆IdR _ ⟩
+          g ∎
+        ) ⟩
+      f C.⋆ g ∎
+
+    lem₂ : ∀ {x y z w} (f : Σ C.Hom[ y , z ] (isIso C))
+         → PathP (λ i → RezkHom (inc x) (inc-ua f i) →
+             RezkHom (inc-ua f i) (inc w) → RezkHom (inc x) (inc w)) C._⋆_ C._⋆_
+    lem₂ e = toPathP $ funExt₂ λ f g →
+      tr i0 ((tr i0 f C.⋆ e .snd .inv) C.⋆ e .fst C.⋆ tr i0 g)
+        ≡[ i ]⟨ tr i ((tr i f C.⋆ e .snd .inv) C.⋆ e .fst C.⋆ tr i g) ⟩
+      (f C.⋆ e .snd .inv) C.⋆ e .fst C.⋆ g
+        ≡⟨ C.⋆Assoc _ _ _ ⟩
+      f C.⋆ (e .snd .inv C.⋆ e .fst C.⋆ g)
+        ≡⟨ congR C._⋆_ (sym (C.⋆Assoc _ _ _) ∙ congL C._⋆_ (e .snd .sec) ∙ C.⋆IdL _) ⟩
+      f C.⋆ g ∎
+
+    lem₃ : ∀ {x y z w} (f : Σ C.Hom[ x , y ] (isIso C))
+         → PathP (λ i → RezkHom (inc-ua f i) (inc z) →
+             RezkHom (inc z) (inc w) → RezkHom (inc-ua f i) (inc w)) C._⋆_ C._⋆_
+    lem₃ e = toPathP $ funExt₂ λ f g →
+      tr i0 (e .snd .inv C.⋆ (e .fst C.⋆ tr i0 f) C.⋆ tr i0 g)
+        ≡[ i ]⟨ tr i (e .snd .inv C.⋆ (e .fst C.⋆ tr i f) C.⋆ tr i g) ⟩
+      e .snd .inv C.⋆ (e .fst C.⋆ f) C.⋆ g
+        ≡⟨ sym (C.⋆Assoc _ _ _) ⟩
+      (e .snd .inv C.⋆ e .fst C.⋆ f) C.⋆ g
+        ≡⟨ congL C._⋆_ (sym (C.⋆Assoc _ _ _) ∙ congL C._⋆_ (e .snd .sec) ∙ C.⋆IdL _) ⟩
+      f C.⋆ g ∎
+
+  Rezk⋆IdL : ∀ x y f → Rezk⋆ x x y (RezkId x) f ≡ f
+  Rezk⋆IdL = elimProp₂ (λ x y → isPropΠ (λ _ → isSetRezkHom x y _ _)) λ x y → C.⋆IdL
+
+  Rezk⋆IdR : ∀ x y f → Rezk⋆ x y y f (RezkId y) ≡ f
+  Rezk⋆IdR = elimProp₂ (λ x y → isPropΠ (λ _ → isSetRezkHom x y _ _)) λ x y → C.⋆IdR
+
+  Rezk⋆Assoc : ∀ x y z w f g h
+             → Rezk⋆ x z w (Rezk⋆ x y z f g) h ≡ Rezk⋆ x y w f (Rezk⋆ y z w g h)
+  Rezk⋆Assoc = elimProp₂ (λ x y → isPropΠ5 λ z w _ _ _ → isSetRezkHom x w _ _) λ x y →
+               elimProp₂ (λ z w → isPropΠ3 λ _ _ _ → isSetRezkHom (inc x) w _ _) λ z w → C.⋆Assoc
+
+  Rezk : Category (ℓ-max ℓ ℓ') ℓ'
+  Rezk .ob = RezkOb
+  Rezk .Hom[_,_] = RezkHom
+  Rezk .id {x} = RezkId x
+  Rezk ._⋆_ {x} {y} {z} = Rezk⋆ x y z
+  Rezk .⋆IdL {x} {y} = Rezk⋆IdL x y
+  Rezk .⋆IdR {x} {y} = Rezk⋆IdR x y
+  Rezk .⋆Assoc {x} {y} {z} {w} = Rezk⋆Assoc x y z w
+  Rezk .isSetHom {x} {y} = isSetRezkHom x y
+
+  RezkIso→Iso : ∀ {x y} → CatIso Rezk (inc x) (inc y) → IsoC x y
+  RezkIso→Iso (f , isiso g s r) = (f , isiso g s r)
+
+  Iso→RezkIso : ∀ {x y} → IsoC x y → CatIso Rezk (inc x) (inc y)
+  Iso→RezkIso (f , isiso g s r) = (f , isiso g s r)
+
+  RezkIsoToPath : ∀ x y → CatIso Rezk x y → x ≡ y
+  RezkIsoToPath = elimSet₂ (λ x y → isSet→ (squash x y)) R-inc R-ua₁ R-ua₂ where
+
+    R-inc = λ x y f → inc-ua (RezkIso→Iso f)
+
+    R-ua₁ : {x y z : C.ob} (f : Σ C.Hom[ y , z ] (isIso C))
+          → PathP (λ i → CatIso Rezk (inc x) (inc-ua f i) → inc x ≡ inc-ua f i)
+              (R-inc x y) (R-inc x z)
+    R-ua₁ e = toPathP $ funExt λ f → let f' = RezkIso→Iso f in
+      subst2 _≡_ refl (inc-ua e) (inc-ua _)
+        ≡⟨ cong (subst2 _≡_ refl (inc-ua e) ∘ inc-ua) (
+          CatIso≡ _ _ (congL C._⋆_ (transportRefl _))
+        ) ⟩
+      subst2 _≡_ refl (inc-ua e) (inc-ua (⋆Iso f' (invIso e)))
+        ≡⟨ fromPathP (compPath-filler (inc-ua (⋆Iso f' (invIso e))) (inc-ua e)) ⟩
+      inc-ua (⋆Iso f' (invIso e)) ∙ inc-ua e
+        ≡⟨ sym (inc-⋆ (⋆Iso f' (invIso e)) e) ⟩
+      inc-ua (⋆Iso (⋆Iso f' (invIso e)) e)
+        ≡⟨ cong inc-ua (CatIso≡ _ _ (C.⋆Assoc _ _ _ ∙ congR C._⋆_ (e .snd .sec) ∙ C.⋆IdR _)) ⟩
+      inc-ua f' ∎
+
+    R-ua₂ : {x y z : C.ob} (f : Σ C.Hom[ x , y ] (isIso C))
+          → PathP (λ i → CatIso Rezk (inc-ua f i) (inc z) → inc-ua f i ≡ inc z)
+              (R-inc x z) (R-inc y z)
+    R-ua₂ e = toPathP $ funExt λ f → let f' = RezkIso→Iso f in
+      subst2 _≡_ (inc-ua e) refl (inc-ua _)
+        ≡⟨ cong (subst2 _≡_ (inc-ua e) refl ∘ inc-ua) (CatIso≡ _ _ (congR C._⋆_ (transportRefl _))) ⟩
+      subst2 _≡_ (inc-ua e) refl (inc-ua (⋆Iso e f'))
+        ≡⟨ fromPathP (compPath-filler' (sym (inc-ua e)) (inc-ua (⋆Iso e f'))) ⟩
+      sym (inc-ua e) ∙ inc-ua (⋆Iso e f')
+        ≡⟨ congR _∙_ (inc-⋆ e f') ⟩
+      sym (inc-ua e) ∙ (inc-ua e ∙ inc-ua f')
+        ≡⟨ compPathl-cancel (sym (inc-ua e)) (inc-ua f') ⟩
+      inc-ua f' ∎
+
+  RezkIsoToPathId : ∀ x → RezkIsoToPath x x idCatIso ≡ refl
+  RezkIsoToPathId = elimProp (λ x → squash x x _ _) (λ x → inc-id)
+
+  RezkIsoToPathη : ∀ x y p → RezkIsoToPath x y (pathToIso p) ≡ p
+  RezkIsoToPathη x = J> cong (RezkIsoToPath x x) pathToIso-refl ∙ RezkIsoToPathId x
+
+  RezkIsoToPathβ : ∀ x y f → pathToIso (RezkIsoToPath x y f) ≡ f
+  RezkIsoToPathβ = elimProp₂ (λ x y → isPropΠ λ _ → isSet-CatIso x y _ _) λ x y f →
+    CatIso≡ _ _ $ transportRefl _ ∙ C.⋆IdL _
+
+  isUnivalentRezk : isUnivalent Rezk
+  isUnivalentRezk .univ x y = isoToIsEquiv $
+    iso pathToIso (RezkIsoToPath x y) (RezkIsoToPathβ x y) (RezkIsoToPathη x y)
+
+  →Rezk : Functor C Rezk
+  →Rezk .F-ob = inc
+  →Rezk .F-hom = idfun _
+  →Rezk .F-id = refl
+  →Rezk .F-seq f g = refl
+
+  →RezkFF : isFullyFaithful →Rezk
+  →RezkFF x y = idIsEquiv _
+
+  →RezkSurj : isEssentiallySurj →Rezk
+  →RezkSurj = elimProp (λ x → isPropPropTrunc) λ x → ∣ x , idCatIso ∣₁
+
+  isWkEquiv→Rezk : isWeakEquivalence →Rezk
+  isWkEquiv→Rezk .fullfaith = →RezkFF
+  isWkEquiv→Rezk .esssurj = →RezkSurj
+
+  isRezkCompletion→Rezk : isRezkCompletion →Rezk
+  isRezkCompletion→Rezk = makeIsRezkCompletion isUnivalentRezk isWkEquiv→Rezk
diff --git a/Cubical/Data/Cardinal/Properties.agda b/Cubical/Data/Cardinal/Properties.agda
index 1c7371cf0c..d4041dafed 100644
--- a/Cubical/Data/Cardinal/Properties.agda
+++ b/Cubical/Data/Cardinal/Properties.agda
@@ -25,8 +25,7 @@ open import Cubical.Data.Sum as ⊎
 open import Cubical.Data.Unit
 open import Cubical.HITs.PropositionalTruncation as ∥₁
 open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Preorder.Base
-open import Cubical.Relation.Binary.Order.Properties
+open import Cubical.Relation.Binary.Order.Proset
 
 private
   variable
@@ -171,9 +170,9 @@ module _ where
              λ (A , _) (B , _) (C , _)
                → ∥₁.map2 λ A↪B B↪C → compEmbedding B↪C A↪B
 
-  isPreorder≲ : IsPreorder {ℓ-suc ℓ} _≲_
+  isPreorder≲ : IsProset {ℓ-suc ℓ} _≲_
   isPreorder≲
-    = ispreorder isSetCard isPropValued≲ isRefl≲ isTrans≲
+    = isproset isSetCard isPropValued≲ isRefl≲ isTrans≲
 
 isLeast𝟘 : ∀{ℓ} → isLeast isPreorder≲ (Card {ℓ} , id↪ (Card {ℓ})) (𝟘 {ℓ})
 isLeast𝟘 = ∥₂.elim (λ x → isProp→isSet (isPropValued≲ 𝟘 x))
diff --git a/Cubical/Data/Fin/Inductive/Properties.agda b/Cubical/Data/Fin/Inductive/Properties.agda
index 9b553fd878..7ad1ab2d90 100644
--- a/Cubical/Data/Fin/Inductive/Properties.agda
+++ b/Cubical/Data/Fin/Inductive/Properties.agda
@@ -25,6 +25,12 @@ open import Cubical.Relation.Nullary
 
 open import Cubical.Algebra.AbGroup.Base using (move4)
 
+Fin≡ : {m : ℕ} (a b : Fin m) → fst a ≡ fst b → a ≡ b
+Fin≡ {m} (a , Ha) (b , Hb) H i =
+  (H i , hcomp (λ j → λ { (i = i0) → Ha
+                        ; (i = i1) → isProp<ᵗ {b}{m} (transp (λ j → H j <ᵗ m) i0 Ha) Hb j })
+               (transp (λ j → H (i ∧ j) <ᵗ m) (~ i) Ha))
+
 fsuc-injectSuc : {m : ℕ} (n : Fin m)
   → injectSuc {n = suc m} (fsuc {n = m} n) ≡ fsuc (injectSuc n)
 fsuc-injectSuc {m = suc m} (x , p) = refl
diff --git a/Cubical/Data/Fin/LehmerCode.agda b/Cubical/Data/Fin/LehmerCode.agda
index 1f2da9db8b..eb0c99a4d3 100644
--- a/Cubical/Data/Fin/LehmerCode.agda
+++ b/Cubical/Data/Fin/LehmerCode.agda
@@ -191,11 +191,7 @@ encode = equivFun lehmerEquiv
 decode : LehmerCode n → Fin n ≃ Fin n
 decode = invEq lehmerEquiv
 
-factorial : ℕ → ℕ
-factorial zero = 1
-factorial (suc n) = suc n · factorial n
-
-lehmerFinEquiv : LehmerCode n ≃ Fin (factorial n)
+lehmerFinEquiv : LehmerCode n ≃ Fin (n !)
 lehmerFinEquiv {zero} = isContr→Equiv isContrLehmerZero isContrFin1
 lehmerFinEquiv {suc n} = _ ≃⟨ invEquiv lehmerSucEquiv ⟩
                          _ ≃⟨ ≃-× (idEquiv _) lehmerFinEquiv ⟩
diff --git a/Cubical/Data/FinSet/Cardinality.agda b/Cubical/Data/FinSet/Cardinality.agda
index 0c67330496..4aa0849f89 100644
--- a/Cubical/Data/FinSet/Cardinality.agda
+++ b/Cubical/Data/FinSet/Cardinality.agda
@@ -379,7 +379,7 @@ module _
 module _
   (X : FinSet ℓ ) where
 
-  cardAut : card (_ , isFinSetAut X) ≡ LehmerCode.factorial (card X)
+  cardAut : card (_ , isFinSetAut X) ≡ (card X !)
   cardAut = refl
 
 module _
diff --git a/Cubical/Data/FinSet/Constructors.agda b/Cubical/Data/FinSet/Constructors.agda
index e4b95450dc..6ae21544ee 100644
--- a/Cubical/Data/FinSet/Constructors.agda
+++ b/Cubical/Data/FinSet/Constructors.agda
@@ -168,7 +168,7 @@ module _
   (X : FinSet ℓ) where
 
   isFinSetAut : isFinSet (X .fst ≃ X .fst)
-  isFinSetAut = LehmerCode.factorial (card X) ,
+  isFinSetAut = card X ! ,
     Prop.map (λ p → isFinOrd≃ (X .fst) (card X , p) .snd) (X .snd .snd)
 
   isFinSetTypeAut : isFinSet (X .fst ≡ X .fst)
diff --git a/Cubical/Data/Int/Base.agda b/Cubical/Data/Int/Base.agda
index 0576b0f241..22fdd45573 100644
--- a/Cubical/Data/Int/Base.agda
+++ b/Cubical/Data/Int/Base.agda
@@ -6,7 +6,7 @@ module Cubical.Data.Int.Base where
 open import Cubical.Foundations.Prelude
 
 open import Cubical.Data.Bool
-open import Cubical.Data.Nat hiding (_+_ ; _·_) renaming (isEven to isEvenℕ ; isOdd to isOddℕ)
+open import Cubical.Data.Nat as ℕ hiding (_+_ ; _·_) renaming (isEven to isEvenℕ ; isOdd to isOddℕ)
 open import Cubical.Data.Fin.Inductive.Base
 
 infix  8 -_
@@ -60,6 +60,13 @@ _+_ : ℤ → ℤ → ℤ
 m + pos n = m +pos n
 m + negsuc n = m +negsuc n
 
+_+f_ : ℤ → ℤ → ℤ
+pos n +f pos n₁ = pos (n ℕ.+ n₁)
+negsuc n +f negsuc n₁ = negsuc (suc (n ℕ.+ n₁))
+n +f m = n + m
+-- pos n +f negsuc n₁ = {!!}
+-- negsuc n +f pos n₁ = {!!}
+
 -_ : ℤ → ℤ
 - pos zero = pos zero
 - pos (suc n) = negsuc n
@@ -74,6 +81,16 @@ pos (suc n) · m = m + pos n · m
 negsuc zero · m = - m
 negsuc (suc n) · m = - m + negsuc n · m
 
+_·f_ : ℤ → ℤ → ℤ
+pos n ·f pos n₁ = pos (n ℕ.· n₁)
+pos zero ·f negsuc n₁ = pos zero
+pos (suc n) ·f negsuc n₁ = negsuc (suc n ℕ.· suc n₁)
+negsuc n ·f pos zero = pos zero
+negsuc n ·f pos (suc n₁) = negsuc (suc n ℕ.· suc n₁)
+negsuc n ·f negsuc n₁ = pos (suc n ℕ.· suc n₁)
+
+
+
 -- Natural number and negative integer literals for ℤ
 
 open import Cubical.Data.Nat.Literals public
diff --git a/Cubical/Data/Int/Order.agda b/Cubical/Data/Int/Order.agda
index e728308348..0422ce48bb 100644
--- a/Cubical/Data/Int/Order.agda
+++ b/Cubical/Data/Int/Order.agda
@@ -4,7 +4,7 @@ module Cubical.Data.Int.Order where
 open import Cubical.Foundations.Prelude
 open import Cubical.Foundations.Isomorphism
 open import Cubical.Foundations.Function
-
+open import Cubical.Foundations.Equiv
 open import Cubical.Data.Empty as ⊥ using (⊥)
 open import Cubical.Data.Int.Base as ℤ
 open import Cubical.Data.Int.Properties as ℤ
@@ -536,6 +536,20 @@ min-0< (pos (suc (suc n₁))) (pos (suc (suc n))) x x₁ =
 ℕ≤→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
 
+ℕ≥→negsuc-≤-negsuc : ∀ m n → m ℕ.≤ n → negsuc n ≤ negsuc m
+ℕ≥→negsuc-≤-negsuc m n = negsuc-≤-negsuc ∘ ℕ≤→pos-≤-pos m n
+
+pos-≤-pos→ℕ≤ : ∀ m n → pos m ≤ pos n → m ℕ.≤ n
+pos-≤-pos→ℕ≤ m n (k , p) = k , injPos ((pos+ k m ∙ ℤ.+Comm (pos k) (pos m)) ∙ p)
+
+pos-≤-pos≃ℕ≤ : ∀ m n → (pos m ≤ pos n) ≃ (m ℕ.≤ n)
+pos-≤-pos≃ℕ≤ m n = propBiimpl→Equiv isProp≤ ℕ.isProp≤
+                (pos-≤-pos→ℕ≤ _ _) (ℕ≤→pos-≤-pos _ _)
+
+pos-<-pos≃ℕ< : ∀ m n → (pos m < pos n) ≃ (m ℕ.< n)
+pos-<-pos≃ℕ< m n = propBiimpl→Equiv (isProp< {pos m} {pos n}) ℕ.isProp≤
+                (pos-≤-pos→ℕ≤ _ _) (ℕ≤→pos-≤-pos (suc m) n)
+
 
 0≤x² : ∀ n → 0 ≤ n ℤ.· n
 0≤x² (pos n) = subst (0 ≤_) (pos·pos n n) zero-≤pos
diff --git a/Cubical/Data/Int/Properties.agda b/Cubical/Data/Int/Properties.agda
index 088182ed42..81582a24ab 100644
--- a/Cubical/Data/Int/Properties.agda
+++ b/Cubical/Data/Int/Properties.agda
@@ -1,6 +1,7 @@
-{-# OPTIONS --safe #-}
+{-# OPTIONS --safe --v=tc.conv:20 #-}
 module Cubical.Data.Int.Properties where
 
+
 open import Cubical.Foundations.Prelude
 open import Cubical.Foundations.Function
 open import Cubical.Foundations.Isomorphism
@@ -1526,3 +1527,21 @@ sign : ℤ → ℤ
 sign (pos zero) = 0
 sign (pos (suc n)) = 1
 sign (negsuc n) = -1
+
+sign·abs : ∀ m → sign m · pos (abs m) ≡ m
+sign·abs (pos zero) = refl
+sign·abs (pos (suc n)) = refl
+sign·abs (negsuc n) = refl
+
+-- abs[sign[m]·pos[n]]≡n : ∀ m n → abs (sign m · pos n) ≡ n
+-- abs[sign[m]·pos[n]]≡n m n = {!!}
+
+
+-- ·'≡· : ∀ n m → n · m ≡ n ·' m
+-- ·'≡· (pos n) (pos n₁) = sym (pos·pos n n₁)
+-- ·'≡· (pos zero) (negsuc n₁) = refl
+-- ·'≡· (pos (suc n)) (negsuc n₁) = {!!}
+-- ·'≡· (negsuc n) (pos zero) = ·AnnihilR (negsuc n)
+-- ·'≡· (negsuc n) (pos (suc n₁)) = negsuc·pos n (suc n₁) ∙
+--   {!!}
+-- ·'≡· (negsuc n) (negsuc n₁) = negsuc·negsuc n n₁ ∙ sym (pos·pos (suc n) (suc n₁))
diff --git a/Cubical/Data/Nat/Order.agda b/Cubical/Data/Nat/Order.agda
index 0b6808ac7c..ec3f6c1f9e 100644
--- a/Cubical/Data/Nat/Order.agda
+++ b/Cubical/Data/Nat/Order.agda
@@ -58,6 +58,9 @@ isProp≤ {m} {n} (k , p) (l , q)
 zero-≤ : 0 ≤ n
 zero-≤ {n} = n , +-zero n
 
+zero-<-suc : 0 < suc n
+zero-<-suc {n} = n , +-comm n 1
+
 suc-≤-suc : m ≤ n → suc m ≤ suc n
 suc-≤-suc (k , p) = k , (+-suc k _) ∙ (cong suc p)
 
@@ -147,6 +150,10 @@ suc-< p = pred-≤-pred (≤-suc p)
   subst2 _≤_ (·-comm m k) (·-comm n k)
     (≤-·k p)
 
+≤monotone· : ∀ {m n k l} → m ≤ n → k ≤ l → m · k ≤ n · l
+≤monotone· {m} {n} {k} {l} m≤n k≤l =
+  ≤-trans (≤-k· {k = m} k≤l) (≤-·k m≤n)
+
 <-k+-cancel : k + m < k + n → m < n
 <-k+-cancel {k} {m} {n} = ≤-k+-cancel ∘ subst (_≤ k + n) (sym (+-suc k m))
 
@@ -229,6 +236,9 @@ predℕ-≤-predℕ {suc m} {suc n} ineq = pred-≤-pred ineq
            (d + suc m) · suc k               ≡⟨ cong (_· suc k) r ⟩
            n · suc k                         ∎
 
+<-·sk' : 0 < k → m < n → m · k < n · k
+<-·sk' {zero} {m} {n} 0<0 = ⊥.rec (¬-<-zero 0<0)
+<-·sk' {suc k} {m} {n}  _ = <-·sk {m} {n} {k}
 
 <-·sk-cancel : ∀ {m n k} → m · suc k < n · suc k → m < n
 <-·sk-cancel {n = zero} x = ⊥.rec (¬-<-zero x)
@@ -589,3 +599,104 @@ module Minimal where
   isPropLeast : {P : ℕ → Type ℓ} → (∀ m → isProp (P m)) → ∀ m → isProp (Least P m)
   isPropLeast pP m
     = isPropΣ (pP m) (λ _ → isPropΠ3 λ _ _ _ → isProp⊥)
+
+<monotone· : ∀ {m n k l} → m < n → k < l → m · k < n · l
+<monotone· {n = zero} {l = l} m<n k<l = ⊥.rec (¬-<-zero m<n)
+<monotone· {n = suc n} {l = zero} m<n k<l = ⊥.rec (¬-<-zero k<l)
+<monotone· {zero} {n = suc n} {l = suc l} m<n k<l = zero-<-suc
+<monotone· {suc m} {n = suc n} {zero} {l = suc l} m<n k<l =
+  subst (_< suc n · suc l) (·-comm 0 m) zero-<-suc
+<monotone· {suc m} {n = suc n} {suc k} {l = suc l} m<n k<l =
+  suc-≤-suc (<-+-< (predℕ-≤-predℕ k<l) (<monotone· (predℕ-≤-predℕ m<n) k<l))
+
+monotone-^ : ∀ x y n → x < y → x ^ (suc n) < y ^ (suc n)
+monotone-^ x y zero x<y = subst2 _<_ (sym (·-identityʳ _)) (sym (·-identityʳ _)) x<y
+monotone-^ x y (suc n) x<y =
+  <monotone· x<y (monotone-^ x y n x<y)
+
+^-monotone' : ∀ x n m → x ^ (suc n) ≤ x ^ (suc (m + n))
+^-monotone' x n zero = ≤-refl
+^-monotone' zero n (suc m) = ≤-refl
+^-monotone' (suc x) n (suc m) =
+ ≤-trans (^-monotone' (suc x) n m)
+   (subst (_≤ ((suc x) · (suc x ^ suc (m + n)))) (·-identityˡ _)
+    (≤-·k {1} {suc x} {k = (suc x ^ suc (m + n))} (suc-≤-suc zero-≤)))
+
+
+^-monotone : ∀ x n m → n ≤ m → x ^ (suc n) ≤ x ^ (suc m)
+^-monotone x n m (k , p) =
+  subst (λ z → x ^ (suc n) ≤ x ^ suc z) p (^-monotone' x n k)
+
+sn<ssm^sn : ∀ n m → suc n < (suc (suc m)) ^ suc n
+sn<ssm^sn zero m = suc-≤-suc (suc-≤-suc zero-≤)
+sn<ssm^sn (suc n) m =
+ <-trans (suc-≤-suc (sn<ssm^sn n m))
+   (subst (suc (suc (suc m) ^ suc n) <_)
+     (  (λ i → +-comm (·-comm (suc m) (suc (suc m) ^ suc n) i) (suc (suc m) ^ suc n) i)
+         ∙ sym (·-suc (suc (suc m) ^ suc n) (suc m))
+       ∙ ·-comm (suc (suc m) ^ (suc n)) (suc (suc m)))
+       (<-+k {1} {(suc m) · (suc (suc m) ^ suc n)} {suc (suc m) ^ suc n}
+         (<≤-trans (suc-≤-suc (suc-≤-suc (zero-≤ {m})))
+           (≤-trans ((subst2 (_≤_)
+                 (cong (suc ∘ suc) (·-identityʳ _) )
+                  (sym (·-identityˡ _))
+                  (^-monotone (suc (suc m)) 0 n zero-≤)))
+             (≤-·k {1} {suc m} {(suc (suc m) ^ suc n)} (suc-≤-suc zero-≤))))))
+
+k+predℕₖ : k ≤ n → k + iter k predℕ n ≡ n
+k+predℕₖ {zero} x = refl
+k+predℕₖ {suc k} {zero} x = ⊥.rec (¬-<-zero x)
+k+predℕₖ {suc k} {suc n} x =
+ cong suc (cong (k +_) (w n k (predℕ-≤-predℕ x)) ∙ k+predℕₖ {k} {n} (predℕ-≤-predℕ x))
+
+ where
+ w : ∀ n k → k ≤ n → predℕ (iter k predℕ (suc n)) ≡ iter k predℕ n
+ w n zero x = refl
+ w zero (suc k) x = ⊥.rec (¬-<-zero x)
+ w (suc n) (suc k) x = cong predℕ (w (suc n) k (≤-trans ≤-predℕ x))
+
+infix 4 _≤ᵖ_ _<ᵖ_ _≤ᵉ_ _<ᵉ_ _≲_ _≺_ _≲ᵉ_ _≺ᵉ_
+
+_≤ᵖ_ : (ℕ → ℕ) → (ℕ → ℕ) → Type
+f ≤ᵖ g = ∀ n → f n ≤ g n
+
+_≤ᵉ_ : (ℕ → ℕ) → (ℕ → ℕ) → Type₀
+f ≤ᵉ g = Σ[ N ∈ ℕ ] (∀ m → N ≤ m → f m ≤ g m)
+
+_<ᵖ_ : (ℕ → ℕ) → (ℕ → ℕ) → Type₀
+f <ᵖ g = ∀ n → f n < g n
+
+_<ᵉ_ : (ℕ → ℕ) → (ℕ → ℕ) → Type₀
+f <ᵉ g = Σ[ N ∈ ℕ ] (∀ m → N ≤ m → f m < g m)
+
+_≲_ : (ℕ → ℕ) → (ℕ → ℕ) → Type₀
+a ≲ b = ∀ n → a (suc n) + b n ≤ b (suc n) + a n
+
+_≺_ : (ℕ → ℕ) → (ℕ → ℕ) → Type₀
+a ≺ b = ∀ n → a (suc n) + b n < b (suc  n) + a n
+
+_≲ᵉ_ : (ℕ → ℕ) → (ℕ → ℕ) → Type₀
+a ≲ᵉ b = Σ[ N ∈ ℕ ] (∀ n → N ≤ n → a (suc n) + b n ≤ b (suc n) + a n)
+
+_≺ᵉ_ : (ℕ → ℕ) → (ℕ → ℕ) → Type₀
+a ≺ᵉ b = Σ[ N ∈ ℕ ] (∀ n → N ≤ n → a (suc n) + b n < b (suc n) + a n)
+
+-- eventualGrowth⇒eventualLarger :
+--   ∀ {a b : ℕ → ℕ} →
+--   a ≺ᵉ b →
+--   Σ[ N ∈ ℕ ] (∀ n → N ≤ n → a n < b n)
+-- eventualGrowth⇒eventualLarger = {!!}
+
+-- ℕε<kⁿ : ∀ p q r s → 0 < q →  s < r → Σ[ n ∈ ℕ ]
+--            p · s ^ n < q · r ^ n
+-- ℕε<kⁿ p q zero s 0<q s<r = ⊥.rec (¬-<-zero s<r)
+-- ℕε<kⁿ p zero (suc r) zero 0<q s<r = ⊥.rec (¬-<-zero 0<q)
+-- ℕε<kⁿ p (suc q) (suc r) zero 0<q s<r = {!!}
+-- ℕε<kⁿ p q (suc r) (suc s) 0<q s<r = {!!}
+
+--  where
+--   ΔLHS : ℕ → ℕ
+--   ΔLHS n = (p · s) · ((suc s) ^ n)
+
+--   ΔRHS : ℕ → ℕ
+--   ΔRHS n = (q · r) · ((suc r) ^ n)
diff --git a/Cubical/Data/Nat/Properties.agda b/Cubical/Data/Nat/Properties.agda
index b78f814b40..d8509f682b 100644
--- a/Cubical/Data/Nat/Properties.agda
+++ b/Cubical/Data/Nat/Properties.agda
@@ -270,12 +270,14 @@ n∸n (suc n) = n∸n n
 ∸-distribʳ zero    (suc n) k = sym (zero∸ (k + n · k))
 ∸-distribʳ (suc m) (suc n) k = ∸-distribʳ m n k ∙ sym (∸-cancelˡ k (m · k) (n · k))
 
-
+infix 6 _!
+infix 7 _choose_
 
 -- factorial:
-_! : ℕ → ℕ
+_! factorial : ℕ → ℕ
 zero ! = 1
-suc n ! = (suc n) · (n !)
+suc n ! = suc n · (n !)
+factorial = _!
 
 --binomial coefficient:
 _choose_ : ℕ → ℕ → ℕ
diff --git a/Cubical/Data/Ordinal/Properties.agda b/Cubical/Data/Ordinal/Properties.agda
index 0cfbd9d98c..f4ea61dd03 100644
--- a/Cubical/Data/Ordinal/Properties.agda
+++ b/Cubical/Data/Ordinal/Properties.agda
@@ -60,7 +60,7 @@ propOrd {ℓ} P prop = P , (wosetstr _<_ (iswoset set prp well weak trans))
 𝟘 {ℓ} = propOrd (⊥* {ℓ}) (isProp⊥*)
 𝟙 {ℓ} = propOrd (Unit* {ℓ}) (isPropUnit*)
 
-isLeast𝟘 : ∀{ℓ} → isLeast (isPoset→isPreorder isPoset≼) ((Ord {ℓ}) , (id↪ (Ord {ℓ}))) (𝟘 {ℓ})
+isLeast𝟘 : ∀{ℓ} → isLeast (isPoset→isProset isPoset≼) ((Ord {ℓ}) , (id↪ (Ord {ℓ}))) (𝟘 {ℓ})
 isLeast𝟘 _ = ⊥.elim* , (⊥.elim* , ⊥.elim*)
 
 -- The successor of 𝟘 is 𝟙
@@ -144,8 +144,8 @@ suc≺ α = (inr tt*) , (eq , makeIsWosetEquiv eq eqsucα eqαsuc)
     eq = isoToEquiv rUnit*×Iso
 
     eqα𝟙 : _
-    eqα𝟙 (x , _) (y , _) (inl tt≺tt) = ⊥.rec (IsStrictPoset.is-irrefl
-                                                (isWoset→isStrictPoset
+    eqα𝟙 (x , _) (y , _) (inl tt≺tt) = ⊥.rec (IsQuoset.is-irrefl
+                                                (isWoset→isQuoset
                                                    (WosetStr.isWoset (str 𝟙)))
                                                tt* tt≺tt)
     eqα𝟙 (x , _) (y , _) (inr (_ , x≺y)) = x≺y
@@ -161,8 +161,8 @@ suc≺ α = (inr tt*) , (eq , makeIsWosetEquiv eq eqsucα eqαsuc)
 
     eq𝟙α : _
     eq𝟙α (_ , x) (_ , y) (inr (_ , tt≺tt)) = ⊥.rec
-                                               (IsStrictPoset.is-irrefl
-                                                (isWoset→isStrictPoset
+                                               (IsQuoset.is-irrefl
+                                                (isWoset→isQuoset
                                                   (WosetStr.isWoset (str 𝟙)))
                                                 tt* tt≺tt)
     eq𝟙α (_ , x) (_ , y) (inl x≺y) = x≺y
diff --git a/Cubical/Data/Rationals/Order.agda b/Cubical/Data/Rationals/Order.agda
index 78828b1a2a..a92bb89da0 100644
--- a/Cubical/Data/Rationals/Order.agda
+++ b/Cubical/Data/Rationals/Order.agda
@@ -30,6 +30,8 @@ open import Cubical.Relation.Binary.Base
 
 infix 4 _≤_ _<_ _≥_ _>_
 
+
+
 private
   ·CommR : (a b c : ℤ) → a ℤ.· b ℤ.· c ≡ a ℤ.· c ℤ.· b
   ·CommR a b c = sym (ℤ.·Assoc a b c) ∙ cong (a ℤ.·_) (ℤ.·Comm b c) ∙ ℤ.·Assoc a c b
@@ -166,6 +168,19 @@ data Trichotomy (m n : ℚ) : Type₀ where
   eq : m ≡ n → Trichotomy m n
   gt : m > n → Trichotomy m n
 
+record TrichotomyRec {ℓ : Level} (n : ℚ) (P : ℚ → Type ℓ) : Type ℓ where
+  no-eta-equality
+  field
+    lt-case : ∀ m → (p : m < n) → P m
+    eq-case : P n
+    gt-case : ∀ m → (p : m > n) → P m
+
+  go : ∀ m → (t : Trichotomy m n) → P m
+  go m (lt p) = lt-case m p
+  go m (eq p) = subst P (sym p) eq-case
+  go m (gt p) = gt-case m p
+
+
 module _ where
   open BinaryRelation
 
@@ -218,8 +233,8 @@ module _ where
   isAsym< : isAsym _<_
   isAsym< = isIrrefl×isTrans→isAsym _<_ (isIrrefl< , isTrans<)
 
-  isStronglyConnected≤ : isStronglyConnected _≤_
-  isStronglyConnected≤ =
+  isTotal≤ : isTotal _≤_
+  isTotal≤ =
     elimProp2 {P = λ a b → (a ≤ b) ⊔′ (b ≤ a)}
               (λ _ _ → isPropPropTrunc)
                λ a b → ∣ lem a b ∣₁
@@ -232,12 +247,34 @@ module _ where
 
   isConnected< : isConnected _<_
   isConnected< =
-    elimProp2 {P = λ a b → ¬ a ≡ b → (a < b) ⊔′ (b < a)}
-              (λ _ _ → isProp→ isPropPropTrunc)
-               λ a b ¬a≡b → ∣ lem a b ¬a≡b ∣₁
+    elimProp2 {P = λ a b → (¬ a < b) × (¬ b < a) → a ≡ b}
+              (λ a b → isProp→ (isSetℚ a b))
+               lem
+    where
+      lem : (a b : ℤ.ℤ × ℕ₊₁) → (¬ [ a ] < [ b ]) × (¬ [ b ] < [ a ]) → [ a ] ≡ [ b ]
+      lem (a , b) (c , d) (¬ad<cb , ¬cb<ad) with (a ℤ.· ℕ₊₁→ℤ d) ℤ.≟ (c ℤ.· ℕ₊₁→ℤ b)
+      ... | ℤ.lt ad<cb = ⊥.rec (¬ad<cb ad<cb)
+      ... | ℤ.eq ad≡cb = eq/ (a , b) (c , d) ad≡cb
+      ... | ℤ.gt cb<ad = ⊥.rec (¬cb<ad cb<ad)
+
+  isProp# : isPropValued _#_
+  isProp# x y = isProp⊎ (isProp< x y) (isProp< y x) (isAsym< x y)
+
+  isIrrefl# : isIrrefl _#_
+  isIrrefl# x (inl x<x) = isIrrefl< x x<x
+  isIrrefl# x (inr x<x) = isIrrefl< x x<x
+
+  isSym# : isSym _#_
+  isSym# _ _ (inl x<y) = inr x<y
+  isSym# _ _ (inr y<x) = inl y<x
+
+  inequalityImplies# : inequalityImplies _#_
+  inequalityImplies#
+    = elimProp2 {P = λ a b → ¬ a ≡ b → a # b}
+                (λ a b → isProp→ (isProp# a b))
+                 lem
     where
-      -- Agda can't infer the relation involved, so the signature looks a bit weird here
-      lem : (a b : ℤ.ℤ × ℕ₊₁) → ¬ [_] {R = _∼_} a ≡ [ b ] → ([ a ] < [ b ]) ⊎ ([ b ] < [ a ])
+      lem : (a b : ℤ.ℤ × ℕ₊₁) → ¬ [_] {R = _∼_} a ≡ [ b ] → [ a ] # [ b ]
       lem (a , b) (c , d) ¬a≡b with (a ℤ.· ℕ₊₁→ℤ d) ℤ.≟ (c ℤ.· ℕ₊₁→ℤ b)
       ... | ℤ.lt ad<cb = inl ad<cb
       ... | ℤ.eq ad≡cb = ⊥.rec (¬a≡b (eq/ (a , b) (c , d) ad≡cb))
@@ -252,20 +289,9 @@ module _ where
       lem : (a b c : ℤ.ℤ × ℕ₊₁) → [ a ] < [ b ] → ([ a ] < [ c ]) ⊔′ ([ c ] < [ b ])
       lem a b c a<b with discreteℚ [ a ] [ c ]
       ... | yes a≡c = ∣ inr (subst (_< [ b ]) a≡c a<b) ∣₁
-      ... | no a≢c = ∥₁.map (⊎.map (λ a<c → a<c)
-                                    (λ c<a → isTrans< [ c ] [ a ] [ b ] c<a a<b))
-                             (isConnected< [ a ] [ c ] a≢c)
-
-  isProp# : isPropValued _#_
-  isProp# x y = isProp⊎ (isProp< x y) (isProp< y x) (isAsym< x y)
-
-  isIrrefl# : isIrrefl _#_
-  isIrrefl# x (inl x<x) = isIrrefl< x x<x
-  isIrrefl# x (inr x<x) = isIrrefl< x x<x
-
-  isSym# : isSym _#_
-  isSym# _ _ (inl x<y) = inr x<y
-  isSym# _ _ (inr y<x) = inl y<x
+      ... | no a≢c = ∣ ⊎.map (λ a<c → a<c)
+                             (λ c<a → isTrans< [ c ] [ a ] [ b ] c<a a<b)
+                             (inequalityImplies# [ a ] [ c ] a≢c) ∣₁
 
   isCotrans# : isCotrans _#_
   isCotrans#
@@ -276,10 +302,7 @@ module _ where
         lem : (a b c : ℤ.ℤ × ℕ₊₁) → [ a ] # [ b ] → ([ a ] # [ c ]) ⊔′ ([ b ] # [ c ])
         lem a b c a#b with discreteℚ [ b ] [ c ]
         ... | yes b≡c = ∣ inl (subst ([ a ] #_) b≡c a#b) ∣₁
-        ... | no  b≢c = ∥₁.map inr (isConnected< [ b ] [ c ] b≢c)
-
-  inequalityImplies# : inequalityImplies _#_
-  inequalityImplies# a b = ∥₁.rec (isProp# a b) (λ a#b → a#b) ∘ (isConnected< a b)
+        ... | no  b≢c = ∣ inr (inequalityImplies# [ b ] [ c ] b≢c) ∣₁
 
 ≤-+o : ∀ m n o → m ≤ n → m ℚ.+ o ≤ n ℚ.+ o
 ≤-+o =
@@ -619,6 +642,7 @@ min≤' m n = subst (_≤ n) (ℚ.minComm n m) (min≤ n m)
 <Dec = elimProp2 (λ x y → isPropDec (isProp< x y))
        λ { (a , b) (c , d) → ℤ.<Dec (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) }
 
+
 _≟_ : (m n : ℚ) → Trichotomy m n
 m ≟ n with discreteℚ m n
 ... | yes m≡n = eq m≡n
@@ -626,6 +650,22 @@ m ≟ n with discreteℚ m n
 ...             | inl m<n = lt m<n
 ...             | inr n<m = gt n<m
 
+byTrichotomy : ∀ x₀ → {A : ℚ → Type} → TrichotomyRec x₀ A → ∀ x → A x
+byTrichotomy x₀ r x = TrichotomyRec.go r x (_ ≟ _)
+
+#Dec : ∀ m n → Dec (m # n)
+#Dec m n with m ≟ n
+... | lt x = yes (inl x)
+... | gt x = yes (inr x)
+... | eq x = no (isIrrefl# n ∘ subst (_# n) x)
+
+≡⊎# : ∀ m n → (m ≡ n) ⊎ (m # n)
+≡⊎# m n with m ≟ n
+... | lt x = inr (inl x)
+... | gt x = inr (inr x)
+... | eq x = inl x
+
+
 ≤MonotoneMin : ∀ m n o s → m ≤ n → o ≤ s → ℚ.min m o ≤ ℚ.min n s
 ≤MonotoneMin m n o s m≤n o≤s
   = subst (_≤ ℚ.min n s)
@@ -662,7 +702,7 @@ m ≟ n with discreteℚ m n
 ... | yes m≡n = ≡Weaken≤ n m (sym m≡n)
 ... | no  m≢n = ∥₁.elim (λ _ → isProp≤ n m)
                         (⊎.rec (⊥.rec ∘ m≮n) (<Weaken≤ n m))
-                        (isConnected< m n m≢n)
+                         ∣ inequalityImplies# m n m≢n ∣₁
 
 0<+ : ∀ m n → 0 < m ℚ.+ n → (0 < m) ⊎ (0 < n)
 0<+ m n 0<m+n with <Dec 0 m | <Dec 0 n
@@ -700,6 +740,17 @@ minus-≤ m n p =
 <→<minus : ∀ m n → m < n → 0 < n - m
 <→<minus m n x = subst (_< n - m) (+InvR m) (<-+o m n (- m) x)
 
+≤→<minus : ∀ m n → m ≤ n → 0 ≤ n - m
+≤→<minus m n x = subst (_≤ n - m) (+InvR m) (≤-+o m n (- m) x)
+
+<minus→< : ∀ m n → 0 < n - m → m < n
+<minus→< m n x = subst2 _<_ (+IdL m)
+  (sym (+Assoc n (- m) m) ∙∙ cong (n ℚ.+_) (+InvL m) ∙∙ +IdR n) (<-+o 0 (n - m) m x)
+
+≤minus→≤ : ∀ m n → 0 ≤ n - m → m ≤ n
+≤minus→≤ m n x = subst2 _≤_ (+IdL m)
+  (sym (+Assoc n (- m) m) ∙∙ cong (n ℚ.+_) (+InvL m) ∙∙ +IdR n) (≤-+o 0 (n - m) m x)
+
 
 minus-<' : ∀ n m → - n < - m → m < n
 minus-<' n m p =
@@ -901,6 +952,7 @@ 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 < ε
@@ -929,8 +981,20 @@ clamp d u x = ℚ.min (ℚ.max d x) u
 ... | eq x = inl x
 ... | gt x = ⊥.rec (≤→≯ q r y x)
 
+≤≃≡⊎< : ∀ q r → (q ≤ r) ≃ ((q ≡ r) ⊎ (q < r))
+≤≃≡⊎< q r = propBiimpl→Equiv
+  (isProp≤ q r)
+  (⊎.isProp⊎ (isSetℚ _ _) ((isProp< q r)) λ u v → ≤→≯ r q (≡Weaken≤ _ _ (sym u)) v)
+    (≤→≡⊎< q r) (⊎.rec (≡Weaken≤ _ _) (<Weaken≤ q r))
+
 ≤ℤ→≤ℚ : ∀ 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))
+
+[k/n]<[k'/n] : ∀ k k' n → k ℤ.< k' → ([ ( k , n ) ]) < ([ (k' , n) ])
+[k/n]<[k'/n] k k' n k<k' = ℤ.<-·o k<k'
+
+[k/n]≤[k'/n] : ∀ k k' n → k ℤ.≤ k' → ([ ( k , n ) ]) ≤ ([ (k' , n) ])
+[k/n]≤[k'/n] k k' n k<k' = ℤ.≤-·o k<k'
diff --git a/Cubical/Data/Rationals/Order/Properties.agda b/Cubical/Data/Rationals/Order/Properties.agda
index a2a610e84d..0b6a42dd42 100644
--- a/Cubical/Data/Rationals/Order/Properties.agda
+++ b/Cubical/Data/Rationals/Order/Properties.agda
@@ -3,12 +3,15 @@ module Cubical.Data.Rationals.Order.Properties where
 
 open import Cubical.Foundations.Prelude
 open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Equiv.Properties
 open import Cubical.Foundations.Function
 open import Cubical.Foundations.HLevels
 open import Cubical.Foundations.Univalence
 open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.Path
 
 open import Cubical.Functions.FunExtEquiv
+open import Cubical.Functions.Involution
 
 open import Cubical.Functions.Logic using (_⊔′_; ⇔toPath)
 
@@ -39,6 +42,8 @@ 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
 
@@ -48,8 +53,26 @@ decℚ<? {_} {_} {p} = 𝟚.toWitness p
 decℚ≤? : ∀ {x y} → {𝟚.True (≤Dec x y)} →  (x ≤ y)
 decℚ≤? {_} {_} {p} = 𝟚.toWitness p
 
+0<sucN : ∀ n → 0 < fromNat (suc n)
+0<sucN n = <ℤ→<ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _ (ℕ.suc-≤-suc ℕ.zero-≤))
+
+0<pos : ∀ n m → 0 < [ pos (suc n) / m ]
+0<pos n m = 0<→< [ pos (suc n) / m ] tt
+
+0≤pos : ∀ n m → 0 ≤ [ pos n / m ]
+0≤pos n m = subst (0 ℤ.≤_)
+   (sym (ℤ.·IdR _))
+  (ℤ.zero-≤pos {n})
 
 
+-fromNat : ∀ n → fromNeg n ≡ - fromNat n
+-fromNat zero = refl
+-fromNat (suc n) = refl
+
+neg≤pos : ∀ n m → fromNeg n ≤ fromNat m
+neg≤pos n m =
+ subst (_≤ fromNat m) (sym (-fromNat n))
+  (isTrans≤ _ 0 (fromNat m) ((minus-≤ 0 (fromNat n) (0≤pos n 1))) (0≤pos m 1))
 
 floor-lemma : ∀ p q → fromNat (ℕ.quotient p / (suc q))
                    ℚ.+ [ ℤ.pos (ℕ.remainder p / (suc q)) / 1+ q ]
@@ -68,6 +91,9 @@ floor-lemma p q = eq/ _ _
           (ℕ.+-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)
@@ -159,6 +185,24 @@ floor-fracℚ₊ = uncurry (SQ.Elim.go w)
          ∙∙ sym (ℕ.·-distribʳ _ _ _))
         ∙∙ (λ i → ℕ.·-comm (ℕ.·-comm (suc q') (ℕ.quotient p' / suc q') i) (suc q) i)))
 
+floor-fracℚ₊≤ : (x : ℚ₊) → fromNat (fst (fst (floor-fracℚ₊ x))) ≤ fst x
+floor-fracℚ₊≤ x =
+  let ((N , q) , (e , (0≤q , _))) = floor-fracℚ₊ x
+      zz = ≡Weaken≤ _ _ e
+      uu = subst (_≤ (fst x + q))
+                (+IdR _) $ ≤Monotone+ _ _ 0 _ zz 0≤q
+  in ≤-+o-cancel (fromNat N) _ _ uu
+
+≤floor-fracℚ₊ : (x : ℚ₊) → fst x < fromNat (suc (fst (fst (floor-fracℚ₊ x))))
+≤floor-fracℚ₊ x =
+  let ((N , q) , (e , (_ , q<1))) = floor-fracℚ₊ x
+  in subst (fst x <_) (ℕ+→ℚ+ _ _ ∙ cong (λ x → [ pos x / 1 ])
+             (ℕ.+-comm N 1))
+           $ isTrans≤< _ _ ((fromNat N) + 1)
+              (≡Weaken≤ _ _ (sym e))
+                 (<-o+ q 1 (fromNat N) q<1)
+
+
 ceil-[1-frac]ℚ₊ : ∀ (x : ℚ₊) → Σ (ℕ × ℚ) λ (k , q) →
                        (fst x + q ≡ fromNat k) × ((0 ≤ q)  × (q < 1))
 ceil-[1-frac]ℚ₊ x =
@@ -204,8 +248,8 @@ floor-frac x with 0 ≟ x
         p , e'
 
 
-ceilℚ₊ : (q : ℚ₊) → Σ[ k ∈ ℕ ] (fst q) < fromNat k
-ceilℚ₊ q = suc (fst (fst (floor-fracℚ₊ q))) ,
+ceilℚ₊ : (q : ℚ₊) → Σ[ k ∈ ℕ₊₁ ] (fst q) < fromNat (ℕ₊₁→ℕ k)
+ceilℚ₊ q = 1+ (fst (fst (floor-fracℚ₊ q))) ,
    subst2 (_<_) --  (fromNat (suc (fst (fst (floor-fracℚ₊ q)))))
       (ℚ.+Comm _ _ ∙ fst (snd (floor-fracℚ₊ q)))
       (ℚ.ℕ+→ℚ+ _ _)
@@ -214,6 +258,8 @@ ceilℚ₊ q = suc (fst (fst (floor-fracℚ₊ q))) ,
 
 
 
+
+
 sign : ℚ → ℚ
 sign = Rec.go w
  where
@@ -469,6 +515,16 @@ elimBy≤ : ∀ {ℓ} {A : ℚ → ℚ → Type ℓ}
 elimBy≤ s f x y = ⊎.rec
   (f _ _ ) (s _ _ ∘ f _ _ ) (≤cases x y)
 
+elim≤By≡⊎< : ∀ {ℓ} (a : ℚ) {A : ∀ x → a ≤ x → Type ℓ}
+  → (A a (isRefl≤ a))
+  → (∀ x a<x → A x (<Weaken≤ _ _ a<x)  )
+  → ∀ x a<x → A x a<x
+elim≤By≡⊎< a {A = A} r f x =
+  ⊎.rec
+    (λ a=x → subst (uncurry A) (Σ≡Prop (isProp≤ a) a=x) r)
+    (subst (A x) (isProp≤ a x _ _) ∘ f x)
+    ∘ (≤→≡⊎< a x)
+
 elimBy≡⊎< : ∀ {ℓ} {A : ℚ → ℚ → Type ℓ}
   → (∀ x y → A x y → A y x)
   → (∀ x → A x x)
@@ -478,6 +534,12 @@ elimBy≡⊎< {A = A} s r f =
  elimBy≤ s (λ x y → ⊎.rec (λ p → subst (A x) p (r x)) (f x y) ∘ ≤→≡⊎< x y)
 
 
+max< : ∀ x y z → x < z → y < z → max x y < z
+max< = elimBy≤
+  (λ x y X z y<z x<z → subst (_< z) (maxComm _ _) (X z x<z y<z) )
+  λ x y x≤y z x<z y<z →
+    subst (_< z) (sym (≤→max x y x≤y)) y<z
+
 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 ∙∙
@@ -499,9 +561,16 @@ minDistMax x = elimBy≤
  subst (L ≤_) (cong (λ y → ℚ.max y _) (sym $ ≤→min L L' y)
       ∙ sym (maxDistMin L x L')) (≤max L (ℚ.min x L'))
 
+clamped≤ : ∀ L L' x → L ≤ x → clamp L L' x ≤ x
+clamped≤ L L' x L≤x = subst (_≤ x)
+  (cong (flip min L') (sym (≤→max L x L≤x))) (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
 
+abs'Comm- : ∀ x y → ℚ.abs' (x ℚ.- y) ≡ ℚ.abs' (y ℚ.- x)
+abs'Comm- x y = sym (abs'≡abs _) ∙∙ absComm- x y ∙∙ abs'≡abs _
+
 ≤MonotoneClamp : ∀ L L' x y → x ≤ y → clamp L L' x ≤ clamp L L' y
 ≤MonotoneClamp L L' x y p =
  ≤MonotoneMin
@@ -533,6 +602,19 @@ inClamps L L' x u v =
 -≤abs' : ∀ x → ℚ.- x ≤ abs' x
 -≤abs' x = subst (- x ≤_) (sym (-abs' x)) (≤abs' (ℚ.- x))
 
+-≤abs : ∀ x → ℚ.- x ≤ abs x
+-≤abs x = subst (- x ≤_) (sym (-abs x)) (≤abs (ℚ.- x))
+
+
+absTo≤×≤ : ∀ ε q
+                → abs q ≤ ε
+                → (- ε ≤ q) × (q ≤ ε)
+
+absTo≤×≤ ε q abs[q]≤ε .fst =
+ subst (- ε ≤_) (-Invol q) (minus-≤ _ _ (isTrans≤ _ _ _ (-≤abs q) abs[q]≤ε))
+absTo≤×≤ ε q abs[q]≤ε .snd = isTrans≤ _ _ _ (≤abs q) abs[q]≤ε
+
+
 Dichotomyℚ : ∀ (n m : ℚ) → (n ≤ m) ⊎ (m < n)
 Dichotomyℚ n m = decRec inr (inl ∘ ≮→≥ _ _) (<Dec m n)
 
@@ -640,6 +722,9 @@ invℚ₊-invol = uncurry (ElimProp.go w)
   ww : ∀ x x₁ → (ℕ₊₁→ℤ (fst (ℤ.0<→ℕ₊₁ (x .fst) x₁)) , (1+ x .snd .ℕ₊₁.n)) ∼ x
   ww (pos (suc n) , snd₁) x₁ = refl
 
+equivInvℚ₊ : ℚ₊ ≃ ℚ₊
+equivInvℚ₊ = involEquiv {f = invℚ₊} λ x → ℚ₊≡ (invℚ₊-invol x)
+
 x·invℚ₊[x] : ∀ x → fst x · fst (invℚ₊ x) ≡ 1
 x·invℚ₊[x] = uncurry (ElimProp.go w)
  where
@@ -739,6 +824,9 @@ invℚ₊Dist· = uncurry (flip ∘ uncurry ∘ ElimProp2.go w)
 /4₊+/4₊≡/2₊ ε = ℚ₊≡ (sym (·DistL+ (fst ε) [ 1 / 4 ] [ 1 / 4 ])
    ∙ cong (fst ε ·_) decℚ?)
 
+/4₊≡/2₊/2₊ : ∀ ε → fst (/4₊ ε) ≡ fst (/2₊ (/2₊ ε))
+/4₊≡/2₊/2₊ ε = cong (fst ε ·_) decℚ? ∙ ·Assoc _ _ _
+
 weak0< : ∀ q (ε δ : ℚ₊)
              →  q < (fst ε - fst δ)
              → q < fst ε
@@ -765,6 +853,20 @@ n/k+m/k n m k = let k' = pos (suc (k .ℕ₊₁.n)) in
     sym (ℤ.·Assoc (n ℤ.+ m) k' k') ∙∙
      cong ((n ℤ.+ m) ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ k) (ℕ₊₁→ℕ k))))
 
+
+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') (cong₂ ℤ._+_ (cong (n ℤ.·_) (cong ℕ₊₁→ℤ (·₊₁-identityˡ _))) refl
+   ∙ sym (ℤ.·DistL+ _ _ _) ) ∙∙
+    sym (ℤ.·Assoc (n ℤ.- m) k' k') ∙∙
+
+     cong {x = k' ℤ.· k'}
+       {y = ℕ₊₁→ℤ (k ·₊₁ ((1+ 0) ·₊₁ k))} ((n ℤ.- m) ℤ.·_) (sym (ℤ.pos·pos _ _) ∙
+         cong (ℕ₊₁→ℤ ∘ (k ·₊₁_)) (sym (·₊₁-identityˡ _)))
+     )
+
+
 k/k : ∀ k → [ ℕ₊₁→ℤ k / k ] ≡ 1
 k/k (1+ k) = eq/ _ _ (ℤ.·IdR (ℕ₊₁→ℤ (1+ k)))
 
@@ -932,6 +1034,12 @@ elimBy≡⊎<' {A = A} s r f' =
  f : ∀ x y → x < y → A x y
  f x y v = subst (A x) lem--05 $ f' x (<→ℚ₊ x y v)
 
+elim≤By+ : ∀ {ℓ} {A : ∀ x y → x < y →  Type ℓ}
+  → (∀ x (ε : ℚ₊) x< → A x (x + fst ε) x<)
+  → ∀ x y x<y → A x y x<y
+elim≤By+ {A = A} X x y v =
+  subst (uncurry (A x)) (Σ≡Prop (isProp< x) lem--05) $
+   X x (<→ℚ₊ x y v) (<+ℚ₊' x x ((<→ℚ₊ x y v)) (isRefl≤ x))
 
 
 module HLP where
@@ -1112,9 +1220,27 @@ riseQandD p q r =
                     ∙ sym (·₊₁-assoc _ _ _)))
 
 
-clampDiff : ∀ L L' x → clamp L L' x ≡
+
+<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)
+
+
+clampDelta : ∀ L L' x → clamp L L' x ≡
                (x + clamp (L - x) (L' - x) 0)
-clampDiff L L' x =
+clampDelta L L' x =
      cong₂ min
        (cong₂ max (lem--035 {L} {x})
          (sym $ +IdL x) ∙ sym (+MaxDistrℚ _ _ x))
@@ -1123,17 +1249,14 @@ clampDiff L L' 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)))
+
+clampDiff : ∀ L L' x y → x ≤ y →
+    clamp L L' y - clamp L L' x ≤ y - x
+clampDiff L L' x y z =
   (subst2 _≤_
      ((sym (lem--041 {y} {a'} {x} {a})) ∙
-       cong₂ _-_ (sym $ clampDiff L L' y)
-                   (sym $ clampDiff L L' x))
+       cong₂ _-_ (sym $ clampDelta L L' y)
+                   (sym $ clampDelta L L' x))
      (+IdR (y - x))
      (≤-o+ ((a' - a)) 0 (y - x)
       (subst (_≤ 0) (-[x-y]≡y-x a a')
@@ -1150,6 +1273,24 @@ clampDist' L L' x y z =
             ) (≤-o+ (- y) (- x) L' $ minus-≤ x y z)
 
 
+minDiff : ∀ L' x y → x ≤ y →
+    min y L' - min x L' ≤ y - x
+minDiff L' x y x≤y =
+ subst (_≤ (y - x))
+    (cong₂ _-_
+     (cong (flip min L') (≤→max x y x≤y ))
+     (cong (flip min L') (maxIdem x)))
+     (clampDiff x L' x y x≤y)
+
+
+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)))
+  (clampDiff L L' x y z)
 
 clampDist : ∀ L L' x y →
     abs (clamp L L' y - clamp L L' x) ≤ abs (y - x)
@@ -1279,7 +1420,16 @@ getPosRatio L₁ L₂ =
                   (<Weaken≤ 0 (y' - y) (-< y y' x₂) ) x₃)))
 
 
-
+≤<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' 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')
 
 invℚ : ∀ q → 0 # q → ℚ
 invℚ q p = sign q · fst (invℚ₊ (0#→ℚ₊ q p))
@@ -1372,6 +1522,65 @@ q ／ℚ[ r , 0＃r ] = q · (invℚ 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≤z/y→x·y≤z : ∀ x q r 0#r → (0<r : 0 < r)
+               → x ≤ q ／ℚ[ r , 0#r  ]
+               → (x · r) ≤ q
+x≤z/y→x·y≤z x q r 0＃r 0<r  p =
+   subst ((x · r) ≤_) (ℚ-[x/y]·y q r 0＃r) (≤-·o _ _ r (<Weaken≤ 0 r 0<r ) p)
+
+
+x/y≤z→x≤z·y : ∀ x q r 0#r → (0<r : 0 < r)
+               → x ／ℚ[ r , 0#r  ] ≤ q
+               → x ≤ q · r
+x/y≤z→x≤z·y x q r 0＃r 0<r  p =
+   subst (_≤ (q · r)) (ℚ-[x/y]·y x r 0＃r) (≤-·o _ _ r (<Weaken≤ 0 r 0<r ) p)
+
+x·invℚ₊y≤z→x≤y·z : ∀ x q r
+               → x · fst (invℚ₊ r) ≤ q
+               → x ≤ (fst r) · q
+x·invℚ₊y≤z→x≤y·z x q r  p =
+   subst (_≤ ((fst r) · q)) (cong ((fst r) ·_) (·Comm _ _) ∙ y·[x/y] r x)
+      (≤-o· _ _ (fst r) (0≤ℚ₊ r ) p)
+
+
+x·invℚ₊y<z→x<y·z : ∀ x q r
+               → x · fst (invℚ₊ r) < q
+               → x < (fst r) · q
+x·invℚ₊y<z→x<y·z x q r  p =
+   subst (_< ((fst r) · q)) (cong ((fst r) ·_) (·Comm _ _) ∙ y·[x/y] r x)
+      (<-o· _ _ (fst r) (0<ℚ₊ r ) p)
+
+
+y·x<z→x<z·invℚ₊y : ∀ x z r
+               → (fst r) · x < z
+               → x < z · fst (invℚ₊ r)
+y·x<z→x<z·invℚ₊y x z r p =
+   subst (_< z · fst (invℚ₊ r))
+    (·Comm _ _ ∙ [y·x]/y _ _)
+    (<-·o _ _ (fst (invℚ₊ r)) (0<ℚ₊ (invℚ₊ r) ) p)
+
+x≤y·z→x·invℚ₊y≤z : ∀ x q r
+               → x ≤ (fst r) · q
+               → x · fst (invℚ₊ r) ≤ q
+
+x≤y·z→x·invℚ₊y≤z x q r  p =
+  subst (x · fst (invℚ₊ r) ≤_)
+   (·Comm _ _ ∙ [y·x]/y _ _)
+   (≤-·o x _ (fst (invℚ₊ r)) ((0≤ℚ₊ ( invℚ₊ r) )) p)
+
+
+x<y·z→x·invℚ₊y<z : ∀ x q r
+               → x < (fst r) · q
+               → x · fst (invℚ₊ r) < q
+
+x<y·z→x·invℚ₊y<z x q r  p =
+  subst (x · fst (invℚ₊ r) <_)
+   (·Comm _ _ ∙ [y·x]/y _ _)
+   (<-·o x _ (fst (invℚ₊ r)) ((0<ℚ₊ ( invℚ₊ 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
@@ -1460,22 +1669,6 @@ invℚ₊≤invℚ₊ x y p =
 
 
 
-<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
@@ -1499,6 +1692,21 @@ 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
 
+1≤x^ⁿ : ∀ x n → 1 ≤ x →  1 ≤ (x ℚ^ⁿ n)
+1≤x^ⁿ x zero 1≤x = isRefl≤ 1
+1≤x^ⁿ x (suc n) 1≤x =
+ ≤Monotone·-onNonNeg 1 _ 1 _
+   (1≤x^ⁿ x n 1≤x) 1≤x (decℚ≤? {0} {1})
+     (decℚ≤? {0} {1})
+
+1<x^ⁿ : ∀ x n → 1 < x →  1 < (x ℚ^ⁿ (suc n))
+1<x^ⁿ x zero 1<x = subst (1 <_) (sym (·IdL _)) 1<x
+1<x^ⁿ x (suc n) 1<x =
+ <Monotone·-onPos 1 _ 1 _
+   (1<x^ⁿ x n 1<x) 1<x (decℚ≤? {0} {1})
+     (decℚ≤? {0} {1})
+
+
 ·-ℚ^ⁿ : ∀ n m x → (x ℚ^ⁿ n) · (x ℚ^ⁿ m) ≡ (x ℚ^ⁿ (n ℕ.+ m))
 ·-ℚ^ⁿ zero m x = ·IdL _
 ·-ℚ^ⁿ (suc n) m x = (sym (·Assoc _ _ _)
@@ -1536,3 +1744,13 @@ invℚ₊-<-invℚ₊ (q , 0<q) (r , 0<r) = ElimProp2.go w q r 0<q 0<r
    propBiimpl→Equiv ℤ.isProp<  ℤ.isProp<
     (subst2 ℤ._<_ (ℤ.·Comm _ _) (ℤ.·Comm _ _))
     (subst2 ℤ._<_ (ℤ.·Comm _ _) (ℤ.·Comm _ _))
+
+invℚ₊-≤-invℚ₊ : ∀ q r → ((fst q) ≤ (fst r))
+             ≃ (fst (invℚ₊ r) ≤ fst (invℚ₊ q))
+invℚ₊-≤-invℚ₊ q r =
+    (≤≃≡⊎< _ _)
+   ∙ₑ ⊎.⊎-equiv (Σ≡PropEquiv (snd ∘ 0<ₚ_) {u = q} {v = r}
+    ∙ₑ congEquiv equivInvℚ₊ ∙ₑ
+     invEquiv (Σ≡PropEquiv (snd ∘ 0<ₚ_) {u = invℚ₊ r} {v = invℚ₊ q}
+        ∙ₑ isoToEquiv symIso )) (invℚ₊-<-invℚ₊ q r)
+   ∙ₑ (invEquiv (≤≃≡⊎< _ _))
diff --git a/Cubical/Data/Rationals/Properties.agda b/Cubical/Data/Rationals/Properties.agda
index 66cf5e0c55..eab7423fa2 100644
--- a/Cubical/Data/Rationals/Properties.agda
+++ b/Cubical/Data/Rationals/Properties.agda
@@ -6,6 +6,8 @@ open import Cubical.Foundations.Isomorphism
 open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.GroupoidLaws hiding (_⁻¹)
 open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
 
 open import Cubical.Data.Int as ℤ using (ℤ; pos·pos; pos0+)
 open import Cubical.HITs.SetQuotients as SetQuotient using () renaming (_/_ to _//_)
@@ -13,12 +15,45 @@ open import Cubical.HITs.SetQuotients as SetQuotient using () renaming (_/_ to _
 open import Cubical.Data.Nat as ℕ using (ℕ; zero; suc)
 open import Cubical.Data.NatPlusOne
 open import Cubical.Data.Sigma
+import Cubical.Data.Bool as 𝟚
 
 open import Cubical.Data.Sum
+open import Cubical.Data.Empty as ⊥
 open import Cubical.Relation.Nullary
 
 open import Cubical.Data.Rationals.Base
 
+open import Cubical.Data.Nat.GCD
+open import Cubical.Data.Nat.Coprime
+
+∼→sign≡sign : ∀ a a' b b' → (a , b) ∼ (a' , b') → ℤ.sign a ≡ ℤ.sign a'
+∼→sign≡sign (ℤ.pos zero) (ℤ.pos zero) (1+ n) (1+ n₁) x = refl
+∼→sign≡sign (ℤ.pos zero) (ℤ.pos (suc n₃)) (1+ n) (1+ n₁) x =
+  ⊥.rec $ ℕ.znots $
+     ℤ.injPos (x ∙ sym (ℤ.pos·pos (suc n₃) (suc n)))
+∼→sign≡sign (ℤ.pos (suc n₂)) (ℤ.pos zero) (1+ n) (1+ n₁) x =
+ ⊥.rec $ ℕ.znots $
+     ℤ.injPos (sym x ∙ sym (ℤ.pos·pos (suc n₂) (suc n₁)))
+∼→sign≡sign (ℤ.pos (suc n₂)) (ℤ.pos (suc n₃)) (1+ n) (1+ n₁) x = refl
+∼→sign≡sign (ℤ.pos zero) (ℤ.negsuc n₃) (1+ n) (1+ n₁) x =
+ ⊥.rec $ ℕ.znots $ ℤ.injPos $ cong ℤ.-_ (x ∙ ℤ.negsuc·pos n₃ (ℕ₊₁→ℕ (1+ n)))
+   ∙ ℤ.-Involutive _ ∙ sym (ℤ.pos·pos (suc n₃) (ℕ₊₁→ℕ (1+ n)))
+∼→sign≡sign (ℤ.pos (suc n₂)) (ℤ.negsuc n₃) (1+ n) (1+ n₁) x =
+ ⊥.rec (ℤ.posNotnegsuc _ _ (ℤ.pos·pos (suc n₂) (ℕ₊₁→ℕ (1+ n₁))
+  ∙∙ x ∙∙
+   (ℤ.negsuc·pos n₃ (ℕ₊₁→ℕ (1+ n)) ∙ cong ℤ.-_ (sym (ℤ.pos·pos (suc n₃) (ℕ₊₁→ℕ (1+ n)))))))
+∼→sign≡sign (ℤ.negsuc n₂) (ℤ.pos zero) (1+ n) (1+ n₁) x =
+  ⊥.rec $ ℕ.snotz $ ℤ.injPos $
+     (ℤ.pos·pos (suc n₂) (ℕ₊₁→ℕ (1+ n₁))) ∙∙
+      sym (ℤ.-Involutive _) ∙∙ cong ℤ.-_ (sym (ℤ.negsuc·pos n₂ (ℕ₊₁→ℕ (1+ n₁))) ∙ x)
+∼→sign≡sign (ℤ.negsuc n₂) (ℤ.pos (suc n₃)) (1+ n) (1+ n₁) x =
+  ⊥.rec (ℤ.negsucNotpos _ _
+     ((cong ℤ.-_ (ℤ.pos·pos (suc n₂) (ℕ₊₁→ℕ (1+ n₁)))
+      ∙ sym (ℤ.negsuc·pos n₂ (ℕ₊₁→ℕ (1+ n₁))))
+      ∙∙ x ∙∙ sym (ℤ.pos·pos (suc n₃) (ℕ₊₁→ℕ (1+ n)))))
+∼→sign≡sign (ℤ.negsuc n₂) (ℤ.negsuc n₃) (1+ n) (1+ n₁) x = refl
+
+
 ·CancelL : ∀ {a b} (c : ℕ₊₁) → [ ℕ₊₁→ℤ c ℤ.· a / c ·₊₁ b ] ≡ [ a / b ]
 ·CancelL {a} {b} c = eq/ _ _
   ((ℕ₊₁→ℤ c ℤ.· a)   ℤ.· ℕ₊₁→ℤ b  ≡⟨ cong (ℤ._· ℕ₊₁→ℤ b) (ℤ.·Comm (ℕ₊₁→ℤ c) a) ⟩
@@ -33,8 +68,58 @@ open import Cubical.Data.Rationals.Base
    a ℤ.· (ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ c)  ≡⟨ cong (a ℤ.·_) (sym (pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ c))) ⟩
    a ℤ.· ℕ₊₁→ℤ (b ·₊₁ c) ∎)
 
+reduced : (x : ℚ) → Σ[ (p , q) ∈ (ℤ × ℕ₊₁) ] (areCoprime (ℤ.abs p , ℕ₊₁→ℕ q) × ([ p / q ] ≡ x))
+reduced = SetQuotient.Elim.go w
+ where
+
+ module cop a b where
+  open ToCoprime (ℤ.abs a , b) renaming (toCoprimeAreCoprime to tcac) public
+
+
+  e : ℤ.sign a ℤ.· ℤ.pos c₁ ℤ.· ℕ₊₁→ℤ b ≡ a ℤ.· ℕ₊₁→ℤ c₂
+  e =     (sym (ℤ.·Assoc (ℤ.sign a) _ _)
+           ∙ cong (ℤ.sign a ℤ.·_)
+              (     cong (ℤ.pos c₁ ℤ.·_)
+                   (cong ℤ.pos (sym p₂ ∙ ℕ.·-comm _ d ) ∙ ℤ.pos·pos d _)
+                 ∙∙ ℤ.·Assoc (ℤ.pos c₁) _ _
+                 ∙∙ cong (λ p → p ℤ.· ℕ₊₁→ℤ c₂ )
+                     (sym (ℤ.pos·pos c₁ d) ∙ cong ℤ.pos p₁)) )
+       ∙∙ ℤ.·Assoc (ℤ.sign a) _ _
+       ∙∙ cong (ℤ._· ℕ₊₁→ℤ c₂) (ℤ.sign·abs a)
+  p' : ∀ a c₁ → (c₁ ℕ.· suc d-1 ≡ ℤ.abs a) → c₁ ≡ ℤ.abs (ℤ.sign a ℤ.· ℤ.pos c₁)
+  p' (ℤ.pos zero) zero x = refl
+  p' (ℤ.pos zero) (suc c₃) x = ⊥.rec (ℕ.snotz x)
+  p' (ℤ.pos (suc n)) _ x = refl
+  p' (ℤ.negsuc n) zero x = refl
+  p' (ℤ.negsuc n) (suc c₃) x = refl
+
+  r = (ℤ.sign a ℤ.· ℤ.pos c₁ , c₂) , subst areCoprime (cong (_, (ℕ₊₁→ℕ c₂))
+         (p' a _ (cong (c₁ ℕ.·_) (sym q) ∙ p₁))) tcac , eq/ _ _ e
+
+
+
+ w : SetQuotient.Elim _
+ w .SetQuotient.Elim.isSetB _ =
+  isSetΣ (isSet× ℤ.isSetℤ (subst isSet 1+Path ℕ.isSetℕ))
+    (isProp→isSet ∘ λ _ → isProp× isPropIsGCD (isSetℚ _ _))
+
+ w .SetQuotient.Elim.f (a , b) = cop.r  a b
+
+ w .SetQuotient.Elim.f∼ (a , b) (a' , b') r =
+   ΣPathPProp
+            (λ _ → isProp× isPropIsGCD (isSetℚ _ _))
+     (cong (map-fst ((ℤ.sign a ℤ.·_) ∘ ℤ.pos)) (sym (toCoprime-cancelʳ (ℤ.abs a , b) b')) ∙∙
+       cong₂ {x = ℤ.sign a} {y = ℤ.sign a'}
+        (λ sa → (map-fst ((sa ℤ.·_) ∘ ℤ.pos) ∘ toCoprime))
+        (∼→sign≡sign a a' b b' r)
+        (ΣPathP (sym (ℤ.abs· a _) ∙∙ cong ℤ.abs r ∙∙ ℤ.abs· a' _ , ·₊₁-comm b b'))
+      ∙∙ cong (map-fst ((ℤ.sign a' ℤ.·_) ∘ ℤ.pos)) (toCoprime-cancelʳ (ℤ.abs a' , b') b) )
+
 -- useful functions for defining operations on ℚ
 
+reduce : ℚ → ℚ
+reduce = [_] ∘ fst ∘  reduced
+
 record OnCommonDenom : Type where
  no-eta-equality
  field
@@ -481,9 +566,27 @@ _·_ = OnCommonDenomSym.go ·Rec
 ·DistR+ x y z = sym ((λ i → ·Comm x z i + ·Comm y z i) ∙ (sym (·DistL+ z x y)) ∙ ·Comm z (x + y))
 
 
+[/]≡· : ∀ n m → [ n / m ] ≡ [ n / 1 ] · [ 1 / m ]
+[/]≡· n m = cong₂ [_/_] (sym (ℤ.·IdR n)) (sym (·₊₁-identityˡ _))
+
+[1/n]·[1/m]≡[1/n·m] : ∀ n m → [ 1 / n ] · [ 1 / m ] ≡ [ 1 / n ·₊₁ m ]
+[1/n]·[1/m]≡[1/n·m] n m = eq/ _ _ refl
+
+
+[n/n]≡[m/m] : ∀ n m → [ ℤ.pos (suc n) / 1+ n ] ≡ [ ℤ.pos (suc m) / 1+ m ]
+[n/n]≡[m/m] n m = eq/ _ _ (ℤ.·Comm (ℤ.pos (suc n)) (ℤ.pos (suc m)))
+
+[0/n]≡[0/m] : ∀ n m → [ ℤ.pos zero / 1+ n ] ≡ [ ℤ.pos zero / 1+ m ]
+[0/n]≡[0/m] n m = eq/ _ _ refl
+
+
 -_ : ℚ → ℚ
 - x = -1 · x
 
+-[/] : ∀ n m → [ ℤ.negsuc m / n ] ≡ - [ ℤ.pos (suc m) / n ]
+-[/] n m = cong [ ℤ.negsuc m /_] (sym (·₊₁-identityˡ _))
+
+
 -Invol : ∀ x → - - x ≡ x
 -Invol x = ·Assoc -1 -1 x ∙ ·IdL x
 
@@ -569,8 +672,22 @@ abs'≡abs = SetQuotient.ElimProp.go w
 ℤ+→ℚ+ : ∀ m n → [ m / 1 ] + [ n / 1 ] ≡ [ m ℤ.+ n / 1 ]
 ℤ+→ℚ+ m n = cong [_/ 1 ] (cong₂ ℤ._+_ (ℤ.·IdR m) (ℤ.·IdR n))
 
+ℤ-→ℚ- : ∀ 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))
+
+
+x+x≡2x : ∀ x → x + x ≡ 2 · x
+x+x≡2x x = cong₂ _+_
+    (sym (·IdL x))
+    (sym (·IdL x))
+    ∙ sym (·DistR+ 1 1 x)
+
diff --git a/Cubical/Data/Sum/Properties.agda b/Cubical/Data/Sum/Properties.agda
index bd0d2402a6..c88f6c1c8a 100644
--- a/Cubical/Data/Sum/Properties.agda
+++ b/Cubical/Data/Sum/Properties.agda
@@ -21,11 +21,12 @@ open Iso
 
 private
   variable
-    ℓa ℓb ℓc ℓd ℓe : Level
+    ℓa ℓb ℓc ℓd ℓe ℓf : Level
     A : Type ℓa
     B : Type ℓb
     C : Type ℓc
     D : Type ℓd
+    F : Type ℓf
     E : A ⊎ B → Type ℓe
 
 
@@ -134,6 +135,14 @@ rightInv (⊎Iso iac ibd) (inr x) = cong inr (ibd .rightInv x)
 leftInv (⊎Iso iac ibd) (inl x)  = cong inl (iac .leftInv x)
 leftInv (⊎Iso iac ibd) (inr x)  = cong inr (ibd .leftInv x)
 
+⊎Iso' : Iso A C → Iso B D → Iso (A ⊎ B) (C ⊎ D)
+fun (⊎Iso' iac ibd) = map (iac .fun) (ibd .fun)
+inv (⊎Iso' iac ibd) = map (iac .inv) (ibd .inv)
+rightInv (⊎Iso' iac ibd) (inl x) = cong inl (iac .rightInv x)
+rightInv (⊎Iso' iac ibd) (inr x) = cong inr (ibd .rightInv x)
+leftInv (⊎Iso' iac ibd) (inl x)  = cong inl (iac .leftInv x)
+leftInv (⊎Iso' iac ibd) (inr x)  = cong inr (ibd .leftInv x)
+
 ⊎-equiv : A ≃ C → B ≃ D → (A ⊎ B) ≃ (C ⊎ D)
 ⊎-equiv p q = isoToEquiv (⊎Iso (equivToIso p) (equivToIso q))
 
@@ -357,3 +366,9 @@ Iso⊎→Iso {A = A} {C = C} {B = B} {D = D} f e p = Iso'
   Iso.inv Iso' = e⁻-pres-inr
   Iso.rightInv Iso' x = lem2 x (_ , refl) (_ , refl)
   Iso.leftInv Iso' x = lem1 x (_ , refl) (_ , refl)
+
+rec-map : (f : C → F) (g : D → F) (h : A → C) (k : B → D)
+        → (x : A ⊎ B)
+        → ⊎.rec f g (⊎.map h k x) ≡ ⊎.rec (f ∘ h) (g ∘ k) x
+rec-map f g h k (inl a) = refl
+rec-map f g h k (inr b) = refl
diff --git a/Cubical/Data/SumFin/Properties.agda b/Cubical/Data/SumFin/Properties.agda
index 41a7d2ffe9..ad5077200c 100644
--- a/Cubical/Data/SumFin/Properties.agda
+++ b/Cubical/Data/SumFin/Properties.agda
@@ -264,7 +264,7 @@ isProp→Fin≤1 (suc (suc n)) p = ⊥.rec (fzero≠fone (p fzero (fsuc fzero)))
 
 -- automorphisms of SumFin
 
-SumFin≃≃ : (n : ℕ) → (Fin n ≃ Fin n) ≃ Fin (LehmerCode.factorial n)
+SumFin≃≃ : (n : ℕ) → (Fin n ≃ Fin n) ≃ Fin (n !)
 SumFin≃≃ _ =
     equivComp (SumFin≃Fin _) (SumFin≃Fin _)
   ⋆ LehmerCode.lehmerEquiv
diff --git a/Cubical/Experiments/ZCohomologyOld/Properties.agda b/Cubical/Experiments/ZCohomologyOld/Properties.agda
index faaadde8c8..8d09d5de98 100644
--- a/Cubical/Experiments/ZCohomologyOld/Properties.agda
+++ b/Cubical/Experiments/ZCohomologyOld/Properties.agda
@@ -268,12 +268,12 @@ cancelₖ (suc (suc (suc (suc (suc n))))) x = cong (ΩKn+1→Kn (5 + n)) (rCance
                  ∙∙ cong (ΩKn+1→Kn (suc n)) (sym (rUnit (Kn→ΩKn+1 (suc n) x)))
                  ∙∙ Iso.leftInv (Iso-Kn-ΩKn+1 (suc n)) x
 
+open Iso renaming (inv to inv')
 abstract
   isCommΩK1 : (n : ℕ) → isComm∙ ((Ω^ n) (coHomK-ptd 1))
   isCommΩK1 zero = isCommA→isCommTrunc 2 comm-ΩS¹ isGroupoidS¹
   isCommΩK1 (suc n) = EH n
 
-  open Iso renaming (inv to inv')
   isCommΩK : (n : ℕ) → isComm∙ (coHomK-ptd n)
   isCommΩK zero p q = isSetℤ _ _ (p ∙ q) (q ∙ p)
   isCommΩK (suc zero) = isCommA→isCommTrunc 2 comm-ΩS¹ isGroupoidS¹
diff --git a/Cubical/Foundations/HLevels.agda b/Cubical/Foundations/HLevels.agda
index 523b385abb..3f5f7ae634 100644
--- a/Cubical/Foundations/HLevels.agda
+++ b/Cubical/Foundations/HLevels.agda
@@ -798,6 +798,15 @@ module _ (isSet-A : isSet A) (isSet-A' : isSet A') where
   SetsIso≡ p q =
     SetsIso≡-ext (funExt⁻ p) (funExt⁻ q)
 
+  SetsIso≡fun : ∀ {a b : Iso A A'}
+            → (Iso.fun a ≡ Iso.fun b)
+            → a ≡ b
+  SetsIso≡fun {a} {b} p =
+    SetsIso≡-ext (funExt⁻ p) λ x' →
+      sym (leftInv b _) ∙ cong (inv b)
+             (sym (p ≡$ (inv a x')) ∙ (rightInv a _))
+
+
   isSet→Iso-Iso-≃ : Iso (Iso A A') (A ≃ A')
   isSet→Iso-Iso-≃ = ww
     where
diff --git a/Cubical/Foundations/Pointed/Properties.agda b/Cubical/Foundations/Pointed/Properties.agda
index ae24e72bf9..746099a931 100644
--- a/Cubical/Foundations/Pointed/Properties.agda
+++ b/Cubical/Foundations/Pointed/Properties.agda
@@ -245,6 +245,14 @@ compPathlEquiv∙ : {A : Type ℓ} {a b c : A} {q : b ≡ c} (p : a ≡ b)
 fst (compPathlEquiv∙ p) = compPathlEquiv p
 snd (compPathlEquiv∙ p) = refl
 
+-- Pointed version of Σ-cong-equiv-snd
+Σ-cong-equiv-snd∙ : ∀ {ℓ ℓ'} {A : Type ℓ} {B₁ B₂ : A → Type ℓ'}
+  → {a : A} {b₁ : B₁ a} {b₂ : B₂ a}
+  → (e : ∀ a → B₁ a ≃ B₂ a)
+  → fst (e a) b₁ ≡ b₂
+  → Path (Pointed _) (Σ∙ (A , a) B₁ b₁) (Σ∙ (A , a) B₂ b₂)
+Σ-cong-equiv-snd∙ e p = ua∙ (Σ-cong-equiv-snd e) (ΣPathP (refl , p))
+
 -- a pointed map is constant iff its non-pointed part is constant
 constantPointed≡ : {A B : Pointed ℓ} (f : A →∙ B)
                  → fst f ≡ fst (const∙ A B) → f ≡ const∙ A B
diff --git a/Cubical/Foundations/Prelude.agda b/Cubical/Foundations/Prelude.agda
index 5559b748bd..e47fc9f525 100644
--- a/Cubical/Foundations/Prelude.agda
+++ b/Cubical/Foundations/Prelude.agda
@@ -311,6 +311,10 @@ subst2 : ∀ {ℓ' ℓ''} {B : Type ℓ'} {z w : B} (C : A → B → Type ℓ'')
         (p : x ≡ y) (q : z ≡ w) → C x z → C y w
 subst2 B p q b = transport (λ i → B (p i) (q i)) b
 
+subst3 : ∀ {ℓ' ℓ'' ℓ'''} {B : Type ℓ'} {C : Type ℓ''} {z w : B} {u v : C} (D : A → B → C → Type ℓ''')
+        (p : x ≡ y) (q : z ≡ w) (r : u ≡ v) → D x z u → D y w v
+subst3 D p q r b = transport (λ i → D (p i) (q i) (r i)) b
+
 substRefl : ∀ {B : A → Type ℓ} {x} → (px : B x) → subst B refl px ≡ px
 substRefl px = transportRefl px
 
diff --git a/Cubical/Foundations/Transport.agda b/Cubical/Foundations/Transport.agda
index 341dc68535..d139f70692 100644
--- a/Cubical/Foundations/Transport.agda
+++ b/Cubical/Foundations/Transport.agda
@@ -74,6 +74,10 @@ substSubst⁻ {x = x} {y = y} B p v = transportTransport⁻ {A = B x} {B = B y}
 substEquiv : ∀ {ℓ ℓ'} {A : Type ℓ} {a a' : A} (P : A → Type ℓ') (p : a ≡ a') → P a ≃ P a'
 substEquiv P p = (subst P p , isEquivTransport (λ i → P (p i)))
 
+subst2Equiv : ∀ {ℓ ℓ' ℓ''} {A : Type ℓ} {B : Type ℓ'} {a a' : A} {b b' : B}
+                (P : A → B → Type ℓ'') (p : a ≡ a') (q : b ≡ b') → P a b ≃ P a' b'
+subst2Equiv P p q = subst2 P p q , isEquivTransport (λ i → P (p i) (q i))
+
 liftEquiv : ∀ {ℓ ℓ'} {A B : Type ℓ} (P : Type ℓ → Type ℓ') (e : A ≃ B) → P A ≃ P B
 liftEquiv P e = substEquiv P (ua e)
 
diff --git a/Cubical/Functions/Embedding.agda b/Cubical/Functions/Embedding.agda
index 3453a3fe57..e24518519f 100644
--- a/Cubical/Functions/Embedding.agda
+++ b/Cubical/Functions/Embedding.agda
@@ -15,7 +15,10 @@ open import Cubical.Foundations.Transport
 open import Cubical.Foundations.Univalence using (ua; univalence; pathToEquiv)
 open import Cubical.Functions.Fibration
 
+open import Cubical.HITs.PropositionalTruncation.Base
+
 open import Cubical.Data.Sigma
+open import Cubical.Data.Sum.Base
 open import Cubical.Functions.Fibration
 open import Cubical.Functions.FunExtEquiv
 open import Cubical.Relation.Nullary using (Discrete; yes; no)
@@ -24,11 +27,10 @@ open import Cubical.Structures.Axioms
 open import Cubical.Reflection.StrictEquiv
 
 open import Cubical.Data.Nat using (ℕ; zero; suc)
-open import Cubical.Data.Sigma
 
 private
   variable
-    ℓ ℓ' ℓ'' : Level
+    ℓ ℓ' ℓ'' ℓ''' : Level
     A B C : Type ℓ
     f h : A → B
     w x : A
@@ -430,6 +432,14 @@ _≃Emb_ = EmbeddingIdentityPrinciple.f≃g
 EmbeddingIP : {B : Type ℓ} (f g : Embedding B ℓ') → f ≃Emb g ≃ (f ≡ g)
 EmbeddingIP = EmbeddingIdentityPrinciple.EmbeddingIP
 
+-- Using the above, we can show that the collection of embeddings forms a set
+isSetEmbedding : {B : Type ℓ} {ℓ' : Level} → isSet (Embedding B ℓ')
+isSetEmbedding M N
+  = isOfHLevelRespectEquiv 1
+      (EmbeddingIP M N)
+      (isProp× (isPropΠ2 (λ b _ → isEmbedding→hasPropFibers (N .snd .snd) b))
+               (isPropΠ2  λ b _ → isEmbedding→hasPropFibers (M .snd .snd) b))
+
 -- Cantor's theorem for sets
 Set-Embedding-into-Powerset : {A : Type ℓ} → isSet A → A ↪ ℙ A
 Set-Embedding-into-Powerset {A = A} setA
@@ -462,3 +472,65 @@ Set-Embedding-into-Powerset {A = A} setA
 
 EmbeddingΣProp : {A : Type ℓ} → {B : A → Type ℓ'} → (∀ a → isProp (B a)) → Σ A B ↪ A
 EmbeddingΣProp f = fst , (λ _ _ → isEmbeddingFstΣProp f)
+
+-- Since embeddings are equivalent to subsets, we can create some notation around this
+_∈ₑ_ : {A : Type ℓ} → A → Embedding A ℓ' → Type (ℓ-max ℓ ℓ')
+x ∈ₑ (_ , (f , _)) = fiber f x
+
+isProp∈ₑ : {A : Type ℓ} (x : A) (S : Embedding A ℓ') → isProp (x ∈ₑ S)
+isProp∈ₑ x S = isEmbedding→hasPropFibers (S .snd .snd) x
+
+_⊆ₑ_ : {A : Type ℓ} → Embedding A ℓ' → Embedding A ℓ'' → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+X ⊆ₑ Y = ∀ x → x ∈ₑ X → x ∈ₑ Y
+
+isProp⊆ₑ : {A : Type ℓ} (X : Embedding A ℓ') (Y : Embedding A ℓ'')
+         → isProp (X ⊆ₑ Y)
+isProp⊆ₑ _ Y = isPropΠ2 λ x _ → isProp∈ₑ x Y
+
+isRefl⊆ₑ : {A : Type ℓ} → (S : Embedding A ℓ') → S ⊆ₑ S
+isRefl⊆ₑ S x x∈S = x∈S
+
+isAntisym⊆ₑ : {A : Type ℓ}
+             (X Y : Embedding A ℓ')
+            → X ⊆ₑ Y
+            → Y ⊆ₑ X
+            → X ≡ Y
+isAntisym⊆ₑ X Y X⊆Y Y⊆X = equivFun (EmbeddingIP X Y) (X⊆Y , Y⊆X)
+
+isTrans⊆ₑ : {A : Type ℓ}
+            (X : Embedding A ℓ')
+            (Y : Embedding A ℓ'')
+            (Z : Embedding A ℓ''')
+          → X ⊆ₑ Y
+          → Y ⊆ₑ Z
+          → X ⊆ₑ Z
+isTrans⊆ₑ X Y Z X⊆Y Y⊆Z x = (Y⊆Z x) ∘ (X⊆Y x)
+
+_∩ₑ_ : {A : Type ℓ}
+       (X : Embedding A ℓ')
+       (Y : Embedding A ℓ'')
+     → Embedding A (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+_∩ₑ_ {A = A} X Y = (Σ[ x ∈ A ] x ∈ₑ X × x ∈ₑ Y) ,
+                    EmbeddingΣProp λ x → isProp× (isProp∈ₑ x X)
+                                                 (isProp∈ₑ x Y)
+
+_∪ₑ_ : {A : Type ℓ}
+       (X : Embedding A ℓ')
+       (Y : Embedding A ℓ'')
+     → Embedding A (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+_∪ₑ_ {A = A} X Y = (Σ[ x ∈ A ] ∥ (x ∈ₑ X) ⊎ (x ∈ₑ Y) ∥₁) ,
+                    EmbeddingΣProp λ _ → squash₁
+
+⋂ₑ_ : {A : Type ℓ}
+      {I : Type ℓ'}
+      (P : I → Embedding A ℓ'')
+     → Embedding A (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+⋂ₑ_ {A = A} P = (Σ[ x ∈ A ] (∀ i → x ∈ₑ P i)) ,
+                EmbeddingΣProp λ x → isPropΠ λ i → isProp∈ₑ x (P i)
+
+⋃ₑ_ : {A : Type ℓ}
+      {I : Type ℓ'}
+      (P : I → Embedding A ℓ'')
+    → Embedding A (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+⋃ₑ_ {A = A} {I = I} P = (Σ[ x ∈ A ] (∃[ i ∈ I ] x ∈ₑ P i)) ,
+                        EmbeddingΣProp λ _ → squash₁
diff --git a/Cubical/Functions/Image.agda b/Cubical/Functions/Image.agda
index d975748b03..42cb61ebce 100644
--- a/Cubical/Functions/Image.agda
+++ b/Cubical/Functions/Image.agda
@@ -30,12 +30,7 @@ module _ (f : A → B) where
   Image = Σ[ y ∈ B ] isInImage y
 
   imageInclusion : Image ↪ B
-  imageInclusion = fst ,
-    hasPropFibers→isEmbedding {f = fst}
-      λ y → isOfHLevelRetractFromIso 1 (ϕ y) isPropPropTrunc
-      where
-        ϕ : (y : B) → Iso _ _
-        ϕ y = invIso (fiberProjIso B isInImage y)
+  imageInclusion = EmbeddingΣProp isPropIsInImage
 
   restrictToImage : A → Image
   restrictToImage x = (f x) , ∣ x , refl ∣₁
diff --git a/Cubical/Functions/Preimage.agda b/Cubical/Functions/Preimage.agda
new file mode 100644
index 0000000000..cdb81437af
--- /dev/null
+++ b/Cubical/Functions/Preimage.agda
@@ -0,0 +1,58 @@
+{-# OPTIONS --safe #-}
+module Cubical.Functions.Preimage where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Equiv.Fiberwise
+open import Cubical.Foundations.Powerset
+
+open import Cubical.Functions.Embedding
+open import Cubical.Functions.Image
+open import Cubical.Functions.Surjection
+
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+private
+  variable
+    ℓ ℓ' : Level
+    A B : Type ℓ
+
+module _ (f : A → B)
+         ((S , (g , emb)) : Embedding B ℓ')
+         where
+           isInPreimage : A → Type _
+           isInPreimage x = isInImage g (f x)
+
+           isPropIsInPreimage : ∀ x → isProp (isInPreimage x)
+           isPropIsInPreimage x = isPropIsInImage g (f x)
+
+           Preimage : Type _
+           Preimage = Σ[ x ∈ A ] isInPreimage x
+
+           preimageInclusion : Preimage ↪ A
+           preimageInclusion = EmbeddingΣProp isPropIsInPreimage
+
+           restrictToPreimage : Preimage → S
+           restrictToPreimage (x , im) = lemma (f x) im .fst
+             where lemma : ∀ y → isInImage g y
+                         → fiber g y
+                   lemma y = ∥₁.rec (isEmbedding→hasPropFibers emb y) λ fib → fib
+
+-- Some notation
+_⃖_ : (A → B) → (Embedding B ℓ') → Embedding A _
+f ⃖ S = Preimage f S , preimageInclusion f S
+
+PreimageOfImage : {A B : Type ℓ}
+                  (f : A → B)
+                → Preimage f (Image f , imageInclusion f) ≡ A
+PreimageOfImage {A = A} {B = B} f = isoToPath is
+  where is : Iso (Preimage f (Image f , imageInclusion f)) A
+        Iso.fun is = fst
+        Iso.inv is a = a , ∣ ((f a) , ∣ a , refl ∣₁) , refl ∣₁
+        Iso.rightInv is x = refl
+        Iso.leftInv is  x = Σ≡Prop (isPropIsInPreimage f (Image f , imageInclusion f)) refl
diff --git a/Cubical/HITs/CauchyReals/Base.agda b/Cubical/HITs/CauchyReals/Base.agda
index 387d29eaf2..af62ea23da 100644
--- a/Cubical/HITs/CauchyReals/Base.agda
+++ b/Cubical/HITs/CauchyReals/Base.agda
@@ -85,7 +85,7 @@ record Elimℝ {ℓ} {ℓ'} (A : ℝ → Type ℓ)
   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)
+             (∀ δ ε → B {x δ} {x ε} (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'
diff --git a/Cubical/HITs/CauchyReals/Bisect.agda b/Cubical/HITs/CauchyReals/Bisect.agda
new file mode 100644
index 0000000000..eac34c7f56
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Bisect.agda
@@ -0,0 +1,1338 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Bisect 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.Foundations.Powerset
+open import Cubical.Foundations.Structure
+
+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
+open import Cubical.HITs.CauchyReals.Sequence
+
+
+
+<^n : ∀ N n → N ℕ.< n →
+        ([ 1 / 2 ] ℚ^ⁿ n) ℚ.< ([ 1 / 2 ] ℚ^ⁿ N)
+<^n N zero x = ⊥.rec (ℕ.¬-<-zero x)
+<^n zero (suc zero) x = ℚ.decℚ<? {[ 1 / 2 ] ℚ.· 1} {1}
+<^n zero (suc (suc n)) x = ℚ.isTrans<
+  (([ 1 / 2 ] ℚ^ⁿ (suc n)) ℚ.· [ 1 / 2 ] )
+  (([ 1 / 2 ] ℚ^ⁿ n) ℚ.· [ 1 / 2 ])
+  _
+  (ℚ.<-·o _ _ [ 1 / 2 ] (ℚ.decℚ<? {0} {[ 1 / 2 ]})
+    (<^n n (suc n) ℕ.≤-refl))
+  (<^n zero (suc n) (ℕ.suc-≤-suc ℕ.zero-≤))
+<^n (suc N) (suc n) x =
+ ℚ.<-·o _ _ [ 1 / 2 ] (ℚ.decℚ<? {0} {[ 1 / 2 ]})
+   (<^n N n (ℕ.predℕ-≤-predℕ x))
+
+
+
+Lipschitz-ℚ→ℝℙ< : ℚ₊ → (P : ℙ ℝ) → (∀ x → rat x ∈ P  → ℝ) → Type
+Lipschitz-ℚ→ℝℙ< L P f = ∀ q q∈ r r∈ → r ℚ.< q →
+     absᵣ (f q q∈ -ᵣ f r r∈)
+     ≤ᵣ rat (fst L ℚ.·  (q ℚ.- r) )
+
+
+Lipschitz-ℚ→ℝℙ<→Lipschitz-ℚ→ℝℙ : ∀ L P f →
+ Lipschitz-ℚ→ℝℙ< L P f → Lipschitz-ℚ→ℝℙ L P f
+Lipschitz-ℚ→ℝℙ<→Lipschitz-ℚ→ℝℙ L P f X = (flip ∘
+  flip (ℚ.elimBy≡⊎<
+    (λ x y X →
+       λ x∈ y∈ ε u → isTrans≡<ᵣ _ _ _ (minusComm-absᵣ _ _)
+         (X y∈ x∈ ε (subst (ℚ._< (fst ε)) (ℚ.absComm- _ _) u)) )
+    (λ _ _ _ ε _ → isTrans≡<ᵣ _ _ _
+      (cong absᵣ (𝐑'.+InvR' _ _
+        (cong (f _) (∈-isProp P _ _ _))))
+     (isTrans≡<ᵣ _ _ _ (absᵣ-rat 0) (<ℚ→<ᵣ 0 _ $ ℚ.0<ℚ₊ (L ℚ₊· ε))))
+    λ x y x₁ y₁ r∈ ε u → isTrans≤<ᵣ _ _ _
+     (X y y₁ x r∈ x₁)
+        (<ℚ→<ᵣ _ _  (ℚ.<-o· _ _ (fst L) (ℚ.0<ℚ₊ L)
+          (subst (ℚ._< fst ε) (ℚ.absPos _ ((ℚ.-< _ _ x₁))) u)) )))
+
+Lipschitz-ℝ→ℝℙ : ℚ₊ → (P : ℙ ℝ) → (∀ x → x ∈ P  → ℝ) → Type
+Lipschitz-ℝ→ℝℙ L P f =
+    (∀ u u∈ v v∈ → (ε : ℚ₊) →
+        u ∼[ ε  ] v → f u u∈ ∼[ L ℚ₊· ε  ] f v v∈)
+
+
+Lipschitz-ℚ→ℝ' : ℚ₊ → (ℚ → ℝ) → Type
+Lipschitz-ℚ→ℝ' L f =
+  ∀ q r →  absᵣ (f q -ᵣ f r) ≤ᵣ rat (fst L ℚ.· ℚ.abs (q ℚ.- r))
+
+
+-- TODO, relevant is propably lim≤rat→∼
+-- ≤≃∀< : ∀ a b → (a ≤ᵣ b) ≃ (∀ x → x <ᵣ a → x <ᵣ b )
+-- ≤≃∀< a b = propBiimpl→Equiv (isSetℝ _ _) (isPropΠ2 λ _ _ → squash₁)
+--   (λ a≤b x x<a → isTrans<≤ᵣ _ _ _ x<a a≤b)
+--     λ X → {!!}
+
+
+Lipschitz-ℚ→ℝ'→Lipschitz-ℚ→ℝ : ∀ L f →
+      Lipschitz-ℚ→ℝ' L f → Lipschitz-ℚ→ℝ L f
+Lipschitz-ℚ→ℝ'→Lipschitz-ℚ→ℝ L f lf q r ε -ε<q-r q-r<ε =
+  invEq (∼≃abs<ε _ _ _)
+   (isTrans≤<ᵣ _ _ _ (lf q r)
+     (<ℚ→<ᵣ _ _ (ℚ.<-o· _ _ _ (ℚ.0<ℚ₊ L) (
+       (ℚ.absFrom<×< (fst ε) (q ℚ.- r) -ε<q-r q-r<ε)))))
+
+
+Lipschitz-ℝ→ℝ' : ℚ₊ → (ℝ → ℝ) → Type
+Lipschitz-ℝ→ℝ' L f =
+  ∀ u v →
+    absᵣ (f u -ᵣ f v) ≤ᵣ rat (fst L) ·ᵣ absᵣ (u -ᵣ v)
+
+-- Lipschitz-ℝ→ℝ→Lipschitz-ℝ→ℝ' : ∀ L f →
+--       Lipschitz-ℝ→ℝ L f → Lipschitz-ℝ→ℝ' L f
+-- Lipschitz-ℝ→ℝ→Lipschitz-ℝ→ℝ' = {!!}
+
+Invlipschitz-ℚ→ℚℙ : ℚ₊ → (P : ℙ ℚ) → (∀ x → x ∈ P  → ℚ) → Type
+Invlipschitz-ℚ→ℚℙ K P f =
+  (∀ q q∈ r r∈ → (ε : ℚ₊) →
+        ℚ.abs' (f q q∈ ℚ.- f r r∈) ℚ.< (fst ε)
+     → ℚ.abs' (q ℚ.- r) ℚ.< fst (K ℚ₊· ε ) )
+
+Invlipschitz-ℝ→ℝ : ℚ₊ → (∀ x → ℝ) → Type
+Invlipschitz-ℝ→ℝ K f =
+    (∀ u v → (ε : ℚ₊) →
+        f u  ∼[ ε ] f v → u ∼[ K ℚ₊· ε  ] v)
+
+Invlipschitz-ℝ→ℝ→injective : ∀ K f → Invlipschitz-ℝ→ℝ K f
+    → ∀ x y → f x ≡ f y → x ≡ y
+Invlipschitz-ℝ→ℝ→injective K f il x y =
+ fst (∼≃≡ _ _) ∘
+   (λ p ε → subst∼ (ℚ.y·[x/y] K (fst ε))
+     (il x y ((invℚ₊ K) ℚ₊· ε) (p (invℚ₊ K ℚ₊· ε))))
+   ∘S invEq (∼≃≡ _ _)
+
+Invlipschitz-ℚ→ℚ : ℚ₊ → (∀ x → ℚ) → Type
+Invlipschitz-ℚ→ℚ K f =
+  (∀ q r → (ε : ℚ₊) →
+        ℚ.abs' (f q ℚ.- f r) ℚ.< (fst ε)
+     → ℚ.abs' (q ℚ.- r) ℚ.< fst (K ℚ₊· ε) )
+
+
+Invlipschitz-ℚ→ℚ' : ℚ₊ → (ℚ → ℚ) → Type
+Invlipschitz-ℚ→ℚ' K f =
+  (∀ q r →
+     ℚ.abs' (q ℚ.- r) ℚ.≤ fst K ℚ.· ℚ.abs' (f q ℚ.- f r))
+
+Invlipschitz-ℝ→ℝ' : ℚ₊ → (ℝ → ℝ) → Type
+Invlipschitz-ℝ→ℝ' K f =
+    (∀ u v →
+        absᵣ (u -ᵣ v) ≤ᵣ rat (fst K) ·ᵣ absᵣ (f u -ᵣ f v))
+
+
+Invlipschitz-ℚ→ℚ→Invlipschitz-ℚ→ℚ' : ∀ K f →
+  Invlipschitz-ℚ→ℚ K f → Invlipschitz-ℚ→ℚ' K f
+Invlipschitz-ℚ→ℚ→Invlipschitz-ℚ→ℚ' K f X q r =
+ ℚ.≮→≥ _ _ λ x →
+
+   let x* : ℚ.abs' (f q ℚ.- f r) ℚ.<
+            fst (invℚ₊ K) ℚ.·  ℚ.abs' (q ℚ.- r)
+       x* = subst (ℚ._< fst (invℚ₊ K) ℚ.· ℚ.abs' (q ℚ.- r))
+              (ℚ.[y·x]/y K _) (ℚ.<-o· _ _ (fst (invℚ₊ K))
+               (ℚ.0<ℚ₊ ((invℚ₊ K))) x)
+       z = X q r ((invℚ₊ K) ℚ₊·
+                     (_ , ℚ.<→0< _ (ℚ.isTrans≤< 0 _ _
+                        (
+                         (subst2 (ℚ._≤_)
+                           (ℚ.·AnnihilR _)
+                         (cong (fst K ℚ.·_) (ℚ.abs'≡abs _)) -- (ℚ.abs'≡abs _)
+                          (ℚ.≤-o· _ _ (fst K) (ℚ.0≤ℚ₊ K) (ℚ.0≤abs _)))) x))) x*
+   in ⊥.rec (ℚ.isIrrefl< (ℚ.abs' (q ℚ.- r))
+         (subst (ℚ.abs' (q ℚ.- r) ℚ.<_) (ℚ.y·[x/y] K _) z))
+
+Invlipschitz-ℚ→ℚ'→Invlipschitz-ℚ→ℚ : ∀ K f →
+  Invlipschitz-ℚ→ℚ' K f → Invlipschitz-ℚ→ℚ K f
+Invlipschitz-ℚ→ℚ'→Invlipschitz-ℚ→ℚ K f X q r ε fq-fr<ε =
+  ℚ.isTrans≤< _ _ _ (X q r) (ℚ.<-o· _ _ (fst K) (ℚ.0<ℚ₊ K)
+             fq-fr<ε)
+
+
+Invlipschitz-ℚ→ℚℙ'< : ℚ₊ → (P : ℙ ℚ) → (∀ x → x ∈ P  → ℚ) → Type
+Invlipschitz-ℚ→ℚℙ'< K P f =
+  (∀ q q∈ r r∈  → r ℚ.< q →
+      (q ℚ.- r) ℚ.≤ fst K ℚ.· ℚ.abs' (f q q∈ ℚ.- f r r∈))
+
+
+Invlipschitz-ℚ→ℚℙ'<→Invlipschitz-ℚ→ℚℙ : ∀ K P f →
+  Invlipschitz-ℚ→ℚℙ'< K P f → Invlipschitz-ℚ→ℚℙ K P f
+Invlipschitz-ℚ→ℚℙ'<→Invlipschitz-ℚ→ℚℙ K P f X = flip ∘
+  flip (ℚ.elimBy≡⊎<
+    ((λ x y X →
+       λ x∈ y∈ ε u → ℚ.isTrans≤< _ _ _
+        (ℚ.≡Weaken≤ _ _ (ℚ.abs'Comm- x y))
+         ((X y∈ x∈ ε ((subst (ℚ._< (fst ε))
+          (ℚ.abs'Comm- (f x x∈) (f y y∈)) u)))) ))
+    (λ x _ _ ε _ → subst (ℚ._< fst (K ℚ₊· ε))
+      (cong ℚ.abs' (sym (ℚ.+InvR x))) (ℚ.0<ℚ₊ (K ℚ₊· ε)))
+    λ x y x<y y∈  x∈ ε u →
+      ℚ.isTrans≤< _ _ _
+        (ℚ.≡Weaken≤ _ _ (sym (ℚ.abs'≡abs _) ∙ ℚ.absPos _ (ℚ.-< _ _ x<y) ))
+       (ℚ.isTrans≤< _ _ _
+        (X y y∈ x x∈  x<y) (ℚ.<-o· _ _ (fst K) (ℚ.0<ℚ₊ K) u)))
+
+
+Invlipschitz-ℝ→ℝ'→Invlipschitz-ℝ→ℝ : ∀ K f →
+  Invlipschitz-ℝ→ℝ' K f → Invlipschitz-ℝ→ℝ K f
+Invlipschitz-ℝ→ℝ'→Invlipschitz-ℝ→ℝ K f X u v ε fu∼fv =
+ let y = fst (∼≃abs<ε _ _ _) fu∼fv
+     y'' = isTrans≤<ᵣ _ _ _ (X u v) (<ᵣ-o·ᵣ _ _ (ℚ₊→ℝ₊ K) y )
+ in invEq (∼≃abs<ε _ _ _)
+       (isTrans<≡ᵣ _ _ _ y'' (sym (rat·ᵣrat _ _)))
+
+Invlipschitz-ℝ→ℝℙ : ℚ₊ → (P : ℙ ℝ) → (∀ x → x ∈ P  → ℝ) → Type
+Invlipschitz-ℝ→ℝℙ K P f =
+    (∀ u u∈ v v∈ → (ε : ℚ₊) →
+        f u u∈ ∼[ ε ] f v v∈ → u ∼[ K ℚ₊· ε  ] v)
+
+
+
+
+ointervalℙ⊆intervalℙ : ∀ a b → ointervalℙ a b ⊆ intervalℙ a b
+ointervalℙ⊆intervalℙ a b x (<x  , x<) = <ᵣWeaken≤ᵣ _ _ <x , <ᵣWeaken≤ᵣ _ _ x<
+
+
+openIintervalℙ : ∀ a b → ⟨ openPred (ointervalℙ a b)  ⟩
+openIintervalℙ a b = ∩-openPred _ _ (openPred< a) (openPred> b)
+
+
+isIncrasingℙ : (P : ℙ ℚ) → (∀ x → x ∈ P → ℚ) → Type₀
+isIncrasingℙ P f = ∀ x x∈ y y∈ → x ℚ.< y → f x x∈ ℚ.< f y y∈
+
+isNondecrasingℙ : (P : ℙ ℚ) → (∀ x → x ∈ P → ℚ) → Type₀
+isNondecrasingℙ P f = ∀ x x∈ y y∈ → x ℚ.≤ y → f x x∈ ℚ.≤ f y y∈
+
+isIncrasingℙ→injective : (P : ℙ ℚ) → (f : ∀ x → x ∈ P → ℚ) →
+                          isIncrasingℙ P f →
+                          ∀ x x∈ x' x'∈
+                            → f x x∈ ≡ f x' x'∈ → x ≡ x'
+isIncrasingℙ→injective P f incrF x x∈ x' x'∈ =
+  ⊎.rec const (⊎.rec (w x x∈ x' x'∈) ((sym ∘_) ∘ (_∘ sym) ∘ w x' x'∈ x x∈))
+    (ℚ.≡⊎# x x')
+
+ where
+ w : ∀ x x∈ x' x'∈  → x ℚ.< x' → f x x∈ ≡ f x' x'∈ → x ≡ x'
+ w x x∈ x' x'∈ x<x' p =
+  ⊥.rec (ℚ.isIrrefl# _
+    (inl (subst (ℚ._< f x' x'∈) p (incrF x x∈ x' x'∈ x<x'))))
+
+ℚisIncrasing→injective : (f : ℚ → ℚ) →
+                            (∀ x x' → x ℚ.< x' → f x ℚ.< f x')
+
+                            → ∀ x x' → f x ≡ f x' → x ≡ x'
+ℚisIncrasing→injective f incrF x x' =
+    ⊎.rec const (⊎.rec (w x x') ((sym ∘_) ∘ (_∘ sym) ∘ w x' x))
+    (ℚ.≡⊎# x x')
+
+ where
+ w : ∀ x x' → x ℚ.< x' → f x ≡ f x' → x ≡ x'
+ w x x' x<x' p =
+  ⊥.rec (ℚ.isIrrefl# _
+    (inl (subst (ℚ._< f x') p (incrF x x' x<x'))))
+
+
+-- isIncrasing→injectiveℝ : ∀ f → IsContinuous f  →
+--      isIncrasing f →
+--       ∀ x x' → f x ≡ f x' → x ≡ x'
+
+-- isIncrasing→injectiveℝ f fC incrF x x' p =
+--  eqℝ _ _ λ ε → invEq (∼≃abs<ε _ _ _) {!!}
+
+isIncrasingℙ→isNondecrasingℙ : ∀ P f
+               → isIncrasingℙ P f
+               → isNondecrasingℙ P f
+isIncrasingℙ→isNondecrasingℙ P f incF x x∈ y y∈ =
+  ⊎.rec (ℚ.≡Weaken≤ _ _ ∘ cong (uncurry f) ∘ Σ≡Prop (∈-isProp _))
+   (ℚ.<Weaken≤ _ _ ∘ incF _ _ _ _) ∘ ℚ.≤→≡⊎< _ _
+
+ℚisIncrasing : (ℚ → ℚ) → Type₀
+ℚisIncrasing f = ∀ x y →  x ℚ.< y → f x ℚ.< f y
+
+
+elimInClamps : ∀ {ℓ} {P : ℚ → Type ℓ} → ∀ L L' → L ℚ.≤ L' →
+     (∀ x → x ∈ ℚintervalℙ L L' → P x) →
+     ∀ x → P (ℚ.clamp L L' x)
+elimInClamps L L' L≤L' X x = X _ (clam∈ℚintervalℙ L L' L≤L' x)
+
+elimInClampsᵣ : ∀ {ℓ} {P : ℝ → Type ℓ} → ∀ L L' →
+     (∀ x → P (clampᵣ L L' x)) →
+     (∀ x → x ∈ intervalℙ L L' → P x)
+
+elimInClampsᵣ {P = P} L L' X x x∈ =
+  subst P (sym (∈ℚintervalℙ→clampᵣ≡ _ _ _ x∈)) (X x)
+
+elimFromClampsᵣ : ∀ {ℓ} {P : ℝ → Type ℓ} → ∀ L L' → L ≤ᵣ L' →
+     (∀ x → x ∈ intervalℙ L L' → P x) →
+     (∀ x → P (clampᵣ L L' x))
+
+elimFromClampsᵣ {P = P} L L' L≤L' X x =
+  X (clampᵣ L L' x) (clampᵣ∈ℚintervalℙ _ _ L≤L' x)
+
+
+elimInClamps2 : ∀ {ℓ} {P : ℚ → ℚ → Type ℓ} → ∀ L L' → L ℚ.≤ L' →
+     (∀ x y → x ∈ ℚintervalℙ L L' → y ∈ ℚintervalℙ L L' → P x y) →
+     ∀ x y → P (ℚ.clamp L L' x) (ℚ.clamp L L' y)
+elimInClamps2 L L' L≤L' X x y =
+  X _ _ (clam∈ℚintervalℙ L L' L≤L' x) (clam∈ℚintervalℙ L L' L≤L' y)
+
+elimInClamps2ᵣ : ∀ {ℓ} {P : ℝ → ℝ → Type ℓ} → ∀ L L' → L ≤ᵣ L' →
+     (∀ x y → x ∈ intervalℙ L L' → y ∈ intervalℙ L L' → P x y) →
+     ∀ x y → P (clampᵣ L L' x) (clampᵣ L L' y)
+elimInClamps2ᵣ L L' L≤L' X x y =
+  X _ _ (clampᵣ∈ℚintervalℙ L L' L≤L' x) (clampᵣ∈ℚintervalℙ L L' L≤L' y)
+
+
+cont-f∈ : ∀ (f : ℝ → ℝ) → IsContinuous f
+          → ∀ a b → (a ℚ.≤ b) → ∀ a' b' → a' ≤ᵣ b'
+          → (∀ x → rat x ∈ intervalℙ (rat a) (rat b)
+                 → f (rat x) ∈ intervalℙ a' b')
+          → ∀ x → x ∈ intervalℙ (rat a) (rat b) → f x ∈ intervalℙ a' b'
+cont-f∈ f fc a b a≤b a' b' a'≤b' X = elimInClampsᵣ (rat a) (rat b)
+  λ x → ≡clampᵣ→∈intervalℙ a' b' a'≤b'
+    (f (clampᵣ (rat a)  (rat b) x))
+      ((≡Continuous _ _
+          (IsContinuous∘ _ _ fc (IsContinuousClamp (rat a)  (rat b)))
+        (IsContinuous∘ _ _ (IsContinuousClamp a' b')
+          (IsContinuous∘ _ _ fc (IsContinuousClamp (rat a)  (rat b))))
+         (elimInClamps {P = λ (r : ℚ) →
+                   f (rat r) ≡ (clampᵣ a' b' (f (rat r)))}
+           a b a≤b λ r → ∈ℚintervalℙ→clampᵣ≡ a' b' (f (rat r))
+                 ∘S X r
+                 ∘S ∈ℚintervalℙ→∈intervalℙ a b r  )
+         ) _)
+
+
+
+-- pre-^ⁿ-Monotone⁻¹ : ∀ {x y : ℝ} (n : ℕ)
+--  → 0 ≤ᵣ x → 0 ≤ᵣ y →
+--   x -ᵣ (x ^ⁿ (suc n)) ≤ᵣ y -ᵣ (y ^ⁿ (suc n))
+-- pre-^ⁿ-Monotone⁻¹ {x} {y} n =
+--   ≤Cont₂Pos {λ x y → x -ᵣ (x ^ⁿ (suc n))} {λ x y → y -ᵣ (y ^ⁿ (suc n))}
+--    {!!} {!!}
+--     (ℚ.elimBy≤
+--       z
+--       {!!}
+--      )
+--      -- (λ u u' 0≤u 0≤u' → {!ℚ^ⁿ-Monotone⁻¹ {u} {u'} (suc n) ? 0≤u 0≤u' !} )
+--     x y
+--  where
+--  z : (x₁ y₁ : ℚ) →
+--        (0 ℚ.≤ x₁ →
+--         0 ℚ.≤ y₁ →
+--         rat x₁ -ᵣ (rat x₁ ^ⁿ suc n) ≤ᵣ rat y₁ -ᵣ (rat y₁ ^ⁿ suc n)) →
+--        0 ℚ.≤ y₁ →
+--        0 ℚ.≤ x₁ →
+--        rat y₁ -ᵣ (rat y₁ ^ⁿ suc n) ≤ᵣ rat x₁ -ᵣ (rat x₁ ^ⁿ suc n)
+--  z = {!!}
+
+
+-- -- ^ⁿ-Monotone⁻¹ : ∀ {x y : ℝ} (n : ℕ)
+-- --  → 0 ≤ᵣ x → 0 ≤ᵣ y  → (x ^ⁿ (suc n)) ≤ᵣ (y ^ⁿ (suc n)) → x ≤ᵣ y
+-- -- ^ⁿ-Monotone⁻¹ n 0≤x 0≤y xⁿ≤yⁿ = {!!}
+
+-- -- --  in {!zz!}
+-- -- --  -- ^ⁿ-Monotone⁻¹ n 0≤x 0<y z
+
+opaque
+ unfolding absᵣ -ᵣ_
+ fromLipInvLip' : ∀ K L (f : ℚ → ℚ)
+                  → (fl : Lipschitz-ℚ→ℝ L (rat ∘ f))
+                  → Invlipschitz-ℚ→ℚ' K f
+                  → Invlipschitz-ℝ→ℝ' K
+                       (fst (fromLipschitz L ((rat ∘ f) , fl)))
+ fromLipInvLip' K L f fl il =
+        ≤Cont₂ (cont∘₂ IsContinuousAbsᵣ
+                 (cont₂∘ (contNE₂ sumR)
+                  IsContinuousId IsContinuous-ᵣ ))
+                 (cont∘₂ (IsContinuous∘ _ _ (IsContinuous·ᵣL _)
+                    IsContinuousAbsᵣ)
+                  (cont₂∘ ((cont₂∘ (contNE₂ sumR)
+                  IsContinuousId IsContinuous-ᵣ ))
+                   cf cf))
+                 λ u u' →
+          isTrans≤≡ᵣ _ _ _ (≤ℚ→≤ᵣ _ _ (il u u'))
+           (rat·ᵣrat _ _)
+  where
+  cf : IsContinuous (fst ( (fromLipschitz L ((rat ∘ f) , fl))))
+  cf = Lipschitz→IsContinuous L _
+         (snd (fromLipschitz L ((rat ∘ f) , fl)))
+
+
+
+fromLipInvLip : ∀ K L (f : ℚ → ℚ)
+                 → (fl : Lipschitz-ℚ→ℝ L (rat ∘ f))
+                 → Invlipschitz-ℚ→ℚ K f
+                 → Invlipschitz-ℝ→ℝ K
+                      (fst (fromLipschitz L ((rat ∘ f) , fl)))
+fromLipInvLip K L f fl =
+    Invlipschitz-ℝ→ℝ'→Invlipschitz-ℝ→ℝ K _
+  ∘S fromLipInvLip' K L f fl
+  ∘S Invlipschitz-ℚ→ℚ→Invlipschitz-ℚ→ℚ' K f
+
+extend-Bilipshitz : ∀ L K → fst (invℚ₊ K) ℚ.≤ fst L → ∀ a b → (a ℚ.≤ b) →
+            (f : ∀ q → q ∈ ℚintervalℙ a b → ℚ) →
+             isIncrasingℙ _ f →
+        Lipschitz-ℚ→ℝℙ L (intervalℙ (rat a) (rat b))
+          ((λ x x₁ → rat (f x (∈intervalℙ→∈ℚintervalℙ a b x x₁)))) →
+        Invlipschitz-ℚ→ℚℙ K (ℚintervalℙ a b) f →
+        Σ[ f' ∈ (ℚ → ℚ) ]
+          Lipschitz-ℚ→ℝ L (rat ∘ f')
+           × Invlipschitz-ℚ→ℚ K f' × (∀ x x∈ → f' x ≡ f x x∈ )
+extend-Bilipshitz L K 1/K≤L a b a≤b f monF li il =
+  fst ∘ f' , li' , (ili' ,
+    snd ∘ f')
+ where
+
+ α : ℚ₊
+ α = /2₊ (ℚ.invℚ₊ K ℚ₊+ L)
+
+ α≤L : fst α ℚ.≤ fst L
+ α≤L = ℚ.isTrans≤ _ _ _ (ℚ.≤-·o _ _ [ 1 / 2 ]
+         (ℚ.decℚ≤? {0} {[ 1 / 2 ]})
+          (ℚ.≤-+o (fst (invℚ₊ K)) (fst L) (fst L) 1/K≤L))
+          (ℚ.≡Weaken≤ _ _ (
+            cong (ℚ._· [ 1 / 2 ])
+              (cong₂ ℚ._+_ (sym (ℚ.·IdL _)) (sym (ℚ.·IdL _))
+              ∙ sym (ℚ.·DistR+ 1 1 (fst L)))
+              ∙∙ ℚ.·Comm _ _ ∙∙ ℚ.[y·x]/y 2 (fst L)))
+
+ 1/K≤α : fst (ℚ.invℚ₊ K) ℚ.≤  fst α
+ 1/K≤α = ℚ.isTrans≤ _ _ _
+   (ℚ.≡Weaken≤ _ _ ((sym (ℚ.[y·x]/y 2 (fst (invℚ₊ K))) ∙ ℚ.·Comm _ _)
+     ∙ cong (ℚ._· [ 1 / 2 ]) ((ℚ.·DistR+ 1 1 (fst (invℚ₊ K))) ∙
+      cong₂ ℚ._+_ (ℚ.·IdL _) (ℚ.·IdL _) )))
+    (ℚ.≤-·o _ _ [ 1 / 2 ] (ℚ.decℚ≤? {0} {[ 1 / 2 ]})
+     ((ℚ.≤-o+ (fst (invℚ₊ K)) (fst L) (fst (invℚ₊ K)) 1/K≤L)))
+
+ g : ℚ → ℚ → ℚ
+ g Δ x = fst α ℚ.· (x ℚ.- Δ)
+
+
+ f≡ : ∀ {x x' x∈ x'∈} → x ≡ x' → f x x∈ ≡ f x' x'∈
+ f≡ p = (cong (uncurry f) (Σ≡Prop (∈-isProp (ℚintervalℙ a b))
+              (p)))
+
+
+ f' : ∀ x → Σ ℚ λ f'x → ∀ x∈ →  f'x ≡ f x x∈
+ f' x = (g a x ℚ.- g a x') ℚ.+ (f x' x'∈)
+   , f'=f
+  where
+   x' = ℚ.clamp a b x
+   x'∈ = clam∈ℚintervalℙ a b a≤b x
+
+   f'=f : (x∈ : x ∈ ℚintervalℙ a b) →
+            (g a x ℚ.- g a x') ℚ.+ f x' x'∈ ≡ f x x∈
+   f'=f x∈ =
+    let p = ∈ℚintervalℙ→clam≡ a b x x∈
+    in cong₂ ℚ._+_ (cong ((ℚ._- (g a x')) ∘S g a) p ∙
+            ℚ.+InvR _)
+         (f≡ (sym p))
+         ∙ ℚ.+IdL _
+
+
+ monF' : ℚisIncrasing (fst ∘ f')
+ monF' = ℚ.elim≤By+ h
+  where
+  h : (x : ℚ) (ε : ℚ₊) (x< : x ℚ.< x ℚ.+ fst ε) → _
+  h x ε x< = ℚ.<minus→< _ _ (subst (0 ℚ.<_)
+                  (sym (lem--069 {fst α} {δ = a}))
+                    (h' (ℚ.≤→≡⊎< x' x+Δ' x'≤x+Δ')))
+
+
+
+   where
+
+   x<x+Δ = (ℚ.<+ℚ₊' x x ε (ℚ.isRefl≤ x))
+   x' = ℚ.clamp a b x
+   x'∈ = clam∈ℚintervalℙ a b a≤b x
+
+   x+Δ' = ℚ.clamp a b (x ℚ.+ fst ε)
+   x+Δ'∈ = clam∈ℚintervalℙ a b a≤b (x ℚ.+ fst ε)
+
+   x'≤x+Δ' : x' ℚ.≤ x+Δ'
+   x'≤x+Δ' = ℚ.≤MonotoneClamp a b _ _ (ℚ.<Weaken≤ _ _ x<x+Δ)
+
+   h' : (x' ≡ x+Δ') ⊎ (x' ℚ.< x+Δ') →
+           0 ℚ.< fst α ℚ.· (fst ε ℚ.- (x+Δ' ℚ.- x')) ℚ.+
+            (f x+Δ' x+Δ'∈  ℚ.- f x' x'∈)
+   h' (inl x) = subst (0 ℚ.<_)
+                    (cong (fst α ℚ.·_) (sym (𝐐'.+IdR' _ _
+                     (cong (ℚ.-_) (𝐐'.+InvR' _ _ (sym x))))) ∙
+                      sym (𝐐'.+IdR' _ _
+                        (𝐐'.+InvR' _ _ (f≡ (sym x)))))
+                 (ℚ.0<ℚ₊ (α ℚ₊· ε))
+   h' (inr xx) = ℚ.≤<Monotone+ 0 _ 0
+     (f x+Δ' x+Δ'∈  ℚ.- f x' x'∈)
+     (subst (ℚ._≤ fst α ℚ.· (fst ε ℚ.- (x+Δ' ℚ.- x')))
+          (ℚ.·AnnihilR (fst α))
+
+           (ℚ.≤-o· _ _ _ (ℚ.0≤ℚ₊ α)
+               (ℚ.-≤ _ _
+                 (subst ((x+Δ' ℚ.- x') ℚ.≤_)
+                    lem--063 (ℚ.clampDiff a b x (x ℚ.+ fst ε)
+                     (ℚ.<Weaken≤ _ _ x<x+Δ ))))))
+      ((ℚ.<→<minus (f x' x'∈) (f x+Δ' x+Δ'∈)
+          (monF x' x'∈ x+Δ' x+Δ'∈ xx)))
+
+
+ li<' : ∀ q Δ ε (u : ℚ.- fst ε ℚ.< (q ℚ.- (q ℚ.+ fst Δ)))
+          (v : (q ℚ.- (q ℚ.+ fst Δ)) ℚ.< fst ε) →
+        absᵣ
+        ((rat ∘ (λ x → fst (f' x))) (q ℚ.+ fst Δ) +ᵣ
+         -ᵣ (rat ∘ (λ x → fst (f' x))) q)
+        <ᵣ rat (fst (L ℚ₊· ε))
+ li<' q Δ ε u v = isTrans≡<ᵣ _ _ _
+   (absᵣPos _ (x<y→0<y-x _ _ (
+     (<ℚ→<ᵣ _ _ (monF' _ _ q<q+Δ))))
+      ∙ -ᵣ-rat₂ _ _ ∙ cong rat (lem--069 {fst α})
+      )
+   (isTrans≤<ᵣ (rat ((fst α ℚ.· (fst Δ ℚ.- (q+Δ' ℚ.- q'))) ℚ.+
+             (((f q+Δ' q+Δ'∈) ℚ.- (f q' q'∈)))))
+             (rat ((ℚ.abs' ((f q+Δ' _) ℚ.- (f q' _)))
+               ℚ.+ (fst L ℚ.· (fst Δ ℚ.- (q+Δ' ℚ.- q'))))) _
+              (≤ℚ→≤ᵣ _ _ zz )
+               (isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _) ∙ cong (_+ᵣ rat (fst L ℚ.· (fst Δ ℚ.- (q+Δ' ℚ.- q'))))
+                 (sym (absᵣ-rat' _) ∙ cong absᵣ (sym (-ᵣ-rat₂ _ _)))) h')) --
+  where
+    Δ<ε : fst Δ ℚ.< fst ε
+    Δ<ε = ℚ.minus-<' (fst ε) (fst Δ)
+            (subst ((ℚ.- (fst ε)) ℚ.<_) lem--072 u)
+
+    q<q+Δ = (ℚ.<+ℚ₊' q q Δ (ℚ.isRefl≤ q))
+    q' = ℚ.clamp a b q
+    q'∈ = clam∈ℚintervalℙ a b a≤b q
+
+    q+Δ' = ℚ.clamp a b (q ℚ.+ fst Δ)
+    q+Δ'∈ = clam∈ℚintervalℙ a b a≤b (q ℚ.+ fst Δ)
+
+    q'≤q+Δ' : q' ℚ.≤ q+Δ'
+    q'≤q+Δ' = ℚ.≤MonotoneClamp a b _ _ (ℚ.<Weaken≤ _ _ q<q+Δ)
+
+    zz : ((fst α ℚ.· (fst Δ ℚ.- (q+Δ' ℚ.- q'))) ℚ.+
+             (((f q+Δ' q+Δ'∈) ℚ.- (f q' q'∈))))
+             ℚ.≤
+             ((ℚ.abs' ((f q+Δ' _) ℚ.- (f q' _)))
+               ℚ.+ (fst L ℚ.· (fst Δ ℚ.- (q+Δ' ℚ.- q'))))
+    zz = subst2 ℚ._≤_ (ℚ.+Comm _ _)
+          (cong (ℚ._+ (fst L ℚ.· (fst Δ ℚ.- (q+Δ' ℚ.- q'))))
+             (sym (ℚ.absNonNeg _ (ℚ.≤→<minus _ _
+                  (((isIncrasingℙ→isNondecrasingℙ _ f monF)
+                      _ q'∈ _ q+Δ'∈ q'≤q+Δ' ))
+                  )) ∙
+                   cong ℚ.abs (cong₂ ℚ._-_ (f≡ refl) (f≡ refl))
+                     ∙ (ℚ.abs'≡abs _)))
+            (ℚ.≤-o+ _ _ _ (ℚ.≤-·o _ _ ((fst Δ ℚ.- (q+Δ' ℚ.- q')))
+              (ℚ.≤→<minus _ _
+                (ℚ.isTrans≤ _ _ _ (ℚ.clampDiff a b q (q ℚ.+ fst Δ)
+                  (ℚ.<Weaken≤ _ _ q<q+Δ))
+                 (ℚ.≡Weaken≤ _ _ lem--063))) α≤L))
+
+
+    h' = a<b-c⇒a+c<b _ (rat (fst L ℚ.· fst ε))
+             (rat (fst L ℚ.· ((fst Δ ℚ.- (q+Δ' ℚ.- q'))))) (isTrans<≡ᵣ _ _ _
+          (li q+Δ' (∈ℚintervalℙ→∈intervalℙ _ _ _ q+Δ'∈)
+            q' (∈ℚintervalℙ→∈intervalℙ _ _ _ q'∈)
+            (fst ε ℚ.- (fst Δ ℚ.- (q+Δ' ℚ.- q')) ,
+               ℚ.<→0< _ (ℚ.-< _ _
+                 (ℚ.isTrans≤< _ _ _
+                   (subst ((fst Δ ℚ.- (q+Δ' ℚ.- q')) ℚ.≤_)
+                     (ℚ.+IdR _ ∙ sym lem--063)
+                      (ℚ.≤-o+ _ 0 (fst Δ)
+                       (ℚ.minus-≤ 0 _ (ℚ.≤→<minus _ _ q'≤q+Δ'))))
+                    ((ℚ.minus-<' _ _ (subst ((ℚ.- (fst ε)) ℚ.<_)
+                     (sym (ℚ.-[x-y]≡y-x _ _)) u))))))
+                      (subst2 ℚ._<_ (ℚ.+IdL _ ∙
+                        sym (ℚ.absNonNeg _ (ℚ.≤→<minus _ _
+                         q'≤q+Δ')))
+                        (sym (ℚ.+Assoc _ _ _) ∙
+                         cong (fst ε ℚ.+_) (sym (ℚ.-Distr' _ _)))
+                       (ℚ.<-+o 0 (fst ε ℚ.- fst Δ) (q+Δ' ℚ.- q')
+                        (ℚ.<→<minus _ _ Δ<ε)))
+                   )
+                   ((cong rat (ℚ.·DistL+ (fst L) (fst ε)
+                  (ℚ.- (fst Δ ℚ.- (q+Δ' ℚ.- q')))) ∙
+                 sym (+ᵣ-rat _ _) ∙ cong (rat (fst L ℚ.· fst ε) +ᵣ_)
+                  (cong rat (sym lem--070) ∙ sym (-ᵣ-rat _))))
+
+                  )
+
+ li' : Lipschitz-ℚ→ℝ L (rat ∘ (λ x → fst (f' x)))
+ li' = ℚ.elimBy≡⊎<'
+  (λ q r X ε u v → sym∼ _ _ _
+    (X ε (subst (ℚ.- fst ε ℚ.<_) (ℚ.-[x-y]≡y-x _ _) (ℚ.minus-< _ _ v))
+          (subst2 ℚ._<_ (ℚ.-[x-y]≡y-x _ _)
+            (ℚ.-Invol _) (ℚ.minus-< _ _ u))))
+  (λ q ε _ _ → refl∼ _ _)
+  λ q Δ ε u v → sym∼ _ _ _ (invEq (∼≃abs<ε _ _ _)
+    (li<' q Δ ε u v))
+
+ ili'< : ∀ x (Δ : ℚ₊) →
+                  fst Δ ℚ.≤
+                  fst K  ℚ.· ℚ.abs' (fst (f' x) ℚ.- fst (f' (x ℚ.+ fst Δ)))
+ ili'< x Δ =
+   ℚ.isTrans≤ _ _ _
+   (ℚ.isTrans≤ _ _ _ (ℚ.isTrans≤ _ _ _
+     (ℚ.isTrans≤ _ _ _ (ℚ.≡Weaken≤ _ _ (sym (ℚ.+IdR (fst Δ))))
+       (ℚ.≤-o+ _ _ _ (ℚ.≤→<minus _ ((fst K) ℚ.· (f x+Δ' x+Δ'∈ ℚ.- f x' x'∈))
+        ((⊎.rec h≡ h< (ℚ.≤→≡⊎< x' x+Δ' x'≤x+Δ'))))))
+      (ℚ.≡Weaken≤ _ _
+          (cong (fst Δ ℚ.+_) (ℚ.+Comm _ _) ∙ (ℚ.+Assoc _ _ _) ∙ (cong (ℚ._+
+             ((fst K) ℚ.· (f x+Δ' x+Δ'∈ ℚ.- f x' x'∈))) (sym (ℚ.y·[x/y] K _)))
+           ∙  sym (ℚ.·DistL+ (fst K) _ _)))
+       )
+      (ℚ.≤-o· _ _ (fst K) (ℚ.0≤ℚ₊ K)
+         (ℚ.isTrans≤ _ _ _ (ℚ.≤-+o _ _
+          (f x+Δ' x+Δ'∈ ℚ.- f x' x'∈) (ℚ.≤-·o _ _ (fst Δ ℚ.- (x+Δ' ℚ.- x'))
+          (ℚ.≤→<minus _ _
+           (ℚ.isTrans≤ _ _ _
+             (ℚ.clampDiff a b x (x ℚ.+ (fst Δ)) (ℚ.<Weaken≤ _ _ x<x+Δ))
+              (ℚ.≡Weaken≤ _ _ lem--063)))
+            1/K≤α)) (ℚ.≤abs _))))
+
+   (ℚ.≡Weaken≤ _ _ (cong (fst K  ℚ.·_) (cong (ℚ.abs) (sym lem-f') ∙
+       ℚ.absComm- _ _ ∙ ℚ.abs'≡abs _)))
+  where
+
+  x<x+Δ = (ℚ.<+ℚ₊' x x Δ (ℚ.isRefl≤ x))
+  x' = ℚ.clamp a b x
+  x'∈ = clam∈ℚintervalℙ a b a≤b x
+
+  x+Δ' = ℚ.clamp a b (x ℚ.+ fst Δ)
+  x+Δ'∈ = clam∈ℚintervalℙ a b a≤b (x ℚ.+ fst Δ)
+
+  x'≤x+Δ' : x' ℚ.≤ x+Δ'
+  x'≤x+Δ' = ℚ.≤MonotoneClamp a b _ _ (ℚ.<Weaken≤ _ _ x<x+Δ)
+
+
+  lem-f' : (fst (f' (x ℚ.+ fst Δ)) ℚ.- fst (f' x))
+        ≡ (fst α) ℚ.· (fst Δ ℚ.- (x+Δ' ℚ.- x'))
+            ℚ.+ (f x+Δ' x+Δ'∈ ℚ.- f x' x'∈)
+  lem-f' = lem--069 {fst α}
+
+  from-il = il x+Δ' x+Δ'∈ x' x'∈
+
+  h< : x' ℚ.< x+Δ' → (x+Δ' ℚ.- x') ℚ.≤ fst K ℚ.· (f x+Δ' x+Δ'∈ ℚ.- f x' x'∈)
+  h< p = ℚ.≮→≥ _ _
+    λ p' →
+     let pp = from-il (invℚ₊ K ℚ₊· (ℚ.<→ℚ₊ _ _ p))
+           (ℚ.isTrans≤< _ _ _
+              (ℚ.≡Weaken≤ _ _ ((sym (ℚ.abs'≡abs _) ∙ (ℚ.absPos _
+               (ℚ.<→<minus _ _  (monF _ x'∈ _ x+Δ'∈ p ))))
+               ∙ sym (ℚ.[y·x]/y K _)))
+               (ℚ.<-o· _ _ (fst (invℚ₊ K)) ((ℚ.0<ℚ₊ (invℚ₊ K))) p'))
+     in ℚ.isIrrefl<  _ (ℚ.isTrans<≤ _ _ _ pp
+         (ℚ.≡Weaken≤ _ _
+           ((ℚ.y·[x/y] K _) ∙
+            (sym (ℚ.absPos _ (ℚ.<→<minus _ _ p)) ∙ ℚ.abs'≡abs _))))
+
+  h≡ : x' ≡ x+Δ' → (x+Δ' ℚ.- x') ℚ.≤ fst K ℚ.· (f x+Δ' x+Δ'∈ ℚ.- f x' x'∈)
+
+  h≡ p = ℚ.≡Weaken≤ _ _ (𝐐'.+InvR' _ _ (sym p) ∙
+           sym (ℚ.·AnnihilR (fst K)) ∙
+            cong (fst K ℚ.·_) (sym (𝐐'.+InvR' _ _ (f≡ (sym p)))))
+
+ ili' : Invlipschitz-ℚ→ℚ K (λ x → fst (f' x))
+ ili' = ℚ.elimBy≡⊎<'
+   (λ x y X ε u → ℚ.isTrans≤< _ _ _
+       (ℚ.≡Weaken≤ _ _ (ℚ.abs'Comm- _ _))
+        (X ε (ℚ.isTrans≤< _ _ _
+       (ℚ.≡Weaken≤ _ _ (ℚ.abs'Comm- _ _)) u)) )
+   (λ x ε _ →
+       ℚ.isTrans≤< (ℚ.abs' (x ℚ.- x)) 0 _
+       (ℚ.≡Weaken≤ _ _ (cong ℚ.abs' (ℚ.+InvR x))) (ℚ.0<ℚ₊ (K ℚ₊· ε))
+       )
+   λ x Δ ε f'x-f'[x+Δ]<ε →
+     let z = ili'< x Δ
+     in ℚ.isTrans≤< (ℚ.abs' (x ℚ.- (x ℚ.+ fst Δ)))
+           ((fst K) ℚ.· ℚ.abs' (fst (f' x) ℚ.- fst (f' (x ℚ.+ fst Δ))))
+             _ (ℚ.isTrans≤ _ _ _
+               (ℚ.≡Weaken≤ _ _ (sym (ℚ.abs'≡abs _)  ∙
+                     ℚ.absComm- _ _
+                  ∙∙ cong ℚ.abs lem--063 ∙∙ -- (cong ℚ.abs' lem--072)
+                    ℚ.absPos _ (ℚ.0<ℚ₊ Δ) ) )
+               z )
+            (ℚ.<-o· _ _ (fst K) (ℚ.0<ℚ₊ K) (f'x-f'[x+Δ]<ε)) --ili'<
+
+<ᵣ-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)
+
+
+fromLip-Invlipschitz-ℚ→ℚ' : ∀ L K f
+           → (l : Lipschitz-ℚ→ℝ L (rat ∘ f))
+           → Invlipschitz-ℚ→ℚ K f
+           → Invlipschitz-ℝ→ℝ K
+             (fst (fromLipschitz L ((rat ∘ f) , l)))
+fromLip-Invlipschitz-ℚ→ℚ' L K f l il u v ε <ε =
+  PT.rec (isProp∼ _ _ _)
+    (λ (ε' , fu-fv<ε' , ε'<ε) →
+     let ε-ε' = (ℚ.<→ℚ₊ ε' (fst ε) (<ᵣ→<ℚ _ _ ε'<ε))
+         δ = /4₊ ε-ε'
+         ε'₊ : ℚ₊
+         ε'₊ = (ε' , ℚ.<→0< ε' (<ᵣ→<ℚ _ _
+                  (isTrans≤<ᵣ 0 _ (rat ε') (0≤absᵣ _) fu-fv<ε')) )
+         δ/L⊔K = (ℚ.min₊ K (invℚ₊ L)) ℚ.ℚ₊· δ
+
+
+     in PT.rec2 (isProp∼ _ _ _)
+          (λ (u' , u<u' , u'<u+δ/L⊔K)
+             (v' , v<v' , v'<v+δ/L⊔K) →
+               let L·δ/L⊔K≤δ : rat (fst (L ℚ₊· δ/L⊔K)) ≤ᵣ rat (fst δ)
+                   L·δ/L⊔K≤δ =
+                     isTrans≤≡ᵣ _ _ _
+                        ((≤ℚ→≤ᵣ _ _
+                            ((ℚ.≤-o· _ _ _
+                             (ℚ.0≤ℚ₊ L)
+                               (ℚ.≤-·o _ _ _ ((ℚ.0≤ℚ₊ δ))
+                                 (ℚ.min≤' _ _))))))
+                      (cong rat (ℚ.y·[x/y] L (fst δ)))
+                   δ/L⊔K≤K·δ : rat (fst δ/L⊔K) ≤ᵣ rat (fst K ℚ.· fst δ)
+                   δ/L⊔K≤K·δ = ≤ℚ→≤ᵣ _ _
+                                  (ℚ.≤-·o (fst (ℚ.min₊ K (invℚ₊ L)))
+                                    _ _ ((ℚ.0≤ℚ₊ δ)) (ℚ.min≤ _ _))
+                   ∣'u-u∣<δ/L⊔K = (isTrans≡<ᵣ _ _ _
+                               (absᵣPos _ (x<y→0<y-x _ _ u<u'))
+                               (a<c+b⇒a-c<b _ _ _ u'<u+δ/L⊔K))
+                   ∣'v-v∣<δ/L⊔K = (isTrans≡<ᵣ _ _ _
+                               (absᵣPos _ (x<y→0<y-x _ _ v<v'))
+                               (a<c+b⇒a-c<b _ _ _ v'<v+δ/L⊔K))
+                   lU : absᵣ (rat (f u') -ᵣ f𝕣 u)
+                           <ᵣ rat (fst δ)
+                   lU = isTrans<≤ᵣ _ _ _
+                          (fst (∼≃abs<ε _ _ _) $ lf (rat u') u δ/L⊔K
+                         (invEq (∼≃abs<ε _ _ _)
+                            ∣'u-u∣<δ/L⊔K))
+                                L·δ/L⊔K≤δ
+                   lV : absᵣ (f𝕣 v -ᵣ rat (f v'))
+                           <ᵣ rat (fst δ)
+                   lV = isTrans≡<ᵣ _ _ _ (minusComm-absᵣ _ _) (isTrans<≤ᵣ _ _ _
+                          (fst (∼≃abs<ε _ _ _) $ lf (rat v') v δ/L⊔K
+                         (invEq (∼≃abs<ε _ _ _)
+                            ∣'v-v∣<δ/L⊔K))
+                                L·δ/L⊔K≤δ)
+                   z< : absᵣ (rat (f u') -ᵣ rat (f v'))
+
+                         <ᵣ (rat (fst δ) +ᵣ rat (fst δ)) +ᵣ rat ε'
+                   z< = isTrans<ᵣ _ _ _ (a-b<c⇒a<c+b _ _ _
+                          (isTrans≤<ᵣ _ _ _
+                            (absᵣ-triangle-minus (rat (f u') -ᵣ rat (f v')) _)
+                           (isTrans≤<ᵣ _ _ _
+                           (isTrans≡≤ᵣ _ _ _
+                             (cong absᵣ (L𝐑.lem--067
+                                {rat (f u')} {rat (f v')}))
+                               (absᵣ-triangle _ _))
+                             (<ᵣMonotone+ᵣ _ _ _ _ lU lV))))
+                               (<ᵣ-o+ _ _ _ fu-fv<ε')
+
+
+                   z : ℚ.abs' (u' ℚ.- v') ℚ.<
+                         fst K ℚ.· ((fst δ ℚ.+ fst δ) ℚ.+ ε')
+                   z = il u' v' ((δ ℚ.ℚ₊+ δ) ℚ.ℚ₊+ ε'₊) (<ᵣ→<ℚ (ℚ.abs' ((f u') ℚ.+ (ℚ.- f v')))
+                      _
+                     (isTrans≡<ᵣ _ _ _ (sym (absᵣ-rat' _) ∙ cong absᵣ (sym (-ᵣ-rat₂ _ _)))
+                      (isTrans<≡ᵣ _ _ _ z<
+                        (cong (_+ᵣ rat ε')
+                          (+ᵣ-rat _ _)
+                         ∙ +ᵣ-rat _ _)))
+                     )
+                     -- z<
+                   zz : absᵣ (u +ᵣ -ᵣ v -ᵣ (rat u' -ᵣ rat v'))
+                          ≤ᵣ (rat ((fst K ℚ.· fst δ)
+                               ℚ.+ (fst K ℚ.· fst δ)))
+                   zz = isTrans≤ᵣ _ _ _
+                          (isTrans≡≤ᵣ _ _ _
+                            (cong absᵣ (L𝐑.lem--067 {u} {v} {rat u'} {rat v'} ))
+                             (absᵣ-triangle _ _))
+                             (isTrans≤≡ᵣ _ _ _
+                              (≤ᵣMonotone+ᵣ _ _ _ _
+                            (isTrans≤ᵣ _ _ _
+                              (isTrans≡≤ᵣ _ _ _ (minusComm-absᵣ _ _)
+                                 (<ᵣWeaken≤ᵣ _ _ ∣'u-u∣<δ/L⊔K)) δ/L⊔K≤K·δ)
+                            (isTrans≤ᵣ _ _ _
+                              (<ᵣWeaken≤ᵣ _ _ ∣'v-v∣<δ/L⊔K) δ/L⊔K≤K·δ))
+                              (+ᵣ-rat _ _))
+
+               in invEq (∼≃abs<ε _ _ _)
+                    (isTrans<≡ᵣ _ (rat ((((fst K ℚ.· fst δ)
+                               ℚ.+ (fst K ℚ.· fst δ)))
+                                      ℚ.+ (fst K ℚ.· ((fst δ ℚ.+ fst δ) ℚ.+ ε')))) _
+                      (isTrans≤<ᵣ _ _ _
+                        ((absᵣ-triangle' (u +ᵣ -ᵣ v) ((rat u' -ᵣ (rat v')))))
+                        (isTrans<≡ᵣ _ _ _ (≤<ᵣMonotone+ᵣ _ (rat ((fst K ℚ.· fst δ)
+                               ℚ.+ (fst K ℚ.· fst δ)))
+                             _ _ zz (isTrans≡<ᵣ _ _ _
+                              (cong absᵣ (-ᵣ-rat₂ _ _) ∙  (absᵣ-rat' _)) (<ℚ→<ᵣ _ _ z)))
+                              (+ᵣ-rat _ _)))
+                      (cong rat
+                        (cong (ℚ._+ (fst K ℚ.· ((fst δ ℚ.+ fst δ) ℚ.+ ε')))
+                            (sym (ℚ.·DistL+ _ _ _)) ∙
+                           (sym (ℚ.·DistL+ _ _ _)) ∙
+                            cong (fst K ℚ.·_)
+                             (ℚ.+Assoc _ _ _ ∙
+                              cong (ℚ._+ ε')
+                               (cong₂ ℚ._+_ (cong fst (ℚ./4₊+/4₊≡/2₊ ε-ε'))
+                                 ((cong fst (ℚ./4₊+/4₊≡/2₊ ε-ε'))) ∙
+                                  ℚ.ε/2+ε/2≡ε _) ∙ lem--00)))))
+          (denseℚinℝ u (u +ᵣ rat (fst (δ/L⊔K)))
+            ( isTrans≡<ᵣ _ _ _ (sym (+IdR u))
+               (<ᵣ-o+ _ _ u (<ℚ→<ᵣ 0 _ (ℚ.0<ℚ₊ δ/L⊔K)) )))
+          (denseℚinℝ v (v +ᵣ rat (fst (δ/L⊔K)))
+             (( isTrans≡<ᵣ _ _ _ (sym (+IdR v))
+               (<ᵣ-o+ _ _ v (<ℚ→<ᵣ 0 _ (ℚ.0<ℚ₊ δ/L⊔K)) )))))
+    (denseℚinℝ _ _ (fst (∼≃abs<ε _ _ _) <ε))
+
+
+ where
+  lf = snd (fromLipschitz L ((rat ∘ f) , l))
+
+  f𝕣 = fst (fromLipschitz L ((rat ∘ f) , l))
+
+
+
+
+fromBilpschitz-ℚ→ℚℙ : ∀ L K → fst (invℚ₊ K) ℚ.≤ fst L →  ∀ a b → (a<b : a ℚ.< b) → ∀ f
+           → isIncrasingℙ _ f
+           → (l : Lipschitz-ℚ→ℝℙ L (intervalℙ (rat a) (rat b))
+              (λ x x₁ → rat (f x (∈intervalℙ→∈ℚintervalℙ a b x x₁))))
+           → Invlipschitz-ℚ→ℚℙ K (ℚintervalℙ a b) f
+           →  Σ[ g ∈ (∀ x → x ∈ _  → ℝ ) ]
+                 ((Lipschitz-ℝ→ℝℙ L (intervalℙ (rat a) (rat b))) g
+                  × Invlipschitz-ℝ→ℝℙ K (intervalℙ (rat a) (rat b)) g
+                   × (∀ x x∈ ratx∈ → g (rat x) ratx∈ ≡ rat (f x x∈)))
+
+fromBilpschitz-ℚ→ℚℙ L K 1/K≤L a b a<b f incrF l il =
+  let (f' , f'-l , f'-il , f≡f') =
+         extend-Bilipshitz L K 1/K≤L a b (ℚ.<Weaken≤ _ _ a<b)
+            f incrF l il
+
+      (f'' , f''-l) = fromLipschitz L ((rat ∘ f') , f'-l)
+      f''-il = fromLip-Invlipschitz-ℚ→ℚ' L K f' f'-l f'-il
+  in (λ x _ → f'' x) ,
+       (λ u u∈ v v∈ ε x → f''-l u v ε x) ,
+       (λ u u∈ v v∈ ε x → f''-il u v ε x) ,
+       λ x x∈ ratx∈ → cong rat (f≡f' _ _)
+
+open ℚ.HLP
+
+
+map-fromCauchySequence' : ∀ L s ics f → (Lipschitz-ℝ→ℝ L f) →
+    Σ _ λ icsf →
+      f (fromCauchySequence' s ics) ≡ fromCauchySequence' (f ∘ s) icsf
+map-fromCauchySequence' L s ics f lf =
+  icsf , sym (fromCauchySequence'≡ _ _ _ h)
+
+ where
+
+ icsf : IsCauchySequence' (f ∘ s)
+ icsf ε = map-snd
+   (λ X m n <m <n →
+      let z = X m n <m <n
+          z' = lf (s n) (s m) (invℚ₊ L ℚ₊· ε)
+                (invEq (∼≃abs<ε _ _ _) z)
+       in fst (∼≃abs<ε _ _ ε) (subst∼ (ℚ.y·[x/y] L (fst ε)) z'))
+   (ics (invℚ₊ L ℚ₊· ε))
+
+ h : (ε : ℚ₊) →
+       ∃-syntax ℕ
+       (λ N →
+          (n : ℕ) →
+          N ℕ.< n →
+          absᵣ ((f ∘ s) n -ᵣ f (fromCauchySequence' s ics)) <ᵣ rat (fst ε))
+ h ε =
+   let (N , X) = ics ((invℚ₊ L ℚ₊· (/4₊ ε)))
+       (N' , X') = icsf (/4₊ ε)
+       midN = suc (ℕ.max N N')
+       midV = f (s midN)
+
+   in ∣ midN , (λ n midN<n →
+        let 3ε/4<ε = subst (ℚ._< (fst ε))
+                 (cong (fst (/4₊ ε) ℚ.+_)
+                   (sym (ℚ.y·[x/y] L _)
+                    ∙ cong (fst L ℚ.·_) (ℚ.·DistL+ _ _ _) ))
+                    distℚ<! ε [ ((ge[ ℚ.[ 1 / 4 ] ]) +ge
+                        (ge[ ℚ.[ 1 / 4 ] ] +ge ge[ ℚ.[ 1 / 4 ] ]))
+                        < ge1 ]
+            z' = invEq (∼≃abs<ε _ _ (/4₊ ε)) (X' ((suc N')) n
+                 (ℕ.<-trans (ℕ.suc-≤-suc ℕ.right-≤-max) midN<n)
+                  ℕ.≤-refl )
+
+            zzzz' =
+                (𝕣-lim-self _ (fromCauchySequence'-isCA s ics)
+                      ((invℚ₊ L ℚ₊· (/4₊ ε))) ( (invℚ₊ L ℚ₊· (/4₊ ε))))
+
+        in fst (∼≃abs<ε _ _ ε)
+             (∼-monotone< 3ε/4<ε
+                (triangle∼ z' (lf _ _ _ zzzz')))) ∣₁
+
+
+
+
+record IsBilipschitz a b  (a<b : a ℚ.< b) f : Type where
+ field
+  incrF : isIncrasingℙ (ℚintervalℙ a b) f
+  L K : ℚ₊
+  1/K≤L : fst (invℚ₊ K) ℚ.≤ fst L
+
+  lipF : Lipschitz-ℚ→ℝℙ L (intervalℙ (rat a) (rat b))
+              (λ x x₁ → rat (f x (∈intervalℙ→∈ℚintervalℙ a b x x₁)))
+  lip⁻¹F : Invlipschitz-ℚ→ℚℙ K (ℚintervalℙ a b) f
+
+ fa = f a (ℚ.isRefl≤ a , ℚ.<Weaken≤ a b a<b)
+ fb = f b (ℚ.<Weaken≤ a b a<b , ℚ.isRefl≤ b)
+
+ fa<fb : fa ℚ.< fb
+ fa<fb = incrF
+   a (ℚ.isRefl≤ a , ℚ.<Weaken≤ a b a<b)
+   b (ℚ.<Weaken≤ a b a<b , ℚ.isRefl≤ b)
+   a<b
+
+ a≤b = ℚ.<Weaken≤ _ _ a<b
+ Δ₀ = b ℚ.- a
+ Δ₀₊ = ℚ.<→ℚ₊ _ _ a<b
+
+
+ ebl = extend-Bilipshitz
+   L K  1/K≤L a b (ℚ.<Weaken≤ a b a<b) f incrF lipF lip⁻¹F
+
+ fl-ebl = fromLipschitz L ((rat ∘ (fst ebl)) , fst (snd ebl))
+
+ fl-ebl∈ : ∀ y →
+             y ∈ ℚintervalℙ a b →
+              fst fl-ebl ((rat y)) ∈ intervalℙ (rat fa) (rat fb)
+ fl-ebl∈ y y∈ = isTrans≤≡ᵣ _ _ _ (≤ℚ→≤ᵣ _ _ z)
+       (sym p) , isTrans≡≤ᵣ _ _ _ p  (≤ℚ→≤ᵣ _ _ z')
+  where
+   p = (cong rat (ebl .snd .snd .snd y y∈))
+   z = (isIncrasingℙ→isNondecrasingℙ _ _ incrF)
+          a ((ℚ.isRefl≤ _) , a≤b) y y∈ (fst y∈)
+
+
+   z' = (isIncrasingℙ→isNondecrasingℙ _ _ incrF)
+          y y∈ b (a≤b , (ℚ.isRefl≤ _)) (snd y∈)
+
+ record Step (y Δ : ℚ) : Type where
+  field
+   a' b' : ℚ
+   a'<b' : a' ℚ.< b'
+   b'-a'≤Δ : b' ℚ.- a' ℚ.≤ Δ
+   a'∈ : a' ∈ ℚintervalℙ a b
+   b'∈ : b' ∈ ℚintervalℙ a b
+   a'≤ : f a' a'∈ ℚ.≤ y
+   ≤b' : y ℚ.≤ f b' b'∈
+
+  a'≤b' : a' ℚ.≤ b'
+  a'≤b' = ℚ.<Weaken≤ _ _ a'<b'
+
+
+  mid : ℚ
+  mid = b' ℚ.· [ 1 / 2 ] ℚ.+ a' ℚ.· [ 1 / 2 ]
+
+  p = ℚ.<-·o _ _ [ 1 / 2 ] (ℚ.decℚ<? {0} {[ 1 / 2 ]}) a'<b'
+
+  a'<mid : a' ℚ.< mid
+  a'<mid = ℚ.isTrans≤< _ _ _
+    (ℚ.≡Weaken≤ _ _ (sym (ℚ.·IdR a') ∙ cong (a' ℚ.·_) ℚ.decℚ? ∙
+      ℚ.·DistL+ a' _ _))
+    (ℚ.<-+o _ _ (a' ℚ.· [ 1 / 2 ]) p)
+
+  mid<b' : mid ℚ.< b'
+  mid<b' = ℚ.isTrans<≤ _ _ _
+    (ℚ.<-o+ _ _ (b' ℚ.· [ 1 / 2 ]) p)
+    (ℚ.≡Weaken≤ _ _ (sym (ℚ.·DistL+ b' _ _) ∙ cong (b' ℚ.·_) ℚ.decℚ? ∙
+      ℚ.·IdR b'))
+  mid∈ : mid ∈ ℚintervalℙ a b
+  mid∈ = ℚ.isTrans≤ _ _ _ (fst (a'∈)) (ℚ.<Weaken≤ _ _ a'<mid) ,
+          ℚ.isTrans≤ _ _ _ (ℚ.<Weaken≤ _ _ mid<b') (snd b'∈)
+
+  fMid = f mid mid∈
+
+
+ record Step⊃Step {y Δ ΔS : _} (s : Step y Δ) (sS : Step y ΔS) : Type where
+
+  field
+   a'≤a'S : Step.a' s ℚ.≤ Step.a' sS
+   bS≤b' : Step.b' sS ℚ.≤ Step.b' s
+   -- distA' : (Step.a' sS) ℚ.≤ Δ ℚ.· [ 1 / 2 ] ℚ.+ (Step.a' s)
+
+ module _ (y : ℚ) (y∈ : rat y ∈ (intervalℙ (rat fa) (rat fb))) where
+
+  step0 : Step y Δ₀
+  step0 .Step.a' = a
+  step0 .Step.b' = b
+  step0 .Step.a'<b' = a<b
+  step0 .Step.b'-a'≤Δ = ℚ.isRefl≤ _
+  step0 .Step.a'∈ = ℚ.isRefl≤ _  , a≤b
+  step0 .Step.b'∈ = a≤b , (ℚ.isRefl≤ _)
+  step0 .Step.a'≤ = ≤ᵣ→≤ℚ _ _ (fst y∈)
+  step0 .Step.≤b' = ≤ᵣ→≤ℚ _ _ (snd y∈)
+
+  stepS' : ∀ Δ → (s : Step y Δ) → Σ (Step y (Δ ℚ.· [ 1 / 2 ])) (Step⊃Step s)
+  stepS' Δ s = w (ℚ.Dichotomyℚ y fMid)
+   where
+   open Step s
+
+   a'-mid≤Δ/2 : (mid ℚ.- a') ℚ.≤ Δ ℚ.· [ 1 / 2 ]
+   a'-mid≤Δ/2 =
+     ℚ.isTrans≤ _ _ _
+      (ℚ.≡Weaken≤ (mid ℚ.- a') ((b' ℚ.- a') ℚ.· [ 1 / 2 ])
+        (sym (ℚ.+Assoc _ _ _) ∙
+         cong (b' ℚ.· [ 1 / 2 ] ℚ.+_)
+          (cong (a' ℚ.· [ 1 / 2 ] ℚ.+_) (ℚ.·Comm -1 a')
+           ∙ sym (ℚ.·DistL+ a' _ _) ∙
+            ℚ.·Comm _ _ ∙
+             sym (ℚ.·Assoc [ 1 / 2 ] -1 a') ∙  ℚ.·Comm [ 1 / 2 ] _)
+          ∙ sym (ℚ.·DistR+ _ _ _)))
+      (ℚ.≤-·o _ _ _ (ℚ.decℚ≤? {0} {[ 1 / 2 ]}) b'-a'≤Δ)
+
+   w : (y ℚ.≤ fMid) ⊎ (fMid ℚ.< y) → Σ (Step y (Δ ℚ.· [ 1 / 2 ]))
+             (Step⊃Step s)
+   w (inl x) .fst .Step.a' = a'
+   w (inl x) .fst .Step.b' = mid
+   w (inl x) .fst .Step.a'<b' = a'<mid
+   w (inl x) .fst .Step.b'-a'≤Δ = a'-mid≤Δ/2
+   w (inl x) .fst .Step.a'∈ = a'∈
+   w (inl x) .fst .Step.b'∈ = mid∈
+   w (inl x) .fst .Step.a'≤ = a'≤
+   w (inl x) .fst .Step.≤b' = x
+   w (inl x) .snd .Step⊃Step.a'≤a'S = ℚ.isRefl≤ a'
+   w (inl x) .snd .Step⊃Step.bS≤b' = ℚ.<Weaken≤ _ _ mid<b'
+   w (inr x) .fst .Step.a' = mid
+   w (inr x) .fst .Step.b' = b'
+   w (inr x) .fst .Step.a'<b' = mid<b'
+   w (inr x) .fst .Step.b'-a'≤Δ =
+     ℚ.isTrans≤ _ _ _
+        (ℚ.≡Weaken≤ (b' ℚ.- mid)
+                    ((b' ℚ.- a') ℚ.· [ 1 / 2 ])
+                      ((cong (b' ℚ.+_) (ℚ.-Distr _ _ ) ∙
+                       ℚ.+Assoc _ _ _ ∙
+                        cong₂ ℚ._+_
+                        (cong₂ ℚ._+_ (sym (ℚ.·IdR b'))
+                         (ℚ.·Comm -1 _ ∙ sym (ℚ.·Assoc _ _ _))
+                         ∙ sym (ℚ.·DistL+ b' 1 [ -1 / 2 ]))
+                         (ℚ.·Assoc -1 _ _))
+                       ∙ sym (ℚ.·DistR+ _ _ _)))
+          (ℚ.≤-·o _ _ _ (ℚ.decℚ≤? {0} {[ 1 / 2 ]}) b'-a'≤Δ)
+
+   w (inr x) .fst .Step.a'∈ = mid∈
+   w (inr x) .fst .Step.b'∈ = b'∈
+   w (inr x) .fst .Step.a'≤ = ℚ.<Weaken≤ _ _ x
+   w (inr x) .fst .Step.≤b' = ≤b'
+   w (inr x) .snd .Step⊃Step.a'≤a'S = ℚ.<Weaken≤ _ _  a'<mid
+   w (inr x) .snd .Step⊃Step.bS≤b' = ℚ.isRefl≤ b'
+
+  stepS : ∀ Δ → Step y Δ → Step y (Δ ℚ.· [ 1 / 2 ])
+  stepS Δ s = fst (stepS' Δ s)
+
+  ww : ∀ n → Step y (Δ₀ ℚ.· ([ 1 / 2 ] ℚ^ⁿ n))
+  ww zero = subst (Step y) (sym (ℚ.·IdR Δ₀)) step0
+  ww (suc n) = subst (Step y) (sym (ℚ.·Assoc _ _ _)) (stepS _ (ww n))
+
+  s : ℕ → ℚ
+  s = Step.a' ∘ ww
+
+  s' : ℕ → ℚ
+  s' = Step.b' ∘ ww
+
+
+  ss≤-suc : ∀ n (z : Step y (Δ₀ ℚ.· ([ 1 / 2 ] ℚ^ⁿ n))) → Step.a' z ℚ.≤
+      Step.a' (subst (Step y) (sym (ℚ.·Assoc _ _ _)) (stepS
+       (Δ₀ ℚ.· ([ 1 / 2 ] ℚ^ⁿ n)) z))
+  ss≤-suc n z = ℚ.isTrans≤ _ _ _ (Step⊃Step.a'≤a'S (snd (stepS'
+       (Δ₀ ℚ.· ([ 1 / 2 ] ℚ^ⁿ n)) z)))
+         (ℚ.≡Weaken≤ _ _ (sym (transportRefl _)))
+
+  ≤ss'-suc : ∀ n (z : Step y (Δ₀ ℚ.· ([ 1 / 2 ] ℚ^ⁿ n))) →
+       Step.b' (subst (Step y) (sym (ℚ.·Assoc _ _ _)) (stepS
+       (Δ₀ ℚ.· ([ 1 / 2 ] ℚ^ⁿ n)) z))
+      ℚ.≤
+       Step.b' z
+  ≤ss'-suc n z =  ℚ.isTrans≤ _ _ _
+         (ℚ.≡Weaken≤ _ _  (transportRefl _))
+           ((Step⊃Step.bS≤b' (snd (stepS'
+       (Δ₀ ℚ.· ([ 1 / 2 ] ℚ^ⁿ n)) z))))
+  ss≤ : ∀ n m → s n ℚ.≤ s (m ℕ.+ n)
+  ss≤ n zero = ℚ.isRefl≤ _
+  ss≤ n (suc m) = ℚ.isTrans≤ _ _ _ (ss≤ n m) (ss≤-suc (m ℕ.+ n) (ww (m ℕ.+ n)))
+
+  ≤ss' : ∀ n m →  s' (m ℕ.+ n) ℚ.≤ s' n
+  ≤ss' n zero = ℚ.isRefl≤ _
+  ≤ss' n (suc m) = ℚ.isTrans≤ _ _ _
+    (≤ss'-suc (m ℕ.+ n) (ww (m ℕ.+ n))) (≤ss' n m)
+
+
+  ww⊂ : ∀ n m → (s (m ℕ.+ n) ℚ.- s n) ℚ.≤ Δ₀ ℚ.· ([ 1 / 2 ] ℚ^ⁿ n)
+  ww⊂ n m = ℚ.isTrans≤
+    (s (m ℕ.+ n) ℚ.- s n) (s' n ℚ.- s n) _
+      (ℚ.≤-+o (s (m ℕ.+ n)) (s' n) (ℚ.- (s n))
+       (ℚ.isTrans≤ _ _ _ (Step.a'≤b' (ww (m ℕ.+ n))) (≤ss' n m)))
+   (Step.b'-a'≤Δ (ww n))
+
+  www : {ε : ℚ₊} → (Σ[ n ∈ ℕ ] [ 1 / 2 ] ℚ^ⁿ n ℚ.<
+            fst (ε ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b)))
+         → Σ[ N ∈ ℕ ] (∀ m n → N ℕ.< n → N ℕ.< m →
+              absᵣ (rat (s n) -ᵣ rat (s m)) <ᵣ rat (fst ε)   )
+  www (N , P) .fst = N
+  www {ε} (N , P) .snd = ℕ.elimBy≤+
+    (λ n m X m< n< → subst (_<ᵣ (rat (fst ε)))
+      (minusComm-absᵣ (rat (s m)) (rat (s n))) (X n< m<))
+    λ n m p N<n →
+      let P' : Δ₀ ℚ.· ([ 1 / 2 ] ℚ^ⁿ N) ℚ.< fst ε
+          P' = ℚ.isTrans<≤ _ _ (fst ε) (ℚ.<-o· _ _ _ (ℚ.-< a b a<b) P)
+                 (ℚ.≡Weaken≤ _ _
+                    ((cong (fst (ℚ.<→ℚ₊ a b a<b) ℚ.·_) (ℚ.·Comm _ _))
+                     ∙ ℚ.y·[x/y] (ℚ.<→ℚ₊ _ _ a<b) (fst ε)))
+          zz = ℚ.isTrans≤< _ _ _
+                  (ℚ.isTrans≤ _ ((s (m ℕ.+ n)) ℚ.- (s n)) _
+                    (ℚ.≡Weaken≤ _ _ (ℚ.absNonNeg (s (m ℕ.+ n) ℚ.- s n)
+                      (ℚ.-≤ (s n) (s (m ℕ.+ n)) (ss≤ n m))))
+                      (ww⊂ n m))
+                  (ℚ.isTrans< _ (Δ₀ ℚ.· ([ 1 / 2 ] ℚ^ⁿ (N))) _
+                    (ℚ.<-o· _ _ Δ₀ (ℚ.-< a b a<b) (<^n N n N<n)) P')
+      in isTrans≡<ᵣ _ _ _ (cong absᵣ (-ᵣ-rat₂ _ _) ∙ absᵣ-rat _ )
+           (<ℚ→<ᵣ _ _ zz)
+
+  f⁻¹ : ℝ
+  f⁻¹ = fromCauchySequence' (rat ∘ s)
+        λ ε → www {ε} (1/2ⁿ<ε (ε ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b)))
+
+  -- Approx-f⁻¹ :
+
+
+  s~y : (ε : ℚ₊) →
+          ∃-syntax ℕ
+          (λ N →
+             (n : ℕ) →
+             N ℕ.< n →
+             absᵣ ((fst fl-ebl ∘ (λ x → rat (s x))) n -ᵣ rat y) <ᵣ rat (fst ε))
+  s~y ε =
+    let (N , X) = (1/2ⁿ<ε (invℚ₊ (L ℚ₊· Δ₀₊) ℚ₊· ε))
+
+    in ∣ suc N ,
+       (λ { zero x → ⊥.rec (ℕ.¬-<-zero x)
+          ; (suc n) x →
+             let 𝒔 = ww (suc n)
+                 q = fst ((∼≃abs<ε _ _ _)) $
+                     snd fl-ebl (rat (Step.b' 𝒔)) (rat (Step.a' 𝒔))
+                       ((Δ₀₊ ℚ₊· (([ 1 / 2 ] , _) ℚ₊^ⁿ n)))
+                        (invEq (∼≃abs<ε _ _ _)
+                         (isTrans≡<ᵣ _ _ _
+
+                           (cong absᵣ (-ᵣ-rat₂ _ _) ∙ absᵣPos _ (<ℚ→<ᵣ _ _
+                             (ℚ.<→<minus _ _ (Step.a'<b' 𝒔)))
+                            )
+                            (<ℚ→<ᵣ _ _
+                           (ℚ.isTrans≤< _ _ _
+                              (Step.b'-a'≤Δ 𝒔)
+                                 (ℚ.<-o· _ _ Δ₀ (ℚ.0<ℚ₊ Δ₀₊) (<^n _ _ ℕ.≤-refl )))  )))
+             in isTrans<ᵣ _ _ _ (isTrans≤<ᵣ _ _ _
+                   (isTrans≡≤ᵣ _ _ _
+                     (minusComm-absᵣ
+                      ((fst fl-ebl ∘ (λ x → rat (s x))) (suc n))
+                        (rat y) ∙
+                           cong absᵣ (-ᵣ-rat₂ _ _)
+                            ∙ absᵣNonNeg _
+                           (≤ℚ→≤ᵣ _ _ (ℚ.≤→<minus _ _ (
+                               (ℚ.isTrans≤ _ _ _
+                                   (ℚ.≡Weaken≤ _ _
+                                    ((snd (snd (snd ebl)) _ _)) )
+                                    (Step.a'≤ 𝒔))))) ∙
+                                     sym (-ᵣ-rat₂ _ _)
+
+                                    )
+                      (isTrans≤≡ᵣ _ _ _
+                        (≤ᵣ-+o _ _ (-ᵣ fst fl-ebl (rat (s (suc n))))
+                          (isTrans≤≡ᵣ _ _ _
+                            (≤ℚ→≤ᵣ _ _ (Step.≤b' (ww (suc n))))
+                            (cong rat (sym (snd (snd (snd ebl)) _ _)))))
+                            (-ᵣ-rat₂ _ _ ∙ (sym (absᵣPos _
+                         (<ℚ→<ᵣ _ _
+                          (ℚ.<→<minus _ _
+                            (subst2 ℚ._<_ (sym (snd (snd (snd ebl)) _ _))
+                              (sym ((snd (snd (snd ebl)) _ _)))
+                              (incrF _ (Step.a'∈ 𝒔) _
+                               (Step.b'∈ 𝒔)
+                               (Step.a'<b' 𝒔))))))) ∙
+                                cong absᵣ
+                                 (sym (-ᵣ-rat₂ _ _)))
+
+                               ))
+                   q)
+
+                 (isTrans<ᵣ _ _ _
+
+                    (isTrans≡<ᵣ _ _ _ (cong rat (ℚ.·Assoc _ _ _)) (<ℚ→<ᵣ _ _
+                       ( ℚ.<-o· _ _ (fst (L ℚ₊· Δ₀₊))
+                           ((ℚ.0<ℚ₊ (L ℚ₊· Δ₀₊)))
+                            (<^n _ _ (ℕ.pred-≤-pred x)))))
+                    (isTrans<≡ᵣ _ _ _
+                      (<ℚ→<ᵣ _ _ (ℚ.<-o· _ _ (fst (L ℚ₊· Δ₀₊))
+                       (ℚ.0<ℚ₊ (L ℚ₊· Δ₀₊) ) X))
+                        (cong rat (ℚ.y·[x/y] (L ℚ₊· Δ₀₊) (fst ε))))
+                     )}) ∣₁
+
+  f⁻¹∈ : f⁻¹ ∈ intervalℙ (rat a) (rat b)
+  f⁻¹∈ = ((≤lim _ _ _
+           λ δ → ≤ℚ→≤ᵣ _ _ $ fst (Step.a'∈
+            (ww (suc (1/2ⁿ<ε (δ ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b)) .fst))))))
+     , (lim≤ _ _ _
+           λ δ → ≤ℚ→≤ᵣ _ _ $ snd (Step.a'∈
+            (ww (suc (1/2ⁿ<ε (δ ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b)) .fst)))))
+
+
+  f∘f⁻¹ : fst fl-ebl f⁻¹
+      ≡ rat y
+  f∘f⁻¹ = snd (map-fromCauchySequence'
+      L (rat ∘ s)
+        (λ ε → www {ε} (1/2ⁿ<ε (ε ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b))))
+         ( fst fl-ebl) (snd fl-ebl)) ∙
+           fromCauchySequence'≡ _ _ _
+      s~y
+
+
+
+ f⁻¹-L : Lipschitz-ℚ→ℝℙ K (intervalℙ
+                 (rat (f a (ℚ.isRefl≤ _  , ℚ.<Weaken≤ a b a<b)))
+                 (rat (f b (ℚ.<Weaken≤ _ _ a<b , (ℚ.isRefl≤ _))))) f⁻¹
+ f⁻¹-L y y∈ r r∈ ε x =
+   let ilℝ = fst (snd (snd
+        ((fromBilpschitz-ℚ→ℚℙ L K  1/K≤L a b a<b f incrF lipF lip⁻¹F))))
+       z = ilℝ (f⁻¹ y y∈) (f⁻¹∈ y y∈) (f⁻¹ r r∈) (f⁻¹∈ r r∈) ε
+           (invEq (∼≃abs<ε _ _ _)
+             (isTrans≡<ᵣ _ _ _ (cong absᵣ
+               (cong₂ _-ᵣ_  (f∘f⁻¹ y y∈) (f∘f⁻¹ r r∈))
+                    ∙ cong absᵣ (-ᵣ-rat₂ _ _) ∙ absᵣ-rat _
+                    )
+               (<ℚ→<ᵣ (ℚ.abs (y ℚ.- r)) (fst ε) x)))
+   in fst (∼≃abs<ε _ _ _) z
+
+ ext-f⁻¹ = extend-Lipshitzℚ→ℝ K fa fb (ℚ.<Weaken≤ _ _ fa<fb) f⁻¹ f⁻¹-L
+
+ f⁻¹R-L : Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ K)
+ f⁻¹R-L = fromLipschitz K (map-snd fst ext-f⁻¹)
+
+ 𝒇⁻¹ = fst f⁻¹R-L
+ 𝒇 = fst fl-ebl
+
+
+ isCont𝒇 = (Lipschitz→IsContinuous L (fst fl-ebl) (snd fl-ebl))
+ isCont𝒇⁻¹ = (Lipschitz→IsContinuous K (fst f⁻¹R-L) (snd f⁻¹R-L))
+
+ 𝒇∘𝒇⁻¹' : ∀ y
+            → fst fl-ebl (fst f⁻¹R-L (clampᵣ (rat fa) (rat fb) y)) ≡
+               (clampᵣ (rat fa) (rat fb) y)
+ 𝒇∘𝒇⁻¹' = ≡Continuous _ _ (IsContinuous∘ _ _
+        (IsContinuous∘ _ _
+          isCont𝒇
+          isCont𝒇⁻¹)
+       (IsContinuousClamp (rat fa) (rat fb)))
+  (IsContinuousClamp (rat fa) (rat fb))
+    λ r → (cong (fst fl-ebl) (snd (snd ext-f⁻¹) _
+          ((∈ℚintervalℙ→∈intervalℙ _ _ _ (clam∈ℚintervalℙ fa fb
+             (ℚ.<Weaken≤ _ _ fa<fb) r)))))
+         ∙ f∘f⁻¹ _ _
+
+
+ 𝒇∘𝒇⁻¹ : ∀ y → y ∈ intervalℙ (rat fa) (rat fb)
+            → fst fl-ebl (fst f⁻¹R-L y) ≡ y
+ 𝒇∘𝒇⁻¹ = elimInClampsᵣ (rat fa) (rat fb) 𝒇∘𝒇⁻¹'
+
+ invl𝒇 : Invlipschitz-ℝ→ℝ K (fst fl-ebl)
+ invl𝒇 = fromLipInvLip K L (fst ebl) (fst (snd ebl))
+       (fst (snd (snd ebl)))
+
+ inj𝒇 : (x y : ℝ) → fst fl-ebl x ≡ fst fl-ebl y → x ≡ y
+ inj𝒇 = Invlipschitz-ℝ→ℝ→injective K (fst fl-ebl) invl𝒇
+
+
+ 𝒇∈ : ∀ x → x ∈ intervalℙ (rat a) (rat b)
+          →  fl-ebl .fst x ∈ intervalℙ (rat fa) (rat fb)
+ 𝒇∈ = cont-f∈ (fl-ebl .fst) (Lipschitz→IsContinuous L _ (snd fl-ebl))
+         a b a≤b (rat fa) (rat fb)
+          (≤ℚ→≤ᵣ fa fb (ℚ.<Weaken≤ fa fb fa<fb))
+         λ x → fl-ebl∈ x ∘S ∈intervalℙ→∈ℚintervalℙ _ _ x
+
+
+ 𝒇⁻¹∘𝒇' : ∀ y
+            → fst f⁻¹R-L (fst fl-ebl  (clampᵣ (rat a) (rat b) y)) ≡
+               (clampᵣ (rat a) (rat b) y)
+ 𝒇⁻¹∘𝒇' y = inj𝒇 _ _
+    (𝒇∘𝒇⁻¹ (fst fl-ebl  (clampᵣ (rat a) (rat b) y))
+       (𝒇∈ (clampᵣ (rat a) (rat b) y)
+          (clampᵣ∈ℚintervalℙ _ _ (≤ℚ→≤ᵣ _ _ a≤b) y)))
+
+
+ 𝒇⁻¹∘𝒇 : ∀ y →  y ∈ intervalℙ (rat a) (rat b)
+            → fst f⁻¹R-L (fst fl-ebl  y) ≡ y
+ 𝒇⁻¹∘𝒇 = elimInClampsᵣ (rat a) (rat b) 𝒇⁻¹∘𝒇'
+
+
+
+ 𝒇⁻¹∈ : ∀ x → x ∈ intervalℙ (rat fa) (rat fb)
+          →  f⁻¹R-L .fst x ∈ intervalℙ (rat a) (rat b)
+ 𝒇⁻¹∈ =
+    cont-f∈ (f⁻¹R-L .fst) (Lipschitz→IsContinuous K _ (snd f⁻¹R-L))
+         fa fb (ℚ.<Weaken≤ fa fb fa<fb) (rat a) (rat b)
+          (≤ℚ→≤ᵣ a b a≤b)
+         λ r → subst-∈ (intervalℙ (rat a) (rat b))
+           (sym (snd (snd ext-f⁻¹) _ _))
+                 ∘ f⁻¹∈ r
+
+
+
+ ℚApproxℙ-𝒇⁻¹ : ℚApproxℙ (intervalℙ (rat fa) (rat fb))
+                        (intervalℙ (rat a) (rat b)) λ x x∈  →
+                          (𝒇⁻¹ x , 𝒇⁻¹∈ x x∈)
+ ℚApproxℙ-𝒇⁻¹ = _ , (λ q q∈ ε →
+      let z =
+             Step.a'∈
+               (ww q q∈ (suc (1/2ⁿ<ε (ε ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b)) .fst)))
+       in ∈ℚintervalℙ→∈intervalℙ a b _ z)
+   , _ , λ q q∈ → sym (snd (snd ext-f⁻¹) q q∈)
+
+
+ isoF : Iso (Σ _ (_∈ intervalℙ (rat a) (rat b)))
+            (Σ _ (_∈ intervalℙ (rat fa) (rat fb)))
+ isoF .Iso.fun (x , x∈) = 𝒇 x , 𝒇∈ x x∈
+ isoF .Iso.inv (x , x∈) = 𝒇⁻¹ x , 𝒇⁻¹∈ x x∈
+ isoF .Iso.rightInv (x , x∈) =
+   Σ≡Prop (∈-isProp (intervalℙ (rat fa) (rat fb)))
+     (𝒇∘𝒇⁻¹ x x∈)
+ isoF .Iso.leftInv (x , x∈) =
+   Σ≡Prop (∈-isProp (intervalℙ (rat a) (rat b)))
+     (𝒇⁻¹∘𝒇 x x∈)
+
diff --git a/Cubical/HITs/CauchyReals/BisectApprox.agda b/Cubical/HITs/CauchyReals/BisectApprox.agda
new file mode 100644
index 0000000000..a6d93accb7
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/BisectApprox.agda
@@ -0,0 +1,1775 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.BisectApprox where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Equiv.Properties
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+import Cubical.Functions.Logic as L
+open import Cubical.Functions.Embedding
+open import Cubical.Functions.Surjection
+open import Cubical.Foundations.Powerset
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.CartesianKanOps
+
+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.HITs.SetQuotients as SQ hiding (_/_)
+
+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
+open import Cubical.HITs.CauchyReals.Sequence
+open import Cubical.HITs.CauchyReals.Bisect
+open import Cubical.HITs.CauchyReals.Exponentiation
+open import Cubical.HITs.CauchyReals.ExponentiationMore
+
+
+fromLipshitzℚ→ℝℙ→Cont : ∀ L a b
+                       → ∀ f
+                       → Lipschitz-ℝ→ℝℙ L (ointervalℙ a b) f
+                       → IsContinuousWithPred (ointervalℙ a b) f
+fromLipshitzℚ→ℝℙ→Cont L a b f lipF u ε u∈P =
+  ∣ ((ℚ.invℚ₊ L) ℚ₊· ε ) ,
+    (λ v v∈P u∼v →
+      subst∼ (ℚ.y·[x/y] L (fst ε))
+        (lipF u u∈P v v∈P ((invℚ₊ L) ℚ₊· ε) u∼v)) ∣₁
+
+fromLipshitzℚ→ℝℙ→Cont0< : ∀ L
+                       → ∀ f
+                       → Lipschitz-ℝ→ℝℙ L pred0< f
+                       → IsContinuousWithPred pred0< f
+fromLipshitzℚ→ℝℙ→Cont0< L f lipF u ε u∈P =
+  ∣ ((ℚ.invℚ₊ L) ℚ₊· ε ) ,
+    (λ v v∈P u∼v →
+      subst∼ (ℚ.y·[x/y] L (fst ε))
+        (lipF u u∈P v v∈P ((invℚ₊ L) ℚ₊· ε) u∼v)) ∣₁
+
+
+
+[n/m]<1 : ∀ n m → ([ pos n / m ] ℚ.< 1) ≃ (n ℕ.< ℕ₊₁→ℕ m)
+[n/m]<1 n m = subst2Equiv (ℤ._<_) (ℤ.·IdR _)
+        (sym (ℤ.pos·pos _ _) ∙ cong pos (ℕ.·-identityˡ _))
+         ∙ₑ ℤ.pos-<-pos≃ℕ< _ _
+
+<^n' : ∀ N n (q : ℚ₊) → fst q ℚ.< 1 → N ℕ.< n →
+        (fst q ℚ^ⁿ n) ℚ.< (fst q ℚ^ⁿ N)
+<^n' N n q q<1 N<n =
+  let z' = (^ℚ-StrictMonotoneR
+           {ℚ₊→ℝ₊ (invℚ₊ q)}
+             (<ℚ→<ᵣ _ _
+               (fst (ℚ.invℚ₊-<-invℚ₊ q 1) q<1))
+             (fromNat N) (fromNat n)
+               (ℚ.<ℤ→<ℚ _ _ (ℤ.ℕ≤→pos-≤-pos  _ _ N<n)))
+      z = <ᵣ→<ℚ _ _ $ subst2 _<ᵣ_
+          (^ⁿ-ℚ^ⁿ _ _ ∙ cong rat (sym (ℚ.invℚ₊-ℚ^ⁿ _ _)))
+          (^ⁿ-ℚ^ⁿ _ _ ∙ cong rat (sym (ℚ.invℚ₊-ℚ^ⁿ _ _)))
+           z'
+  in invEq (ℚ.invℚ₊-<-invℚ₊ _ _) z
+
+
+1/n-1/sn : ∀ n →  [ pos 1 / 1+ n ] ℚ.- [ pos 1 / 2+ n ] ≡
+                  [ pos 1 / ((1+ n) ·₊₁ (2+ n)) ]
+1/n-1/sn n = eq/ _ _ h
+
+ where
+ h : (ℚ.ℕ₊₁→ℤ (1 ·₊₁ (2+ n)) ℤ.- ℚ.ℕ₊₁→ℤ (1+ n))
+         ℤ.· ℚ.ℕ₊₁→ℤ ((1+ n) ·₊₁ (2+ n)) ≡
+      1 ℤ.· ℚ.ℕ₊₁→ℤ ((1+ n) ·₊₁ (1 ·₊₁ (2+ n)))
+ h = cong₂ (λ u v → v ℤ.· ℚ.ℕ₊₁→ℤ ((1+ n) ·₊₁ u))
+      (sym (·₊₁-identityˡ _))
+      (cong ((ℤ._- ℚ.ℕ₊₁→ℤ (1+ n))) (cong ℚ.ℕ₊₁→ℤ (·₊₁-identityˡ _)
+       ∙  ℤ.+Comm _ _)
+       ∙ ℤ.plusMinus (ℚ.ℕ₊₁→ℤ (1+ n)) 1)
+
+
+apartFrom-Invlipschitz-ℝ→ℝℙ : ∀ K P f →
+    Invlipschitz-ℝ→ℝℙ K P f →
+     (∀ u u∈ v v∈ → (ε : ℚ₊) →
+         rat (fst (K ℚ₊· ε)) ≤ᵣ absᵣ (u -ᵣ v)   →
+           rat (fst ε) ≤ᵣ absᵣ (f u u∈ -ᵣ f v v∈))
+apartFrom-Invlipschitz-ℝ→ℝℙ K P f X u u∈ v v∈ ρ Y =
+ let Δ = absᵣ (f u u∈ -ᵣ f v v∈)
+ in x<y+δ→x≤y _ _ λ ε →
+      PT.rec (isProp<ᵣ _ _) -- u ∼[ K ℚ₊· (q , ?3) ] v
+        (λ (q , Δ<q , q<Δ+ε) →
+          let 0<q = ℚ.<→0< _ (<ᵣ→<ℚ 0 q
+                     (isTrans≤<ᵣ _ _ _
+                       (0≤absᵣ _) Δ<q))
+              zzz : (fst (K ℚ₊· ρ)) ℚ.< (fst (K ℚ₊· (q , 0<q)))
+              zzz = <ᵣ→<ℚ _ _ $ isTrans≤<ᵣ _ _ _
+                       Y
+                       (fst (∼≃abs<ε _ _ _)
+                      $ X u u∈ v v∈ (q , 0<q)
+                       (invEq (∼≃abs<ε _ _ _)
+                         Δ<q))
+              zzz' = ℚ.<-·o-cancel _ _ _
+                         (ℚ.0<ℚ₊ K)
+                      (subst2 ℚ._<_ (ℚ.·Comm _ _) (ℚ.·Comm _ _)
+                          zzz)
+              zz : rat (fst ρ) <ᵣ Δ +ᵣ rat (fst ε)
+              zz = isTrans<ᵣ _ _ _
+                      (<ℚ→<ᵣ _ _ zzz')
+                       q<Δ+ε
+          in zz
+          )
+        ((denseℚinℝ Δ (Δ +ᵣ rat (fst (ε)))
+             (≤Weaken<+ᵣ _ _ (ℚ₊→ℝ₊ (ε)) (≤ᵣ-refl _))))
+
+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)
+
+
+1ℚ^ⁿ : ∀ a → 1 ℚ^ⁿ a ≡ 1
+1ℚ^ⁿ zero = refl
+1ℚ^ⁿ (suc a) = ℚ.·IdR _ ∙ 1ℚ^ⁿ a
+
+ℚ^-· : ∀ x a b → ((x ℚ^ⁿ a) ℚ^ⁿ b) ≡ (x ℚ^ⁿ (a ℕ.· b))
+ℚ^-· x a zero = cong (x ℚ^ⁿ_) (0≡m·0 a)
+ℚ^-· x a (suc b) = cong (ℚ._· (x ℚ^ⁿ a))
+     (ℚ^-· x a b) ∙
+       (ℚ.·-ℚ^ⁿ (a ℕ.· b) a x)
+      ∙ cong (x ℚ^ⁿ_) ((λ i → ℕ.+-comm (ℕ.·-comm a b i) a i) ∙
+          ℕ.·-comm _ _)
+
+¾ⁿ<ε : ∀ (ε : ℚ₊) → Σ[ n ∈ ℕ ] [ 3 / 4 ] ℚ^ⁿ n ℚ.< fst ε
+¾ⁿ<ε ε =
+  let (n , X) = 1/2ⁿ<ε ε
+      ¾³≤½ = ℚ^ⁿ-Monotone
+              {[ 3 / 4 ] ℚ^ⁿ 3} {[ 1 / 2 ]}
+              n (ℚ.decℚ≤? {0} {[ 3 / 4 ] ℚ^ⁿ 3})
+               (ℚ.decℚ≤? {0} {[ 1 / 2 ]} )
+                 (ℚ.decℚ≤? {[ 3 / 4 ] ℚ^ⁿ 3} {[ 1 / 2 ]})
+  in 3 ℕ.· n , ℚ.isTrans≤< _ _ _
+    (ℚ.isTrans≤ _ _ _
+      (ℚ.≡Weaken≤ _ _ (sym (ℚ^-· [ 3 / 4 ] 3 n)))
+        ¾³≤½) X
+
+
+
+map-fromCauchySequence'ℙ : ∀ L s ics P f → (Lipschitz-ℝ→ℝℙ L P f) →
+   ∀ lim∈ →
+   (s∈ : ∀ n → s n ∈ P) →
+    Σ _ λ icsf →
+       f (fromCauchySequence' s ics) lim∈ ≡
+        fromCauchySequence' (λ n → f (s n) (s∈ n))
+          icsf
+map-fromCauchySequence'ℙ L s ics P f lf lim∈ s∈ =
+  icsf , sym (fromCauchySequence'≡ _ _ _ h)
+
+
+ where
+ open ℚ.HLP
+
+ icsf : IsCauchySequence' (λ n → f (s n) (s∈ n))
+ icsf ε = map-snd
+   (λ X m n <m <n →
+      let z = X m n <m <n
+          z' = lf (s n) (s∈ n) (s m) (s∈ m) (invℚ₊ L ℚ₊· ε)
+                (invEq (∼≃abs<ε _ _ _) z)
+       in fst (∼≃abs<ε _ _ ε) (subst∼ (ℚ.y·[x/y] L (fst ε)) z'))
+   (ics (invℚ₊ L ℚ₊· ε))
+
+ h : (ε : ℚ₊) →
+       ∃-syntax ℕ
+       (λ N →
+          (n : ℕ) →
+          N ℕ.< n →
+          absᵣ (f (s n) (s∈ n)
+            -ᵣ f (fromCauchySequence' s ics) lim∈) <ᵣ rat (fst ε))
+ h ε =
+   let (N , X) = ics ((invℚ₊ L ℚ₊· (/4₊ ε)))
+       (N' , X') = icsf (/4₊ ε)
+       midN = suc (ℕ.max N N')
+       midV = f (s midN)
+
+   in ∣ midN , (λ n midN<n →
+        let 3ε/4<ε = subst (ℚ._< (fst ε))
+                            (cong (fst (/4₊ ε) ℚ.+_)
+                              (sym (ℚ.y·[x/y] L _)
+                               ∙ cong (fst L ℚ.·_) (ℚ.·DistL+ _ _ _) ))
+
+                               (distℚ<! ε [ ((ge[ ℚ.[ 1 / 4 ] ]) +ge
+                                   (ge[ ℚ.[ 1 / 4 ] ] +ge ge[ ℚ.[ 1 / 4 ] ]))
+                                   < ge1 ])
+            z' = invEq (∼≃abs<ε _ _ (/4₊ ε)) (X' ((suc N')) n
+                 (ℕ.<-trans (ℕ.suc-≤-suc ℕ.right-≤-max) midN<n)
+                  ℕ.≤-refl )
+
+            zzzz' =
+                (𝕣-lim-self _ (fromCauchySequence'-isCA s ics)
+                      ((invℚ₊ L ℚ₊· (/4₊ ε))) ( (invℚ₊ L ℚ₊· (/4₊ ε))))
+
+        in fst (∼≃abs<ε _ _ ε)
+             (∼-monotone< 3ε/4<ε
+                (triangle∼ z' (lf _ _ _ _ _ zzzz')))) ∣₁
+
+x+y≤x'-y'≃x+y'≤x'-y : ∀ x y x' y' →
+       (x +ᵣ y ≤ᵣ x' -ᵣ y') ≃ (x +ᵣ y' ≤ᵣ x' -ᵣ y)
+x+y≤x'-y'≃x+y'≤x'-y x y x' y' =
+      subst2Equiv _≤ᵣ_
+        (cong (x +ᵣ_) (sym L𝐑.lem--063) ∙
+          +ᵣAssoc _ _ _ ∙ cong (_-ᵣ y') (+ᵣAssoc _ _ _))
+        (cong (_-ᵣ y') (sym (𝐑'.minusPlus _ _)))
+   ∙ₑ x+y≤z+y≃x≤z _ _ (-ᵣ y')
+   ∙ₑ x+y≤z+y≃x≤z _ _ y
+
+x+y<x'-y'≃x+y'<x'-y : ∀ x y x' y' →
+       (x +ᵣ y <ᵣ x' -ᵣ y') ≃ (x +ᵣ y' <ᵣ x' -ᵣ y)
+x+y<x'-y'≃x+y'<x'-y x y x' y' =
+      subst2Equiv _<ᵣ_
+        (cong (x +ᵣ_) (sym L𝐑.lem--063) ∙
+          +ᵣAssoc _ _ _ ∙ cong (_-ᵣ y') (+ᵣAssoc _ _ _))
+        (cong (_-ᵣ y') (sym (𝐑'.minusPlus _ _)))
+   ∙ₑ x+y<z+y≃x<z _ _ (-ᵣ y')
+   ∙ₑ x+y<z+y≃x<z _ _ y
+
+
+1/m·1/n : ∀ {n m} → [ 1 / n ] ℚ.· [ 1 / m ] ≡ [ 1 / (n ·₊₁ m) ]
+1/m·1/n = refl
+
+invL→embed : ∀ a b (a≤b : rat a ≤ᵣ rat b) f (f∈ : ∀ x x∈ → f x x∈ ∈ intervalℙ
+                         (f (rat a) ((≤ᵣ-refl _) , a≤b))
+                         (f (rat b) (a≤b , ≤ᵣ-refl _)))
+                K → Invlipschitz-ℝ→ℝℙ K (intervalℙ (rat a) (rat b)) f
+               → isEmbedding {A = Σ _ _} {B = Σ _ (_∈ intervalℙ
+                         (f (rat a) ((≤ᵣ-refl _) , a≤b))
+                         (f (rat b) (a≤b , ≤ᵣ-refl _)))}
+                  λ (x , x∈) → (f x x∈ , f∈ x x∈)
+invL→embed a b a≤b f f∈ K il (x , x∈) (y , y∈) =
+ snd (propBiimpl→Equiv (isSetΣ isSetℝ
+   (isProp→isSet ∘ snd ∘ intervalℙ (rat a) (rat b) ) _ _)
+   (isSetΣ isSetℝ (isProp→isSet ∘ snd ∘ intervalℙ _ _ ) _ _) _
+     (Σ≡Prop (snd ∘ intervalℙ (rat a) (rat b)) ∘S fst (∼≃≡ _ _) ∘ (λ p ε →
+        subst∼ (ℚ.y·[x/y] K (fst ε))
+     (il x x∈ y y∈ ((invℚ₊ K) ℚ₊· ε) (p (invℚ₊ K ℚ₊· ε))))
+      ∘S invEq (∼≃≡ _ _) ∘S cong fst))
+
+
+
+
+module IsBilipschitz' (a b : ℚ)  (a<b : a ℚ.< b)
+         (f : ∀ (x : ℝ) → x ∈ (intervalℙ (rat a) (rat b)) → ℝ)
+         (fC : IsContinuousWithPred (intervalℙ (rat a) (rat b)) f)
+          (incrF : isIncrasingℙᵣ (intervalℙ (rat a) (rat b)) f)
+          (nondF : isNondecrasingℙᵣ (intervalℙ (rat a) (rat b)) f)
+           where
+
+
+ a∈ : rat a ∈ (intervalℙ (rat a) (rat b))
+
+ a∈ = (≤ᵣ-refl (rat a) , <ᵣWeaken≤ᵣ _ _ (<ℚ→<ᵣ _ _ a<b))
+ b∈ : rat b ∈ (intervalℙ (rat a) (rat b))
+ b∈ = (<ᵣWeaken≤ᵣ _ _ (<ℚ→<ᵣ _ _ a<b) , ≤ᵣ-refl (rat b))
+
+ fa = f (rat a) a∈
+ fb = f (rat b) b∈
+
+ f∈ : ∀ x x∈ → f x x∈ ∈ (intervalℙ fa fb)
+ f∈ x x∈ =
+   nondF (rat a) _ x x∈ (fst x∈) ,
+    nondF x x∈  (rat b) _ (snd x∈)
+
+ f' : ∀ x x∈ → Σ ℝ (_∈ intervalℙ fa fb)
+ f' x x∈ = _ , f∈ x x∈
+
+ fa<fb : fa <ᵣ fb
+ fa<fb = incrF
+   (rat a) a∈
+   (rat b) b∈
+   (<ℚ→<ᵣ _ _ a<b)
+
+ a≤b = ℚ.<Weaken≤ _ _ a<b
+
+ Δ₀ = b ℚ.- a
+ Δ₀₊ = ℚ.<→ℚ₊ _ _ a<b
+
+
+ fo : (x : ℝ) → x ∈ ointervalℙ (rat a) (rat b)
+              → Σ ℝ (_∈ ointervalℙ fa fb)
+ fo x (<x , x<)  = (f x (<ᵣWeaken≤ᵣ _ _ <x , <ᵣWeaken≤ᵣ _ _ x<))
+         , (incrF (rat a) a∈  x (<ᵣWeaken≤ᵣ _ _ <x , <ᵣWeaken≤ᵣ _ _ x<) <x)
+         , (incrF x (<ᵣWeaken≤ᵣ _ _ <x , <ᵣWeaken≤ᵣ _ _ x<) (rat b) b∈   x<)
+
+
+ module Inv
+    (approxF : ℚApproxℙ' (intervalℙ (rat a) (rat b)) (intervalℙ fa fb) f')
+    (L K : ℚ₊)
+    (lipF : Lipschitz-ℝ→ℝℙ L (intervalℙ (rat a) (rat b)) f)
+    (1/K≤L : fst (invℚ₊ K) ℚ.≤ fst L)
+    (lip⁻¹F : Invlipschitz-ℝ→ℝℙ K (intervalℙ (rat a) (rat b)) f)
+
+   where
+
+  fApart : ∀ x x∈ y y∈ → (ε : ℚ₊) → rat (fst (K ℚ₊· ε)) ≤ᵣ absᵣ (x -ᵣ y) →
+                                    rat (fst ε) ≤ᵣ absᵣ (f x x∈ -ᵣ f y y∈)
+  fApart = apartFrom-Invlipschitz-ℝ→ℝℙ
+           K _ f lip⁻¹F
+
+  invApart : ∀ x x∈ y y∈ → (ε : ℚ₊) →
+         rat (fst (L ℚ₊· ε)) ≤ᵣ absᵣ (f x x∈ -ᵣ f y y∈)   →
+           rat (fst ε) ≤ᵣ absᵣ (x -ᵣ y)
+  invApart x x∈ y y∈ ρ z =
+   let Δ = absᵣ (x -ᵣ y)
+   in x<y+δ→x≤y _  _
+       λ ε →
+            PT.rec (isProp<ᵣ _ _)
+        (λ (q , Δ<q , q<Δ+ε) →
+           let z' : f x x∈ ∼[
+                      L ℚ₊·
+                      (q ,
+                       ℚ.<→0< q
+                       (<ᵣ→<ℚ [ pos 0 / 1 ] q
+                        (isTrans≤<ᵣ 0 Δ (rat q) (0≤absᵣ (x -ᵣ y)) Δ<q)))
+                      ] f y y∈
+               z' = lipF x x∈ y y∈
+                     (q , ℚ.<→0< _ (<ᵣ→<ℚ _ _
+                       (isTrans≤<ᵣ _ _ _
+                         (0≤absᵣ _) Δ<q)))
+                    (invEq (∼≃abs<ε _ _ _) Δ<q )
+
+               zz' = ℚ.<-·o-cancel _ _ _ (ℚ.0<ℚ₊ L)
+                 (subst2 ℚ._<_ (ℚ.·Comm _ _) (ℚ.·Comm _ _)
+                      (<ᵣ→<ℚ _ _ (isTrans≤<ᵣ _ _ _
+                       z
+                       (fst (∼≃abs<ε _ _ _) z'))))
+
+
+           in isTrans<ᵣ _ _ _
+                 (<ℚ→<ᵣ _ _ zz') q<Δ+ε
+          )
+        ((denseℚinℝ Δ (Δ +ᵣ rat (fst (ε)))
+             (≤Weaken<+ᵣ _ _ (ℚ₊→ℝ₊ (ε)) (≤ᵣ-refl _))))
+
+  invApart' : ∀ x x∈ y y∈ → (ε : ℚ₊) →
+         rat (fst ε) ≤ᵣ absᵣ (f x x∈ -ᵣ f y y∈)   →
+           rat (fst ((invℚ₊ L) ℚ₊· ε)) ≤ᵣ absᵣ (x -ᵣ y)
+  invApart' x x∈ y y∈ ε z =
+    invApart x x∈ y y∈ ((invℚ₊ L) ℚ₊· ε)
+      (isTrans≡≤ᵣ _ _ _ (cong rat (ℚ.y·[x/y] L (fst ε) )) z)
+
+  invMon : ∀ x x∈ y y∈ →
+          f x x∈ <ᵣ f y y∈   →
+           x <ᵣ y
+  invMon x x∈ y y∈ fx<fy =
+   PT.rec (isProp<ᵣ _ _)
+      (λ (δ , X) →
+         let z = isTrans<≤ᵣ _ _ _
+                    (snd (ℚ₊→ℝ₊ ((invℚ₊ L) ℚ₊· δ)))
+                    (invApart y y∈ x x∈  ((invℚ₊ L) ℚ₊· δ)
+                      (isTrans≡≤ᵣ _ _ _
+                         (cong rat (ℚ.y·[x/y] L (fst δ)))
+                          (isTrans≤ᵣ _ _ _
+                           (<ᵣWeaken≤ᵣ _ _ X) (≤absᵣ _))))
+         in ⊎.rec (⊥.rec ∘ isAsym<ᵣ (f x x∈) (f y y∈) fx<fy
+              ∘S incrF y y∈ x x∈ ) (idfun _)
+              (invEq (＃≃0<dist _ _) z)
+              )
+     (<ᵣ→Δ _ _ fx<fy)
+
+  isEmbed-fo : isEmbedding (uncurry fo)
+  isEmbed-fo (x , x∈) (y , y∈) =
+    snd (propBiimpl→Equiv (isSetΣ isSetℝ
+    (isProp→isSet ∘ snd ∘ ointervalℙ (rat a) (rat b) ) _ _)
+    (isSetΣ isSetℝ (isProp→isSet ∘ snd ∘ ointervalℙ _ _ ) _ _) _
+      (Σ≡Prop (snd ∘ ointervalℙ (rat a) (rat b)) ∘S fst (∼≃≡ _ _) ∘ (λ p ε →
+         subst∼ (ℚ.y·[x/y] K (fst ε))
+      (lip⁻¹F x _ y _ ((invℚ₊ K) ℚ₊· ε) (p (invℚ₊ K ℚ₊· ε))))
+       ∘S invEq (∼≃≡ _ _) ∘S cong fst))
+
+  module _ (y : ℚ) (y∈ : rat y ∈ (intervalℙ fa fb))  where
+
+   record Step (Δ : ℚ) : Type where
+    field
+     a' b' : ℚ
+     a'<b' : a' ℚ.< b'
+     b'-a'≤Δ : b' ℚ.- a' ℚ.≤ Δ
+     a'∈ : a' ∈ ℚintervalℙ a b
+     b'∈ : b' ∈ ℚintervalℙ a b
+     a'≤ : f (rat a') (∈ℚintervalℙ→∈intervalℙ _ _ _ a'∈) ≤ᵣ rat y
+     ≤b' : rat y ≤ᵣ f (rat b') (∈ℚintervalℙ→∈intervalℙ _ _ _ b'∈)
+
+    a'≤b' : a' ℚ.≤ b'
+    a'≤b' = ℚ.<Weaken≤ _ _ a'<b'
+    mid : ℚ
+    mid = b' ℚ.· [ 1 / 2 ] ℚ.+ a' ℚ.· [ 1 / 2 ]
+
+    Δ₊ : ℚ₊
+    Δ₊ = Δ , ℚ.<→0< _ (ℚ.isTrans<≤ 0 _ _ (ℚ.-< a' b' a'<b') b'-a'≤Δ)
+
+    p = ℚ.<-·o _ _ [ 1 / 2 ] (ℚ.decℚ<? {0} {[ 1 / 2 ]}) a'<b'
+
+    a'<mid : a' ℚ.< mid
+    a'<mid = ℚ.isTrans≤< _ _ _
+      (ℚ.≡Weaken≤ _ _ (sym (ℚ.·IdR a') ∙ cong (a' ℚ.·_) ℚ.decℚ? ∙
+        ℚ.·DistL+ a' _ _))
+      (ℚ.<-+o _ _ (a' ℚ.· [ 1 / 2 ]) p)
+
+    mid<b' : mid ℚ.< b'
+    mid<b' = ℚ.isTrans<≤ _ _ _
+      (ℚ.<-o+ _ _ (b' ℚ.· [ 1 / 2 ]) p)
+      ((ℚ.≡Weaken≤ _ _ ((sym (ℚ.·DistL+ b' _ _) ∙ cong (b' ℚ.·_) ℚ.decℚ? ∙
+        ℚ.·IdR b'))))
+
+    mid∈ : mid ∈ ℚintervalℙ a b
+    mid∈ = ℚ.isTrans≤ _ _ _ (fst (a'∈)) (ℚ.<Weaken≤ _ _ a'<mid) ,
+            ℚ.isTrans≤ _ _ _ (ℚ.<Weaken≤ _ _ mid<b') (snd b'∈)
+
+    mid∈' = (∈ℚintervalℙ→∈intervalℙ _ _ _ mid∈)
+
+    fMidᵣ = f (rat mid) mid∈'
+
+    y-fa' : absᵣ (f (rat a') (∈ℚintervalℙ→∈intervalℙ _ _ _ a'∈) -ᵣ rat y)
+            <ᵣ rat (fst L ℚ.· (2 ℚ.· Δ))
+    y-fa' = isTrans≡<ᵣ _ _ _
+       (minusComm-absᵣ _ _)
+       (isTrans≤<ᵣ _ _ _
+          (subst2 _≤ᵣ_
+            ((sym (absᵣNonNeg _ (x≤y→0≤y-x _ _
+               (a'≤)))))
+            (sym (absᵣPos _ (x<y→0<y-x _ _
+              (incrF _ _ _ _ (<ℚ→<ᵣ _ _ a'<b')))))
+            (≤ᵣ-+o _ _ _ (≤b')))
+         (fst (∼≃abs<ε _ _ _)
+          ((lipF (rat b') (∈ℚintervalℙ→∈intervalℙ _ _ _ b'∈)
+                  (rat a') (∈ℚintervalℙ→∈intervalℙ _ _ _ a'∈)
+
+                 (2 ℚ₊· Δ₊)
+                  (invEq (∼≃abs<ε _ _ _)
+                   (isTrans≤<ᵣ _ _ _
+                    (isTrans≡≤ᵣ _ _ _
+                       (cong absᵣ (cong₂ _+ᵣ_ refl (-ᵣ-rat _)
+                        ∙ +ᵣ-rat _ _ )  ∙ (absᵣPos _ (<ℚ→<ᵣ _ _ (ℚ.-< _ _ a'<b')))) --
+                        (≤ℚ→≤ᵣ _ _ b'-a'≤Δ))
+                        (<ℚ→<ᵣ _ _
+                          (ℚ.isTrans≤< _ _ _
+                            (ℚ.≡Weaken≤ _ _
+                               (sym (ℚ.·IdL _)))
+
+                           (ℚ.<-·o 1 2 _ (ℚ.0<ℚ₊ Δ₊) (ℚ.decℚ<?))))))))))
+
+   record Step⊃Step {Δ ΔS : _} (s : Step Δ) (sS : Step ΔS) : Type where
+
+    field
+     a'≤a'S : Step.a' s ℚ.≤ Step.a' sS
+     bS≤b' : Step.b' sS ℚ.≤ Step.b' s
+     -- distA' : (Step.a' sS) ℚ.≤ Δ ℚ.· [ 1 / 2 ] ℚ.+ (Step.a' s)
+
+   step0 : Step Δ₀
+   step0 .Step.a' = a
+   step0 .Step.b' = b
+   step0 .Step.a'<b' = a<b
+   step0 .Step.b'-a'≤Δ = ℚ.isRefl≤ _
+   step0 .Step.a'∈ = ℚ.isRefl≤ _  , a≤b
+   step0 .Step.b'∈ = a≤b , (ℚ.isRefl≤ _)
+   step0 .Step.a'≤ =
+         subst (_≤ᵣ _)
+           (cong (f (rat a)) (snd (intervalℙ _ _ _) _ _)) ( (fst y∈))
+   step0 .Step.≤b' =
+         subst (_ ≤ᵣ_)
+           (cong (f (rat b)) (snd (intervalℙ _ _ _) _ _)) ( (snd y∈))
+
+   stepS' : ∀ Δ → (s : Step Δ) → Σ (Step (Δ ℚ.· [ 3 / 4 ])) (Step⊃Step s)
+   stepS' Δ s = w (ℚ.Dichotomyℚ y fMid)
+    where
+    open Step s
+
+
+    Δ₊* : ℚ₊
+    Δ₊* = ℚ.<→ℚ₊ _ _ a'<b'
+
+    Δ* : ℚ
+    Δ* = fst Δ₊*
+
+
+    Δ*≤Δ : Δ* ℚ.≤ Δ
+    Δ*≤Δ = b'-a'≤Δ
+
+
+    mid=b-Δ/2 : mid ≡ b' ℚ.- fst (/2₊ Δ₊*)
+    mid=b-Δ/2 =
+          cong₂ ℚ._+_
+           (sym lem--063 ∙
+            cong₂ ℚ._+_
+             (ℚ.ε/2+ε/2≡ε _) refl)
+          (cong (ℚ._· [ 1 / 2 ]) (sym (ℚ.-Invol _))
+            ∙ sym (ℚ.·Assoc -1 _ _))
+       ∙∙ sym (ℚ.+Assoc _ _ _)
+       ∙∙ cong (ℚ._+_ b')
+         (sym (ℚ.-Distr (b' ℚ.· [ 1 / 2 ])
+            (ℚ.- a' ℚ.· [ 1 / 2 ]))
+           ∙ cong ℚ.-_ (sym (ℚ.·DistR+ b' (ℚ.- a') [ 1 / 2 ])))
+
+
+    Φ : ℚ₊
+    Φ = /2₊ (invℚ₊ K ℚ₊· /4₊ Δ₊*)
+
+    fMid = fst (approxF mid mid∈') Φ
+
+    fMidDist : rat fMid ∼[ (invℚ₊ K ℚ₊· /4₊ Δ₊*) ] f (rat mid) mid∈'
+    fMidDist =
+      subst∼ (ℚ.ε/2+ε/2≡ε _) (subst (rat fMid ∼[ Φ ℚ₊+ Φ ]_)
+                (snd (snd (snd (approxF mid mid∈'))))
+                 (𝕣-lim-self _ _ Φ Φ))
+
+
+    a'-mid≡Δ/2 : (mid ℚ.- a') ≡ Δ* ℚ.· [ 1 / 2 ]
+    a'-mid≡Δ/2 =
+       ((sym (ℚ.+Assoc _ _ _) ∙
+          cong (b' ℚ.· [ 1 / 2 ] ℚ.+_)
+           (cong (a' ℚ.· [ 1 / 2 ] ℚ.+_) (ℚ.·Comm -1 a')
+            ∙ sym (ℚ.·DistL+ a' _ _) ∙
+             ℚ.·Comm _ _ ∙
+              sym (ℚ.·Assoc [ 1 / 2 ] -1 a') ∙  ℚ.·Comm [ 1 / 2 ] _)
+           ∙ sym (ℚ.·DistR+ _ _ _)))
+
+    w : (y ℚ.≤ fMid) ⊎ (fMid ℚ.< y) → Σ (Step (Δ ℚ.· [ 3 / 4 ]))
+              (Step⊃Step s)
+    w (inl x) = ww
+     where
+
+     ab-dist = ℚ.isTrans≤
+      ((mid ℚ.+ (Δ* ℚ.· [ 1 / 4 ])) ℚ.- a') _ _
+       (ℚ.≡Weaken≤ _ _
+         (cong (ℚ._- a') (ℚ.+Comm _ _) ∙ sym (ℚ.+Assoc _ _ _)))
+        ((ℚ.isTrans≤ _ _ _
+          (ℚ.≤-o+ _ _ _ (ℚ.≡Weaken≤ _ _ a'-mid≡Δ/2))
+            (ℚ.≡Weaken≤ _ _ (sym (ℚ.·DistL+ Δ* _ _) ∙
+              cong (Δ* ℚ.·_) ℚ.decℚ?))))
+
+     newb' = mid ℚ.+ (Δ* ℚ.· [ 1 / 4 ])
+
+
+     newb'+Δ/4≡b' : newb' ℚ.+ (Δ* ℚ.· [ 1 / 4 ]) ≡ b'
+     newb'+Δ/4≡b' = sym (ℚ.+Assoc _ _ _) ∙
+       cong₂ ℚ._+_
+         mid=b-Δ/2
+         (cong fst (ℚ./4₊+/4₊≡/2₊ Δ₊*))
+       ∙ lem--00
+
+     y≤fnewb' : rat y ≤ᵣ f (rat newb') _
+     y≤fnewb' =
+      (isTrans≤ᵣ _ _ _
+        (≤ℚ→≤ᵣ _ _ x) (isTrans≤ᵣ _ _ _
+           (a-b≤c⇒a≤c+b _ _ _
+             (isTrans≤ᵣ _ _ _ (≤absᵣ _ )
+               (<ᵣWeaken≤ᵣ _ _ (fst (∼≃abs<ε _ _ _) fMidDist)))) mid-dist))
+        where
+         mid-dist : rat (fst (invℚ₊ K ℚ₊· /4₊ Δ₊*))
+                      +ᵣ f (rat mid) mid∈' ≤ᵣ
+                      f _ _
+         mid-dist = a≤b-c⇒a+c≤b _ _ _ $ isTrans≤≡ᵣ _ _ _
+          (apartFrom-Invlipschitz-ℝ→ℝℙ
+           K _ f lip⁻¹F (rat newb')
+             _
+             (rat mid) mid∈'
+             (invℚ₊ K ℚ₊· (/4₊ Δ₊*))
+                (isTrans≤≡ᵣ _ _ _(≤ℚ→≤ᵣ _ _
+
+                  (subst2 ℚ._≤_ (sym (ℚ.y·[x/y] K (fst (/4₊ Δ₊*))))
+                    (cong ℚ.abs' (sym lem--063))
+                  (ℚ.≤abs' _))
+                  ) (cong rat (sym (ℚ.abs'≡abs _)) ∙ sym (absᵣ-rat _) ∙
+                   cong absᵣ
+                    (sym (-ᵣ-rat₂ _ _))))
+
+                  )
+              (absᵣPos _ (x<y→0<y-x _ _
+                (incrF _ mid∈' _ _
+                    (<ℚ→<ᵣ _ _ (ℚ.<+ℚ₊' mid mid ((Δ₊* ℚ₊· ([ 1 / 4 ] , _))) (ℚ.isRefl≤ mid) )))))
+
+     a'<newb' : a' ℚ.< newb'
+     a'<newb' =  ℚ.isTrans≤< _ _ _
+         (ℚ.≡Weaken≤ _ _ (sym (ℚ.+IdR _))) (ℚ.<Monotone+ _ _ 0 (Δ* ℚ.· [ 1 / 4 ])
+              a'<mid (ℚ.0<ℚ₊ (Δ₊* ℚ₊· ([ 1 / 4 ] , _))))
+
+     newb'≤b' : newb' ℚ.≤ b'
+     newb'≤b' =
+      subst (newb' ℚ.≤_) newb'+Δ/4≡b'
+       (ℚ.≤+ℚ₊ _ _ (Δ₊* ℚ₊· _) (ℚ.isRefl≤ _))
+
+     newb'∈ : newb' ∈ ℚintervalℙ a b
+     newb'∈ = ℚ.isTrans≤ _ _ _
+              (fst a'∈) (ℚ.<Weaken≤ _ _ a'<newb')
+       , ℚ.isTrans≤ _ _ _ newb'≤b' (snd b'∈)
+
+
+     ww : Σ (Step (Δ ℚ.· [ 3 / 4 ])) (Step⊃Step s)
+     ww .fst .Step.a' = a'
+     ww .fst .Step.b' = newb'
+     ww .fst .Step.a'<b' = a'<newb'
+     ww .fst .Step.b'-a'≤Δ = ℚ.isTrans≤
+           _ _ _ ab-dist (ℚ.≤-·o Δ* Δ [ 3 / 4 ]
+             (ℚ.<Weaken≤ 0 [ 3 / 4 ] (ℚ.0<pos 2 4)) Δ*≤Δ)
+     ww .fst .Step.a'∈ = a'∈
+     ww .fst .Step.b'∈ = newb'∈
+     ww .fst .Step.a'≤ = a'≤
+     ww .fst .Step.≤b' =  y≤fnewb'
+     ww .snd .Step⊃Step.a'≤a'S = ℚ.isRefl≤ a'
+     ww .snd .Step⊃Step.bS≤b' = newb'≤b'
+    w (inr x) = ww
+     where
+     newa' = mid ℚ.- (Δ* ℚ.· [ 1 / 4 ])
+
+     ≡newa' : a' ℚ.+ Δ* ℚ.· [ 1 / 4 ] ≡ newa'
+     ≡newa' = (cong (a' ℚ.+_)
+                     (cong (Δ* ℚ.·_) ℚ.decℚ? ∙ 𝐐'.·DistR- Δ* _ _)
+                     ∙ ℚ.+Assoc _  _ _)
+                  ∙ cong (ℚ._- (Δ* ℚ.· [ 1 / 4 ]))
+                    (  ℚ.+Comm _ _
+                     ∙∙ sym (cong (ℚ._+ a') a'-mid≡Δ/2)
+                     ∙∙ 𝐐'.minusPlus _ _)
+
+
+     newa'<b' : newa' ℚ.< b'
+     newa'<b' = ℚ.isTrans<≤ _ _ _
+        (ℚ.<Monotone+ _ _ _ _
+         mid<b' (ℚ.minus-< 0 _ (ℚ.0<ℚ₊ (Δ₊* ℚ₊· ([ 1 / 4 ] , _)))))
+        (ℚ.≡Weaken≤ _ _ (ℚ.+IdR _))
+
+     ab-dist =
+       ℚ.≡Weaken≤ (b' ℚ.- newa') (Δ* ℚ.· [ 3 / 4 ])
+         (cong (ℚ._-_ b')
+           (cong (ℚ._- (Δ* ℚ.· [ 1 / 4 ]))
+             mid=b-Δ/2 ∙
+              sym (ℚ.+Assoc _ _ _))
+              ∙ sym lem--050
+           ∙ ℚ.-[x-y]≡y-x _ _ ∙
+            cong (ℚ._+_ (Δ* ℚ.· [ 1 / 4 ]))
+              (ℚ.-Invol _) ∙
+               sym (ℚ.·DistL+ Δ* _ _) ∙
+                cong (Δ* ℚ.·_) ℚ.decℚ?  )
+
+     a'≤newa' : a' ℚ.≤ newa'
+     a'≤newa' =
+       ℚ.isTrans≤ _ _ _ (ℚ.≤+ℚ₊ a' a' ((Δ₊* ℚ₊· ([ 1 / 4 ] , _)))
+                (ℚ.isRefl≤ a'))
+                 (ℚ.≡Weaken≤ _ _ ≡newa')
+
+     newa'<mid : newa' ℚ.< mid
+     newa'<mid = ℚ.<-ℚ₊' _ _ (Δ₊* ℚ₊· ([ 1 / 4 ] , _))
+        (ℚ.isRefl≤ mid)
+
+     newa'∈ : newa' ∈ ℚintervalℙ a b
+     newa'∈ =
+        ℚ.isTrans≤ _ _ _
+               (fst a'∈) a'≤newa'
+       , ℚ.isTrans≤ _ _ _
+               (ℚ.<Weaken≤ _ _ newa'<b') (snd b'∈)
+
+     newa'∈ᵣ = ∈ℚintervalℙ→∈intervalℙ _ _ _ newa'∈
+
+     fnewa'≤y : f (rat newa') _ ≤ᵣ rat y
+     fnewa'≤y = isTrans≤ᵣ _ _ _
+        (isTrans≤ᵣ _ _ _ mid-dist
+           (a-b≤c⇒a-c≤b _ _ _
+                 (isTrans≤ᵣ _ _ _ (≤absᵣ _ )
+                   (<ᵣWeaken≤ᵣ _ _
+                   (fst (∼≃abs<ε _ _ _) (sym∼ _ _ _ fMidDist))))))
+        (≤ℚ→≤ᵣ fMid _ (ℚ.<Weaken≤ _ _ x))
+
+       where
+         hh = isTrans≤≡ᵣ _ _ _ (apartFrom-Invlipschitz-ℝ→ℝℙ
+           K _ f lip⁻¹F
+            (rat mid) mid∈'
+            (rat newa') newa'∈ᵣ
+            (invℚ₊ K ℚ₊· (/4₊ Δ₊*))
+              (isTrans≡≤ᵣ _ _ _
+                (cong rat (ℚ.y·[x/y] K (fst (/4₊ Δ₊*)))
+                 ∙ cong rat (sym lem--079)
+                 ∙ sym (-ᵣ-rat₂ _ _))
+                (≤absᵣ _)))
+             (absᵣPos _ (x<y→0<y-x _ _
+               (incrF _ _  _ _ (<ℚ→<ᵣ _ _ newa'<mid) )))
+
+         mid-dist :  f (rat newa') newa'∈ᵣ
+                    ≤ᵣ f (rat mid) mid∈' -ᵣ
+                       rat (fst (invℚ₊ K ℚ₊· /4₊ Δ₊*))
+
+
+         mid-dist = a≤b-c⇒c≤b-a _ _ _ hh
+
+
+     ww : Σ (Step (Δ ℚ.· [ 3 / 4 ])) (Step⊃Step s)
+     ww .fst .Step.a' = newa'
+     ww .fst .Step.b' = b'
+     ww .fst .Step.a'<b' = newa'<b'
+     ww .fst .Step.b'-a'≤Δ =
+        ℚ.isTrans≤
+           _ _ _ ab-dist (ℚ.≤-·o Δ* Δ [ 3 / 4 ]
+             (ℚ.<Weaken≤ 0 [ 3 / 4 ] (ℚ.0<pos 2 4)) Δ*≤Δ)
+     ww .fst .Step.a'∈ = newa'∈
+     ww .fst .Step.b'∈ = b'∈
+     ww .fst .Step.a'≤ =  fnewa'≤y
+     ww .fst .Step.≤b' = ≤b'
+     ww .snd .Step⊃Step.a'≤a'S = a'≤newa'
+     ww .snd .Step⊃Step.bS≤b' = ℚ.isRefl≤ b'
+
+
+   stepS : ∀ Δ → Step Δ → Step (Δ ℚ.· [ 3 / 4 ])
+   stepS Δ s = fst (stepS' Δ s)
+
+   ww : ∀ n → Step (Δ₀ ℚ.· ([ 3 / 4 ] ℚ^ⁿ n))
+   ww zero = subst (Step) (sym (ℚ.·IdR Δ₀)) step0
+   ww (suc n) = subst (Step) (sym (ℚ.·Assoc _ _ _)) (stepS _ (ww n))
+
+   s : ℕ → ℚ
+   s = Step.a' ∘ ww
+
+   s' : ℕ → ℚ
+   s' = Step.b' ∘ ww
+
+   ss≤-suc : ∀ n (z : Step (Δ₀ ℚ.· ([ 3 / 4 ] ℚ^ⁿ n))) → Step.a' z ℚ.≤
+       Step.a' (subst (Step) (sym (ℚ.·Assoc _ _ _)) (stepS
+        (Δ₀ ℚ.· ([ 3 / 4 ] ℚ^ⁿ n)) z))
+   ss≤-suc n z = ℚ.isTrans≤ _ _ _ (Step⊃Step.a'≤a'S (snd (stepS'
+        (Δ₀ ℚ.· ([ 3 / 4 ] ℚ^ⁿ n)) z)))
+          (ℚ.≡Weaken≤ _ _ (sym (transportRefl _)))
+
+   ≤ss'-suc : ∀ n (z : Step (Δ₀ ℚ.· ([ 3 / 4 ] ℚ^ⁿ n))) →
+        Step.b' (subst (Step) (sym (ℚ.·Assoc _ _ _)) (stepS
+        (Δ₀ ℚ.· ([ 3 / 4 ] ℚ^ⁿ n)) z))
+       ℚ.≤
+        Step.b' z
+   ≤ss'-suc n z =  ℚ.isTrans≤ _ _ _
+          (ℚ.≡Weaken≤ _ _  (transportRefl _))
+            ((Step⊃Step.bS≤b' (snd (stepS'
+        (Δ₀ ℚ.· ([ 3 / 4 ] ℚ^ⁿ n)) z))))
+   ss≤ : ∀ n m → s n ℚ.≤ s (m ℕ.+ n)
+   ss≤ n zero = ℚ.isRefl≤ _
+   ss≤ n (suc m) = ℚ.isTrans≤ _ _ _ (ss≤ n m) (ss≤-suc (m ℕ.+ n) (ww (m ℕ.+ n)))
+
+   ≤ss' : ∀ n m →  s' (m ℕ.+ n) ℚ.≤ s' n
+   ≤ss' n zero = ℚ.isRefl≤ _
+   ≤ss' n (suc m) = ℚ.isTrans≤ _ _ _
+     (≤ss'-suc (m ℕ.+ n) (ww (m ℕ.+ n))) (≤ss' n m)
+
+
+
+   ww⊂ : ∀ n m → (s (m ℕ.+ n) ℚ.- s n) ℚ.≤ Δ₀ ℚ.· ([ 3 / 4 ] ℚ^ⁿ n)
+   ww⊂ n m = ℚ.isTrans≤
+     (s (m ℕ.+ n) ℚ.- s n) (s' n ℚ.- s n) _
+       (ℚ.≤-+o (s (m ℕ.+ n)) (s' n) (ℚ.- (s n))
+        (ℚ.isTrans≤ _ _ _ (Step.a'≤b' (ww (m ℕ.+ n))) (≤ss' n m)))
+    (Step.b'-a'≤Δ (ww n))
+
+   www : {ε : ℚ₊}
+           → (Σ[ n ∈ ℕ ] [ 3 / 4 ] ℚ^ⁿ n ℚ.<
+             fst (ε ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b)))
+          → Σ[ N ∈ ℕ ] (∀ m n → N ℕ.< n → N ℕ.< m →
+               absᵣ (rat (s n) -ᵣ rat (s m)) <ᵣ rat (fst ε))
+   www (N , P) .fst = N
+   www {ε} (N , P) .snd = ℕ.elimBy≤+
+     (λ n m X m< n< → subst (_<ᵣ (rat (fst ε)))
+       (minusComm-absᵣ (rat (s m)) (rat (s n))) (X n< m<))
+     λ n m p N<n →
+       let P' : Δ₀ ℚ.· ([ 3 / 4 ] ℚ^ⁿ N) ℚ.< fst ε
+           P' = ℚ.isTrans<≤ _ _ (fst ε) (ℚ.<-o· _ _ _ (ℚ.-< a b a<b) P)
+                  (ℚ.≡Weaken≤ _ _
+                     ((cong (fst (ℚ.<→ℚ₊ a b a<b) ℚ.·_) (ℚ.·Comm _ _))
+                      ∙ ℚ.y·[x/y] (ℚ.<→ℚ₊ _ _ a<b) (fst ε)))
+           zz = ℚ.isTrans≤< _ _ _
+                   (ℚ.isTrans≤ _ ((s (m ℕ.+ n)) ℚ.- (s n)) _
+                     (ℚ.≡Weaken≤ _ _ (ℚ.absNonNeg (s (m ℕ.+ n) ℚ.- s n)
+                       (ℚ.-≤ (s n) (s (m ℕ.+ n)) (ss≤ n m))))
+                       (ww⊂ n m))
+                   (ℚ.isTrans< _ (Δ₀ ℚ.· ([ 3 / 4 ] ℚ^ⁿ (N))) _
+                     (ℚ.<-o· _ _ Δ₀ (ℚ.-< a b a<b)
+                      (<^n' N n _ ℚ.decℚ<? N<n)) P')
+       in isTrans≡<ᵣ _ _ _ (cong absᵣ (-ᵣ-rat₂ _  _) ∙ absᵣ-rat _)
+            (<ℚ→<ᵣ _ _ zz)
+
+
+   s-cauchy : IsCauchySequence' (rat ∘ s)
+   s-cauchy ε = www {ε} (¾ⁿ<ε (ε ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b)))
+
+   f⁻¹ : ℝ
+   f⁻¹ = fromCauchySequence' (rat ∘ s)
+         s-cauchy
+
+
+
+
+   f⁻¹∈ : f⁻¹ ∈ intervalℙ (rat a) (rat b)
+   f⁻¹∈ = ((≤lim _ _ _
+            λ δ → ≤ℚ→≤ᵣ _ _ $ fst (Step.a'∈
+             (ww (suc (¾ⁿ<ε (δ ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b)) .fst))))))
+      , (lim≤ _ _ _
+            λ δ → ≤ℚ→≤ᵣ _ _ $ snd (Step.a'∈
+             (ww (suc (¾ⁿ<ε (δ ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b)) .fst)))))
+
+
+   s∈ : ∀ n → rat (s n) ∈ intervalℙ (rat a) (rat b)
+   s∈ n = ((≤ℚ→≤ᵣ _ _ $ fst (Step.a'∈
+             (ww n))))
+      , (≤ℚ→≤ᵣ _ _ $ snd (Step.a'∈
+             (ww n)))
+
+
+   s~y : (ε : ℚ₊) →
+           ∃-syntax ℕ
+           (λ N →
+              (n : ℕ) →
+              N ℕ.< n →
+              absᵣ (f (rat (s n)) (s∈ n) -ᵣ rat y) <ᵣ rat (fst ε))
+   s~y ε =
+     let (N , X) = (¾ⁿ<ε (invℚ₊ (L ℚ₊· (2 ℚ₊· Δ₀₊)) ℚ₊· ε))
+
+     in ∣ suc N ,
+        (λ { zero x → ⊥.rec (ℕ.¬-<-zero x)
+           ; (suc n) x →
+              let 𝒔 = ww (suc n)
+                  XX : ([ pos 3 / 1+ 3 ] ℚ^ⁿ (suc n))
+                         ℚ.· fst  (L ℚ₊· (2 ℚ₊· Δ₀₊))
+                          ℚ.< fst ε
+                  XX =  ℚ.isTrans< _ _ _
+                        (ℚ.<-·o _ _ _
+                           (ℚ.0<ℚ₊ (L ℚ₊· (2 ℚ₊· Δ₀₊)))
+                           (<^n' N (suc n) ([ 3 / 4 ] , _)
+                              (ℚ.decℚ<? {[ 3 / 4 ]} {1})
+                              (ℕ.<-weaken x)))
+                        (subst (ℚ._< _) (
+                        cong (([ pos 3 / 1+ 3 ] ℚ^ⁿ N) ℚ.·_)
+                        (ℚ.invℚ₊-invol (L ℚ₊· (2 ℚ₊· Δ₀₊))))
+                          (ℚ.x<y·z→x·invℚ₊y<z _ _
+                            (invℚ₊ (L ℚ₊· (2 ℚ₊· Δ₀₊))) X))
+
+
+              in isTrans<ᵣ _ _ _ (Step.y-fa' (ww (suc n)))
+                     (<ℚ→<ᵣ _ _ (ℚ.isTrans≤<
+                       _ _ _
+                       (ℚ.≡Weaken≤ _ _
+                         (    cong (fst L ℚ.·_)
+                               (ℚ.·Assoc _ _ _)
+                           ∙∙ ℚ.·Assoc _ _ _
+                           ∙∙ ℚ.·Comm _ _))
+                       XX)) }) ∣₁
+
+
+   f∘f⁻¹ : f f⁻¹ f⁻¹∈ ≡ rat y
+   f∘f⁻¹ = snd (map-fromCauchySequence'ℙ
+          L (rat ∘ s)
+            (λ ε → www {ε} (¾ⁿ<ε  (ε ℚ₊· invℚ₊ (ℚ.<→ℚ₊ a b a<b))))
+            (intervalℙ (rat a) (rat b)) f lipF f⁻¹∈ s∈) ∙
+               fromCauchySequence'≡ _ _ _ s~y
+
+
+
+  f⁻¹-L : Lipschitz-ℚ→ℝℙ K (intervalℙ fa fb) f⁻¹
+  f⁻¹-L y y∈ r r∈ ε x =
+    let zz = lip⁻¹F _ _ _ _ ε
+             (subst2 _∼[ ε ]_
+               (sym (f∘f⁻¹ y y∈))
+               (sym (f∘f⁻¹ r r∈)) (invEq (∼≃abs<ε _ _ _)
+                  (isTrans≡<ᵣ _ _ _
+                      (cong absᵣ (-ᵣ-rat₂ _ _)
+                        ∙ absᵣ-rat _)
+                      (<ℚ→<ᵣ (ℚ.abs (y ℚ.- r)) (fst ε) x))
+
+                    ))
+
+    in fst (∼≃abs<ε (f⁻¹ y y∈) (f⁻¹ r r∈) _) zz
+
+  f⁻¹-L-o : Lipschitz-ℚ→ℝℙ K (ointervalℙ fa fb)
+                 (λ x x∈ → f⁻¹ x (ointervalℙ⊆intervalℙ fa fb (rat x) x∈ ))
+  f⁻¹-L-o y y∈ r r∈ ε x =
+    let zz = lip⁻¹F _ _ _ _ ε
+             (subst2 _∼[ ε ]_
+               (sym (f∘f⁻¹ y (ointervalℙ⊆intervalℙ fa fb _ y∈)))
+               (sym (f∘f⁻¹ r (ointervalℙ⊆intervalℙ fa fb _ r∈)))
+                (invEq (∼≃abs<ε _ _ _)
+                  ((isTrans≡<ᵣ _ _ _
+                      (cong absᵣ (-ᵣ-rat₂ _ _)
+                        ∙ absᵣ-rat _)
+                      (<ℚ→<ᵣ (ℚ.abs (y ℚ.- r)) (fst ε) x)))))
+
+    in fst (∼≃abs<ε (f⁻¹ y (ointervalℙ⊆intervalℙ fa fb _ y∈))
+           (f⁻¹ r (ointervalℙ⊆intervalℙ fa fb _ r∈)) _) zz
+
+
+  δₙ : ℕ → ℚ₊
+  δₙ n = /2₊ ([ 1 / ((2+ n) ·₊₁ (2+ (suc n))) ] , _)
+
+  δₙ₊₁≤δₙ : ∀ n → fst (δₙ (suc n )) ℚ.≤ fst (δₙ n)
+  δₙ₊₁≤δₙ n =  ℚ.≤-·o _ _ [ 1 / 2 ]  (ℚ.0≤ℚ₊ ([ 1 / 2 ] , tt))
+                (fst (ℚ.invℚ₊-≤-invℚ₊
+                   (fromNat (ℕ₊₁→ℕ ((2+ n) ·₊₁ (2+ (suc n)))))
+                   (fromNat (ℕ₊₁→ℕ ((2+ (suc n)) ·₊₁ (2+ (suc (suc n)))))))
+                  (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos
+                    (ℕ₊₁→ℕ ((2+ n) ·₊₁ (2+ (suc n))))
+                    (ℕ₊₁→ℕ ((2+ (suc n)) ·₊₁ (2+ (suc (suc n)))))
+                    (ℕ.≤monotone·
+                      (ℕ.≤-sucℕ {2 ℕ.+ n})
+                      (ℕ.≤-sucℕ {3 ℕ.+ n})))))
+
+
+  δₙ< : ∀ n →  Δ₀ ℚ.· [ pos 1 / 2+ n ]
+                 ℚ.< Δ₀
+
+  δₙ< n = subst (Δ₀ ℚ.· [ pos 1 / 2+ n ] ℚ.<_) (ℚ.·IdR _)
+        ((ℚ.<-o· _ 1 _ (ℚ.0<ℚ₊ Δ₀₊)
+                      (fst (ℚ.invℚ₊-<-invℚ₊ 1 (fromNat (suc (suc n))))
+                       (ℚ.<ℤ→<ℚ _ _
+                         (ℤ.ℕ≤→pos-≤-pos _ _
+                           (ℕ.suc-≤-suc ℕ.zero-<-suc))) )))
+  Ψ₊ : ℚ₊
+  Ψ₊ = invℚ₊ K ℚ₊· Δ₀₊
+
+  Ψ = fst Ψ₊
+
+  Ψ≤fb-fa : rat (fst Ψ₊) ≤ᵣ fb -ᵣ fa
+  Ψ≤fb-fa =
+     isTrans≤≡ᵣ _ _ _
+       (apartFrom-Invlipschitz-ℝ→ℝℙ
+                  K _ f lip⁻¹F (rat b) b∈ (rat a) a∈
+                   (invℚ₊ K ℚ₊· Δ₀₊)
+                    (isTrans≡≤ᵣ _ _ _
+                     (cong rat (ℚ.y·[x/y] K _) ∙ sym (-ᵣ-rat₂ _ _))
+                     (≤absᵣ _)
+                     ) )
+                   (absᵣPos _ (x<y→0<y-x _ _ fa<fb))
+
+
+  a* b* : ℕ → Σ[ q ∈ ℚ ] (rat q ∈ intervalℙ (rat a) (rat b))
+  a* n = (a ℚ.+ Δ₀ ℚ.· [ 1 / 1+ (suc n) ]) ,
+           (≤ℚ→≤ᵣ _ _
+           (ℚ.≤+ℚ₊ a a (Δ₀₊ ℚ₊· ([ 1 / 1+ (suc n) ] , _)) (ℚ.isRefl≤ _)))
+            ,
+              isTrans≤≡ᵣ _ _ _
+                ((≤ℚ→≤ᵣ _ _ (ℚ.≤-o+ _ _ a (ℚ.<Weaken≤ _ _ (δₙ< n)))))
+                (cong rat
+                  (lem--05 ))
+  b* n = b ℚ.- (Δ₀ ℚ.· [ 1 / 1+ (suc n) ]) ,
+              isTrans≡≤ᵣ _
+          (rat (b ℚ.- Δ₀)) _
+         (cong rat (sym lem--079))
+         (≤ℚ→≤ᵣ _ _
+           (ℚ.≤-o+ _ _ b (ℚ.minus-≤ _ _ (ℚ.<Weaken≤ _ _ (δₙ< n)))))
+      , ≤ℚ→≤ᵣ _ _
+           ((ℚ.≤-ℚ₊ b b (Δ₀₊ ℚ₊· ([ 1 / 1+ (suc n) ] , _))
+            (ℚ.isRefl≤ _)))
+
+  a*<b* : ∀ n → fst (a* (suc n)) ℚ.< fst (b* (suc n))
+  a*<b* n =
+   subst (ℚ._< fst (b* (suc n)))
+    (ℚ.+Comm _ _)
+     zz
+   where
+   zz : (b ℚ.- a) ℚ.· [ 1 / 2+ suc n ] ℚ.+ a ℚ.<
+           b ℚ.- ((b ℚ.- a) ℚ.· [ 1 / 2+ (suc n) ])
+   zz = ℚ.<-+o-cancel _ (b ℚ.- ((b ℚ.- a) ℚ.· [ 1 / 2+ (suc n) ])) (ℚ.- a)
+         (subst2 ℚ._<_
+           ((sym (𝐐'.plusMinus ((b ℚ.- a) ℚ.· [ 1 / 2+ suc n ]) a)))
+           (    cong₂ ℚ._·_ refl (sym (ℚ.n/k-m/k _ _ (2+ suc n)))
+              ∙ 𝐐'.·DistR- _ _ [ 1 / 2+ suc n ]
+              ∙ cong₂ ℚ._+_ (𝐐'.·IdR' _ _ (ℚ.[n/n]≡[m/m] (suc (suc n)) 0)) refl
+              ∙ sym (ℚ.+Assoc b (ℚ.- a) _)
+              ∙ cong₂ ℚ._+_ refl (ℚ.+Comm _ _ )
+              ∙ ℚ.+Assoc _ _ _)
+
+           (ℚ.<-o· _ _ (b ℚ.- a)
+             (ℚ.0<ℚ₊ Δ₀₊) (ℚ.[k/n]<[k'/n] _ _ _
+               (subst (1 ℤ.<_)
+                 (cong (ℤ.sucℤ ∘ ℤ.sucℤ)
+                   (ℤ.pos+ 0 n ∙ sym (ℤ.sucℤ+ -1 (pos n)))
+                   ∙ ℤ.+Comm _ _)
+                 (ℤ.suc-≤-suc (ℤ.suc-≤-suc ℤ.zero-≤pos))))))
+
+  a*-desc : ∀ n → fst (a* (suc n)) ℚ.< fst (a* n)
+  a*-desc n = ℚ.<-o+ _ _ _
+    (ℚ.<-o· _ _ _ (ℚ.0<ℚ₊ Δ₀₊)
+      ((fst (ℚ.invℚ₊-<-invℚ₊
+        (fromNat (suc (suc n))) ((fromNat (suc (suc (suc n))))))
+                       (ℚ.<ℤ→<ℚ _ _
+                         (ℤ.ℕ≤→pos-≤-pos _ _
+                           ℕ.≤-refl)) )))
+
+  b*-asc : ∀ n → fst (b* n) ℚ.< fst (b* (suc n))
+  b*-asc n = ℚ.<-o+ _ _ _
+   (ℚ.minus-< _ _ (ℚ.<-o· _ _ _ (ℚ.0<ℚ₊ Δ₀₊)
+      (
+         ((fst (ℚ.invℚ₊-<-invℚ₊
+        (fromNat (suc (suc n))) ((fromNat (suc (suc (suc n))))))
+                       (ℚ.<ℤ→<ℚ _ _
+                         (ℤ.ℕ≤→pos-≤-pos _ _
+                           ℕ.≤-refl)) )))))
+
+  fa* : ∀ n → Σ[ r ∈ ℚ ] ((rat r ∈ intervalℙ fa fb)
+             × (absᵣ (rat r -ᵣ f _  (snd (a* n))) <ᵣ rat (fst (Ψ₊ ℚ₊· δₙ n))))
+  fa* n =
+   let (u , v , (_ , z)) = approxF (fst (a* n)) (snd (a* n))
+   in    u (/2₊ (Ψ₊ ℚ₊· δₙ n))
+       , v (/2₊ (Ψ₊ ℚ₊· δₙ n))
+       , (fst (∼≃abs<ε (rat (u (/2₊ (Ψ₊ ℚ₊· δₙ n)))) _ (Ψ₊ ℚ₊· δₙ n))
+         (subst∼ (sym (ℚ.+Assoc _ _ _) ∙
+           cong (fst (/2₊ (Ψ₊ ℚ₊· δₙ n)) ℚ.+_)
+              (cong fst (ℚ./4₊+/4₊≡/2₊ (Ψ₊ ℚ₊· δₙ n)) )
+             ∙ ℚ.ε/2+ε/2≡ε (fst (Ψ₊ ℚ₊· δₙ n)))
+           (triangle∼
+            (𝕣-lim-self _ _ (/2₊ (Ψ₊ ℚ₊· δₙ n)) (/4₊ (Ψ₊ ℚ₊· δₙ n)))
+            (≡→∼ {(/4₊ (Ψ₊ ℚ₊· δₙ n))} z))))
+
+  fb* : ∀ n → Σ[ r ∈ ℚ ] ((rat r ∈ intervalℙ fa fb)
+             × (absᵣ (rat r -ᵣ f _  (snd (b* n))) <ᵣ rat (fst (Ψ₊ ℚ₊· δₙ n))))
+  fb* n =
+   let (u , v , (_ , z)) = approxF (fst (b* n)) (snd (b* n))
+   in    u (/2₊ (Ψ₊ ℚ₊· δₙ n))
+       , v (/2₊ (Ψ₊ ℚ₊· δₙ n))
+       , (fst (∼≃abs<ε (rat (u (/2₊ (Ψ₊ ℚ₊· δₙ n)))) _ (Ψ₊ ℚ₊· δₙ n))
+         (subst∼ (sym (ℚ.+Assoc _ _ _) ∙
+           cong (fst (/2₊ (Ψ₊ ℚ₊· δₙ n)) ℚ.+_)
+              (cong fst (ℚ./4₊+/4₊≡/2₊ (Ψ₊ ℚ₊· δₙ n)) )
+             ∙ ℚ.ε/2+ε/2≡ε (fst (Ψ₊ ℚ₊· δₙ n)))
+           (triangle∼
+            (𝕣-lim-self _ _ (/2₊ (Ψ₊ ℚ₊· δₙ n)) (/4₊ (Ψ₊ ℚ₊· δₙ n)))
+            (≡→∼ {(/4₊ (Ψ₊ ℚ₊· δₙ n))} z))))
+
+  faΔ : ∀ n → f (rat (fst (a* n))) (snd (a* n))
+          ∼[ L ℚ₊· (2 ℚ₊· (Δ₀₊ ℚ₊· ([ 1 / 2+ n ] , tt))) ] fa
+  faΔ n =
+   let z = lipF (rat a) a∈
+                (rat (fst (a* n))) ((snd (a* n)))
+                 (2 ℚ₊· (Δ₀₊ ℚ₊· ([ 1 / 1+ (suc n) ] , _)))
+                 ((+IdL _ subst∼[ refl ]
+                            (+ᵣComm (rat (Δ₀ ℚ.· [ 1 / 2+ n ])) (rat a)
+                             ∙ +ᵣ-rat _ _) )
+                            (+ᵣ-∼ 0 (rat (Δ₀ ℚ.· [ 1 / 1+ (suc n) ]))
+                              (rat a)
+                              (2 ℚ₊· (Δ₀₊ ℚ₊· ([ 1 / 1+ (suc n) ] , _)))
+                              (invEq (∼≃abs<ε _ _ _)
+                                (isTrans≡<ᵣ _ _ _
+                                  (minusComm-absᵣ _ _ ∙∙
+                                    cong absᵣ (𝐑'.+IdR' _ _ (-ᵣ-rat 0)) ∙∙
+                                      absᵣPos _
+                                      (snd (ℚ₊→ℝ₊ (Δ₀₊ ℚ₊· ([ 1 / 1+ (suc n) ] , _))))
+                                      ∙ cong rat (sym (ℚ.·IdL _)))
+                                  (<ℚ→<ᵣ _ _
+                                    (ℚ.<-·o 1 2 (fst (Δ₀₊ ℚ₊· ([ pos 1 / 2+ n ] , tt)))
+                                     (ℚ.0<ℚ₊ (Δ₀₊ ℚ₊· ([ pos 1 / 2+ n ] , tt)))
+                                     ℚ.decℚ<?
+                                     ))))))
+
+   in (sym∼ _ _ _ z)
+
+  -- fa# : ∀ n → f (rat (fst (a* n))) (snd (a* n))
+  --         ∼[ L ℚ₊· (2 ℚ₊· (Δ₀₊ ℚ₊· ([ 1 / 2+ n ] , tt))) ] fa
+  -- fa# n =
+  --  let z = {!!}
+  --  in (sym∼ _ _ _ z)
+
+
+  fbΔ : ∀ n → f (rat (fst (b* n))) (snd (b* n))
+          ∼[ L ℚ₊· (2 ℚ₊· (Δ₀₊ ℚ₊· ([ 1 / 2+ n ] , tt))) ] fb
+  fbΔ n =
+   sym∼ _ _ _ $
+     lipF (rat b) b∈
+                (rat (fst (b* n))) ((snd (b* n)))
+                 (2 ℚ₊· (Δ₀₊ ℚ₊· ([ 1 / 1+ (suc n) ] , _)))
+                 (
+                  (+IdL _ subst∼[ refl ]
+                   (+ᵣComm (rat (ℚ.- (Δ₀ ℚ.· [ 1 / 2+ n ]))) (rat b)
+                     ∙ +ᵣ-rat _ _) )
+                   (+ᵣ-∼ 0 (rat (ℚ.- (Δ₀ ℚ.· [ 1 / 1+ (suc n) ])))
+                     (rat b)
+                     (2 ℚ₊· (Δ₀₊ ℚ₊· ([ 1 / 1+ (suc n) ] , _)))
+
+                     ( (refl subst∼[ refl ] -ᵣ-rat _)
+                       (invEq (∼≃abs<ε _ _ _)
+                       ((isTrans≡<ᵣ _ _ _
+                         (cong (absᵣ ∘ (0 +ᵣ_)) (-ᵣInvol _)
+                           ∙∙
+                           cong absᵣ (+IdL _) ∙∙
+                             absᵣPos _
+                             (snd (ℚ₊→ℝ₊ (Δ₀₊ ℚ₊· ([ 1 / 1+ (suc n) ] , _))))
+                             ∙ cong rat (sym (ℚ.·IdL _)))
+                         (<ℚ→<ᵣ _ _
+                           (ℚ.<-·o 1 2 (fst (Δ₀₊ ℚ₊· ([ pos 1 / 2+ n ] , tt)))
+                            (ℚ.0<ℚ₊ (Δ₀₊ ℚ₊· ([ pos 1 / 2+ n ] , tt)))
+                            ℚ.decℚ<?
+                            ))))))))
+
+
+  Φ = (((L ℚ₊· 2) ℚ₊· Δ₀₊) ℚ₊+ (invℚ₊ K ℚ₊· Δ₀₊))
+
+  fa*Δ : ∀ n → rat (fst (fa* n)) -ᵣ fa <ᵣ
+                  rat ([ 1 / 1+ (suc n) ] ℚ.· fst Φ)
+
+  fa*Δ n =
+   let z = triangle∼ {w = rat (fst (fa* n))}
+                (sym∼ _ _ _ (faΔ n)) ((sym∼ _ _ _)
+                (invEq (∼≃abs<ε _ _ (Ψ₊ ℚ₊· (([ 1 / (2+ n) ] , _))))
+                 ((isTrans<ᵣ _ _ _ (snd (snd (fa* n)))
+                (<ℚ→<ᵣ _ _ (ℚ.<-o· (fst (δₙ n)) [ 1 / 2+ n ] Ψ
+                (ℚ.0<ℚ₊ Ψ₊)
+                 (ℚ.isTrans< (fst (δₙ n)) [ 1 / (2+ n) ·₊₁ (2+ (suc n)) ]
+                  [ 1 / (2+ n) ]
+                   (x/2<x ([ 1 / (2+ n) ·₊₁ (2+ (suc n)) ] , _))
+                  (subst2 (ℚ._<_) (1/m·1/n {2+ n} {2+ (suc n)})
+                   (ℚ.·IdR [ 1 / 2+ n ])
+                   (ℚ.<-o· [ 1 / 2+ (suc n) ] 1 [ 1 / 2+ n ]
+                   (ℚ.0<→< [ 1 / 2+ n ] tt)
+                   (fst (ℚ.invℚ₊-<-invℚ₊ 1 (fromNat (3 ℕ.+ n)))
+                    (ℚ.<ℤ→<ℚ _ _
+                     (ℤ.ℕ≤→pos-≤-pos  _ _
+                      (ℕ.≤-k+ {0} {k = 2} (ℕ.zero-≤ {suc n})))) ))))))))))
+   in isTrans≤<ᵣ _ _ _
+          (≤absᵣ _)
+           (fst (∼≃abs<ε _ _
+             (([ 1 / 1+ (suc n) ] , _) ℚ₊·
+                 (((L ℚ₊· 2) ℚ₊· Δ₀₊) ℚ₊+ (invℚ₊ K ℚ₊· Δ₀₊)))) (subst∼
+             (cong₂ ℚ._+_ (ℚ.·Assoc (fst L) 2 ((Δ₀ ℚ.· [ 1 / 1+ (suc n) ]))
+                 ∙ ℚ.·Assoc _ _ _)
+               refl
+               ∙∙ sym (ℚ.·DistR+ _ _ [ 1 / 1+ (suc n) ])
+               ∙∙ ℚ.·Comm _ _ )
+           (sym∼ _ _ _ z)))
+
+  fb*Δ : ∀ n → fb -ᵣ rat (fst (fb* n))  <ᵣ
+                  rat ([ 1 / 1+ (suc n) ] ℚ.· fst Φ)
+  fb*Δ n =
+   let z = triangle∼ {w = rat (fst (fb* n))}
+                (sym∼ _ _ _ (fbΔ n)) ((sym∼ _ _ _)
+                (invEq (∼≃abs<ε _ _ (Ψ₊ ℚ₊· (([ 1 / (2+ n) ] , _))))
+                 ((isTrans<ᵣ _ _ _ (snd (snd (fb* n)))
+                (<ℚ→<ᵣ _ _ (ℚ.<-o· (fst (δₙ n)) [ 1 / 2+ n ] Ψ
+                (ℚ.0<ℚ₊ Ψ₊)
+                 (ℚ.isTrans< (fst (δₙ n)) [ 1 / (2+ n) ·₊₁ (2+ (suc n)) ]
+                  [ 1 / (2+ n) ]
+                   (x/2<x ([ 1 / (2+ n) ·₊₁ (2+ (suc n)) ] , _))
+                  (subst2 (ℚ._<_) (1/m·1/n {2+ n} {2+ (suc n)})
+                   (ℚ.·IdR [ 1 / 2+ n ])
+                   (ℚ.<-o· [ 1 / 2+ (suc n) ] 1 [ 1 / 2+ n ]
+                   (ℚ.0<→< [ 1 / 2+ n ] tt)
+                   (fst (ℚ.invℚ₊-<-invℚ₊ 1 (fromNat (3 ℕ.+ n)))
+                    (ℚ.<ℤ→<ℚ _ _
+                     (ℤ.ℕ≤→pos-≤-pos  _ _
+                      (ℕ.≤-k+ {0} {k = 2} (ℕ.zero-≤ {suc n})))) ))))))))))
+   in isTrans≤<ᵣ _ _ _
+          (≤absᵣ _)
+           (fst (∼≃abs<ε _ _
+             (([ 1 / 1+ (suc n) ] , _) ℚ₊·
+                 (((L ℚ₊· 2) ℚ₊· Δ₀₊) ℚ₊+ (invℚ₊ K ℚ₊· Δ₀₊)))) (subst∼
+             (cong₂ ℚ._+_ (ℚ.·Assoc (fst L) 2 ((Δ₀ ℚ.· [ 1 / 1+ (suc n) ]))
+                 ∙ ℚ.·Assoc _ _ _)
+               refl
+               ∙∙ sym (ℚ.·DistR+ _ _ [ 1 / 1+ (suc n) ])
+               ∙∙ ℚ.·Comm _ _ ) z))
+
+
+  fa*-desc : ∀ n → rat (fst (fa* (suc n))) <ᵣ rat (fst (fa* n))
+  fa*-desc n =
+     isTrans<ᵣ _ _ _
+       (a-b<c⇒a<c+b _ _ _
+         (isTrans≤<ᵣ _ _ _ (≤absᵣ _) (snd (snd (fa* (suc n))))))
+       (isTrans≤<ᵣ _ _ _
+         (fst (x+y≤x'-y'≃x+y'≤x'-y _ _ _ _)
+           (isTrans≤≡ᵣ _ _ _
+
+            (isTrans≡≤ᵣ _ _ _
+               (+ᵣ-rat _ _)
+                (apartFrom-Invlipschitz-ℝ→ℝℙ
+           K _ f lip⁻¹F _ _ _ _
+                 ((Ψ₊ ℚ₊· δₙ (suc n)) ℚ₊+ (Ψ₊ ℚ₊· δₙ n))
+                 (subst2 _≤ᵣ_
+                   (cong rat (cong (ℚ._· (fst (δₙ (suc n)) ℚ.+ fst (δₙ n)))
+                      (sym (ℚ.y·[x/y] K Δ₀)) ∙ sym (ℚ.·Assoc _ _ _)
+                     ∙ cong ((fst K) ℚ.·_)
+                     ((ℚ.·DistL+ Ψ (fst (δₙ (suc n)))
+                       (fst (δₙ n))))))
+                   (cong rat ((𝐐'.·DistR- Δ₀ _ _) ∙ sym lem--081)
+                    ∙ sym (absᵣPos _ ((<ℚ→<ᵣ _ _ (ℚ.-< _ _ (a*-desc n)))))
+                    ∙ cong absᵣ (sym (-ᵣ-rat₂ _ _)))
+                   (≤ℚ→≤ᵣ _ _
+                     (ℚ.≤-o·
+                       (fst (δₙ (suc n)) ℚ.+ fst (δₙ n))
+                        ([ 1 / 2+ n ] ℚ.- [ 1 / 2+ suc n ])
+                        _ (ℚ.0≤ℚ₊ Δ₀₊)
+                       (subst (fst (δₙ (suc n)) ℚ.+ fst (δₙ n) ℚ.≤_)
+                         (sym (1/n-1/sn (suc n)))
+                         (ℚ.isTrans≤
+                           (fst (δₙ (suc n)) ℚ.+ fst (δₙ n))
+                           (fst (δₙ n) ℚ.+ fst (δₙ n))
+                           [ 1 / ((2+ n) ·₊₁ (2+ (suc n))) ]
+                           ((ℚ.≤-+o (fst (δₙ (suc n)))
+                             (fst (δₙ n)) (fst (δₙ n)) (δₙ₊₁≤δₙ n) ))
+                           ((ℚ.≡Weaken≤
+                             ((fst (δₙ n)) ℚ.+ (fst (δₙ n)))
+                             [ 1 / ((2+ n) ·₊₁ (2+ (suc n))) ]
+                            (ℚ.ε/2+ε/2≡ε
+                             [ 1 / ((2+ n) ·₊₁ (2+ (suc n))) ]))))))))))
+             (absᵣPos _ (x<y→0<y-x _ _
+                (incrF _ _ _ _ (<ℚ→<ᵣ _ _ (a*-desc n)))))
+           ))
+         (a-b<c⇒a-c<b _ _ _ (isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+           (isTrans≡<ᵣ _ _ _ (minusComm-absᵣ _ _) (snd (snd (fa* (n))))))))
+
+
+  fb*-asc : ∀ n → rat (fst (fb* n)) <ᵣ rat (fst (fb* (suc n)))
+  fb*-asc n =
+    isTrans<ᵣ _ _ _
+      (isTrans<≤ᵣ _ _ _
+        ( isTrans<≡ᵣ _ _ _ (a-b<c⇒a<c+b _ _ _
+         (isTrans≤<ᵣ _ _ _ (≤absᵣ _) (snd (snd (fb* n)))))
+         (+ᵣComm _ _))
+        w )
+      ((a-b<c⇒a-c<b _ _ _
+         (isTrans≤<ᵣ _ _ _
+         (isTrans≤≡ᵣ _ _ _
+           (≤absᵣ _) (minusComm-absᵣ _ _))
+         (snd (snd (fb* (suc n)))))))
+
+   where
+   w : f (rat (b* n .fst)) (snd (b* n))
+        +ᵣ rat (fst ((Ψ₊ ℚ₊· δₙ n))) ≤ᵣ
+        f (rat (b* (suc n) .fst)) (snd (b* (suc n))) +ᵣ
+          -ᵣ rat (fst (Ψ₊ ℚ₊· δₙ (suc n)))
+   w = isTrans≡≤ᵣ _ _ _ (+ᵣComm _ _) $
+        fst (x+y≤x'-y'≃x+y'≤x'-y (rat (fst (Ψ₊ ℚ₊· δₙ n))) _ _ _)
+          (isTrans≤≡ᵣ _ _ _
+            (isTrans≡≤ᵣ _ _ _
+             (+ᵣComm (rat (fst (Ψ₊ ℚ₊· δₙ n))) (rat (fst (Ψ₊ ℚ₊· δₙ (suc n))))
+              ∙ +ᵣ-rat _ _)
+             ((apartFrom-Invlipschitz-ℝ→ℝℙ
+           K _ f lip⁻¹F _ (snd (b* (suc n))) _  (snd (b* n))
+                 ((Ψ₊ ℚ₊· δₙ (suc n)) ℚ₊+ (Ψ₊ ℚ₊· δₙ n))
+                 (subst2 _≤ᵣ_
+                   (cong rat (cong (ℚ._· (fst (δₙ (suc n)) ℚ.+ fst (δₙ n)))
+                      (sym (ℚ.y·[x/y] K Δ₀)) ∙ sym (ℚ.·Assoc _ _ _)
+                     ∙ cong ((fst K) ℚ.·_)
+                     ((ℚ.·DistL+ Ψ (fst (δₙ (suc n)))
+                       (fst (δₙ n))))))
+                       (((cong rat ((𝐐'.·DistR- Δ₀ _ _)
+                         ∙ sym lem--062))
+                    ∙ sym (absᵣPos _ ((<ℚ→<ᵣ _ _ (ℚ.-< _ _ (b*-asc n)))))
+                      ∙ cong absᵣ
+                       (sym (-ᵣ-rat₂ _ _))))
+                   ((≤ℚ→≤ᵣ _ _
+                     (ℚ.≤-o·
+                       (fst (δₙ (suc n)) ℚ.+ fst (δₙ n))
+                        ([ 1 / 2+ n ] ℚ.- [ 1 / 2+ suc n ])
+                        _ (ℚ.0≤ℚ₊ Δ₀₊)
+                       (subst (fst (δₙ (suc n)) ℚ.+ fst (δₙ n) ℚ.≤_)
+                         (sym (1/n-1/sn (suc n)))
+                         (ℚ.isTrans≤
+                           (fst (δₙ (suc n)) ℚ.+ fst (δₙ n))
+                           (fst (δₙ n) ℚ.+ fst (δₙ n))
+                           [ 1 / ((2+ n) ·₊₁ (2+ (suc n))) ]
+                           ((ℚ.≤-+o (fst (δₙ (suc n)))
+                             (fst (δₙ n)) (fst (δₙ n)) (δₙ₊₁≤δₙ n) ))
+                           ((ℚ.≡Weaken≤
+                             ((fst (δₙ n)) ℚ.+ (fst (δₙ n)))
+                             [ 1 / ((2+ n) ·₊₁ (2+ (suc n))) ]
+                            (ℚ.ε/2+ε/2≡ε
+                             [ 1 / ((2+ n) ·₊₁ (2+ (suc n))) ]))))))))))))
+            (absᵣPos _ ((x<y→0<y-x _ _
+                (incrF _ (snd (b* n)) _ (snd (b* (suc n)))
+                                  (<ℚ→<ᵣ _ _ (b*-asc n)))))))
+
+
+  fa*<fb* : ∀ n → fst (fa* (suc n)) ℚ.< fst (fb* (suc n))
+  fa*<fb* n =
+    let z = incrF _ (snd (a* (suc n))) _ (snd (b* (suc n)))
+             (<ℚ→<ᵣ _ _ (a*<b* n))
+        zz = isTrans≤≡ᵣ _ _ _ (apartFrom-Invlipschitz-ℝ→ℝℙ
+                   K _ f lip⁻¹F
+                   _ (snd (b* (suc n)))
+                   _ (snd (a* (suc n)))
+                   (invℚ₊ K ℚ₊· (Δ₀₊ ℚ₊·
+                     (ℚ.<→ℚ₊ _ 1
+                       (subst (ℚ._< 1)
+                         (sym (ℚ.n/k+m/k 1 1 (2+ suc n)))
+                          (invEq ([n/m]<1 _ _)
+                            (ℕ.<-k+ {0} {k = 2} ℕ.zero-<-suc))) )))
+                    (≡ᵣWeaken≤ᵣ _ _
+                      (  cong rat
+                           (((ℚ.y·[x/y] K _ ∙ 𝐐'.·DistR- Δ₀ _ _) ∙
+                             cong₂ (ℚ._+_)
+                               (ℚ.·IdR _)
+                               (cong (ℚ.-_)
+                               (ℚ.·DistL+ Δ₀ _ _) ∙ sym (𝐐'.-Dist _ _)))
+                            ∙∙ 𝐐'.+ShufflePairs _ _ _ _
+                            ∙∙ cong (b* (suc n) .fst ℚ.+_)
+                                (𝐐'.-Dist _ _))
+                       ∙ sym (-ᵣ-rat₂ _ _) ∙ sym
+                          (absᵣPos _
+                        (x<y→0<y-x _ _ (<ℚ→<ᵣ _ _ (a*<b* n))))
+
+                        )))
+                        (absᵣPos _ (x<y→0<y-x _ _ z))
+        zA = a-b<c⇒a<c+b (rat (fst (fa* (suc n))))
+                (f (rat (a* (suc n) .fst)) (snd (a* (suc n))))
+                _
+              ((isTrans≤<ᵣ _ _ _ (≤absᵣ _) (snd (snd (fa* (suc n))))))
+        zB = a-b<c⇒a-c<b _ (rat (fst (fb* (suc n)))) _
+              ((isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+                (isTrans≡<ᵣ _ _ _ (minusComm-absᵣ _ _) (snd (snd (fb* (suc n)))))))
+        1/sssn≤1/3 = (fst (ℚ.invℚ₊-≤-invℚ₊ 3 (fromNat (suc (suc (suc n))))))
+                       (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _
+                        (ℕ.<-k+ {0} {k = 2} ℕ.zero-<-suc))
+                         )
+        zzs = (<ℚ→<ᵣ _ _
+                              (ℚ.<≤Monotone+
+                                _ _ _ _
+                                 (ℚ.isTrans<≤ _ ([ 1 / 2+ suc n ]) _
+                                  (subst2 (ℚ._<_)
+                                    ( cong ([ 1 /_])
+                                          (·₊₁-comm _ _)
+                                     ∙ ℚ.riseQandD 1 _ _
+                                     ∙∙ cong₂ ([_/_] ∘ ℚ.ℕ₊₁→ℤ)
+                                          (·₊₁-identityˡ 2)
+                                          refl
+                                     ∙∙ sym (ℚ.n/k+m/k _ _ _))
+                                     (cong ([ 1 /_]) (·₊₁-identityˡ _))
+                                    ((fst (ℚ.invℚ₊-<-invℚ₊
+                                      (fromNat (1 ℕ.· (suc (suc (suc n)))))
+                                      (fromNat (ℕ₊₁→ℕ
+                                         ((2+ suc (suc n)) ·₊₁ (2+ suc n)))))
+                                        (ℚ.<ℤ→<ℚ _ _
+                                         (ℤ.ℕ≤→pos-≤-pos _ _
+                                           (ℕ.<-·sk {k = (suc (suc n))}
+                                             ((ℕ.<-k+ {0} {k = 1} ℕ.zero-<-suc))))))))
+                                  1/sssn≤1/3 )
+                                (ℚ.≤Monotone+
+                                 (([ 1 / 2+ suc n ])) [ 1 / 3 ]
+                                 (([ 1 / 2+ suc n ])) [ 1 / 3 ]
+                                 1/sssn≤1/3
+                                 1/sssn≤1/3))
+                              )
+        qzz = (a+c<b⇒a<b-c _ 1
+                           (rat ([ 1 / 2+ suc n ] ℚ.+ [ 1 / 2+ suc n ]))
+                            (isTrans<≡ᵣ _ _ _ (isTrans≡<ᵣ _ _ _
+                               (+ᵣ-rat _ _) zzs)
+                              (cong rat (ℚ.ε/3+ε/3+ε/3≡ε 1))))
+        wzqq = (<ℚ→<ᵣ _ _ (subst2 ℚ._<_
+                        (ℚ.·DistL+ Ψ _ _)
+                        (sym (ℚ.·Assoc (fst (invℚ₊ K)) Δ₀ _))
+                        (ℚ.<-o· _ _ _ (ℚ.0<ℚ₊ Ψ₊)
+
+                          (<ᵣ→<ℚ _ _ (isTrans<≡ᵣ _ _ _
+                            qzz (-ᵣ-rat₂ _ _)))
+                            )))
+    in <ᵣ→<ℚ _ _ (isTrans<ᵣ _ _ _
+                zA
+                (isTrans<ᵣ _ _ _
+                  (fst (x+y<x'-y'≃x+y'<x'-y _ _ _ _)
+                    (isTrans<≤ᵣ _ _ _
+                       (isTrans≡<ᵣ _ _ _
+                         (+ᵣ-rat _ _)
+                         wzqq)
+
+                      zz) )
+                  zB))
+
+  interval*⊆ : ∀ n
+    →  intervalℙ (rat (fst (fa* n))) (rat (fst (fb* n)))
+     ⊆ intervalℙ fa fb
+  interval*⊆ n x (≤x , x≤) =
+     (isTrans≤ᵣ _ _ _ (fst (fst (snd (fa* n)))) ≤x)
+   , (isTrans≤ᵣ _ _ _ x≤ (snd (fst (snd (fb* n)))))
+
+  interval*⊆o : ∀ n
+    →  intervalℙ (rat (fst (fa* n))) (rat (fst (fb* n)))
+     ⊆ ointervalℙ fa fb
+  interval*⊆o n x (≤x , x≤) =
+     (isTrans<≤ᵣ _ _ _
+        (isTrans≤<ᵣ _ _ _ ((fst (fst (snd (fa* (suc n))))))
+           (fa*-desc n)) ≤x)
+   , (isTrans≤<ᵣ _ _ _ x≤
+       (isTrans<≤ᵣ _ _ _ (fb*-asc n)
+         (snd (fst (snd (fb* (suc n)))))))
+
+
+  module Fₙ (n : ℕ) where
+
+
+   fₙ : Σ[ 𝒇⁻¹ ∈ (ℝ → ℝ) ] ((∀ x → x ∈ intervalℙ (rat (fst (fa* (suc n))))
+                                 (rat (fst (fb* (suc n))))
+                               → 𝒇⁻¹ x ∈ intervalℙ
+                                      (𝒇⁻¹ (rat (fst (fa* (suc n)))))
+                                      (𝒇⁻¹ (rat (fst (fb* (suc n))))) )
+                           × ((Lipschitz-ℝ→ℝ K 𝒇⁻¹) ×
+                (((x : ℚ)
+                  (x∈ : rat x ∈ intervalℙ (rat (fst (fa* (suc n))))
+                                 (rat (fst (fb* (suc n))))) →
+                 𝒇⁻¹ (rat x) ≡ f⁻¹ x (interval*⊆ (suc n) (rat x) x∈)))))
+   fₙ = flg , g∈ , X
+    where
+
+    g = extend-Lipshitzℚ→ℝ K _ _
+         (ℚ.<Weaken≤ _ _ (fa*<fb* n))
+          (λ x x∈ → f⁻¹ x (interval*⊆ (suc n) (rat x) x∈))
+           λ q q∈ r r∈ → f⁻¹-L q _ r _
+
+    flg = (λ z → fromLipschitz K (map-snd (λ r → fst r) g) .fst z)
+    X = (snd (fromLipschitz K (map-snd fst g)) , λ x x∈ → snd (snd g) x x∈)
+
+
+
+    flg-mon : (x : ℚ)
+              (x∈ : rat x ∈ intervalℙ (rat (fst (fa* (suc n))))
+                             (rat (fst (fb* (suc n)))))
+              (y : ℚ)
+              (y∈ : rat y ∈ intervalℙ (rat (fst (fa* (suc n))))
+                             (rat (fst (fb* (suc n)))))
+              → x ℚ.< y → flg (rat x) <ᵣ flg (rat y)
+    flg-mon x x∈ y y∈ x<y =
+       let xP = cong₂ f (snd X x x∈) {transport _ _}
+                 {f⁻¹∈ x (interval*⊆ (suc n) (rat x) x∈)}
+                  (symP (transport-filler _ _))
+                  ∙ f∘f⁻¹ _ _
+           yP = cong₂ f (snd X y y∈) {transport _ _}
+                 {f⁻¹∈ y (interval*⊆ (suc n) (rat y) y∈)}
+                  (symP (transport-filler _ _))
+                  ∙ f∘f⁻¹ _ _
+       in invMon (flg (rat x)) _ (flg (rat y)) _
+                   (subst2 _<ᵣ_ (sym xP) (sym yP)
+                     (<ℚ→<ᵣ _ _ x<y))
+
+    flg-monNS : (x : ℚ)
+              (x∈ : rat x ∈ intervalℙ (rat (fst (fa* (suc n))))
+                             (rat (fst (fb* (suc n)))))
+              (y : ℚ)
+              (y∈ : rat y ∈ intervalℙ (rat (fst (fa* (suc n))))
+                             (rat (fst (fb* (suc n)))))
+              → x ℚ.≤ y → flg (rat x) ≤ᵣ flg (rat y)
+    flg-monNS x x∈ y y∈ =
+      ⊎.rec (≡ᵣWeaken≤ᵣ _ _ ∘ cong (flg ∘ rat) )
+        (<ᵣWeaken≤ᵣ _ _ ∘ flg-mon x x∈ y y∈)
+        ∘ ℚ.≤→≡⊎< _ _
+
+
+    g∈ : ∀ x (x∈ : x ∈ intervalℙ
+                (rat (fst (fa* (suc n))))
+                (rat (fst (fb* (suc n)))))
+           → flg x ∈ intervalℙ
+            (flg (rat (fst (fa* (suc n)))))
+            (flg (rat (fst (fb* (suc n)))))
+    g∈ x x∈@(≤x , x≤) =
+     (x<y+δ→x≤y (flg (rat (fst (fa* (suc n))))) (flg x) (λ ε →
+      PT.rec (isProp<ᵣ (flg (rat (fst (fa* (suc n)))))
+                (flg x +ᵣ rat (fst ε)))
+        (λ (η' , x<η' , η<') →
+          let η = ℚ.min η' (fst (fb* (suc n)))
+              x≤η = ≤min-lem _ _ _ (<ᵣWeaken≤ᵣ _ _ x<η') x≤
+              η< = isTrans≤<ᵣ _ _ _
+                    (≤ℚ→≤ᵣ _ _  (ℚ.min≤ η' _)) η<'
+              a*∈ : (rat (fst (fa* (suc n)))) ∈
+                      intervalℙ (rat (fst (fa* (suc n))))
+                             (rat (fst (fb* (suc n))))
+              a*∈ = ((≤ᵣ-refl _) , (
+                     ≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ (fa*<fb* n))))
+              η∈ : (rat η) ∈
+                      intervalℙ (rat (fst (fa* (suc n))))
+                             (rat (fst (fb* (suc n))))
+              η∈ =  (isTrans≤ᵣ _ _ _ ≤x x≤η) ,
+                    ≤ℚ→≤ᵣ _ _ (ℚ.min≤' η' _)
+              z : flg (rat (fst (fa* (suc n)))) ≤ᵣ flg (rat η)
+              z = flg-monNS (fst (fa* (suc n)))
+                    a*∈
+                    η η∈
+                    (≤ᵣ→≤ℚ _ _
+                      (isTrans≤ᵣ _ _ _
+                        ≤x x≤η))
+              zz' = (fst X (rat η) x  (invℚ₊ K ℚ₊· ε))
+                   ((invEq (∼≃abs<ε _ _ _)
+                      (isTrans≡<ᵣ _ _ _
+                        (absᵣNonNeg _ (x≤y→0≤y-x _ _ x≤η))
+                        (a<c+b⇒a-c<b _ _ _ η<))))
+              z' : flg (rat η) <ᵣ flg x +ᵣ rat (fst ε)
+              z' = isTrans<≡ᵣ _ _ _ (a-b<c⇒a<c+b _ _ _ (isTrans≤<ᵣ _ _ _
+                     (≤absᵣ _) (fst (∼≃abs<ε _ _ _) zz')))
+
+                     (+ᵣComm (rat (fst (K ℚ₊· (invℚ₊ K ℚ₊· ε)))) _ ∙
+                      cong (flg x +ᵣ_) (cong rat
+                        (ℚ.y·[x/y] K _)))
+              zzz : flg (rat (fst (fa* (suc n))))
+                     <ᵣ flg x +ᵣ rat (fst ε)
+              zzz = isTrans≤<ᵣ (flg (rat (fst (fa* (suc n)))))
+                   (flg (rat η))
+                     (flg x +ᵣ rat (fst ε)) z z'
+              in zzz)
+        (denseℚinℝ x (x +ᵣ rat (fst (invℚ₊ K ℚ₊· ε)))
+          (isTrans≡<ᵣ _ _ _
+             (sym (+IdR _))
+              (<ᵣ-o+ _ _ _ (snd (ℚ₊→ℝ₊ (invℚ₊ K ℚ₊· ε))))))
+      ))
+     ,
+     x<y+δ→x≤y (flg x) (flg (rat (fst (fb* (suc n))))) λ ε →
+      PT.rec (isProp<ᵣ (flg x) (flg (rat (fst (fb* (suc n)))) +ᵣ rat (fst ε)))
+       (λ (η' , <η' , η'<x) →
+         let η = ℚ.max η' (fst (fa* (suc n)))
+             η≤x : rat η ≤ᵣ x
+             η≤x = max≤-lem _ _ _ (<ᵣWeaken≤ᵣ _ _ η'<x) ≤x
+             <η = isTrans<≤ᵣ _ _ _
+                     <η' (≤ℚ→≤ᵣ _ _  (ℚ.≤max η' (fst (fa* (suc n)))))
+             b*∈ : (rat (fst (fb* (suc n)))) ∈
+                      intervalℙ (rat (fst (fa* (suc n))))
+                             (rat (fst (fb* (suc n))))
+             b*∈ = ≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ (fa*<fb* n)) , ≤ᵣ-refl _
+             η∈ : (rat η) ∈
+                      intervalℙ (rat (fst (fa* (suc n))))
+                             (rat (fst (fb* (suc n))))
+             η∈ =  ≤ℚ→≤ᵣ _ _ (ℚ.≤max' η' _)
+                  , (isTrans≤ᵣ _ _ _  η≤x x≤)
+             z : flg (rat η) ≤ᵣ  flg (rat (fst (fb* (suc n))))
+             z = flg-monNS η η∈
+                   (fst (fb* (suc n))) b*∈
+                    (≤ᵣ→≤ℚ _ _
+                      (isTrans≤ᵣ _ _ _ η≤x x≤ ))
+             zz' = (fst X x (rat η)  (invℚ₊ K ℚ₊· ε))
+                   ((invEq (∼≃abs<ε _ _ _)
+                      (isTrans≡<ᵣ _ _ _
+                        (absᵣNonNeg _ (x≤y→0≤y-x _ _ η≤x))
+                        (a-b<c⇒a-c<b _ _ _ <η))))
+             z' : flg x <ᵣ flg (rat η)  +ᵣ rat (fst ε)
+             z' = isTrans<≡ᵣ _ _ _ (a-b<c⇒a<c+b _ _ _ (isTrans≤<ᵣ _ _ _
+                     (≤absᵣ _) (fst (∼≃abs<ε _ _ _) zz')))
+                     (+ᵣComm (rat (fst (K ℚ₊· (invℚ₊ K ℚ₊· ε)))) (flg (rat η)) ∙
+                      cong (flg (rat η) +ᵣ_) (cong rat
+                        (ℚ.y·[x/y] K _)))
+             zzz : flg x <ᵣ flg (rat (fst (fb* (suc n)))) +ᵣ rat (fst ε)
+             zzz = isTrans<≤ᵣ _ _ _
+                     z' (≤ᵣ-+o _ _ _ z)
+         in zzz)
+        ((denseℚinℝ (x -ᵣ rat (fst (invℚ₊ K ℚ₊· ε))) x
+          (isTrans<≡ᵣ _ _ _
+            ((<ᵣ-o+ _ _ _
+              (-ᵣ<ᵣ _ _ (snd (ℚ₊→ℝ₊ (invℚ₊ K ℚ₊· ε)))))) (𝐑'.+IdR' _ _ (-ᵣ-rat 0)))))
+
+
+
+
+  lem-fₙ∈ : ∀ n → rat a <ᵣ Fₙ.fₙ n .fst (rat (fst (fa* (suc n))))
+  lem-fₙ∈ n =
+   let a*∈ = (≤ᵣ-refl _) , (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ (fa*<fb* n)))
+       zz : _ <ᵣ _
+       zz = invMon
+               (rat a)
+               a∈ _
+               _ (isTrans<≡ᵣ _ _ _
+                 (isTrans≤<ᵣ _ _ _
+                   (fst (fst (snd (fa* (suc (suc n))))))
+                   (fa*-desc (suc n)))
+                  (sym (f∘f⁻¹ _ _)))
+
+   in isTrans<≡ᵣ _ _ _ zz
+       (sym (snd (snd (snd (Fₙ.fₙ n))) (fst (fa* (suc n)))
+           a*∈))
+
+
+
+  lem-fₙ∈' : ∀ n → Fₙ.fₙ n .fst (rat (fst (fb* (suc n)))) <ᵣ rat b
+  lem-fₙ∈' n =
+   let a*∈ = (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ (fa*<fb* n))) , (≤ᵣ-refl _)
+       zz : _ <ᵣ _
+       zz = invMon _
+               _ (rat b) b∈
+               (isTrans≡<ᵣ _ _ _ ((f∘f⁻¹ _ _))
+                 (isTrans<≤ᵣ _ _ _
+                   (fb*-asc (suc n))
+                   (snd (fst (snd (fb* (suc (suc n))))))))
+
+   in isTrans≡<ᵣ _ _ _
+       ((snd (snd (snd (Fₙ.fₙ n))) (fst (fb* (suc n)))
+           a*∈)) zz
+
+
+  fₙ∈ : ∀ n → ∀ x → x ∈ intervalℙ (rat (fst (fa* (suc n))))
+                                 (rat (fst (fb* (suc n))))
+                             → fst (Fₙ.fₙ n) x ∈ ointervalℙ (rat a) (rat b)
+  fₙ∈ n x x∈ =
+   let (<x , x<) = fst (snd (Fₙ.fₙ n)) x x∈
+   in (isTrans<≤ᵣ _ _ _ (lem-fₙ∈ n) <x)
+      , (isTrans≤<ᵣ _ _ _ x< (lem-fₙ∈' n))
+
+  invSeq : Seq⊆
+  invSeq .Seq⊆.𝕡 n =
+    intervalℙ (rat (fst (fa* (suc n)))) (rat (fst (fb* (suc n))))
+  invSeq .Seq⊆.𝕡⊆ n x (≤x , x≤) =
+      isTrans≤ᵣ _ _ _ (<ᵣWeaken≤ᵣ _ _ $ fa*-desc (suc n)) ≤x
+    , isTrans≤ᵣ _ _ _ x≤ (<ᵣWeaken≤ᵣ _ _ $ fb*-asc (suc n))
+
+  seg→ : Seq⊆→ ℝ invSeq
+  seg→ .Seq⊆→.fun x n _ = fst (Fₙ.fₙ n) x
+
+  seg→ .Seq⊆→.fun⊆ x n m x∈ x∈' n<m =
+    cong (fst (Fₙ.fₙ n))
+      (∈ℚintervalℙ→clampᵣ≡ _ _ _ x∈) ∙∙
+     ≡Continuous _ _
+       (IsContinuous∘ _ _
+          ((Lipschitz→IsContinuous K _
+        (fst (snd (snd (Fₙ.fₙ n))))))
+         (IsContinuousClamp (rat (fst (fa* (suc n)))) _))
+       (IsContinuous∘ _ _
+          ((Lipschitz→IsContinuous K _
+        (fst (snd (snd (Fₙ.fₙ m))))))
+         (IsContinuousClamp (rat (fst (fa* (suc n)))) _))
+
+       (λ r →
+          let r∈ = ((clampᵣ∈ℚintervalℙ _ _
+                 (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ ( fa*<fb* n)))
+                  (rat r)))
+          in (snd (snd (snd (Fₙ.fₙ n)))) _
+                 r∈
+                 ∙∙ cong (f⁻¹ _) (snd (intervalℙ fa fb _) _ _)
+                   ∙∙
+                  sym ((snd (snd (snd (Fₙ.fₙ m)))) _
+                    (Seq⊆.𝕡⊆' invSeq n m ((ℕ.<-weaken n<m )) _ r∈)))
+                    x
+     ∙∙ cong (fst (Fₙ.fₙ m))
+       (sym (∈ℚintervalℙ→clampᵣ≡ _ _ _ x∈))
+
+   where
+    x∈'' = Seq⊆.𝕡⊆' invSeq n m ((ℕ.<-weaken n<m )) x x∈
+
+
+  invSeq⊆⟨fa,fb⟩ : invSeq Seq⊆.s⊇ ointervalℙ fa fb
+  invSeq⊆⟨fa,fb⟩ x (<x , x<) =
+   PT.map2
+     (λ (q , (<q , q<)) (r , (<r , r<)) →
+      let q⊔r = ℚ.min₊ (q , ℚ.<→0< q (<ᵣ→<ℚ _ _ <q))
+                   (r , ℚ.<→0< r (<ᵣ→<ℚ _ _ <r))
+
+          (N₊ , <N') = map-snd
+                (subst (ℚ._≤ fst q⊔r) (ℚ.·Comm _ _) ∘ ℚ.x≤y·z→x·invℚ₊y≤z _ _ _ ∘
+                  subst (fst Φ ℚ.≤_) (ℚ.·Comm _ _)
+                  ∘ ℚ.x·invℚ₊y≤z→x≤y·z _ _ _ ∘ ℚ.<Weaken≤ _ _)
+                (ℚ.ceilℚ₊ (Φ ℚ₊· (invℚ₊ q⊔r) ))
+          N = (ℕ₊₁→ℕ N₊)
+
+          <N : ([ 1 / 2+ N ] ℚ.· fst Φ)
+                ℚ.≤ fst q⊔r
+          <N = ℚ.isTrans≤ _ ([ 1 / N₊ ] ℚ.· fst Φ) _
+                   (ℚ.≤-·o _ _ (fst Φ)
+                    (ℚ.0≤ℚ₊ Φ)
+                    ((fst (ℚ.invℚ₊-≤-invℚ₊
+                         (fromNat ((ℕ₊₁→ℕ N₊)))
+                         (fromNat (suc (suc ((ℕ₊₁→ℕ N₊))))))
+                    ((ℚ.≤ℤ→≤ℚ _ _
+                     (ℤ.ℕ≤→pos-≤-pos  _ _
+                       (ℕ.≤SumRight {k = 2})))) ))) <N'
+
+
+
+      in _ ,
+          (isTrans≤ᵣ _ _ _
+           (a-b≤c⇒a≤c+b _ _ _
+            (isTrans≤ᵣ _ _ _
+              (<ᵣWeaken≤ᵣ _ _ (fa*Δ N))
+              (≤ℚ→≤ᵣ _ _ (ℚ.isTrans≤ _ _ _
+                <N (ℚ.min≤ q r) ))))
+           (a≤b-c⇒a+c≤b (rat q) _ fa
+            (<ᵣWeaken≤ᵣ _ _ q<)) ,
+           isTrans≤ᵣ _ _ _
+             (<ᵣWeaken≤ᵣ _ _ (a<b-c⇒c<b-a _ _ _ r<))
+               (a-b≤c⇒a-c≤b _ _ _
+                 (isTrans≤ᵣ _ _ _
+                   (<ᵣWeaken≤ᵣ _ _ (fb*Δ N))
+                   (≤ℚ→≤ᵣ _ _ (ℚ.isTrans≤ _ _ _
+                      <N (ℚ.min≤' q r) ))))))
+     (denseℚinℝ _ _ (x<y→0<y-x _ _ <x))
+     (denseℚinℝ _ _ (x<y→0<y-x _ _ x<))
+
+
+  open Seq⊆→.FromIntersection seg→ isSetℝ (ointervalℙ fa fb)
+         invSeq⊆⟨fa,fb⟩
+
+
+  𝒇⁻¹ = ∩$
+
+  IsLip-𝒇⁻¹ : Lipschitz-ℝ→ℝℙ K (ointervalℙ fa fb) 𝒇⁻¹
+  IsLip-𝒇⁻¹ u u∈ v v∈ ε =
+    ∩$-elimProp2 u u∈ v v∈
+      {B = λ fu fv → u ∼[ ε  ] v → fu ∼[ K ℚ₊· ε  ] fv}
+      (λ _ _ → isPropΠ λ _ → isProp∼ _ _ _)
+      λ n x∈ y∈ x →
+         fst (snd (snd (Fₙ.fₙ n))) _ _ ε x
+
+  IsContinuous-𝒇⁻¹ : IsContinuousWithPred (ointervalℙ fa fb) 𝒇⁻¹
+  IsContinuous-𝒇⁻¹ = fromLipshitzℚ→ℝℙ→Cont K _ _ _
+    IsLip-𝒇⁻¹
+
+  𝒇⁻¹∈ : ∀ x x∈ →  (𝒇⁻¹ x x∈) ∈ ointervalℙ (rat a) (rat b)
+  𝒇⁻¹∈ x x∈ = ∩$-elimProp x x∈
+     {_∈ ointervalℙ (rat a) (rat b)}
+     (snd ∘ ointervalℙ (rat a) (rat b))
+     λ n x∈ₙ → fₙ∈ n x x∈ₙ
+
+
+
+  f∘𝒇⁻¹ : ∀ x x∈ → fst (fo (𝒇⁻¹  x x∈) (𝒇⁻¹∈  x x∈)) ≡ x
+  f∘𝒇⁻¹ x x∈ = ≡ContinuousWithPred (ointervalℙ fa fb) (ointervalℙ fa fb)
+                (openIintervalℙ fa fb) (openIintervalℙ fa fb) _ _
+                (IsContinuousWP∘ (ointervalℙ (rat a) (rat b)) _
+                  (λ r r∈ → fst (fo r r∈)) 𝒇⁻¹ 𝒇⁻¹∈
+                   (IsContinuousWithPred⊆ _ _ f
+                     (ointervalℙ⊆intervalℙ (rat a) (rat b)) fC)
+                      IsContinuous-𝒇⁻¹)
+                (AsContinuousWithPred _ _ IsContinuousId)
+                (λ r r∈ r∈' →
+                 let zz : (𝒇⁻¹ (rat r) r∈)
+                           ≡ (f⁻¹ r (ointervalℙ⊆intervalℙ fa fb (rat r) r∈))
+                     zz = ∩$-elimProp (rat r) r∈
+                            {λ x → x ≡
+                             (f⁻¹ r
+                              (ointervalℙ⊆intervalℙ fa fb (rat r) r∈))}
+                               (λ _ → isSetℝ _ _)
+                                λ n x∈ →
+                                  snd (snd (snd (Fₙ.fₙ n))) r x∈ ∙
+                                   cong (f⁻¹ r)
+                                     (snd (intervalℙ fa fb (rat r)) _ _)
+                 in cong (uncurry f)
+                       (Σ≡Prop (λ x → snd (intervalℙ (rat a) (rat b) x))
+                        zz )
+                     ∙ f∘f⁻¹ r
+                      (ointervalℙ⊆intervalℙ fa fb (rat r) r∈) ) x x∈ x∈
+
+
+  isSurjection-fo : isSurjection (uncurry fo)
+  isSurjection-fo (x , x∈) =
+   ∣ _ ,
+    (Σ≡Prop (snd ∘ ointervalℙ fa fb) (f∘𝒇⁻¹ x x∈)) ∣₁
+
+  isEquivFo : isEquiv (uncurry fo)
+  isEquivFo = isEmbedding×isSurjection→isEquiv (isEmbed-fo , isSurjection-fo)
+
+  𝒇⁻¹∘f : ∀ x x∈ →  uncurry 𝒇⁻¹ (fo x x∈) ≡ x
+  𝒇⁻¹∘f x x∈ =  cong fst (invEq (congEquiv (_ , isEquivFo))
+    (Σ≡Prop (snd ∘ ointervalℙ fa fb) (uncurry  f∘𝒇⁻¹ (fo x x∈))))
+
+  f-iso : Iso (Σ ℝ (_∈ ointervalℙ (rat a) (rat b)))
+              (Σ ℝ (_∈ ointervalℙ fa fb))
+  f-iso .Iso.fun = uncurry fo
+  f-iso .Iso.inv (x , x∈) = (𝒇⁻¹  x x∈) , (𝒇⁻¹∈  x x∈)
+  f-iso .Iso.rightInv (x , x∈) = Σ≡Prop (snd ∘ ointervalℙ _ _) (f∘𝒇⁻¹ x x∈)
+  f-iso .Iso.leftInv (x , x∈) = Σ≡Prop (snd ∘ ointervalℙ _ _) (𝒇⁻¹∘f x x∈)
diff --git a/Cubical/HITs/CauchyReals/Closeness.agda b/Cubical/HITs/CauchyReals/Closeness.agda
index 979c90f6e1..c2116e7a46 100644
--- a/Cubical/HITs/CauchyReals/Closeness.agda
+++ b/Cubical/HITs/CauchyReals/Closeness.agda
@@ -834,18 +834,18 @@ triangle∼ {u} {v} {w} {ε} {η} x  =
 
 
 
--- _ : ∀ r x y ε → (rat r) ∼'[ ε ] (lim x y) ≡
---               (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ] ((rat r) ∼'[ (fst ε ℚ.- fst δ) , v ] x δ))
--- _ = λ r x y ε → refl
+_ : ∀ 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
+_ : ∀ 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
+_ : ∀ 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
index 2f5ab88109..c8aa25b7b4 100644
--- a/Cubical/HITs/CauchyReals/Continuous.agda
+++ b/Cubical/HITs/CauchyReals/Continuous.agda
@@ -7,12 +7,15 @@ open import Cubical.Foundations.Structure
 open import Cubical.Foundations.Function
 open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Powerset
+open import Cubical.Foundations.Isomorphism
 
 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.Data.Unit
 
 open import Cubical.HITs.PropositionalTruncation as PT
 open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
@@ -33,260 +36,121 @@ 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))
-
 
+open ℚ.HLP
 
--[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
+ -- HoTT Lemma (11.3.41)
 
 
-minusComm-absᵣ : ∀ x y → absᵣ (x +ᵣ (-ᵣ y)) ≡ absᵣ (y +ᵣ (-ᵣ x))
-minusComm-absᵣ x y = -absᵣ _ ∙ cong absᵣ (-[x-y]≡y-x x y)
+-- -- 11.3.42
 
 
-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
+⊤Pred : ℝ → hProp ℓ-zero
+⊤Pred = (λ _ → Unit , isPropUnit )
 
 
+∼→≤ : ∀ u q → u ≤ᵣ (rat q) → ∀ v ε → u ∼'[ ε ] v → v ≤ᵣ rat (q ℚ.+ fst ε)
+∼→≤ u q u≤q v ε u∼v = xxx
 
+ where
 
-∼→≤ : ∀ 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 =
+ opaque
+  unfolding _≤ᵣ_
+  ∼→≤-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 λ v → ∀ ε
+              → rat r ∼'[ ε ] v → v ≤ᵣ rat (q ℚ.+ fst ε)
+   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 λ _ _ → isProp≤ᵣ _ _
+
+  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ℝ _ _
-
 
+  -- zzz =
+  xxx : v ≤ᵣ rat (q ℚ.+ fst ε)
+  xxx = cong (maxᵣ v ∘ rat) (sym (ℚ.≤→max q (q ℚ.+ fst ε)
+          (ℚ.≤+ℚ₊ q q ε (ℚ.isRefl≤ q )))) ∙∙
+            (maxᵣAssoc v (rat q) (rat (q ℚ.+ fst ε)))  ∙∙
+              ∼→≤-rat-u q q (≤ᵣ-refl (rat q)) (maxᵣ v ((rat q))) ε (∼→∼' _ _ _ maxLip)
 
 -- 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'') →
+∼→< u q u<q v ε x = invEq (<ᵣ-impl _ _)
+   (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
+            (fst (<ᵣ-impl _ _) u<q))
+
+  -- 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
 
 
 
@@ -314,17 +178,17 @@ x+[y-x]/2≡y-[y-x]/2 u v =
            (sym (ℚ.·DistR+ v (ℚ.- u) [ 1 / 2 ])) ))
 
 
--- 11.3.43-ii
+-- -- 11.3.43-ii
 
 ∼→<' : ∀ u q → u <ᵣ (rat q) → ∀ v
    → ∃[ ε ∈ ℚ₊ ] (u ∼'[ ε ] v → v <ᵣ rat q)
 ∼→<' u q u<q v =
- PT.map
+  PT.map
       (λ ((u' , q') , z , z' , z'') →
             ℚ./2₊ (ℚ.<→ℚ₊ u' q' z')  ,
               (λ xx →
                 let zwz = ∼→≤  u u'  z v _ xx
-                in ∣ (_ , q') , (zwz ,
+                in invEq (<ᵣ-impl _ _) ∣ (_ , q') , (zwz ,
                   (subst2
                       {x = q' ℚ.- (fst (ℚ./2₊ (ℚ.<→ℚ₊ u' q' z')))}
                       {u' ℚ.+ fst (ℚ./2₊ (ℚ.<→ℚ₊ u' q' z'))}
@@ -334,7 +198,7 @@ x+[y-x]/2≡y-[y-x]/2 u v =
                      (ℚ.<-o+ (ℚ.- fst (ℚ./2₊ (ℚ.<→ℚ₊ u' q' z'))) 0 q'
                           (ℚ.-ℚ₊<0 (ℚ./2₊ (ℚ.<→ℚ₊ u' q' z'))))
                      , z'')) ∣₁ ))
-      u<q
+      (fst (<ᵣ-impl _ _) u<q)
 
 
 -- 11.3.44
@@ -342,75 +206,77 @@ x+[y-x]/2≡y-[y-x]/2 u v =
 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₁
+ opaque
+  unfolding _<ᵣ_ absᵣ
+  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  ε →
@@ -418,6 +284,10 @@ lem-11-3-44 = Elimℝ-Prop.go w
 
 ∼≃abs<ε⇐ u v ε = Elimℝ-Prop2Sym.go w u v ε
  where
+
+ opaque
+  unfolding _<ᵣ_ absᵣ
+
   w : Elimℝ-Prop2Sym λ u v → ∀ ε →
           (absᵣ (u +ᵣ (-ᵣ  v)) <ᵣ rat (fst ε))
             → u ∼[ ε ] v
@@ -507,17 +377,18 @@ lem-11-3-44 = Elimℝ-Prop.go w
   (u ∼[ ε ] v) ≃
     (absᵣ (u +ᵣ (-ᵣ  v)) <ᵣ rat (fst ε))
 ∼≃abs<ε u v ε =
-  propBiimpl→Equiv (isProp∼ _ _ _) (squash₁)
-   (λ x →
+  propBiimpl→Equiv (isProp∼ _ _ _) (isProp<ᵣ _ _)
+
+   ((λ x →
     lem-11-3-44 ((u +ᵣ (-ᵣ v))) ε
       (∼→∼' _ _ _ $  (subst ((u +ᵣ (-ᵣ v)) ∼[ ε ]_) (+-ᵣ v)
-       (+ᵣ-∼ u v (-ᵣ v) ε x))))
+       (+ᵣ-∼ 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 _ ))
+      (cong rat (ℚ.abs'≡abs _ ) ∙ sym (absᵣ-rat' _))
       ∘S (<ℚ→<ᵣ _ _))) ∘ ℚ.boundℕ
 
 getClamps : ∀ u →
@@ -539,6 +410,16 @@ getClamps = Elimℝ-Prop.go w
    in (suc₊₁ (1+ n)) , subst ((absᵣ (lim x p) <ᵣ_) ∘ rat) (eq/ _ _ uu) z) $ x₁ (ℚ./4₊ 1)
   w .Elimℝ-Prop.isPropA _ = squash₁
 
+
+
+lim≡≃∼ : ∀ x y a → (lim x y ≡ a)
+                    ≃ (∀ ε → absᵣ (lim x y -ᵣ a) <ᵣ rat (fst ε) )
+lim≡≃∼ x y r =
+  invEquiv (∼≃≡ _ _ ) ∙ₑ
+    equivΠCod λ ε →
+      ∼≃abs<ε _ _ _
+
+
 restrSq : ∀ n → Lipschitz-ℚ→ℚ-restr (fromNat (suc n))
                   ((2 ℚ₊· fromNat (suc n)))
                   λ x → x ℚ.· x
@@ -655,6 +536,24 @@ isPropIsContinuous f = isPropΠ2 λ _ _ → squash₁
         f' g'
  w .Elimℝ-Prop.isPropA _ = isSetℝ _ _
 
+
+
+fromLipschitz' : ∀ f → ∃[ L ∈ ℚ₊ ] (Lipschitz-ℚ→ℝ L f)
+                     → Σ[ f' ∈ (ℝ → ℝ) ] ∃[ L ∈ ℚ₊ ] (Lipschitz-ℝ→ℝ L f')
+fromLipschitz' f = PT.elim→Set
+  (λ _ → isSetΣ (isSet→ isSetℝ)
+   λ _ → isProp→isSet squash₁)
+   (λ (L , lip) → map-snd (∣_∣₁ ∘ (L ,_)) $ fromLipschitz L (f , lip))
+   λ (L , lip) (L' , lip') →
+    Σ≡Prop (λ _ → squash₁)
+          (funExt (≡Continuous _ _
+            (Lipschitz→IsContinuous L _
+              (snd (fromLipschitz L (f , lip))))
+            (Lipschitz→IsContinuous L' _
+              ((snd (fromLipschitz L' (f , lip')))) )
+            λ _ → refl))
+
+
 openPred : (P : ℝ → hProp ℓ-zero) → hProp ℓ-zero
 openPred P = (∀ x → ⟨ P x ⟩ → ∃[ δ ∈ ℚ₊ ] (∀ y → x ∼[ δ ] y → ⟨ P y ⟩ ) )
    , isPropΠ2 λ _ _ → squash₁
@@ -676,26 +575,29 @@ m·n/m m n =
 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 ]} _ ))))
+
+opaque
+ unfolding absᵣ _<ᵣ_
+ 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 ])
@@ -728,8 +630,10 @@ abs'q≤Δ₁' q n n< = (ℚ.isTrans≤ (ℚ.abs' q) (fromNat (suc n)) _
    (ℚ.abs ((x ℚ.- y) ℚ.+ y))
    (ℚ.abs (x ℚ.- y) ℚ.+ ℚ.abs y) (ℚ.- (ℚ.abs y)) (ℚ.abs+≤abs+abs (x ℚ.- y) y))
 
+-- opaque
+--  unfolding absᵣ _<ᵣ_
 IsContinuousAbsᵣ : IsContinuous absᵣ
-IsContinuousAbsᵣ = Lipschitz→IsContinuous _ (fst absᵣL) (snd absᵣL)
+IsContinuousAbsᵣ = Lipschitz→IsContinuous _ _ absᵣ-lip
 
 
 IsContinuousMaxR : ∀ x → IsContinuous (λ u → maxᵣ u x)
@@ -748,10 +652,15 @@ IsContinuousMinL : ∀ x → IsContinuous (minᵣ x)
 IsContinuousMinL x u ε =
  ∣ ε , (λ v → NonExpanding₂.go∼R minR _ _ _ ε) ∣₁
 
-
+IsContinuousClamp : ∀ a b → IsContinuous (clampᵣ a b)
+IsContinuousClamp a b =
+ IsContinuous∘ _ _
+   (IsContinuousMinR _)
+   (IsContinuousMaxL _)
 
 IsContinuous-ᵣ : IsContinuous (-ᵣ_)
-IsContinuous-ᵣ = Lipschitz→IsContinuous _ (fst -ᵣR) (snd -ᵣR)
+IsContinuous-ᵣ = Lipschitz→IsContinuous _ _ -ᵣ-lip
+
 
 contDiagNE₂ : ∀ {h} → (ne : NonExpanding₂ h)
   → ∀ f g → (IsContinuous f) → (IsContinuous g)
@@ -783,11 +692,23 @@ contDiagNE₂WP ne P f g fC gC u ε u∈ =
            )
    (fC u (ℚ./2₊ ε) u∈) (gC u (ℚ./2₊ ε) u∈)
 
+opaque
+ unfolding _+ᵣ_
+ cont₂+ᵣ : ∀ f g → (IsContinuous f) → (IsContinuous g)
+   → IsContinuous (λ x → f x +ᵣ g x)
+ cont₂+ᵣ = contDiagNE₂ sumR
+
+
+
 
+ 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 _ _ _ ε) ∣₁
 
-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))
@@ -799,46 +720,33 @@ 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ᵣ
+opaque
+ unfolding _≤ᵣ_ absᵣ
+ 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
+  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) ∣₁
@@ -846,70 +754,775 @@ 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)
+opaque
+ unfolding _+ᵣ_
+ +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
+
+opaque
+ unfolding _≤ᵣ_ absᵣ
+
+ ≤ᵣ-+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≤ᵣ _ _
+
+
 
+ ≤lim : ∀ r x y → (∀ δ → rat r ≤ᵣ x δ) → rat r ≤ᵣ lim x y
+ ≤lim r x y p = snd (NonExpanding₂.β-rat-lim' maxR r x y) ∙
+        congLim _ _ _ _ p
 
-+ᵣ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
+ limConstRat : ∀ x y → lim (λ _ → (rat x)) y ≡ rat x
+ limConstRat x y = eqℝ _ _ λ ε → lim-rat _ _ _ (/2₊ ε) _
+   (ℚ.<→0< _ (ℚ.<→<minus _ _ (ℚ.x/2<x ε))) (refl∼  _ _)
 
+ lim≤ : ∀ r x y → (∀ δ → x δ ≤ᵣ rat r ) → lim x y ≤ᵣ rat r
+ lim≤ r x y p = maxᵣComm _ _ ∙ snd (NonExpanding₂.β-rat-lim' maxR r x y) ∙
+    congLim' _ _ _ (λ δ → maxᵣComm _ _ ∙ p δ)
+     ∙ limConstRat _ _
 
 
-≤ᵣ-+o : ∀ m n o →  m ≤ᵣ n → (m +ᵣ o) ≤ᵣ (n +ᵣ o)
-≤ᵣ-+o m n o p = sym (+ᵣMaxDistr m n o) ∙ cong (_+ᵣ o) p
+ IsContinuousWithPred∘IsContinuous : ∀ P f g
+  → (g∈ : ∀ x → g x ∈ P)
+  → IsContinuousWithPred P f
+  → IsContinuous g
+  → IsContinuous λ x → f (g x) (g∈ x)
+ IsContinuousWithPred∘IsContinuous P f g g∈ fc gc u ε =
+   PT.rec squash₁
+          (λ (δ , δ∼) →
+       PT.map (map-snd λ x v u∼v →
+          δ∼ (g v) (g∈ v) (x v u∼v)
+           ) (gc u δ) )
+       (fc (g u) ε (g∈ u))
 
-≤ᵣ-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)
 
+ 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) ε))
 
 
+ contDropPred : ∀ f → IsContinuousWithPred ⊤Pred (λ x _ → f x)
+                 → IsContinuous f
+ contDropPred f =
+  flip (IsContinuousWithPred∘IsContinuous  ⊤Pred (λ x _ → f x)
+    (idfun _) _) IsContinuousId
 
-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))
+ ∩-openPred : ∀ P Q → ⟨ openPred P ⟩ → ⟨ openPred Q ⟩ →
+               ⟨ openPred (λ x → _ , isProp× (snd (P x)) (snd (Q x))) ⟩
+ ∩-openPred _ _ oP oQ x (x∈P , x∈Q) =
+   PT.map2 (λ (δ , Δ) (δ' , Δ') →
+      (ℚ.min₊ δ δ') , λ y x∼y →
+        (Δ y (∼-monotone≤ (ℚ.min≤ _ _) x∼y))
+       , Δ' y (∼-monotone≤ (ℚ.min≤' _ _) x∼y))
+    (oP x x∈P) (oQ x x∈Q)
 
-absᵣNonNeg : ∀ x → 0 ≤ᵣ x → absᵣ x ≡ x
-absᵣNonNeg x p = abs-max x ∙∙ maxᵣComm _ _ ∙∙ z
+
+
+
+
+ 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'')
+
+
+
+maxᵣ₊ : ℝ₊ → ℝ₊ → ℝ₊
+maxᵣ₊ (x , 0<x) (y , 0<y) =
+ maxᵣ x y , isTrans<≤ᵣ _ _ _ 0<x (≤maxᵣ _ _)
+
+
+minᵣ₊ : ℝ₊ → ℝ₊ → ℝ₊
+minᵣ₊ (x , 0<x) (y , 0<y) =
+  minᵣ x y , <min-lem _ _ _ 0<x 0<y
+
+opaque
+ unfolding _≤ᵣ_ absᵣ
+
+ 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
+
+ maxDistMin : ∀ x y z → minᵣ x (maxᵣ y z) ≡ maxᵣ (minᵣ x y) (minᵣ x z)
+
+ maxDistMin x y y' =
+   ≡Continuous _ _
+    (IsContinuousMinR _)
+    (cont₂maxᵣ _ _ (IsContinuousMinR _) (IsContinuousMinR _))
+    (λ xR →
+      ≡Continuous _ _
+        (IsContinuous∘ _ _ (IsContinuousMinL (rat xR)) ((IsContinuousMaxR y')))
+        (IsContinuous∘ _ _ (IsContinuousMaxR _) (IsContinuousMinL (rat xR)))
+        (λ yR →
+          ≡Continuous _ _
+            (IsContinuous∘ _ _ (IsContinuousMinL (rat xR))
+              ((IsContinuousMaxL (rat yR))))
+            (IsContinuous∘ _ _ (IsContinuousMaxL (minᵣ (rat xR) (rat yR)))
+              (IsContinuousMinL (rat xR)))
+            (λ r →
+              cong rat (ℚ.minComm _ _  ∙∙
+               ℚ.maxDistMin _ _ _ ∙∙
+                cong₂ ℚ.max (ℚ.minComm _ _) (ℚ.minComm _ _))) y')
+        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)
+
+
+ ≤→minᵣ : ∀ m n → m ≤ᵣ n → minᵣ m n ≡ m
+ ≤→minᵣ m n p = cong₂ minᵣ (sym (maxᵣIdem m)) (sym p) ∙
+   sym (minDistMaxᵣ _ _ _) ∙ maxAbsorbLMinᵣ _ _
+
+
+ ≤→maxᵣ : ∀ m n → m ≤ᵣ n → maxᵣ m n ≡ n
+ ≤→maxᵣ m n p = p
+
+
+
+IsContinuous₂ : (ℝ → ℝ → ℝ) → Type
+IsContinuous₂ f =
+ (∀ x → IsContinuous (f x)) × (∀ x → IsContinuous (flip f x))
+
+cont₂-fst : IsContinuous₂ (λ x _ → x)
+cont₂-fst = (λ _ → IsContinuousConst _) , (λ _ → IsContinuousId)
+
+cont₂-snd : IsContinuous₂ (λ _ x → x)
+cont₂-snd = (λ _ → IsContinuousId) , (λ _ → IsContinuousConst _)
+
+cont₂-id : ∀ x → IsContinuous₂ (λ _ _ → x)
+cont₂-id _ = (λ _ → IsContinuousConst _) , (λ _ → IsContinuousConst _)
+
+≡Cont₂ : {f₀ f₁ : ℝ → ℝ → ℝ}
+         → IsContinuous₂ f₀
+         → IsContinuous₂ f₁
+         → (∀ u u' → f₀ (rat u) (rat u') ≡ f₁ (rat u) (rat u'))
+             → ∀ x x' → f₀ x x' ≡ f₁ x x'
+≡Cont₂ {f₀} {f₁} (f₀C , f₀C') (f₁C , f₁C') p x =
+  ≡Continuous _ _ (f₀C x) (f₁C x)
+    (λ q → ≡Continuous _ _ (f₀C' (rat q)) (f₁C' (rat q))
+       (λ r → p r q) x)
+
+
+
+contNE₂∘ : ∀ {h} → (ne : NonExpanding₂ h)
+  {f₀ f₁ : ℝ → ℝ → ℝ}
+   → IsContinuous₂ f₀
+   → IsContinuous₂ f₁
+  → IsContinuous₂ (λ x x' → NonExpanding₂.go ne (f₀ x x') (f₁ x x'))
+contNE₂∘ ne x x₁ =
+  (λ x₂ → contDiagNE₂ ne _ _ (x .fst x₂) (x₁ .fst x₂)) ,
+   λ x₂ → contDiagNE₂ ne _ _ (x .snd x₂) (x₁ .snd x₂)
+
+cont∘₂ : ∀ {g}
+  {f : ℝ → ℝ → ℝ}
+   → IsContinuous g
+   → IsContinuous₂ f
+  → IsContinuous₂ (λ x x' → g (f x x'))
+cont∘₂ cG (cF , _) .fst x = IsContinuous∘ _ _ cG (cF x)
+cont∘₂ cG (_ , cF) .snd x = IsContinuous∘ _ _ cG (cF x)
+
+cont₂∘ :
+  {g : ℝ → ℝ → ℝ}
+  → ∀ {f f'}
+   → IsContinuous₂ g
+   → IsContinuous f
+   → IsContinuous f'
+  → IsContinuous₂ (λ x x' → g (f x) (f' x'))
+cont₂∘ (cG , _) _ cF .fst x = IsContinuous∘ _ _ (cG _) cF
+cont₂∘ (_ , cG) cF _ .snd x = IsContinuous∘ _ _ (cG _) cF
+
+
+contNE₂ : ∀ {h} → (ne : NonExpanding₂ h)
+  → IsContinuous₂ (NonExpanding₂.go ne)
+contNE₂ ne =
+  contNE₂∘ ne
+   ((λ _ → IsContinuousConst _) , (λ _ → IsContinuousId))
+   ((λ _ → IsContinuousId) , (λ _ → IsContinuousConst _))
+
+
+
+IsContinuousClamp₂ : ∀ x → IsContinuous₂ λ a b → clampᵣ a b x
+IsContinuousClamp₂ x = (λ _ → IsContinuousMinL _) ,
+   λ _ → IsContinuous∘ _ _ (IsContinuousMinR _) (IsContinuousMaxR _)
+
+IsContinuousClamp₂∘ : ∀ {f₀} {f₁} x → IsContinuous₂ f₀ → IsContinuous₂ f₁ →
+         IsContinuous₂ λ a b → clampᵣ (f₀ a b) (f₁ a b) x
+IsContinuousClamp₂∘ x =
+  contNE₂∘ minR ∘
+    (flip (contNE₂∘ maxR) ((λ _ → IsContinuousConst _) , (λ _ → IsContinuousConst _)))
+
+IsContinuousClamp₂∘' : ∀ {f₀} {f₁} {f₂} →
+         IsContinuous₂ f₀ → IsContinuous₂ f₁ → IsContinuous₂ f₂ →
+         IsContinuous₂ λ a b → clampᵣ (f₀ a b) (f₁ a b) (f₂ a b)
+IsContinuousClamp₂∘' f₀C f₁C f₂C =
+  contNE₂∘ minR (contNE₂∘ maxR f₀C f₂C) f₁C
+
+
+opaque
+ unfolding _+ᵣ_
+ IsContinuous-₂∘ : ∀ {f₀} {f₁} → IsContinuous₂ f₀ → IsContinuous₂ f₁ →
+      IsContinuous₂ λ a b → (f₀ a b) -ᵣ (f₁ a b)
+ IsContinuous-₂∘ f₀C f₁C =
+  contNE₂∘ sumR f₀C
+    (cont∘₂ IsContinuous-ᵣ f₁C)
+
+
+
+
+opaque
+ unfolding _≤ᵣ_
+
+ ≤Cont₂ : {f₀ f₁ : ℝ → ℝ → ℝ}
+          → IsContinuous₂ f₀
+          → IsContinuous₂ f₁
+          → (∀ u u' → f₀ (rat u) (rat u') ≤ᵣ f₁ (rat u) (rat u'))
+              → ∀ x x' → f₀ x x' ≤ᵣ f₁ x x'
+ ≤Cont₂ f₀C f₁C =
+   (≡Cont₂ (contNE₂∘ maxR f₀C f₁C) f₁C)
+
+
+
+
+ ≤Cont : {f₀ f₁ : ℝ → ℝ}
+          → IsContinuous f₀
+          → IsContinuous f₁
+          → (∀ u → f₀ (rat u) ≤ᵣ f₁ (rat u))
+              → ∀ x → f₀ x ≤ᵣ f₁ x
+ ≤Cont f₀C f₁C =
+   ≡Continuous _ _ (contDiagNE₂ maxR _ _ f₀C f₁C ) f₁C
+
+ ≤Cont₂Pos : {f₀ f₁ : ℝ → ℝ → ℝ}
+          → IsContinuous₂ f₀
+          → IsContinuous₂ f₁
+          → (∀ u u' → 0 ℚ.≤ u → 0 ℚ.≤ u' → f₀ (rat u) (rat u') ≤ᵣ f₁ (rat u) (rat u'))
+              → ∀ x x' → 0 ≤ᵣ x → 0 ≤ᵣ x' → f₀ x x' ≤ᵣ f₁ x x'
+ ≤Cont₂Pos {f₀} {f₁} f₀C f₁C X x x' 0≤x 0≤x' =
+   subst2 (λ x x' → f₀ x x' ≤ᵣ f₁ x x') 0≤x 0≤x'
+     (≤Cont₂
+       (cont₂∘ f₀C (IsContinuousMaxL 0) (IsContinuousMaxL 0))
+       (cont₂∘ f₁C (IsContinuousMaxL 0) (IsContinuousMaxL 0))
+         (λ u u' → (X _ _ (ℚ.≤max 0 u) (ℚ.≤max 0 u')))
+          x x')
+
+
+
+ ≤ContPos' : {x₀ : ℚ} {f₀ f₁ : ℝ → ℝ}
+          → IsContinuous f₀
+          → IsContinuous f₁
+          → (∀ u → x₀ ℚ.≤ u → f₀ (rat u) ≤ᵣ f₁ (rat u) )
+              → ∀ x → rat x₀ ≤ᵣ x → f₀ x ≤ᵣ f₁ x
+ ≤ContPos' {x₀} {f₀} {f₁} f₀C f₁C X x 0≤x =
+   subst (λ x → f₀ x  ≤ᵣ f₁ x) 0≤x
+     (≤Cont
+       (IsContinuous∘ _ _  f₀C (IsContinuousMaxL (rat x₀)))
+       (IsContinuous∘ _ _ f₁C (IsContinuousMaxL (rat x₀)))
+         (λ u  → (X _ (ℚ.≤max x₀ u)))
+          x)
+
+
+
+
+ ≤ContPos'pred : {x₀ : ℚ} {f₀ f₁ : ∀ x → (rat x₀ ≤ᵣ x) → ℝ}
+          → IsContinuousWithPred (λ _ → _ , isProp≤ᵣ _ _) f₀
+          → IsContinuousWithPred (λ _ → _ , isProp≤ᵣ _ _) f₁
+          → (∀ u x₀<u → f₀ (rat u) (≤ℚ→≤ᵣ _ _ x₀<u)
+                 ≤ᵣ f₁ (rat u) (≤ℚ→≤ᵣ _ _ x₀<u) )
+              → ∀ x x₀≤x → f₀ x x₀≤x ≤ᵣ f₁ x x₀≤x
+ ≤ContPos'pred {x₀} {f₀} {f₁} f₀C f₁C X x 0≤x =
+   subst (λ (x , x₀≤x) → f₀ x x₀≤x  ≤ᵣ f₁ x x₀≤x)
+      (Σ≡Prop (λ _ → isSetℝ _ _) 0≤x)
+     (≤Cont
+       (IsContinuousWithPred∘IsContinuous _ _ _
+          (λ _ → ≤maxᵣ _ _) f₀C (IsContinuousMaxL (rat x₀)))
+       (IsContinuousWithPred∘IsContinuous _ _ _
+          (λ _ → ≤maxᵣ _ _) f₁C (IsContinuousMaxL (rat x₀)))
+          (λ u  →
+              subst (λ qq → f₀ (maxᵣ (rat x₀) (rat u)) qq
+                      ≤ᵣ f₁ (maxᵣ (rat x₀) (rat u)) qq)
+                 (isSetℝ _ _ _ _) (X (ℚ.max x₀ u) (ℚ.≤max _ _))) x)
+
+
+
+
+ <→≤ContPos' : {x₀ : ℚ} {f₀ f₁ : ℝ → ℝ}
+          → IsContinuous f₀
+          → IsContinuous f₁
+          → (∀ u → x₀ ℚ.< u → f₀ (rat u) ≤ᵣ f₁ (rat u) )
+              → ∀ x → rat x₀ <ᵣ x → f₀ x ≤ᵣ f₁ x
+ <→≤ContPos' {x₀} {f₀} {f₁} f₀C f₁C X x =
+    PT.rec (isSetℝ _ _)
+      λ ((q , q') , (x₀≤q , q<q' , q'≤x)) →
+        ≤ContPos' {q'} f₀C f₁C
+              ((_∘ ℚ.isTrans<≤ _ _ _
+                (ℚ.isTrans≤< _ _ _ (≤ᵣ→≤ℚ _ _ x₀≤q) q<q'))
+                ∘ X ) x q'≤x
+
+
+
+IsContinuousWithPred⊆ : ∀ (P P' : ℝ → hProp ℓ-zero) f
+                       → (P'⊆P : P' ⊆ P)
+                       → IsContinuousWithPred P f
+                       → IsContinuousWithPred P' ((_∘ P'⊆P _) ∘ f )
+IsContinuousWithPred⊆ P P' f P'⊆P X u ε u∈P =
+  PT.map (map-snd ((_∘ P'⊆P _) ∘_))
+   (X u ε (P'⊆P _ u∈P))
+
+opaque
+ unfolding _<ᵣ_
+ <→≤ContPos'pred : {x₀ : ℚ} {f₀ f₁ : ∀ x → (rat x₀ <ᵣ x) → ℝ}
+          → IsContinuousWithPred (λ _ → _ , isProp<ᵣ _ _) f₀
+          → IsContinuousWithPred (λ _ → _ , isProp<ᵣ _ _) f₁
+          → (∀ u x₀<u → f₀ (rat u) x₀<u
+                     ≤ᵣ f₁ (rat u) x₀<u )
+              → ∀ x x₀<x → f₀ x x₀<x ≤ᵣ f₁ x x₀<x
+ <→≤ContPos'pred {x₀} {f₀} {f₁} f₀C f₁C X x =
+    PT.elim (λ _ → isSetℝ _ _)
+      λ ((q , q') , (x₀≤q , q<q' , q'≤x)) →
+       let z = ≤ContPos'pred {q'}
+                (IsContinuousWithPred⊆ _ _ f₀
+                   (λ  _ → isTrans<≤ᵣ _ _ _
+                  ((<ℚ→<ᵣ _ _ (ℚ.isTrans≤< _ _ _ (≤ᵣ→≤ℚ x₀ q x₀≤q) q<q'))))
+                   f₀C)
+                 (IsContinuousWithPred⊆ _ _ f₁
+                   (λ  _ → isTrans<≤ᵣ _ _ _
+                  ((<ℚ→<ᵣ _ _ (ℚ.isTrans≤< _ _ _ (≤ᵣ→≤ℚ x₀ q x₀≤q) q<q'))))
+                   f₁C)
+                 (λ u _ → X u _)
+                       x q'≤x
+      in subst (λ x₀<x → f₀ x x₀<x  ≤ᵣ f₁ x x₀<x)
+             (squash₁ _ _) z
+
+
+
+≤ContPos : {f₀ f₁ : ℝ → ℝ}
+         → IsContinuous f₀
+         → IsContinuous f₁
+         → (∀ u → 0 ℚ.≤ u → f₀ (rat u) ≤ᵣ f₁ (rat u) )
+             → ∀ x → 0 ≤ᵣ x → f₀ x ≤ᵣ f₁ x
+≤ContPos = ≤ContPos' {0}
+
+
+ℚabs-min-max : ∀ u v →
+      ℚ.abs (ℚ.max u v ℚ.- ℚ.min u v) ≡ ℚ.abs (u ℚ.- v)
+ℚabs-min-max = ℚ.elimBy≤
+  (λ x y X →
+    (cong ℚ.abs (cong₂ ℚ._-_ (ℚ.maxComm _ _) (ℚ.minComm _ _)))
+       ∙∙ X ∙∙
+      ℚ.absComm- _ _)
+  λ x y x≤y →
+    cong ℚ.abs
+      (cong₂ ℚ._-_
+        (ℚ.≤→max _ _ x≤y) (ℚ.≤→min _ _ x≤y))
+     ∙ ℚ.absComm- _ _
+
+opaque
+ unfolding absᵣ
+ absᵣ-min-max : ∀ u v →
+       absᵣ (maxᵣ u v -ᵣ minᵣ u v) ≡ absᵣ (u -ᵣ v)
+ absᵣ-min-max =
+  ≡Cont₂
+    (cont∘₂ IsContinuousAbsᵣ
+     (contNE₂∘ sumR
+       (contNE₂ maxR)
+       (cont∘₂ IsContinuous-ᵣ (contNE₂ minR) )))
+    (cont∘₂ IsContinuousAbsᵣ
+     (cont₂∘ (contNE₂ sumR)
+       IsContinuousId IsContinuous-ᵣ))
+    λ u v →
+       cong rat (sym (ℚ.abs'≡abs _) ∙∙ ℚabs-min-max u v ∙∙ ℚ.abs'≡abs _)
+
+maxMonotoneᵣ : ∀ m n o s → m ≤ᵣ n → o ≤ᵣ s → maxᵣ m o ≤ᵣ maxᵣ n s
+maxMonotoneᵣ _ _ _ _ m≤n o≤s =
+  max≤-lem _ _ _
+    (isTrans≤ᵣ _ _ _ m≤n (≤maxᵣ _ _))
+    (isTrans≤ᵣ _ _ _ o≤s
+      (isTrans≤≡ᵣ _ _ _  (≤maxᵣ _ _) (maxᵣComm _ _) ))
+
+minMonotoneᵣ : ∀ m n o s → m ≤ᵣ n → o ≤ᵣ s → minᵣ m o ≤ᵣ minᵣ n s
+minMonotoneᵣ m n o s m≤n o≤s =
+  ≤min-lem _ _ _
+    (isTrans≤ᵣ _ _ _
+     (min≤ᵣ _ _) m≤n)
+    (isTrans≤ᵣ _ _ _
+     (isTrans≡≤ᵣ _ _ _ (minᵣComm _ _) (min≤ᵣ _ _)) o≤s)
+
+opaque
+ unfolding _≤ᵣ_ absᵣ
+ incr→max≤ : (f : ∀ x → 0 <ᵣ x → ℝ)
+        → (∀ x 0<x y 0<y → x ≤ᵣ y → f x 0<x ≤ᵣ f y 0<y)
+       → ∀ u v 0<u 0<v →
+          maxᵣ (f u 0<u) (f v 0<v)
+            ≤ᵣ  (f (maxᵣ u v) (snd (maxᵣ₊ (u , 0<u) (v , 0<v))))
+ incr→max≤ f incr u v 0<u 0<v =
+   isTrans≤≡ᵣ _ _ _
+     (maxMonotoneᵣ _ _ _ _
+       (incr u 0<u (maxᵣ u v) (snd (maxᵣ₊ (u , 0<u) (v , 0<v)))
+        (≤maxᵣ _ _))
+       (incr v 0<v (maxᵣ u v) (snd (maxᵣ₊ (u , 0<u) (v , 0<v)))
+        (isTrans≤≡ᵣ _ _ _  (≤maxᵣ _ _) (maxᵣComm _ _))))
+     (maxᵣIdem _)
+
+incr→≤min : (f : ∀ x → 0 <ᵣ x → ℝ)
+       → (∀ x 0<x y 0<y → x ≤ᵣ y → f x 0<x ≤ᵣ f y 0<y)
+      → ∀ u v 0<u 0<v →
+           (f (minᵣ u v) (snd (minᵣ₊ (u , 0<u) (v , 0<v))))
+            ≤ᵣ  minᵣ (f u 0<u) (f v 0<v)
+incr→≤min f incr u v 0<u 0<v =
+  isTrans≡≤ᵣ _ _ _
+    (sym (minᵣIdem _))
+     (minMonotoneᵣ _ _ _ _
+       (incr (minᵣ u v) (snd (minᵣ₊ (u , 0<u) (v , 0<v)))
+           u 0<u
+          (min≤ᵣ _ _))
+       (incr (minᵣ u v) (snd (minᵣ₊ (u , 0<u) (v , 0<v)))
+           v 0<v
+          (isTrans≡≤ᵣ _ _ _  (minᵣComm _ _) (min≤ᵣ _ _))))
+
+absᵣ-monotoneOnNonNeg : (x y : ℝ₀₊) →
+ fst x ≤ᵣ fst y → absᵣ (fst x) ≤ᵣ absᵣ (fst y)
+absᵣ-monotoneOnNonNeg x y x≤y =
+  subst2 _≤ᵣ_
+    (sym (absᵣNonNeg (fst x) (snd x)))
+    (sym (absᵣNonNeg (fst y) (snd y)))
+    x≤y
+
+
+
+ℚApproxℙ : (P : ℙ ℝ) (Q : ℙ ℝ) (f : ∀ x → x ∈ P → Σ ℝ (_∈ Q)) → Type
+ℚApproxℙ P Q f =
+   Σ[ f' ∈ (∀ q → rat q ∈ P → ℚ₊ → ℚ) ]
+    (((∀ q q∈ ε  → rat (f' q q∈ ε) ∈ Q)) × (Σ[ f'-cauchy ∈ (∀ q q∈P → _) ]
+      (∀ q q∈P → lim (rat ∘ f' q q∈P) (f'-cauchy q q∈P)
+                ≡ fst (f (rat q) q∈P))))
+
+ℚApprox : (f : ℝ → ℝ) → Type
+ℚApprox f =
+   Σ[ f' ∈ (ℚ → ℚ₊ → ℚ) ]
+    Σ[ f'-cauchy ∈ (∀ q → _) ]
+      (∀ q → lim (rat ∘ f' q) (f'-cauchy q)
+                ≡ f (rat q))
+
+
+ℚApproxℙ'Num : (P Q : ℙ ℝ) (f : ∀ x → x ∈ P → Σ ℝ (_∈ Q)) →
+   ∀ q → (q∈P : rat q ∈ P) → Type
+
+ℚApproxℙ'Num P Q f q q∈P =
+     Σ[ f' ∈ (ℚ₊ → ℚ) ]
+    ((∀ ε  → rat (f' ε) ∈ Q) × (Σ[ f'-cauchy ∈ (_) ]
+      (lim (rat ∘ f') (f'-cauchy) ≡ fst (f (rat q) q∈P))))
+
+
+ℚApproxℙ' : (P Q : ℙ ℝ) (f : ∀ x → x ∈ P → Σ ℝ (_∈ Q)) → Type
+ℚApproxℙ' P Q f =
+ ∀ q → (q∈P : rat q ∈ P) →
+   ℚApproxℙ'Num P Q f q q∈P
+
+Iso-ℚApproxℙ'-ℚApproxℙ : (P Q : ℙ ℝ) → ∀ f →
+  Iso (ℚApproxℙ' P Q f) (ℚApproxℙ P Q f)
+Iso-ℚApproxℙ'-ℚApproxℙ P Q f .Iso.fun x =
+  (λ q → fst ∘ x q) ,
+   (λ q → fst ∘ snd ∘ x q) ,
+    ((λ q → fst ∘ snd ∘ snd ∘ x q) ,
+    (λ q → snd ∘ snd ∘ snd ∘ x q))
+Iso-ℚApproxℙ'-ℚApproxℙ P Q f .Iso.inv = _
+Iso-ℚApproxℙ'-ℚApproxℙ P Q f .Iso.rightInv _ = refl
+Iso-ℚApproxℙ'-ℚApproxℙ P Q f .Iso.leftInv _ = refl
+
+
+ℚApproxℙ'≃ℚApproxℙ : (P Q : ℙ ℝ) → ∀ f →
+  ℚApproxℙ' P Q f ≃ ℚApproxℙ P Q f
+ℚApproxℙ'≃ℚApproxℙ P Q f =
+ isoToEquiv (Iso-ℚApproxℙ'-ℚApproxℙ P Q f)
+
+
+
+IsUContinuousℚℙ : (P : ℙ ℝ) → (∀ q → rat q ∈ P → ℝ) → Type
+IsUContinuousℚℙ P f =
+  ∀ (ε : ℚ₊) → Σ[ δ ∈ ℚ₊ ]
+     (∀ u v u∈ v∈ → ℚ.abs (u ℚ.- v) ℚ.< fst δ  → f u u∈ ∼[ ε ] f v v∈)
+
+IsUContinuousℙ : (P : ℙ ℝ) → (∀ x → x ∈ P → ℝ) → Type
+IsUContinuousℙ P f =
+  ∀ (ε : ℚ₊) → Σ[ δ ∈ ℚ₊ ]
+     (∀ u v u∈ v∈ → u ∼[ δ ] v  → f u u∈ ∼[ ε ] f v v∈)
+
+ℚApproxℙ'' : (P Q : ℙ ℝ) (f : ∀ x → x ∈ P → Σ ℝ (_∈ Q)) → Type
+ℚApproxℙ'' P Q f =
+ ∀ x → (x∈P : rat x ∈ P) (ε : ℚ₊) →
+    Σ[ r ∈ ℚ ] ((rat r ∈ Q) × (rat r ∼[ ε ] fst (f (rat x) x∈P)))
+
+ℚApproxℙ'→ℚApproxℙ'' : (P Q : ℙ ℝ) → ∀ f →
+  (ℚApproxℙ' P Q f) → (ℚApproxℙ'' P Q f)
+ℚApproxℙ'→ℚApproxℙ'' P Q f X x x∈P ε =
+   fst (X x x∈P) (/2₊ ε) , fst (snd (X x x∈P)) (/2₊ ε) ,
+     subst (rat (fst (X x x∈P) (/2₊ ε)) ∼[ ε ]_)
+    (snd (snd (snd ( ((X x x∈P))) )))
+      ((rat-lim _ _ _ (/2₊ ε) _ (snd (ℚ.<→ℚ₊ _ _ (ℚ.x/2<x ε)))
+        (refl∼ _ _)))
+
+
+ℚApproxℙ∘ : ∀ P Q R g f
+          → IsUContinuousℙ Q ((fst ∘_) ∘ g)
+          → ℚApproxℙ'' Q R g
+          → ℚApproxℙ'' P Q f
+          → ℚApproxℙ'' P R (curry (uncurry g ∘ uncurry f))
+ℚApproxℙ∘ P Q R  g f gC gA fA q q∈ ε =
+  let (δ' , Δ) = gC (/2₊ ε)
+      δ = ℚ.min₊ δ' (/2₊ ε)
+
+      uu' : rat (fst (fA q q∈ δ)) ∈ Q
+      uu' = (fst (snd (fA q q∈ δ)))
+
+      zz : rat (fst (gA (fst (fA q q∈ δ)) uu' δ))
+             ∼[ /2₊ ε ℚ₊+ /2₊ ε ]
+              fst (g (fst (f (rat q) q∈)) (snd (f (rat q) q∈)))
+      zz = triangle∼
+               ((∼-monotone≤ (ℚ.min≤' _ _)
+                 ((snd (snd (gA (fst (fA q q∈ δ)) uu' δ))))))
+
+                   (Δ _ _ uu' _ (
+                     ∼-monotone≤ (ℚ.min≤ _ _)
+                       (snd (snd (fA q q∈ δ)))))
+
+  in fst (gA (fst (fA q q∈ δ)) uu' δ)
+        , fst (snd (gA (fst (fA q q∈ δ)) uu' δ))
+         , subst∼ (ℚ.ε/2+ε/2≡ε (fst ε)) zz
+
+≡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
-   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≤ᵣ _ _
+ 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ℝ _ _
+
+
+
+
+≤clampᵣ : ∀ L L' x → L ≤ᵣ L' →  L ≤ᵣ clampᵣ L L' x
+≤clampᵣ L L' x y =
+  isTrans≤≡ᵣ _ _ _ (≤maxᵣ L (minᵣ x L'))
+    (cong₂ maxᵣ (sym (≤→minᵣ _ _ y) ∙ minᵣComm _ _) (minᵣComm _ _)
+     ∙∙ sym (maxDistMin L' L x) ∙∙
+     minᵣComm _ _ )
+
+
+clamp≤ᵣ : ∀ L L' x →  clampᵣ L L' x ≤ᵣ L'
+clamp≤ᵣ L L' x = min≤ᵣ' _ _
diff --git a/Cubical/HITs/CauchyReals/Derivative.agda b/Cubical/HITs/CauchyReals/Derivative.agda
index 59778e28ba..57575afd94 100644
--- a/Cubical/HITs/CauchyReals/Derivative.agda
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -3,9 +3,12 @@
 module Cubical.HITs.CauchyReals.Derivative where
 
 open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Powerset
 open import Cubical.Foundations.Function
 open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Equiv.Properties
 open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Isomorphism
 open import Cubical.Functions.FunExtEquiv
 
 open import Cubical.Data.Sum as ⊎
@@ -36,11 +39,169 @@ open import Cubical.HITs.CauchyReals.Sequence
 
 
 
+IsUContinuous : (ℝ → ℝ) → Type
+IsUContinuous f =
+  ∀ (ε : ℚ₊) → Σ[ δ ∈ ℚ₊ ]
+     (∀ u v → u ∼[ δ ] v → f u ∼[ ε ] f v)
+
+IsUContinuous→IsContinuous : ∀ f → IsUContinuous f → IsContinuous f
+IsUContinuous→IsContinuous f fc u ε =
+  ∣ map-snd (_$ u) (fc ε) ∣₁
+
+
+IsUContinuous∘ : ∀ {f g} → IsUContinuous f → IsUContinuous g →
+  IsUContinuous (f ∘ g)
+IsUContinuous∘ cF cG ε =
+  let (η , X) = cF ε ; (δ , Y) = cG η
+  in _ , λ _ _ → X _ _ ∘ Y _ _
+
+
+interpℝ : ℝ → ℝ → ℝ → ℝ
+interpℝ a b t = a +ᵣ t ·ᵣ (b -ᵣ a)
+
+IsUContinuous+ᵣL : ∀ x → IsUContinuous (x +ᵣ_)
+IsUContinuous+ᵣL x ε = ε , λ u v u∼v →
+  subst2 (_∼[ ε ]_) (+ᵣComm _ _) (+ᵣComm _ _) $ +ᵣ-∼ u v x ε u∼v
+
+
+·ᵣ-∼ : ∀ u v r r' ε
+    → absᵣ r ≤ᵣ rat (fst r')
+    → u ∼[ ε ℚ₊· invℚ₊ r' ] v
+    → (u ·ᵣ r) ∼[ ε ] (v ·ᵣ r)
+·ᵣ-∼ u v r r' ε abs-r≤ᵣr' u∼v =
+ invEq (∼≃abs<ε _ _ _)
+   (isTrans≤<ᵣ _ _ _
+     (isTrans≡≤ᵣ _ _ _
+       (cong absᵣ (sym (𝐑'.·DistL- _ _ _) ∙ ·ᵣComm _ _)
+        ∙ ·absᵣ _ _)
+       (≤ᵣ-·ᵣo _ _ (absᵣ (u +ᵣ -ᵣ v)) (0≤absᵣ _) abs-r≤ᵣr'))
+     (isTrans<≡ᵣ _ _ _
+    (<ᵣ-o·ᵣ _ _ (ℚ₊→ℝ₊ r')  (fst (∼≃abs<ε _ _ _) u∼v))
+    (sym (rat·ᵣrat _ _) ∙ cong rat (cong ((fst r') ℚ.·_) (ℚ.·Comm (fst ε) _)
+     ∙ ℚ.y·[x/y] r' (fst ε) ))))
+
+
+
+IsUContinuous·ᵣR : ∀ x → ∥ IsUContinuous (_·ᵣ x) ∥₁
+IsUContinuous·ᵣR x =
+  PT.map
+    (λ (x' , (absᵣx<x' , _)) ε →
+      ε ℚ₊· invℚ₊ (x' , ℚ.<→0< x'
+       (<ᵣ→<ℚ 0 x' (isTrans≤<ᵣ 0 (absᵣ x) _ (0≤absᵣ _) absᵣx<x'))) ,
+       λ _ _ → ·ᵣ-∼ _ _ _ _ ε (<ᵣWeaken≤ᵣ _ _ absᵣx<x') )
+    (denseℚinℝ (absᵣ x) ((absᵣ x) +ᵣ 1)
+       (isTrans≡<ᵣ _ _ _
+         (sym (+IdR _)) (<ᵣ-o+ 0 1 (absᵣ x) decℚ<ᵣ?)))
+
+IsUContinuous∘ℙ : ∀ P {f g} → IsUContinuous f → IsUContinuousℙ P g  →
+  IsUContinuousℙ P (λ x x∈ → f (g x x∈))
+IsUContinuous∘ℙ P cF cG ε =
+  let (η , X) = cF ε ; (δ , Y) = cG η
+  in _ , λ _ _ _ _ → X _ _ ∘ Y _ _ _ _
+
+
+IsUContinuous-εᵣ : ∀ f → IsUContinuous f →
+   ∀ (ε : ℝ₊) → ∃[ δ ∈ ℚ₊ ]
+     (∀ u v → u ∼[ δ ] v → absᵣ (f u -ᵣ f v) <ᵣ fst ε)
+IsUContinuous-εᵣ f fuc εᵣ =
+ PT.map
+   (λ (ε , 0<ε , ε<εᵣ) →
+     map-snd
+      (λ {δ} X →
+        λ u v u∼v → isTrans<ᵣ _ _ _ (fst (∼≃abs<ε _ _ _) (X u v u∼v)) ε<εᵣ)
+      (fuc (ε , ℚ.<→0< _ (<ᵣ→<ℚ 0 ε 0<ε))))
+   (denseℚinℝ 0 (fst εᵣ) (snd εᵣ))
+
+
+
+IsUContinuousℚ : (ℚ → ℝ) → Type
+IsUContinuousℚ f =
+  ∀ (ε : ℚ₊) → Σ[ δ ∈ ℚ₊ ]
+     (∀ u v → ℚ.abs (u ℚ.- v) ℚ.< fst ε  → f u ∼[ ε ] f v)
+
+
+Lipschitiz→IsUContinuous : ∀ L f →
+     Lipschitz-ℝ→ℝ L f → IsUContinuous f
+Lipschitiz→IsUContinuous L f X ε =
+   (invℚ₊ L) ℚ₊· ε ,
+    ( λ u v → subst∼ (ℚ.y·[x/y] _ _)
+      ∘ X u v ((invℚ₊ L) ℚ₊· ε))
+
+-- IsUContinuousℙ : (P : ℙ ℝ) → (∀ x → x ∈ P → ℝ) → Type
+-- IsUContinuousℙ P f =
+--   ∀ (ε : ℚ₊) → ∃[ δ ∈ ℚ₊ ]
+--      (∀ u u∈ v v∈ → u ∼[ δ ] v → f u u∈ ∼[ ε ] f v v∈)
+
+
+
+
+
+-- fromUContinuous : Σ _ (λ f → (IsUContinuousℚ f)) →
+--   Σ _ (λ f' → IsUContinuous f')
+-- fromUContinuous (f , uC) = f' , Iso.inv Σ-Π-Iso (cMod , rl)
+--  where
+
+--  cMod : (a : ℚ₊) → ℚ₊
+--  cMod = fst ∘ uC
+
+--  cMod' : (a : ℚ₊) → ℚ₊
+--  cMod' = fst ∘ uC
+
+--  isCMode : {!!}
+--  isCMode = {!!}
+
+--  cMod≤ : ∀ δ ε → fst (cMod' (cMod δ ℚ₊+ cMod ε)) ℚ.≤ fst (δ ℚ₊+ ε)
+--  cMod≤ = {!!}
+
+--  cMod≤' : ∀ ε → fst (cMod' (cMod ε)) ℚ.≤ fst (ε)
+--  cMod≤' = {!!}
+--  w : Elimℝ (λ _ → ℝ) λ u v ε z → u ∼[ cMod' ε  ] v
+
+
+--  w .Elimℝ.ratA = f
+--  w .Elimℝ.limA x p a v = lim (a ∘ cMod)
+--    λ δ ε →
+--     let v' = v ((cMod δ)) ((cMod ε))
+--     in ∼-monotone≤ (cMod≤ δ ε) v'
+--  w .Elimℝ.eqA p a a' x y =
+--    eqℝ a a' λ ε →
+--      ∼-monotone≤  (cMod≤' ε) (y (cMod ε))
+
+
+--  w .Elimℝ.rat-rat-B q r ε x x₁ = {!snd (uC ε) q r !}
+--  w .Elimℝ.rat-lim-B = {!!}
+--  w .Elimℝ.lim-rat-B x r ε δ p v₁ u v' u' x₁ =
+--   {!!}
+--  w .Elimℝ.lim-lim-B x y ε δ η p p' v₁ r v' u' v'' u'' x₁ =
+--   let z = {!!}
+--   in ?
+--     -- lim-lim _ _ _ (cMod' δ) (cMod' η)  _ _
+--     --      {!!} {!!}
+--  w .Elimℝ.isPropB _ _ _ _ = isProp∼ _ _ _
+
+--  f' : ℝ → ℝ
+--  f' = Elimℝ.go w
+
+--  rl : (ε : ℚ₊) (u v : ℝ) → u ∼[ cMod ε ] v → f' u ∼[ ε ] f' v
+--  rl ε u v u∼v = ∼-monotone≤  (cMod≤' ε) (Elimℝ.go∼ w u∼v)
+
+
+
 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_limitOfℙ_,_is_ : (x : ℝ) → (P : ℙ ℝ) →  (∀ r → r ∈ P → x ＃ r → ℝ)  → ℝ → Type
+at x limitOfℙ P , f is L =
+  ∀ (ε : ℝ₊) → ∃[ δ ∈ ℝ₊ ]
+   (∀ r r∈ x＃r → absᵣ (x -ᵣ r) <ᵣ fst δ → absᵣ (L -ᵣ f r r∈ x＃r) <ᵣ fst ε)
+
+at_limitOf_is'_ : (x : ℝ) → (∀ r → x ＃ r → ℝ)  → ℝ → Type
+at x limitOf f is' L =
+  ∀ (ε : ℚ₊) → ∃[ δ ∈ ℚ₊ ]
+   (∀ r x＃r → absᵣ (x -ᵣ r) <ᵣ rat (fst δ) → absᵣ (L -ᵣ f r x＃r) <ᵣ rat (fst ε))
+
 at_inclLimitOf_is_ : (x : ℝ) → (∀ r → ℝ)  → ℝ → Type
 at x inclLimitOf f is L =
   ∀ (ε : ℝ₊) → ∃[ δ ∈ ℝ₊ ]
@@ -71,6 +232,20 @@ IsContinuousLim : ∀ f x → IsContinuous f →
                     at x limitOf (λ r _ → f r) is (f x)
 IsContinuousLim f x cx = inclLimit→Limit _ _ _ (IsContinuousInclLim f x cx)
 
+IsContinuousLimℙ : ∀ P f x x∈ → IsContinuousWithPred P f →
+                    at x limitOfℙ P , (λ r r∈ _ → f r r∈) is (f x x∈)
+IsContinuousLimℙ P f x x∈ cx = uncurry
+  λ ε → (PT.rec squash₁
+   λ (q , 0<q , q<ε) →
+     PT.map (λ (δ , X) →
+       (ℚ₊→ℝ₊ δ) ,
+         λ r x₁ xx yy → isTrans<ᵣ _ _ _
+           (fst (∼≃abs<ε _ _ _) ((X r x₁ (invEq (∼≃abs<ε _ _ _) yy))))
+            q<ε)
+       (cx x (q , ℚ.<→0< q (<ᵣ→<ℚ 0 q 0<q)) x∈)) ∘ denseℚinℝ 0 ε
+
+
+
 IsContinuousInclLim→IsContinuous : ∀ f  →
                     (∀ x → at x inclLimitOf f is (f x))
                     → IsContinuous f
@@ -111,7 +286,13 @@ IsContinuousLimΔ f x cx =
 
 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 ε)) ∣₁
+  (λ r x＃r x₁ → subst (_<ᵣ fst ε) (sym (absᵣ-rat 0) ∙ cong absᵣ (sym (+-ᵣ C))) (snd ε)) ∣₁
+
+const-limℙ : ∀ P C x → at x limitOfℙ P ,  (λ _ _ _ → C) is C
+const-limℙ _ C x ε = ∣ (1 , decℚ<ᵣ?) ,
+  (λ r x＃r _ x₁ → subst (_<ᵣ fst ε) (sym (absᵣ-rat 0) ∙ cong absᵣ (sym (+-ᵣ C))) (snd ε) ) ∣₁
+
+
 
 id-lim : ∀ x → at x limitOf (λ r _ → r) is x
 id-lim x ε = ∣ ε , (λ r x＃r p → p )  ∣₁
@@ -135,7 +316,7 @@ f #[ _op_ ]$ g = λ r x → (f r x) op (g r x)
         → at x limitOf (f #[ _+ᵣ_ ]$ g) is (F +ᵣ G)
 +-lim x f g F G fL gL ε =
   PT.map2 (λ (δ , p) (δ' , p') →
-       (_ , ℝ₊min δ δ') ,
+       (minᵣ₊ δ δ') ,
         λ r x＃r x₁ →
          let u = p r x＃r (isTrans<≤ᵣ _ _ _ x₁ (min≤ᵣ _ _))
              u' = p' r x＃r (isTrans<≤ᵣ _ _ _ x₁ (min≤ᵣ' _ _))
@@ -157,91 +338,92 @@ f #[ _op_ ]$ g = λ r x → (f r x) op (g r x)
 
  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)) ·ᵣ_)
+  ε'f : ℝ₊
+  ε'f = (ε ₊／ᵣ₊ 2) ₊／ᵣ₊ (1 +ᵣ absᵣ G ,
+           isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _))
+            (<≤ᵣMonotone+ᵣ 0 1 0 (absᵣ G) decℚ<ᵣ? (0≤absᵣ G)))
+
+  ε'g : ℝ₊
+  ε'g = (ε ₊／ᵣ₊ 2) ₊／ᵣ₊ (1 +ᵣ absᵣ F ,
+            isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _))
+            (<≤ᵣMonotone+ᵣ 0 1 0 (absᵣ F) decℚ<ᵣ? (0≤absᵣ F)))
+
+  w : _
+  w (δ , p) (δ' , p') (δ'' , p'') = δ* , ww
+
+   where
+
+    δ* : ℝ₊
+    δ* = minᵣ₊ (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 = isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _)) (<≤ᵣMonotone+ᵣ 0 1 0 (absᵣ G) decℚ<ᵣ? (0≤absᵣ G))
+       0<1+f = isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _)) $ <≤ᵣ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ᵣ 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 _))
+              ∙ ·ᵣ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))
+                               ∙ +ᵣ-rat _ _)
+                       ∙∙ ·ᵣ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_)
@@ -250,13 +432,78 @@ 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 ]
 
+differenceAt0-swap : ∀ f h 0＃h → differenceAt f 0 h 0＃h ≡ differenceAt f h (-ᵣ h)
+  (subst (_＃ (-ᵣ h)) (-ᵣ-rat 0) (-＃ _ _ 0＃h)) --
+differenceAt0-swap f h 0＃h =
+     sym (-ᵣ·-ᵣ _ _)
+  ∙ cong₂ _·ᵣ_
+    (cong -ᵣ_ (cong₂ _-ᵣ_
+         (cong f (+IdL _))
+         (cong f (sym (+-ᵣ _))))
+      ∙ -[x-y]≡y-x _ _)
+    (-invℝ h 0＃h)
+
+
+
+differenceAtℙ : ∀ P → (∀ r → r ∈ P → ℝ) → ∀ x → ∀ h → 0 ＃ h → x ∈ P → x +ᵣ h ∈ P   → ℝ
+differenceAtℙ P f x h 0＃h x∈ x+h∈ = (f (x +ᵣ h) x+h∈ -ᵣ f x x∈) ／ᵣ[ h , 0＃h ]
+
+opaque
+ unfolding -ᵣ_
+ incr→0<differenceAtℙ : ∀ P f x h 0＃h x∈ x+h∈ →
+           (∀ x x∈ y y∈ → x <ᵣ y → f x x∈ <ᵣ f y y∈) →
+             0 <ᵣ differenceAtℙ P f x h 0＃h x∈ x+h∈
+ incr→0<differenceAtℙ P f x h (inl 0<h) x∈ x+h∈ incr =
+  snd ((_ , x<y→0<y-x _ _ (incr _ _ _ _
+   (isTrans≡<ᵣ _ _ _ (sym (+IdR _)) $ <ᵣ-o+ 0 h x 0<h)))
+    ₊·ᵣ (_ , invℝ-pos _ 0<h))
+ incr→0<differenceAtℙ P f x h (inr h<0) x∈ x+h∈ incr =
+  isTrans<≡ᵣ _ _ _
+    (snd ((_ , -ᵣ<ᵣ _ _ (x<y→x-y<0 _ _
+     (incr _ _ _ _ (isTrans<≡ᵣ _ _ _ (<ᵣ-o+ h 0 x h<0) (+IdR _)))))
+     ₊·ᵣ (_ , -ᵣ<ᵣ _ _ (invℝ-neg _ h<0))))
+    (-ᵣ·-ᵣ _ _)
+
+＃ℙ : ℝ → ℙ ℝ
+＃ℙ r x = r ＃ x , isProp＃ r x
+
+
+uDerivativeOfℙ_,_is_ : (P : ℙ ℝ) → (∀ r → r ∈ P → ℝ)
+                                    → (∀ r → r ∈ P → ℝ) → Type
+uDerivativeOfℙ P , f is f' =
+  ∀ (ε : ℚ₊) → ∃[ δ ∈ ℚ₊ ]
+   (∀ x x∈ h h∈ 0＃h → absᵣ h <ᵣ rat (fst δ)
+    → absᵣ (f' x x∈ -ᵣ differenceAtℙ P f x h 0＃h x∈ h∈) <ᵣ rat (fst ε))
+
+IsContinuousWithPred-differenceAt : ∀ x f → IsContinuous f
+   → IsContinuousWithPred (＃ℙ 0) (differenceAt f x)
+IsContinuousWithPred-differenceAt x f cf =
+  cont₂·ᵣWP _ _ _
+    (AsContinuousWithPred _ _
+      (cont₂+ᵣ _ _ (IsContinuous∘ _ _ cf (IsContinuous+ᵣL _)) (IsContinuousConst _)))
+    IsContinuousWithPredInvℝ
 
 derivativeAt : (ℝ → ℝ) → ℝ → Type
 derivativeAt f x = At 0 limitOf (differenceAt f x)
 
+
+derivativeOfℙ_,_at_is_ : (P : ℙ ℝ) → (∀ r → r ∈ P → ℝ) → Σ _ (_∈ P) → ℝ → Type
+derivativeOfℙ P , f at (x , x∈) is d =
+ at 0 limitOfℙ P ∘S (x +ᵣ_) , (λ h h∈ 0＃h → differenceAtℙ P f x h 0＃h x∈ h∈) is d
+
 derivativeOf_at_is_ : (ℝ → ℝ) → ℝ → ℝ → Type
 derivativeOf f at x is d = at 0 limitOf (differenceAt f x) is d
 
+as-derivativeOfℙ : ∀ P f x x∈P x'
+    → derivativeOf f at x is x'
+    → derivativeOfℙ P , (λ r _ → f r) at x , x∈P  is x'
+as-derivativeOfℙ P f x x∈P x' X ε =
+  PT.map (map-snd λ y r _ y＃r x₂ → y r  y＃r x₂) (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)
@@ -283,6 +530,35 @@ idDerivative x =  subst (at 0 limitOf_is 1)
           cong (_·ᵣ (invℝ h 0＃h))
            (sym L𝐑.lem--041)) (+-lim _ _ _ _ _ F G)
 
++uDerivativeℙ : ∀ P  f f' g g'
+        → uDerivativeOfℙ P , f is f'
+        → uDerivativeOfℙ P , g is g'
+        → uDerivativeOfℙ P , (λ x x∈ → f x x∈ +ᵣ g x x∈)
+          is (λ x x∈ → f' x x∈ +ᵣ g' x x∈)
++uDerivativeℙ P f f' g g' F G ε =
+  PT.map2
+    (λ (δ , X) (δ' , X') →
+       let δ⊔δ' = ℚ.min₊ δ δ'
+       in δ⊔δ' ,
+           λ x x∈ h h∈ 0＃h x₁ →
+              (subst2 _<ᵣ_
+                (cong absᵣ (sym L𝐑.lem--041
+                  ∙ cong₂ _-ᵣ_
+                    refl
+                    (sym (·DistR+ _ _ _) ∙
+                      cong₂ _·ᵣ_
+                        (sym L𝐑.lem--041)
+                        refl)))
+                (+ᵣ-rat _ _ ∙ cong rat (ℚ.ε/2+ε/2≡ε (fst ε)))
+               (isTrans≤<ᵣ _ _ _ (absᵣ-triangle _ _)
+                (<ᵣMonotone+ᵣ _ _ _ _
+                 (X x x∈ h h∈ 0＃h (isTrans<≤ᵣ _ _ _ x₁
+                  (≤ℚ→≤ᵣ _ _ (ℚ.min≤ (fst δ) (fst δ') ))))
+                 (X' x x∈ h h∈ 0＃h (isTrans<≤ᵣ _ _ _ x₁
+                  (≤ℚ→≤ᵣ _ _ (ℚ.min≤' (fst δ) (fst δ')))))))))
+    (F (/2₊ ε))
+    (G (/2₊ ε))
+
 C·Derivative : ∀ C x f f'x
         → derivativeOf f at x is f'x
         → derivativeOf ((C ·ᵣ_) ∘S f) at x is (C ·ᵣ f'x)
@@ -295,6 +571,60 @@ C·Derivative C x f f'x F =
            cong (_·ᵣ (invℝ h 0＃h)) (·DistL- _ _ _))
        (·-lim _ _ _ _ _ (const-lim C 0) F)
 
+uDerivativeℙ-id : ∀ P
+ → uDerivativeOfℙ P , (λ x _ → x) is (λ _ _ → 1)
+uDerivativeℙ-id P ε =
+ ∣ ε , (λ _ _ h _ 0＃h _ →
+   isTrans≡<ᵣ _ _ _
+     (cong absᵣ ((𝐑'.+InvR' _ _ (sym (x·invℝ[x] h 0＃h) ∙
+    cong (_·ᵣ (invℝ h 0＃h)) (sym (L𝐑.lem--063)))))
+    ∙ absᵣ0)
+    (snd (ℚ₊→ℝ₊ ε))) ∣₁
+
+uDerivativeℙ-const : ∀ P C →
+ uDerivativeOfℙ P , (λ _ _ → C) is (λ _ _ → 0)
+
+uDerivativeℙ-const P C ε =
+ ∣ 1 , (λ _ _ h _ 0＃h _ →
+   isTrans≡<ᵣ _ _ _
+    (minusComm-absᵣ _ _ ∙
+      cong absᵣ (𝐑'.+IdR' _ _ (-ᵣ-rat 0)
+        ∙ cong (_·ᵣ (invℝ h 0＃h)) (+-ᵣ _)
+     ∙ (𝐑'.0LeftAnnihilates (invℝ h 0＃h)))
+     ∙ absᵣ0
+     )
+    (snd (ℚ₊→ℝ₊ ε))) ∣₁
+
+C·uDerivativeℙ : ∀ P C f f'
+        → uDerivativeOfℙ P , f is f'
+        → uDerivativeOfℙ P , (λ x x∈ → C ·ᵣ f x x∈) is (λ x x∈ → C ·ᵣ f' x x∈)
+C·uDerivativeℙ P C f f' udp ε =
+  PT.rec squash₁
+    (λ (η , 0<η , η<1/[C+1]) →
+      PT.map (map-snd
+        (λ X _ _ _ h∈ 0＃h h<a →
+          isTrans≡<ᵣ _ _ _
+             (cong absᵣ (cong₂ _-ᵣ_ refl
+               (sym (·ᵣAssoc _ _ _ ∙
+           cong (_·ᵣ (invℝ _ 0＃h)) (·DistL- _ _ _)))
+               ∙ sym (𝐑'.·DistR- C _ _) )
+               ∙ ·absᵣ _ _)
+             (isTrans≤<ᵣ _ _ _
+               (≤ᵣ-·ᵣo (absᵣ C) _ _ (0≤absᵣ _)
+                 (isTrans≡≤ᵣ _ _ _
+                    (sym (+IdR _))
+                    (≤ᵣ-o+ 0 1 (absᵣ C) decℚ≤ᵣ?)))
+               (fst (z<x/y₊≃y₊·z<x _ _ _)
+             (isTrans<ᵣ _ _ _
+            (X _ _ _ h∈ 0＃h h<a)
+            η<1/[C+1])))))
+        (udp (η , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<η))))
+    (denseℚinℝ 0 _ (snd (ℚ₊→ℝ₊ ε ₊·ᵣ invℝ₊ (absᵣ C +ᵣ 1 ,
+      isTrans≡<ᵣ _ _ _
+        (sym (+ᵣ-rat _ _)) (≤<ᵣMonotone+ᵣ _ _ _ _
+          (0≤absᵣ C) (decℚ<ᵣ? {0} {1}))))))
+
+
 substDer : ∀ {x f' f g} → (∀ r → f r ≡ g r)
      → derivativeOf f at x is f'
      → derivativeOf g at x is f'
@@ -368,12 +698,229 @@ derivative-^ⁿ (suc n) x =
        (·ᵣComm _ _) (sym (·ᵣAssoc _ _ _)) ∙
        sym (·DistR+ _ _ _) ∙
         cong (_·ᵣ ((x ^ⁿ n) ·ᵣ idfun ℝ x))
-         (cong rat (ℚ.ℕ+→ℚ+ _ _)))
+         (+ᵣ-rat _ _ ∙ cong rat (ℚ.ℕ+→ℚ+ _ _)))
     (·Derivative _ _ _ _ _ IsContinuousId
        (derivative-^ⁿ n x) (idDerivative x))
 
+derivative-∘· : ∀ f f' x k
+   → derivativeOf f at x is f'
+   → derivativeOf (f ∘ (fst k ·ᵣ_)) at x ／ᵣ₊ k is (fst k ·ᵣ f')
+derivative-∘· f f' x k X ε =
+ PT.map
+  (λ (δ , Y) →
+    (δ ₊·ᵣ invℝ₊ k) , λ h 0＃h v →
+         let 0＃k·h : (0 <ᵣ fst k ·ᵣ h) ⊎ (fst k ·ᵣ h <ᵣ 0)
+             0＃k·h = ⊎.map
+                (λ 0<h → snd (k ₊·ᵣ (h , 0<h)))
+                (λ h<0 → isTrans<≡ᵣ _ _ _
+                           (<ᵣ-o·ᵣ _ _ k h<0) (𝐑'.0RightAnnihilates _)) 0＃h
+             u = fst (z<x/y₊≃y₊·z<x _ _ _) (Y (fst k ·ᵣ h)
+                   0＃k·h (isTrans≡<ᵣ _ _ _
+                    (cong absᵣ (+IdL _ ∙ sym (·-ᵣ _ _)) ∙ ·absᵣ _ _  ∙
+                      cong₂ _·ᵣ_
+                       ((absᵣPos _ (snd k)))
+                       (cong absᵣ (sym (+IdL _))))
+                    (fst (z<x/y₊≃y₊·z<x _ _ _) v)))
+         in  isTrans≡<ᵣ _ _ _
+              (cong absᵣ
+                  (   cong (_-ᵣ_ (fst k ·ᵣ f'))
+                    ((cong₂ _·ᵣ_
+                       (cong₂ _-ᵣ_
+                         (cong f (·DistL+ _ _ _ ∙
+                           cong (_+ᵣ fst k ·ᵣ h)
+                             (·ᵣComm _ _ ∙ [x/₊y]·yᵣ x k) ))
+                         (cong f (·ᵣComm _ _ ∙ [x/₊y]·yᵣ x k)))
+                       ((sym ([x/y]·yᵣ _ _ _))
+                        ∙ cong (_·ᵣ (fst k))
+                         (·ᵣComm _ _ ∙ sym (invℝ· (fst k) h (inl (snd k)) _ 0＃k·h)) )
+                     ∙  (·ᵣAssoc _ _ _))
+                      ∙ ·ᵣComm _ _)
+                    ∙ sym (·DistL- _ _ _))
+               ∙∙ ·absᵣ _ _
+               ∙∙ cong (_·ᵣ absᵣ (f' -ᵣ differenceAt f x (fst k ·ᵣ h) 0＃k·h))
+                   (absᵣPos _ (snd k))) u)
+   (X (ε ₊·ᵣ invℝ₊ k))
+
+-- -- -- easy to prove, but with narrow assumptin
+
+
+
+chainRuleIncr : ∀ x f f'gx g g'x
+        → isIncrasing g
+        → IsContinuous g
+        → 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)
+chainRuleIncr x f f'gx g g'x incrG cg dg df =
+  let z = ·-lim _ _ _ _ _ w dg
+  in substLim (λ h 0#h → sym (x/y=x/z·z/y _ _ _ _ _)) z
+
+ where
+ 0#g : ∀ h → (0＃h : 0 ＃ h) → 0 ＃ (g (x +ᵣ h) -ᵣ g x)
+ 0#g h = ⊎.map ((x<y→0<y-x _ _ ∘S incrG _ _)
+           ∘S subst (_<ᵣ (x +ᵣ h)) (+IdR x) ∘S <ᵣ-o+ _ _ x)
+            (((x<y→x-y<0 _ _ ∘S incrG _ _)
+           ∘S subst ((x +ᵣ h) <ᵣ_) (+IdR x) ∘S <ᵣ-o+ _ _ x))
+
+ w' :   ∀ (ε : ℝ₊) → ∃[ δ ∈ ℝ₊ ]
+        (∀ h 0＃h →
+           absᵣ (0 -ᵣ h) <ᵣ fst δ →
+             absᵣ (f'gx -ᵣ ((f (g (x)  +ᵣ h) -ᵣ f (g x))
+           ／ᵣ[ (h) , 0＃h ])) <ᵣ fst ε)
+
+ w' = df
+
+ w : at 0 limitOf
+        (λ h 0＃h → (f (g (x +ᵣ h)) -ᵣ f (g x))
+           ／ᵣ[ (g (x +ᵣ h) -ᵣ g x) , 0#g h 0＃h ]) is f'gx
+ w ε =
+   PT.rec squash₁
+     (λ (δ , X) →
+       PT.map
+        (map-snd (λ X* →
+          (λ h 0＃h ∣h∣<δ' →
+           let Δg<δ = isTrans≡<ᵣ _ _ _
+                     (cong absᵣ (+IdL _ ∙ -[x-y]≡y-x _ _))
+                    (X* h 0＃h ∣h∣<δ')
+               z = X (g (x +ᵣ h) -ᵣ g x) (0#g h 0＃h) Δg<δ
+           in isTrans≡<ᵣ _ _ _
+             (cong (absᵣ ∘ (λ x → f'gx -ᵣ x)
+               ∘ _／ᵣ[ (g (x +ᵣ h) -ᵣ g x) , 0#g h 0＃h ] ∘
+                  (_-ᵣ f (g x)) ∘ f)
+               (sym L𝐑.lem--05 ) ) z )))
+                (IsContinuousLimΔ _ x cg δ))
+     (w' ε)
+
 -- -- -- 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 = {!!}
+
+
+-- IsContinuousLimExcl : ∀ x f → IsContinuousWithPred (＃ℙ x) f →
+--                     at x limitOf f is (f x)
+-- IsContinuousLimExcl f x cx = ?
+--  -- inclLimit→Limit _ _ _ (IsContinuousInclLim f x cx)
+
+opaque
+ unfolding -ᵣ_
+ limitUniq : ∀ x f y y'
+  → at x limitOf f is y
+  → at x limitOf f is y'
+  → y ≡ y'
+ limitUniq x f y y' X X' = eqℝ _ _
+   λ ε →
+     PT.rec2 (isProp∼ _ _ _)
+       (λ (δ , D) (δ' , D') →
+         let [δ⊔δ]/2 = (minᵣ₊ δ δ') ₊·ᵣ (ℚ₊→ℝ₊ ([ 1 / 2 ] , _))
+             x＃ : x ＃ (x +ᵣ -ᵣ (minᵣ₊ δ δ' ₊·ᵣ ℚ₊→ℝ₊ ([ 1 / 2 ] , tt)) .fst)
+             x＃ = (inr (isTrans<≡ᵣ _ _ _
+                         (<ᵣ-o+ _ _ _ (-ᵣ<ᵣ _ _ (snd [δ⊔δ]/2))) (+IdR _)))
+         in subst∼ (ℚ.ε/2+ε/2≡ε (fst ε))
+                   (triangle∼  {ε = /2₊ ε} {/2₊ ε}
+                     (invEq (∼≃abs<ε _ _ _) (D (x -ᵣ fst [δ⊔δ]/2)
+                      x＃
+                      ((isTrans≡<ᵣ _ _ _
+                        (cong absᵣ L𝐑.lem--079 ∙ absᵣPos _ (snd [δ⊔δ]/2))
+                        (isTrans≤<ᵣ _ _ _
+                          (≤ᵣ-·o _ _ _ (ℚ.0≤pos _ _) (min≤ᵣ _ _)) (isTrans<≡ᵣ _ _ _
+                            (<ᵣ-o·ᵣ _ _ δ decℚ<ᵣ?) (·IdR _)))))))
+                       (sym∼ _ _ _
+                        ((invEq (∼≃abs<ε _ _ _) (D' (x -ᵣ fst [δ⊔δ]/2)
+                      x＃
+                      (isTrans≡<ᵣ _ _ _
+                        (cong absᵣ L𝐑.lem--079 ∙ absᵣPos _ (snd [δ⊔δ]/2))
+                        (isTrans≤<ᵣ _ _ _
+                          (≤ᵣ-·o _ _ _ (ℚ.0≤pos _ _) (min≤ᵣ' _ _)) (isTrans<≡ᵣ _ _ _
+                            (<ᵣ-o·ᵣ _ _ δ' decℚ<ᵣ?) (·IdR _)))))))))
+         )
+       (X (ℚ₊→ℝ₊ (/2₊ ε))) (X' (ℚ₊→ℝ₊ (/2₊ ε)))
+
+-- mapLimit : ∀ x f y (g : ℝ → ℝ)
+--   → IsContinuousWithPred (＃ℙ x) f
+--   → IsContinuous g
+--   → at x limitOf f is y
+--   → at x limitOf (λ r r#x → g (f r r#x)) is g y
+-- mapLimit x f y g fC gC X (ε , 0<ε) =
+--   PT.rec squash₁
+--     (λ (q , 0<q , q<e) →
+--      let q₊ = (q , {!!})
+--      in PT.rec squash₁
+--          (λ (δ , D) →
+--             PT.rec squash₁
+--               (λ (δ' , D') →
+--                 ∣ minᵣ₊ (ℚ₊→ℝ₊ δ') δ ,
+--                     (λ r x＃r x-r<δ →
+--                        {!D r x＃r ?!}) ∣₁)
+--               (gfC (x +ᵣ fst δ) (/2₊ q₊)
+--                   {!!})
+
+--                 )
+
+--          (X (ℚ₊→ℝ₊ (/2₊ q₊)) ))
+--    (denseℚinℝ _ _ 0<ε)
+
+--  where
+--   gfC : _
+--   gfC = IsContinuousWP∘' _ _ _ gC fC
+
+
+-- mapLimit' : ∀ x z f y (v : ∀ r r#x → z ＃ f r r#x) → ∀ ＃y → (g : ∀ r → z ＃ r → ℝ)
+--   → IsContinuousWithPred (＃ℙ x) f
+--   → IsContinuousWithPred (＃ℙ z) g
+--   → at x limitOf f is y
+--   → at x limitOf (λ r r#x → g (f r r#x) (v _ _)) is (g y ＃y)
+-- mapLimit' x z f y v ＃y g fC gC L = {!!}
+
+
+-- preMapLimit : ∀ x x' f g y → (u : ∀ r ＃r →  x' ＃ g r ＃r)
+--   → at x  limitOf g is x'
+--   → at x' limitOf f is y
+--   → at x  limitOf (λ r ＃r → f (g r ＃r) (u _ _)) is y
+-- preMapLimit = {!!}
+
+
+-- invDerivative : ∀ f x (f' : ℝ) → ∀ 0＃f'  → (isEquivF : isEquiv f)
+--   → IsContinuous f
+--   → IsContinuous (invEq (f , isEquivF))
+--   → derivativeOf f at x is f'
+--   → derivativeOf (invEq (f , isEquivF)) at (f x) is (invℝ f' 0＃f')
+-- invDerivative f x f' 0＃f' isEquivF fC gC d =
+--  let g = invEq (f , isEquivF)
+--      h' = λ h 0＃h →
+--              g (f x +ᵣ h) -ᵣ x
+--      d' = preMapLimit 0 0 _ h' f'
+--            (λ r ＃r →
+--              invEq (＃Δ _ _) {!!})
+--             (subst (at 0 limitOf h' is_)
+--               (cong (_-ᵣ x) (retEq (f , isEquivF) x) ∙ +-ᵣ x)
+--               (+-lim _ _ _ _ _ (IsContinuousLimΔ g (f x) gC)
+--                (const-lim (-ᵣ x) _)))
+--             d
+--      d'' = mapLimit' 0 0 _ f' {!!} 0＃f'
+--           invℝ
+--           (IsContinuousWP∘ _ _ _ _ _
+--             (IsContinuousWithPred-differenceAt _ _ fC)
+--              {!!})
+--           IsContinuousWithPredInvℝ
+--           d'
+
+--  in substLim (λ r x＃r →
+--       invℝ· _ _ (invEq (＃Δ _ _) {!!}) _ _ ∙∙ ·ᵣComm _ _ ∙∙
+--         cong₂ _·ᵣ_
+--           (invℝInvol _ _ ∙
+--             cong (λ z → (invEq (f , isEquivF) (f x +ᵣ r)) -ᵣ z)
+--               (sym (retEq (f , isEquivF) x)))
+--           (cong₂ invℝ
+--              (cong (_-ᵣ f x) (fst (equivAdjointEquiv (f , isEquivF))
+--                  (cong (x +ᵣ_) (cong (_-ᵣ x) (cong (invEq (f , isEquivF)) (+ᵣComm _ _)) )
+--                   ∙ +ᵣComm _ _ ∙ 𝐑'.minusPlus _ _))
+--                ∙ 𝐑'.plusMinus _ _)
+--              (toPathP (isProp＃  _ _ _ _)))
+--       ) d''
+
+
+-- fromCauchySequence'-limit : ∀ s ics →
+--     {!fromCauchySequence' s ics!}
+-- fromCauchySequence'-limit = {!!}
diff --git a/Cubical/HITs/CauchyReals/ExpLog.agda b/Cubical/HITs/CauchyReals/ExpLog.agda
new file mode 100644
index 0000000000..ad107930a3
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/ExpLog.agda
@@ -0,0 +1,209 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.ExpLog 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.Foundations.Powerset
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.Structure
+
+open import Cubical.Functions.FunExtEquiv
+open import Cubical.Functions.Embedding
+open import Cubical.Functions.Surjection
+
+open import Cubical.Relation.Nullary
+
+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.Data.Unit
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.HITs.SetQuotients as SQ hiding (_/_)
+
+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
+open import Cubical.HITs.CauchyReals.Sequence
+open import Cubical.HITs.CauchyReals.Bisect
+-- open import Cubical.HITs.CauchyReals.BisectApprox
+open import Cubical.HITs.CauchyReals.NthRoot
+open import Cubical.HITs.CauchyReals.Derivative
+
+open import Cubical.HITs.CauchyReals.Exponentiation
+open import Cubical.HITs.CauchyReals.ExponentiationDer
+open import Cubical.HITs.CauchyReals.ExponentiationMore
+
+import Cubical.Algebra.CommRing.Instances.Int as ℤCRing
+open import Cubical.Algebra.Group.Instances.Bool
+open import Cubical.Algebra.Ring
+open import Cubical.Algebra.Ring.Properties
+open import Cubical.Algebra.Group
+open import Cubical.Algebra.Group.Morphisms
+open import Cubical.Algebra.Group.MorphismProperties
+import Cubical.Algebra.CommRing as CR
+
+open import Cubical.Algebra.Group.DirProd
+
+
+ln-mon-str-<1 :
+   ∀ (y y' : ℝ₊)
+   → fst y' <ᵣ 1
+   → fst y <ᵣ fst y'
+   → ln y <ᵣ ln y'
+ln-mon-str-<1 y y' y'<1 y<y' =
+  <ᵣ-ᵣ _ _ $ subst2 _<ᵣ_
+   (ln-inv y')
+   (ln-inv y)
+   (ln-mon-str-1< (invℝ₊ y') (invℝ₊ y)
+   (fst (1/x<1≃1<x (invℝ₊ y'))
+    (isTrans≡<ᵣ _ _ _ (cong fst (invℝ₊Invol y')) y'<1))
+       (invEq (invℝ₊-<-invℝ₊ _ _) y<y'))
+
+
+
+module 𝒆-number a (1<a : 1 <ᵣ fst a) where
+  𝒆' : ℝ₊
+  𝒆' = a ^ᵣ (fst (invℝ₊ (ln a , 1<a→0<ln[a] a 1<a)))
+
+  ln-𝒆'≡1 : ln 𝒆' ≡ 1
+  ln-𝒆'≡1 = ln[a^b₊]≡b₊·ln[a] _ (invℝ₊ _) ∙ ·ᵣComm _ _ ∙ x·invℝ₊[x] (ln a , 1<a→0<ln[a] a 1<a)
+
+  ln[𝒆'^x]≡x : ∀ (x : ℝ) → (ln (𝒆' ^ᵣ x)) ≡  x
+  ln[𝒆'^x]≡x x = ln[a^b]≡b·ln[a] _ x ∙ 𝐑'.·IdR' _ _  ln-𝒆'≡1
+
+  𝒆'^ln[x]≡x : ∀ (x : ℝ₊) → (𝒆' ^ᵣ (ln x)) ≡  x
+  𝒆'^ln[x]≡x x = inj-ln (𝒆' ^ᵣ ln x) x (ln[𝒆'^x]≡x (ln x))
+
+  exp-ln-Iso : Iso ℝ ℝ₊
+  exp-ln-Iso .Iso.fun = 𝒆' ^ᵣ_
+  exp-ln-Iso .Iso.inv = ln
+  exp-ln-Iso .Iso.rightInv = 𝒆'^ln[x]≡x
+  exp-ln-Iso .Iso.leftInv = ln[𝒆'^x]≡x
+
+  ln-+ : ∀ x x' → ln x +ᵣ ln x' ≡ ln (x ₊·ᵣ x')
+  ln-+ x x' =
+     sym (ln[𝒆'^x]≡x _) ∙  cong ln (^ᵣ+  𝒆' (ln x) (ln x') ∙
+       cong₂ _₊·ᵣ_ (𝒆'^ln[x]≡x x) (𝒆'^ln[x]≡x x'))
+
+  ln-mon-str : ∀ (y y' : ℝ₊)
+   → fst y <ᵣ fst y'
+   → ln y <ᵣ ln y'
+  ln-mon-str y y' y<y' =
+    <-o+-cancel _ _ _ $ subst2 _<ᵣ_
+     (sym (ln-+ (2 ₊·ᵣ invℝ₊ y) y))
+     (sym (ln-+ (2 ₊·ᵣ invℝ₊ y) y'))
+      $ ln-mon-str-1<
+       ((2 ₊·ᵣ (invℝ₊ y)) ₊·ᵣ y)
+       ((2 ₊·ᵣ (invℝ₊ y)) ₊·ᵣ y')
+       (isTrans<≡ᵣ 1 2 (fst ((2 ₊·ᵣ invℝ₊ y) ₊·ᵣ y)) decℚ<ᵣ? (sym ([x/₊y]·yᵣ 2 y)) )
+       (<ᵣ-o·ᵣ _ _ (2 ₊·ᵣ (invℝ₊ y)) y<y')
+
+  𝒆'^-der : ∀ y → derivativeOf (fst ∘ 𝒆' ^ᵣ_) at y is (fst (𝒆' ^ᵣ y))
+  𝒆'^-der y = subst (derivativeOf (λ r → fst r) ∘ _^ᵣ_ 𝒆' at y is_)
+     (𝐑'.·IdR' _ _ ln-𝒆'≡1) (^-der 𝒆' y)
+
+
+  1<𝒆' : 1 <ᵣ fst 𝒆'
+  1<𝒆' =
+    isTrans≡<ᵣ _ _ _
+      (sym (^ᵣ0 _)) (^ᵣ-mon-str a 1<a 0
+     (fst (invℝ₊ (ln a , 1<a→0<ln[a] a 1<a)))
+      (snd (invℝ₊ (ln a , 1<a→0<ln[a] a 1<a))))
+
+  ln-der : ∀ x₀ → derivativeOfℙ pred0< , curry ln at x₀ is fst (invℝ₊ x₀)
+  ln-der x₀ =
+    subst (λ x → derivativeOfℙ pred0< , curry ln at x is (fst (invℝ₊ x)))
+      (𝒆'^ln[x]≡x x₀)
+      w
+   where
+   w : derivativeOfℙ pred0< , curry ln at (𝒆' ^ᵣ (ln x₀))
+           is fst (invℝ₊ ((𝒆' ^ᵣ (ln x₀))))
+   w = invDerivativeℙ
+     (ln x₀)
+     _ (fst (𝒆' ^ᵣ (ln x₀)))
+     (snd (𝒆' ^ᵣ (ln x₀)))
+     (snd ∘ (𝒆' ^ᵣ_))
+     (snd (isoToEquiv exp-ln-Iso))
+     ln-mon-str
+     (^ᵣ-mon-str 𝒆' 1<𝒆' )
+     (cont-^ 𝒆')
+     ln-cont
+     (𝒆'^-der (ln x₀))
+
+  exp-log-group-hom : GroupHom +Groupℝ ·₊Groupℝ
+  exp-log-group-hom .fst = 𝒆' ^ᵣ_
+  exp-log-group-hom .snd = makeIsGroupHom (^ᵣ+ 𝒆')
+
+  exp-log-group-iso : GroupIso +Groupℝ ·₊Groupℝ
+  exp-log-group-iso = exp-ln-Iso , snd (exp-log-group-hom)
+
+
+𝒆-≡ : ∀ a 1<a a' 1<a' → 𝒆-number.𝒆' a 1<a ≡ 𝒆-number.𝒆' a' 1<a'
+𝒆-≡ a 1<a a' 1<a' = inj-ln _ _ (A.ln-𝒆'≡1 ∙ sym A'.ln-𝒆'≡1)
+
+ where
+ module A  = 𝒆-number a  1<a
+ module A' = 𝒆-number a' 1<a'
+
+
+·-+grpIso : ℝ₋₊ → Aut[ snd +Groupℝ ]ᵣ .fst
+·-+grpIso (α , 0＃α) =
+  (i , makeIsGroupHom λ x y → ·DistR+ x y α) ,
+   (IsContinuous·ᵣR α) , (IsContinuous·ᵣR (invℝ α 0＃α))
+ where
+  i : Iso _ _
+  i .Iso.fun = _·ᵣ α
+  i .Iso.inv = _·ᵣ invℝ α 0＃α
+  i .Iso.rightInv _ = [x/y]·yᵣ _ _ _
+  i .Iso.leftInv _ = [x·y]/yᵣ _ _ _
+
+grpIso→α : Aut[ snd +Groupℝ ]ᵣ .fst → ℝ
+grpIso→α x = Iso.fun (fst (fst x)) 1
+
+
+hhzzz : (a : Aut[ snd +Groupℝ ]ᵣ .fst) →
+  ∀ x → x ·ᵣ Iso.fun (fst (fst a)) 1 ≡ Iso.fun (fst (fst a)) x
+hhzzz a = ≡Continuous _ _
+ (IsContinuous·ᵣR _)
+ (fst (snd a))
+ (sym ∘ +GrAutomorphism.fun-rat (fst a))
+
+-- hhzz-iso : Iso ℝ₋₊ (Aut[ snd +Groupℝ ]ᵣ .fst)
+-- hhzz-iso .Iso.fun = ·-+grpIso
+-- hhzz-iso .Iso.inv x = grpIso→α x , {!!}
+-- hhzz-iso .Iso.rightInv a =
+--  AutCont.i≡ (snd +Groupℝ)
+--   (funExt (hhzzz a))
+-- hhzz-iso .Iso.leftInv α =
+--  ℝ₋₊≡ (·IdL _)
+
+-- hhzz : GroupIso ·Groupℝ Aut[ snd +Groupℝ ]ᵣ
+-- hhzz .fst = hhzz-iso
+-- hhzz .snd = makeIsGroupHom λ x y → AutCont.i≡ (snd +Groupℝ)
+--   (funExt λ _ → ·ᵣAssoc _ _ _)
diff --git a/Cubical/HITs/CauchyReals/Exponentiation.agda b/Cubical/HITs/CauchyReals/Exponentiation.agda
new file mode 100644
index 0000000000..aba4ee02b8
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Exponentiation.agda
@@ -0,0 +1,2331 @@
+{-# OPTIONS --safe  --lossy-unification #-} --
+
+module Cubical.HITs.CauchyReals.Exponentiation where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Equiv.Properties
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Powerset
+open import Cubical.Foundations.Transport
+
+open import Cubical.Functions.Embedding
+open import Cubical.Functions.Surjection
+
+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.Data.Unit
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.HITs.SetQuotients as SQ hiding (_/_)
+
+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
+open import Cubical.HITs.CauchyReals.Sequence
+open import Cubical.HITs.CauchyReals.Bisect
+open import Cubical.HITs.CauchyReals.NthRoot
+
+
+
+ointervalℙ⊆-max : ∀ n m →
+           ointervalℙ
+           (rat (ℚ.- fromNat (suc n)))
+           (rat (fromNat (suc n))) ⊆
+           ointervalℙ
+           (rat (ℚ.- fromNat (suc (max n m))))
+           (rat (fromNat (suc (max n m))))
+ointervalℙ⊆-max n m x (≤x , x≤) =
+    (isTrans≤<ᵣ _ _ _
+    (≤ℚ→≤ᵣ _ _ (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≥→negsuc-≤-negsuc _ _ ℕ.left-≤-max)))
+    ≤x)
+  , isTrans<≤ᵣ _ _ _ x≤
+       (≤ℚ→≤ᵣ _ _ (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _
+         (ℕ.left-≤-max {suc n} {suc m}))))
+
+
+ointervalℙ⊆-max' : ∀ n m →
+           ointervalℙ
+           (rat (ℚ.- fromNat (suc m)))
+           (rat (fromNat (suc m))) ⊆
+           ointervalℙ
+           (rat (ℚ.- fromNat (suc (max n m))))
+           (rat (fromNat (suc (max n m))))
+ointervalℙ⊆-max' n m x (≤x , x≤) =
+  (isTrans≤<ᵣ _ _ _
+    (≤ℚ→≤ᵣ _ _ (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≥→negsuc-≤-negsuc _ _ ℕ.right-≤-max)))
+    ≤x)
+  , isTrans<≤ᵣ _ _ _ x≤
+       (≤ℚ→≤ᵣ _ _ (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _
+         (ℕ.right-≤-max {suc m} {suc n}))))
+
+
+module RestrℝIso (a b fa fb : ℝ)
+      (isom :
+          Iso (Σ ℝ (_∈ ointervalℙ a b))
+              (Σ ℝ (_∈ ointervalℙ fa fb))) where
+
+ open Iso isom
+
+ module _ (monotoneFun : ∀ x y → fst x ≤ᵣ fst y → fst (fun x) ≤ᵣ fst (fun y))
+          (monotoneInv : ∀ x y → fst x ≤ᵣ fst y → fst (inv x) ≤ᵣ fst (inv y))
+          (a' b' : ℝ) (a'<b' : a' <ᵣ b')
+          (a'∈ : a' ∈ ointervalℙ a b)
+          (b'∈ : b' ∈ ointervalℙ a b) where
+
+  fa' = fun (a' , a'∈)
+  fb' = fun (b' , b'∈)
+
+  restrIso : Iso (Σ ℝ (_∈ intervalℙ a' b'))
+                 (Σ ℝ (_∈ intervalℙ (fst fa') (fst fb')))
+  restrIso .Iso.fun (x , ≤x , x≤) =
+    let X = (x ,
+             (isTrans<≤ᵣ _ _ _ (fst a'∈) ≤x)
+               , isTrans≤<ᵣ _ _ _ x≤ (snd b'∈))
+        (fx , fx∈) = fun X
+    in fx , monotoneFun (a' , a'∈) X ≤x
+          , monotoneFun X (b' , b'∈) x≤
+  restrIso .Iso.inv (x , ≤x , x≤) =
+    let X = (x ,
+             (isTrans<≤ᵣ _ _ _ (fst (snd fa')) ≤x)
+               , isTrans≤<ᵣ _ _ _ x≤ (snd (snd fb')))
+        (fx , fx∈) = inv X
+    in fx , isTrans≡≤ᵣ _ _ _ (sym (cong fst (leftInv (a' , a'∈))))
+            (monotoneInv fa' X ≤x)
+          , isTrans≤≡ᵣ _ _ _ (monotoneInv X fb' x≤)
+            (cong fst (leftInv (b' , b'∈)))
+  restrIso .Iso.rightInv _ =
+   Σ≡Prop (∈-isProp (intervalℙ _ _))
+     (cong fst
+        ((cong fun (Σ≡Prop (∈-isProp (ointervalℙ _ _))
+          (refl))) ∙ rightInv _))
+
+  restrIso .Iso.leftInv _ =
+   Σ≡Prop (∈-isProp (intervalℙ _ _))
+     (cong fst
+        ((cong inv (Σ≡Prop (∈-isProp (ointervalℙ _ _))
+          (refl))) ∙ leftInv _))
+
+
+module EquivFromRestr
+     (f : ℝ → ℝ)
+
+     (f∈ₙ : ∀ n x → (x ∈ (ointervalℙ
+                      (rat (ℚ.- fromNat (suc n)))
+                      (rat (fromNat (suc n))))) →
+                       f x ∈ (ointervalℙ
+                      (f (rat (ℚ.- fromNat (suc n))))
+                      (f (rat (fromNat (suc n))))))
+     (equiv-restr : ∀ n →
+       isEquiv {A = Σ ℝ (_∈ (ointervalℙ
+                      (rat (ℚ.- fromNat (suc n)))
+                      (rat (fromNat (suc n)))))}
+               {B = Σ ℝ (_∈ (ointervalℙ
+                      (f (rat (ℚ.- fromNat (suc n))))
+                      (f (rat (fromNat (suc n))))))}
+                λ (x , x∈) → f x , f∈ₙ n x x∈) where
+
+ clamp' : ∀ x → ∃[ n ∈ ℕ ] (x ∈ (ointervalℙ
+                  ((rat (ℚ.- fromNat (suc n))))
+                  ((rat (fromNat (suc n))))))
+ clamp' x =
+   PT.map (λ (1+ n , X) →
+        n
+     , isTrans<≡ᵣ _ _ _
+           (isTrans≡<ᵣ _ _ _ (sym (-ᵣ-rat  _)) (-ᵣ<ᵣ _ _ (isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+           (isTrans≡<ᵣ _ _ _ (sym (-absᵣ _)) X))))
+
+            (-ᵣInvol x)
+     , isTrans≤<ᵣ _ _ _ (≤absᵣ _) X)
+     (getClamps x)
+
+ Bℙ : ℙ ℝ
+ Bℙ x = (∃[ n ∈ ℕ ] (x ∈ (ointervalℙ
+                      (f (rat (ℚ.- fromNat (suc n))))
+                      (f (rat (fromNat (suc n))))))) , squash₁
+
+ f' : ℝ → Σ ℝ (_∈ Bℙ)
+ f' x = f x , PT.map (map-snd (λ {n} → f∈ₙ n x)) (clamp' x)
+
+ f-inj : ∀ w x → f w ≡ f x → w ≡ x
+ f-inj w x =
+   PT.rec2 (isProp→ (isSetℝ _ _))
+     (λ (n , N) (m , M) →
+      λ fw=fx →
+         cong fst (invEq (congEquiv
+       {x = w , ointervalℙ⊆-max n m w N}
+       {y = x , ointervalℙ⊆-max' n m x M} (_ , equiv-restr (ℕ.max n m)))
+         (Σ≡Prop (∈-isProp _) fw=fx)))
+    (clamp' w) (clamp' x)
+
+ isEmbedding-f' : isEmbedding f'
+ isEmbedding-f' w x =
+  snd (propBiimpl→Equiv (isSetℝ _ _)
+      ((isSetΣ isSetℝ (isProp→isSet ∘ ∈-isProp Bℙ)) _ _)
+    (cong f')
+    (f-inj w x ∘ cong fst))
+
+ isSurjection-f' : isSurjection f'
+ isSurjection-f' = λ (x , x∈) →
+   PT.map (λ (n , N) →
+    let (y , y∈) = invEq (_ , equiv-restr n) (_ , N)
+    in y , Σ≡Prop (∈-isProp _) (cong fst (secEq (_ , equiv-restr n) (_ , N))))
+    x∈
+
+ equiv-fromRestr : isEquiv f'
+ equiv-fromRestr = isEmbedding×isSurjection→isEquiv
+  (isEmbedding-f' , isSurjection-f')
+
+
+ℚApproxℙ''→ℚApproxℙ' : ∀ (P Q : ℙ ℝ) f  →
+  (ℚApproxℙ'' P Q f) → (ℚApproxℙ' P Q f)
+ℚApproxℙ''→ℚApproxℙ' P Q f X q q∈P =
+  fst ∘ X q q∈P ∘ /2₊
+  , fst ∘ snd ∘ X q q∈P ∘ /2₊ , zz ,
+
+    eqℝ _ _ λ ε →
+       let z = triangle∼ {ε = (/2₊ ε ℚ₊+ /2₊ (/2₊ ε)) ℚ₊+ (/2₊ (/2₊ (/2₊ ε)))}
+                    (lim-rat (rat ∘ fst ∘ X q q∈P ∘ /2₊) _ _
+                      (/2₊ (/2₊ ε))
+                      _ (subst 0<_
+                         (sym (𝐐'.plusMinus _ _)
+                            ∙ cong (ℚ._- fst (/2₊ (/2₊ ε))) (
+                               sym (ℚ.+Assoc _ _ _)
+                              ∙∙ cong (fst (/2₊ ε) ℚ.+_) (ℚ.+Comm _ _)
+                               ∙∙ ℚ.+Assoc _ _ _) )
+                         (snd ((/2₊ ε) ℚ₊+ (/2₊ (/2₊ (/2₊ ε))))  )) (refl∼ _ _))
+
+                  (snd (snd (X q q∈P (/2₊ (/2₊ (/2₊ ε))))))
+       in subst∼ (sym (ℚ.+Assoc _ _ _)
+               ∙∙ cong ((fst (/2₊ ε) ℚ.+ fst (/2₊ (/2₊ ε))) ℚ.+_)
+                     (ℚ.ε/2+ε/2≡ε _)
+               ∙∙ (sym (ℚ.+Assoc _ _ _)
+                ∙∙ cong (fst (/2₊ ε) ℚ.+_) (ℚ.ε/2+ε/2≡ε _)
+                ∙∙ ℚ.ε/2+ε/2≡ε (fst ε))) z
+ where
+ zz : (δ ε : ℚ₊) →
+      rat (fst (X q q∈P (/2₊ δ))) ∼[ δ ℚ₊+ ε ]
+      rat (fst (X q q∈P (/2₊ ε)))
+ zz δ ε = ∼-monotone< (
+       subst (ℚ._< fst (δ ℚ₊+ ε)) (ℚ.·DistR+ _ _ _) (x/2<x (δ ℚ₊+ ε)))
+   (triangle∼ (snd (snd ((X q q∈P) (/2₊ δ)))) --((snd ((X q q∈P) (/2₊ δ))))
+     (sym∼ _ _ _ (snd ((snd ((X q q∈P) (/2₊ ε))))) --((snd ((X q q∈P) (/2₊ ε))))
+     ))
+
+
+
+
+clamp-abs : ∀ L L' x → L ℚ.≤ L' →
+     ℚ.abs (ℚ.clamp L L' x) ℚ.≤ ℚ.max (ℚ.abs L) (ℚ.abs L')
+clamp-abs L L' x L≤L' = ⊎.rec
+  (λ 0≤ → subst (ℚ._≤ ℚ.max (ℚ.abs L) (ℚ.abs L'))
+     (sym (ℚ.absNonNeg _ 0≤))
+       (ℚ.isTrans≤ _ _ _ (ℚ.clamp≤ L L' x)
+        (ℚ.isTrans≤ _ _ _
+          (ℚ.≤abs _) (ℚ.≤max' _ _))))
+  (λ <0 →
+     subst (ℚ._≤ ℚ.max (ℚ.abs L) (ℚ.abs L'))
+       (sym (ℚ.absNeg _ <0))
+       (ℚ.isTrans≤ _ _ _
+         (ℚ.isTrans≤ _ _ _
+          (ℚ.minus-≤ _ _ (ℚ.≤clamp L L' x L≤L'))
+          (subst (ℚ.- L ℚ.≤_) (sym (ℚ.abs'≡abs L)) (ℚ.-≤abs' L)))
+         (ℚ.≤max _ _)))
+  (ℚ.Dichotomyℚ 0 (ℚ.clamp L L' x))
+
+module _ (f : ℚ → ℝ) (B : ℕ → ℚ₊)  where
+
+ boundedLipschitz : Type
+ boundedLipschitz =
+   ∀ n x y
+       → ℚ.abs x ℚ.≤ fromNat (suc n)
+       → ℚ.abs y ℚ.≤ fromNat (suc n)
+     →  absᵣ (f y -ᵣ f x) ≤ᵣ rat (fst (B n) ℚ.· ℚ.abs (y ℚ.- x))
+
+ module BoundedLipsch (bl : boundedLipschitz) where
+
+
+  flₙ : ∀ n → Σ (Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ (B n))) (IsContinuous ∘ fst)
+  flₙ n = fl , uncurry (Lipschitz→IsContinuous _) fl
+   where
+   fl = fromLipschitz (B n)
+     (f ∘ ℚ.clamp (fromNeg (suc n)) (fromNat (suc n)) ,
+         Lipschitz-ℚ→ℝ'→Lipschitz-ℚ→ℝ _ _
+           λ q r → isTrans≤ᵣ _ _ _ (bl n
+             (ℚ.clamp (fromNeg (suc n)) (fromNat (suc n)) r)
+             (ℚ.clamp (fromNeg (suc n)) (fromNat (suc n)) q)
+              (ℚ.isTrans≤ _ _ _ (clamp-abs _ _ _
+                (ℚ.≤ℤ→≤ℚ _ _ ℤ.negsuc<pos))
+                ((ℚ.≡Weaken≤ _ _ (((ℚ.≤→max (ℚ.abs (fromNeg (suc n)))
+                    (ℚ.abs (fromNat (suc n))
+                     ) (ℚ.≡Weaken≤ _ _
+                        ((ℚ.absNeg _
+                         (ℚ.<ℤ→<ℚ _ _ ℤ.negsuc<-zero)
+                          ) ∙ sym (ℚ.absPos _ (ℚ.0<sucN _))))))
+                      ∙ ℚ.absPos _ (ℚ.0<sucN _)))) )
+              (ℚ.isTrans≤ _ _ _ (clamp-abs _ _ _
+                (ℚ.≤ℤ→≤ℚ _ _ ℤ.negsuc<pos))
+                ((ℚ.≡Weaken≤ _ _ (((ℚ.≤→max (ℚ.abs (fromNeg (suc n)))
+                    (ℚ.abs (fromNat (suc n))
+                     ) (ℚ.≡Weaken≤ _ _
+                        ((ℚ.absNeg _
+                         (ℚ.<ℤ→<ℚ _ _ ℤ.negsuc<-zero)
+                          ) ∙ sym (ℚ.absPos _ (ℚ.0<sucN _))))))
+                      ∙ ℚ.absPos _ (ℚ.0<sucN _)))) ))
+              (≤ℚ→≤ᵣ _ _ (ℚ.≤-o· _ _ _ (ℚ.0≤ℚ₊ (B n))
+                (ℚ.clampDist _ _ _ _))))
+
+
+  Seq⊆→Power : Seq⊆→ ℝ Seq⊆-abs<N
+  Seq⊆→Power .Seq⊆→.fun x n _ = fst (fst (flₙ n)) x
+  Seq⊆→Power .Seq⊆→.fun⊆ x n m x∈@(<x , x<) x'∈@(<x' , x'<) n<m =
+    (cong (fst (fst (flₙ n))) (∈ℚintervalℙ→clampᵣ≡ _ _ _
+      (<ᵣWeaken≤ᵣ _ _ <x , <ᵣWeaken≤ᵣ _ _ x<)) ∙∙
+    ≡Continuous _ _
+       (IsContinuous∘ _ _ (snd (flₙ n))
+         (IsContinuousClamp (fromNeg (suc n)) (fromNat (suc n)) ))
+       (IsContinuous∘ _ _ (snd (flₙ m))
+         (IsContinuousClamp (fromNeg (suc n)) (fromNat (suc n)) ))
+        (λ x →
+         cong f
+          (sym (clamp-contained-agree _ _ _ _ _
+          (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≥→negsuc-≤-negsuc _ _ (ℕ.<-weaken n<m)))
+           (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _ (ℕ.≤-suc n<m)))
+           (clam∈ℚintervalℙ _ _ (ℚ.≤ℤ→≤ℚ _ _ ℤ.negsuc<pos) _))))
+             x
+    ∙∙ cong (fst (fst (flₙ m))) (
+       sym (∈ℚintervalℙ→clampᵣ≡ _ _ _
+      (<ᵣWeaken≤ᵣ _ _ <x , <ᵣWeaken≤ᵣ _ _ x<))))
+
+
+  open Seq⊆→.FromIntersection Seq⊆→Power
+    isSetℝ (λ _ → Unit , isPropUnit) Seq⊆-abs<N-s⊇-⊤Pred public
+
+  𝒇 : ℝ → ℝ
+  𝒇 x = ∩$ x _
+
+
+
+  𝒇-rat : ∀ q → 𝒇 (rat q) ≡ f q
+  𝒇-rat q = PT.rec (isSetℝ _ _) (λ y → snd (snd y) ∙ cong f
+        (sym (∈ℚintervalℙ→clam≡ _ _ _
+          (∈intervalℙ→∈ℚintervalℙ _ _ _
+             (<ᵣWeaken≤ᵣ _ _ (fst (fst (snd y))) ,
+              <ᵣWeaken≤ᵣ _ _ (snd (fst (snd y))))))))
+    (∩$-lem (rat q) _)
+
+  𝒇-cont : IsContinuous 𝒇
+  𝒇-cont = contDropPred 𝒇 (∩$-cont _ _ (λ _ → openIintervalℙ _ _)
+     _ _ λ n → AsContinuousWithPred (λ _ → _ ,
+         isProp× _ _)
+                 (fst (fst (flₙ n)))
+                  (snd (flₙ n)))
+  module Equiv𝒇₊ (f∈ : ∀ n x x∈ → fst (fst (flₙ n)) x ∈
+                   ointervalℙ (𝒇 (fromNeg (suc n)))
+                             (𝒇 (fromNat (suc n))))
+           (isEquivFₙ : ∀ n →
+           isEquiv
+              {A = Σ _ (_∈ ointervalℙ (fromNeg (suc n)) (fromNat (suc n)))}
+              {B = Σ _ (_∈ ointervalℙ (𝒇 (fromNeg (suc n)))
+                                      (𝒇 (fromNat (suc n))))}
+             λ (x , x∈) →
+                ((fst (fst (flₙ n))) x) ,
+                  f∈ n x x∈)
+           (exN' : ∀ b → 0 <ᵣ b → ∃[ n ∈ ℕ ]
+                  b ∈
+                   ointervalℙ (𝒇 (fromNeg (suc n)))
+                             (𝒇 (fromNat (suc n))))
+           (𝒇-pos : ∀ x → 0 <ᵣ 𝒇 x)
+      where
+
+   𝒇₊ : ℝ → ℝ₊
+   𝒇₊ x = 𝒇 x , 𝒇-pos x
+
+   isEmbedding-𝒇 : isEmbedding {A = ℝ} {B = ℝ₊} 𝒇₊
+   isEmbedding-𝒇 w x =
+    snd
+     (propBiimpl→Equiv (isSetℝ _ _) (isSetℝ₊ _ _)
+      (cong 𝒇₊)
+      ((∩$-elimProp2 w _ x _ {λ u v → u ≡ v → w ≡ x}
+       (λ _ _ → isProp→ (isSetℝ _ _))
+        λ n w∈ x∈ p → cong fst
+          (invEq (congEquiv {x = _ , w∈} {y = _ , x∈}
+            (_ , isEquivFₙ n))
+            (Σ≡Prop (∈-isProp
+             (ointervalℙ
+               (𝒇 (fromNeg (suc n)))
+               (𝒇 (fromNat (suc n))))) p)) ) ∘ cong fst)
+               )
+
+   isSurjection-𝒇 : isSurjection 𝒇₊
+   isSurjection-𝒇 (b , b∈') =
+     PT.map (λ (n , b∈) →
+       let (y , y∈) = invEq (_ , isEquivFₙ n) (b , b∈)
+       in y , ℝ₊≡
+            (∩$-∈ₙ _ _ n y∈
+           ∙ cong fst (secEq (_ , isEquivFₙ n) (b , b∈))))
+       (exN' b b∈')
+
+   𝒇₊-equiv : isEquiv 𝒇₊
+   𝒇₊-equiv = isEmbedding×isSurjection→isEquiv
+     (isEmbedding-𝒇 , isSurjection-𝒇)
+
+  lipFₙ : ∀ n → Lipschitz-ℝ→ℝℙ (B n)
+       (intervalℙ (rat (ℚ.- fromNat (suc n))) (rat (fromNat (suc n))))
+       (λ x _ → fst (fst (flₙ n)) x)
+  lipFₙ n u _ v _ = snd (fst (flₙ n)) u v
+
+  module _ (K : ℕ → ℚ₊) where
+   boundedInvLipschitz : Type
+   boundedInvLipschitz =
+     ∀ n x y
+         → ℚ.abs x ℚ.≤ fromNat (suc n)
+         → ℚ.abs y ℚ.≤ fromNat (suc n)
+       →  rat (ℚ.abs (y ℚ.- x)) ≤ᵣ rat (fst (K n)) ·ᵣ absᵣ (f y -ᵣ f x)
+
+   module BoundedInvLipsch (ibl : boundedInvLipschitz)
+              -- (𝒇-pos : ∀ x → 0 <ᵣ 𝒇 x)
+              -- (aprox : ℚApproxℙ' ⊤Pred (λ x → (rat [ pos 0 / 1+ 0 ] <ᵣ x) , squash₁)
+              --     λ x _ → 𝒇 x , 𝒇-pos x)
+              where
+    invLipFₙ : ∀ n → Invlipschitz-ℝ→ℝℙ (K n)
+      (intervalℙ (rat (ℚ.- fromNat (suc n))) (rat (fromNat (suc n))))
+      (λ x _ → fst (fst (flₙ n)) x)
+    invLipFₙ n u u∈ v v∈ ε X =
+     let X' = fst (∼≃abs<ε _ _ _) X
+
+
+     in invEq (∼≃abs<ε _ _ _)
+          (isTrans≤<ᵣ _ _ _
+            bil-clamp
+            (isTrans<≡ᵣ _ _ _
+              (<ᵣ-o·ᵣ _ _ (ℚ₊→ℝ₊ (K n)) X')
+              (sym (rat·ᵣrat _ _))))
+
+        where
+
+         u' = clampᵣ (rat (ℚ.- [ pos (suc n) / 1+ 0 ]))
+                (rat [ pos (suc n) / 1+ 0 ]) u
+         v' = clampᵣ (rat (ℚ.- [ pos (suc n) / 1+ 0 ]))
+                (rat [ pos (suc n) / 1+ 0 ]) v
+
+         opaque
+          unfolding _+ᵣ_
+          bil-clamp : absᵣ (u +ᵣ -ᵣ v) ≤ᵣ
+                       fst (ℚ₊→ℝ₊ (K n)) ·ᵣ
+                       absᵣ (fst (fst (flₙ n)) u +ᵣ -ᵣ fst (fst (flₙ n)) v)
+          bil-clamp =
+            subst2 {x = u'} {z = v'} (λ u v → absᵣ (u +ᵣ -ᵣ v) ≤ᵣ
+               fst (ℚ₊→ℝ₊ (K n)) ·ᵣ
+               absᵣ (fst (fst (flₙ n)) u +ᵣ -ᵣ fst (fst (flₙ n)) v))
+               (sym (∈ℚintervalℙ→clampᵣ≡ (rat (ℚ.- fromNat (suc n))) (rat (fromNat (suc n)))
+                   u ((fst u∈) , snd u∈)))
+               (sym (∈ℚintervalℙ→clampᵣ≡ (rat (ℚ.- fromNat (suc n))) (rat (fromNat (suc n)))
+                   v (fst v∈ , snd v∈)))
+               (≤Cont₂ {λ u v →
+                         absᵣ (clampᵣ (rat (ℚ.- [ pos (suc n) / 1+ 0 ]))
+                 (rat [ pos (suc n) / 1+ 0 ]) u -ᵣ
+                           clampᵣ (rat (ℚ.- [ pos (suc n) / 1+ 0 ]))
+                 (rat [ pos (suc n) / 1+ 0 ]) v)}
+                       {λ u v →
+                         fst (ℚ₊→ℝ₊ (K n)) ·ᵣ
+                       absᵣ (fst (fst (flₙ n)) (clampᵣ (rat (ℚ.- [ pos (suc n) / 1+ 0 ]))
+                 (rat [ pos (suc n) / 1+ 0 ]) u)
+                          -ᵣ fst (fst (flₙ n)) (clampᵣ (rat (ℚ.- [ pos (suc n) / 1+ 0 ]))
+                 (rat [ pos (suc n) / 1+ 0 ]) v))}
+                  (cont∘₂ IsContinuousAbsᵣ
+                      (cont₂∘ (contNE₂ sumR)
+                        (IsContinuousClamp (fromNeg (suc n)) (fromNat (suc n)) )
+                        (IsContinuous∘ _ _ IsContinuous-ᵣ
+                           (IsContinuousClamp (fromNeg (suc n)) (fromNat (suc n))))))
+                  (cont∘₂ (IsContinuous·ᵣL _)
+                     (cont∘₂ IsContinuousAbsᵣ
+                        (cont₂∘ (contNE₂ sumR)
+                            (IsContinuous∘ _ _
+                              (snd (flₙ n))
+                             (IsContinuousClamp (fromNeg (suc n)) (fromNat (suc n))))
+                            (IsContinuous∘ _ _ IsContinuous-ᵣ
+                              (IsContinuous∘ _ _
+                              (snd (flₙ n))
+                             (IsContinuousClamp (fromNeg (suc n)) (fromNat (suc n))))))))
+                    (λ u v →
+                        subst2 _≤ᵣ_
+                            (sym (absᵣ-rat _) ∙ cong absᵣ (sym (-ᵣ-rat₂ _ _)))
+                            (cong₂ (λ fu fv → rat (fst (K n)) ·ᵣ
+                              absᵣ (fu -ᵣ fv))
+                               (cong f (∈ℚintervalℙ→clam≡ _ _ _
+                                (clam∈ℚintervalℙ _ _ (ℚ.neg≤pos _ _) _))
+                                ∙ cong {x =
+                                rat (ℚ.clamp ((ℚ.- [ pos (suc n) / 1+ 0 ]))
+                                     ([ pos (suc n) / 1+ 0 ]) u) }
+                                       (fst (fst (flₙ n))) refl)
+                               (cong f (∈ℚintervalℙ→clam≡ _ _ _
+                                (clam∈ℚintervalℙ _ _ (ℚ.neg≤pos _ _) _))
+                                 ∙ cong {x =
+                                rat (ℚ.clamp ((ℚ.- [ pos (suc n) / 1+ 0 ]))
+                                     ([ pos (suc n) / 1+ 0 ]) v) }
+                                       (fst (fst (flₙ n))) refl))
+                           (ibl n
+                           (ℚ.clamp ((ℚ.- [ pos (suc n) / 1+ 0 ]))
+                               ([ pos (suc n) / 1+ 0 ]) (v))
+                           (ℚ.clamp ((ℚ.- [ pos (suc n) / 1+ 0 ]))
+                               ([ pos (suc n) / 1+ 0 ]) (u))
+                               (ℚ.absFrom≤×≤ _ _ (ℚ.≤clamp _ _ _ (ℚ.neg≤pos _ _))
+                                  (ℚ.clamp≤ (ℚ.- [ pos (suc n) / 1+ 0 ]) _ _))
+                               (ℚ.absFrom≤×≤ _ _ (ℚ.≤clamp _ _ _ (ℚ.neg≤pos _ _))
+                                  (ℚ.clamp≤ (ℚ.- [ pos (suc n) / 1+ 0 ]) _ _))) )
+                    u v)
+
+
+boundedLipsch-coh : (f : ℚ → ℝ) (B B' : ℕ → ℚ₊)
+    (bl : boundedLipschitz f B)
+    (bl' : boundedLipschitz f B')
+    → ∀ x →  BoundedLipsch.𝒇 f B bl x
+           ≡ BoundedLipsch.𝒇 f B' bl' x
+boundedLipsch-coh f B B' bl bl' =
+                  ≡Continuous _ _
+                   (BoundedLipsch.𝒇-cont f B bl)
+                   (BoundedLipsch.𝒇-cont f B' bl')
+                    λ r →
+                      BoundedLipsch.𝒇-rat f B bl r ∙
+                        sym (BoundedLipsch.𝒇-rat f B' bl' r)
+
+
+_₊^ⁿ_ : ℝ₊ → ℕ → ℝ₊
+(x , 0<x) ₊^ⁿ n  = (x ^ⁿ n) , 0<x^ⁿ x n 0<x
+
+
+IsContinuous₊^ⁿ : ∀ n → IsContinuousWithPred
+         (λ x → _ , isProp<ᵣ _ _)
+         λ x 0<x →  fst ((x , 0<x) ₊^ⁿ n)
+IsContinuous₊^ⁿ zero = AsContinuousWithPred _ _
+ (IsContinuousConst 1)
+IsContinuous₊^ⁿ (suc n) =
+ cont₂·ᵣWP _ _ _
+   (IsContinuous₊^ⁿ n) (AsContinuousWithPred _ _
+  (IsContinuousId))
+
+
+^ℕ-+ : ∀ x a b → ((x ₊^ⁿ a) ₊·ᵣ (x ₊^ⁿ b)) ≡ (x ₊^ⁿ (a ℕ.+ b))
+^ℕ-+ x zero b = ℝ₊≡ (·IdL _)
+^ℕ-+ x (suc a) b =
+   ℝ₊≡ ((sym $ ·ᵣAssoc _ _ _)
+        ∙∙ cong (fst (x ₊^ⁿ a) ·ᵣ_) (·ᵣComm _ _)
+        ∙∙ ·ᵣAssoc _ _ _)
+  ∙ cong (_₊·ᵣ x) (^ℕ-+ x a b)
+
+_^ℤ_ : ℝ₊ → ℤ → ℝ₊
+x ^ℤ pos n = x ₊^ⁿ n
+x ^ℤ ℤ.negsuc n = invℝ₊ (x ₊^ⁿ (suc n))
+
+
+_ℚ^ℤ_ : ℚ₊ → ℤ → ℚ₊
+x ℚ^ℤ pos n = _ , ℚ.0<ℚ^ⁿ (fst x) (snd x) n
+x ℚ^ℤ ℤ.negsuc n = invℚ₊ (_ , ℚ.0<ℚ^ⁿ (fst x) (snd x) (suc n))
+
+
+
+
+^ℤ-rat : ∀ q n → ((ℚ₊→ℝ₊ q) ^ℤ n) ≡ ℚ₊→ℝ₊ (q ℚ^ℤ n)
+^ℤ-rat q (pos n) = ℝ₊≡ (^ⁿ-ℚ^ⁿ _ _)
+^ℤ-rat q (ℤ.negsuc n) =
+  ℝ₊≡ (  fst (ℚ₊→ℝ₊ q ^ℤ ℤ.negsuc n)
+      ≡⟨ cong (fst ∘ invℝ₊) (ℝ₊≡ (^ⁿ-ℚ^ⁿ _ _)) ⟩
+         fst (invℝ₊ (ℚ₊→ℝ₊ (_ , ℚ.0<ℚ^ⁿ (fst q) (snd q) (suc n))))
+      ≡⟨ invℝ'-rat _ _
+        (snd ((ℚ₊→ℝ₊ ((q .fst ℚ^ⁿ suc n) ,
+          ℚ.0<ℚ^ⁿ (fst q) (snd q) (suc n))))) ⟩ _
+      ∎)
+
+^ℤ-ℚApproxℙ'' : ∀ n → ℚApproxℙ''
+      (λ x → (rat [ pos 0 / 1+ 0 ] <ᵣ x) , isProp<ᵣ _ _)
+      (λ x → (rat [ pos 0 / 1+ 0 ] <ᵣ x) , isProp<ᵣ _ _)
+      (curry (λ p → ((p .fst , p .snd) ^ℤ n)))
+^ℤ-ℚApproxℙ'' n x x∈P ε =
+  fst (q₊ ℚ^ℤ n) , snd (ℚ₊→ℝ₊ (q₊ ℚ^ℤ n)) ,
+    ≡→∼ (cong fst (sym (^ℤ-rat q₊ n)) ∙
+         cong (curry (λ p → (p ^ℤ n) .fst) (rat x))
+             (isProp<ᵣ _ _ _ _))
+
+ where
+  q₊ = (x , ℚ.<→0< _ (<ᵣ→<ℚ _ _ x∈P))
+
+IsContinuous^ℤ : ∀ n → IsContinuousWithPred
+         (λ x → _ , isProp<ᵣ _ _)
+         λ x 0<x →  fst ((x , 0<x) ^ℤ n)
+IsContinuous^ℤ (pos n) = IsContinuous₊^ⁿ n
+IsContinuous^ℤ (ℤ.negsuc n) =
+ IsContinuousWP∘ _ _ _ _
+   _ (snd invℝ') (IsContinuous₊^ⁿ (suc n))
+
+
+-- TODO : more direct!! (invℝ₊ is more basic than invℝ)
+
+₊^ⁿ-invℝ₊ : ∀ n x  →
+            ((invℝ₊ x) ₊^ⁿ n) ≡ (invℝ₊ (x ₊^ⁿ n))
+₊^ⁿ-invℝ₊ n x =
+    ℝ₊≡ (cong (_^ⁿ n) (invℝ₊≡invℝ _ (inl (snd x))) ∙∙
+       ^ⁿ-invℝ _ _ _ _
+       ∙∙ sym (invℝ₊≡invℝ _ (inl (snd (x ₊^ⁿ n)))) )
+
+1₊^ⁿ≡1 : ∀ k → 1 ₊^ⁿ k ≡ 1
+1₊^ⁿ≡1 zero = refl
+1₊^ⁿ≡1 (suc k) = ℝ₊≡ (·IdR _) ∙ 1₊^ⁿ≡1 k
+
+1^ℤ≡1 : ∀ k → 1 ^ℤ k ≡ 1
+1^ℤ≡1 (pos n) = 1₊^ⁿ≡1 n
+1^ℤ≡1 (ℤ.negsuc n) =
+     cong invℝ₊ (1₊^ⁿ≡1 (suc n))
+   ∙ invℝ₊1
+
+
+pos+negsuc : ∀ a b → pos a ℤ.+ ℤ.negsuc b ≡ pos (suc a) ℤ.+ ℤ.negsuc (suc b)
+pos+negsuc a b = ℤ.+Comm _ _ ∙∙
+   cong (ℤ.negsuc b ℤ.+_) (ℤ.+Comm _ _)
+     ∙ ℤ.+Assoc (ℤ.negsuc b) (ℤ.negsuc 0) _ ∙∙ ℤ.+Comm _ _
+
+^ℤ-minus : ∀ x a b → ((x ^ℤ (pos a)) ₊·ᵣ (x ^ℤ (ℤ.negsuc b)))
+                   ≡ (x ^ℤ ((pos a) ℤ.+ (ℤ.negsuc b)))
+^ℤ-minus x zero b =
+    ℝ₊≡ (·IdL _)
+  ∙ cong (x ^ℤ_) (ℤ.pos0+ _)
+^ℤ-minus x (suc a) zero =
+  ℝ₊≡ (sym (·ᵣAssoc _ _ _) ∙
+    cong (fst (x ₊^ⁿ a) ·ᵣ_) (
+       cong (fst x ·ᵣ_) (cong (fst ∘ invℝ₊) (ℝ₊≡ (·IdL _)))
+      ∙ x·invℝ₊[x] x)  ∙ ·IdR _ )
+^ℤ-minus x (suc a) (suc b) =
+  let z = ^ℤ-minus x a b
+  in ℝ₊≡ (sym (·ᵣAssoc _ _ _) ∙
+       cong ((x .fst ^ⁿ a) ·ᵣ_)
+         (  ·ᵣComm _ _
+        ∙∙  cong (_·ᵣ x .fst) (cong fst (invℝ₊· (x ₊^ⁿ (suc b)) x))
+            ∙ sym (·ᵣAssoc _ _ _)
+            ∙ cong (invℝ₊ (x ₊^ⁿ suc b) .fst ·ᵣ_)
+                (·ᵣComm _ _ ∙ x·invℝ₊[x] x )
+        ∙∙ ·IdR _))
+       ∙∙ z ∙∙
+     cong (x ^ℤ_) (pos+negsuc a b)
+
+^ℤ-+ : ∀ x a b → ((x ^ℤ a) ₊·ᵣ (x ^ℤ b)) ≡ (x ^ℤ (a ℤ.+ b))
+^ℤ-+ x (pos n) (pos n₁) = ^ℕ-+ x n n₁ ∙ cong (x ^ℤ_) (ℤ.pos+ _ _)
+^ℤ-+ x (pos n) (ℤ.negsuc n₁) = ^ℤ-minus x n n₁
+^ℤ-+ x (ℤ.negsuc n) (pos n₁) =
+  ℝ₊≡ (·ᵣComm _ _)
+  ∙∙ ^ℤ-minus x n₁ n ∙∙
+  cong (x ^ℤ_) (ℤ.+Comm _ _)
+^ℤ-+ x (ℤ.negsuc n) (ℤ.negsuc n₁) =
+      sym (invℝ₊· _ _)
+   ∙∙ cong invℝ₊ (^ℕ-+ x (suc n) (suc n₁))
+   ∙∙ cong (x ^ℤ_) (ℤ.negsuc+ n (suc n₁))
+
+
+^ℕ-· : ∀ x a b → ((x ₊^ⁿ a) ₊^ⁿ b) ≡ (x ₊^ⁿ (a ℕ.· b))
+^ℕ-· x a zero = cong (x ₊^ⁿ_) (ℕ.0≡m·0 a)
+^ℕ-· x a (suc b) = cong (_₊·ᵣ (x ₊^ⁿ a)) (^ℕ-· x a b)
+  ∙ ^ℤ-+ x (pos (a ℕ.· b)) (pos a) ∙
+   cong {y = pos ((a ℕ.· suc b))} (x ^ℤ_)
+    (sym (ℤ.pos+ _ _) ∙ cong pos
+      ((cong (ℕ._+ a) (ℕ.·-comm _ _) ∙ ℕ.+-comm _ _) ∙ ℕ.·-comm (suc b) a))
+
+
+pow-root-+ℕ₊₁ : ∀ (m n : ℕ₊₁) →
+         nth-pow-root-iso (m ·₊₁ n)
+             ≡ compIso (nth-pow-root-iso m) (nth-pow-root-iso n)
+pow-root-+ℕ₊₁ (1+ m) (1+ n) = SetsIso≡fun isSetℝ₊ isSetℝ₊
+  (funExt (λ x → sym (^ℕ-· x (suc m) (suc n))))
+
+
+ₙ√1 : ∀ b → root b 1 ≡ 1
+ₙ√1 b = cong (root b) (sym (1₊^ⁿ≡1 _)) ∙ Iso.leftInv (nth-pow-root-iso b) 1
+
+
+
+ₙ√-StrictMonotone : ∀ {x y : ℝ₊} (b : ℕ₊₁)
+      → fst x <ᵣ fst y → fst (root b x) <ᵣ fst (root b y)
+ₙ√-StrictMonotone x@{_ , 0<x} y@{_ , 0<y} (1+ b) x<y =
+  ^ⁿStrictMonotone⁻¹  (suc b) (ℕ.suc-≤-suc  ℕ.zero-≤)
+    (snd (root (1+ b) (_ , 0<x)))
+    (snd (root (1+ b) (_ , 0<y)))
+    (subst2 _<ᵣ_
+      (cong fst $ sym (Iso.rightInv (nth-pow-root-iso (1+ b)) x))
+      (cong fst $ sym (Iso.rightInv (nth-pow-root-iso (1+ b)) y))
+      x<y)
+
+
+ₙ√-Monotone : ∀ {x y : ℝ₊} (b : ℕ₊₁)
+      → fst x ≤ᵣ fst y → fst (root b x) ≤ᵣ fst (root b y)
+ₙ√-Monotone x@{_ , 0<x} y@{_ , 0<y} (1+ b) x≤y =
+  ^ⁿMonotone⁻¹  (suc b) (ℕ.suc-≤-suc  ℕ.zero-≤)
+    (snd (root (1+ b) (_ , 0<x)))
+    (snd (root (1+ b) (_ , 0<y)))
+    (subst2 _≤ᵣ_
+      (cong fst $ sym (Iso.rightInv (nth-pow-root-iso (1+ b)) x))
+      (cong fst $ sym (Iso.rightInv (nth-pow-root-iso (1+ b)) y))
+      x≤y)
+
+
+
+uContRoot0 : ∀ n → ∀ (ε : ℚ₊) → Σ[ δ ∈ ℚ₊ ]
+     (∀ (u : ℝ₊) → fst u <ᵣ rat (fst δ)
+         → (fst (root n u)) <ᵣ rat (fst ε))
+uContRoot0 (1+ n) ε =
+    (ε ℚ₊^ⁿ (suc n))
+  , λ u u<εⁿ →
+    isTrans<≡ᵣ _ _ _ (ₙ√-StrictMonotone
+          {y = ℚ₊→ℝ₊ (ε ℚ₊^ⁿ (suc n))} (1+ n) u<εⁿ)
+         (cong (fst ∘ root (1+ n)) (
+            ℝ₊≡ (sym (^ⁿ-ℚ^ⁿ _ _)))
+          ∙ cong fst (Iso.leftInv (nth-pow-root-iso (1+ n)) (ℚ₊→ℝ₊ ε)))
+
+
+·DistRoot : ∀ x y b → root b x ₊·ᵣ root b y ≡ root b (x ₊·ᵣ y)
+·DistRoot x y b =
+   sym (Iso.leftInv (nth-pow-root-iso b) _) ∙ cong (root b)
+     (ℝ₊≡ (^ⁿDist·ᵣ _ _ _)
+      ∙ cong₂ _₊·ᵣ_
+       (Iso.rightInv (nth-pow-root-iso b) x)
+       (Iso.rightInv (nth-pow-root-iso b) y))
+
+invCommRoot : ∀ x b → invℝ₊ (root b x) ≡ root b (invℝ₊ x)
+invCommRoot x b =
+  isoFunInjective (nth-pow-root-iso b) _ _
+   (₊^ⁿ-invℝ₊ _ _
+     ∙ cong invℝ₊ (Iso.rightInv (nth-pow-root-iso b) _)
+     ∙ sym (Iso.rightInv (nth-pow-root-iso b) _))
+
+pow-root-comm₊ : ∀ x a b → (root b x) ₊^ⁿ a ≡ root b (x ₊^ⁿ a)
+pow-root-comm₊ x zero b = sym (ₙ√1 b)
+pow-root-comm₊ x (suc a) b =
+    cong (_₊·ᵣ (root b x)) (pow-root-comm₊ x a b)
+  ∙ ·DistRoot _ _ _
+
+
+pow-root-comm : ∀ x a b → (root b x) ^ℤ a ≡ root b (x ^ℤ a)
+pow-root-comm x (pos n) b = pow-root-comm₊ x n b
+pow-root-comm x (ℤ.negsuc n) b =
+   cong invℝ₊ (pow-root-comm₊ x (suc n) b) ∙
+     invCommRoot _ _
+
+
+
+ℝ₊→ℝ₀₊ : ℝ₊ → ℝ₀₊
+ℝ₊→ℝ₀₊ (x , y) = x , <ᵣWeaken≤ᵣ _ _ y
+
+
+
+a/[a+c]<b/[b+c] : ∀ (a b c : ℝ₊) → fst a <ᵣ fst b →
+    fst (a ₊·ᵣ invℝ₊ (a ₊+ᵣ c)) <ᵣ fst (b ₊·ᵣ invℝ₊ (b ₊+ᵣ c))
+a/[a+c]<b/[b+c] a b c a<b =
+  invEq (z/y'<x/y≃y₊·z<y'₊·x _ _ _ _)
+   (subst2 _<ᵣ_
+     (cong (_+ᵣ fst c ·ᵣ fst a) (·ᵣComm _ _) ∙ sym (·DistR+ _ _ _))
+      (sym (·DistR+ _ _ _))
+     (<ᵣ-o+ _ _ _ (<ᵣ-o·ᵣ _ _ c a<b) ))
+
+
+
+_₀₊+ᵣ_ : ℝ₊ → ℝ₀₊ → ℝ₊
+(x , 0<x) ₀₊+ᵣ (y , 0≤y) = x +ᵣ y ,
+ (isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _)) $ <≤ᵣMonotone+ᵣ _ _ _ _ 0<x 0≤y)
+
+
+
+opaque
+ unfolding _<ᵣ_
+ x<δ→x≤0 : ∀ x → ((ε : ℚ₊) → x <ᵣ (rat (fst ε))) → x ≤ᵣ 0
+ x<δ→x≤0 x p = eqℝ _ _
+   λ ε → invEq (∼≃abs<ε _ _ _)
+     (isTrans≡<ᵣ _ _ _
+         (cong absᵣ (+IdR _ ∙ maxᵣComm _ _)
+           ∙ (absᵣNonNeg _ (≤maxᵣ 0 x)) ∙ maxᵣComm _ _) (p' ε))
+   where
+   p' : (ε : ℚ₊) → maxᵣ x 0 <ᵣ (rat (fst ε))
+   p' ε = max<-lem _ _ _  (p ε) (snd (ℚ₊→ℝ₊ ε))
+
+opaque
+ unfolding _<ᵣ_
+ x<y+δ→x≤y : ∀ x y → ((ε : ℚ₊) → x <ᵣ y +ᵣ (rat (fst ε))) → x ≤ᵣ y
+ x<y+δ→x≤y x y p = invEq (x≤y≃0≤y-x _ _)
+  ( isTrans≤≡ᵣ _ _ _
+    (-ᵣ≤ᵣ _ 0 (x<δ→x≤0 _ (a<c+b⇒a-c<b _ _ _ ∘ p)))
+    (-[x-y]≡y-x _ _))
+
+-- lim√→₀ : ∀ n → (ε : ℚ₊) →
+--            ∃[ δ ∈ ℚ₊ ] (∀ x →
+--                fst x <ᵣ rat (fst δ) → fst (root n x) <ᵣ rat (fst ε))
+-- lim√→₀ = {!!}
+
+
+module slope-incr-root (n : ℕ) where
+
+
+ help-fn : (a c : ℝ₊) → ℝ
+ help-fn a c =
+   fst (root (1+ (suc n)) (a ₊+ᵣ c)) -ᵣ fst (root (1+ (suc n)) a)
+
+ help-fn-decr : ∀ c a b → fst a <ᵣ fst b
+                 →  help-fn b c <ᵣ help-fn a c
+ help-fn-decr c a b a<b =
+      subst2 _<ᵣ_
+        (cong (fst c ·ᵣ_) (invℝ₊≡invℝ _ _) ∙ sym (H.h b))
+         (cong (fst c ·ᵣ_) (invℝ₊≡invℝ _ _) ∙ sym (H.h a))
+        (invEq (z/y'<x/y≃y₊·z<y'₊·x (fst c) (fst c)
+           (H.fac.S₊ a) (H.fac.S₊ b ))
+          (<ᵣ-·ᵣo _ _ c (Seq<→Σ<
+            (geometricProgression _ (H.fac.r a))
+            (geometricProgression _ (H.fac.r b))
+            (suc n) (λ m m≤n →
+              subst2 _<ᵣ_
+                (sym (geometricProgressionClosed _ _ _))
+                (sym (geometricProgressionClosed _ _ _))
+                (<≤ᵣ₊Monotone·ᵣ
+                  (ℝ₊→ℝ₀₊ ((root (2+ n) (a ₊+ᵣ c) ₊^ⁿ n)
+                    ₊·ᵣ root (2+ n) (a ₊+ᵣ c) ))
+                  _ ((H.fac.r a , H.fac.0<r a) ₊^ⁿ m) _
+
+                     (^ⁿ-StrictMonotone (suc n)
+                      (ℕ.suc-≤-suc ℕ.zero-≤)
+                      ((<ᵣWeaken≤ᵣ _ _
+                      $ snd (root (1+ (suc n)) (a ₊+ᵣ c))))
+                       ((<ᵣWeaken≤ᵣ _ _
+                      $ snd (root (1+ (suc n)) (b ₊+ᵣ c))))
+                       (ₙ√-StrictMonotone _
+                         (<ᵣ-+o _ _ (fst c) a<b)))
+                     (^ⁿ-Monotone m
+                      (<ᵣWeaken≤ᵣ _ _ (H.fac.0<r a))
+                       (subst2 _≤ᵣ_
+                         (sym (cong fst (·DistRoot _ _ _))
+                            ∙ (cong (fst (root (1+ (suc n)) a) ·ᵣ_)
+                              (cong fst (sym (invCommRoot _ _))
+                               ∙ invℝ₊≡invℝ _ _ )))
+                         (sym (cong fst (·DistRoot _ _ _))
+                            ∙ (cong (fst (root (1+ (suc n)) b) ·ᵣ_)
+                              (cong fst (sym (invCommRoot _ _))
+                               ∙ invℝ₊≡invℝ _ _ )))
+                         (ₙ√-Monotone _
+                           (<ᵣWeaken≤ᵣ _ _
+                             (a/[a+c]<b/[b+c] _ _ _ a<b))))))))))
+
+  where
+  open bⁿ-aⁿ n hiding (n)
+
+  module H (a : ℝ₊) where
+   module fac = factor
+     (fst (root (1+ (suc n)) a)) (fst (root (1+ (suc n)) (a ₊+ᵣ c)))
+     (snd (root (1+ (suc n)) a)) (snd (root (1+ (suc n)) (a ₊+ᵣ c)))
+
+   h : fst (root (2+ n) (a ₊+ᵣ c)) -ᵣ fst (root (2+ n) a) ≡ (c .fst ／ᵣ[
+                Sₙ (fst (root (2+ n) (a ₊+ᵣ c)) ^ⁿ suc n)
+                (r (fst (root (2+ n) a)) (fst (root (2+ n) (a ₊+ᵣ c)))
+                 (snd (root (2+ n) a)) (snd (root (2+ n) (a ₊+ᵣ c))))
+                (bⁿ-aⁿ.n n)
+                , _ ])
+   h = x·y≡z→x≡z/y _ _ _ (inl fac.0<S) ((fac.[b-a]·S≡bⁿ-aⁿ
+
+         ∙ cong₂ _-ᵣ_
+         (cong fst
+          (Iso.rightInv (nth-pow-root-iso (1+ (suc n))) (a ₊+ᵣ c)))
+         (cong fst
+          (Iso.rightInv (nth-pow-root-iso (1+ (suc n))) a))
+           ∙ L𝐑.lem--063))
+
+
+opaque
+ unfolding -ᵣ_
+ -ᵣWeaken<ᵣ : ∀ a b c → 0 ≤ᵣ b → a <ᵣ c  → a -ᵣ b <ᵣ c
+ -ᵣWeaken<ᵣ a b c 0≤b a<c =
+   isTrans<≡ᵣ _ _ _
+     (<≤ᵣMonotone+ᵣ _ _ _ _ a<c (-ᵣ≤ᵣ _ _ 0≤b))
+     (+IdR _)
+
+opaque
+ unfolding _+ᵣ_
+ nth-root-slope-incr : ∀ n (x : ℚ₊) (Δ : ℚ₊)
+    → fst (root (1+ n) ((ℚ₊→ℝ₊ x) ₊+ᵣ (ℚ₊→ℝ₊ Δ)))
+       -ᵣ fst (root (1+ n) (ℚ₊→ℝ₊ x))
+       ≤ᵣ fst (root (1+ n) (ℚ₊→ℝ₊ Δ))
+ nth-root-slope-incr zero x Δ  = ≡ᵣWeaken≤ᵣ _ _ (-ᵣ-rat₂ _ _ ∙ cong rat lem--063)
+ nth-root-slope-incr (suc n) x Δ =
+    x<y+δ→x≤y _ _ h
+
+  where
+
+   h : ∀ (ε : ℚ₊) →
+             fst (root (1+ (suc n)) ((ℚ₊→ℝ₊ x) ₊+ᵣ (ℚ₊→ℝ₊ Δ)))
+       -ᵣ fst (root (1+ (suc n)) (ℚ₊→ℝ₊ x))
+          <ᵣ (fst (NthRoot.nth-root n (ℚ₊→ℝ₊ Δ))) +ᵣ rat (fst ε)
+
+   h ε = PT.rec
+     (isProp<ᵣ _ _)
+     (λ (δ , X)
+        --(δ' , X')
+       → let δ⊓x = (ℚ.min₊
+                     x δ)
+             ineq1 = (slope-incr-root.help-fn-decr
+                 n (ℚ₊→ℝ₊ Δ) (ℚ₊→ℝ₊ (/2₊ δ⊓x)) _
+                       (isTrans<≤ᵣ _ _ _
+                         (<ℚ→<ᵣ _ _ (x/2<x δ⊓x))
+                         (min≤ᵣ _ (rat (fst δ)))))
+
+             ineq2 :
+                fst (root (1+ (suc n)) ((ℚ₊→ℝ₊ (/2₊ δ⊓x)) ₊+ᵣ (ℚ₊→ℝ₊ Δ)))
+                 -ᵣ fst (root (1+ (suc n)) (ℚ₊→ℝ₊ (/2₊ δ⊓x)))
+                    <ᵣ
+                 fst (root (1+ (suc n)) (ℚ₊→ℝ₊ Δ)) +ᵣ (rat (fst ε))
+             ineq2 =
+                -- isTrans<ᵣ _ _ _
+                  -ᵣWeaken<ᵣ _ _ _
+                     (<ᵣWeaken≤ᵣ _ _
+                      (snd (root (1+ (suc n)) (ℚ₊→ℝ₊ (/2₊ δ⊓x)))))
+                     (isTrans<≡ᵣ _ _ _
+                       (a-b<c⇒a<c+b _ _ _
+                         (isTrans≤<ᵣ _ _ _
+                          (≤absᵣ _)
+                          (fst (∼≃abs<ε _ _ _)
+                            (sym∼ _ _ _
+                              (X _ _
+                                (subst (_∼[ δ ]
+                                   (ℚ₊→ℝ₊ (/2₊ δ⊓x) .fst +ᵣ rat (fst Δ)))
+                                 (+IdL _)
+                                 (+ᵣ-∼ 0 (ℚ₊→ℝ₊ (/2₊ δ⊓x) .fst)
+                                 (rat (fst Δ)) δ
+                                    (invEq (∼≃abs<ε _ _ _)
+                                      (isTrans≡<ᵣ _ _ _
+                                        (minusComm-absᵣ _ _ ∙
+                                         cong (absᵣ ∘ (ℚ₊→ℝ₊ (/2₊ δ⊓x) .fst +ᵣ_))
+                                           (-ᵣ-rat 0) ∙ cong absᵣ (+IdR _)
+                                         ∙ absᵣPos _ ((ℚ₊→ℝ₊ (/2₊ δ⊓x) .snd)))
+                                        ((isTrans<≤ᵣ _ _ _
+                         (<ℚ→<ᵣ _ _ (x/2<x δ⊓x))
+                         (min≤ᵣ' (rat (fst x)) _)))))))))) ))
+                       (+ᵣComm _ _))
+
+         in isTrans<ᵣ _ _ _
+              ineq1
+                 ineq2
+       )
+      (IsContinuousRoot (2+ n) (rat (fst Δ))
+        ε (snd (ℚ₊→ℝ₊ Δ)))
+
+
+
+
+ uContRootℚ : ∀ n → IsUContinuousℚℙ (λ x → (0 <ᵣ x) , isProp<ᵣ _ _ )
+                    (curry (fst ∘ root n) ∘ rat)
+ uContRootℚ (1+ n) ε =
+   (ε ℚ₊^ⁿ (suc n)) ,
+     ℚ.elimBy≡⊎<'
+      (λ x y X u∈ v∈ →
+        sym∼ _ _ _ ∘ X v∈ u∈ ∘ (subst (ℚ._< fst (ε ℚ₊^ⁿ suc n))
+           (ℚ.absComm- _ _)))
+      (λ x u∈ v∈ _ → subst (_ ∼[ _ ]_)
+         (cong (fst ∘ (root (1+ n))) (ℝ₊≡ refl)) (refl∼ _ _))
+      λ x Δ u∈ v∈ X →
+        sym∼ _ _ _ (invEq (∼≃abs<ε _ _ _)
+         (isTrans≡<ᵣ _ _ _ (absᵣPos _
+           (fst (x<y≃0<y-x _ _)
+             (ₙ√-StrictMonotone (1+ n)
+               (isTrans≡<ᵣ _ _ _
+                 (sym (+IdR _)) (<ᵣ-o+ _ _ (rat x) (snd (ℚ₊→ℝ₊ Δ)))))))
+          let X' = isTrans<≡ᵣ _ _ _
+               (ₙ√-StrictMonotone {ℚ₊→ℝ₊ Δ} {ℚ₊→ℝ₊ (ε ℚ₊^ⁿ suc n)} (1+ n)
+               ((<ℚ→<ᵣ _ _ (subst (ℚ._< fst (ε ℚ₊^ⁿ suc n))
+                   (ℚ.absComm- _ _ ∙ cong ℚ.abs
+                     lem--063 ∙ (ℚ.absPos _ (ℚ.0<ℚ₊ Δ))) X))))
+                     (cong (fst ∘ (root (1+ n)))
+                        (ℝ₊≡
+                          (sym (^ⁿ-ℚ^ⁿ _ _)))
+                       ∙ cong fst (Iso.leftInv (nth-pow-root-iso (1+ n))
+                         (ℚ₊→ℝ₊ ε)))
+          in isTrans≤<ᵣ _ _ _
+              (isTrans≡≤ᵣ _ _ _
+                 (cong₂ (λ v∈ u∈ →
+                    fst (root (1+ n) (rat (x ℚ.+ Δ .fst) , v∈)) -ᵣ
+                     fst (root (1+ n) (rat x , u∈)))
+                      (isProp<ᵣ _ _ _ _) (isProp<ᵣ _ _ _ _))
+                  (nth-root-slope-incr _
+                    (x , (ℚ.<→0< _ (<ᵣ→<ℚ _ _ u∈))) _) )
+              X'))
+
+uContRoot : ∀ n → IsUContinuousℙ (λ x → (0 <ᵣ x) , isProp<ᵣ _ _ )
+                   (curry (fst ∘ root n))
+uContRoot n = IsUContinuousℚℙ→IsUContinuousℙ _
+  (λ _ _ _ _ → ₙ√-Monotone n)
+  (uContRootℚ n)
+
+
+^ℤ-· : ∀ x a b → ((x ^ℤ a) ^ℤ b) ≡  (x ^ℤ (a ℤ.· b))
+^ℤ-· x (pos n) (pos n₁) = ^ℕ-· x n n₁ ∙ cong (x ^ℤ_) (ℤ.pos·pos _ _)
+^ℤ-· x (pos zero) (ℤ.negsuc n₁) = 1^ℤ≡1 _
+^ℤ-· x (pos (suc n)) (ℤ.negsuc n₁) =
+     cong invℝ₊ (^ℕ-· x (suc n) (suc n₁))
+   ∙ cong (x ^ℤ_) (cong ℤ.-_ (ℤ.pos·pos _ _ ) ∙ sym (ℤ.pos·negsuc _ _))
+^ℤ-· x (ℤ.negsuc n) (pos zero) =
+  cong {x = 0} (x ^ℤ_) (sym (ℤ.·AnnihilR _))
+^ℤ-· x (ℤ.negsuc n) (pos (suc n₁)) =
+      ₊^ⁿ-invℝ₊ _ _
+   ∙∙ cong invℝ₊ (^ℕ-· x (suc n) (suc n₁))
+   ∙∙ cong (x ^ℤ_)
+     ( cong ℤ.-_ ((ℤ.pos·pos (suc n) (suc n₁) )) ∙ sym (ℤ.negsuc·pos n (suc n₁)) )
+
+^ℤ-· x (ℤ.negsuc n) (ℤ.negsuc n₁) =
+        (sym (₊^ⁿ-invℝ₊ _ _)
+       ∙ cong (_₊^ⁿ (suc n₁)) (invℝ₊Invol _))
+   ∙∙ ^ℕ-· x (suc n) (suc n₁)
+   ∙∙ cong (x ^ℤ_) (ℤ.pos·pos _ _ ∙ (sym $ ℤ.negsuc·negsuc n n₁))
+
+
+
+pre^ℚ-aprox : ∀ a b → ℚApproxℙ'' (λ x → (0 <ᵣ x) , isProp<ᵣ _ _)
+                                 (λ x → (0 <ᵣ x) , isProp<ᵣ _ _)
+                    λ x 0<x → (root b ((x , 0<x) ^ℤ a))
+pre^ℚ-aprox a b =
+  ℚApproxℙ∘ (λ x → (0 <ᵣ x) , isProp<ᵣ _ _)
+            (λ x → (0 <ᵣ x) , isProp<ᵣ _ _)
+            (λ x → (0 <ᵣ x) , isProp<ᵣ _ _)
+     (curry (root b))
+      (curry ((_^ℤ a)))
+       (uContRoot _)
+      (ℚApproxℙ'→ℚApproxℙ'' _ _ (curry (root b)) (ℚApproxℙ-root b))
+      (^ℤ-ℚApproxℙ'' a)
+
+module _ (x : ℝ) (0<x : 0 <ᵣ x) where
+ ^ℚ-coh' : ∀ a a' b b' → pos a ℤ.· pos (suc b') ≡ pos a' ℤ.· pos (suc b) →
+   (root (1+ b) (x , 0<x)  ^ℤ (pos a)) ≡ (root (1+ b') (x , 0<x) ^ℤ (pos a'))
+ ^ℚ-coh' n n' b b' p  =
+     let z = cong₂ (_^ℤ_)
+               (sym ((cong Iso.inv (pow-root-+ℕ₊₁ (1+ b') (1+ b))) ≡$ (x , 0<x))
+               ∙∙ cong (flip root (x , 0<x) )
+                 (·₊₁-comm _ _ )
+               ∙∙ (((cong Iso.inv (pow-root-+ℕ₊₁ (1+ b) (1+ b'))) ≡$ (x , 0<x))))
+                (ℤ.·Comm _ _ ∙∙ p ∙∙ ℤ.·Comm _ _)
+    in (sym (cong (_₊^ⁿ n)
+            (Iso.rightInv (nth-pow-root-iso (1+ b')) (root (1+ b) (x , 0<x))))
+        ∙ (^ℤ-· _ (pos (suc b')) (pos n)) )
+      ∙∙ z ∙∙
+       ( sym (^ℤ-· _ (pos (suc b)) (pos n'))
+         ∙ cong (_₊^ⁿ n')
+            (Iso.rightInv (nth-pow-root-iso (1+ b)) (root (1+ b') (x , 0<x))))
+
+ ^ℚ-coh : ∀ a a' b b' → a ℤ.· pos (suc b') ≡ a' ℤ.· pos (suc b) →
+   (root (1+ b) (x , 0<x)  ^ℤ a) ≡ (root (1+ b') (x , 0<x) ^ℤ a')
+ ^ℚ-coh (pos n) (pos n₁) b b' p = ^ℚ-coh' n n₁ b b' p
+
+ ^ℚ-coh (pos n) (ℤ.negsuc n₁) b b' p =
+   ⊥.rec (ℤ.posNotnegsuc _ _
+    (ℤ.pos·pos _ _ ∙∙ p ∙∙ (ℤ.negsuc·pos n₁ (suc b) ∙
+      cong (ℤ.-_) (sym (ℤ.pos·pos _ _)) )))
+ ^ℚ-coh (ℤ.negsuc n) (pos n₁) b b' p =
+   ⊥.rec (ℤ.negsucNotpos _ _
+    ((cong (ℤ.-_) (ℤ.pos·pos _ _) ∙
+       sym (ℤ.negsuc·pos n (suc b'))) ∙∙ p ∙∙ ((sym (ℤ.pos·pos _ _)) )))
+ ^ℚ-coh (ℤ.negsuc n) (ℤ.negsuc n₁) b b' p =
+   cong invℝ₊ (^ℚ-coh' (suc n) (suc n₁) b b' (
+     sym (ℤ.-DistL· (ℤ.negsuc n) (pos (suc b')))
+      ∙∙ cong ℤ.-_ p ∙∙
+      ℤ.-DistL· (ℤ.negsuc n₁) (pos (suc b))))
+
+ _^ℚc_ : ℚ → ℝ₊
+ _^ℚc_ = SQ.Elim.go w
+  where
+  w : Elim (λ _ → ℝ₊)
+  w .Elim.isSetB _ = isSetℝ₊
+  w .Elim.f (a , b) = (root b (x , 0<x)) ^ℤ a
+  w .Elim.f∼ (a , (1+ b)) (a' , (1+ b')) r =
+    ^ℚ-coh a a' b b' r
+
+_^ℚ_ : ℝ₊ → ℚ →  ℝ₊
+_^ℚ_ = uncurry _^ℚc_
+
+IsContinuous^ℚ : ∀ q → IsContinuousWithPred (λ _ → _ , isProp<ᵣ _ _)
+                          (curry (fst ∘ (_^ℚ q)))
+IsContinuous^ℚ = SQ.ElimProp.go w
+  where
+  P = _
+  w : ElimProp _
+  w .ElimProp.isPropB _ = isPropΠ3 λ _ _ _ → squash₁
+  w .ElimProp.f (a , b) =
+    IsContinuousWP∘ P P (curry (fst ∘ _^ℤ a)) (curry (fst ∘ root b))
+      (curry (snd ∘ root b))
+      (IsContinuous^ℤ a)
+      (IsContinuousRoot b)
+
+^ℚ-+ : ∀ x a b → ((x ^ℚ a) ₊·ᵣ (x ^ℚ b)) ≡ (x ^ℚ (a ℚ.+ b))
+^ℚ-+ x₊@(x , 0<x) = SQ.ElimProp2.go w
+ where
+ w : ElimProp2 (λ z z₁ → ((x₊ ^ℚ z) ₊·ᵣ (x₊ ^ℚ z₁)) ≡ (x₊ ^ℚ (z ℚ.+ z₁)))
+ w .ElimProp2.isPropB _ _ = isSetℝ₊ _ _
+ w .ElimProp2.f (a , 1+ b) (a' , 1+ b') =
+  ((root (1+ b) (x , 0<x) ^ℤ a) ₊·ᵣ (root (1+ b') (x , 0<x) ^ℤ a'))
+   ≡⟨ cong₂ _₊·ᵣ_
+        (cong (_^ℤ a) b√x≡ ∙ ^ℤ-· bb'√x _ _)
+        (cong (_^ℤ a') b'√x≡ ∙ ^ℤ-· bb'√x _ _) ⟩
+            ((bb'√x ^ℤ (ℚ.ℕ₊₁→ℤ (1+ b') ℤ.· a))
+         ₊·ᵣ (bb'√x ^ℤ (ℚ.ℕ₊₁→ℤ (1+ b) ℤ.· a')))
+   ≡⟨ (λ i → ^ℤ-+ bb'√x
+       (ℤ.·Comm (pos (suc b')) a i)
+       (ℤ.·Comm (pos (suc b)) a' i)
+       i) ⟩
+   ((bb'√x ^ℤ
+      (a ℤ.· ℚ.ℕ₊₁→ℤ (1+ b') ℤ.+ a' ℤ.· ℚ.ℕ₊₁→ℤ (1+ b)))) ∎
+
+  where
+   bb'√x = root ((1+ b) ·₊₁ (1+ b')) (x , 0<x)
+
+   b√x≡ = sym (Iso.rightInv (nth-pow-root-iso (1+ b')) _) ∙
+      (cong (_₊^ⁿ (suc b')) $ sym (cong Iso.inv (pow-root-+ℕ₊₁ (1+ b') (1+ b)) ≡$ x₊)
+        ∙ cong (flip root x₊) (·₊₁-comm _ _))
+
+   b'√x≡ = sym (Iso.rightInv (nth-pow-root-iso (1+ b)) _) ∙
+      (cong (_₊^ⁿ (suc b)) $ sym (cong Iso.inv (pow-root-+ℕ₊₁ (1+ b) (1+ b')) ≡$ x₊))
+
+
+^ℚ-· : ∀ x a b → ((x ^ℚ a) ^ℚ b) ≡ (x ^ℚ (a ℚ.· b))
+^ℚ-· x₊@(x , 0<x) = SQ.ElimProp2.go w
+ where
+ w : ElimProp2 _
+ w .ElimProp2.isPropB _ _ = isSetℝ₊ _ _
+ w .ElimProp2.f (a , 1+ b) (a' , 1+ b') =
+     cong (_^ℤ a')
+       (sym (pow-root-comm _ _ _) ∙ cong (_^ℤ a) (
+             sym (cong Iso.inv (pow-root-+ℕ₊₁ (1+ b') (1+ b)) ≡$ x₊)
+          ∙ cong (flip root x₊) (·₊₁-comm _ _)))
+       ∙ ^ℤ-· _ _ _
+
+
+
+-- ^ⁿ-invℝ₊ : ∀ n x →
+--             ((invℝ₊ x) ₊^ⁿ n) ≡ invℝ₊ (x ₊^ⁿ n)
+-- ^ⁿ-invℝ₊ n = {!!}
+-- uncurry
+--   λ x 0<x →
+--      ℝ₊≡ (≡ContinuousWithPred _ _ (openPred< 0) (openPred< 0)
+--         _ _
+--          (IsContinuousWP∘
+--            (λ y → (0 <ᵣ y) , squash₁)
+--            (λ y → (0 <ᵣ y) , squash₁)
+--            _ _
+--            (λ x 0<x → invℝ'-pos x 0<x) (IsContinuous₊^ⁿ n) (snd invℝ'))
+
+--     (IsContinuousWP∘
+--            (λ y → (0 <ᵣ y) , squash₁)
+--            (λ y → (0 <ᵣ y) , squash₁)
+--            _ _
+--            (λ x 0<x → snd ((x , 0<x) ₊^ⁿ n)) (snd invℝ') (IsContinuous₊^ⁿ n) )
+--     (λ r r<0 _ → {!!}) x 0<x 0<x)
+
+
+invℝ₊^ℤ : ∀ x a → (invℝ₊ x) ^ℤ (ℤ.- a) ≡ x ^ℤ a
+invℝ₊^ℤ x (pos zero) = refl
+invℝ₊^ℤ x (pos (suc n)) = cong invℝ₊ (₊^ⁿ-invℝ₊ (suc n) x)
+ ∙ invℝ₊Invol _
+invℝ₊^ℤ x (ℤ.negsuc n) = ₊^ⁿ-invℝ₊ _ _
+
+invℝ₊[^ℤ] : ∀ x a → (invℝ₊ x ^ℤ a) ≡ invℝ₊ (x ^ℤ a)
+invℝ₊[^ℤ] x (pos zero) = ℝ₊≡ (sym (invℝ₊-rat 1))
+invℝ₊[^ℤ] x (pos (suc n)) = ₊^ⁿ-invℝ₊ _ _
+invℝ₊[^ℤ] x (ℤ.negsuc n) = cong invℝ₊ (₊^ⁿ-invℝ₊ _ _)
+
+invℝ₊^ℤ' : ∀ x a → (invℝ₊ x) ^ℤ a ≡ x ^ℤ (ℤ.- a)
+invℝ₊^ℤ' x a = cong ((invℝ₊ x) ^ℤ_) (sym (ℤ.-Involutive a)) ∙ invℝ₊^ℤ x (ℤ.- a)
+
+
+
+invℝ₊^ℚ : ∀ x a → (invℝ₊ x ^ℚ a) ≡ invℝ₊ (x ^ℚ a)
+invℝ₊^ℚ x = SQ.ElimProp.go w
+
+ where
+ w : ElimProp _
+ w .ElimProp.isPropB _ = isSetℝ₊ _ _
+ w .ElimProp.f (a , b) = cong (_^ℤ a) (sym (invCommRoot x b))
+   ∙ invℝ₊[^ℤ] (root b x) a
+
+^ℚ-minus : ∀ x a → (x ^ℚ a) ≡ ((invℝ₊ x) ^ℚ (ℚ.- a))
+^ℚ-minus x = SQ.ElimProp.go w
+
+ where
+ w : ElimProp _
+ w .ElimProp.isPropB _ = isSetℝ₊ _ _
+ w .ElimProp.f (a , (1+ b)) =
+  cong (λ b → (x ^ℚ [ a , b ]))
+   (sym (·₊₁-identityˡ _))
+  ∙
+  (sym (invℝ₊^ℤ _ _))
+   ∙ cong (_^ℤ _) (invCommRoot _ _)
+
+^ℚ-minus' : ∀ x a → (x ^ℚ (ℚ.- a)) ≡ ((invℝ₊ x) ^ℚ a)
+^ℚ-minus' x a = ^ℚ-minus x (ℚ.- a) ∙ cong ((invℝ₊ x) ^ℚ_) (ℚ.-Invol a)
+
+
+
+1^ℚ≡1 : ∀ q → 1 ^ℚ q ≡ 1
+1^ℚ≡1 = ElimProp.go w
+ where
+ w : ElimProp _
+ w .ElimProp.isPropB _ = isSetℝ₊ _ _
+ w .ElimProp.f (a , b) = cong (_^ℤ a) (ₙ√1 b) ∙ 1^ℤ≡1 _
+
+Iso^ₙₒₜ₀ : ∀ q → 0 ℚ.# q  → Iso ℝ₊ ℝ₊
+Iso^ₙₒₜ₀ q _ .Iso.fun = _^ℚ q
+Iso^ₙₒₜ₀ q 0#q .Iso.inv = _^ℚ (invℚ q 0#q)
+Iso^ₙₒₜ₀ q 0#q .Iso.rightInv x =
+ ^ℚ-· x _ _ ∙∙ cong (x ^ℚ_) (ℚ.·Comm _ _ ∙ ℚ.ℚ-y/y q 0#q)
+  ∙∙ ℝ₊≡ (·IdL (fst x))
+Iso^ₙₒₜ₀ q 0#q .Iso.leftInv x =
+ ^ℚ-· x _ _  ∙∙ cong (x ^ℚ_) (ℚ.ℚ-y/y q 0#q) ∙∙ ℝ₊≡ (·IdL (fst x))
+
+
+-- pow-root-+ : ∀ (m n : ℚ₊) →
+--          Iso^₊ (m ℚ₊· n)
+--              ≡ compIso (Iso^₊ m) (Iso^₊ n)
+-- pow-root-+ m n = SetsIso≡fun isSetℝ₊ isSetℝ₊
+--   (funExt (λ x → {!Iso^₊!}))
+
+
+factor-xᵃ-xᵇ : ∀ x a b → fst (x ^ℚ a) -ᵣ fst (x ^ℚ b) ≡
+                        fst (x ^ℚ b) ·ᵣ (fst (x ^ℚ (a ℚ.- b)) -ᵣ 1)
+factor-xᵃ-xᵇ x a b =
+    cong₂ _-ᵣ_
+      (cong (fst ∘ x ^ℚ_) (sym lem--05)
+       ∙ cong fst (sym (^ℚ-+ _ _ _)))
+      (sym (·IdR _))
+  ∙ sym (·DistL- _ _ _)
+
+factor-xᵃ-xᵇ' : ∀ x a b → fst (x ^ℚ a) -ᵣ fst (x ^ℚ b) ≡
+                        fst (x ^ℚ a) ·ᵣ (1 -ᵣ fst (x ^ℚ (b ℚ.- a)))
+factor-xᵃ-xᵇ' x a b =
+ cong₂ _-ᵣ_ (sym (·IdR _))
+            (cong fst (cong (x ^ℚ_) (sym lem--05))
+              ∙ cong fst (sym (^ℚ-+ _ _ _)) )
+   ∙ sym (·DistL- _ _ _)
+
+factorOut-xᵃ : ∀ x a b → x ^ℚ a ≡
+     ((x ^ℚ b) ₊·ᵣ (x ^ℚ (a ℚ.- b)))
+factorOut-xᵃ x a b =
+  cong (x ^ℚ_) (sym lem--05)
+  ∙ sym (^ℚ-+ x b (a ℚ.- b))
+
+^ℚ-StrictMonotone : ∀ {x y : ℝ₊} (q : ℚ₊)
+    → fst x <ᵣ fst y
+    → fst (x ^ℚ (fst q)) <ᵣ fst (y ^ℚ (fst q))
+^ℚ-StrictMonotone {_ , 0<x} {_ , 0<y} = uncurry $ ElimProp.go w
+ where
+ w : ElimProp _
+ w .ElimProp.isPropB _ = isPropΠ2 λ _ _ → isProp<ᵣ _ _
+ w .ElimProp.f (pos (suc n) , b) 0<q x<y =
+   ^ⁿ-StrictMonotone _ (ℕ.suc-≤-suc  ℕ.zero-≤)
+      (<ᵣWeaken≤ᵣ _ _ (snd (root b (_ , 0<x))))
+      (<ᵣWeaken≤ᵣ _ _ (snd (root b (_ , 0<y))))
+     (ₙ√-StrictMonotone b x<y)
+
+^ℚ-Monotone : ∀ {x y : ℝ₊} (q : ℚ₊)
+    → fst x ≤ᵣ fst y
+    → fst (x ^ℚ (fst q)) ≤ᵣ fst (y ^ℚ (fst q))
+^ℚ-Monotone {_ , 0<x} {_ , 0<y} = uncurry $ ElimProp.go w
+ where
+ w : ElimProp _
+ w .ElimProp.isPropB _ = isPropΠ2 λ _ _ → isProp≤ᵣ _ _
+ w .ElimProp.f (pos (suc n) , b) 0<q x≤y =
+   ^ⁿ-Monotone _ -- (ℕ.suc-≤-suc  ℕ.zero-≤)
+      (<ᵣWeaken≤ᵣ _ _ (snd (root b (_ , 0<x))))
+     (ₙ√-Monotone b x≤y)
+
+
+1<^ℚ : ∀ x → (q : ℚ₊) → (1 <ᵣ fst x) → (1 <ᵣ fst (x ^ℚ (fst q)))
+1<^ℚ x q₊@(q , 0<q) 1<x =
+  subst (_<ᵣ fst (x ^ℚ q))
+    (cong fst (1^ℚ≡1 q)) (^ℚ-StrictMonotone q₊ 1<x)
+
+
+1≤^ℚ : ∀ x → (q : ℚ₊) → (1 ≤ᵣ fst x) → (1 ≤ᵣ fst (x ^ℚ (fst q)))
+1≤^ℚ x q₊@(q , 0<q) 1≤x =
+  subst (_≤ᵣ fst (x ^ℚ q))
+    (cong fst (1^ℚ≡1 q)) (^ℚ-Monotone q₊ 1≤x)
+
+
+^ℚ-StrictMonotoneR : ∀ {x : ℝ₊} → 1 <ᵣ fst x → (q r : ℚ)
+    → q ℚ.< r
+    → fst (x ^ℚ q) <ᵣ fst (x ^ℚ r)
+^ℚ-StrictMonotoneR {x} 1<x q r q<r =
+  isTrans<≡ᵣ _ _ _
+    (isTrans≡<ᵣ _ _ _
+      (sym (·IdR _ )) (<ᵣ-o·ᵣ _ _ (x ^ℚ q) (1<^ℚ _ (ℚ.<→ℚ₊ _ _ q<r) 1<x)))
+   (cong fst $ sym (factorOut-xᵃ x  r q))
+
+^ℚ-StrictMonotoneR' : ∀ {x : ℝ₊} → fst x <ᵣ 1  → (q r : ℚ)
+    → q ℚ.< r
+    → fst (x ^ℚ r) <ᵣ fst (x ^ℚ q)
+^ℚ-StrictMonotoneR' {x} x<1 q r q<r =
+   fst (invℝ₊-<-invℝ₊ (x ^ℚ q) (x ^ℚ r))
+     (subst2 _<ᵣ_
+       (cong fst (invℝ₊^ℚ x q))
+       (cong fst (invℝ₊^ℚ x r))
+       (^ℚ-StrictMonotoneR {invℝ₊ x}
+         1/x<1 q r q<r))
+   where
+   1/x<1 = isTrans≡<ᵣ _ _ _ (cong fst (sym (invℝ₊1)))
+            (invEq (invℝ₊-<-invℝ₊ 1 x) x<1)
+
+⊆IsContinuousWithPred : ∀ P P' → (P'⊆P : P' ⊆ P) → ∀ f
+        → IsContinuousWithPred P f
+        → IsContinuousWithPred P' (λ x x∈ → f x (P'⊆P x x∈))
+⊆IsContinuousWithPred _ _ P'⊆P f cp u ε u∈P =
+  PT.map (map-snd (λ x _ → x _ ∘ (P'⊆P _)))
+    (cp u ε (P'⊆P _ u∈P))
+
+
+^ℚ-MonotoneR : ∀ {x : ℝ₊} → (q r : ℚ) → q ℚ.≤ r
+    → 1 ≤ᵣ fst x
+    → fst (x ^ℚ q) ≤ᵣ fst (x ^ℚ r)
+^ℚ-MonotoneR {x} q r q≤r 1≤x =
+
+  let z = ≤ContPos'pred {1}
+             (⊆IsContinuousWithPred _ _
+                (λ x → isTrans<≤ᵣ 0 1 x ((decℚ<ᵣ? {0} {1})))
+                 (λ x x< → fst ((x , x<) ^ℚ q))
+                (IsContinuous^ℚ q))
+             (⊆IsContinuousWithPred _ _
+                (λ x → isTrans<≤ᵣ 0 1 x ((decℚ<ᵣ? {0} {1})))
+                 (λ x x< → fst ((x , x<) ^ℚ r))
+                (IsContinuous^ℚ r))
+                (λ u 1≤u → hh (ℚ.≤→<⊎≡ q r q≤r) u 1≤u (ℚ.≤→<⊎≡ 1 u 1≤u))
+             (fst x) 1≤x
+  in subst (λ 0<x → fst ((fst x , 0<x) ^ℚ q) ≤ᵣ fst ((fst x , 0<x) ^ℚ r))
+       (isProp<ᵣ _ _ _ _)
+       z
+
+
+ where
+ hh : ((q ≡ r) ⊎ (q ℚ.< r)) → (u : ℚ) (x₀<u : 1 ℚ.≤ u) → (1 ≡ u) ⊎ (1 ℚ.< u) →
+        fst
+        ((rat u , isTrans<≤ᵣ 0 1 (rat u) decℚ<ᵣ? (≤ℚ→≤ᵣ 1 u x₀<u)) ^ℚ q)
+        ≤ᵣ
+        fst
+        ((rat u , isTrans<≤ᵣ 0 1 (rat u) decℚ<ᵣ? (≤ℚ→≤ᵣ 1 u x₀<u)) ^ℚ r)
+ hh _ u x₀<u (inl x) =
+   ≡ᵣWeaken≤ᵣ _ _
+      (sym ((cong (fst ∘ _^ℚ q) (ℝ₊≡ (cong rat x))))
+        ∙∙ cong fst (1^ℚ≡1 q) ∙
+           cong fst (sym (1^ℚ≡1 r))
+           ∙∙ cong fst (cong (_^ℚ r) (ℝ₊≡ (cong rat x))))
+ hh (inr q<r) u 1≤u (inr 1<u) = subst
+       (λ uu →
+         fst ((rat u , uu) ^ℚ q)
+           ≤ᵣ fst ((rat u , uu) ^ℚ r))
+            (isProp<ᵣ _ _ _ _)
+             (<ᵣWeaken≤ᵣ _ _ ( ^ℚ-StrictMonotoneR
+                             {rat u , isTrans<ᵣ 0 1 (rat u)
+                                 ((decℚ<ᵣ? {0} {1}))
+                                   (<ℚ→<ᵣ _ _ 1<u)}
+                              (<ℚ→<ᵣ _ _ 1<u) q r q<r))
+ hh (inl q≡r) u 1≤u (inr 1<u) = ≡ᵣWeaken≤ᵣ _ _
+   (cong (fst ∘ ((rat u , isTrans<≤ᵣ 0 1 (rat u) decℚ<ᵣ? (≤ℚ→≤ᵣ 1 u 1≤u)) ^ℚ_))
+     q≡r)
+
+
+fromNatℝ+ : ∀ {x y z} →
+    x ℕ.+ y ≡ z →
+    HasFromNat.fromNat fromNatℝ x +ᵣ HasFromNat.fromNat fromNatℝ y
+      ≡ HasFromNat.fromNat fromNatℝ z
+fromNatℝ+ p = +ᵣ-rat _ _ ∙ cong rat (ℚ.ℕ+→ℚ+  _ _ ∙ cong ([_/ 1 ] ∘ pos) p)
+
+AM-GM₂ : ∀ z → 1 <ᵣ fst z → ∀ x (Δ : ℚ₊) →
+          fst (2 ₊·ᵣ (z ^ℚ x)) <ᵣ
+            fst ((z ^ℚ (x ℚ.- fst Δ)) ₊+ᵣ (z ^ℚ (x ℚ.+ fst Δ)))
+AM-GM₂ z 1<z x Δ = isTrans<≡ᵣ _ _ _ (isTrans≡<ᵣ _ _ _
+       (cong (2 ·ᵣ_) (cong (fst ∘ z ^ℚ_) lem--035
+          ∙ sym (cong fst (^ℚ-+ z _ _)))
+          ∙ ·ᵣComm _ _ ∙ sym (·ᵣAssoc _ _ _))
+       (fst (z<x≃y₊·z<y₊·x _ _ (z ^ℚ (x ℚ.- fst Δ))) (isTrans≡<ᵣ _ _ _
+         (cong (fst a ·ᵣ_) (sym (fromNatℝ+ refl))
+           ∙ ·DistL+ (fst a) 1 1)
+       (invEq (x<y≃0<y-x _ _)
+      $ isTrans<≡ᵣ _ _ _ (ℝ₊· (_ , w') (_ , w'))
+       (L𝐑.lem--073 {fst a} {1})))))
+        (·DistL+ _ _ _ ∙ +ᵣComm _ _ ∙
+          cong₂ _+ᵣ_
+          (cong (((z ^ℚ (x ℚ.- fst Δ)) .fst) ·ᵣ_)
+              (sym (rat·ᵣrat _ _)) ∙ ·IdR _)
+              (cong (((z ^ℚ (x ℚ.- fst Δ)) .fst) ·ᵣ_)
+                (cong fst (^ℚ-+ z _ _)) ∙
+                  (cong fst (^ℚ-+ z _ _)) ∙
+                    cong (fst ∘ z ^ℚ_)
+                      lem--074))
+
+
+ where
+ a = z ^ℚ (fst Δ)
+ w' = fst (x<y≃0<y-x _ _) (1<^ℚ z Δ 1<z)
+
+invℚ₊-[/] : ∀ n m → [ n / 1 ] ℚ.· fst (invℚ₊ (fromNat (suc m))) ≡ [ n / 1+ m ]
+invℚ₊-[/] n m = cong₂ [_/_]
+  (ℤ.·IdR n)
+    (·₊₁-identityˡ (1+ m))
+
+[2+N]/[1+N]=2-N/[1+N] : ∀ n →
+   [ pos (2 ℕ.+ n) , (1+ n) ] ≡ (fromNat 2) ℚ.- [ pos n / 1+ n ]
+[2+N]/[1+N]=2-N/[1+N] n = cong₂ [_/_]
+  (sym (ℤ.plusMinus _ _) ∙ cong₂ (ℤ._+_)
+      (sym (ℤ.pos+ (2 ℕ.+ n) n) ∙ cong ℤ.sucℤ  (ℤ.pos+ _ _ ∙ cong₂ ℤ._+_
+        (cong ℚ.ℕ₊₁→ℤ (sym (·₊₁-identityˡ (1+ n))))
+        (cong pos (sym (ℕ.+-zero n)) )))
+      (sym (ℤ.·IdR _)))
+  (sym (·₊₁-identityˡ _) ∙ sym (·₊₁-identityˡ _))
+
+module AM-GM-hlp (b : ℝ₊) (1<b : 1 <ᵣ (fst b)) (x₀ : ℚ) (s : ℚ₊) where
+
+ x : ℕ → ℚ
+ x n = x₀ ℚ.+ fromNat n ℚ.· fst s
+
+ -- TODO : this should be used in few places bellow:
+ x-suc : ∀ n → x n ℚ.+ fst s ≡ x (suc n)
+ x-suc n = sym (ℚ.+Assoc _ _ _)
+     ∙ cong (x₀ ℚ.+_) (
+       cong ((fromNat n) ℚ.· (fst s) ℚ.+_) (sym (ℚ.·IdL _)) ∙∙
+       sym (ℚ.·DistR+  (fromNat n) 1 (fst s)) ∙∙
+           cong (ℚ._· (fst s)) (ℚ.+Comm _ _ ∙ (ℚ.ℕ+→ℚ+ 1 n) ) )
+
+ α : ℝ₊
+ α = (1 ₊+ᵣ (b ^ℚ (2 ℚ.· fst s))) ₊·ᵣ ℚ₊→ℝ₊ ( [ 1 / 2 ] , _ )
+
+ y : ℕ → ℝ₊
+ y zero = b ^ℚ x₀
+ y (suc n) = (b ^ℚ (x n)) ₊·ᵣ α
+
+
+
+ fromAM-GM : fst (b ^ℚ x 1) <ᵣ
+      fst (b ^ℚ x₀) +ᵣ
+      rat (fst (invℚ₊ (fromNat 2))) ·ᵣ (fst (b ^ℚ x 2) -ᵣ fst (b ^ℚ x₀))
+ fromAM-GM = isTrans≡<ᵣ _ _ _ (cong (fst ∘ b ^ℚ_ ∘ (x₀ ℚ.+_ ))
+      (ℚ.·IdL _))
+    (isTrans<≡ᵣ _ _ _ (invEq (z<x/y₊≃y₊·z<x _ _ 2)
+   (AM-GM₂ b 1<b (x₀ ℚ.+ fst s) s))
+    (cong (_·ᵣ fst (invℝ₊ 2))
+       (cong₂ _+ᵣ_
+          (cong (fst ∘ b ^ℚ_) (sym lem--034)
+            ∙ L𝐑.lem--034 {fst (b ^ℚ x₀)} {fst (b ^ℚ x₀)}
+            ∙ cong (_-ᵣ fst (b ^ℚ x₀))
+             (x+x≡2x _ ∙ ·ᵣComm _ _))
+             ((cong (fst ∘ b ^ℚ_) (sym (ℚ.+Assoc _ _ _)
+             ∙ cong (x₀ ℚ.+_) (ℚ.x+x≡2x _))))
+         ∙ sym (+ᵣAssoc _ _ _))
+      ∙ ·DistR+ (fst (b ^ℚ x₀) ·ᵣ 2) _ _
+      ∙ cong₂ _+ᵣ_ ([x·yᵣ]/₊y _ _)
+             (·ᵣComm _ _ ∙
+             cong₂ _·ᵣ_ (invℝ'-rat 2 _ _)
+               (+ᵣComm _ _))))
+
+ opaque
+  unfolding -ᵣ_ _+ᵣ_
+  convStep : ∀ N → rat (fst (invℚ₊ (fromNat (suc N)))) ·ᵣ
+       (fst (b ^ℚ x (suc N)) -ᵣ fst (b ^ℚ x₀))
+       <ᵣ
+       rat (fst (invℚ₊ (fromNat (suc (suc N))))) ·ᵣ
+       (fst (b ^ℚ x (suc (suc N))) -ᵣ fst (b ^ℚ x₀))
+
+  convSteps : ∀ N n → n ℕ.< N →
+                  fst (b ^ℚ (x (suc n))) <ᵣ
+                     (fst (b ^ℚ x₀) +ᵣ (rat (fst (fromNat (suc n)
+                      ℚ₊· invℚ₊ (fromNat (suc N)))) ·ᵣ
+                       (fst (b ^ℚ (x (suc N))) -ᵣ fst (b ^ℚ x₀))  ))
+  convSteps zero n n<0 = ⊥.rec (ℕ.¬-<-zero n<0)
+  convSteps (suc N) n n<sN@(N-n@(suc k) , p) =
+    let X = convSteps N n (k , cong predℕ p)
+    in isTrans<ᵣ _ _ _ X (<ᵣ-o+ _ _ _
+         (subst2 _<ᵣ_ (·ᵣAssoc _ _ _ ∙
+             cong (_·ᵣ ((fst (b ^ℚ (x (suc N))) -ᵣ fst (b ^ℚ x₀))))
+            (sym (rat·ᵣrat  (fromNat (suc n))
+             (fst $ invℚ₊ (fromNat (suc N))))))
+
+           (·ᵣAssoc _ _ _ ∙
+             cong (_·ᵣ ((fst (b ^ℚ (x (suc (suc N)))) -ᵣ fst (b ^ℚ x₀))))
+            (sym (rat·ᵣrat (fromNat (suc n))
+             (fst $ invℚ₊ (fromNat (suc (suc N)))))))
+           (fst (z<x≃y₊·z<y₊·x _ _ (fromNat (suc n)))
+             (convStep N))))
+  convSteps (suc zero) zero (zero , 1+n=1+N) = fromAM-GM
+  convSteps (suc (suc N)) zero (zero , 1+n=1+N) =
+    ⊥.rec (ℕ.znots (cong predℕ 1+n=1+N))
+  convSteps (suc N) (suc n) (zero , 2+n=1+N) =
+    subst2 _<ᵣ_ (cong (fst ∘ (b ^ℚ_) ∘ x) (sym 2+n=1+N))
+      (cong (λ sn → fst (b ^ℚ x₀) +ᵣ
+       rat (fst (fromNat (suc (predℕ sn)) ℚ₊· invℚ₊ (fromNat (suc (suc N)))))
+       ·ᵣ (fst (b ^ℚ x (suc (suc N))) -ᵣ fst (b ^ℚ x₀))) (sym (2+n=1+N)))
+         (isTrans<≡ᵣ _ _ _ (a-b<c⇒a<c+b (fst (b ^ℚ x (suc N))) _ _
+           (invEq (z<x/y₊≃y₊·z<x _ _ (ℚ₊→ℝ₊ (invℚ₊ (fromNat (suc N)))))
+            (convStep N)))
+           (cong (_+ᵣ fst (b ^ℚ x₀))
+            (sym (·ᵣAssoc _ _ _) ∙
+              cong (rat (fst (invℚ₊ (fromNat (suc (suc N))))) ·ᵣ_)
+               (·ᵣComm _ _)
+              ∙ ·ᵣAssoc _ _ _
+               ∙ cong (_·ᵣ (fst (b ^ℚ x (suc (suc N))) -ᵣ fst (b ^ℚ x₀)))
+                    ((cong (rat (fst (invℚ₊ (fromNat (suc (suc N))))) ·ᵣ_)
+                      (invℝ'-rat _ _ (snd (ℚ₊→ℝ₊ (invℚ₊ (fromNat (suc N)))))
+                        ∙ cong rat (ℚ.invℚ₊-invol _))
+                     ∙ sym (rat·ᵣrat _ (fromNat (suc N)))) ∙
+                        cong rat (ℚ.·Comm _ _)))
+              ∙ +ᵣComm _ _ ))
+
+
+  convStep zero = isTrans≡<ᵣ _ _ _
+    (·IdL _) (a<c+b⇒a-c<b _ _  _ fromAM-GM)
+  convStep (suc N) =
+    isTrans<ᵣ _ _ _
+       (isTrans<≡ᵣ _ _ _
+          (invEq (z<x/y₊≃y₊·z<x _ _ (fromNat (suc (suc (suc N)))))
+            (isTrans≡<ᵣ _ _ _
+             (·ᵣAssoc _ _ _ ∙
+              cong (_·ᵣ (fst (b ^ℚ x (suc (suc N))) -ᵣ fst (b ^ℚ x₀)))
+                (sym (rat·ᵣrat _ _) ∙
+                 cong rat ((invℚ₊-[/] _ _) ∙ [2+N]/[1+N]=2-N/[1+N] (suc N)))
+               ∙
+                ·DistR+ 2 (-ᵣ (rat [ _ / _ ])
+                ) _
+                )
+              (isTrans<≡ᵣ _ _ _
+                 (<ᵣ-o+ _ _ _ (isTrans≡<ᵣ _ _ _ (-ᵣ· _ _)
+                   (-ᵣ<ᵣ _ _
+                  (isTrans<≡ᵣ _ _ _
+             (a<c+b⇒a-c<b _ _ _ (convSteps (suc N) N ℕ.≤-refl))
+            (cong (_·ᵣ (fst (b ^ℚ x (suc (suc N))) -ᵣ fst (b ^ℚ x₀)))
+             (cong rat (invℚ₊-[/] (pos (suc N)) (suc N)))))) ))
+                 (cong (_-ᵣ (fst (b ^ℚ x (suc N)) -ᵣ fst (b ^ℚ x₀)))
+                   (sym (x+x≡2x _))
+                  ∙∙ L𝐑.lem--076 ∙∙
+                  cong ((_-ᵣ fst (b ^ℚ x₀)) ∘ (_-ᵣ fst (b ^ℚ x (suc N))))
+                    (x+x≡2x _)))))
+           (cong ((fst (2 ₊·ᵣ (b ^ℚ x (suc (suc N))))
+           -ᵣ fst (b ^ℚ x (suc N)) +ᵣ
+            -ᵣ fst (b ^ℚ x₀))
+             ·ᵣ_) (invℝ'-rat _ _ _) ∙ ·ᵣComm _ _))
+
+       (<ᵣ-o·ᵣ _ _ (ℚ₊→ℝ₊
+             ((invℚ₊ ([ pos (suc (suc (suc N))) , (1+ 0) ] , tt)))) (
+          (<ᵣ-+o _ _ _
+             (a<c+b⇒a-c<b _ _
+              (fst (b ^ℚ (x (suc N))))
+               (isTrans<≡ᵣ _ _ _ (AM-GM₂ b 1<b (x (suc (suc N))) s)
+                 (cong₂ _+ᵣ_
+                   (cong (fst ∘ (b ^ℚ_)) (cong (ℚ._- (fst s))
+                     (sym (x-suc (suc N)))
+                     ∙ sym lem--034))
+                    (cong (fst ∘ (b ^ℚ_)) (x-suc (suc (suc N))) )  ))))) )
+
+
+
+AM-GM-strict : ∀ z x → (1 <ᵣ fst z) → (Δ : ℚ₊) → (α : ℚ) → 0 ℚ.< α → α ℚ.< 1 →
+          fst (z ^ℚ (x ℚ.+ (α ℚ.· fst Δ))) <ᵣ
+            fst (z ^ℚ x) +ᵣ
+              (rat α) ·ᵣ
+                (fst (z ^ℚ (x ℚ.+ fst Δ)) -ᵣ fst (z ^ℚ x))
+AM-GM-strict z x 1<z Δ = ElimProp.go w
+ where
+ w : ElimProp _
+ w .ElimProp.isPropB _ = isPropΠ2 λ _ _ → isProp<ᵣ _ _
+ w .ElimProp.f (pos zero , (1+ m)) 0<α α<1 =
+   ⊥.rec (ℤ.¬-pos<-zero 0<α)
+ w .ElimProp.f (pos (suc n) , (1+ m)) 0<α α<1 =
+   subst2 _<ᵣ_
+     (cong (fst ∘ z ^ℚ_ ∘ (x ℚ.+_))
+         (ℚ.·Assoc _ [ pos 1 / 1+ m ] _ ∙
+            cong (ℚ._· (fst Δ)) n/N-lem))
+     ((cong (fst (z ^ℚ x) +ᵣ_)
+       (cong₂ _·ᵣ_ (cong rat n/N-lem)
+         (cong (_-ᵣ (fst (z ^ℚ x)))
+           ((cong (fst ∘ z ^ℚ_ ∘ (x ℚ.+_))
+              (ℚ.·Assoc _ [ pos 1 / 1+ m ] _ ∙
+            cong (ℚ._· (fst Δ)) (ℚ.x·invℚ₊[x] (fromNat (suc m)))
+              ∙ ℚ.·IdL _)))))))
+     ww
+  where
+  Δ/N =  ([ pos 1 / 1+ m ] , _) ℚ₊· Δ
+
+  n/N-lem = cong₂ [_/_] (ℤ.·IdR _) (·₊₁-identityˡ _)
+
+  ww = AM-GM-hlp.convSteps z 1<z x Δ/N m n
+       (ℕ.predℕ-≤-predℕ (ℤ.pos-≤-pos→ℕ≤ _ _
+         (subst2 ℤ._<_ (ℤ.·IdR _) (ℤ.·IdL _)
+           α<1)))
+ w .ElimProp.f α@(ℤ.negsuc n , 1+ m) 0<α _ =
+   ⊥.rec $ ℤ.¬pos≤negsuc (subst (0 ℤ.≤_) (ℤ.·IdR _)
+            (ℚ.<Weaken≤ 0 SQ.[ α ] 0<α))
+
+AM-GM : ∀ z x → (1 <ᵣ fst z) → (Δ : ℚ₊) → (α : ℚ) → 0 ℚ.≤ α → α ℚ.≤ 1 →
+          fst (z ^ℚ (x ℚ.+ (α ℚ.· fst Δ))) ≤ᵣ
+            fst (z ^ℚ x) +ᵣ
+              (rat α) ·ᵣ
+                (fst (z ^ℚ (x ℚ.+ fst Δ)) -ᵣ fst (z ^ℚ x))
+
+AM-GM z x 1<z Δ α 0≤α α≤1 =
+ ⊎.rec
+   (λ α≡1 → ≡ᵣWeaken≤ᵣ
+       (fst (z ^ℚ (x ℚ.+ α ℚ.· fst Δ)))
+       (fst (z ^ℚ x) +ᵣ rat α ·ᵣ (fst (z ^ℚ (x ℚ.+ fst Δ)) -ᵣ fst (z ^ℚ x)))
+       (cong {y = fst Δ} (fst ∘ (z ^ℚ_) ∘ (x ℚ.+_))
+          (cong (ℚ._· _) α≡1 ∙ ℚ.·IdL _)
+        ∙∙ sym (L𝐑.lem--05)
+        ∙∙ cong (fst (z ^ℚ x) +ᵣ_)
+             (sym (cong ((_·ᵣ (fst (z ^ℚ (x ℚ.+ fst Δ)) -ᵣ fst (z ^ℚ x))
+               ) ∘ rat) α≡1 ∙ ·IdL _))))
+   (⊎.rec
+      (λ 0=α _ → ≡ᵣWeaken≤ᵣ _ _
+         (cong (fst ∘ (z ^ℚ_))
+            (𝐐'.+IdR' x _
+               (cong (ℚ._· (fst Δ)) (sym 0=α)
+                 ∙ 𝐐'.0LeftAnnihilates _))
+           ∙ sym (𝐑'.+IdR' _ _
+           (cong (_·ᵣ (fst (z ^ℚ (x ℚ.+ fst Δ)) -ᵣ fst (z ^ℚ x)))
+             (cong rat (sym 0=α))
+            ∙ 𝐑'.0LeftAnnihilates _))))
+      ((<ᵣWeaken≤ᵣ _ _ ∘_) ∘ (AM-GM-strict z x 1<z Δ α))
+      (ℚ.≤→≡⊎< 0 α 0≤α))
+   (ℚ.≤→≡⊎< α 1 α≤1)
+
+^ⁿ-1 : ∀ x → x ^ⁿ 1 ≡ x
+^ⁿ-1 x = ·IdL _
+
+^ℚ-1 : ∀ x → x ^ℚ 1 ≡ x
+^ℚ-1 x = ℝ₊≡ (^ⁿ-1 _)
+
+-- AM-GM
+
+
+
+slope-incr-strict : (z : ℝ₊) (1<z : 1 <ᵣ fst z) → (a b c : ℚ)
+  → (a<b : a ℚ.< b) → (b<c : b ℚ.< c) →  (a<c : a ℚ.< c) →
+  ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<b))
+      <ᵣ
+  ((fst (z ^ℚ c) -ᵣ fst (z ^ℚ a))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a<c ))
+slope-incr-strict z 1<z a b c a<b b<c a<c =
+  isTrans≡<ᵣ _ _ _
+     (cong (_·ᵣ fst (invℝ₊ (ℚ₊→ℝ₊ (ℚ.<→ℚ₊ a b a<b))))
+      (cong (_-ᵣ fst (z ^ℚ a))
+          (cong (fst ∘ (z ^ℚ_))
+            (sym lem--05 ∙ cong (a ℚ.+_) (sym (ℚ.y·[x/y] _ _) ∙
+             ℚ.·Comm _ _ ∙
+              cong (ℚ._· fst (ℚ.<→ℚ₊ a c a<c))
+               (ℚ.·Comm _ _))))))
+     (isTrans<≡ᵣ _ _ _
+      amgm
+      (·ᵣComm _ _ ∙
+        cong₂ _·ᵣ_ (cong (_-ᵣ fst (z ^ℚ a))
+          (cong (fst ∘ (z ^ℚ_))
+            lem--05))
+         (sym (invℝ'-rat _ _ (snd (ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a<c )))))))
+
+ where
+ α₊ = (ℚ.<→ℚ₊ _ _  a<b ) ℚ₊· invℚ₊ (ℚ.<→ℚ₊ _ _  a<c )
+ α<1 : fst α₊ ℚ.< 1
+ α<1 = ℚ.x<y·z→x·invℚ₊y<z _ _ _
+   (subst (b ℚ.- a ℚ.<_)
+    (sym (ℚ.·IdR _))
+    (ℚ.<-+o _ _ (ℚ.- a) b<c))
+
+
+ amgm = invEq (z/y<x₊≃z<y₊·x _ _ (ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a<b )))
+  (isTrans<≡ᵣ _ _ _ (a<c+b⇒a-c<b _ _ _
+      (AM-GM-strict z a 1<z ((ℚ.<→ℚ₊ _ _  a<c ))
+          (fst α₊) (ℚ.0<ℚ₊ α₊) α<1))
+           (cong (_·ᵣ (fst (z ^ℚ (a ℚ.+ fst (ℚ.<→ℚ₊ _ _ a<c))) -ᵣ
+       fst (z ^ℚ a))) (rat·ᵣrat _ _)
+        ∙ sym (·ᵣAssoc _ _ _)))
+
+opaque
+ unfolding _+ᵣ_
+ slope-incr'-strict : (z : ℝ₊) (1<z : 1 <ᵣ fst z) → (a b c : ℚ)
+   → (a ℚ.< b) → (b<c : b ℚ.< c) →  (a<c : a ℚ.< c) →
+   ((fst (z ^ℚ c) -ᵣ fst (z ^ℚ a))
+     ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<c))
+       <ᵣ
+   ((fst (z ^ℚ c) -ᵣ fst (z ^ℚ b))
+     ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  b<c ))
+ slope-incr'-strict z 1<z a b c a<b b<c a<c =
+  let w = fst (x'/x<[x'+y']/[x+y]≃[x'+y']/[x+y]<y'/y
+                  (ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<b)) ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a)))
+                  (ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ b<c)) ((fst (z ^ℚ c) -ᵣ fst (z ^ℚ b))))
+              (isTrans<≡ᵣ _ _ _
+                (slope-incr-strict z 1<z _ _ _ a<b b<c a<c)
+                (cong₂ _／ᵣ₊_
+                  L𝐑.lem--077
+                  (ℝ₊≡ (cong rat lem--077))))
+  in isTrans≡<ᵣ _ _ _
+      (cong₂ _／ᵣ₊_
+        L𝐑.lem--077
+        ((ℝ₊≡ (cong rat lem--077)))) w
+
+opaque
+ unfolding _+ᵣ_ -ᵣ_
+ slope-incr : (z : ℝ₊) (a b c : ℚ)
+   → (a<b : a ℚ.< b) → (b≤c : b ℚ.≤ c) →  (a<c : a ℚ.< c) →
+   ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a))
+     ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<b))
+       ≤ᵣ
+   ((fst (z ^ℚ c) -ᵣ fst (z ^ℚ a))
+     ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a<c ))
+ slope-incr (z , 0<z) a b c a<b b≤c a<c =
+   <→≤ContPos'pred {0}
+     {λ z 0<z →
+        ((fst ((z , 0<z) ^ℚ b)
+        -ᵣ fst ((z , 0<z) ^ℚ a))
+      ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<b))}
+      {λ z 0<z →
+         ((fst ((z , 0<z) ^ℚ c)
+           -ᵣ fst ((z , 0<z) ^ℚ a))
+      ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a<c ))}
+       ((IsContinuousWP∘' _ _ _
+       (IsContinuous·ᵣR (fst (invℝ₊ (ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<b)))))
+       (contDiagNE₂WP sumR _ _ _
+         (⊆IsContinuousWithPred _ _ (λ x 0<x → 0<x) _
+           (IsContinuous^ℚ b))
+            (IsContinuousWP∘' _ _ _ IsContinuous-ᵣ
+              ((⊆IsContinuousWithPred _ _ (λ x 0<x → 0<x) _
+           (IsContinuous^ℚ a)))))))
+       (((IsContinuousWP∘' _ _ _
+       (IsContinuous·ᵣR (fst (invℝ₊ (ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<c)))))
+       (contDiagNE₂WP sumR _ _ _
+         (⊆IsContinuousWithPred _ _ (λ x 0<x → 0<x) _
+           (IsContinuous^ℚ c))
+            (IsContinuousWP∘' _ _ _ IsContinuous-ᵣ
+              ((⊆IsContinuousWithPred _ _ (λ x 0<x → 0<x) _
+           (IsContinuous^ℚ a))))))))
+       (ℚ.byTrichotomy 1 w)
+         z 0<z
+
+  where
+
+   slope-incr** : (z : ℝ₊) (1<z : 1 <ᵣ fst z) → (a b c : ℚ)
+     → (a<b : a ℚ.< b) → (b≤c : b ℚ.≤ c) →  (a<c : a ℚ.< c) →
+     ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a))
+       ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<b))
+         ≤ᵣ
+     ((fst (z ^ℚ c) -ᵣ fst (z ^ℚ a))
+       ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a<c ))
+   slope-incr** z 1<z a b c a<b =
+      flip
+        λ a<c → ⊎.rec
+           (≡ᵣWeaken≤ᵣ _ _ ∘
+             cong
+               (λ (b , a<b) →
+                 ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a)) ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ a b a<b)))
+               ∘ Σ≡Prop {B = λ b → a ℚ.< b} (ℚ.isProp< _))
+           (λ b<c → <ᵣWeaken≤ᵣ _ _ $  slope-incr-strict z 1<z a b c a<b b<c a<c)
+          ∘ ℚ.≤→≡⊎< b c
+
+   w : ℚ.TrichotomyRec 1
+          λ u → (0<u : 0 <ᵣ rat u) → ((fst ((rat u , 0<u) ^ℚ b) -ᵣ fst ((rat u , 0<u) ^ℚ a)) ／ᵣ₊
+                      ℚ₊→ℝ₊ (ℚ.<→ℚ₊ a b a<b))
+                     ≤ᵣ
+                     ((fst ((rat u , 0<u) ^ℚ c) -ᵣ fst ((rat u , 0<u) ^ℚ a)) ／ᵣ₊
+                      ℚ₊→ℝ₊ (ℚ.<→ℚ₊ a c a<c))
+   w .ℚ.TrichotomyRec.lt-case u u<1 0<u =
+     subst2 _≤ᵣ_
+         (sym (-ᵣ· _ _ ) ∙ cong₂ (λ A B → A ／ᵣ₊ (ℚ₊→ℝ₊ B))
+            (-[x-y]≡y-x _ _ ∙ cong₂ _-ᵣ_ (sym (cong fst (^ℚ-minus u₊ b)))
+                        ((sym (cong fst (^ℚ-minus u₊ a)))))
+                        {u = ℚ.<→ℚ₊ (ℚ.- b) (ℚ.- a) (ℚ.minus-< _ _ a<b)}
+                        (ℚ₊≡ (sym lem--083)))
+         (sym (-ᵣ· _ _) ∙ (cong₂ (λ A B → A ／ᵣ₊ (ℚ₊→ℝ₊ B))
+            (-[x-y]≡y-x _ _ ∙ cong₂ _-ᵣ_
+               ((sym (cong fst (^ℚ-minus u₊ c))))
+               ((sym (cong fst (^ℚ-minus u₊ a)))))
+               {u = ℚ.<→ℚ₊ (ℚ.- c) (ℚ.- a) (ℚ.minus-< _ _ a<c)}
+                 (ℚ₊≡ (sym lem--083))))
+           (-ᵣ≤ᵣ _ _
+             (⊎.rec ww'' ww' (ℚ.≤→≡⊎< b c b≤c)))
+     where
+     u₊ : ℝ₊
+     u₊ = (rat u , 0<u)
+     1/u₊ : ℝ₊
+     1/u₊ = (invℝ₊ (rat u , 0<u))
+     1<1/u : 1 <ᵣ (fst 1/u₊)
+     1<1/u = isTrans<≡ᵣ _ _ _
+        (invEq (z<x/y₊≃y₊·z<x 1 1 (rat u , 0<u)) (isTrans≡<ᵣ _ _ _
+            (·IdR _) (<ℚ→<ᵣ _ _ u<1)))
+         (·IdL _)
+
+     ww' : (b ℚ.< c) →   ((fst (1/u₊ ^ℚ (ℚ.- a)) -ᵣ fst (1/u₊ ^ℚ (ℚ.- c)))
+                                  ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ (ℚ.- c) (ℚ.- a) (ℚ.minus-< a c a<c)))
+                                    ≤ᵣ
+                                ((fst (1/u₊ ^ℚ (ℚ.- a)) -ᵣ fst (1/u₊ ^ℚ (ℚ.- b)))
+                                  ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ (ℚ.- b) (ℚ.- a) (ℚ.minus-< a b a<b) ))
+     ww' b<c = <ᵣWeaken≤ᵣ _ _ $ slope-incr'-strict (invℝ₊ (rat u , 0<u)) 1<1/u (ℚ.- c) (ℚ.- b) (ℚ.- a)
+              (ℚ.minus-< _ _ b<c) (ℚ.minus-< _ _ a<b) (ℚ.minus-< _ _ a<c)
+
+
+     ww'' : (b ≡ c) →   ((fst (1/u₊ ^ℚ (ℚ.- a)) -ᵣ fst (1/u₊ ^ℚ (ℚ.- c)))
+                                  ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ (ℚ.- c) (ℚ.- a) (ℚ.minus-< a c a<c)))
+                                   ≤ᵣ
+                                ((fst (1/u₊ ^ℚ (ℚ.- a)) -ᵣ fst (1/u₊ ^ℚ (ℚ.- b)))
+                                  ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ (ℚ.- b) (ℚ.- a) (ℚ.minus-< a b a<b) ))
+     ww'' b=c = ≡ᵣWeaken≤ᵣ _ _ (
+             cong
+               (λ (b , -b<-a) →
+                 ((fst (1/u₊ ^ℚ (ℚ.- a)) -ᵣ fst (1/u₊ ^ℚ (ℚ.- b))) ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ (ℚ.- b) (ℚ.- a) -b<-a)))
+               (Σ≡Prop {B = λ b → (ℚ.- b) ℚ.< (ℚ.- a)} (λ _ → ℚ.isProp< _ _) (sym b=c)))
+
+
+   w .ℚ.TrichotomyRec.eq-case _ = ≡ᵣWeaken≤ᵣ _ _
+             (𝐑'.0LeftAnnihilates' _ _
+                 (𝐑'.+InvR' _ _ (cong (fst ∘ (_^ℚ b)) (ℝ₊≡ refl) ∙ cong fst (1^ℚ≡1 b)
+                   ∙ sym (cong (fst ∘ (_^ℚ a)) (ℝ₊≡ refl) ∙ cong fst (1^ℚ≡1 a))))
+               ∙ sym (𝐑'.0LeftAnnihilates' _ _
+                 (𝐑'.+InvR' _ _ ((cong (fst ∘ (_^ℚ c)) (ℝ₊≡ refl) ∙ cong fst (1^ℚ≡1 c)
+                   ∙ sym (cong (fst ∘ (_^ℚ a)) (ℝ₊≡ refl) ∙ cong fst (1^ℚ≡1 a)))))))
+   w .ℚ.TrichotomyRec.gt-case u 1<u 0<u =
+     slope-incr** (rat u , 0<u) (<ℚ→<ᵣ _ _ 1<u) a b c a<b b≤c a<c
+
+
+
+
+slope-incr' : (z : ℝ₊) → (a b c : ℚ)
+  → (a≤b : a ℚ.≤ b) → (b<c : b ℚ.< c) →  (a<c : a ℚ.< c) →
+  ((fst (z ^ℚ c) -ᵣ fst (z ^ℚ a))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<c))
+      ≤ᵣ
+  ((fst (z ^ℚ c) -ᵣ fst (z ^ℚ b))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  b<c ))
+slope-incr' z a b c a≤b b<c a<c =
+     subst2 _≤ᵣ_
+       (sym (-ᵣ· _ _) ∙ cong₂ (λ A B → A ／ᵣ₊ (ℚ₊→ℝ₊ B))
+          (-[x-y]≡y-x _ _ ∙ cong₂ _-ᵣ_ (sym (cong fst (^ℚ-minus z _)))
+                      ((sym (cong fst (^ℚ-minus z _)))))
+                      {u = ℚ.<→ℚ₊ (ℚ.- _) (ℚ.- _) (ℚ.minus-< _ _ _)}
+                      (ℚ₊≡ (sym lem--083)))
+       (sym (-ᵣ· _ _) ∙ (cong₂ (λ A B → A ／ᵣ₊ (ℚ₊→ℝ₊ B))
+          (-[x-y]≡y-x _ _ ∙ cong₂ _-ᵣ_
+             ((sym (cong fst (^ℚ-minus z _))))
+             ((sym (cong fst (^ℚ-minus z _)))))
+             {u = ℚ.<→ℚ₊ (ℚ.- _) (ℚ.- _) (ℚ.minus-< _ _ _)}
+               (ℚ₊≡ (sym lem--083))))
+              ww
+
+ where
+ ww : -ᵣ ((fst (invℝ₊ z ^ℚ (ℚ.- a)) -ᵣ fst (invℝ₊ z ^ℚ (ℚ.- c))) ／ᵣ₊
+        ℚ₊→ℝ₊ (ℚ.<→ℚ₊ (ℚ.- c) (ℚ.- a) (ℚ.minus-< a c a<c)))
+      ≤ᵣ
+      -ᵣ ((fst (invℝ₊ z ^ℚ (ℚ.- b)) -ᵣ fst (invℝ₊ z ^ℚ (ℚ.- c))) ／ᵣ₊
+        ℚ₊→ℝ₊ (ℚ.<→ℚ₊ (ℚ.- c) (ℚ.- b) (ℚ.minus-< b c b<c)))
+
+
+ ww = -ᵣ≤ᵣ _ _ (slope-incr (invℝ₊ z) (ℚ.- c) (ℚ.- b) (ℚ.- a)
+         (ℚ.minus-< _ _ b<c) (ℚ.minus-≤ _ _ a≤b) (ℚ.minus-< _ _ a<c))
+
+
+slope-monotone : (z : ℝ₊)  → (a b a' b' : ℚ)
+  → (a<b : a ℚ.< b) → (a'<b' : a' ℚ.< b') → (a≤a' : a ℚ.≤ a') →  (b≤b' : b ℚ.≤ b') →
+  ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<b))
+      ≤ᵣ
+  ((fst (z ^ℚ b') -ᵣ fst (z ^ℚ a'))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a'<b' ))
+slope-monotone z a b a' b' a<b a'<b' a≤a' b≤b' =
+  isTrans≤ᵣ _ _ _
+    (slope-incr z a b b' a<b b≤b' (ℚ.isTrans<≤ _ _ _ a<b b≤b'))
+      (slope-incr' z a a' b' a≤a' a'<b' (ℚ.isTrans<≤ _ _ _ a<b b≤b'))
+
+opaque
+ unfolding -ᵣ_ _+ᵣ_
+ slope-monotone＃ : (z : ℝ₊) → (a b a' b' : ℚ)
+   → (a＃b : rat a ＃ rat b) → (a'<b' : a' ℚ.< b') → (a≤a' : a ℚ.≤ a') →  (b≤b' : b ℚ.≤ b') →
+   ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a))
+     ／ᵣ[ rat b -ᵣ rat a  , invEq (＃Δ _ _) a＃b ])
+       ≤ᵣ
+   ((fst (z ^ℚ b') -ᵣ fst (z ^ℚ a'))
+     ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a'<b' ))
+ slope-monotone＃ z a b a' b' (inl a<b) a'<b' a≤a' b≤b' =
+   isTrans≡≤ᵣ _ _ _
+     (cong ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a)) ·ᵣ_)
+       (sym (invℝ₊≡invℝ _ _)))
+     (slope-monotone z  a b a' b' (<ᵣ→<ℚ _ _ a<b) a'<b' a≤a' b≤b')
+ slope-monotone＃ z  a b a' b' (inr b<a) a'<b' a≤a' b≤b' =
+   isTrans≡≤ᵣ _ _ _
+      w
+     (slope-monotone z b a a' b' (<ᵣ→<ℚ _ _ b<a) a'<b'
+       (ℚ.isTrans≤ _ _ _
+         (ℚ.<Weaken≤ _ _ (<ᵣ→<ℚ _ _ b<a)) a≤a')
+          (ℚ.isTrans≤ _ _ _ a≤a' (ℚ.<Weaken≤ _ _ a'<b')))
+
+  where
+  w : ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a)) ／ᵣ[ rat b -ᵣ rat a ,
+        invEq (＃Δ (rat b) (rat a)) (inr b<a) ])
+       ≡
+       ((fst (z ^ℚ a) -ᵣ fst (z ^ℚ b)) ／ᵣ₊
+        ℚ₊→ℝ₊ (ℚ.<→ℚ₊ b a (<ᵣ→<ℚ b a b<a)))
+  w = sym (-ᵣ·-ᵣ _ _) ∙
+      cong₂ _·ᵣ_
+        (-[x-y]≡y-x _ _)
+        (-invℝ _ _ ∙∙ cong₂ invℝ (-[x-y]≡y-x (rat b) (rat a))
+          (toPathP refl)
+          ∙∙ sym (invℝ₊≡invℝ _ _))
+
+ slope-monotone＃' : (z : ℝ₊) → (a b a' b' : ℚ)
+   → (a<b : a ℚ.< b) → (a'＃b' : rat a' ＃ rat b')  → (a≤a' : a ℚ.≤ a') →  (b≤b' : b ℚ.≤ b') →
+   ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a))
+     ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a<b ))
+       ≤ᵣ
+   ((fst (z ^ℚ b') -ᵣ fst (z ^ℚ a'))
+      ／ᵣ[ rat b' -ᵣ rat a'  , invEq (＃Δ _ _) a'＃b' ])
+ slope-monotone＃' z a b a' b' a<b (inl a'<b') a≤a' b≤b' =
+   isTrans≤≡ᵣ _ _ _
+     (slope-monotone z a b a' b' a<b (<ᵣ→<ℚ _ _ a'<b') a≤a' b≤b')
+     ((cong ((fst (z ^ℚ b') -ᵣ fst (z ^ℚ a')) ·ᵣ_)
+       (invℝ₊≡invℝ _ _)))
+ slope-monotone＃' z a b a' b' a<b (inr b'<a') a≤a' b≤b' =
+  isTrans≤≡ᵣ _ _ _
+    ((slope-monotone z a b b' a' a<b (<ᵣ→<ℚ _ _ b'<a')
+       (ℚ.isTrans≤ _ _ _ (ℚ.<Weaken≤ _ _ a<b) b≤b')
+       (ℚ.isTrans≤ _ _ _ b≤b' ((ℚ.<Weaken≤ _ _ (<ᵣ→<ℚ _ _ b'<a'))))))
+    (sym w)
+
+
+  where
+  w : ((fst (z ^ℚ b') -ᵣ fst (z ^ℚ a')) ／ᵣ[ rat b' -ᵣ rat a' ,
+        invEq (＃Δ (rat b') (rat a')) (inr b'<a') ])
+       ≡
+       ((fst (z ^ℚ a') -ᵣ fst (z ^ℚ b')) ／ᵣ₊
+        ℚ₊→ℝ₊ (ℚ.<→ℚ₊ b' a' (<ᵣ→<ℚ b' a' b'<a')))
+  w = sym (-ᵣ·-ᵣ _ _) ∙
+      cong₂ _·ᵣ_
+        (-[x-y]≡y-x _ _)
+        (-invℝ _ _ ∙∙ cong₂ invℝ (-[x-y]≡y-x (rat b') (rat a'))
+          (toPathP refl)
+          ∙∙ sym (invℝ₊≡invℝ _ _))
+
+
+
+
+slope-monotone-strict : (z : ℝ₊) (1<z : 1 <ᵣ fst z) → (a b a' b' : ℚ)
+  → (a<b : a ℚ.< b) → (a'<b' : a' ℚ.< b') → (a≤a' : a ℚ.≤ a') →  (b<b' : b ℚ.< b') →
+  ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<b))
+      <ᵣ
+  ((fst (z ^ℚ b') -ᵣ fst (z ^ℚ a'))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a'<b' ))
+slope-monotone-strict z 1<z a b a' b' a<b a'<b' a≤a' b<b' =
+  isTrans<≤ᵣ _ _ _
+    (slope-incr-strict z 1<z a b b' a<b b<b' (ℚ.isTrans< _ _ _ a<b b<b'))
+      (slope-incr' z a a' b' a≤a' a'<b' (ℚ.isTrans< _ _ _ a<b b<b'))
+
+slope-monotone-strict' : (z : ℝ₊) (1<z : 1 <ᵣ fst z) → (a b a' b' : ℚ)
+  → (a<b : a ℚ.< b) → (a'<b' : a' ℚ.< b') → (a<a' : a ℚ.< a') →  (b≤b' : b ℚ.≤ b') →
+  ((fst (z ^ℚ b) -ᵣ fst (z ^ℚ a))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ a<b))
+      <ᵣ
+  ((fst (z ^ℚ b') -ᵣ fst (z ^ℚ a'))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  a'<b' ))
+slope-monotone-strict' z 1<z a b a' b' a<b a'<b' a<a' b≤b' =
+  isTrans≤<ᵣ _ _ _
+    (slope-incr z a b b' a<b b≤b' (ℚ.isTrans<≤ _ _ _ a<b b≤b'))
+      (slope-incr'-strict z 1<z a a' b' a<a' a'<b' (ℚ.isTrans<≤ _ _ _ a<b b≤b'))
+
+opaque
+ unfolding invℝ
+ bernoulli's-ineq-^ℚ-r<1 : ∀ x r → 1 <ᵣ fst x → 0 ℚ.< r → r ℚ.< 1 → fst (x ^ℚ r) <ᵣ 1 +ᵣ rat r ·ᵣ (fst x -ᵣ 1)
+ bernoulli's-ineq-^ℚ-r<1 x r 1<x 0<r r<1 =
+   isTrans<≡ᵣ _ _ _ (a-b<c⇒a<c+b _ 1 _
+       ((fst (z/y<x₊≃z<y₊·x _ _ _)
+             (slope-incr-strict x 1<x 0 r 1
+                0<r r<1 ℚ.decℚ<?))))
+              (+ᵣComm _ _ ∙ cong (1 +ᵣ_)
+                (cong₂ _·ᵣ_ (cong rat (ℚ.+IdR _))
+                  (𝐑'.·IdR' _ _ (cong rat ℚ.decℚ?)
+                   ∙ cong₂ (_-ᵣ_) (cong fst (^ℚ-1 x)) (cong fst (1^ℚ≡1 0)))))
+
+ bernoulli's-ineq-^ℚ : ∀ x r → 1 <ᵣ fst x
+  → 1 ℚ.< r → 1 +ᵣ rat r ·ᵣ (fst x -ᵣ 1)  <ᵣ fst (x ^ℚ r)
+ bernoulli's-ineq-^ℚ x r 1<x 1<r =
+   isTrans≡<ᵣ _ _ _
+        (cong (1 +ᵣ_) (cong₂ _·ᵣ_
+          (sym (cong rat (ℚ.+IdR _)))
+          (cong₂ (_-ᵣ_) (sym (cong fst (^ℚ-1 x))) (cong fst (sym (1^ℚ≡1 0)))
+           ∙ sym (𝐑'.·IdR' _ _ (cong rat ℚ.decℚ?))))
+          ∙ +ᵣComm _ _)
+        (a<b-c⇒a+c<b _ _ 1 (fst (z<x/y₊≃y₊·z<x _ _ _)
+         (slope-incr-strict x 1<x 0 1 r ℚ.decℚ<?
+          1<r (ℚ.isTrans< _ 1 _ ℚ.decℚ<? 1<r))))
+
+
+power-slope-Δ : (z : ℝ₊) (1<z : 1 <ᵣ fst z) → (a b : ℚ) → a ℚ.< b →
+   (Δ : ℚ₊) →
+  fst (z ^ℚ b) -ᵣ fst (z ^ℚ a) <ᵣ
+   fst (z ^ℚ (b ℚ.+ fst Δ)) -ᵣ fst (z ^ℚ (a ℚ.+ fst Δ))
+power-slope-Δ z 1<z a b a<b Δ =
+  isTrans<≡ᵣ _ _ _
+    (isTrans≡<ᵣ _ _ _
+       (sym (·IdL _))
+       (<ᵣ-·ᵣo _ _ (_ ,
+         x<y→0<y-x _ _ (^ℚ-StrictMonotoneR 1<z _ _ a<b ))
+        (1<^ℚ z Δ 1<z)  ))
+    (·DistL- (fst (z ^ℚ (fst Δ))) _ _ ∙
+      cong₂ _-ᵣ_
+       (·ᵣComm _ _ ∙ cong fst (^ℚ-+ z _ _))
+       (·ᵣComm _ _ ∙ cong fst (^ℚ-+ z _ _)))
+
+
+fromNatℝ≡fromNatℚ : ∀ n → fromNat (suc n) ≡ ℚ₊→ℝ₊ (fromNat (suc n))
+fromNatℝ≡fromNatℚ n = ℝ₊≡ refl
+
+bound : ℝ₊ → ℚ₊ → ℝ
+bound z B = ((fst (z ^ℚ (2 ℚ.· (fst B))) -ᵣ fst (z ^ℚ (fst B))) ·ᵣ
+   rat (fst (invℚ₊ B)))
+
+bound1≡0 : ∀ q → bound 1 q ≡ 0
+bound1≡0 q = 𝐑'.0LeftAnnihilates' _ _
+  (𝐑'.+InvR' _ _ ((cong fst (1^ℚ≡1 _) ∙ cong fst (sym (1^ℚ≡1 _)))))
+
+2x-x≡x : ∀ q → (2 ℚ.· q) ℚ.- q ≡ q
+2x-x≡x q = cong ((2 ℚ.· q) ℚ.+_)
+            (cong (ℚ.-_) (sym (ℚ.·IdL _)))
+              ∙ sym (𝐐'.·DistL- 2 1 q)
+              ∙ ℚ.·IdL _
+
+module _ (Z N : ℕ) where
+
+ N<2N : fromNat (suc N) ℚ.< 2 ℚ.· fromNat (suc N)
+ N<2N = (ℚ.<ℤ→<ℚ _ _
+         (ℤ.suc-≤-suc (subst (pos (suc N) ℤ.≤_) (cong pos (ℕ.+-suc _ _)
+          ∙ ℤ.pos+ _ _)
+           (ℤ.ℕ≤→pos-≤-pos _ _ (ℕ.≤-+k {0} {N} {k = suc N} ℕ.zero-≤)))))
+
+ N<2N' : fromNat (suc N) ℚ.< fromNat (2 ℕ.· suc N)
+ N<2N' = subst (fromNat (suc N) ℚ.<_) (ℚ.ℕ·→ℚ· _ _) N<2N
+
+
+
+ 1<2+Z = (<ℚ→<ᵣ 1 (fromNat (2 ℕ.+ Z)) (ℚ.<ℤ→<ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _
+        (ℕ.≤-k+ {k = 2} ℕ.zero-≤))))
+
+ boundℚ : ℚ₊
+ boundℚ = ℚ.<→ℚ₊ _ _
+    (<ᵣ→<ℚ ((fromNat (2 ℕ.+ Z)) ℚ^ⁿ suc N)
+           ((fromNat (2 ℕ.+ Z)) ℚ^ⁿ (2 ℕ.· suc N))
+      (subst2 _<ᵣ_
+        (^ⁿ-ℚ^ⁿ _ _)
+        (cong (fst ∘ (fromNat (suc (suc Z)) ^ℚ_))
+          (ℚ.ℕ·→ℚ· _ _)
+         ∙ ^ⁿ-ℚ^ⁿ _ _)
+       (^ℚ-StrictMonotoneR {fromNat (suc (suc Z))}
+       1<2+Z
+       (fromNat (suc N)) (2 ℚ.· fromNat (suc N)) N<2N)))
+         ℚ₊·
+       (invℚ₊ (fromNat (suc N)))
+
+ boundℚInv : ℚ₊
+ boundℚInv = ℚ.<→ℚ₊ _ _
+    (<ᵣ→<ℚ ([ 1 / fromNat (2 ℕ.+ Z) ] ℚ^ⁿ (2 ℕ.· suc N))
+           ([ 1 / fromNat (2 ℕ.+ Z) ] ℚ^ⁿ (suc N))
+      (subst2 _<ᵣ_
+        (^ⁿ-ℚ^ⁿ _ _)
+        (^ⁿ-ℚ^ⁿ _ _)
+        (^ℚ-StrictMonotoneR' {ℚ₊→ℝ₊ ([ 1 / fromNat (2 ℕ.+ Z) ] , _)}
+           (<ℚ→<ᵣ _ _ (fst (ℚ.invℚ₊-<-invℚ₊ 1 (fromNat (2 ℕ.+ Z)))
+             (ℚ.<ℤ→<ℚ _ _ ((ℤ.ℕ≤→pos-≤-pos _ _
+               (ℕ.≤-k+ {k = 2} ℕ.zero-≤))))))
+           (fromNat (suc N)) (fromNat (2 ℕ.· suc N))
+              (subst (λ n → fromNat (n) ℚ.< fromNat (2 ℕ.· suc N))
+                (ℕ.·-identityˡ _)
+                (ℚ.<ℤ→<ℚ _ _ (
+                  invEq (ℤ.pos-<-pos≃ℕ< _ _)
+                    (ℕ.<-·sk {1} {2} {N} ℕ.≤-refl)))))))
+         ℚ₊·
+       (invℚ₊ (fromNat (suc N)))
+
+
+ hlp : fst
+      (invℝ₊
+       (ℚ₊→ℝ₊
+        (ℚ.<→ℚ₊ [ pos (suc N) / 1+ 0 ]
+         [ pos (suc (N ℕ.+ suc (N ℕ.+ zero))) / 1+ 0 ] N<2N')))
+      ≡ rat (fst (invℚ₊ ([ pos (suc N) , (1+ 0) ] , tt)))
+ hlp = (invℝ₊-rat _ ∙
+            cong (rat ∘ fst ∘ invℚ₊)
+              (ℚ₊≡ (cong (ℚ._- (fromNat (suc N))) (sym (ℚ.ℕ·→ℚ· _ _))
+               ∙ 2x-x≡x (fromNat (suc N)))))
+
+ hlp2 : invℝ₊ (fromNat (2 ℕ.+ Z)) ≡
+      ℚ₊→ℝ₊ ([ 1 / fromNat (2 ℕ.+ Z) ] , _)
+ hlp2 = ℝ₊≡ (cong (fst ∘ invℝ₊) (fromNatℝ≡fromNatℚ _)
+  ∙ invℝ₊-rat (fromNat (2 ℕ.+ Z)))
+
+ opaque
+  unfolding -ᵣ_ _+ᵣ_
+  boundℚInv<boundℚ : fst (boundℚInv) ℚ.< fst (boundℚ)
+  boundℚInv<boundℚ =
+    <ᵣ→<ℚ _ _
+      (subst2 _<ᵣ_
+        (cong₂ _·ᵣ_
+           (cong₂ _-ᵣ_
+             (cong fst (^ℚ-minus' _ _ ∙ cong (_^ℚ fromNat (suc N))
+                  hlp2)
+              ∙ ^ⁿ-ℚ^ⁿ (suc N) _)
+             (cong fst (^ℚ-minus' _ _ ∙ cong (_^ℚ fromNat (2 ℕ.· suc N))
+                  hlp2) ∙ ^ⁿ-ℚ^ⁿ (2 ℕ.· suc N) _))
+           (cong (fst ∘ invℝ₊ ∘ ℚ₊→ℝ₊)
+             (ℚ₊≡ (sym lem--083))
+             ∙ hlp)
+          ∙ sym (rat·ᵣrat _ _))
+        (cong₂ _·ᵣ_
+           (cong₂ _-ᵣ_
+             (^ⁿ-ℚ^ⁿ _ _)
+             (^ⁿ-ℚ^ⁿ _ _))
+           hlp
+          ∙ sym (rat·ᵣrat _ _))
+        (slope-monotone-strict (fromNat (2 ℕ.+ Z))
+           1<2+Z
+          (ℚ.- (fromNat (2 ℕ.· suc N))) (ℚ.- (fromNat (suc N)))
+          (fromNat (suc N)) (fromNat (2 ℕ.· suc N))
+          (ℚ.minus-< _ _ N<2N')
+          N<2N'
+          (ℚ.isTrans≤ _ 0 _  (ℚ.neg≤pos _ _) (ℚ.0≤pos _ _))
+          (ℚ.isTrans≤< _ 0 _  (ℚ.neg≤pos _ _) (ℚ.0<pos _ _))))
+
+1<boundℚ : ∀ Z n → 1 ℚ.< fst (boundℚ Z n)
+1<boundℚ Z n = w
+
+ where
+ w : 1 ℚ.< (((fromNat (2 ℕ.+ Z)) ℚ^ⁿ (2 ℕ.· suc n)) ℚ.- ((fromNat (2 ℕ.+ Z)) ℚ^ⁿ suc n))
+              ℚ.· fst (invℚ₊ (fromNat (suc n)))
+ w = subst (1 ℚ.<_)
+    (ℚ.·Assoc _ _ _
+       ∙ cong (ℚ._· fst (invℚ₊ (fromNat (suc n))))
+         (ℚ.·DistR+ (fromNat (2 ℕ.+ Z) ℚ^ⁿ suc n) (-1) (fromNat (2 ℕ.+ Z) ℚ^ⁿ suc n)
+           ∙ cong₂ (ℚ._+_)
+           (ℚ.·-ℚ^ⁿ (suc n) (suc n) (fromNat (2 ℕ.+ Z)) ∙ cong {x = (suc n) ℕ.+ (suc n)} ((fromNat (2 ℕ.+ Z)) ℚ^ⁿ_)
+             (cong (λ n' → suc (n ℕ.+ suc n')) (sym (ℕ.+-zero n))))
+             (sym (ℚ.-·- (ℚ.- 1) _) ∙ ℚ.·IdL _)
+             ) )
+    (ℚ.≤<Monotone·-onPos 1 ((fromNat (2 ℕ.+ Z) ℚ^ⁿ suc n) ℚ.- 1)
+       1 _
+       (ℚ.≤-+o 2 ((fromNat (2 ℕ.+ Z) ℚ^ⁿ suc n)) -1
+         (ℚ.isTrans≤ _ (fromNat (2 ℕ.+ Z)) _ (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos 2 (2 ℕ.+ Z)
+          (ℕ.suc-≤-suc (ℕ.suc-≤-suc (ℕ.zero-≤ {Z})))))
+          (subst (fromNat (2 ℕ.+ Z) ℚ.≤_) (sym (ℚ.fromNat-^ (2 ℕ.+ Z) (suc n)))
+            (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _
+              (subst (ℕ._≤ ((2 ℕ.+ Z) ^ suc n))
+                (cong (suc ∘ suc) (·-identityʳ Z))
+                 (ℕ.^-monotone (2 ℕ.+ Z) 0 n (ℕ.zero-≤ {n}))))))))
+       (subst (ℚ._<
+          (fromNat (2 ℕ.+ Z) ℚ^ⁿ suc n) ℚ.· fst (invℚ₊ (fromNat (suc n))))
+            (ℚ.x·invℚ₊[x] (fromNat (suc n)))
+              (ℚ.<-·o _ _ (fst (invℚ₊ (fromNat (suc n))))
+                (ℚ.0<ℚ₊ (invℚ₊ (fromNat (suc n))))
+                 (subst (fst (fromNat (suc n)) ℚ.<_)
+                   (sym (ℚ.fromNat-^ (2 ℕ.+ Z) (suc n)))
+                   (ℚ.<ℤ→<ℚ _ _ (invEq (ℤ.pos-<-pos≃ℕ< _ _) (ℕ.sn<ssm^sn n Z))))))
+       (ℚ.decℚ<? {0} {1}) (ℚ.decℚ≤? {0} {1}))
+
+pred0< : ℙ ℝ
+pred0< = λ x → (0 <ᵣ x) , isProp<ᵣ _ _
+
+pred1< : ℙ ℝ
+pred1< = λ x → (1 <ᵣ x) , isProp<ᵣ _ _
+
+
+opaque
+ unfolding -ᵣ_ _+ᵣ_
+ contBound : ∀ B → IsContinuousWithPred pred0< (curry (flip bound B))
+ contBound B =
+   IsContinuousWP∘ ⊤Pred _ _ _ _
+     (AsContinuousWithPred _ _ (IsContinuous·ᵣR (rat (fst (invℚ₊ B)))))
+     (contDiagNE₂WP sumR _
+        _ _
+          (IsContinuous^ℚ _)
+           (IsContinuousWP∘ pred0< _ _ _
+             (curry (snd ∘ (_^ℚ fst B))) (AsContinuousWithPred _ _  IsContinuous-ᵣ)
+               (IsContinuous^ℚ _)))
+
+
+
+
+-- module ExpSlopeBound (z : ℝ₊) (1<z : 1 <ᵣ fst z)  where
+--  module _ (B : ℚ₊) where
+
+
+
+--   ineqStrict : ∀ x y → y ℚ.≤ fst B → x ℚ.< y →
+--            (fst (z ^ℚ y) -ᵣ fst (z ^ℚ x)) <ᵣ
+--               bound z B ·ᵣ rat (y ℚ.- x)
+--   ineqStrict x y y≤B x<y =
+--        isTrans<≡ᵣ _ _ _
+--          (fst (z/y<x₊≃z<y₊·x _ _ (ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ x<y)))
+--            (isTrans≤<ᵣ _ _ _
+--              (slope-incr' z x x' y
+--                (ℚ.≤max _ _) x'<y x<y)
+--              (isTrans<≤ᵣ _ _ _
+--                (<ᵣ-·ᵣo _ _ (invℝ₊ (ℚ₊→ℝ₊ (ℚ.<→ℚ₊ x' y x'<y)))
+--                 (power-slope-Δ z 1<z x' y x'<y
+--                (ℚ.<→ℚ₊ _ _ (ℚ.isTrans<≤  _ _ _ x'<y y≤B))))
+--                (isTrans≡≤ᵣ _ _ _
+--                  (cong₂ _／ᵣ₊_ (cong (λ v →
+--                         fst (z ^ℚ (y ℚ.+ (fst B ℚ.- x'))) -ᵣ fst (z ^ℚ v))
+--                        lem--05)
+--                    (ℝ₊≡ (cong rat lem--078)))
+--                  (isTrans≤≡ᵣ _ _ _
+--                     (slope-incr z
+--                       (fst B) (y ℚ.+ (fst B ℚ.- x')) (2 ℚ.· (fst B))
+--                        (subst2 (ℚ._<_) (ℚ.+IdL (fst B))
+--                          (sym (ℚ.+Assoc _ _ _)
+--                          ∙ cong (y ℚ.+_) (ℚ.+Comm _ _))
+--                          (ℚ.<-+o 0 _ (fst B) (ℚ.-< _ _ x'<y)))
+--                        (subst2 ℚ._≤_
+--                          ( sym (ℚ.+Assoc _ _ _)
+--                          ∙ cong (y ℚ.+_) (ℚ.+Comm _ _)) (ℚ.x+x≡2x (fst B))
+--                          (ℚ.≤-+o _ _ _ y-x'≤B))
+--                        (subst (ℚ._< (2 ℚ.· fst B)) (ℚ.·IdL (fst B))
+--                          (ℚ.<-·o _ _ (fst B) (ℚ.0<ℚ₊ B)
+--                            (ℚ.decℚ<? {1} {2})))) ww)))))
+--          (·ᵣComm _ _)
+
+--     where
+--     x' = ℚ.max x (y ℚ.- fst B)
+
+--     x'<y : x' ℚ.< y
+--     x'<y = ℚ.max< _ _ _ x<y (ℚ.<-ℚ₊' y y B (ℚ.isRefl≤ y ) )
+
+--     y-x'≤B : y ℚ.- x' ℚ.≤ fst B
+--     y-x'≤B = subst (y ℚ.- x' ℚ.≤_) lem--079
+--      (ℚ.≤-o+ _ _ y
+--      (ℚ.minus-≤ (y ℚ.- fst B) x' (ℚ.≤max' x (y ℚ.- fst B))))
+
+--     ww' = (ℚ.<→ℚ₊ (fst B) (2 ℚ.· fst B)
+--              (subst (ℚ._< 2 ℚ.· fst B) (ℚ.·IdL (fst B))
+--               (ℚ.<-·o 1 2 (fst B) (ℚ.0<ℚ₊ B) ℚ.decℚ<?)))
+
+--     ww : ((fst (z ^ℚ (2 ℚ.· fst B)) -ᵣ fst (z ^ℚ fst B)) ／ᵣ₊
+--             (ℚ₊→ℝ₊ ww'))
+--            ≡ ((fst (z ^ℚ (2 ℚ.· (fst B))) -ᵣ fst (z ^ℚ (fst B))) ·ᵣ
+--      rat (fst (invℚ₊ B)))
+--     ww =
+--      cong ((fst (z ^ℚ (2 ℚ.· fst B)) -ᵣ fst (z ^ℚ fst B)) ·ᵣ_)
+--        (invℝ'-rat _ (snd ww') (snd (ℚ₊→ℝ₊ ww')) ∙
+--          cong (rat ∘ fst ∘ invℚ₊) (ℚ₊≡
+--           (cong (ℚ._- (fst B)) (sym (ℚ.x+x≡2x (fst B)))
+--            ∙ sym (lem--034 {fst B}))) )
+
+
+--   ineqStrictInv : ∀ x y → (ℚ.- (fst B)) ℚ.≤ x → x ℚ.< y →
+--                 (-ᵣ (bound (invℝ₊ z) B)) ·ᵣ rat (y ℚ.- x) <ᵣ  (fst (z ^ℚ y) -ᵣ fst (z ^ℚ x))
+--   ineqStrictInv x y -B≤x x<y =
+--      isTrans≡<ᵣ _ _ _ (·ᵣComm _ _)
+--        (fst (z<x/y₊≃y₊·z<x _ _ _) w)
+--     where
+
+--     -2B<-B = (ℚ.minus-< _ _ (subst (ℚ._< 2 ℚ.· (fst B))
+--                 (ℚ.·IdL (fst B)) (ℚ.<-·o 1 2 (fst B) (ℚ.0<ℚ₊ B)
+--                   ℚ.decℚ<?)))
+
+--     w : (-ᵣ (bound (invℝ₊ z) B))  <ᵣ  ((fst (z ^ℚ y) -ᵣ fst (z ^ℚ x)) ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  x<y ))
+--     w = isTrans≡<ᵣ _ _ _ (sym (-ᵣ· _ _) ∙
+--        cong₂ _·ᵣ_ (-[x-y]≡y-x _ _ ∙ cong₂ _-ᵣ_
+--                     (cong fst (cong (invℝ₊ z ^ℚ_) (sym (ℚ.-Invol _)) ∙ sym (^ℚ-minus _ _)))
+--                     (cong fst (cong (invℝ₊ z ^ℚ_) (sym (ℚ.-Invol _)) ∙ sym (^ℚ-minus _ _))))
+--                   (sym (invℝ₊-rat B)
+--                    ∙ cong (fst ∘ invℝ₊ ∘ ℚ₊→ℝ₊)
+--                      (ℚ₊≡ ((sym (ℚ.·IdL _) ∙ ℚ.·DistR+ 2 -1 (fst B))
+--                       ∙ cong (ℚ._+ (ℚ.- fst B)) (sym (ℚ.-Invol _))
+--                       ∙ ℚ.+Comm _ _))) )
+--       (slope-monotone-strict z 1<z
+--         (ℚ.- (2 ℚ.· fst B)) (ℚ.- (fst B))
+--           x y -2B<-B x<y
+--             (ℚ.isTrans≤ _ _ _ (ℚ.<Weaken≤ _ _ -2B<-B) -B≤x)
+--             (ℚ.isTrans≤< _ _ _ -B≤x x<y))
+
+--   ineq : ∀ x y → y ℚ.≤ fst B → x ℚ.≤ y →
+--            (fst (z ^ℚ y) -ᵣ fst (z ^ℚ x)) ≤ᵣ
+--               bound z B ·ᵣ rat (y ℚ.- x)
+--   ineq x y y≤B = ⊎.rec
+--     (λ x≡y → ≡ᵣWeaken≤ᵣ _ _
+--       (𝐑'.+InvR' _ _ (cong (fst ∘ z ^ℚ_) (sym x≡y))
+--         ∙∙ sym (𝐑'.0RightAnnihilates (bound z B)) ∙∙
+--         cong (bound z B ·ᵣ_) (cong rat (sym (𝐐'.+InvR' _ _ (sym x≡y))))))
+--     (<ᵣWeaken≤ᵣ _ _ ∘ ineqStrict x y y≤B )
+--     ∘ ℚ.≤→≡⊎< x y
+
+
+
+--   ineqInv : ∀ x y → (ℚ.- (fst B)) ℚ.≤ x → x ℚ.≤ y →
+--                 (-ᵣ (bound (invℝ₊ z) B)) ·ᵣ rat (y ℚ.- x) ≤ᵣ  (fst (z ^ℚ y) -ᵣ fst (z ^ℚ x))
+--   ineqInv x y -B≤x =
+--     ⊎.rec
+--       (λ x≡y → ≡ᵣWeaken≤ᵣ _ _
+--          (cong (-ᵣ bound (invℝ₊ z) B ·ᵣ_) (cong rat (𝐐'.+InvR' y x (sym x≡y))) ∙∙
+--            𝐑'.0RightAnnihilates (-ᵣ bound (invℝ₊ z) B) ∙∙
+--             (sym (𝐑'.+InvR' (fst (z ^ℚ y)) (fst (z ^ℚ x))
+--              (cong (fst ∘ (z ^ℚ_)) (sym x≡y))) )))
+--       (<ᵣWeaken≤ᵣ _ _ ∘ ineqStrictInv x y -B≤x)
+--      ∘ ℚ.≤→≡⊎< x y
+
+--   opaque
+--    unfolding -ᵣ_ absᵣ
+--    ineq-abs : ∀ x y → x ℚ.≤ fst B → y ℚ.≤ fst B →
+--             absᵣ (fst (z ^ℚ y) -ᵣ fst (z ^ℚ x)) ≤ᵣ
+--                bound z B ·ᵣ rat (ℚ.abs' (y ℚ.- x))
+--    ineq-abs x y x≤B y≤B = w (ℚ.≡⊎# x y)
+
+--     where
+--     w : (x ≡ y) ⊎ (x ℚ.# y) → absᵣ (fst (z ^ℚ y) -ᵣ fst (z ^ℚ x)) ≤ᵣ
+--                bound z B ·ᵣ rat (ℚ.abs' (y ℚ.- x))
+--     w (inl x≡y) =
+--       ≡ᵣWeaken≤ᵣ _ _
+--        (cong absᵣ (𝐑'.+InvR' _ _ (cong (fst ∘ z ^ℚ_) (sym x≡y)))
+--          ∙∙ sym (𝐑'.0RightAnnihilates (bound z B)) ∙∙
+--          cong (bound z B ·ᵣ_)
+--           (cong (rat ∘ ℚ.abs') (sym (𝐐'.+InvR' _ _ (sym x≡y))))
+--           )
+--     w (inr (inl x<y)) = <ᵣWeaken≤ᵣ _ _ (isTrans<≡ᵣ _ _ _ (isTrans≡<ᵣ _ _ _
+--           (absᵣNonNeg _ (x≤y→0≤y-x _ _ (^ℚ-MonotoneR x y
+--              (ℚ.<Weaken≤ _ _ x<y)
+--             (<ᵣWeaken≤ᵣ _ _ 1<z))))
+--            (ineqStrict x y y≤B x<y))
+--          (cong (bound z B ·ᵣ_)
+--           (cong rat (sym (ℚ.absPos _ (ℚ.-< _ _ x<y)) ∙ ℚ.abs'≡abs _))))
+--     w (inr (inr y<x)) =
+--       <ᵣWeaken≤ᵣ _ _ (isTrans<≡ᵣ _ _ _ (isTrans≡<ᵣ _ _ _
+--           (minusComm-absᵣ _ _ ∙
+--            absᵣPos _ (x<y→0<y-x _ _ (^ℚ-StrictMonotoneR 1<z y x y<x)))
+--            (ineqStrict y x x≤B y<x))
+--          (cong (bound z B ·ᵣ_)
+--           (cong rat ((sym (ℚ.-[x-y]≡y-x _ _) ∙ sym (ℚ.absNeg _
+--             (subst ((y ℚ.- x) ℚ.<_)
+--               (ℚ.+InvR _) (ℚ.<-+o _ _ (ℚ.- x) y<x)))) ∙ ℚ.abs'≡abs _))))
+
+--   ineqInv-abs : ∀ x y → (ℚ.- (fst B)) ℚ.≤ x → (ℚ.- (fst B)) ℚ.≤ y →
+--                 (-ᵣ (bound (invℝ₊ z) B)) ·ᵣ rat (ℚ.abs (y ℚ.- x)) ≤ᵣ
+--                     absᵣ (fst (z ^ℚ y) -ᵣ fst (z ^ℚ x))
+--   ineqInv-abs = ℚ.elimBy≤ (λ x y X u v →
+--     subst2 (λ a b → (-ᵣ (bound (invℝ₊ z) B)) ·ᵣ rat a ≤ᵣ b)
+--                     (ℚ.absComm- _ _) (minusComm-absᵣ _ _) (X v u))
+--      λ x y x≤y x≤ _ →
+--         subst2 (λ a b → (-ᵣ (bound (invℝ₊ z) B)) ·ᵣ rat a ≤ᵣ b)
+--           (sym (ℚ.absNonNeg _ (ℚ.-≤ _ _ x≤y)))
+--            (sym (absᵣNonNeg _ (x≤y→0≤y-x _ _ (^ℚ-MonotoneR _ _ x≤y (<ᵣWeaken≤ᵣ _ _ 1<z) ))))
+--            (ineqInv x y x≤ x≤y)
diff --git a/Cubical/HITs/CauchyReals/ExponentiationDer.agda b/Cubical/HITs/CauchyReals/ExponentiationDer.agda
new file mode 100644
index 0000000000..43c2e41db0
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/ExponentiationDer.agda
@@ -0,0 +1,1584 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.ExponentiationDer where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Equiv.Properties
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Powerset
+open import Cubical.Foundations.Transport
+
+open import Cubical.Functions.FunExtEquiv
+
+open import Cubical.Relation.Nullary
+
+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.Data.Unit
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.HITs.SetQuotients as SQ hiding (_/_)
+
+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
+open import Cubical.HITs.CauchyReals.Sequence
+open import Cubical.HITs.CauchyReals.Bisect
+open import Cubical.HITs.CauchyReals.NthRoot
+open import Cubical.HITs.CauchyReals.Derivative
+
+open import Cubical.HITs.CauchyReals.Exponentiation
+
+import Cubical.Algebra.CommRing.Instances.Int as ℤCRing
+open import Cubical.Algebra.Ring.Properties
+open import Cubical.Algebra.Group
+open import Cubical.Algebra.Group.Morphisms
+open import Cubical.Algebra.Group.MorphismProperties
+import Cubical.Algebra.CommRing as CR
+import Cubical.Algebra.CommRing.Properties as CR
+
+module L𝐙 = Lems ℤCRing.ℤCommRing
+module 𝐙' = RingTheory (CR.CommRing→Ring ℤCRing.ℤCommRing )
+
+
+
+slopeMonotone^ : (n : ℕ) (a b a' b' : ℝ₊)
+  → (a<b : fst a <ᵣ fst b) → (a'<b' : fst a' <ᵣ fst b')
+  → (a≤a' : fst a ≤ᵣ fst a') →  (b≤b' : fst b ≤ᵣ fst b') →
+  (((fst b ^ⁿ n) -ᵣ (fst a ^ⁿ n))
+    ／ᵣ₊ (_ , x<y→0<y-x _ _ a<b ))
+      ≤ᵣ
+  (((fst b' ^ⁿ n) -ᵣ (fst a' ^ⁿ n))
+    ／ᵣ₊ (_ , x<y→0<y-x _ _ a'<b' ))
+slopeMonotone^ zero a b a' b' a<b a'<b' a≤a' b≤b' =
+  ≡ᵣWeaken≤ᵣ _ _
+    ((𝐑'.0LeftAnnihilates' _ _ (+-ᵣ _))
+    ∙ sym (𝐑'.0LeftAnnihilates' _ _ (+-ᵣ _)))
+slopeMonotone^ (suc zero) a b a' b' a<b a'<b' a≤a' b≤b' =
+  ≡ᵣWeaken≤ᵣ _ _
+    ((cong (_／ᵣ₊ (_ , x<y→0<y-x _ _ a<b )) (cong₂ _-ᵣ_ (·IdL _) (·IdL _))
+      ∙ x·invℝ₊[x] _)
+     ∙ sym (x·invℝ₊[x] _) ∙ (cong (_／ᵣ₊ (_ , x<y→0<y-x _ _ a'<b' ))
+       (sym ((cong₂ _-ᵣ_ (·IdL _) (·IdL _))))))
+slopeMonotone^ (suc (suc N)) a b a' b' a<b a'<b' a≤a' b≤b' =
+   subst2 _≤ᵣ_
+     (sym ([x·yᵣ]/₊y _ (_ , x<y→0<y-x _ _ a<b ))
+       ∙ cong (_／ᵣ₊ (_ , x<y→0<y-x _ _ a<b )) (·ᵣComm _ _ ∙ fa.[b-a]·S≡bⁿ-aⁿ))
+     (sym ([x·yᵣ]/₊y _ (_ , x<y→0<y-x _ _ a'<b'))
+       ∙ cong (_／ᵣ₊ (_ , x<y→0<y-x _ _ a'<b' )) (·ᵣComm _ _ ∙ fa'.[b-a]·S≡bⁿ-aⁿ))
+     (Seq≤→Σ≤-upto
+       (geometricProgression _ fa.r)
+       (geometricProgression _ fa'.r)
+       (suc (suc N))
+       w)
+ where
+ open bⁿ-aⁿ N
+ module fa = factor (fst a) (fst b) (snd a) (snd b)
+ module fa' = factor (fst a') (fst b') (snd a') (snd b')
+
+ w : (n₁ : ℕ) → n₁ ℕ.< suc (suc N) →
+      geometricProgression (fst b ^ⁿ (suc N)) (fst a ／ᵣ[ fst b , _ ]) n₁ ≤ᵣ
+      geometricProgression (fst b' ^ⁿ (suc N)) (fst a' ／ᵣ[ fst b' , _ ]) n₁
+ w n x =
+  let (m , p) = ℕ.predℕ-≤-predℕ x
+  in subst2 _≤ᵣ_ -- ^ℕ-+
+    ((cong₂ _·ᵣ_ refl (sym ([x/y]·yᵣ _ _ (inl (0<x^ⁿ _ _ (snd b))))
+     ∙ ·ᵣComm _ _) ∙ ·ᵣAssoc _ _ _)
+      ∙ cong₂ _·ᵣ_
+          ((cong fst (^ℕ-+ b _ _) ∙ cong ((fst b) ^ⁿ_) (p)))
+          (／^ⁿ _ _ _ _ _)
+      ∙ sym (geometricProgressionClosed _ _ _))
+    ((cong₂ _·ᵣ_ refl (sym ([x/y]·yᵣ _ _ (inl (0<x^ⁿ _ _ (snd b'))))
+     ∙ ·ᵣComm _ _) ∙ ·ᵣAssoc _ _ _)
+      ∙ cong₂ _·ᵣ_
+          ((cong fst (^ℕ-+ b' _ _) ∙ cong ((fst b') ^ⁿ_) (p)))
+          (／^ⁿ _ _ _ _ _)
+      ∙ sym (geometricProgressionClosed _ _ _))
+    (≤ᵣ₊Monotone·ᵣ _ _ _ _
+      (<ᵣWeaken≤ᵣ _ _ (0<x^ⁿ _ _ (snd b')))
+      (<ᵣWeaken≤ᵣ _ _ (0<x^ⁿ _ _ (snd a)))
+      (^ⁿ-Monotone _ (<ᵣWeaken≤ᵣ _ _ (snd b)) b≤b')
+       (^ⁿ-Monotone _ (<ᵣWeaken≤ᵣ _ _ (snd a)) a≤a') )
+
+slope-monotone-ₙ√ : (n : ℕ) (a b a' b' : ℝ₊)
+  → (a<b : fst a <ᵣ fst b) → (a'<b' : fst a' <ᵣ fst b')
+  → (a≤a' : fst a ≤ᵣ fst a') →  (b≤b' : fst b ≤ᵣ fst b') →
+  ((fst (root (1+ n) b') -ᵣ fst (root (1+ n) a'))
+    ／ᵣ₊ (_ , x<y→0<y-x _ _ a'<b' ))
+      ≤ᵣ
+  ((fst (root (1+ n) b) -ᵣ fst (root (1+ n) a))
+    ／ᵣ₊ (_ , x<y→0<y-x _ _ a<b ))
+slope-monotone-ₙ√ n a b a' b' a<b a'<b' a≤a' b≤b' =
+  fst (x/y≤x'/y'≃y'/x'≤y/x _ _ _ _) $
+   subst2 _≤ᵣ_
+    ((cong₂ _·ᵣ_ (cong₂ _-ᵣ_
+      (cong fst (Iso.rightInv (nth-pow-root-iso (1+ n)) _))
+     (cong fst (Iso.rightInv (nth-pow-root-iso (1+ n)) _))) refl))
+    (cong₂ _·ᵣ_ (cong₂ _-ᵣ_
+     (cong fst (Iso.rightInv (nth-pow-root-iso (1+ n)) _))
+     (cong fst (Iso.rightInv (nth-pow-root-iso (1+ n)) _))) refl)
+    $ slopeMonotone^ (suc n)
+     ((root (1+ n) a)) ((root (1+ n) b)) ((root (1+ n) a')) ((root (1+ n) b'))
+    (ₙ√-StrictMonotone (1+ n) a<b)
+      (ₙ√-StrictMonotone (1+ n) a'<b')
+       (ₙ√-Monotone {a} {a'} (1+ n) a≤a')
+       ((ₙ√-Monotone {b} {b'} (1+ n) b≤b'))
+
+
+cauchySequenceSpeedup : ∀ s
+    → (ics : IsCauchySequence' s)
+    → (spd : ℚ₊ → ℕ)
+    → (∀ ε → fst (ics ε) ℕ.≤ spd ε)
+
+    → IsCauchySequence' s
+cauchySequenceSpeedup s  ics spd ≤spd ε =
+ let (N , X) = ics ε
+ in spd ε ,
+     λ m n spdN<n spdN<m →
+
+        X m n (ℕ.≤<-trans (≤spd ε) spdN<n)
+               (ℕ.≤<-trans (≤spd ε) spdN<m)
+opaque
+ unfolding _≤ᵣ_
+ cauchySequenceSpeedup≡ : ∀ s ics spd ≤spd →
+   fromCauchySequence' s ics ≡
+    fromCauchySequence' s (cauchySequenceSpeedup s ics spd ≤spd   )
+ cauchySequenceSpeedup≡ s ics spd ≤spd =
+   fromCauchySequence'-≡-lem _ _ _
+
+ fromCauchySequence'≤ : ∀ s ics s' ics'
+   → (∀ n → s n ≤ᵣ s' n)
+   → fromCauchySequence' s ics ≤ᵣ fromCauchySequence' s' ics'
+ fromCauchySequence'≤ s ics s' ics' x =
+   cong₂ maxᵣ
+      (cauchySequenceSpeedup≡ s  ics
+         (λ ε → ℕ.max (ℕ.max (fst (ics ε)) (fst (ics' ε))) ((fst (ics' (2 ℚ₊· ε)))))
+           λ ε → ℕ.≤-trans ℕ.left-≤-max ℕ.left-≤-max)
+      (cauchySequenceSpeedup≡ s' ics'
+         ((λ ε → ℕ.max (ℕ.max (fst (ics ε)) (fst (ics' ε))) ((fst (ics' (2 ℚ₊· ε))))))
+           λ ε → ℕ.≤-trans ℕ.right-≤-max ℕ.left-≤-max) ∙
+   snd (NonExpanding₂.β-lim-lim/2 maxR _ _ _ _) ∙
+     (congLim _ _ _ _
+      λ q →  x (suc (fastS q)))
+      ∙
+       sym (cauchySequenceSpeedup≡ s' ics'
+         fastS λ ε → subst (ℕ._≤ fastS ε) (cong (fst ∘ ics')
+           ((ℚ₊≡ (cong (2 ℚ.·_) (ℚ.·Comm _ _) ∙ ℚ.y·[x/y] 2 _)))) ℕ.right-≤-max)
+
+  where
+   fastS : ℚ₊ → ℕ
+   fastS ε = ℕ.max (ℕ.max (fst (ics (/2₊ ε)))
+        (fst (ics' (/2₊ ε))))
+               (fst (ics' (2 ℚ₊· /2₊ ε)))
+
+·-limℙ : ∀ P x f g F G
+        → at x limitOfℙ P , f is F
+        → at x limitOfℙ P , g is G
+        → at x limitOfℙ P , (λ r x₁ x₂ → f r x₁ x₂ ·ᵣ g r x₁ x₂) is (F ·ᵣ G)
+·-limℙ P x f g F G fL gL ε =
+  PT.map3 w (fL (ε'f)) (gL (ε'g)) (gL 1)
+
+ where
+
+ ε'f : ℝ₊
+ ε'f = (ε ₊／ᵣ₊ 2) ₊／ᵣ₊ (1 +ᵣ absᵣ G ,
+          isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _)) (<≤ᵣMonotone+ᵣ 0 1 0 (absᵣ G) decℚ<ᵣ? (0≤absᵣ G)))
+
+ ε'g : ℝ₊
+ ε'g = (ε ₊／ᵣ₊ 2) ₊／ᵣ₊ (1 +ᵣ absᵣ F ,
+          isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _)) (<≤ᵣMonotone+ᵣ 0 1 0 (absᵣ F) decℚ<ᵣ? (0≤absᵣ F)))
+
+
+ w : _
+ w (δ , p) (δ' , p') (δ'' , p'') = δ* , ww
+
+  where
+
+   f·g : ∀ r → _ → _ → ℝ
+   f·g r x₁ x₂ = f r x₁ x₂ ·ᵣ g r x₁ x₂
+
+   δ* : ℝ₊
+   δ* = minᵣ₊ (minᵣ₊ δ δ') δ''
+
+   ww : ∀ (r : ℝ) (r∈ : r ∈ P) (x＃r : x ＃ r) →
+          absᵣ (x -ᵣ r) <ᵣ fst δ* →
+          absᵣ (F ·ᵣ G -ᵣ (f·g) r r∈ x＃r) <ᵣ fst ε
+   ww r 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 r∈ x＃r x₁'
+      u' = p' r r∈ x＃r x₁''
+      u'' = p'' r r∈ x＃r x₁'''
+      gx< : absᵣ (g r r∈ x＃r) <ᵣ 1 +ᵣ absᵣ G
+      gx< =
+         subst (_<ᵣ (1 +ᵣ absᵣ G))
+            (cong absᵣ (sym (L𝐑.lem--035)))
+
+           (isTrans≤<ᵣ _ _ _
+             (absᵣ-triangle ((g r 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 (isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _)) 0<1+g)))) ∙
+              ·ᵣAssoc _ _ _)
+            (cong ((1 +ᵣ absᵣ F) ·ᵣ_)
+              (cong ((fst (ε ₊／ᵣ₊ 2)) ·ᵣ_)
+               (invℝ≡ _ _ _)
+               ∙ ·ᵣComm  (fst (ε ₊／ᵣ₊ 2))
+              (invℝ (1 +ᵣ absᵣ F)
+                  (inl (isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _)) 0<1+f)))) ∙
+               ·ᵣAssoc _ _ _) ∙
+            sym (·DistR+ _ _ (fst (ε ₊／ᵣ₊ 2)))
+             ∙∙ cong {y = 2} (_·ᵣ (fst (ε ₊／ᵣ₊ 2)))
+                             (cong₂ _+ᵣ_
+                                 (x·invℝ[x] (1 +ᵣ absᵣ G)
+                                   (inl (isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _)) 0<1+g)))
+                                 (x·invℝ[x] (1 +ᵣ absᵣ F)
+                                   (inl (isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _)) 0<1+f)))
+                                   ∙ +ᵣ-rat _ _
+                                )
+                        ∙∙ ·ᵣComm 2 (fst (ε ₊／ᵣ₊ 2))  ∙
+                          [x/y]·yᵣ (fst ε) _ (inl _))
+
+
+IsContinuousLimΔℙ : ∀ P f x x∈ → IsContinuousWithPred P f →
+                    at 0 limitOfℙ (P ∘S (x +ᵣ_))  ,
+                     (λ Δx x∈ _ → f (x +ᵣ Δx) x∈) is (f x x∈)
+IsContinuousLimΔℙ P f x x∈ cx =
+  let z = IsContinuousLimℙ (P ∘S (x +ᵣ_)) _ 0
+           (subst (fst ∘ P) (sym (+IdR _)) x∈)
+            (IsContinuousWP∘ _ _ _ _ (λ _ x → x)
+              cx (AsContinuousWithPred _ _ (IsContinuous+ᵣL x)))
+  in subst2 (at (rat [ pos zero / 1+ zero ]) limitOfℙ (P ∘S (x +ᵣ_))  ,_is_)
+         refl (cong₂ f ((+IdR _)) (toPathP ((snd (P _)) _ _ ))) z
+
+
+chainRuleIncrℙ : ∀ x f f'gx g g'x
+        → (gPos : ∀ x x∈ → 0 <ᵣ g x x∈)
+        → (∀ x x∈ y y∈ → x <ᵣ y → g x x∈ <ᵣ g y y∈)
+        → IsContinuousWithPred pred0< g
+        → derivativeOfℙ pred0< , g at x is g'x
+         → derivativeOfℙ pred0< , f at (g (fst x) (snd x) , gPos _ _) is f'gx
+        → derivativeOfℙ pred0< ,
+           (λ r r∈ → f (g r r∈) (gPos _ _)) at x is (f'gx ·ᵣ g'x)
+
+chainRuleIncrℙ x₊@(x , 0<x) f f'gx g g'x gPos incrG gC gD fD =
+
+  let z = ·-limℙ _ _ _ _ _ _ w gD
+  in subst (at (rat [ pos zero / 1+ zero ])
+       limitOfℙ (pred0< ∘S (x +ᵣ_)) ,_is (f'gx ·ᵣ g'x))
+      (funExt₃ λ x₁ y z₁ → sym (x/y=x/z·z/y _ _ _ _ _))
+       z
+
+
+ where
+ 0#g : ∀ h → ∀ h∈ → (0＃h : 0 ＃ h) → 0 ＃ (g (x +ᵣ h) h∈ -ᵣ g x 0<x)
+ 0#g h h∈ =
+   ⊎.map ((x<y→0<y-x _ _ ∘S incrG _ _ _ _)
+           ∘S subst (_<ᵣ (x +ᵣ h)) (+IdR x) ∘S <ᵣ-o+ _ _ x)
+            (((x<y→x-y<0 _ _ ∘S incrG _ _ _ _)
+           ∘S subst ((x +ᵣ h) <ᵣ_) (+IdR x) ∘S <ᵣ-o+ _ _ x))
+
+ w' :   ∀ (ε : ℝ₊) → ∃[ δ ∈ ℝ₊ ]
+        (∀ h h∈ 0＃h →
+           absᵣ (0 -ᵣ h) <ᵣ fst δ →
+             absᵣ (f'gx -ᵣ ((f (g (x) 0<x  +ᵣ h) h∈ -ᵣ f (g x 0<x) (gPos x 0<x))
+           ／ᵣ[ (h) , 0＃h ])) <ᵣ fst ε)
+
+ w' = fD
+
+ w : at 0 limitOfℙ _ ,
+        (λ h h∈ 0＃h → (f (g (x +ᵣ h) h∈) (gPos _ _) -ᵣ f (g x 0<x) (gPos _ _))
+           ／ᵣ[ (g (x +ᵣ h) h∈ -ᵣ g x 0<x) , 0#g h h∈ 0＃h ]) is f'gx
+ w ε =
+   PT.rec squash₁
+     (λ (δ , X) →
+         PT.map  (map-snd
+            λ X* r r∈ ＃r <a →
+              let Δg<δ = isTrans≡<ᵣ _ _ _
+                     (cong absᵣ (+IdL _ ∙ -[x-y]≡y-x _ _))
+                    (X* r r∈ ＃r <a)
+                  z = X ((g (x +ᵣ r) r∈ -ᵣ g x 0<x))
+                      (subst-∈ pred0< (sym L𝐑.lem--05 ) (gPos _ _))
+                       (0#g _ _ ＃r) Δg<δ
+              in isTrans≡<ᵣ _ _ _
+                   (cong (λ xx →
+                       absᵣ (f'gx -ᵣ
+                         ((xx -ᵣ f (g x 0<x) (gPos x 0<x))
+                          ／ᵣ[ g (x +ᵣ r) r∈ -ᵣ g x 0<x , 0#g r r∈ ＃r ])
+                       ))
+                     (cong (uncurry f)
+                       (Σ≡Prop (snd ∘ pred0<) (sym L𝐑.lem--05))) )
+                   z)
+           (IsContinuousLimΔℙ _ _ x 0<x gC δ))
+
+     (w' ε)
+
+
+preMapLimitPos : ∀ P Q x x' f g y →
+   (u : ∀ r r∈ ＃r →  g r r∈ ＃r ∈ Q)
+   (v : ∀ r r∈ ＃r → x' ＃ g r r∈ ＃r)
+  → at x  limitOfℙ P , g is x'
+  → at x' limitOfℙ Q , f is y
+  → at x  limitOfℙ P ,
+   (λ r r∈ ＃r → f (g r r∈ ＃r) (u _ _ _) (v _ _ _ )) is y
+preMapLimitPos _ _ _ _ _ _ _ _ _ gL =
+  PT.rec squash₁
+    (λ (δ , X) →
+      PT.rec squash₁
+       (λ (δ' , X') →
+         ∣ δ' , (λ _ _ _ uu →
+           let vv = X' _ _ _ uu
+           in X _ _ _ vv) ∣₁)
+       (gL δ)) ∘_
+
+
+mapLimitPos' : ∀ x P Q f g y y∈ → (f∈ : ∀ r r∈ x＃ → f r r∈ x＃ ∈ Q)
+  → IsContinuousWithPred Q g
+  → at x limitOfℙ P , f is y
+  → at x limitOfℙ P , (λ r r∈ x＃ → g (f r r∈ x＃) (f∈ _ _ _)) is
+      g y y∈
+mapLimitPos' x P Q f g y y∈ f∈ gC fL (ε , 0<ε) =
+    PT.rec squash₁
+    (λ (q , 0<q , q<ε) →
+     let q₊ = (q , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<q))
+     in PT.rec squash₁
+         (λ (δ' , D') →
+            PT.rec squash₁
+              (λ (δ , D) →
+                ∣ minᵣ₊ (ℚ₊→ℝ₊ δ') δ ,
+                    (λ r r∈ x＃r x-r<δ →
+                       let uu = D r r∈ x＃r
+                                  (isTrans<≤ᵣ _ _ _ x-r<δ
+                                    (min≤ᵣ' (rat (fst δ')) _))
+                           uu' = D' (f r r∈ x＃r) (f∈ r r∈ x＃r)
+                                 (invEq (∼≃abs<ε _ _ _) uu)
+                       in  isTrans<ᵣ _ _ _
+                            (fst (∼≃abs<ε _ _ _) uu')
+                            q<ε) ∣₁)
+              (fL (ℚ₊→ℝ₊ (δ'))))
+         (gC y (q₊) y∈))
+   (denseℚinℝ _ _ 0<ε)
+
+
+
+invDerivativeℙPos-temp : ∀ x f f' f'Pos (fPos : ∀ x 0<x → 0 <ᵣ f x 0<x )
+  → (isEquivF : isEquiv {A = ℝ × Unit} {B = ℝ₊}
+       λ x → f (fst x) (snd x) , fPos (fst x) (snd x) )
+   → (∀ x y → fst x <ᵣ fst y →
+       fst (invEq (_ , isEquivF) x) <ᵣ fst (invEq (_ , isEquivF) y))
+   → (∀ x y → fst x <ᵣ fst y →
+       (f (fst x) (snd x)) <ᵣ (f (fst y) (snd y)))
+       → IsContinuousWithPred ⊤Pred f
+  → IsContinuousWithPred pred0< (λ x x∈ → fst (invEq (_ , isEquivF) (x , x∈)))
+  → derivativeOfℙ ⊤Pred , f at x is f'
+  → derivativeOfℙ pred0< , (λ r 0<r →
+       fst (invEq (_ , isEquivF) (r , 0<r)))
+         at f (fst x) (snd x) , fPos _ _
+       is fst (invℝ₊ (f' , f'Pos))
+invDerivativeℙPos-temp x f f' f'Pos fPos isEquivF incrG incrF  fC gC dF =
+  subst
+    (uncurry (at (rat [ pos zero / 1+ zero ]) limitOfℙ_,_is
+      fst (invℝ₊ (f' , f'Pos)) ))
+    (ΣPathP (refl , funExt₃
+      pp)) d''
+  where
+
+  e : _ ≃ _
+  e = (_ , isEquivF)
+
+  g = invEq e
+
+  y = f (fst x) (snd x)
+
+
+
+  h'' : (r : ℝ) → r ∈ (λ x₁ → pred0< (y +ᵣ x₁)) → ℝ
+  h'' h h∈  = fst (g (_ , h∈)) -ᵣ fst x
+
+
+  h' : (r : ℝ) → r ∈ (λ x₁ → pred0< (y +ᵣ x₁)) → 0 ＃ r → ℝ
+  h' h h∈ _ = h'' h h∈
+
+
+
+  uu : (r : ℝ) (r∈ : r ∈ (λ x₂ → pred0< (y +ᵣ x₂))) (＃r : 0 ＃ r) →
+        h' r r∈ ＃r ∈ (λ x₂ → ⊤Pred (x .fst +ᵣ x₂))
+  uu _ r∈ _ = tt
+
+  vv : (r : ℝ) (r∈ : r ∈ (λ x₂ → pred0< (y +ᵣ x₂))) (＃r : 0 ＃ r) →
+        0 ＃ h' r r∈ ＃r
+  vv r r∈ = ⊎.elim
+    (inl ∘ λ p → x<y→0<y-x _ _ (isTrans≡<ᵣ _ _ _
+     (sym (cong fst (retEq e _)))
+     (incrG (y , fPos _ _) _ (isTrans≡<ᵣ _ _ _ (sym (+IdR _))
+       ((<ᵣ-o+ 0 _ y p))))) )
+    (inr ∘ λ p →
+      (x<y→x-y<0 _ _ (isTrans<≡ᵣ _ _ _
+       (incrG _ _ (isTrans<≡ᵣ _ _ _ (<ᵣ-o+ _ 0 y p) (+IdR _)))
+         (cong fst (retEq e _)))) )
+
+  h-lim : at 0 limitOfℙ (λ x₁ → pred0< (y +ᵣ x₁)) , (λ h h∈ _ → h'' h h∈) is 0
+  h-lim = subst (at _ limitOfℙ _ , h' is_) (𝐑'.+InvR' _ _
+      (cong (fst ∘ invEq e) (ℝ₊≡ (+IdR y)) ∙ cong fst (retEq e _)))
+    (IsContinuousLimℙ (λ x₁ → pred0< (y +ᵣ x₁)) h'' 0
+      (isTrans<≡ᵣ _ _ _ (fPos (fst x) (snd x)) (sym (+IdR _)))
+
+      (IsContinuousWP∘ ⊤Pred _ _ _ _
+        (AsContinuousWithPred _ _ (IsContinuous+ᵣR (-ᵣ fst x)))
+          (IsContinuousWP∘ _ _
+               _ _ _ gC
+           (AsContinuousWithPred _ _ (IsContinuous+ᵣL y ))))
+           )
+
+  d' : at 0 limitOfℙ (λ x₁ → pred0< (y +ᵣ x₁)) ,
+        (λ r r∈ ＃r →
+           differenceAtℙ ⊤Pred f (x .fst) (h' r r∈ ＃r) (vv r r∈ ＃r) (x .snd)
+           (uu r r∈ ＃r))
+        is f'
+  d' = preMapLimitPos _ _ _ _ _
+     h'
+     f'
+     uu vv
+      h-lim dF
+
+
+  h''-pos : (r : ℝ) (r∈ : r ∈ (λ x₁ → pred0< (f (fst x) (snd x) +ᵣ x₁)))
+              (x＃ : 0 ＃ r) →
+             0 <ᵣ differenceAtℙ ⊤Pred f (x .fst) (h' r r∈ x＃)
+               _ (x .snd) _
+  h''-pos r r∈ x＃ = incr→0<differenceAtℙ _ _ _ _ _ _ _
+   λ _ _ _ _ → incrF _ _
+
+
+  d'' :
+   at 0 limitOfℙ pred0< ∘S (y +ᵣ_) ,
+       (λ r z z₁ →
+          invℝ' .fst
+          (differenceAtℙ ⊤Pred f (x .fst) (h' r z z₁) _ (x .snd) _)
+          (h''-pos r z z₁))
+         is (fst (invℝ₊ (f' , f'Pos)) )
+  d'' = mapLimitPos' _ _ _ _ _ f'
+        f'Pos
+        h''-pos
+        (snd invℝ')
+        d'
+
+
+  pp : ∀ x' u v → fst (invℝ₊ (_ , _))
+                   ≡ differenceAtℙ pred0< _
+                      _ x' v (fPos (fst x) (snd x)) u
+  pp x' u v =
+    cong {x = _ , uuu} (fst ∘ invℝ₊)
+       (ℝ₊≡ (sym (absᵣPos _ uuu) ∙ ·absᵣ _ _))
+      ∙ (cong fst (invℝ₊· (absᵣ _ , 0＃→0<abs _ zz)
+          (_ , 0＃→0<abs _ (invℝ0＃ _ _))) ∙
+       cong₂ _·ᵣ_
+          (cong (fst ∘ invℝ₊) (ℝ₊≡ (cong absᵣ zzz))
+            ∙ sym (absᵣ-invℝ _ _))
+          (sym (absᵣ-invℝ _ _)
+           ∙ cong absᵣ (invℝInvol _ _  ∙
+            cong₂ _-ᵣ_ refl (cong fst (sym (retEq e _))))
+             ))
+       ∙ ·ᵣComm _ _ ∙ sym (·absᵣ _ _) ∙ (absᵣPos _
+        (incr→0<differenceAtℙ _ _ _ _ _ _ _
+         λ _ _ _ _ → incrG _ _))
+   where -- ·absᵣ _ _
+   uuu = _
+
+   qq : f (x .fst +ᵣ h' x' u v) (uu x' u v) ≡ y +ᵣ x'
+   qq = cong₂ f (L𝐑.lem--05) (toPathP refl)
+         ∙ cong fst (secEq e _)
+
+
+   zzz : f (x .fst +ᵣ h' x' u v) (uu x' u v) -ᵣ f (x .fst) (x .snd)
+              ≡ x'
+   zzz = cong (_-ᵣ f (x .fst) (x .snd)) qq ∙ L𝐑.lem--063
+
+
+   zz : 0 ＃ ((f (x .fst +ᵣ h' x' u v) (uu x' u v)) -ᵣ f (x .fst) (x .snd))
+   zz = subst (0 ＃_) (sym zzz) v
+
+
+invDerivativeℙ : ∀ x (f : ℝ → ℝ) f' f'Pos (fPos : ∀ x → 0 <ᵣ f x)
+  → (isEquivF : isEquiv {A = ℝ} {B = ℝ₊} λ x → f x  , fPos x)
+   → (∀ x y → fst x <ᵣ fst y →
+       (invEq (_ , isEquivF) x) <ᵣ (invEq (_ , isEquivF) y))
+   → (∀ x y → x <ᵣ y →  (f x) <ᵣ (f y)) → IsContinuous f
+  → IsContinuousWithPred pred0< (λ x x∈ → (invEq (_ , isEquivF) (x , x∈)))
+  → derivativeOf f at x is f'
+  → derivativeOfℙ pred0< , (λ r 0<r →
+        (invEq (_ , isEquivF) (r , 0<r)))
+         at f x , fPos _
+       is fst (invℝ₊ (f' , f'Pos))
+invDerivativeℙ x f f' f'Pos fPos isEquivF incrG incrF  fC gC dF =
+ invDerivativeℙPos-temp
+   (x , tt)
+   (λ x _ → f x)
+   f'
+   f'Pos
+   (λ v _ → fPos v)
+   (snd (isoToEquiv rUnit×Iso ∙ₑ (_ , isEquivF)))
+   (λ x₁ y x₂ → incrG _ _ x₂)
+   (λ x₁ y x₂ → incrF _ _ x₂)
+   (AsContinuousWithPred _ _ fC)
+   gC
+   (as-derivativeOfℙ _ _ _ _ _ dF)
+
+
+invDerivativeℙPos : ∀ x f f' f'Pos (fPos : ∀ x 0<x → 0 <ᵣ f x 0<x )
+  → (isEquivF : isEquiv {A = ℝ₊} {B = ℝ₊}
+       λ x → f (fst x) (snd x) , fPos (fst x) (snd x) )
+   → (∀ x y → fst x <ᵣ fst y →
+       fst (invEq (_ , isEquivF) x) <ᵣ fst (invEq (_ , isEquivF) y))
+   → (∀ x y → fst x <ᵣ fst y →
+       (f (fst x) (snd x)) <ᵣ (f (fst y) (snd y)))
+       → IsContinuousWithPred pred0< f
+  → IsContinuousWithPred pred0< (λ x x∈ → fst (invEq (_ , isEquivF) (x , x∈)))
+  → derivativeOfℙ pred0< , f at x is f'
+  → derivativeOfℙ pred0< , (λ r 0<r →
+       fst (invEq (_ , isEquivF) (r , 0<r)))
+         at f (fst x) (snd x) , fPos _ _
+       is fst (invℝ₊ (f' , f'Pos))
+invDerivativeℙPos x f f' f'Pos fPos isEquivF incrG incrF  fC gC dF =
+  subst
+    (uncurry (at (rat [ pos zero / 1+ zero ]) limitOfℙ_,_is
+      fst (invℝ₊ (f' , f'Pos)) ))
+    (ΣPathP (refl , funExt₃
+      pp)) d''
+  where
+
+
+  e : _ ≃ _
+  e = (_ , isEquivF)
+
+  g = invEq e
+
+  y = f (fst x) (snd x)
+
+
+
+  h'' : (r : ℝ) → r ∈ (λ x₁ → pred0< (y +ᵣ x₁)) → ℝ
+  h'' h h∈  = fst (g (_ , h∈)) -ᵣ fst x
+
+
+  h' : (r : ℝ) → r ∈ (λ x₁ → pred0< (y +ᵣ x₁)) → 0 ＃ r → ℝ
+  h' h h∈ _ = h'' h h∈
+
+
+
+  uu : (r : ℝ) (r∈ : r ∈ (λ x₂ → pred0< (y +ᵣ x₂))) (＃r : 0 ＃ r) →
+        h' r r∈ ＃r ∈ (λ x₂ → pred0< (x .fst +ᵣ x₂))
+  uu _ r∈ _ =
+   isTrans<≡ᵣ _ _ _ (snd (g (_ , r∈)))
+     (sym L𝐑.lem--05)
+
+  vv : (r : ℝ) (r∈ : r ∈ (λ x₂ → pred0< (y +ᵣ x₂))) (＃r : 0 ＃ r) →
+        0 ＃ h' r r∈ ＃r
+  vv r r∈ = ⊎.elim
+    (inl ∘ λ p → x<y→0<y-x _ _ (isTrans≡<ᵣ _ _ _
+     (sym (cong fst (retEq e _)))
+     (incrG (y , fPos _ _) _ (isTrans≡<ᵣ _ _ _ (sym (+IdR _))
+       ((<ᵣ-o+ 0 _ y p))))) )
+    (inr ∘ λ p →
+      (x<y→x-y<0 _ _ (isTrans<≡ᵣ _ _ _
+       (incrG _ _ (isTrans<≡ᵣ _ _ _ (<ᵣ-o+ _ 0 y p) (+IdR _)))
+         (cong fst (retEq e _)))) )
+
+
+  h-lim : at 0 limitOfℙ (λ x₁ → pred0< (y +ᵣ x₁)) , (λ h h∈ _ → h'' h h∈) is 0
+  h-lim = subst (at _ limitOfℙ _ , h' is_) (𝐑'.+InvR' _ _
+      (cong (fst ∘ invEq e) (ℝ₊≡ (+IdR y)) ∙ cong fst (retEq e _)))
+    (IsContinuousLimℙ (λ x₁ → pred0< (y +ᵣ x₁)) h'' 0
+      (isTrans<≡ᵣ _ _ _ (fPos (fst x) (snd x)) (sym (+IdR _)))
+
+      (IsContinuousWP∘ ⊤Pred _ _ _ _
+        (AsContinuousWithPred _ _ (IsContinuous+ᵣR (-ᵣ fst x)))
+          (IsContinuousWP∘ _ _
+               _ _ _ gC
+           (AsContinuousWithPred _ _ (IsContinuous+ᵣL y ))))
+           )
+
+  d' : at 0 limitOfℙ (λ x₁ → pred0< (y +ᵣ x₁)) ,
+        (λ r r∈ ＃r →
+           differenceAtℙ pred0< f (x .fst) (h' r r∈ ＃r) (vv r r∈ ＃r) (x .snd)
+           (uu r r∈ ＃r))
+        is f'
+  d' = preMapLimitPos _ _ _ _ _
+     h'
+     f'
+     uu vv
+      h-lim dF
+
+
+  h''-pos : (r : ℝ) (r∈ : r ∈ (λ x₁ → pred0< (f (fst x) (snd x) +ᵣ x₁)))
+              (x＃ : 0 ＃ r) →
+             0 <ᵣ differenceAtℙ pred0< f (x .fst) (h' r r∈ x＃)
+               _ (x .snd) _
+  h''-pos r r∈ x＃ = incr→0<differenceAtℙ _ _ _ _ _ _ _
+   λ _ _ _ _ → incrF _ _
+
+
+  d'' :
+   at 0 limitOfℙ pred0< ∘S (y +ᵣ_) ,
+       (λ r z z₁ →
+          invℝ' .fst
+          (differenceAtℙ pred0< f (x .fst) (h' r z z₁) _ (x .snd) _)
+          (h''-pos r z z₁))
+         is (fst (invℝ₊ (f' , f'Pos)) )
+  d'' = mapLimitPos' _ _ _ _ _ f'
+        f'Pos
+        h''-pos
+        (snd invℝ')
+        d'
+
+
+  pp : ∀ x' u v → fst (invℝ₊ (_ , _))
+                   ≡ differenceAtℙ pred0< _
+                      _ x' v (fPos (fst x) (snd x)) u
+  pp x' u v =
+    cong {x = _ , uuu} (fst ∘ invℝ₊)
+       (ℝ₊≡ (sym (absᵣPos _ uuu) ∙ ·absᵣ _ _))
+      ∙ (cong fst (invℝ₊· (absᵣ _ , 0＃→0<abs _ zz)
+          (_ , 0＃→0<abs _ (invℝ0＃ _ _))) ∙
+       cong₂ _·ᵣ_
+          (cong (fst ∘ invℝ₊) (ℝ₊≡ (cong absᵣ zzz))
+            ∙ sym (absᵣ-invℝ _ _))
+          (sym (absᵣ-invℝ _ _)
+           ∙ cong absᵣ (invℝInvol _ _  ∙
+            cong₂ _-ᵣ_ refl (cong fst (sym (retEq e _))))
+             ))
+       ∙ ·ᵣComm _ _ ∙ sym (·absᵣ _ _) ∙ (absᵣPos _
+        (incr→0<differenceAtℙ _ _ _ _ _ _ _
+         λ _ _ _ _ → incrG _ _))
+   where -- ·absᵣ _ _
+   uuu = _
+
+   qq : f (x .fst +ᵣ h' x' u v) (uu x' u v) ≡ y +ᵣ x'
+   qq = cong₂ f (L𝐑.lem--05) (toPathP (isProp<ᵣ _ _ _ _))
+         ∙ cong fst (secEq e _)
+
+
+   zzz : f (x .fst +ᵣ h' x' u v) (uu x' u v) -ᵣ f (x .fst) (x .snd)
+              ≡ x'
+   zzz = cong (_-ᵣ f (x .fst) (x .snd)) qq ∙ L𝐑.lem--063
+
+
+   zz : 0 ＃ ((f (x .fst +ᵣ h' x' u v) (uu x' u v)) -ᵣ f (x .fst) (x .snd))
+   zz = subst (0 ＃_) (sym zzz) v
+
+derivative-n√ : ∀ x n →
+        derivativeOfℙ pred0< , curry (fst ∘ root (1+ n))
+                  at x is fst
+                   (invℝ₊ (fromNat (suc n) ₊·ᵣ (root (1+ n) x ₊^ⁿ n)))
+derivative-n√ x@(x' , 0<x') n = subst2
+  (derivativeOfℙ pred0< ,_at_is
+   fst (invℝ₊ (fromNat (suc n) ₊·ᵣ (root (1+ n) x ₊^ⁿ n))))
+   refl (secEq e x) w
+ where
+
+ e = isoToEquiv (nth-pow-root-iso (1+ n))
+
+ y = invEq e x
+
+ w = invDerivativeℙPos y _ _ (snd (fromNat (suc n) ₊·ᵣ (y ₊^ⁿ n)))
+       (λ x₁ 0<x → snd ((x₁ , 0<x) ₊^ⁿ (suc n)))
+       (snd e)
+       (λ _ _ → ₙ√-StrictMonotone _)
+       (λ a b  → ^ⁿ-StrictMonotone _ ℕ.zero-<-suc
+         (<ᵣWeaken≤ᵣ _ _ (snd a)) ((<ᵣWeaken≤ᵣ _ _ (snd b))))
+       (AsContinuousWithPred _ _ (IsContinuous^ⁿ _))
+       (IsContinuousRoot _ )
+       λ ε →
+         PT.map (map-snd
+             λ {a} X r _ → X r) (derivative-^ⁿ n (fst y) ε)
+
+reciporalDerivative : ∀ x f f' → (fPos : ∀ x 0<x → 0 <ᵣ f x 0<x)
+ → IsContinuousWithPred pred0< f
+ → derivativeOfℙ pred0< , f at x is f'
+ → derivativeOfℙ pred0< , (λ r 0<r → fst (invℝ₊ (f r 0<r , fPos _ _)))
+     at x is (-ᵣ (f' ／ᵣ₊ ((f (fst x) (snd x) , fPos _ _ ) ₊·ᵣ
+                       (f (fst x) (snd x) , fPos _ _ ))))
+reciporalDerivative (x , x∈) f f' fPos fC d =
+  subst2
+         {x = pp₀}
+         {y = pp₁}
+         {z = [1/f]'} (at 0 limitOfℙ pred0< ∘S (x +ᵣ_) ,_is_)
+         pp
+        (cong ((f' ·ᵣ_) ∘ -ᵣ_ ∘ fst ∘ invℝ₊)
+          (ℝ₊≡ {_ , ℝ₊· (f x x∈ , fPos x x∈) (f (x +ᵣ 0) x+0∈ , fPos _ _)}
+            {_ , _} (cong (f x x∈  ·ᵣ_)
+              (cong₂ f (+IdR x) (toPathP (isProp<ᵣ _ _ _ _)))))
+           ∙ ·-ᵣ _ _)
+            w
+ where
+ f⁻² = -ᵣ (fst (invℝ₊ ((f x x∈ , fPos _ _ ) ₊·ᵣ
+                       (f x x∈ , fPos _ _ ))))
+
+ [1/f]' = _
+
+ x+0∈ = (subst-∈ pred0< (sym (+IdR _)) x∈)
+
+ f⁻²-lim : at 0 limitOfℙ (λ x₁ → pred0< (x +ᵣ x₁)) ,
+            (λ x' x'∈ _ →
+               -ᵣ (fst
+               (invℝ₊
+                ((f x x∈ , fPos x x∈) ₊·ᵣ (f (x +ᵣ x') x'∈ , fPos (x +ᵣ x') x'∈)))))
+            is (-ᵣ (fst (invℝ₊ ((f x x∈ , fPos _ _ ) ₊·ᵣ
+                       (f (x +ᵣ 0) x+0∈
+                        , fPos _ _ )))))
+ f⁻²-lim = IsContinuousLimℙ _ _ 0 (x+0∈)
+                (IsContinuousWP∘ ⊤Pred _ _ _ _
+                  (AsContinuousWithPred _ _ IsContinuous-ᵣ)
+                    (IsContinuousWP∘ _ _ _ _ _
+                       (snd invℝ')
+                        (IsContinuousWP∘ ⊤Pred _ _ _ _
+                          (AsContinuousWithPred _ _ (IsContinuous·ᵣL _))
+                           (IsContinuousWP∘ _ _ _ _ _
+                             fC
+                             (AsContinuousWithPred _ _ (IsContinuous+ᵣL x))))))
+ pp₀ = _
+ pp₁ = _
+
+ pp : pp₀ ≡ pp₁
+ pp = funExt₃ λ _ _ _ → 𝐑.·CommAssocr _ _ _ ∙
+   cong (_·ᵣ invℝ _ _) ((·-ᵣ _ _ ∙
+     cong (-ᵣ_)
+       (cong₂ _·ᵣ_ refl (cong fst (invℝ₊· _ _))
+        ∙ 𝐑'.·DistL- (f (x +ᵣ _) _) (f x x∈) _ ∙
+        cong₂ _-ᵣ_ (·ᵣComm _ _ ∙ [x/₊y]·yᵣ _ _)
+         (·ᵣComm _ _ ∙ cong (_·ᵣ f x x∈) (·ᵣComm _ _) ∙
+           [x/₊y]·yᵣ _ _)) )
+     ∙ -[x-y]≡y-x _ _)
+
+ w : at 0 limitOfℙ pred0< ∘S (x +ᵣ_) , pp₀ is [1/f]'
+ w = ·-limℙ (pred0< ∘S (x +ᵣ_)) 0 _ _ _ _ d f⁻²-lim
+
+
+derivative-^ℤ : ∀ x k → ¬ (k ≡ 0) →
+   derivativeOfℙ pred0< , curry (fst ∘S (_^ℤ k)) at x is
+     (rat [ k / 1 ] ·ᵣ fst (x ^ℤ (k ℤ.- 1 )))
+derivative-^ℤ (x , 0<x) (pos zero) ¬k=0 = ⊥.rec (¬k=0 refl)
+derivative-^ℤ (x , 0<x) (pos (suc n)) ¬k=0  ε =
+  PT.map (map-snd
+    λ {a} X r _ → X r) (derivative-^ⁿ n x ε)
+derivative-^ℤ x₊@(x , 0<x) (ℤ.negsuc n) _ =
+  let h = reciporalDerivative (x , 0<x)
+           (λ r x₂ → fst ((r , x₂) ^ℤ pos (suc n))) _
+             (λ r x₂ → snd ((r , x₂) ^ℤ pos (suc n)))
+             (AsContinuousWithPred _ _ (IsContinuous^ⁿ _))
+             (λ ε → PT.map (map-snd
+              λ {a} X r _ → X r)
+              (derivative-^ⁿ n x ε))
+  in subst (derivativeOfℙ pred0< , _ at _ is_)
+      (cong -ᵣ_ (sym (·ᵣAssoc _ _ _)) ∙
+        sym (-ᵣ· _ _) ∙
+         cong₂ (_·ᵣ_)
+         (-ᵣ-rat _)
+         (cong ((x ^ⁿ n) ·ᵣ_)
+           (cong fst (cong invℝ₊ (ℝ₊≡ (sym (·ᵣAssoc _ _ _) ∙
+             cong ((x ^ⁿ n) ·ᵣ_) (·ᵣComm _ _)))
+              ∙ invℝ₊·  (x₊ ₊^ⁿ n) (x₊ ₊^ⁿ (suc (suc n)))))
+           ∙ ·ᵣAssoc _ _ _ ∙ 𝐑'.·IdL' _ _ (x·invℝ₊[x] _)
+         )) h
+
+[0/n]=[0/m] : ∀ n m → [ 0 / n ] ≡ [ 0 / m ]
+[0/n]=[0/m] n m = eq/ _ _ refl
+
+0#[n/m]→n≠0 : ∀ n m → 0 ℚ.# [ n , (1+ m) ] → ¬ n ≡ 0
+0#[n/m]→n≠0 n m x n=0 =
+ let x' = subst (0 ℚ.#_) (cong [_/ (1+ m) ] n=0 ∙ [0/n]=[0/m] _ _) x
+ in ℚ.isIrrefl# 0 x'
+
+
+derivative-^ℚ : ∀ x q → 0 ℚ.# q →
+   derivativeOfℙ pred0< , curry (fst ∘S (_^ℚ q)) at x is
+     (rat q ·ᵣ fst (x ^ℚ (q ℚ.- 1)))
+
+derivative-^ℚ x = SQ.ElimProp.go w
+  where
+  w : ElimProp _
+  w .ElimProp.isPropB _ = isPropΠ2 λ _ _ → squash₁
+  w .ElimProp.f ( n , (1+ m) ) 0#q =
+    subst (derivativeOfℙ pred0< , _ at x is_)
+        (cong₂ (_·ᵣ_) refl (cong fst (invℝ₊· _ _))
+          ∙ L𝐑.lem--086
+          ∙ cong₂ (_·ᵣ_) (cong (rat [ n / 1 ] ·ᵣ_)
+             (cong
+               {x = fromNat (suc m)}
+               {y = ℚ₊→ℝ₊ (fromNat (suc m))}
+               (fst ∘ invℝ₊) (fromNatℝ≡fromNatℚ m)
+               ∙ invℝ₊-rat (fromNat (suc m)))
+           ∙ sym (rat·ᵣrat _ _) ∙ cong rat (invℚ₊-[/] n m))
+            (cong₂ (_·ᵣ_) refl (cong fst (sym (invℝ₊^ℚ _ [ pos m / 1+ m ]))
+               ∙ cong fst (sym (^ℚ-minus' x _)))
+             ∙ cong fst (^ℚ-+ _ [ _ / 1+ m ] _
+              ∙ cong (x ^ℚ_) (
+                ℚ.n/k-m/k _ _ _ ∙
+                  cong [_/ 1+ m ] (sym (ℤ.+Assoc _ _ _)
+                    ∙ cong {y = ℤ.- pos (suc m)} (n ℤ.+_)
+                     (sym (ℤ.negsuc+ 0 m))) ∙ sym (ℚ.n/k-m/k n (pos (suc m)) (1+ m))
+                   ∙ cong (ℚ._-_ [ n / 1+ m ] ) (ℚ.k/k _)))))
+        ww -- sym (^ℚ-minus' x [ pos m / 1+ m ])
+   where
+   ww : derivativeOfℙ pred0< , curry (fst ∘S (_^ℚ [ n / (1+ m) ])) at x is
+              ((rat [ n / 1 ] ·ᵣ fst (root (1+ m) x ^ℤ (n ℤ.- 1 ))) ·ᵣ
+                fst (invℝ₊ (fromNat (suc m) ₊·ᵣ (root (1+ m) x ₊^ⁿ m))))
+   ww = chainRuleIncrℙ _ _ _ _ _ _
+          (λ x₁ x∈ y y∈ x₂ →
+            ₙ√-StrictMonotone {x₁ , x∈} {y , y∈} (1+ m) x₂ )
+          (IsContinuousRoot (1+ m))
+         (derivative-n√ x m)
+         (derivative-^ℤ _ n (0#[n/m]→n≠0 _ _ 0#q))
+
+
+
+opaque
+ unfolding invℝ
+ bernoulli's-ineq-^ℚⁿ : ∀ x n → 1 ℚ.< x
+  →
+   ((fromNat (suc (suc n))) ℚ.· (x ℚ.- 1)) ℚ.+ 1  ℚ.< (x ℚ^ⁿ (suc (suc n)))
+ bernoulli's-ineq-^ℚⁿ x n 1<x =
+  <ᵣ→<ℚ _ _
+    (subst2 _<ᵣ_
+      (cong (1 +ᵣ_) (sym (rat·ᵣrat _ _)) ∙  +ᵣComm _ _) (^ⁿ-ℚ^ⁿ _ _)
+      (bernoulli's-ineq-^ℚ (ℚ₊→ℝ₊ (x ,
+        ℚ.<→0< _ (ℚ.isTrans< 0 1 _ (ℚ.0<pos  _ _) 1<x)))
+        (fromNat (suc (suc n))) (<ℚ→<ᵣ _ _ 1<x)
+           (ℚ.<ℤ→<ℚ _ _ (invEq (ℤ.pos-<-pos≃ℕ< _ _)
+             (ℕ.suc-≤-suc (ℕ.zero-<-suc {n}))))))
+
+
+
+
+ℚ0≤x·ᵣx : ∀ x → 0 ℚ.≤ x ℚ.· x
+ℚ0≤x·ᵣx = SQ.ElimProp.go w
+  where
+  w : ElimProp _
+  w .ElimProp.isPropB _ = ℚ.isProp≤ _ _
+  w .ElimProp.f (pos n , b) = ℚ.≤Monotone·-onNonNeg 0 [ ℤ.pos n , b ] 0 [ ℤ.pos n , b ]
+    (ℚ.0≤pos _ _) (ℚ.0≤pos _ _) (ℚ.0≤pos _ _) (ℚ.0≤pos _ _)
+  w .ElimProp.f (ℤ.negsuc n , b) =
+    subst {x = [ ℤ.pos (suc n) , b ] ℚ.· [ ℤ.pos (suc n) , b ]}
+          {y = [ ℤ.negsuc n , b ] ℚ.· [ ℤ.negsuc n , b ]}
+          (0 ℚ.≤_) (cong [_/ _ ] (sym (ℤ.negsuc·negsuc _ _)))
+      (ℚ.≤Monotone·-onNonNeg 0 [ ℤ.pos (suc n) , b ] 0 [ ℤ.pos (suc n) , b ]
+    (ℚ.0≤pos _ _) (ℚ.0≤pos _ _) (ℚ.0≤pos _ _) (ℚ.0≤pos _ _))
+
+
+0≤x·ᵣx : ∀ x → 0 ≤ᵣ x ·ᵣ x
+0≤x·ᵣx = ≤Cont (IsContinuousConst 0) (cont₂·ᵣ _ _ IsContinuousId IsContinuousId)
+  λ u → isTrans≤≡ᵣ _ _ _ (≤ℚ→≤ᵣ _ _
+    (ℚ0≤x·ᵣx u)) (rat·ᵣrat u u )
+
+
+opaque
+ unfolding invℝ
+ x+1/x-bound : ∀ (x : ℝ₊) → rat [ 1 / 2 ] ≤ᵣ fst x →
+    (fst x -ᵣ 1) -ᵣ (1 -ᵣ fst (invℝ₊ x))  ≤ᵣ (2 ·ᵣ (fst x -ᵣ 1)) ·ᵣ (fst x -ᵣ 1)
+ x+1/x-bound x 1/2≤x =
+   isTrans≡≤ᵣ _ _ _
+     (λ i →  (fst x -ᵣ 1 -ᵣ (1 -ᵣ ·IdL (fst (invℝ₊ x)) (~ i))))
+     (b≤c-b⇒a+b≤c _ _ _ (isTrans≡≤ᵣ _ _ _
+       (-[x-y]≡y-x _ _)
+       (a≤c+b⇒a-c≤b _ _ _
+       (isTrans≤≡ᵣ _ _ _ (invEq (z/y≤x₊≃z≤y₊·x _ _ _) (invEq (x≤y≃0≤y-x _ _)
+         (isTrans≤≡ᵣ _ _ _ h L𝐑.lem--085))) (+ᵣComm _ _)))))
+
+  where
+  h :  0  ≤ᵣ (fst x -ᵣ 1) ·ᵣ (fst x -ᵣ 1) ·ᵣ ((L𝐑.[ 2 ]r ·ᵣ x .fst) -ᵣ 1)
+  h = isTrans≡≤ᵣ _ _ _ (rat·ᵣrat 0 0)
+      (≤ᵣ₊Monotone·ᵣ 0 _ 0 _
+        (0≤x·ᵣx _) (≤ᵣ-refl 0)
+        (0≤x·ᵣx _) (fst (x≤y≃0≤y-x _ _)
+         (fst (z/y≤x₊≃z≤y₊·x (fst x) 1 2) (isTrans≡≤ᵣ _ _ _
+           (·IdL _ ∙ decℚ≡ᵣ?) 1/2≤x) )))
+
+
+lnSeq : ℝ₊ → ℕ → ℝ
+lnSeq z n =  (fst (z ^ℚ [ 1 / 2+ n ]) -ᵣ 1)  ·ᵣ fromNat (suc (suc n))
+
+
+opaque
+ unfolding -ᵣ_
+ lnSeqMonStrictInZ : (z z' : ℝ₊)
+                → fst z <ᵣ fst z'
+                → ∀ n → lnSeq z n <ᵣ lnSeq z' n
+ lnSeqMonStrictInZ z z' z<z' n =
+   <ᵣ-·ᵣo _ _ (fromNat (suc (suc n)))
+    $ <ᵣ-+o _ _ -1
+      (^ℚ-StrictMonotone {z} {z'} ([ 1 / 2+ n ] , _) z<z')
+
+ lnSeqMonInZ : (z z' : ℝ₊)
+                → fst z ≤ᵣ fst z'
+                → ∀ n → lnSeq z n ≤ᵣ lnSeq z' n
+ lnSeqMonInZ z z' z≤z' n =
+   ≤ᵣ-·ᵣo _ _ (fromNat (suc (suc n))) (≤ℚ→≤ᵣ _ _ (ℚ.0≤pos _ _))
+    $ ≤ᵣ-+o _ _ -1
+      (^ℚ-Monotone {z} {z'} ([ 1 / 2+ n ] , _) z≤z')
+
+
+
+ lnSeqCont : ∀ n → IsContinuousWithPred pred0<
+              (λ z 0<z → lnSeq (z , 0<z) n)
+ lnSeqCont n =  IsContinuousWP∘' pred0< _ _
+      (IsContinuous∘ _ _ (IsContinuous·ᵣR _)
+        ((IsContinuous+ᵣR -1))
+        ) (IsContinuous^ℚ [ 1 / 2+ n ])
+
+
+lnSeq' : ℝ₊ → ℕ → ℝ
+lnSeq' z n = (1 -ᵣ fst (z ^ℚ (ℚ.- [ 1 / 2+ n ])))  ·ᵣ fromNat (suc (suc n))
+
+
+lnSeq'Cont : ∀ n → IsContinuousWithPred pred0<
+             (λ z 0<z → lnSeq' (z , 0<z) n)
+lnSeq'Cont n =  IsContinuousWP∘' pred0< _ _
+     (IsContinuous∘ _ _ (IsContinuous·ᵣR _)
+       (IsContinuous∘ _ _ (IsContinuous+ᵣL 1)
+        IsContinuous-ᵣ)
+       ) (IsContinuous^ℚ (ℚ.- [ 1 / 2+ n ]))
+
+lnSeq'[z]≡lnSeq[1/x] : ∀ n z → -ᵣ lnSeq' z n ≡ lnSeq (invℝ₊ z) n
+lnSeq'[z]≡lnSeq[1/x] n z =  sym (-ᵣ· _ _)
+  ∙ cong (_·ᵣ fromNat (suc (suc n)))
+    (-[x-y]≡y-x 1 _ ∙
+     cong (_-ᵣ 1)
+      (cong fst (^ℚ-minus' _ _)))
+
+lnSeq[z]≡lnSeq'[1/x] : ∀ n z → lnSeq z n ≡ -ᵣ lnSeq' (invℝ₊ z) n
+lnSeq[z]≡lnSeq'[1/x] n z =
+     cong (flip lnSeq n) (sym (invℝ₊Invol z))
+   ∙ sym (lnSeq'[z]≡lnSeq[1/x] n (invℝ₊ z))
+
+
+x^→∞ : ∀ m (ε : ℚ₊) →
+         Σ[ N ∈ ℕ ]
+           (∀ n → N ℕ.< n → fromNat m ℚ.< (((fst ε) ℚ.+ 1) ℚ^ⁿ n))
+x^→∞ m ε =
+ let (1+ N , X) = ℚ.ceilℚ₊
+         (fromNat (suc m) ℚ₊· invℚ₊ ε )
+ in   suc N
+    , λ { zero 0< → ⊥.rec (ℕ.¬-<-zero 0<)
+      ; (suc zero) <1 → ⊥.rec (ℕ.¬-<-zero (ℕ.predℕ-≤-predℕ <1))
+      ; (suc (suc n)) <ssn →
+       ℚ.isTrans< (fromNat m) _ _
+         (subst (fromNat m ℚ.<_)
+           (ℚ.·Comm _ _)
+           (ℚ.isTrans< _ (fromNat (suc m)) _
+             (ℚ.<ℤ→<ℚ _ _ ((ℤ.isRefl≤ {pos (suc m)})))
+              (ℚ.x·invℚ₊y<z→x<y·z _ _ _ X)))
+         (ℚ.isTrans< _ _ _ (ℚ.<-·o
+           (fromNat (suc N))
+           (fromNat (suc (suc n))) _ (ℚ.0<ℚ₊ ε)
+           (ℚ.<ℤ→<ℚ _ _  (invEq (ℤ.pos-<-pos≃ℕ< (suc N) (suc (suc n))) <ssn)))
+          (ℚ.isTrans< _ _ _ (
+           ℚ.isTrans≤< _ _ _
+            (ℚ.≡Weaken≤ _ _
+             (cong ((fromNat (suc (suc n))) ℚ.·_)
+              lem--034))
+            (ℚ.<+ℚ₊' _ _ 1 (ℚ.isRefl≤ _)))
+          (bernoulli's-ineq-^ℚⁿ ((fst ε) ℚ.+ 1) n
+           (subst (1 ℚ.<_) (ℚ.+Comm _ _)
+            (ℚ.<+ℚ₊' 1 1 ε (ℚ.isRefl≤ 1))))))}
+
+
+-- bernoulli's-ineq-^ℚ-r<1 : ∀ x r → 1 <ᵣ fst x → 0 ℚ.< r → r ℚ.< 1 → fst (x ^ℚ r) <ᵣ 1 +ᵣ rat r ·ᵣ (fst x -ᵣ 1)
+
+
+module _ (z : ℝ₊) where
+
+ lnSeq=diff : ∀ n → ((fst (z ^ℚ (0 ℚ.+ [ 1 / (2+ n)])) -ᵣ
+                fst (z ^ℚ 0)) ／ᵣ[ rat [ 1 / (2+ n)] , inl (snd (ℚ₊→ℝ₊ ([ 1 / 2+ n ] , _))) ])
+                 ≡ lnSeq z n
+ lnSeq=diff n = cong₂ _·ᵣ_ (cong₂ _-ᵣ_ (cong (fst ∘ (z ^ℚ_)) (ℚ.+IdL _)) refl )
+  (invℝ-rat _ _ (inl (ℚ.0<→< _ tt)))
+
+ lnSeq≤ : ∀ n → lnSeq z n ≤ᵣ fst z -ᵣ 1
+ lnSeq≤ n = subst2 _≤ᵣ_
+   (cong ((fst (z ^ℚ ([ 1 / 2+ n ])) -ᵣ 1) ·ᵣ_)
+      (invℝ₊-rat _ ∙ cong rat (cong (fst ∘ invℚ₊)
+    (ℚ₊≡ (ℚ.+IdR _)) ∙ ℚ.invℚ₊-invol _)))
+
+   (𝐑'.·IdR' _ _
+     (cong fst invℝ₊1) ∙ cong (_-ᵣ 1) (cong fst (^ℚ-1 _)))
+   (slope-incr z 0 [ 1 / 2+ n ] 1
+      (ℚ.0<pos _ _)
+      ((fst (ℚ.invℚ₊-≤-invℚ₊ 1 (fromNat (suc (suc n))))
+        (ℚ.≤ℤ→≤ℚ 1 (pos (suc (suc n)))
+          (ℤ.suc-≤-suc {0} {pos (suc n)}
+            ((ℤ.≤-suc {0} {pos n} (ℤ.zero-≤pos {n} )))))))
+
+      (ℚ.0<pos _ _))
+
+
+
+ lnSeq≤lnSeq : ∀ n m → m ℕ.≤ n → lnSeq z n ≤ᵣ lnSeq z m
+ lnSeq≤lnSeq n m m≤n =
+   subst2 _≤ᵣ_
+     (cong ((fst (z ^ℚ ([ 1 / 2+ n ])) -ᵣ 1) ·ᵣ_)
+        (invℝ₊-rat _ ∙ cong rat (cong (fst ∘ invℚ₊)
+      (ℚ₊≡ (ℚ.+IdR _)) ∙ ℚ.invℚ₊-invol _)))
+     (cong ((fst (z ^ℚ ([ 1 / 2+ m ])) -ᵣ 1) ·ᵣ_)
+        (invℝ₊-rat _ ∙ cong rat (cong (fst ∘ invℚ₊)
+      (ℚ₊≡ (ℚ.+IdR _)) ∙ ℚ.invℚ₊-invol _)))
+     (slope-monotone z 0 [ 1 / 2+ n ] 0 [ 1 / 2+ m ]
+            (ℚ.0<pos _ _) (ℚ.0<pos _ _) (ℚ.0≤pos _ _)
+             (fst (ℚ.invℚ₊-≤-invℚ₊ (fromNat (suc (suc m))) (fromNat (suc (suc n))))
+               (ℚ.≤ℤ→≤ℚ _ _ (invEq (ℤ.pos-≤-pos≃ℕ≤ _ _) (ℕ.≤-k+ {k = 2} m≤n)))))
+
+ lnSeq'≤lnSeq' : ∀ m n → m ℕ.≤ n → lnSeq' z m ≤ᵣ lnSeq' z n
+ lnSeq'≤lnSeq' m n m<n =
+   subst2 _≤ᵣ_
+        ((cong ((1 -ᵣ fst (z ^ℚ (ℚ.- [ 1 / 2+ m ]))) ·ᵣ_)
+     (invℝ₊-rat _ ∙ cong rat (cong (fst ∘ invℚ₊)
+    (ℚ₊≡ (ℚ.+IdL _
+    ∙ ℚ.-Invol _)) ∙ ℚ.invℚ₊-invol _))))
+     (cong ((1 -ᵣ fst (z ^ℚ (ℚ.- [ 1 / 2+ n ]))) ·ᵣ_)
+     (invℝ₊-rat _ ∙ cong rat (cong (fst ∘ invℚ₊)
+    (ℚ₊≡ (ℚ.+IdL _
+    ∙ ℚ.-Invol _)) ∙ ℚ.invℚ₊-invol _)))
+     (slope-monotone z (ℚ.- [ 1 / 2+ _ ]) 0 (ℚ.- [ 1 / 2+ _ ]) 0
+             (ℚ.minus-< 0 [ 1 / 2+ _ ] ((ℚ.0<pos 0 (1+ _))))
+             (ℚ.minus-< 0 [ 1 / 2+ _ ] ((ℚ.0<pos 0 (1+ _))))
+
+             (ℚ.minus-≤ [ 1 / 2+ _ ] [ 1 / 2+ _ ]
+                (fst (ℚ.invℚ₊-≤-invℚ₊ (fromNat (suc (suc m))) ((fromNat (suc (suc n)))))
+                       ((ℚ.≤ℤ→≤ℚ _ _ (invEq (ℤ.pos-≤-pos≃ℕ≤ _ _) (ℕ.≤-k+ {k = 2} m<n))))))
+              (ℚ.isRefl≤ 0))
+
+
+--  0≤ᵣlnSeq : ∀ n → 0 ≤ᵣ lnSeq z n
+--  0≤ᵣlnSeq n =  isTrans≡≤ᵣ _ _ _ (rat·ᵣrat 0 0) $
+--    ≤ᵣ₊Monotone·ᵣ _ _ _ _
+--     w (≤ᵣ-refl _)
+--     w  (≤ℚ→≤ᵣ _ _ (ℚ.0≤pos _ _) )
+
+--    where
+
+--    w = fst (x≤y≃0≤y-x _ _) (1≤^ℚ z _ 1≤z)
+
+ lnSeq'≤lnSeq : ∀ n m → lnSeq' z n ≤ᵣ lnSeq z m
+ lnSeq'≤lnSeq n m =
+   subst2 _≤ᵣ_
+     (cong ((1 -ᵣ fst (z ^ℚ (ℚ.- [ 1 / 2+ n ]))) ·ᵣ_)
+       (invℝ₊-rat _ ∙ cong rat (cong (fst ∘ invℚ₊)
+      (ℚ₊≡ (ℚ.+IdL _
+      ∙ ℚ.-Invol _)) ∙ ℚ.invℚ₊-invol _)))
+     (cong ((fst (z ^ℚ ([ 1 / 2+ m ])) -ᵣ 1) ·ᵣ_)
+        (invℝ₊-rat _ ∙ cong rat (cong (fst ∘ invℚ₊)
+      (ℚ₊≡ (ℚ.+IdR _)) ∙ ℚ.invℚ₊-invol _)))
+     (slope-monotone z (ℚ.- [ 1 / 2+ n ]) 0 0 [ 1 / 2+ m ]
+            (ℚ.minus-< 0 [ pos 1 / 2+ n ] (ℚ.0<pos _ _)) (ℚ.0<pos _ _ )
+            (ℚ.minus-≤ 0 [ pos 1 / 2+ n ] (ℚ.0≤pos _ _)) (ℚ.0≤pos _ _))
+
+
+seqΔ-δ : (Z : ℕ) → (ε : ℚ₊) → Σ ℕ λ N → (n : ℕ) →
+            N ℕ.< n →
+            fromNat (suc (suc Z)) ℚ.<
+            ((fst (ε ℚ₊· invℚ₊ (fromNat (suc Z) ℚ₊· 2)) ℚ.+ 1) ℚ^ⁿ
+             n)
+seqΔ-δ Z ε = x^→∞ (suc (suc Z))
+         (ε ℚ₊· (invℚ₊ ((([ pos (suc Z) / 1 ] , _)) ℚ₊· 2)))
+
+opaque
+ unfolding -ᵣ_ _+ᵣ_
+
+ seqΔ-pos : ∀ z Z → (z<Z : fst z ≤ᵣ fromNat (suc (suc Z))) →
+    1 ≤ᵣ fst z → ∀ (ε : ℚ₊) →
+    (∀ n → (fst (seqΔ-δ Z ε)) ℕ.< n →
+       lnSeq z n -ᵣ lnSeq' z n <ᵣ (rat (fst ε)))
+
+ seqΔ-pos z Z z≤Z 1≤z ε =
+  let (N , X) = x^→∞ (suc (suc Z))
+          (ε ℚ₊· (invℚ₊ ((([ pos (suc Z) / 1 ] , _)) ℚ₊· 2)))
+  in λ { n N<n →
+     let
+         X' = X (suc (suc n)) (ℕ.≤-trans N<n (ℕ.≤SumRight {k = 2}) )
+         X'' = isTrans<≡ᵣ _ _ _ (a<c+b⇒a-b<c _ _ _
+             (isTrans<≡ᵣ _ _ _ (^ℚ-StrictMonotone {fromNat (suc (suc Z)) }
+                {ℚ₊→ℝ₊
+                  (((ε ℚ₊· invℚ₊ (([ pos (suc Z) / 1 ] , tt) ℚ₊· 2)) ℚ₊+ 1)
+                   ℚ₊^ⁿ (suc (suc n)))}
+                 ([ 1 / 1+ (suc n) ] , _)
+                 (<ℚ→<ᵣ _ _ X'))
+                 (cong (fst ∘ _^ℚ [ pos 1 / 1+ (suc n) ])
+                   (ℝ₊≡ (sym (^ⁿ-ℚ^ⁿ _ _)))
+                  ∙  cong fst (^ℚ-·
+                      (ℚ₊→ℝ₊
+                       ((ε ℚ₊· invℚ₊ (([ pos (suc Z) / 1 ] , tt) ℚ₊· 2)) ℚ₊+ 1))
+                       (fromNat (suc (suc n))) [ pos 1 / 1+ (suc n) ])
+                       ∙ cong (fst ∘
+                          (ℚ₊→ℝ₊ ((ε ℚ₊· invℚ₊ (([ pos (suc Z) / 1 ] , _) ℚ₊· 2))
+                            ℚ₊+ 1) ^ℚ_)) (ℚ.x·invℚ₊[x] (fromNat _))
+                       ∙ cong fst (^ℚ-1 _) ∙ cong (_+ᵣ 1) (rat·ᵣrat _ _))))
+                       (cong (rat (fst ε) ·ᵣ_)
+                         (sym (invℝ₊-rat _)))
+         X''' = isTrans≡<ᵣ _ _ _
+                  (cong (_·ᵣ
+                 (fst (fromNat (suc (suc Z)) ^ℚ [ 1 / 2+ n ]) -ᵣ 1))
+                  (cong rat (cong {y = fromNat (suc Z)} (ℚ._· 2)
+                   (ℚ.ℤ-→ℚ- _ _ ∙ cong [_/ 1 ] (sym (ℤ.pos- _ _)) )
+                  )))
+                  (fst (z<x/y₊≃y₊·z<x _ _ _) X'')
+     in isTrans≡<ᵣ _ _ _
+       (cong (λ y → lnSeq z n -ᵣ  (1 -ᵣ y) ·ᵣ fromNat (suc (suc n)) )
+         (cong fst (^ℚ-minus' z _) ∙
+           cong fst (invℝ₊^ℚ _ _))
+        ∙ sym (𝐑'.·DistL- _ _ _))
+       (isTrans≤<ᵣ _ _ _
+         (isTrans≤≡ᵣ _ _ _ (≤ᵣ-·ᵣo _ _ (fromNat (suc (suc n)))
+          (≤ℚ→≤ᵣ _ _ (ℚ.0≤pos _ _))
+          ((x+1/x-bound _ (isTrans≤ᵣ _ _ _
+             decℚ≤ᵣ?
+             (1≤^ℚ z
+               ([ pos 1 / 2+ n ] , _)
+               1≤z)
+               ))))
+          (sym (·ᵣAssoc _ _ _)))
+          (isTrans≤<ᵣ _ _ _
+           (≤ᵣ₊Monotone·ᵣ _ _ _ _
+           (let w = fst (x≤y≃0≤y-x _ _) (1≤^ℚ z ([ 1 / 2+ n ] , _) 1≤z)
+            in isTrans≡≤ᵣ _ _ _ (sym (𝐑'.0RightAnnihilates 2) ) (≤ᵣ-o·ᵣ _ _ 2 decℚ≤ᵣ?
+                   (x≤y→0≤y-x 1 _ (1≤^ℚ _ _
+                    (isTrans≤ᵣ _ _ _ 1≤z z≤Z)))))
+
+
+            (0≤ᵣlnSeq _)
+             (≤ᵣ-o·ᵣ _ _ 2 decℚ≤ᵣ?
+              (≤ᵣ-+o _ _ -1
+               (^ℚ-Monotone {y = fromNat (suc (suc Z))} ([ 1 / 2+ n ] , _) z≤Z)))
+             (isTrans≤ᵣ _ _ _ (lnSeq≤ z n)
+               (≤ᵣ-+o _ _ -1 z≤Z)))
+           (isTrans≡<ᵣ _ _ _ (·ᵣComm _ _ ∙  (·ᵣAssoc _ _ _) ∙
+            cong (_·ᵣ (fst (fromNat (suc (suc Z)) ^ℚ [ 1 / 2+ n ]) +ᵣ -1))
+             (sym (rat·ᵣrat _ _)) )
+               X''')))
+               }
+   where
+
+    0≤ᵣlnSeq : ∀ n → 0 ≤ᵣ lnSeq z n
+    0≤ᵣlnSeq n =  isTrans≡≤ᵣ _ _ _ (rat·ᵣrat 0 0) $
+      ≤ᵣ₊Monotone·ᵣ _ _ _ _
+       w (≤ᵣ-refl _)
+       w  (≤ℚ→≤ᵣ _ _ (ℚ.0≤pos _ _) )
+
+      where
+
+      w : rat 0 ≤ᵣ fst (z ^ℚ [ 1 / 2+ n ]) -ᵣ 1
+      w = fst (x≤y≃0≤y-x _ _) (1≤^ℚ z _ 1≤z)
+
+opaque
+ unfolding invℝ
+
+ 1≤x-⊔-x⁻¹ : ∀ x → 1 ≤ᵣ fst (maxᵣ₊ x (invℝ₊ x))
+ 1≤x-⊔-x⁻¹ (x , 0<x) =
+  <→≤ContPos'pred {0}
+   (AsContinuousWithPred _ _ (IsContinuousConst 1))
+   (contDiagNE₂WP maxR _ _ _
+     (AsContinuousWithPred _ _ (IsContinuousId))
+       (snd invℝ'))
+   (λ u 0<u →
+     ⊎.rec (λ 1≤u → isTrans≤ᵣ _ _ _ (≤ℚ→≤ᵣ _ _ 1≤u) (≤maxᵣ _ _))
+           (λ u≤1 → isTrans≤ᵣ _ _ _
+                      (≤ℚ→≤ᵣ _ (fst (invℚ₊ (u , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<u))))
+             (fst (ℚ.invℚ₊-≤-invℚ₊ _ _) u≤1))
+            (isTrans≤≡ᵣ _ _ _
+             (≤maxᵣ _ (rat u))
+              ( maxᵣComm _ _ ∙ cong (maxᵣ (rat u)) (sym (invℝ₊-rat _)
+               ∙ cong (fst ∘ invℝ₊) (ℝ₊≡ refl)))))
+       (ℚ.≤cases 1 u))
+   x 0<x
+
+
+
+mapNE-fromCauchySequence' : ∀ {h} (ne : NonExpanding₂ h) s ics s' ics' →
+    Σ (IsCauchySequence'
+         λ k → NonExpanding₂.go ne (s k) (s' k)) λ icsf →
+      NonExpanding₂.go ne
+        (fromCauchySequence' s ics)
+        (fromCauchySequence' s' ics')
+          ≡
+           fromCauchySequence' _ icsf
+mapNE-fromCauchySequence' ne s ics s' ics' =
+ (λ  ε →
+  let (N , X) = ics (/2₊ ε)
+      (N' , X') = ics' (/2₊ ε)
+  in ℕ.max N N' , λ m n <n <m →
+       isTrans<≡ᵣ _ _ _ (fst (∼≃abs<ε _ _ _) (go∼₂ (/2₊ ε) (/2₊ ε)
+           (invEq (∼≃abs<ε _ _ _)
+             (X m n (ℕ.≤<-trans ℕ.left-≤-max <n)
+                    (ℕ.≤<-trans ℕ.left-≤-max <m)))
+           (invEq (∼≃abs<ε _ _ _)
+              ((X' m n (ℕ.≤<-trans ℕ.right-≤-max <n)
+                       (ℕ.≤<-trans ℕ.right-≤-max <m)))))
+          ) (cong rat (ℚ.ε/2+ε/2≡ε (fst ε))))
+   , cong₂ go
+       (cauchySequenceSpeedup≡ _ _
+          (λ ε → ℕ.max (fst (ics ε)) (fst (ics' ε)))
+            λ _ → ℕ.left-≤-max)
+       (cauchySequenceSpeedup≡ _ _
+          (λ ε → ℕ.max (fst (ics ε)) (fst (ics' ε)))
+            λ _ → ℕ.right-≤-max)
+      ∙ snd (β-lim-lim/2 _ _ _ _)
+         ∙ congLim _ _ _ _ λ _ → refl
+
+ where
+ open NonExpanding₂ ne
+
+Lipschitz-·R : ∀ q a → absᵣ a ≤ᵣ rat (fst q) → Lipschitz-ℝ→ℝ q (_·ᵣ a)
+Lipschitz-·R q a a<q u v ε u∼v =
+   invEq (∼≃abs<ε _ _ _) (
+    subst2 _<ᵣ_
+     (sym (·absᵣ _ _) ∙ cong absᵣ (𝐑'.·DistL- _ _ _))
+     (·ᵣComm _ _ ∙ sym (rat·ᵣrat _ _))
+     (isTrans≤<ᵣ _ _ _
+       (≤ᵣ-o·ᵣ _ _ _ (0≤absᵣ _) a<q)
+       (<ᵣ-·ᵣo _ _ (ℚ₊→ℝ₊ q) (fst (∼≃abs<ε _ _ _) u∼v))))
+
+∃Lipschitz-·R : ∀ a → ∃[ L ∈ ℚ₊ ] Lipschitz-ℝ→ℝ L (_·ᵣ a)
+∃Lipschitz-·R a =
+  PT.map (λ (q , (<q , _)) →
+    (q , (ℚ.<→0< _ $ <ᵣ→<ℚ _ _ (isTrans≤<ᵣ _ _ _ (0≤absᵣ _) <q)))
+      , Lipschitz-·R _ a (<ᵣWeaken≤ᵣ _ _ <q) )
+   (denseℚinℝ _ _
+    (isTrans≡<ᵣ _ _ _ (sym (+IdR _)) (<ᵣ-o+ 0 1 (absᵣ a) decℚ<ᵣ?)))
+
+
+module expPreDer (Z : ℕ) where
+ module expPreDer' (z : ℝ₊)
+          (z≤Z : fst z ≤ᵣ fromNat (suc (suc Z)))
+          (1/Z≤z :  rat [ 1 / fromNat (suc (suc Z)) ] ≤ᵣ fst z) where
+
+
+
+  seqΔ : ∀ (ε : ℚ₊) →
+     (∀ n → (fst (seqΔ-δ Z ε)) ℕ.< n →
+        lnSeq z n -ᵣ lnSeq' z n <ᵣ (rat (fst ε)))
+
+  seqΔ ε n a<n =
+      isTrans≡<ᵣ _ _ _ (w' n z)
+        (seqΔ-pos z⊔z⁻¹ Z z⊔z⁻¹≤Z (1≤x-⊔-x⁻¹ z) ε n a<n)
+
+   where
+     diff : ℝ₊ → ℕ → ℝ
+     diff z n = lnSeq z n -ᵣ lnSeq' z n
+
+     z⊔z⁻¹ : ℝ₊
+     z⊔z⁻¹ = maxᵣ₊ z (invℝ₊ z)
+
+     z⊔z⁻¹≤Z : fst z⊔z⁻¹ ≤ᵣ fromNat (suc (suc Z))
+     z⊔z⁻¹≤Z = max≤-lem _ _ _ z≤Z
+      (subst2 _≤ᵣ_
+        (·IdR _) (·IdR _)
+        (fst (z/y'≤x/y≃y₊·z≤y'₊·x 1 1 (invℝ₊ z) (fromNat (suc (suc Z))))
+         (subst2 _≤ᵣ_
+        ((sym (invℝ₊-rat (fromNat (suc (suc Z)))) ∙
+         cong (fst ∘ invℝ₊) (ℝ₊≡ refl))
+         ∙ sym (·IdL _)) (cong fst (sym (invℝ₊Invol z)) ∙ sym (·IdL _))
+         1/Z≤z)))
+     opaque
+      unfolding _+ᵣ_
+      wC : ∀ n →
+        IsContinuousWithPred pred0<
+          (λ z 0<z → diff (z , 0<z) n)
+      wC n = contDiagNE₂WP sumR pred0<  _ _
+                (lnSeqCont n)
+                (IsContinuousWP∘' pred0< _ _ IsContinuous-ᵣ
+                 (lnSeq'Cont n))
+
+     w-r<1 : ∀ n r 0<r → diff (ℚ₊→ℝ₊ (r , 0<r)) n ≡
+                        diff (invℝ₊ (ℚ₊→ℝ₊ (r , 0<r))) n
+     w-r<1 n r 0<r =
+        +ᵣComm _ _ ∙ cong₂ _+ᵣ_
+          (lnSeq'[z]≡lnSeq[1/x] n (ℚ₊→ℝ₊ (r , 0<r)))
+          (lnSeq[z]≡lnSeq'[1/x] n (ℚ₊→ℝ₊ (r , 0<r)))
+
+     w-r : ∀ n r 0<r → diff (ℚ₊→ℝ₊ (r , 0<r)) n ≡
+                        diff (maxᵣ₊ (ℚ₊→ℝ₊ (r , 0<r)) (ℚ₊→ℝ₊ (invℚ₊ (r , 0<r)))) n
+     w-r n r 0<r = ⊎.rec
+         (λ ≤r → cong (flip diff n)
+                  (ℝ₊≡ {ℚ₊→ℝ₊ (r , 0<r)}
+                       {maxᵣ₊ (ℚ₊→ℝ₊ (r , 0<r)) (ℚ₊→ℝ₊ (invℚ₊ (r , 0<r)))}
+                    ((sym (maxᵣComm (fst ((ℚ₊→ℝ₊ (r , 0<r))))
+                               (fst (ℚ₊→ℝ₊ (invℚ₊ (r , 0<r))))
+                     ∙ ≤ᵣ→≡ (≤ℚ→≤ᵣ _ _ ≤r)))))) -- ≤ℚ→≤ᵣ _ _ ≤r
+
+          (λ r≤ → w-r<1 n r 0<r ∙
+
+           cong (flip diff n) (ℝ₊≡
+            (invℝ₊-rat _ ∙ sym (≤ᵣ→≡  (≤ℚ→≤ᵣ r _  r≤))))
+            )
+         (ℚ.≤cases (fst (invℚ₊ (r , 0<r))) r)
+
+     w' : ∀ n z → diff z n ≡ diff (maxᵣ₊ z (invℝ₊ z)) n
+     w' n (z , 0<z) =
+      ≡ContinuousWithPred
+                 pred0< pred0< (openPred< 0) (openPred< 0) _ _ (wC n)
+                 (IsContinuousWP∘ pred0< pred0< _ _
+                   (λ r x → snd (maxᵣ₊ (r , x) (invℝ₊ (r , x))))  (wC n)
+                   ((contDiagNE₂WP maxR _ _ _
+                   (AsContinuousWithPred _ _ (IsContinuousId))
+                     (snd invℝ'))))
+                 (λ r r∈ r∈' → cong (flip diff n) (ℝ₊≡ refl)
+                      ∙ w-r n r (ℚ.<→0< _ (<ᵣ→<ℚ _ _ r∈'))
+                  ∙ cong (flip diff n)
+                   (cong₂ maxᵣ₊
+                     (ℝ₊≡ refl)
+                     (ℝ₊≡ {_} {_ , snd ((invℝ₊ (fst (ℚ₊→ℝ₊
+                      (r , ℚ.<→0< r (<ᵣ→<ℚ [ pos 0 / 1 ] r r∈'))) , r∈')))}
+                      (sym (invℝ₊-rat _) ∙ cong (fst ∘ invℝ₊)
+                       (ℝ₊≡ refl) ))) )
+                 z 0<z 0<z
+
+  -- lnSeq-∼ : (ε : ℚ₊) → ∀ {!!}
+  -- lnSeq-∼ = {!!}
+  ca-lnSeq : IsCauchySequence' (lnSeq z)
+  ca-lnSeq ε =
+    fst (seqΔ-δ Z ε) , ℕ.elimBy≤
+     (λ x y X u v → isTrans≡<ᵣ _ _ _
+       (minusComm-absᵣ _ _) (X v u) )
+     λ x y x≤y <y <x →
+       isTrans≤<ᵣ _ _ _
+        ((isTrans≡≤ᵣ _ _ _
+            (absᵣNonPos (lnSeq z y +ᵣ -ᵣ lnSeq z x)
+              (fst (x≤y≃x-y≤0 _ _) (lnSeq≤lnSeq z _ _ x≤y))
+              ∙ -[x-y]≡y-x _ _)
+            (≤ᵣ-o+ _ _ _ (-ᵣ≤ᵣ _ _ (lnSeq'≤lnSeq z x y)))
+            ))
+        (seqΔ ε _ <x)
+
+--   -- ca-lnSeq' : IsCauchySequence' lnSeq'
+--   -- ca-lnSeq' = IsCauchySequence'-via-~seq lnSeq lnSeq' lnSeq~lnSeq' ca-lnSeq
+--   -- IsCauchySequence'-via-~seq
+
+  preLn : ℝ
+  preLn = fromCauchySequence' _ ca-lnSeq
+
+ -- --  lnSeq'-lim : ?
+ -- --  lnSeq'-lim = fromCauchySequence'≡ _ ca-lnSeq
+ -- -- -- fromCauchySequence'≡ : ∀ s ics x
+ -- -- --          → ((∀ (ε : ℚ₊) →
+ -- -- --              ∃[ N ∈ ℕ ] (∀ n → N ℕ.< n →
+ -- -- --                   absᵣ ((s n) -ᵣ x) <ᵣ rat (fst ε))))
+ -- -- --          → fromCauchySequence' s ics ≡ x
+
+  preLn≤lnSeq : ∀ n → preLn ≤ᵣ (lnSeq z n)
+  preLn≤lnSeq n =
+    x<y+δ→x≤y  _ _ λ ε →
+          let (m , M) = fromCauchySequence'-lim _ ca-lnSeq ε
+              ii = isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+                   (isTrans≡<ᵣ _ _ _
+                    (minusComm-absᵣ _ _)
+                    (M (ℕ.max (suc m) n) ℕ.left-≤-max))
+          in isTrans<≤ᵣ _ _ _
+               (a-b<c⇒a<c+b _ _ _ ii)
+               (isTrans≤≡ᵣ _ _ _
+                 (≤ᵣ-o+ _ _ (rat (fst ε))
+                   (lnSeq≤lnSeq z _ _ ℕ.right-≤-max))
+                 (+ᵣComm _ _))
+
+  lnSeq'≤preLn : ∀ n →  lnSeq' z n ≤ᵣ preLn
+  lnSeq'≤preLn n = x<y+δ→x≤y  _ _ λ ε →
+   let (m , M) = fromCauchySequence'-lim _ ca-lnSeq ε
+
+   in isTrans≤<ᵣ _ _ _ (lnSeq'≤lnSeq z n (suc m))
+        (isTrans<≡ᵣ _ _ _ (a-b<c⇒a<c+b _ _ _
+         (isTrans≤<ᵣ _ _ _ (≤absᵣ _) (M (suc m) (ℕ.≤-refl {suc m}))))
+           (+ᵣComm (rat (fst ε)) preLn))
+
+  preLn∼ : ∀ n ε → fst (seqΔ-δ Z ε) ℕ.< n → lnSeq z n ∼[ ε ] preLn
+  preLn∼ n ε <n = invEq (∼≃abs<ε _ _ _)
+    (isTrans≤<ᵣ _ _ _
+      (isTrans≡≤ᵣ _ _ _
+        (absᵣNonNeg _ (x≤y→0≤y-x _ _ (preLn≤lnSeq n)))
+        (≤ᵣ-o+ _ _ _ (-ᵣ≤ᵣ _ _ (lnSeq'≤preLn n))))
+     (seqΔ ε n <n))
+
+  0<preLn : 1 <ᵣ fst z → 0 <ᵣ preLn
+  0<preLn 1<z = isTrans<≤ᵣ _ _ _
+      (ℝ₊· (_ , x<y→0<y-x _ 1
+       (^ℚ-StrictMonotoneR {z} 1<z (ℚ.- [ 1 / 2+ 0 ]) 0
+         (ℚ.decℚ<? {ℚ.- [ pos 1 / 2+ 0 ]} {0})))
+      (fromNat 2))
+      (lnSeq'≤preLn 0)
+
+  -- preLn<0 : fst z <ᵣ 1 → preLn <ᵣ 0
+  -- preLn<0 z<1 = isTrans≤<ᵣ _ _ _
+  --   {!!}
+  --   {!!}
+
+ open expPreDer'
+
+ 0=preLn : (1≤ : fst 1 ≤ᵣ fromNat (suc (suc Z)))
+           (≤1 : rat [ pos 1 / 2+ Z ] ≤ᵣ 1)
+           → 0 ≡ preLn 1 1≤ ≤1
+ 0=preLn 1≤ ≤1 = sym (limConstRat 0 λ _ _ → refl∼ _ _)
+  ∙ congLim _ _ _ _ λ q → sym (𝐑'.0LeftAnnihilates' _ _
+     (𝐑'.+InvR' (fst (1 ^ℚ [ 1 / 2+ _ ])) 1 (cong fst (1^ℚ≡1 _))))
+
+ preLn-inv : (z : ℝ₊)
+          (z≤Z : fst z ≤ᵣ fromNat (suc (suc Z)))
+          (1/Z≤z :  rat [ 1 / fromNat (suc (suc Z)) ] ≤ᵣ fst z)
+          (1/z≤Z : fst (invℝ₊ z) ≤ᵣ fromNat (suc (suc Z)))
+          (1/Z≤1/z :  rat [ 1 / fromNat (suc (suc Z)) ] ≤ᵣ fst (invℝ₊ z))
+           → preLn (invℝ₊ z) 1/z≤Z 1/Z≤1/z ≡ -ᵣ (preLn z z≤Z 1/Z≤z)
+ preLn-inv z z≤Z 1/Z≤z 1/z≤Z 1/Z≤1/z =
+   fromCauchySequence'≡ _ _ _
+     λ ε → ∣ (fst (seqΔ-δ Z ε)) ,
+          (λ n <n →
+            isTrans≡<ᵣ _ (preLn z z≤Z 1/Z≤z -ᵣ lnSeq' z n) _
+              (cong (λ xx → absᵣ (xx -ᵣ -ᵣ preLn z z≤Z 1/Z≤z))
+                  (sym (lnSeq'[z]≡lnSeq[1/x] n z))
+                ∙ cong absᵣ (sym (L𝐑.lem--083 {preLn z z≤Z 1/Z≤z} {lnSeq' z n}))
+                ∙ absᵣNonNeg _ (x≤y→0≤y-x _ _ (lnSeq'≤preLn _ _ _ n )))
+              (isTrans≤<ᵣ _ _ _
+                (≤ᵣ-+o (preLn z z≤Z 1/Z≤z) _ (-ᵣ lnSeq' z n)
+                  (preLn≤lnSeq _ _ _ n))
+                (seqΔ z z≤Z 1/Z≤z ε n <n))) ∣₁
+
+
+
+
+ monotonePreLn : (z z' : ℝ₊)
+          (z≤Z : fst z ≤ᵣ fromNat (suc (suc Z)))
+          (1/Z≤z :  rat [ 1 / fromNat (suc (suc Z)) ] ≤ᵣ fst z)
+          (z'≤Z : fst z' ≤ᵣ fromNat (suc (suc Z)))
+          (1/Z≤z' :  rat [ 1 / fromNat (suc (suc Z)) ] ≤ᵣ fst z')
+          → fst z ≤ᵣ fst z'
+          → preLn z z≤Z 1/Z≤z  ≤ᵣ
+              preLn z' z'≤Z 1/Z≤z'
+ monotonePreLn z z' z≤Z 1/Z≤z z'≤Z 1/Z≤z' z≤z' =
+   fromCauchySequence'≤ _ _ _ _
+     (lnSeqMonInZ z z' z≤z')
+
+
+
+
+ opaque
+  unfolding -ᵣ_
+
+  slope-monotone-preLn : ∀ (a b a' b' : ℝ₊)
+     a≤Z 1/Z≤a b≤Z 1/Z≤b a'≤Z 1/Z≤a' b'≤Z 1/Z≤b'
+    → (a<b : fst a <ᵣ fst b) → (a'<b' : fst a' <ᵣ fst b')
+    → (a≤a' : fst a ≤ᵣ fst a') →  (b≤b' : fst b ≤ᵣ fst b') →
+    (((preLn b' b'≤Z 1/Z≤b') -ᵣ (preLn a' a'≤Z 1/Z≤a'))
+      ／ᵣ₊ (_ , x<y→0<y-x _ _ a'<b' ))
+        ≤ᵣ
+    (((preLn b b≤Z 1/Z≤b) -ᵣ (preLn a a≤Z 1/Z≤a))
+      ／ᵣ₊ (_ , x<y→0<y-x _ _ a<b ))
+  slope-monotone-preLn a b a' b'
+    a≤Z 1/Z≤a b≤Z 1/Z≤b a'≤Z 1/Z≤a' b'≤Z 1/Z≤b'
+      a<b a'<b' a≤a' b≤b' =
+        PT.rec2 (isProp≤ᵣ _ _)
+                          ww
+          (∃Lipschitz-·R (fst (invℝ₊ b'-a')))
+          (∃Lipschitz-·R (fst (invℝ₊ b-a)))
+
+
+    where
+
+
+     b'-a' : ℝ₊
+     b'-a' = (_ , x<y→0<y-x _ _ a'<b' )
+     b-a : ℝ₊
+     b-a = (_ , x<y→0<y-x _ _ a<b )
+     opaque
+      unfolding _+ᵣ_
+      ww : Σ ℚ₊ (λ L → Lipschitz-ℝ→ℝ L (_·ᵣ fst (invℝ₊ b'-a'))) →
+           Σ ℚ₊ (λ L → Lipschitz-ℝ→ℝ L (_·ᵣ fst (invℝ₊ b-a))) →
+              ((preLn b' b'≤Z 1/Z≤b' -ᵣ preLn a' a'≤Z 1/Z≤a') ／ᵣ₊
+                  (fst b' +ᵣ -ᵣ fst a' , x<y→0<y-x (fst a') (fst b') a'<b'))
+                 ≤ᵣ
+                 ((preLn b b≤Z 1/Z≤b -ᵣ preLn a a≤Z 1/Z≤a) ／ᵣ₊
+                  (fst b +ᵣ -ᵣ fst a , x<y→0<y-x (fst a) (fst b) a<b))
+      ww (_ , lip·') (_ , lip·) = subst2 _≤ᵣ_
+        (sym (snd (map-fromCauchySequence' _ _ _ _ lip·'))
+               ∙ cong (_／ᵣ₊ b'-a')
+                   (sym (snd (mapNE-fromCauchySequence' sumR _ _ _ _))
+                      ∙ cong ((preLn b' b'≤Z 1/Z≤b') +ᵣ_)
+                       (sym (snd (map-fromCauchySequence' _ _ _ _ (snd -ᵣR))))))
+        (sym (snd (map-fromCauchySequence' _ _ _ _ lip·))
+               ∙ cong (_／ᵣ₊ b-a)
+                   (sym (snd (mapNE-fromCauchySequence' sumR _ _ _ _))
+                     ∙ cong ((preLn b b≤Z 1/Z≤b) +ᵣ_)
+                       (sym (snd (map-fromCauchySequence' _ _ _ _ (snd -ᵣR))))))
+            (fromCauchySequence'≤ _ _ _ _ w)
+
+       where
+
+
+
+       w : (n : ℕ) →
+                (((lnSeq b' n) -ᵣ (lnSeq a' n)) ／ᵣ₊ b'-a')
+             ≤ᵣ (((lnSeq b n) -ᵣ (lnSeq a n)) ／ᵣ₊ b-a)
+       w n = subst2 _≤ᵣ_
+              (·ᵣAssoc _ _ _
+                 ∙ cong (_／ᵣ₊ b'-a')
+                  ((cong (fromNat (suc (suc n)) ·ᵣ_)
+                   (cong₂ _-ᵣ_ (sym (·IdL _)) (sym (·IdL _)) ∙ sym ( L𝐑.lem--075))
+                      ∙ ·ᵣComm _ _  ∙ 𝐑'.·DistL- _ _ _)))
+              (·ᵣAssoc _ _ _
+                  ∙ cong (_／ᵣ₊ b-a) ((cong (fromNat (suc (suc n)) ·ᵣ_)
+                    (cong₂ _-ᵣ_ (sym (·IdL _)) (sym (·IdL _)) ∙ sym (L𝐑.lem--075))
+                      ∙ ·ᵣComm _ _ ∙ 𝐑'.·DistL- _ _ _)))
+              (≤ᵣ-o·ᵣ _ _ _ (≤ℚ→≤ᵣ _ _ (ℚ.0≤pos _ _))
+                (slope-monotone-ₙ√ (suc n) _ _ _ _
+                  a<b a'<b' a≤a' b≤b'))
+
diff --git a/Cubical/HITs/CauchyReals/ExponentiationMore.agda b/Cubical/HITs/CauchyReals/ExponentiationMore.agda
new file mode 100644
index 0000000000..5fef3e0ff6
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/ExponentiationMore.agda
@@ -0,0 +1,2252 @@
+{-# OPTIONS --lossy-unification --safe #-}
+
+module Cubical.HITs.CauchyReals.ExponentiationMore 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.Foundations.Powerset
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.Structure
+
+open import Cubical.Functions.FunExtEquiv
+open import Cubical.Functions.Embedding
+open import Cubical.Functions.Surjection
+
+open import Cubical.Relation.Nullary
+
+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.Data.Unit
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.HITs.SetQuotients as SQ hiding (_/_)
+
+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
+open import Cubical.HITs.CauchyReals.Sequence
+open import Cubical.HITs.CauchyReals.Bisect
+-- open import Cubical.HITs.CauchyReals.BisectApprox
+open import Cubical.HITs.CauchyReals.NthRoot
+open import Cubical.HITs.CauchyReals.Derivative
+
+open import Cubical.HITs.CauchyReals.Exponentiation
+open import Cubical.HITs.CauchyReals.ExponentiationDer
+
+import Cubical.Algebra.CommRing.Instances.Int as ℤCRing
+open import Cubical.Algebra.Group.Instances.Bool
+open import Cubical.Algebra.Ring
+open import Cubical.Algebra.Ring.Properties
+open import Cubical.Algebra.Group
+open import Cubical.Algebra.Group.Morphisms
+open import Cubical.Algebra.Group.MorphismProperties
+import Cubical.Algebra.CommRing as CR
+
+open import Cubical.Algebra.Group.DirProd
+
+
+fromLipschitz'-rat : ∀ f isL q →
+  fst (fromLipschitz' (f ∘S rat) isL) (rat q) ≡ f (rat q)
+fromLipschitz'-rat f = PT.elim
+ (λ _ → isPropΠ λ _ → isSetℝ _ _)
+ λ _ _ → refl
+
+x+n·x≡sn·x : ∀ n x → x +ᵣ fromNat n ·ᵣ x ≡ fromNat (suc n) ·ᵣ x
+x+n·x≡sn·x n x = cong₂ _+ᵣ_
+  (sym (·IdL _)) refl ∙ sym (·DistR+ _ _ _)
+   ∙ cong (_·ᵣ x) (fromNat+ᵣ 1 n)
+
+
++Groupℝ : Group₀
++Groupℝ = Ring→Group Rℝ
+
+Is·₊Groupℝ : IsGroup 1 _₊·ᵣ_ invℝ₊
+Is·₊Groupℝ = makeIsGroup
+   isSetℝ₊
+   (λ _ _ _ → ℝ₊≡ (·ᵣAssoc _ _ _ ))
+   (λ _ → ℝ₊≡ (·IdR _)) (λ _ → ℝ₊≡ (·IdL _))
+   (λ (x , 0<x) → ℝ₊≡ (·invℝ' x 0<x))
+   (λ (x , 0<x) → ℝ₊≡ (·ᵣComm _ _ ∙ ·invℝ' x 0<x))
+
+ℝ₋₊ : Type
+ℝ₋₊ = Σ ℝ (0 ＃_)
+
+_·ᵣ₋₊_ : ℝ₋₊ → ℝ₋₊ → ℝ₋₊
+x ·ᵣ₋₊ x₁ = (fst x ·ᵣ fst x₁) , 0＃· _ _ (snd x) (snd x₁)
+
+ℝ₋₊≡ : ∀ {x y : ℝ₋₊} → fst x ≡ fst y → x ≡ y
+ℝ₋₊≡ = Σ≡Prop (isProp＃ 0)
+
+ℝ₋₊→ℝ₊×Bool : ℝ₋₊ → (ℝ₊ × Bool)
+ℝ₋₊→ℝ₊×Bool x = (absᵣ (fst x) , 0＃→0<abs _ (snd x)) ,
+  ⊎.rec (const true) (const false) (snd x)
+
+ℝ₊×Bool→ℝ₋₊ : (ℝ₊ × Bool) → ℝ₋₊
+ℝ₊×Bool→ℝ₋₊ x = (if (snd x) then (1 , inl decℚ<ᵣ?) else (-1 , inr decℚ<ᵣ?))
+  ·ᵣ₋₊ (fst (fst x) , inl (snd (fst x)))
+
+opaque
+ unfolding 0＃· absᵣ
+ sec-ℝ₋₊→ℝ₊×Bool : section ℝ₋₊→ℝ₊×Bool ℝ₊×Bool→ℝ₋₊
+ sec-ℝ₋₊→ℝ₊×Bool (x , false) =
+   cong₂ _,_
+   (ℝ₊≡ (·absᵣ _ _ ∙ ·IdL _ ∙ absᵣPos _ (snd x)))
+   refl
+ sec-ℝ₋₊→ℝ₊×Bool (x , true) =
+  cong₂ _,_
+   (ℝ₊≡ (·absᵣ _ _ ∙ ·IdL _ ∙ absᵣPos _ (snd x)))
+   refl
+
+ret-ℝ₋₊→ℝ₊×Bool : retract ℝ₋₊→ℝ₊×Bool ℝ₊×Bool→ℝ₋₊
+ret-ℝ₋₊→ℝ₊×Bool (fst₁ , inl x) =
+  ℝ₋₊≡ (·IdL _ ∙ absᵣPos _ x)
+ret-ℝ₋₊→ℝ₊×Bool (fst₁ , inr x) =
+  ℝ₋₊≡ (sym (-ᵣ≡[-1·ᵣ] _)
+    ∙∙ cong (-ᵣ_) (absᵣNeg _ x)
+    ∙∙ -ᵣInvol _)
+
+Iso-ℝ₋₊-ℝ₊×𝟚 : Iso ℝ₋₊ (ℝ₊ × Bool)
+Iso-ℝ₋₊-ℝ₊×𝟚 .Iso.fun  = ℝ₋₊→ℝ₊×Bool
+Iso-ℝ₋₊-ℝ₊×𝟚 .Iso.inv = ℝ₊×Bool→ℝ₋₊
+Iso-ℝ₋₊-ℝ₊×𝟚 .Iso.rightInv = sec-ℝ₋₊→ℝ₊×Bool
+Iso-ℝ₋₊-ℝ₊×𝟚 .Iso.leftInv = ret-ℝ₋₊→ℝ₊×Bool
+
+IsGroupℝˣ : IsGroup {G = ℝ₋₊}
+  (1 , inl decℚ<ᵣ?)
+  _·ᵣ₋₊_
+  λ (x , 0＃x) → invℝ x 0＃x , invℝ0＃ x 0＃x
+IsGroupℝˣ = makeIsGroup
+  (isSetΣ isSetℝ (isProp→isSet ∘ isProp＃ 0))
+  (λ _ _ _ → ℝ₋₊≡ (·ᵣAssoc _ _ _))
+  (λ _ → ℝ₋₊≡ (·IdR _)) (λ _ → ℝ₋₊≡ (·IdL _))
+  (λ _ → ℝ₋₊≡ (x·invℝ[x] _ _))
+  (λ _ → ℝ₋₊≡ (·ᵣComm _ _ ∙ x·invℝ[x] _ _))
+
+·₊Groupℝ : Group₀
+·₊Groupℝ = group _ _ _ _ Is·₊Groupℝ
+
+·Groupℝ : Group₀
+·Groupℝ = group _ _ _ _ IsGroupℝˣ
+
+
+-- GroupIso-ℝˣ-ℝˣ₊×𝟚 : GroupIso ·Groupℝ (DirProd ·₊Groupℝ BoolGroup)
+-- GroupIso-ℝˣ-ℝˣ₊×𝟚 = Iso-ℝ₋₊-ℝ₊×𝟚 , makeIsGroupHom {!!}
+
+
+module AutCont (Gstr : GroupStr ℝ) where
+
+ open GroupStr Gstr
+ Ĝ : Group₀
+ Ĝ = ℝ , Gstr
+
+ contGroupIso : Type
+ contGroupIso = Σ (GroupIso Ĝ Ĝ) λ x → (IsContinuous (Iso.fun (fst x))
+                                        × IsContinuous (Iso.inv (fst x)))
+ i≡ : ∀ {x₀ x₁ : contGroupIso} → Iso.fun (fst (fst x₀)) ≡ Iso.fun (fst (fst x₁)) → x₀ ≡ x₁
+ i≡ {x₀} {x₁} = Σ≡Prop (λ _ → isProp× (isPropIsContinuous _) (isPropIsContinuous _))
+  ∘ GroupIso≡ ∘ SetsIso≡fun isSetℝ isSetℝ
+
+
+ Aut[_]ᵣ : Group₀
+ Aut[_]ᵣ =
+   makeGroup {G = contGroupIso}
+     (idGroupIso , IsContinuousId , IsContinuousId)
+     (λ (a , b , c) (a' , b' , c') →
+       compGroupIso a a' , IsContinuous∘ _ _ b' b , IsContinuous∘ _ _ c c')
+     (λ (a , b , c) → invGroupIso a , c , b)
+     (isSetΣ (isSetΣ (isSet-SetsIso isSetℝ isSetℝ)
+        (λ _ → isProp→isSet (isPropIsGroupHom _ _)))
+         (λ _ → isProp→isSet (isProp× (isPropIsContinuous _) (isPropIsContinuous _))))
+     (λ _ _ _ → i≡ refl)
+          (λ _ → i≡ refl)
+          (λ _ → i≡ refl)
+          (λ ((x , _) , _) → i≡ (funExt (Iso.leftInv x)))
+          (λ ((x , _) , _) → i≡ (funExt (Iso.rightInv x)))
+
+
+
+open AutCont public using (Aut[_]ᵣ)
+
+module +GrAutomorphism (A : ⟨ (Aut[ +Groupℝ ]) ⟩) where
+
+ open IsGroupHom (snd A)
+ open Iso (fst A)
+
+ f-linℚ : ∀ x q → rat q ·ᵣ fun x ≡ fun (rat q ·ᵣ x)
+ f-linℚ x = SQ.ElimProp.go w
+  where
+
+  w'' : ∀ x n → fromNat n ·ᵣ fun x ≡ fun (fromNat n ·ᵣ x)
+  w'' x zero = 𝐑'.0LeftAnnihilates _ ∙∙
+    sym pres1 ∙∙ cong fun (sym (𝐑'.0LeftAnnihilates _))
+  w'' x (suc n) = sym (x+n·x≡sn·x n (fun x)) ∙∙
+     cong (fun x +ᵣ_) (w'' x n) ∙∙
+      (sym (pres· _ _) ∙ cong fun (x+n·x≡sn·x n x))
+
+
+  w' : ∀ n m → rat [ ℤ.pos m , (1+ n) ] ·ᵣ fun x ≡ fun (rat [ ℤ.pos m , (1+ n) ] ·ᵣ x)
+  w' n m = cong₂ _·ᵣ_ (cong rat (ℚ.[/]≡· (ℤ.pos m) (1+ n))
+      ∙ rat·ᵣrat _ _ ∙ ·ᵣComm  _ _)
+    refl ∙
+    (sym (·ᵣAssoc _ _ _) ∙
+     cong (rat [ pos 1 / 1+ n ] ·ᵣ_)
+       (w'' _ _)) ∙
+        cong (rat [ pos 1 / 1+ n ] ·ᵣ_)
+          (cong fun (cong (_·ᵣ x)
+           (cong rat (sym (m·n/m n m)) ∙ rat·ᵣrat _ _)
+           ∙ sym (·ᵣAssoc _ _ _)) ∙ sym (w'' _ _)) ∙ ·ᵣAssoc _ _ _
+          ∙ cong₂ _·ᵣ_ (sym (rat·ᵣrat _ _)
+           ∙ cong rat (ℚ.·Comm _ _
+            ∙ sym (ℚ.[/]≡· (pos (suc n)) (1+ n)) ∙
+            eq/ _ _ (ℤ.·Comm _ _))) refl ∙ ·IdL _
+
+
+  w : ElimProp (λ z → rat z ·ᵣ fun x ≡ fun (rat z ·ᵣ x))
+  w .ElimProp.isPropB _ = isSetℝ _ _
+  w .ElimProp.f (pos m , (1+ n)) = w' n m
+  w .ElimProp.f (ℤ.negsuc m , (1+ n)) =
+    cong₂ _·ᵣ_ (cong rat (ℚ.-[/] _ _) ∙ sym (-ᵣ-rat _)) refl  ∙ (-ᵣ· _ _)
+    ∙ cong -ᵣ_ (w' n (suc m)) ∙ sym (presinv _) ∙
+     cong fun (sym (-ᵣ· _ _) ∙
+       cong₂ _·ᵣ_ (-ᵣ-rat _ ∙ cong rat (sym (ℚ.-[/] _ _) )) refl)
+
+ α = fun 1
+
+ fun-rat : ∀ q → fun (rat q) ≡ rat q ·ᵣ α
+ fun-rat q = cong fun (sym (·IdR _)) ∙ sym (f-linℚ 1 q)
+
+ -- _ : {!!}
+ -- _ = {!fun-rat 1!}
+
+ Σfun' : Σ[ f' ∈ (ℝ → ℝ) ] ∃[ L ∈ ℚ₊ ] (Lipschitz-ℝ→ℝ L f')
+ Σfun' = fromLipschitz' (fun ∘ rat)
+  (PT.map
+     (λ (δ , <δ , δ<) →
+      let δ₊ = δ , ℚ.<→0< _
+             (<ᵣ→<ℚ _ _ (isTrans≤<ᵣ _ _ _
+              (0≤absᵣ _) <δ))
+      in δ₊ , λ q r ε x x₁ →
+          let u = ℚ.absFrom<×< (fst ε) (q ℚ.- r) x x₁
+          in invEq (∼≃abs<ε _ _ _)
+                (isTrans≡<ᵣ _ _ _
+                  (cong absᵣ (cong₂ _-ᵣ_ (fun-rat q) (fun-rat r)
+                   ∙ sym (𝐑'.·DistL- _ _ _))
+                    ∙ ·absᵣ _ _ ∙
+                     ·ᵣComm _ _ ∙
+                      cong (absᵣ α ·ᵣ_)
+                      (cong absᵣ (-ᵣ-rat₂ _ _) ∙ absᵣ-rat _ ) )
+                  (isTrans≤<ᵣ _ _ _
+                    (isTrans≤≡ᵣ _ _ _
+                      (≤ᵣ-·ᵣo _ _ _
+                        (≤ℚ→≤ᵣ _ _ (ℚ.0≤abs _) )
+                        (<ᵣWeaken≤ᵣ _ _ <δ))
+                      (sym (rat·ᵣrat _ _)))
+                    (<ℚ→<ᵣ _ _ (ℚ.<-o· _ _ _ (ℚ.0<ℚ₊ δ₊) u))))
+         )
+     (denseℚinℝ (absᵣ α) ((absᵣ α) +ᵣ 1)
+       (isTrans≡<ᵣ _ _ _
+         (sym (+IdR (absᵣ α)))
+         (<ᵣ-o+ 0 1 _ decℚ<ᵣ?))))
+
+
+ fun' = fst Σfun'
+
+ fun'-cont : IsContinuous fun'
+ fun'-cont = PT.rec
+  (isPropIsContinuous _)
+  (λ x → Lipschitz→IsContinuous _ _ (snd x))
+  (snd Σfun')
+
+ fun'· : ∀ x → fun' x ≡ x ·ᵣ α
+ fun'· = ≡Continuous _ _ fun'-cont
+   (IsContinuous·ᵣR α)
+    λ q → fromLipschitz'-rat fun _ _ ∙ fun-rat q
+
+ fun'-rat : ∀ x → fun' (rat x) ≡ fun (rat x)
+ fun'-rat x = fun'· (rat x) ∙ sym (fun-rat x)
+
+
+
+-- .Elimℝ-Prop2Sym.rat-ratA r q p =
+--     let z = sym (fun'-rat r) ∙∙ p ∙∙ fun'-rat q
+--     in isoFunInjective (fst A) _ _ z
+--   w .Elimℝ-Prop2Sym.rat-limA = {!!}
+--   w .Elimℝ-Prop2.lim-limA = {!!}
+--   w .Elimℝ-Prop2.isPropA _ _ = isPropΠ λ _ → isSetℝ _ _
+
+ -- fun'·-equiv : isEquiv fun'
+ -- fun'·-equiv = isEmbedding×isSurjection→isEquiv {f = fun'}
+ --  (fun-emb , {!!})
+
+-- module +GrAutomorphism-Cont (A : ⟨ (Aut[ +Groupℝ ]) ⟩) where
+
+--  module F = +GrAutomorphism A
+--  module F' = +GrAutomorphism (invGroupIso A)
+
+--  isom' : Iso ℝ ℝ
+--  isom' .Iso.fun = F.fun'
+--  isom' .Iso.inv = F'.fun'
+--  isom' .Iso.rightInv = {!!}
+--  -- ≡Continuous _ _
+--  --   (IsContinuous∘ _ _ F.fun'-cont F'.fun'-cont) IsContinuousId
+--  --     λ r → {!!}
+--  isom' .Iso.leftInv = {!!}
+
+--  α·α'≡1 : F'.α ·ᵣ F.α ≡ 1
+--  α·α'≡1 = sym (F.fun'· _)
+--   ∙  cong F.fun' (sym (·IdL _) ∙ sym (F'.fun'· _)) ∙ isom' .Iso.rightInv 1
+
+--  g-linℚ : ∀ x q → rat q ·ᵣ g x ≡ g (rat q ·ᵣ x)
+--  g-linℚ = {!!}
+
+
+--  β = g 1
+
+
+--  g-rat : ∀ q → g (rat q) ≡ rat q ·ᵣ β
+--  g-rat q = cong g (sym (·IdR _)) ∙ sym (g-linℚ 1 q)
+
+
+--  α·β=1 : α ·ᵣ β ≡ 1
+--  α·β=1 =
+--    let q : ℚ
+--        q = {!!}
+--        pp : {!!}
+--        pp =     cong g {!f
+--        !}
+--                ∙ Iso.leftInv (fst A) (rat q)
+--    in {!!}
+
+--  -- f≠1 : f 1 ≡ 0 → ⊥
+--  -- f≠1 p = {!inj-rat _ _
+--  --   (isoFunInjective (fst A) _ _ (p ∙ sym (pres1)))!}
+
+--  0<∣α∣ : 0 <ᵣ absᵣ α
+--  0<∣α∣ = {! !}
+
+
+-- --  _ : {!!}
+-- --  _ = {!g (absᵣ α)!}
+
+
+-- --  f-cont : IsContinuous f
+-- --  f-cont u ε =
+-- --   PT.map
+-- --     {!!}
+-- --     {!!}
+
+
+Invlipschitz-ℝ→ℝ→injective-interval : ∀ K a b f →
+ Invlipschitz-ℝ→ℝℙ K (intervalℙ a b) f
+    → ∀ x x∈ y y∈ → f x x∈ ≡ f y y∈ → x ≡ y
+Invlipschitz-ℝ→ℝ→injective-interval K a b f il x x∈ y y∈ =
+ fst (∼≃≡ _ _) ∘
+   (λ p ε → subst∼ (ℚ.y·[x/y] K (fst ε))
+     (il x x∈ y  y∈ ((invℚ₊ K) ℚ₊· ε) (p (invℚ₊ K ℚ₊· ε))))
+   ∘S invEq (∼≃≡ _ _)
+
+
+intervalℙ→dist< : ∀ a b x y → x ∈ intervalℙ a b → y ∈ intervalℙ a b
+                   → absᵣ (x -ᵣ y) ≤ᵣ b -ᵣ a
+intervalℙ→dist< a b x y (a≤x , x≤b) (a≤y , y≤b) =
+  isTrans≡≤ᵣ _ _ _ (abs-max _ ∙ cong (maxᵣ _) (-[x-y]≡y-x _ _) )
+    (max≤-lem _ _ _ (≤ᵣMonotone+ᵣ _ _ _ _ x≤b (-ᵣ≤ᵣ _ _ a≤y))
+                    ((≤ᵣMonotone+ᵣ _ _ _ _ y≤b (-ᵣ≤ᵣ _ _ a≤x))))
+
+
+
+ℚ1≤x⊔1/x : ∀ x → 1 ℚ.≤ ℚ.max (fst x) (fst (invℚ₊ x))
+ℚ1≤x⊔1/x x =
+  ⊎.rec
+     (λ 1≤x →
+       ℚ.isTrans≤ _ _ _ 1≤x (ℚ.≤max (fst x) (fst (invℚ₊ x))) )
+     (λ x<1 →
+       ℚ.isTrans≤ _ _ _ (ℚ.invℚ≤invℚ 1 _
+         (ℚ.<Weaken≤ _ _ x<1))
+         (ℚ.≤max' (fst x) (fst (invℚ₊ x))))
+   (ℚ.Dichotomyℚ 1 (fst x))
+
+
+
+1≤x⊔1/x : ∀ x → 1 ≤ᵣ maxᵣ (fst x) (fst (invℝ₊ x))
+1≤x⊔1/x =
+  uncurry (<→≤ContPos'pred {0}
+    (AsContinuousWithPred _ _
+      (IsContinuousConst _))
+       (contDiagNE₂WP maxR _ _ _
+         (AsContinuousWithPred _ _
+           IsContinuousId) (snd invℝ'))
+             λ u 0<u →
+               subst (1 ≤ᵣ_) (cong (maxᵣ (rat u))
+                 (sym (invℝ'-rat _ _ _)))
+                 (≤ℚ→≤ᵣ _ _ (
+                  (ℚ1≤x⊔1/x (u , ℚ.<→0< u (<ᵣ→<ℚ _ _ 0<u))))))
+
+
+0<pos[sucN]² : ∀ n → 0 ℤ.< (ℤ.pos (suc n)) ℤ.· (ℤ.pos (suc n))
+0<pos[sucN]² n = ℤ.<-·o {0} {ℤ.pos (suc n)} {n} (ℤ.suc-≤-suc ℤ.zero-≤pos)
+
+0<x² : ∀ n → ¬ (n ≡ 0) → 0 ℤ.< n ℤ.· n
+0<x² (pos zero) x = ⊥.elim (x refl)
+0<x² (pos (suc n)) _ = 0<pos[sucN]² n
+0<x² (ℤ.negsuc n) _ = subst (0 ℤ.<_) (sym (ℤ.negsuc·negsuc n n))
+  (0<pos[sucN]² n)
+
+mn<m²+n² : (a b : ℕ) → pos (suc a) ℤ.· pos (suc b) ℤ.<
+                    (pos (suc a) ℤ.· pos (suc a))
+                      ℤ.+ (pos (suc b) ℤ.· pos (suc b))
+mn<m²+n² a b =
+  ℤ.<-+pos-trans {k = a ℕ.· suc b} h'
+ where
+ a' = pos (suc a)
+ b' = pos (suc b)
+ h : ((a' ℤ.· b') ℤ.+ (a' ℤ.· b')) ℤ.≤
+         (a' ℤ.· a' ℤ.+ b' ℤ.· b')
+ h = subst2 (ℤ._≤_)
+       (𝐙'.+IdL' _ _ refl)
+       (cong (ℤ._+ ((a' ℤ.· b') ℤ.+ (a' ℤ.· b'))) (L𝐙.lem--073 {a'} {b'})
+        ∙ 𝐙'.minusPlus _ _)
+       (ℤ.≤-+o {o = ((a' ℤ.· b') ℤ.+ (a' ℤ.· b'))} (ℤ.0≤x² (a' ℤ.- b')))
+
+ h' = ℤ.<≤-trans (ℤ.<-o+ (subst (ℤ._< a' ℤ.· b')
+     (sym (ℤ.pos·pos _ _)) (ℤ.<-·o {k = b}
+       ℤ.isRefl≤))) h
+
+
+ℚ1<x+1/x : ∀ x → 1 ℚ.< fst x ℚ.+ fst (invℚ₊ x)
+ℚ1<x+1/x = uncurry (SQ.ElimProp.go w)
+ where
+ w : ElimProp (λ z → (y : 0< z) → 1 ℚ.< z ℚ.+ fst (invℚ₊ (z , y)))
+ w .ElimProp.isPropB _ = isPropΠ λ _ → ℚ.isProp< _ _
+ w .ElimProp.f (pos (suc n) , (1+ m)) y =
+    subst2 ℤ._<_
+      (sym (ℤ.pos·pos  _ _)) (ℤ.+Comm _ _ ∙ sym (ℤ.·IdR _))
+     (mn<m²+n² m n)
+opaque
+ unfolding _+ᵣ_
+ 1≤x+1/x : ∀ x → 1 ≤ᵣ fst x +ᵣ fst (invℝ₊ x)
+ 1≤x+1/x =
+   uncurry (<→≤ContPos'pred {0}
+     (AsContinuousWithPred _ _
+       (IsContinuousConst _))
+        (contDiagNE₂WP sumR _ _ _
+          (AsContinuousWithPred _ _
+            IsContinuousId) (snd invℝ'))
+              λ u 0<u →
+                subst (1 ≤ᵣ_) (cong (rat u +ᵣ_)
+                  (sym (invℝ'-rat _ _ _)))
+                  (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ 1 _
+                   (ℚ1<x+1/x (u , ℚ.<→0< u (<ᵣ→<ℚ _ _ 0<u))))))
+
+-- pasting : (x₀ : ℝ) → (f< : ∀ x → x ≤ᵣ x₀ → ℝ)
+--                   → (<f : ∀ x → x₀ ≤ᵣ x → ℝ)
+--                   → f< x₀ (≤ᵣ-refl x₀) ≡ <f x₀ (≤ᵣ-refl x₀)
+--                   → Σ[ f ∈ (ℝ → ℝ) ]
+--                         (∀ x x≤x₀ → f x ≡ f< x x≤x₀)
+--                          × (∀ x x₀≤x → f x ≡ <f x x₀≤x)
+-- pasting x₀ f< <f p =
+--   (λ x → (<f (maxᵣ x₀ x) (≤maxᵣ _ _)
+--       +ᵣ f< (minᵣ x₀ x) (min≤ᵣ _ _))
+--        -ᵣ f< x₀ (≤ᵣ-refl x₀))
+--   , (λ x x≤x₀ →
+--       let z = minᵣComm _ _ ∙ ≤→minᵣ _ _ x≤x₀
+--       in cong₂ _-ᵣ_ (cong₂ _+ᵣ_
+--              (cong (uncurry <f) (Σ≡Prop (λ _ → isProp≤ᵣ _ _)
+--                (maxᵣComm _ _ ∙ ?))) -- x≤x₀
+--              (cong (uncurry f<) (Σ≡Prop (λ _ → isProp≤ᵣ _ _) z)) ) p ∙
+--           L𝐑.lem--063)
+--   , λ x x₀≤x →
+--        𝐑'.plusMinus' _ _ _ (cong (uncurry f<)
+--         (Σ≡Prop (λ _ → isProp≤ᵣ _ _) (≤→minᵣ _ _ x₀≤x))) ∙
+--         (cong (uncurry <f)
+--         (Σ≡Prop (λ _ → isProp≤ᵣ _ _) ?)) -- x₀≤x
+
+
+-- pasting< : ∀ b x₀ b<x₀
+--                   → (f< : ∀ x → b <ᵣ x → x ≤ᵣ x₀ → ℝ)
+--                   → (<f : ∀ x → x₀ ≤ᵣ x → ℝ)
+--                   → f< x₀ b<x₀ (≤ᵣ-refl x₀) ≡ <f x₀ (≤ᵣ-refl x₀)
+--                   → Σ[ f ∈ (∀ x → b <ᵣ x → ℝ) ]
+--                         (∀ x b<x x≤x₀ → f x b<x ≡ f< x b<x x≤x₀)
+--                          × (∀ x b<x x₀≤x → f x b<x ≡ <f x x₀≤x)
+-- pasting< b x₀ b<x₀ f< <f p =
+--    ((λ x x< → (<f (maxᵣ x₀ x) (≤maxᵣ _ _)
+--       +ᵣ f< (minᵣ x₀ x) (<min-lem _ _ _ b<x₀ x<) (min≤ᵣ _ _))
+--        -ᵣ f< x₀ b<x₀ (≤ᵣ-refl x₀)))
+--   , (λ x b<x x≤x₀ →
+--       let z = minᵣComm _ _ ∙ ≤→minᵣ _ _ x≤x₀
+--       in cong₂ _-ᵣ_ (cong₂ _+ᵣ_
+--              (cong (uncurry <f) (Σ≡Prop (λ _ → isSetℝ _ _)
+--                (maxᵣComm _ _ ∙ x≤x₀)))
+--              (cong (uncurry (uncurry f<))
+--                (Σ≡Prop (flip isProp≤ᵣ _ ∘ fst) (Σ≡Prop (isProp<ᵣ _) z)))
+--              ) p ∙
+--           L𝐑.lem--063)
+--    , λ x b<x x₀≤x →
+--      𝐑'.plusMinus' _ _ _ (cong (uncurry (uncurry f<))
+--         (Σ≡Prop (λ (x , _) → isProp≤ᵣ x _) (Σ≡Prop (isProp<ᵣ _) (≤→minᵣ _ _ x₀≤x))) ) ∙
+--        cong (uncurry <f) ((Σ≡Prop (λ _ → isSetℝ _ _) x₀≤x))
+
+
+
+-- pasting≤ : ∀ b x₀ b≤x₀
+--                   → (f< : ∀ x → b ≤ᵣ x → x ≤ᵣ x₀ → ℝ)
+--                   → (<f : ∀ x → x₀ ≤ᵣ x → ℝ)
+--                   → f< x₀ b≤x₀ (≤ᵣ-refl x₀) ≡ <f x₀ (≤ᵣ-refl x₀)
+--                   → Σ[ f ∈ (∀ x → b ≤ᵣ x → ℝ) ]
+--                         (∀ x b≤x x≤x₀ → f x b≤x ≡ f< x b≤x x≤x₀)
+--                          × (∀ x b≤x x₀≤x → f x b≤x ≡ <f x x₀≤x)
+-- pasting≤ b x₀ b≤x₀ f< <f p =
+--   (λ x _ → (fst h) x)
+--   , (λ x b≤x x≤x₀ → fst (snd h) x x≤x₀ ∙ q b≤x)
+--   ,  const ∘ snd (snd h)
+--  where
+
+--  q : ∀ {y y' : Σ[ x ∈ ℝ ] (b ≤ᵣ x) × (x ≤ᵣ x₀)}
+--          → (a : (fst y) ≡ (fst y')) → _ ≡ _
+--  q {y} {y'} = cong {x = y} {y = y'} (uncurry $ uncurry ∘ f<) ∘
+--          (Σ≡Prop (λ _ → isProp× (isSetℝ _ _) (isSetℝ _ _)))
+
+--  h = pasting x₀
+--        (λ x x≤x₀ → f< (maxᵣ b x) (≤maxᵣ _ _)
+--          (max≤-lem _ _ _ b≤x₀ x≤x₀))
+--        <f (q b≤x₀ ∙ p)
+
+
+opaque
+ unfolding _+ᵣ_
+ slope-lower-bound : (z : ℝ₊) (B : ℚ₊) (1<z : 1 <ᵣ fst z) → (y₀ y₁ : ℚ )
+   → (y₀<y₁ : y₀ ℚ.< y₁)
+   → (y₀∈ : y₀ ∈ ℚintervalℙ (ℚ.- (fst B)) (fst B))
+   → (y₁∈ : y₁ ∈ ℚintervalℙ (ℚ.- (fst B)) (fst B)) →
+   fst (z ^ℚ (ℚ.- fst B)) ·ᵣ
+        ((fst z -ᵣ 1) ／ᵣ₊ z)
+       <ᵣ
+   ((fst (z ^ℚ y₁) -ᵣ fst (z ^ℚ y₀))
+     ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  y₀<y₁ ))
+ slope-lower-bound z B 1<z y₀ y₁ y₀<y₁ (-B≤y₀ , y₀≤B) (-B≤y₁ , y₁≤B) =
+   isTrans<≡ᵣ _ _ _
+     (≤<ᵣ₊Monotone·ᵣ
+       ((z ^ℚ (ℚ.- (fst B)))) (fst (z ^ℚ y₀))
+       (_ ,
+         isTrans≡≤ᵣ _ _ _ (sym (𝐑'.0LeftAnnihilates _))
+            (≤ᵣ-·ᵣo 0 _ _
+             (<ᵣWeaken≤ᵣ _ _ (snd (invℝ₊ (fst z , z .snd))))
+              (<ᵣWeaken≤ᵣ _ _ (x<y→0<y-x _ _ 1<z))))
+               ((fst (z ^ℚ (fst h₊)) -ᵣ 1) ／ᵣ₊ ℚ₊→ℝ₊ h₊)
+
+       (^ℚ-MonotoneR {z} (ℚ.- (fst B)) y₀ -B≤y₀ (<ᵣWeaken≤ᵣ _ _ 1<z))
+
+        (invEq (z/y'<x/y≃y₊·z<y'₊·x _ _ _ _)
+           brn )
+        )
+       (·ᵣAssoc _ _ _
+        ∙ cong (_·ᵣ
+         fst (invℝ₊ (ℚ₊→ℝ₊ h₊)))
+          (sym (factor-xᵃ-xᵇ z _ _) ))
+
+  where
+   h₊ : ℚ₊
+   h₊ = ℚ.<→ℚ₊ _ _ y₀<y₁
+
+   brn : fst (ℚ₊→ℝ₊ h₊) ·ᵣ (fst z -ᵣ 1)   <ᵣ
+         fst z ·ᵣ (fst (z ^ℚ fst h₊) -ᵣ rat [ pos 1 / 1+ 0 ])
+
+   brn = isTrans<≡ᵣ _ _ _ (a+c<b⇒a<b-c _ _ _ (isTrans≡<ᵣ _ _ _ (sym (·DistR+ (fst (ℚ₊→ℝ₊ h₊)) 1 _))
+          (a+c<b⇒a<b-c _ _ 1
+           (isTrans≡<ᵣ _ _ _
+            (+ᵣComm (rat (fst h₊ ℚ.+ [ pos 1 / 1+ 0 ]) ·ᵣ
+       (fst z -ᵣ rat [ pos 1 / 1+ 0 ])) 1) (bernoulli's-ineq-^ℚ z (fst h₊ ℚ.+ 1)
+             1<z (subst (1 ℚ.<_) (ℚ.+Comm 1 (fst h₊))
+              (ℚ.<+ℚ₊' _ _ h₊ (ℚ.isRefl≤ 1))) )))))
+             (sym (+ᵣAssoc (fst (z ^ℚ (fst h₊ ℚ.+ 1))) _ _) ∙
+              cong₂ _+ᵣ_
+                (cong fst (sym (^ℚ-+ z (fst h₊) 1))
+                  ∙ ·ᵣComm _ _ ∙
+                    cong (_·ᵣ (z ^ℚ fst h₊) .fst) (cong fst (^ℚ-1 _) ))
+                ((sym (-ᵣDistr _ _) ∙
+                  cong (-ᵣ_) (cong (1 +ᵣ_) (·IdL _)
+                   ∙ L𝐑.lem--05 ∙ sym (·IdL _))
+                  ) ∙ sym (-ᵣ· _ _) ∙ ·ᵣComm _ _)
+               ∙ sym (·DistL+ _ _ _) )
+
+
+slope-upper-bound : (z : ℝ₊) (B : ℚ₊) → (y₀ y₁ : ℚ )
+  → (y₀<y₁ : y₀ ℚ.< y₁)
+  → (y₀∈ : y₀ ∈ ℚintervalℙ (ℚ.- (fst B)) (fst B))
+  → (y₁∈ : y₁ ∈ ℚintervalℙ (ℚ.- (fst B)) (fst B)) →
+  ((fst (z ^ℚ y₁) -ᵣ fst (z ^ℚ y₀))
+    ／ᵣ₊ ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _  y₀<y₁ ))
+     ≤ᵣ fst (z ^ℚ (fst B)) ·ᵣ (fst z -ᵣ 1)
+slope-upper-bound z B y₀ y₁ y₀<y₁ (-B≤y₀ , y₀≤B) (-B≤y₁ , y₁≤B) =
+  isTrans≤≡ᵣ _ _ _
+    (slope-monotone z
+      y₀ y₁ (fst B) (fst B ℚ.+ 1)
+       y₀<y₁ B<B+1 y₀≤B
+         (ℚ.isTrans≤ _ _ _ y₁≤B (ℚ.<Weaken≤ _ _ B<B+1))
+         )
+    (𝐑'.·IdR' _ _ (cong (fst ∘ invℝ₊)
+      (ℝ₊≡ (cong rat lem--063)) ∙ cong fst invℝ₊1) ∙
+       factor-xᵃ-xᵇ z (fst B ℚ.+ 1) (fst B) ∙
+         cong (λ u → fst (z ^ℚ fst B) ·ᵣ (fst u -ᵣ 1))
+           (cong (z ^ℚ_) lem--063 ∙ ^ℚ-1 z))
+
+ where
+  h₊ = ℚ.<→ℚ₊ _ _ y₀<y₁
+  B<B+1 = ℚ.<+ℚ₊' _ _ 1 (ℚ.isRefl≤ (fst B))
+
+
+-- -- lowBnd-1/ℕ : (ε : ℝ₊) → ∃[ k ∈ ℕ₊₁ ] rat [ 1 / k ] <ᵣ fst ε
+-- -- lowBnd-1/ℕ = {!!}
+
+
+-- -- ceilℚ₊ q = 1+ (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)))))
+
+
+slUpBd : ℕ → ℕ → ℚ₊
+slUpBd Z m = (fromNat (suc (suc Z)) ℚ₊^ⁿ (suc m)) ℚ₊· fromNat (suc Z)
+
+
+
+monotone^ℚ' : ∀ q q' q''
+ → q ℚ.≤ q'
+ → q' ℚ.≤ q''
+ → ∀ u 0<u
+ → minᵣ (fst ((rat u , 0<u) ^ℚ q)) (fst ((rat u , 0<u) ^ℚ q'')) ≤ᵣ
+   fst ((rat u , 0<u) ^ℚ q')
+monotone^ℚ' q q' q'' q≤q' q'≤q'' u 0<u =
+ ⊎.rec
+   (λ 1≤u →
+     isTrans≤ᵣ _ _ _ (min≤ᵣ (fst ((rat u , 0<u) ^ℚ q))
+            (fst ((rat u , 0<u) ^ℚ q'')))
+        (^ℚ-MonotoneR {(rat u , 0<u)} q q'
+           q≤q'
+        (≤ℚ→≤ᵣ _ _ 1≤u)))
+   (λ u<1 → isTrans≤ᵣ _ _ _
+     (min≤ᵣ' (fst ((rat u , 0<u) ^ℚ q))
+            (fst ((rat u , 0<u) ^ℚ q'')))
+       let xx = (^ℚ-MonotoneR {invℝ₊ (rat u , 0<u)}
+               _ _  (ℚ.minus-≤ _ _ q'≤q'')
+                   (isTrans≤≡ᵣ _ _ _
+                    (invEq (z≤x/y₊≃y₊·z≤x 1 1 (rat u , 0<u))
+                      (isTrans≡≤ᵣ _ _ _ (·IdR _)
+                        (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ u<1))))
+                    (·IdL _)))
+       in subst2 _≤ᵣ_
+            (cong fst (sym (^ℚ-minus _ _)))
+            (cong fst (sym (^ℚ-minus _ _)))
+            xx)
+   (ℚ.Dichotomyℚ 1 u)
+
+
+
+monotone^ℚ : ∀ q q' q''
+ → q ℚ.≤ q'
+ → q' ℚ.≤ q''
+ → ∀ z
+ → minᵣ (fst (z ^ℚ q)) (fst (z ^ℚ q'')) ≤ᵣ fst (z ^ℚ q')
+monotone^ℚ q q' q'' q≤q' q'≤q'' =
+  uncurry (<→≤ContPos'pred {0}
+    (contDiagNE₂WP minR _ _ _
+      (IsContinuous^ℚ q)
+      (IsContinuous^ℚ q''))
+    (IsContinuous^ℚ q')
+    λ u 0<u → monotone^ℚ' q q' q'' q≤q' q'≤q'' u 0<u)
+
+-- module BDL (z : ℝ₊) (Z : ℕ)
+--           (z≤Z : fst z ≤ᵣ fromNat (suc (suc Z)))
+--           (1/Z≤z : rat [ 1 / fromNat (suc (suc Z)) ]  ≤ᵣ fst z)
+--           -- (1+1/Z<z : rat (1 ℚ.+ [ 1 / 1+ (suc Z) ]) ≤ᵣ fst z )
+--            where
+
+
+-- bdl' : 1 ≤ᵣ fst z → boundedLipschitz (fst ∘ z ^ℚ_) (slUpBd Z)
+-- bdl' 1≤z n = ℚ.elimBy≡⊎<
+--  (λ x y X y∈ x∈ → subst2 _≤ᵣ_
+--       (minusComm-absᵣ _ _)
+--       (cong (rat ∘ (fst (slUpBd Z n) ℚ.·_)) (ℚ.absComm- _ _))
+--       (X x∈ y∈)  )
+--  (λ x _ _ → subst2 _≤ᵣ_
+--     (cong absᵣ (sym (+-ᵣ _)))
+--     (cong rat (sym (𝐐'.0RightAnnihilates' _ _ (cong ℚ.abs (ℚ.+InvR x)))))
+--     (≤ᵣ-refl 0))
+--  λ y₀ y₁ y₀<y₁ y₀∈ y₁∈ →
+--   isTrans≡≤ᵣ _ _ _ (absᵣNonNeg _ (x≤y→0≤y-x _ _
+--         (^ℚ-MonotoneR _ _ (ℚ.<Weaken≤ _ _ y₀<y₁) 1≤z )))
+--     (isTrans≤≡ᵣ _ _ _ (isTrans≤ᵣ _ _ _ (
+--    (fst (z/y≤x₊≃z≤y₊·x _ _ _) (slope-upper-bound z (fromNat (suc n))
+--    y₀ y₁ y₀<y₁
+--     (ℚ.absTo≤×≤ (fromNat (suc n)) y₀ y₀∈)
+--     (ℚ.absTo≤×≤ (fromNat (suc n)) y₁ y₁∈))))
+--      (≤ᵣ-o· _ _ _ (ℚ.<Weaken≤ 0 _ (ℚ.-< _ _ y₀<y₁))
+--       (≤ᵣ₊Monotone·ᵣ _ _ _ _
+--         (<ᵣWeaken≤ᵣ _ _ $ snd (fromNat (suc (suc Z)) ^ℚ fst (fromNat (suc n))))
+--         (x≤y→0≤y-x _ _ 1≤z)
+--         (^ℚ-Monotone {y = fromNat (suc (suc Z))}
+--          (fromNat (suc n)) z≤Z)
+--         (≤ᵣ-+o _ _ (-1) z≤Z))))
+--      (·ᵣComm _ _ ∙
+--       cong₂ (_·ᵣ_)
+--         (cong₂ (_·ᵣ_) (^ⁿ-ℚ^ⁿ _ _) (cong rat (ℚ.ℤ+→ℚ+ _ _))
+--          ∙ sym (rat·ᵣrat _ _) )
+--         (cong rat (sym (ℚ.absPos _ (ℚ.-< _ _ y₀<y₁))))
+--        ∙ sym (rat·ᵣrat _ _)))
+
+
+
+-- --  slUpBdInv : ℕ → ℚ₊
+-- --  slUpBdInv m = (fromNat (suc (suc Z))) ℚ₊^ⁿ (suc (suc (suc m)))
+-- --      -- ℚ₊· ((invℚ₊ (fromNat (suc (suc Z)))) ℚ₊· invℚ₊ (fromNat (suc (suc Z))))
+-- -- -- ((fst z -ᵣ 1) ／ᵣ₊ z)
+
+--  -- slpBdIneq : ∀ n → fst (invℚ₊ (slUpBdInv n)) ℚ.≤
+--  --    fst (slUpBd n)
+--  -- slpBdIneq n = ℚ.isTrans≤ _ 1 _
+--  --   (fst (ℚ.invℚ₊-≤-invℚ₊ 1 _)
+--  --     (ℚ.1≤x^ⁿ (fromNat (suc (suc Z)))
+--  --          (suc (suc (suc n)))
+--  --          (ℚ.≤ℤ→≤ℚ 1 (pos (suc (suc Z)))
+--  --            (ℤ.suc-≤-suc {0} {pos (suc Z)}
+--  --             (ℤ.zero-≤pos {suc Z})))))
+--  --   (ℚ.≤Monotone·-onNonNeg 1 _ 1 _
+--  --    ((ℚ.1≤x^ⁿ (fromNat (suc (suc Z)))
+--  --          ((suc n))
+--  --          (ℚ.≤ℤ→≤ℚ 1 (pos (suc (suc Z)))
+--  --            (ℤ.suc-≤-suc {0} {pos (suc Z)}
+--  --             (ℤ.zero-≤pos {suc Z})))))
+--  --    ((ℚ.≤ℤ→≤ℚ 1 (pos (suc Z))
+--  --            (ℤ.suc-≤-suc {0} {pos Z}
+--  --             (ℤ.zero-≤pos {Z}))))
+--  --    (ℚ.decℚ≤? {0} {1})
+--  --    (ℚ.decℚ≤? {0} {1}))
+
+-- --  1<z : 1 <ᵣ (fst z)
+-- --  1<z = isTrans<ᵣ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.<+ℚ₊' _ _ _ (ℚ.isRefl≤ 1))) 1+1/Z<z
+
+
+-- clampᵣ₊ : ℝ₊ → ℝ₊ → ℝ₊ → ℝ₊
+-- clampᵣ₊ d u x = minᵣ₊ (maxᵣ₊ d x) u
+
+isIncrasingℙᵣ : (P : ℙ ℝ) → (∀ (x : ℝ) → x ∈ P → ℝ) → Type
+isIncrasingℙᵣ P f =
+ ∀ (x : ℝ) (x∈ : x ∈ P) (y : ℝ) (y∈ : y ∈ P) → x <ᵣ y → f x x∈ <ᵣ f y y∈
+
+
+isNondecrasingℙᵣ : (P : ℙ ℝ) → (∀ (x : ℝ) → x ∈ P → ℝ) → Type
+isNondecrasingℙᵣ P f =
+ ∀ (x : ℝ) (x∈ : x ∈ P) (y : ℝ) (y∈ : y ∈ P) → x ≤ᵣ y → f x x∈ ≤ᵣ f y y∈
+
+
+∈interval→≤ContPos'pred : {x₀ x₁ : ℚ} → (x₀ ℚ.≤ x₁)
+         → {f₀ f₁ : ∀ x → x ∈ intervalℙ (rat x₀) (rat x₁)   → ℝ}
+         → IsContinuousWithPred (intervalℙ (rat x₀) (rat x₁)) f₀
+         → IsContinuousWithPred (intervalℙ (rat x₀) (rat x₁)) f₁
+         → (∀ u x₀<u<x₁ → f₀ (rat u) x₀<u<x₁
+                    ≤ᵣ f₁ (rat u) x₀<u<x₁ )
+             → ∀ x x₀<x<x₁ → f₀ x x₀<x<x₁ ≤ᵣ f₁ x x₀<x<x₁
+∈interval→≤ContPos'pred {x₀} {x₁} x₀≤x₁ {f₀} {f₁} f₀C f₁C X x (≤x , x≤) =
+  subst (λ (u , u∈) → f₀ u u∈ ≤ᵣ f₁ u u∈)
+   (Σ≡Prop (∈-isProp ((intervalℙ (rat x₀) (rat x₁))))
+     (sym (∈ℚintervalℙ→clampᵣ≡ _ _ _ (≤x , x≤))))
+   $ ≤Cont
+     {λ x → f₀ (clampᵣ (rat x₀) (rat x₁) x)
+       (clampᵣ∈ℚintervalℙ _ _ (≤ℚ→≤ᵣ _ _ x₀≤x₁) _)}
+     {λ x → f₁ (clampᵣ (rat x₀) (rat x₁) x)
+      ((clampᵣ∈ℚintervalℙ _ _ (≤ℚ→≤ᵣ _ _ x₀≤x₁) _))}
+     (IsContinuousWithPred∘IsContinuous _ _ _
+         _ f₀C (IsContinuousClamp (rat x₀) (rat x₁)))
+     (IsContinuousWithPred∘IsContinuous _ _ _
+         _ f₁C (IsContinuousClamp (rat x₀) (rat x₁)))
+     (λ u →
+        X (ℚ.clamp x₀ x₁ u) (clampᵣ∈ℚintervalℙ (rat x₀) (rat x₁) (≤ℚ→≤ᵣ x₀ x₁ x₀≤x₁) (rat u)))
+     x
+
+module BDL (z : ℝ₊) (Z : ℕ)
+          (z≤Z : fst z ≤ᵣ fromNat (suc (suc Z)))
+          (1/Z≤z : rat [ 1 / fromNat (suc (suc Z)) ]  ≤ᵣ fst z)
+          -- (1+1/Z<z : rat (1 ℚ.+ [ 1 / 1+ (suc Z) ]) ≤ᵣ fst z )
+           where
+
+ opaque
+  unfolding _+ᵣ_
+  bdl' : (z : ℝ₊) (Z : ℕ)
+           (z≤Z : fst z ≤ᵣ fromNat (suc (suc Z)))
+           (1/Z≤z : rat [ 1 / fromNat (suc (suc Z)) ]  ≤ᵣ fst z)
+           → 1 ≤ᵣ fst z → boundedLipschitz (fst ∘ z ^ℚ_) (slUpBd Z)
+  bdl' z Z z≤Z 1/Z≤z 1≤z n = ℚ.elimBy≡⊎<
+   (λ x y X y∈ x∈ → subst2 _≤ᵣ_
+        (minusComm-absᵣ _ _)
+        (cong (rat ∘ (fst (slUpBd Z n) ℚ.·_)) (ℚ.absComm- _ _))
+        (X x∈ y∈)  )
+   (λ x _ _ → subst2 _≤ᵣ_
+      (cong absᵣ (sym (+-ᵣ _)))
+      (cong rat (sym (𝐐'.0RightAnnihilates' _ _ (cong ℚ.abs (ℚ.+InvR x)))))
+      (≡ᵣWeaken≤ᵣ _ _ (absᵣ-rat 0))) -- (≤ᵣ-refl 0)
+   λ y₀ y₁ y₀<y₁ y₀∈ y₁∈ →
+    isTrans≡≤ᵣ _ _ _ (absᵣNonNeg _ (x≤y→0≤y-x _ _
+          (^ℚ-MonotoneR _ _ (ℚ.<Weaken≤ _ _ y₀<y₁) 1≤z )))
+      (isTrans≤≡ᵣ _ _ _ (isTrans≤ᵣ _ _ _ (
+     (fst (z/y≤x₊≃z≤y₊·x _ _ _) (slope-upper-bound z (fromNat (suc n))
+     y₀ y₁ y₀<y₁
+      (ℚ.absTo≤×≤ (fromNat (suc n)) y₀ y₀∈)
+      (ℚ.absTo≤×≤ (fromNat (suc n)) y₁ y₁∈))))
+       (≤ᵣ-o· _ _ _ (ℚ.<Weaken≤ 0 _ (ℚ.-< _ _ y₀<y₁))
+        (≤ᵣ₊Monotone·ᵣ _ _ _ _
+          (<ᵣWeaken≤ᵣ _ _ $ snd (fromNat (suc (suc Z)) ^ℚ fst (fromNat (suc n))))
+          (x≤y→0≤y-x _ _ 1≤z)
+          (^ℚ-Monotone {y = fromNat (suc (suc Z))}
+           (fromNat (suc n)) z≤Z)
+          (isTrans≡≤ᵣ _ _ _ (cong (fst z +ᵣ_) (-ᵣ-rat 1)) (≤ᵣ-+o _ _ (-1) z≤Z)))))
+       (·ᵣComm _ _ ∙
+        cong₂ (_·ᵣ_)
+          (cong₂ (_·ᵣ_) (^ⁿ-ℚ^ⁿ _ _) (cong rat (ℚ.ℤ+→ℚ+ _ _))
+           ∙ sym (rat·ᵣrat _ _) )
+          (cong rat (sym (ℚ.absPos _ (ℚ.-< _ _ y₀<y₁))))
+         ∙ sym (rat·ᵣrat _ _)))
+
+
+  bdl : boundedLipschitz (fst ∘ z ^ℚ_) (slUpBd Z)
+  bdl n x y x< y< = isTrans≡≤ᵣ _ _ _
+     (cong (λ z → absᵣ
+       (fst (z ^ℚ  y) -ᵣ fst (z ^ℚ x)))
+       (ℝ₊≡ refl))
+    (∈interval→≤ContPos'pred {[ 1 / fromNat (suc (suc Z)) ]}
+         {fromNat (suc (suc Z)) }
+         (ℚ.isTrans≤ [ 1 / (fromNat (suc (suc Z))) ] 1 (fromNat (suc (suc Z)))
+          (fst (ℚ.invℚ₊-≤-invℚ₊ 1 ((fromNat (suc (suc Z)))))
+            ((ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos 1 (suc (suc Z))
+            (ℕ.suc-≤-suc (ℕ.zero-≤ {suc Z})))))  )
+           ((ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos 1 (suc (suc Z))
+            (ℕ.suc-≤-suc (ℕ.zero-≤ {suc Z}))))))
+         {λ x₁ z₁ →
+             absᵣ (fst (_ ^ℚ  y) -ᵣ fst (_ ^ℚ x))}
+         (IsContinuousWP∘' _ _ _ IsContinuousAbsᵣ (IsContinuousWithPred⊆ pred0< _ _
+          (λ z z∈ → isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _))
+           (fst z∈))
+          ((contDiagNE₂WP sumR _ _ _
+         (⊆IsContinuousWithPred _ _ (λ x 0<x → 0<x) _
+           (IsContinuous^ℚ y))
+            (IsContinuousWP∘' _ _ _ IsContinuous-ᵣ
+              ((⊆IsContinuousWithPred _ _ (λ x 0<x → 0<x) _
+           (IsContinuous^ℚ x))))))))
+         ((AsContinuousWithPred _ _ (IsContinuousConst
+           (rat (fst (slUpBd Z n) ℚ.· ℚ.abs (y ℚ.- x))))))
+           www
+         (fst z) (1/Z≤z , z≤Z))
+
+      where
+      www : (u : ℚ)
+             (x₀<u<x₁
+              : rat u ∈
+                intervalℙ (rat [ 1 / fromNat (suc (suc Z)) ])
+                (rat (fromNat (suc (suc Z))))) →
+             absᵣ
+             (fst
+              ((rat u ,
+                isTrans<≤ᵣ (rat [ pos 0 / 1 ]) (rat [ 1 / fromNat (suc (suc Z)) ])
+                (rat u)
+                (<ℚ→<ᵣ [ pos 0 / 1 ] [ 1 / fromNat (suc (suc Z)) ]
+                 (ℚ.0<pos 0 (fromNat (suc (suc Z)))))
+                (fst x₀<u<x₁))
+               ^ℚ y)
+              -ᵣ
+              fst
+              ((rat u ,
+                isTrans<≤ᵣ (rat [ pos 0 / 1 ]) (rat [ 1 / fromNat (suc (suc Z)) ])
+                (rat u)
+                (<ℚ→<ᵣ [ pos 0 / 1 ] [ 1 / fromNat (suc (suc Z)) ]
+                 (ℚ.0<pos 0 (fromNat (suc (suc Z)))))
+                (fst x₀<u<x₁))
+               ^ℚ x))
+             ≤ᵣ rat (fst (slUpBd Z n) ℚ.· ℚ.abs (y ℚ.- x))
+      www u (≤u , u≤) =
+        ⊎.rec
+          wwwL
+          wwwR
+          (ℚ.≤cases 1 u)
+       where
+       u₊ : ℝ₊
+       u₊ = (rat u ,
+                  isTrans<≤ᵣ (rat [ pos 0 / 1 ]) (rat [ 1 / fromNat (suc (suc Z)) ])
+                  (rat u)
+                  (<ℚ→<ᵣ [ pos 0 / 1 ] [ 1 / fromNat (suc (suc Z)) ]
+                   (ℚ.0<pos 0 (fromNat (suc (suc Z)))))
+                  ≤u)
+       wwwL : 1 ℚ.≤ u →
+               absᵣ (fst (u₊ ^ℚ y) -ᵣ fst (u₊ ^ℚ x))
+               ≤ᵣ rat (fst (slUpBd Z n) ℚ.· ℚ.abs (y ℚ.- x))
+       wwwL 1≤u = bdl' u₊
+          Z u≤ ≤u (≤ℚ→≤ᵣ _ _ 1≤u) n x y x< y<
+
+       wwwR : u ℚ.≤ 1 →
+                absᵣ (fst (u₊ ^ℚ y) -ᵣ fst (u₊ ^ℚ x))
+               ≤ᵣ rat (fst (slUpBd Z n) ℚ.· ℚ.abs (y ℚ.- x))
+       wwwR u≤1 = subst2 _≤ᵣ_
+              (cong absᵣ (cong₂ _-ᵣ_ (cong fst (sym (^ℚ-minus _ _)))
+                                     (cong fst (sym (^ℚ-minus _ _)))))
+              (cong (λ uu → rat (fst (slUpBd Z n) ℚ.· uu))
+                (cong ℚ.abs (sym lem--083) ∙ ℚ.absComm- _ _))
+            wwwR'
+        where
+         wwwR' : absᵣ (fst ((invℝ₊ u₊) ^ℚ (ℚ.- y)) -ᵣ fst ((invℝ₊ u₊) ^ℚ (ℚ.- x)))
+                ≤ᵣ rat (fst (slUpBd Z n) ℚ.· ℚ.abs ((ℚ.- y) ℚ.- (ℚ.- x)))
+         wwwR' = bdl' (invℝ₊ u₊) Z
+          (isTrans≤≡ᵣ _ _ _ (invEq (invℝ₊-≤-invℝ₊ _ _) ≤u) (invℝ₊-rat _)  )
+          (isTrans≡≤ᵣ _ _ _ (sym (invℝ₊-rat _)) (invEq (invℝ₊-≤-invℝ₊ _ _) u≤))
+          (isTrans≡≤ᵣ _ _ _ (sym (invℝ₊-rat _)) (invEq (invℝ₊-≤-invℝ₊ 1 u₊)
+            (≤ℚ→≤ᵣ _ _ u≤1)))
+
+          n (ℚ.- x) (ℚ.- y)
+           (subst (ℚ._≤ (fromNat (suc n))) (ℚ.-abs x) x<)
+           (subst (ℚ._≤ (fromNat (suc n))) (ℚ.-abs y) y<)
+
+ open BoundedLipsch (fst ∘ z ^ℚ_) (slUpBd Z) bdl public
+
+-- --  bdlInv-lem : ( fst (fromNat (suc (suc Z))
+-- --                    ^ℚ -2)) ≤ᵣ ((fst z -ᵣ 1) ／ᵣ₊ z)
+-- --  bdlInv-lem = isTrans≡≤ᵣ _ _ _
+-- --    (cong fst (^ℚ-minus' _ 2 ∙ sym (^ℚ-+ _ 1 1)) ∙
+-- --     cong₂ _·ᵣ_ (
+-- --         cong fst (^ℚ-1 (invℝ₊ (fromNat (suc (suc Z)))))
+-- --       ∙ cong (fst ∘ invℝ₊) (fromNatℝ≡fromNatℚ _)
+-- --      ∙ invℝ₊-rat (fromNat (suc (suc Z))))
+-- --         (cong fst (^ℚ-1 (invℝ₊ (fromNat (suc (suc Z)))))
+-- --       ∙ cong (fst ∘ invℝ₊) (fromNatℝ≡fromNatℚ _)) )
+-- --    (≤ᵣ₊Monotone·ᵣ (rat _) _ _ _
+-- --     (<ᵣWeaken≤ᵣ _ _ (x<y→0<y-x _ _ 1<z))
+-- --     (<ᵣWeaken≤ᵣ _ _ $
+-- --      snd (invℝ₊ (ℚ₊→ℝ₊ ([ pos (suc (suc Z)) , 1 ] , tt)))) (
+-- --     <ᵣWeaken≤ᵣ _ _
+-- --      (a+c<b⇒a<b-c _ _ _
+-- --        (isTrans≡<ᵣ _ _ _ (+ᵣComm (rat [ 1 / 1+ (suc Z) ]) 1) 1+1/Z<z)))
+-- --      (invEq (invℝ₊-≤-invℝ₊ (ℚ₊→ℝ₊ _) _) (<ᵣWeaken≤ᵣ _ _ z<Z)))
+
+-- --  bdlInv : boundedInvLipschitz slUpBdInv
+-- --  bdlInv n = ℚ.elimBy≡⊎<
+-- --   (λ x y X y∈ x∈ → subst2 _≤ᵣ_
+-- --        (cong rat (ℚ.absComm- _ _))
+-- --        (cong (rat (fst (slUpBdInv n)) ·ᵣ_) (minusComm-absᵣ _ _))
+-- --        (X x∈ y∈)  )
+-- --   ((λ x _ _ → subst2 _≤ᵣ_
+-- --      (cong rat (sym (cong ℚ.abs (ℚ.+InvR x))))
+-- --      (sym (𝐑'.0RightAnnihilates' _ _ (cong absᵣ (+-ᵣ _))))
+-- --      (≤ᵣ-refl 0)))
+-- --   λ y₀ y₁ y₀<y₁ y₀∈ y₁∈ →
+-- --    subst2 _≤ᵣ_
+-- --      (cong rat (sym (ℚ.absPos _ (ℚ.-< _ _ y₀<y₁))))
+-- --      (cong (rat (fst (slUpBdInv n)) ·ᵣ_)
+-- --       (sym (absᵣNonNeg _ (x≤y→0≤y-x _ _
+-- --          (^ℚ-MonotoneR _ _ (ℚ.<Weaken≤ _ _ y₀<y₁) (<ᵣWeaken≤ᵣ _ _ 1<z) )))))
+-- --      (isTrans≡≤ᵣ _ _ _ (sym (·IdR _))
+-- --       (fst (z/y'≤x/y≃y₊·z≤y'₊·x _ _ (ℚ₊→ℝ₊ (ℚ.<→ℚ₊ _ _ y₀<y₁))
+-- --             (ℚ₊→ℝ₊ (slUpBdInv n)))
+-- --         (isTrans≡≤ᵣ _ _ _ (·IdL _)
+-- --          (isTrans≤ᵣ _ _ _
+-- --            (isTrans≡≤ᵣ _ _ _
+-- --              (invℝ₊-rat _ ∙ cong fst (
+-- --                ( (sym (^ℤ-rat (fromNat (suc (suc Z)))
+-- --                    (ℤ.negsuc (1 ℕ.+ suc n)))
+-- --                    ∙ cong (_^ℚ [ ℤ.negsuc (1 ℕ.+ suc n) / 1 ])
+-- --                     (ℝ₊≡ refl))
+-- --            ∙ cong (fromNat (suc (suc Z)) ^ℚ_)
+-- --             (cong [_/ 1 ] (ℤ.negsuc+ _ _) ∙ sym (ℚ.ℤ+→ℚ+ _ _)))
+-- --                ∙ sym (^ℚ-+ _ _ _)) ∙ ·ᵣComm _ _)
+-- --              (≤ᵣ₊Monotone·ᵣ
+-- --                (fst (fromNat (suc (suc Z))
+-- --                    ^ℚ (ℚ.- [ pos (suc n) , (1+ 0) ])))
+-- --                _
+-- --                _
+-- --                _
+-- --                (<ᵣWeaken≤ᵣ _ _
+-- --                  $ snd (z ^ℚ (ℚ.- [ pos (suc n) , (1+ 0) ])))
+-- --                (<ᵣWeaken≤ᵣ _ _
+-- --                  $ snd (fromNat (fromNat (suc (suc Z))) ^ℚ -2))
+-- --                (subst2 _≤ᵣ_
+-- --                  (cong fst (sym (^ℚ-minus' _ _)))
+-- --                  (cong fst (sym (^ℚ-minus' _ _)))
+-- --                  (^ℚ-Monotone (fromNat (suc n))
+-- --                   (invEq (invℝ₊-≤-invℝ₊ _ _)
+-- --                    (<ᵣWeaken≤ᵣ _ _ z<Z))))
+-- --                bdlInv-lem))
+-- --           (<ᵣWeaken≤ᵣ _ _
+-- --            (slope-lower-bound z (fromNat (suc n)) 1<z
+-- --             _ _ y₀<y₁
+-- --             (ℚ.absTo≤×≤ (fromNat (suc n)) y₀ y₀∈)
+-- --             (ℚ.absTo≤×≤ (fromNat (suc n)) y₁ y₁∈))
+-- --      )))))
+
+-- --  open BoundedInvLipsch slUpBdInv bdlInv public
+
+ mid-𝒇 : ∀ q q' q'' → q ℚ.≤ q' → q' ℚ.≤ q'' →
+    minᵣ (𝒇 (rat q))
+         (𝒇 (rat q'')) ≤ᵣ 𝒇 (rat q')
+ mid-𝒇 q q' q'' q≤q' q'≤q'' =
+   subst2 _≤ᵣ_
+     (cong₂ minᵣ (sym (𝒇-rat q)) (sym (𝒇-rat q'')))
+     (sym (𝒇-rat q'))
+     (monotone^ℚ q q' q'' q≤q' q'≤q'' _)
+
+
+ 0<𝒇 : ∀ x → 0 <ᵣ 𝒇 x
+ 0<𝒇 x = PT.rec (isProp<ᵣ _ _)
+  (λ ((q , q') , q'-q<1 , q<x , x<q') →
+    let q⊓q' = (minᵣ₊ (z ^ℚ q) (z ^ℚ q'))
+    in PT.rec (isProp<ᵣ _ _)
+       (λ (ε , 0<ε , ε<q⊓q') →
+         PT.rec (isProp<ᵣ _ _)
+         (λ (δ , X) →
+          PT.rec (isProp<ᵣ _ _)
+            (λ (r , r-x≤δ , x≤r) →
+               let r' = ℚ.clamp q q' r
+                   r'-x≤δ = isTrans≤ᵣ _ _ _
+                             (≤ᵣ-+o _ _ (-ᵣ x)
+                               (≤ℚ→≤ᵣ _ _
+                            (ℚ.clamped≤ q q' r
+                              (ℚ.<Weaken≤ _ _
+                                (<ᵣ→<ℚ _ _ (isTrans<≤ᵣ _ _ _ q<x x≤r))))) ) r-x≤δ
+                   x≤r' = ≤min-lem _ (rat (ℚ.max q r)) (rat q')
+                            (isTrans≤ᵣ _ _ _ x≤r
+                             (≤ℚ→≤ᵣ _ _ (ℚ.≤max' q r)))
+                            (<ᵣWeaken≤ᵣ _ _ x<q')
+                   |fx-fr|<ε = fst (∼≃abs<ε _ _ _)
+                       (sym∼ _ _ _ (X (rat r') (sym∼ _ _ _
+                         ((invEq (∼≃abs<ε _ _ _)
+                        (isTrans≡<ᵣ _ _ _
+                          (absᵣNonNeg _ (x≤y→0≤y-x _ _ x≤r'))
+                           (isTrans≤<ᵣ _ _ _
+                               r'-x≤δ (<ℚ→<ᵣ _ _ (x/2<x δ))))))) ))
+                   zzz =
+                        mid-𝒇 q r' q'
+                         (≤ᵣ→≤ℚ _ _ (isTrans≤ᵣ _ _ _
+                          (<ᵣWeaken≤ᵣ _ _ q<x) x≤r'))
+                         (ℚ.clamp≤ q q' r)
+                   zzz' = isTrans<≤ᵣ _ _ _
+                            (isTrans<≡ᵣ _ _ _ ε<q⊓q'
+                              (cong₂ minᵣ
+                                (sym (𝒇-rat _)) (sym (𝒇-rat _))))
+                             zzz
+               in isTrans≡<ᵣ _ _ _ (sym (CRℝ.+InvR _)) (a-b<c⇒a-c<b _ _ _
+                     (isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+                    (isTrans<ᵣ _ _ _ |fx-fr|<ε zzz')))
+              ) (∃rationalApprox≤ x (/2₊ δ)))
+
+         (𝒇-cont x (ε , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<ε)))
+         )
+      (denseℚinℝ 0 _ (snd q⊓q')) )
+   (∃rationalApprox x 1)
+
+ 𝒇₊ : ℝ → ℝ₊
+ 𝒇₊ x = 𝒇 x , 0<𝒇 x
+
+ flₙ≡𝒇 : ∀ x n → (x ∈ intervalℙ (fromNeg (suc n)) (fromNat (suc n)))
+           →  fst (fst (flₙ n)) x ≡ 𝒇 x
+ flₙ≡𝒇 x n x∈ = ≡Continuous (fst (fst (flₙ n)))
+           (𝒇 ∘ clampᵣ (fromNeg (suc n)) (fromNat (suc n)))
+     (snd (flₙ n)) (IsContinuous∘ _ _ 𝒇-cont
+          (IsContinuousClamp (fromNeg (suc n)) (fromNat (suc n))))
+       (λ r → sym (𝒇-rat _))
+       x
+   ∙ cong 𝒇 (sym (∈ℚintervalℙ→clampᵣ≡ _ _ x x∈))
+
+
+ 𝒇-monotone : 1 ≤ᵣ fst z → ∀ x y → x ≤ᵣ y → 𝒇 x ≤ᵣ 𝒇 y
+ 𝒇-monotone 1≤z x y x≤y =
+  ≡→≤ᵣ ((≡Cont₂ (cont₂∘ (contNE₂ maxR) 𝒇-cont 𝒇-cont)
+    (cont∘₂ 𝒇-cont (contNE₂ maxR) )
+    (ℚ.elimBy≤
+       (λ u u' X → maxᵣComm _ _ ∙∙ X ∙∙ cong 𝒇 (maxᵣComm _ _))
+       λ u u' u≤u' →
+         cong₂ maxᵣ (𝒇-rat _) (𝒇-rat _)
+          ∙∙ ≤ᵣ→≡ (^ℚ-MonotoneR u u' u≤u' 1≤z) ∙
+           cong (fst ∘ (z ^ℚ_)) (sym (ℚ.≤→max u u' u≤u')) ∙∙
+          sym (𝒇-rat _))
+        x y)
+   ∙ cong 𝒇 (≤ᵣ→≡ x≤y))
+
+
+ opaque
+  unfolding _<ᵣ_
+  𝒇-monotone-str : 1 <ᵣ fst z → ∀ x y → x <ᵣ y → 𝒇 x <ᵣ 𝒇 y
+  𝒇-monotone-str 1<z x y = PT.rec (isProp<ᵣ _ _)
+     λ ((q , q') , (≤q , q<q' , q'≤)) →
+       isTrans≤<ᵣ _ _ _ (𝒇-monotone (<ᵣWeaken≤ᵣ _ _ 1<z) x (rat q) ≤q)
+         (isTrans<≤ᵣ _ _ _ (
+            subst2 _<ᵣ_ (sym (𝒇-rat _)) (sym (𝒇-rat _))
+             (^ℚ-StrictMonotoneR 1<z q q' q<q'))
+           (𝒇-monotone (<ᵣWeaken≤ᵣ _ _ 1<z) (rat q') y q'≤))
+
+ module _ (n : ℕ) where
+
+
+  incr^ : 1 <ᵣ fst z → isIncrasingℙᵣ
+            (intervalℙ (rat (ℚ.- fromNat (suc n))) (rat (fromNat (suc n))))
+            (λ x _ → fst (fst (flₙ n)) x)
+  incr^ 1<z x x∈ y y∈ x<y =
+    subst2 _<ᵣ_
+      (sym (flₙ≡𝒇 x n x∈))
+      (sym (flₙ≡𝒇 y n y∈))
+      (𝒇-monotone-str 1<z  x y x<y)
+
+
+  nondecr^ : 1 ≤ᵣ fst z → isNondecrasingℙᵣ
+      (intervalℙ (rat (ℚ.- [ pos (suc n) / 1+ 0 ]))
+       (rat [ pos (suc n) / 1+ 0 ]))
+      (λ x _ → fst (fst (flₙ n)) x)
+  nondecr^ 1≤z x x∈ y y∈ x≤y =
+    subst2 _≤ᵣ_
+      (sym (flₙ≡𝒇 x n x∈))
+      (sym (flₙ≡𝒇 y n y∈))
+      (𝒇-monotone 1≤z x y x≤y)
+
+
+
+ open expPreDer Z public
+ open expPreDer' z z≤Z 1/Z≤z public
+
+ opaque
+  unfolding _+ᵣ_
+  expDerAt0 : derivativeOf 𝒇 at 0 is preLn
+  expDerAt0 ε =
+   PT.rec
+     squash₁
+     (λ (ε' , 0<ε' , <ε) →
+       let ε'₊ = (ε' , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<ε'))
+           N = fst (seqΔ-δ Z ε'₊)
+           X =  seqΔ ε'₊
+       in  ∣ ℚ₊→ℝ₊ ([ 1 / 2+ (suc N) ] , _) ,
+              (λ r 0＃r ∣r∣<1/N →
+                let d≤lnSeq : differenceAt 𝒇 0 r 0＃r ≤ᵣ lnSeq z (suc N)
+                    d≤lnSeq = ≤ContWP＃≤ [ 1 / 2+ suc N ] (ℚ.0<pos 0 (2+ (suc N)))
+                              (IsContinuousWithPred-differenceAt 0 _ 𝒇-cont)
+                              ((AsContinuousWithPred _ _
+                               (IsContinuousConst (lnSeq z (suc N)))))
+                              (λ u u∈ u≤ →
+                                subst2 _≤ᵣ_
+                                 ((cong₂ _·ᵣ_ (cong₂ _-ᵣ_
+                              (cong (fst ∘ (z ^ℚ_)) (sym (ℚ.+IdL _)) ∙ sym (𝒇-rat _))
+                              (sym (𝒇-rat _)))
+                                 ((cong₂ invℝ (𝐑'.+IdR' _ _ (-ᵣ-rat 0)) (toPathP (isProp＃ _ _ _ _))))))
+                                 (cong₂ _·ᵣ_
+                                   refl ((invℝ₊-rat _ ∙ cong rat
+                               (cong (fst ∘ invℚ₊) (ℚ₊≡ {y = [ 1 / 2+ (suc N) ] , _ }
+                                  (ℚ.+IdR _))))))
+                                 ( (slope-monotone＃ ((z)) 0 u
+                                   0 [ 1 / 2+ (suc N) ]
+                                   u∈ (ℚ.0<pos 0 _) (ℚ.isRefl≤ 0) u≤))
+
+                                   )
+                              r 0＃r
+                              (isTrans≤ᵣ _ _ _ (≤absᵣ r)
+                                 (isTrans≡≤ᵣ _ _ _ (cong absᵣ (sym (𝐑'.+IdR' _ _ (-ᵣ-rat 0)))
+                                  ∙ minusComm-absᵣ _ _) (<ᵣWeaken≤ᵣ (absᵣ (0 -ᵣ r)) _ ∣r∣<1/N)))
+
+
+                    lnSeq'≤d : lnSeq' z (suc N) ≤ᵣ differenceAt 𝒇 0 r 0＃r
+                    lnSeq'≤d = ≤ContWP＃≤' (ℚ.- [ 1 / 2+ suc N ])
+                                   ((ℚ.minus-< 0 [ 1 / 2+ suc N ] (ℚ.0<pos 0 (2+ (suc N)))))
+                               ((AsContinuousWithPred _ _
+                               (IsContinuousConst (lnSeq' z (suc N)))))
+                               (IsContinuousWithPred-differenceAt 0 _ 𝒇-cont)
+                                (λ u u∈ u≤ → subst2 _≤ᵣ_
+                                   ((cong₂ _·ᵣ_ refl ((invℝ₊-rat _ ∙ cong rat
+                                     (cong (fst ∘ invℚ₊)
+                                       (ℚ₊≡ {x = (0 ℚ.- (ℚ.- [ 1 / 2+ suc N ])) , _}
+                                            {y = [ 1 / 2+ (suc N) ] , _ }
+                                         (ℚ.+IdL _ ∙ ℚ.-Invol _)))))))
+                                   (sym (-ᵣ·-ᵣ _ _) ∙ cong₂ _·ᵣ_
+                                     (-[x-y]≡y-x _ _ ∙
+                                       cong₂ _-ᵣ_ (sym (𝒇-rat _) ∙ cong 𝒇 (sym (+IdL _)))
+                                         (sym (𝒇-rat _)))
+                                     (-invℝ _ _ ∙ cong₂ invℝ (cong -ᵣ_ (+IdL _) ∙ -ᵣInvol _)
+                                       (toPathP (isProp＃ _ _ _ _))))
+
+                                   (slope-monotone＃' z
+                                     (ℚ.- [ 1 / 2+ (suc N) ]) 0 u 0
+                                     ((ℚ.minus-< 0 [ 1 / 2+ suc N ] (ℚ.0<pos 0 (2+ (suc N)))))
+                                     (isSym＃ _ _ u∈) u≤ (ℚ.isRefl≤ 0))
+                                     )
+                                r 0＃r
+                              (isTrans≤ᵣ _ _ _
+                                (isTrans≡≤ᵣ _ _ _
+                                 (sym (-ᵣ-rat _))
+                                 (-ᵣ≤ᵣ _ _ (<ᵣWeaken≤ᵣ (absᵣ (0 -ᵣ r)) _ ∣r∣<1/N)))
+                                (≤ᵣ-ᵣ _ _ (isTrans≤≡ᵣ _ _ _ (≤absᵣ (-ᵣ r))
+                                  (cong absᵣ (sym (+IdL _)) ∙ sym (-ᵣInvol _)))))
+
+
+                in isTrans≤<ᵣ _ _ _
+                     (intervalℙ→dist< _ _ _ _
+                        ((lnSeq'≤preLn _) , (preLn≤lnSeq _))
+                        (lnSeq'≤d , d≤lnSeq))
+                     (isTrans<ᵣ _ _ _ (X (suc N) ℕ.≤-refl) <ε)
+
+                 ) ∣₁ )
+     (denseℚinℝ 0 _ (snd ε))
+
+  𝒇· : ∀ x y → 𝒇 x ·ᵣ 𝒇 y ≡ 𝒇 (x +ᵣ y)
+  𝒇· = ≡Cont₂
+       (cont₂∘ IsContinuous₂·ᵣ 𝒇-cont 𝒇-cont )
+       (cont∘₂ 𝒇-cont (contNE₂ sumR))
+       λ u u' → cong₂ _·ᵣ_ (𝒇-rat _) (𝒇-rat _)
+          ∙ cong fst (^ℚ-+ _ _ _) ∙ sym (𝒇-rat _)
+
+
+ differenceAt𝒇-Δ : ∀ x r 0＃r → 𝒇 x ·ᵣ differenceAt 𝒇 0 r 0＃r ≡ (differenceAt 𝒇 x r 0＃r)
+ differenceAt𝒇-Δ x r 0＃r = ·ᵣAssoc _ _ _ ∙
+   cong (_／ᵣ[ r , 0＃r ]) (𝐑'.·DistR- _ _ _ ∙
+     cong₂ _-ᵣ_
+       (𝒇· _ (0 +ᵣ r) ∙ cong 𝒇 (cong (x +ᵣ_) (+IdL r)))
+       (𝒇· _ _ ∙ cong 𝒇 (+IdR x)))
+
+
+ expDerA : ∀ x → derivativeOf 𝒇 at x is (𝒇 x ·ᵣ preLn)
+ expDerA x =
+  subst (at (rat [ pos zero / 1+ zero ]) limitOf_is (𝒇 x ·ᵣ preLn))
+   (funExt₂ λ r 0＃r → differenceAt𝒇-Δ _ _ _ )
+   (·-lim _ _ _ _ _ (const-lim (𝒇 x) 0) expDerAt0)
+
+
+seq-^-intervals : Seq⊆
+seq-^-intervals .Seq⊆.𝕡 Z = intervalℙ (rat [ 1 / (fromNat (suc (suc Z))) ]) (fromNat (suc (suc Z)))
+
+seq-^-intervals .Seq⊆.𝕡⊆ Z x (≤x , x≤) =
+  isTrans≤ᵣ _ _ _  (≤ℚ→≤ᵣ _ _ ((invEq (ℚ.invℚ₊-≤-invℚ₊
+     ([ 1 / (2+ (suc Z)) ] , _) _) w))) ≤x
+  , isTrans≤ᵣ _ _ _ x≤ (≤ℚ→≤ᵣ _ _ w)
+
+ where
+  w = (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _ (ℕ.≤-suc (ℕ.≤-refl {suc (suc Z)}))))
+
+seq-^-intervals∈Pos : seq-^-intervals Seq⊆.s⊇ pred0<
+seq-^-intervals∈Pos x 0<x =
+  PT.map2 (λ (1+ n , N) (1+ n' , N') →
+        ℕ.max n n'
+            ,
+              fst (invℝ₊-≤-invℝ₊ (x , 0<x) (_ , <ℚ→<ᵣ _ _ (ℚ.0<pos _ _)))
+              (isTrans≤ᵣ _ _ _
+               (isTrans≤ᵣ _ _ _                 (≤absᵣ _) (<ᵣWeaken≤ᵣ _ _ N'))
+               (isTrans≤≡ᵣ _ _ _
+                 (((≤ℚ→≤ᵣ (fromNat (suc n')) (fromNat (suc (suc (ℕ.max n n'))))
+                      ((ℚ.≤ℤ→≤ℚ _ _
+                       (ℤ.ℕ≤→pos-≤-pos _ _ (ℕ.≤-suc (ℕ.right-≤-max {suc n'} {suc n}))))))))
+                        (sym (invℝ₊-rat _))))
+
+              ,
+                isTrans≤ᵣ _ _ _
+             (isTrans≤ᵣ _ _ _
+                 (≤absᵣ _) (<ᵣWeaken≤ᵣ _ _ N))
+
+                 (((≤ℚ→≤ᵣ (fromNat (suc n)) _
+                      (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _ (ℕ.≤-suc (ℕ.left-≤-max {suc n} {suc n'})))))))
+               )
+    (getClamps x) (getClamps (fst (invℝ₊ (x , 0<x))))
+
+
+
+-- -- -- -- -- -- -- FnWith
+
+
+Seq-^ : Seq⊆→ ((ℝ → ℝ₊) × ℝ) seq-^-intervals
+Seq-^ .Seq⊆→.fun x Z (≤x , x≤) = F.𝒇₊ , F.preLn
+ where
+ module F = BDL (x , isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _)) ≤x) Z x≤ ≤x
+Seq-^ .Seq⊆→.fun⊆ x n m (≤x , x≤) (≤x' , x≤') n<m = cong₂ _,_
+  (funExt (ℝ₊≡ ∘ (≡Continuous _ _ F.𝒇-cont F'.𝒇-cont
+       λ r → F.𝒇-rat r ∙∙ cong (fst ∘ (_^ℚ r)) (ℝ₊≡ refl) ∙∙ sym (F'.𝒇-rat r))))
+        λ i → fromCauchySequence'-≡-lem (lnSeq (x , xp i))
+              (icP i) (icP' i) i
+
+ where
+ module F = BDL _ n x≤ ≤x
+ module F' = BDL _ m x≤' ≤x'
+
+ 0<x = isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _)) ≤x
+ 0<x' = isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _)) ≤x'
+ xp : 0<x ≡ 0<x'
+ xp = isProp<ᵣ 0 x 0<x 0<x'
+
+ icP : PathP (λ i → IsCauchySequence' (lnSeq (x , xp i))) F.ca-lnSeq _
+ icP = toPathP refl
+
+ icP' : PathP (λ i → IsCauchySequence' (lnSeq (x , xp i))) _ F'.ca-lnSeq
+ icP' = symP (toPathP refl)
+
+
+
+
+
+
+
+
+open ℚ.HLP
+
+module Seq-^-FI = Seq⊆→.FromIntersection Seq-^
+   (isSet× (isSet→ isSetℝ₊) isSetℝ) pred0< seq-^-intervals∈Pos
+
+module Pos^ where
+ open Seq-^-FI
+
+
+ ^-c : ∀ x → 0 <ᵣ x  → ℝ → ℝ₊
+ ^-c x 0<x = fst (∩$ x 0<x)
+
+ _^ᵣ_ : ℝ₊ → ℝ → ℝ₊
+ (x , 0<x) ^ᵣ y = fst (∩$ x 0<x) y
+
+
+ ^ᵣ-mon-str : ∀ x
+   → 1 <ᵣ fst x
+   → ∀ y y'
+   → y <ᵣ y'
+   → fst (x ^ᵣ y) <ᵣ fst (x ^ᵣ y')
+ ^ᵣ-mon-str x 1<x y y'  y<y' =
+  ∩$-elimProp (fst x) (snd x)
+    {λ (f , _) → fst (f y) <ᵣ fst (f y')}
+    (λ _ → isProp<ᵣ _ _)
+    (λ n x∈ₙ → BDL.𝒇-monotone-str (fst x , _) n (snd x∈ₙ) (fst x∈ₙ)
+         1<x y y' y<y')
+
+ ln-c : ∀ x → 0 <ᵣ x → ℝ
+ ln-c x 0<x = snd (∩$ x 0<x)
+
+ ln : ℝ₊ → ℝ
+ ln (x , 0<x) = snd (∩$ x 0<x)
+
+ ln-1≡0 : ln 1 ≡ 0
+ ln-1≡0 =
+   let 1r : ℝ₊
+       1r = fromNat 1
+   in ∩$-elimProp (fst 1r) (snd 1r)
+             {λ (_ , lnx) → lnx ≡ 0}
+             (λ _ → isSetℝ _ _)
+             λ Z x∈ →
+                 congS (λ 0<1 → BDL.preLn (rat [ pos (suc zero) / 1+ zero ] , 0<1)
+                        Z (snd x∈) (fst x∈))
+                         (isProp<ᵣ _ _ _ _)
+                ∙ sym (expPreDer.0=preLn Z (snd x∈) (fst x∈))
+
+ ln-cont : IsContinuousWithPred pred0< (curry ln)
+ ln-cont x ε 0<x = w
+  where
+  ww : (Z : ℕ) (x∈ : x ∈ Seq⊆.𝕡 seq-^-intervals Z) →
+        ∃-syntax ℚ₊
+        (λ δ →
+           (v : ℝ) (v∈P : 0 <ᵣ v) →
+           x ∼[ δ ] v → Seq⊆→.fun Seq-^ x Z x∈ .snd ∼[ ε ] curry ln v v∈P)
+  ww Z x∈ =
+    let (N , X) = seqΔ-δ (suc Z) (/4₊ ε)
+        uuu = seq-^-intervals .Seq⊆.𝕡⊆ Z x x∈
+        δZ : ℚ₊
+        δZ = ℚ.<→ℚ₊ [ 1 / fromNat (suc (suc (suc Z))) ] [ 1 / fromNat (suc (suc Z)) ]
+              (fst (ℚ.invℚ₊-<-invℚ₊ (fromNat (suc (suc Z))) (fromNat (suc (suc (suc Z)))))
+                (ℚ.<ℤ→<ℚ _ _ ((invEq (ℤ.pos-<-pos≃ℕ< _ _) ℕ.≤-refl ))))
+    in PT.map
+        (λ (δ , D) →
+          (ℚ.min₊ δ δZ) ,
+            (λ v 0<v x∼v →
+               let ca' = expPreDer.expPreDer'.preLn∼ (suc Z)
+                   uvu = isTrans≡≤ᵣ (rat [ pos 1 / 2+ suc Z ]) _ _
+                           (sym (L𝐑.lem--079 {rat [ pos 1 / 2+ Z ]}) ∙
+                             cong₂ _-ᵣ_ refl (-ᵣ-rat₂ _ _)
+                            ) (≤ᵣMonotone+ᵣ _ _ _ _
+                          (fst x∈) (-ᵣ≤ᵣ _ _ (isTrans≤ᵣ _ _ _ (isTrans≤ᵣ _ _ _
+                            (≤absᵣ _) (<ᵣWeaken≤ᵣ _ _ (fst (∼≃abs<ε _ _ _)
+                                   x∼v))) (≤ℚ→≤ᵣ _ _ (ℚ.min≤' _ _)))))
+                   uuuV : v ∈ seq-^-intervals .Seq⊆.𝕡 (suc Z)
+                   uuuV = isTrans≤≡ᵣ _ _ _ uvu L𝐑.lem--079
+                        , (isTrans≤≡ᵣ _ _ _
+                            (isTrans≤ᵣ _ _ _
+                             (a-b≤c⇒a≤c+b _ _ _
+                               (isTrans≤ᵣ _ _ _ (≤absᵣ _)
+                                (isTrans≤ᵣ _ _ _ (<ᵣWeaken≤ᵣ _ _ (fst (∼≃abs<ε _ _ _)
+                                   (sym∼ _ _ _ x∼v)))
+                                    (≤ℚ→≤ᵣ _ _
+                                      (ℚ.isTrans≤ _ _ _ (ℚ.min≤' _ _)
+                                       (ℚ.≤-ℚ₊ [ 1 / fromNat (suc (suc Z)) ]
+                                        1 ([ 1 / fromNat (suc (suc (suc Z))) ] , _)
+                                         (fst (ℚ.invℚ₊-≤-invℚ₊ 1 (fromNat (suc (suc Z))))
+                                           (ℚ.≤ℤ→≤ℚ _ _
+                                              (invEq (ℤ.pos-≤-pos≃ℕ≤ _ _)
+                                                (ℕ.suc-≤-suc ℕ.zero-≤))))))))))
+                             (≤ᵣ-o+ _ _ 1 (snd x∈)))
+                            (+ᵣ-rat _ _ ∙  cong rat (ℚ.ℕ+→ℚ+ _ _)))
+                   ≡ε = distℚ! (fst ε) ·[ ((ge[ ℚ.[ 1 / 4 ] ]
+                               +ge ge[ ℚ.[ 1 / 2 ] ])
+                            +ge  ge[ ℚ.[ 1 / 4 ] ]
+                            ) ≡ ge1 ]
+                   qqq : BDL.preLn (x , _) (suc Z) (snd (Seq⊆.𝕡⊆ seq-^-intervals Z x x∈))
+                          (fst (Seq⊆.𝕡⊆ seq-^-intervals Z x x∈))
+                          ∼[ ((/4₊ ε) ℚ₊+ /2₊ ε) ℚ₊+ (/4₊ ε) ]
+                          BDL.preLn (v , _) (suc Z) _ _
+                   qqq = (triangle∼ (triangle∼ (sym∼ _ _ _
+                             (ca' (x , isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _)) (fst uuu))
+                              (snd uuu) (fst uuu) _ _ ℕ.≤-refl))
+                         ((D v (isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _)) (fst uuuV))
+                            (∼-monotone≤ (ℚ.min≤ _ _) x∼v))))
+                          ((ca' (v , _) (snd uuuV) (fst uuuV) _ _ ℕ.≤-refl)))
+               in ((cong snd (2c x (suc Z) Z uuu _))
+                    subst∼[ ℚ₊≡ ≡ε ]
+                      (cong snd (sym (∩$-∈ₙ v _ (suc Z) uuuV)))
+                      )
+                      qqq))
+        (lnSeqCont (suc N) x (/2₊ ε) _)
+
+  w : _
+  w = ∩$-elimProp x 0<x
+    {λ (_ , lnx) → ∃-syntax ℚ₊
+      (λ δ → (v : ℝ) (v∈P : 0 <ᵣ v) →
+        x ∼[ δ ] v → lnx ∼[ ε ] curry ln v v∈P)}
+    (λ _ → squash₁)
+    ww
+
+
+
+ ^-rat : ∀ x y → fst (x ^ᵣ (rat y)) ≡ fst (x ^ℚ y)
+ ^-rat x =
+   ∩$-elimProp (fst x) (snd x)
+    {λ (f , _) → ∀ y → fst (f (rat y)) ≡ fst (x ^ℚ y)}
+     (λ _ → isPropΠ λ _ → isSetℝ _ _)
+     (λ n (≤x , x≤) q →
+          BDL.𝒇-rat _ n x≤ ≤x q ∙ cong (λ x → fst (x ^ℚ q)) (ℝ₊≡ refl))
+
+
+ ln-inv : ∀ x → ln (invℝ₊ x) ≡ -ᵣ (ln x)
+ ln-inv (x , 0<x) =
+   let (1/x , 0<1/x) = invℝ₊ (x , 0<x)
+   in ∩$-elimProp2 1/x 0<1/x x 0<x
+        {λ (_ , ln1/x) (_ , lnx) → ln1/x ≡ -ᵣ lnx}
+        (λ _ _ → isSetℝ _ _)
+        λ Z x∈ y∈ →
+          congS (λ zz → BDL.preLn (1/x , zz) Z (snd x∈) (fst x∈))
+            (isProp<ᵣ 0 _ _ _)  ∙ expPreDer.preLn-inv Z _
+            (snd y∈) (fst y∈) (snd x∈) (fst x∈)
+           ∙ congS (λ zz → -ᵣ (BDL.preLn (x , zz) Z (snd y∈) (fst y∈)))
+            (isProp<ᵣ 0 _ _ _)
+
+ cont-^ : ∀ (x : ℝ₊) → IsContinuous (fst ∘ x ^ᵣ_)
+ cont-^ (x , 0<x) =
+    ∩$-elimProp x 0<x  {λ (f , _) → IsContinuous (fst ∘ f)}
+      (λ _ → isPropIsContinuous _)
+      λ Z (≤x , x≤) → BDL.𝒇-cont _ Z x≤ ≤x
+
+
+
+ -- slope-monotone-^ᵣ :   (a b a' b' : ℝ₊)
+ --  → (a<b : fst a <ᵣ fst b) → (a'<b' : fst a' <ᵣ fst b')
+ --  → (a≤a' : fst a ≤ᵣ fst a') →  (b≤b' : fst b ≤ᵣ fst b') →
+ --  ∀ y → 1 ≤ᵣ y →
+ --  (((fst (b ^ᵣ y)) -ᵣ (fst (a ^ᵣ y)))
+ --    ／ᵣ₊ (_ , x<y→0<y-x _ _ a<b ))
+ --      ≤ᵣ
+ --  (((fst (b' ^ᵣ y)) -ᵣ (fst (a' ^ᵣ y)))
+ --    ／ᵣ₊ (_ , x<y→0<y-x _ _ a'<b' ))
+ -- slope-monotone-^ᵣ a b a' b' a<b a'<b' a≤a' b≤b' =
+ --   (≤ContPos' {1}
+ --    (IsContinuous∘ _ _ (IsContinuous·ᵣR _)
+ --      (cont₂+ᵣ _ _
+ --        (cont-^ _)
+ --        (IsContinuous∘ _ _
+ --          IsContinuous-ᵣ
+ --           (cont-^ _))))
+ --    (IsContinuous∘ _ _ (IsContinuous·ᵣR _)
+ --      (cont₂+ᵣ _ _
+ --        (cont-^ _)
+ --        (IsContinuous∘ _ _
+ --          IsContinuous-ᵣ
+ --           (cont-^ _))))
+ --    λ q 1≤q →
+ --      subst2 _≤ᵣ_
+ --        (cong₂ (λ u v → ((u -ᵣ v) ／ᵣ₊
+ --         (fst b +ᵣ -ᵣ fst a , x<y→0<y-x (fst a) (fst b) a<b)))
+ --        (sym (^-rat _ _)) (sym (^-rat _ _)))
+ --        ((cong₂ (λ u v → ((u -ᵣ v) ／ᵣ₊
+ --         (fst b' +ᵣ -ᵣ fst a' , x<y→0<y-x (fst a') (fst b') a'<b')))
+ --        (sym (^-rat _ _)) (sym (^-rat _ _))))
+ --        (slope-monotone-^ℚ a b a' b' a<b a'<b' a≤a' b≤b' q 1≤q))
+
+ -- ^-cont : ∀ (y : ℝ) → IsContinuousWithPred pred0< (curry (fst ∘ (_^ᵣ y)))
+ -- ^-cont  y = {! !}
+
+ -- factor-xᵃ-xᵇ'ᵣ : ∀ x a b → fst (x ^ᵣ a) -ᵣ fst (x ^ᵣ b) ≡
+ --                         fst (x ^ᵣ a) ·ᵣ (1 -ᵣ fst (x ^ᵣ (b -ᵣ a)))
+ -- factor-xᵃ-xᵇ'ᵣ x a b = {!!}
+
+ -- ^-monotone-lemmaℚ : ∀ (x : ℚ₊) y (δ : ℚ₊) → fst ((ℚ₊→ℝ₊ x) ^ℚ y) ∈
+ --                        intervalℙ (minᵣ (fst ((ℚ₊→ℝ₊ x) ^ℚ (y ℚ.+ (fst δ))))
+ --                                      (fst ((ℚ₊→ℝ₊ x) ^ℚ (y ℚ.+ (fst δ)))))
+ --                                  (maxᵣ (fst ((ℚ₊→ℝ₊ x) ^ℚ (y ℚ.+ (fst δ))))
+ --                                      (fst ((ℚ₊→ℝ₊ x) ^ℚ (y ℚ.+ (fst δ)))))
+ -- ^-monotone-lemmaℚ = {!!}
+
+ -- ^-monotone-lemma : ∀ x y δ → fst (x ^ᵣ y) ∈
+ --                        intervalℙ (minᵣ (fst (x ^ᵣ (y -ᵣ δ)))
+ --                                      (fst (x ^ᵣ (y +ᵣ δ))))
+ --                                  (maxᵣ (fst (x ^ᵣ (y -ᵣ δ)))
+ --                                      (fst (x ^ᵣ (y +ᵣ δ))))
+ -- ^-monotone-lemma = {!!}
+ -- -- ^-strictMonotone : ∀ x x' y → 0 <ᵣ y → fst x <ᵣ fst x'
+ -- --   → fst (x ^ᵣ y) <ᵣ fst (x' ^ᵣ y)
+ -- -- ^-strictMonotone = {!!}
+
+--  ^-cont : ∀ (y : ℝ) → IsContinuousWithPred pred0< (curry (fst ∘ (_^ᵣ y)))
+--  ^-cont y u ε 0<u =
+--    PT.rec
+--      squash₁
+--       (λ (δy , Xy) →
+--         PT.rec2 squash₁
+--           (λ (δy- , (<δy- , δy-< )) (δy+ , <δy+ , δy+< )
+--              → PT.map2
+--               (λ (δx- , Xx-) (δx+ , Xx+ ) →
+--                 let δ₊ = ℚ.min₊ (ℚ.min₊ δx- δx+) δy
+--                     Xy- = subst ((fst ((u , 0<u) ^ᵣ y))  ∼[ /4₊ ε ]_)
+--                             (^-rat _ _)
+--                              (Xy (rat δy-)
+--                              {!!})
+--                     Xy+ = subst ((fst ((u , 0<u) ^ᵣ y))  ∼[ /4₊ ε ]_)
+--                             (^-rat _ _)
+--                              (Xy (rat δy+) {!!})
+--                 in δ₊ ,
+--                   λ v 0<v u∼v →
+--                    let Y : fst ((u , 0<u) ^ᵣ y) ∼[ _ ]
+--                             fst ((v , 0<v) ^ᵣ rat δy-)
+--                        Y = triangle∼ Xy-
+--                           (subst ((fst ((u , 0<u) ^ℚ δy-))  ∼[ /4₊ ε ]_)
+--                             (sym (^-rat _ _))
+--                              ((Xx- v 0<v {!!})) )
+--                    in {!!}
+--                  )
+--               (IsContinuous^ℚ δy- u (/4₊ ε) 0<u)
+--               (IsContinuous^ℚ δy+ u (/4₊ ε) 0<u)
+--              )
+--           (denseℚinℝ (y -ᵣ rat (fst δy)) y {!!})
+--           (denseℚinℝ y (y +ᵣ rat (fst δy)) {!!}))
+--       (cont-^ (u , 0<u) y (/4₊ ε))
+-- --     PT.map
+-- --       {!!}
+-- --       (denseℚinℝ 0 (fst δᵣ) (snd δᵣ))
+
+
+   -- Seq⊆.elimProp-∩ Seq⊆-abs<N
+   --    ⊤Pred y tt Seq⊆-abs<N-s⊇-⊤Pred
+   --    (λ (y : ℝ) → IsContinuousWithPred pred0< (curry (fst ∘ (_^ᵣ y))))
+   --    (λ _ → isPropΠ3 λ _ _ _ → squash₁)
+   --    λ n y∈ u ε u∈P → PT.map2
+   --     (λ (δ , X) (δ' , X') →
+   --       ℚ.min₊ δ δ' ,
+   --        λ v 0<v u∼v →
+   --          let B  = fst (∼≃abs<ε _ _ _)
+   --                     $ X  v 0<v (∼-monotone≤ (ℚ.min≤ _ _ ) u∼v)
+   --              B' = fst (∼≃abs<ε _ _ _)
+   --                     $ X' v 0<v (∼-monotone≤ (ℚ.min≤' _ _) u∼v)
+   --          in invEq (∼≃abs<ε _ _ _)
+   --               (isTrans≤<ᵣ _ _ _
+   --                 (^B-δ-lemma n y (u , _) (v , 0<v)
+   --                  (ointervalℙ⊆intervalℙ _ _ _ y∈))
+   --                 (max<-lem _ _ _
+   --                   B
+   --                   B')))
+   --     (IsContinuous^ℚ (fromNat (suc n)) u ε u∈P)
+   --     (IsContinuous^ℚ (fromNeg (suc n)) u ε u∈P)
+
+
+
+ ^-der : ∀ x → ∀ y → derivativeOf (fst ∘ x ^ᵣ_) at y
+               is (fst (x ^ᵣ y) ·ᵣ ln x)
+ ^-der (x , 0<x) = ∩$-elimProp x 0<x
+       {λ (g , d) → (y : ℝ) →
+         derivativeOf (fst ∘ g) at y is (fst (g y) ·ᵣ d)}
+      (λ _ → isPropΠ2 λ _ _ → squash₁)
+       (λ n (a , b) → BDL.expDerA (x , _) n b a)
+
+ ^ᵣ0 : ∀ x → fst (x ^ᵣ 0) ≡ 1
+ ^ᵣ0 x = ^-rat x 0
+
+ ^ᵣ1 : ∀ x → fst (x ^ᵣ 1) ≡ fst x
+ ^ᵣ1 x = ^-rat x 1 ∙ ^ⁿ-1 _
+
+ ^ᵣ[1/n] : ∀ x n₊ → fst (x ^ᵣ rat [ 1 / n₊ ]) ≡ fst (root n₊ x)
+ ^ᵣ[1/n] x n₊ =  ^-rat x [ 1 / n₊ ] ∙ ^ⁿ-1 _
+
+ 1<a→0<ln[a] : ∀ a → (1 <ᵣ fst a) → 0 <ᵣ ln a
+ 1<a→0<ln[a] (a , 0<a) 1<a =
+    ∩$-elimProp a 0<a
+             {λ (_ , lna) → 0 <ᵣ lna}
+               (λ _ → isProp<ᵣ _ _)
+               λ _ _ → BDL.0<preLn _ _ _ _ 1<a
+
+ ^ᵣ+ : ∀ x y y' → x ^ᵣ (y +ᵣ y') ≡ (x ^ᵣ y) ₊·ᵣ (x ^ᵣ y')
+ ^ᵣ+ (x , 0<x) y y' =
+   ∩$-elimProp x 0<x
+    {λ (f , _) → f (y +ᵣ y') ≡ f y ₊·ᵣ f y'}
+    (λ _ → isSetℝ₊ _ _ )
+    λ n x∈ → ℝ₊≡ (sym (BDL.𝒇· _ _ _  _ y y'))
+
+open Pos^ public
+
+
+rootₙ→1 : ∀ x (α : ℝ) → 1 <ᵣ α →
+         ∃[ N ∈ ℕ ]
+           (∀ n → N ℕ.< n → fst (root (1+ n) x) <ᵣ α)
+rootₙ→1 x α 1<α =
+  PT.rec squash₁ w
+    (IsContinuousLim _ 0 (cont-^ x) (α -ᵣ 1 , x<y→0<y-x _ _ 1<α))
+ where
+ w : Σ ℝ₊
+      (λ δ →
+         (r : ℝ) (x＃r : 0 ＃ r) →
+         absᵣ (0 -ᵣ r) <ᵣ fst δ →
+         absᵣ (fst (x ^ᵣ 0) -ᵣ fst (x ^ᵣ r))
+         <ᵣ α -ᵣ 1) →
+      ∃ ℕ (λ N → (n : ℕ) → N ℕ.< n → fst (root (1+ n) x) <ᵣ α)
+ w ((δᵣ , 0<δᵣ) , X) =
+    PT.map
+      (λ (δ , 0<δ , δ<δᵣ) →
+        let 1/δ = (invℚ₊ (δ , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<δ)))
+            ((1+ k) , Y) = ℚ.boundℕ (fst 1/δ)
+        in suc k , λ n <n →
+            <-+o-cancel _ _ (-ᵣ 1)
+              (isTrans≤<ᵣ _ _ _
+                (≤absᵣ _) (isTrans≡<ᵣ _ _ _
+               (cong absᵣ (cong₂ _-ᵣ_
+                (sym (^ᵣ[1/n] x (1+ n)))
+                (sym (^ᵣ0 x)))
+                ∙ minusComm-absᵣ _ _) (X (rat [ 1 / 1+ n ])
+            (inl (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _)))
+             (isTrans≡<ᵣ _ _ _ (
+              cong absᵣ (+IdL _) ∙ sym (-absᵣ _)
+                ∙ absᵣPos _ (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _))) (isTrans<ᵣ _ _ _
+              (<ℚ→<ᵣ [ 1 / 1+ n ] δ
+                (subst2 ℚ._<_
+                  refl
+                  (ℚ.invℚ₊-invol _)
+                  (fst (ℚ.invℚ₊-<-invℚ₊ 1/δ (fromNat (suc n)) )
+                   (ℚ.isTrans< _ _ _
+                     (ℚ.isTrans≤< _ _ _ (ℚ.≤abs (fst 1/δ)) Y)
+                     (ℚ.<ℤ→<ℚ _ _ (invEq (ℤ.pos-<-pos≃ℕ< _ _)
+                      (ℕ.≤-suc <n) )))))) δ<δᵣ)))))
+        )
+      (denseℚinℝ 0 δᵣ 0<δᵣ)
+
+-- clamp : ℚ → ℚ → ℚ → ℚ
+-- clamp d u x = ℚ.min (ℚ.max d x) u
+
+
+ℚ-clamp-<-cases : ∀ L L' x y → L ℚ.< L' → x ℚ.< y →
+                    (ℚ.clamp L L' x ≡ ℚ.clamp L L' y) ⊎
+                       (ℚ.clamp L L' x ℚ.< ℚ.clamp L L' y)
+ℚ-clamp-<-cases L L' x y L<L' x<y =
+  w (ℚ.Dichotomyℚ y L) (ℚ.Dichotomyℚ L' x)
+ where
+ w : _ → _ → _
+ w _ (inl L'≤x) = inl (ℚ.minComm _ _ ∙ ℚ.≤→min _ _ (ℚ.isTrans≤ _ _ _ L'≤x (ℚ.≤max' _ _))
+      ∙ sym ((ℚ.minComm _ _ ∙ ℚ.≤→min _ _
+       (ℚ.isTrans≤ _ _ _ (ℚ.isTrans≤ _ _ _ L'≤x (ℚ.<Weaken≤ _ _ x<y)) (ℚ.≤max' _ _)))))
+ w (inl y≤L) _ = inl
+   (cong (flip ℚ.min _) (ℚ.maxComm _ _ ∙
+    (ℚ.≤→max _ _ (ℚ.isTrans≤ _ _ _  (ℚ.<Weaken≤ _ _ x<y) y≤L)))
+     ∙ cong (flip ℚ.min _) (sym (ℚ.≤→max _ _ y≤L) ∙ ℚ.maxComm _ _))
+
+ w (inr L<y) (inr x<L') = inr
+  (ℚ.isTrans≤< _ _ _
+    (ℚ.min≤ _ _)
+      (ℚ.isTrans<≤ (ℚ.max L x) (ℚ.min y L') _
+        (<ᵣ→<ℚ _ _ (<min-lem (rat y) (rat L') (maxᵣ (rat L) (rat x))
+             (max<-lem _ _ _ (<ℚ→<ᵣ _ _ L<y) (<ℚ→<ᵣ _ _ x<y))
+             (max<-lem _ _ _ ((<ℚ→<ᵣ _ _ L<L')) (<ℚ→<ᵣ _ _ x<L'))))
+        (ℚ.≡Weaken≤ _ _ (cong (flip ℚ.min L') (sym (ℚ.≤→max L y (ℚ.<Weaken≤ _ _ L<y)))))))
+
+ℚ-clamp-<-casesᵣ : ∀ L L' x y → L ℚ.< L' →  x ℚ.< y →
+                    (clampᵣ (rat L) (rat L') (rat x)
+                      ≡ clampᵣ (rat L) (rat L') (rat y)) ⊎
+                       (clampᵣ (rat L) (rat L') (rat x)
+                        <ᵣ clampᵣ (rat L) (rat L') (rat y))
+ℚ-clamp-<-casesᵣ L L' x y L<L' x<y =
+ (⊎.map (cong rat) (<ℚ→<ᵣ _ _)
+    (ℚ-clamp-<-cases L L' x y L<L' x<y))
+
+eventually-lnSeq[x]<lnSeq'[x+Δ] : ∀ (x Δ : ℝ₊) → 1 <ᵣ fst x →
+  ∃[ k ∈ ℕ ] lnSeq x k <ᵣ lnSeq' (x ₊+ᵣ Δ) k
+eventually-lnSeq[x]<lnSeq'[x+Δ] x Δ 1<x =
+   PT.map w
+     (rootₙ→1 x α 1<α)
+
+ where
+
+
+ 0<1-1/[x+Δ] = (isTrans<≡ᵣ _ _ _
+          (invEq (invℝ₊-<-invℝ₊ _ 1)
+            (isTrans≡<ᵣ _ _ _
+              (sym (+IdR _))
+              (<ᵣMonotone+ᵣ _ _ _ _ 1<x (snd Δ)))) (cong fst invℝ₊1) )
+
+
+ 0<1-1/x = (isTrans<≡ᵣ _ _ _
+          (invEq (invℝ₊-<-invℝ₊ _ 1)
+            (isTrans≡<ᵣ _ _ _
+              (sym (+IdR _) ∙ (+ᵣ-rat _ _))
+              1<x)) (cong fst invℝ₊1) )
+
+
+ α : ℝ
+ α = (1 -ᵣ fst (invℝ₊ (x ₊+ᵣ Δ)))
+      ／ᵣ₊ (_ , x<y→0<y-x _ _ 0<1-1/x)
+
+ 1<α : 1 <ᵣ α
+ 1<α = invEq (1<x/y≃y<x _ _)
+   (<ᵣ-o+ _ _ 1
+     (-ᵣ<ᵣ _ _ (invEq (invℝ₊-<-invℝ₊ _ _)
+       (isTrans≡<ᵣ _ _ _
+         (sym (+IdR _))
+         (<ᵣ-o+ _ _ (fst x) (snd Δ))))))
+
+
+
+ w : Σ ℕ
+      (λ N → (n : ℕ) → N ℕ.< n → fst (root (1+ n) x) <ᵣ α) →
+      Σ ℕ (λ k → lnSeq x k <ᵣ lnSeq' (x ₊+ᵣ Δ) k)
+ w (K , X) =
+   K , <ᵣ-·ᵣo _ _ (_ , <ℚ→<ᵣ _ _ (ℚ.0<pos _ _))
+     (isTrans<≤ᵣ _ _ _
+       (isTrans≡<ᵣ _ _ _
+         (cong₂ _-ᵣ_
+           (^ⁿ-1 _ ∙ sym (·IdL _))
+           (cong fst (sym (ₙ√1 _) ∙∙
+             cong (root _) (ℝ₊≡ (sym (x·invℝ₊[x] _) ∙ ·ᵣComm _ _))
+              ∙∙ sym (·DistRoot _ _ _)))
+           ∙ sym (𝐑'.·DistL- _ _ _))
+         (<ᵣ-o·ᵣ _ _
+           (_ , x<y→0<y-x (fst (root (1+ (suc K)) (invℝ₊ x))) 1
+              (isTrans<≡ᵣ _ _ _
+               (ₙ√-StrictMonotone {invℝ₊ x} {1}  (1+ suc K)
+                 (invEq (1/x<1≃1<x x) 1<x))
+               (cong fst (ₙ√1 _))))
+           (X (suc K) (ℕ.≤-refl {suc K}))))
+       from-concave)
+
+  where
+
+  from-concave :
+    (1 -ᵣ fst (root (2+ K) (invℝ₊ x))) ·ᵣ α ≤ᵣ
+     1 -ᵣ fst ((x ₊+ᵣ Δ) ^ℚ (ℚ.- [ 1 / 2+ K ]))
+  from-concave = isTrans≡≤ᵣ (_ ·ᵣ α) _ _
+        (cong₂ (_·ᵣ_) (cong₂ _-ᵣ_ (cong fst (sym (ₙ√1 _)))
+         refl) (·ᵣComm _ _) ∙ ·ᵣAssoc _ _ _ ∙ ·ᵣComm _ _ )
+        (isTrans≤≡ᵣ _ _ _ (fst (z≤x/y₊≃y₊·z≤x _ _ _) (slope-monotone-ₙ√ (suc K)
+         (invℝ₊ (x ₊+ᵣ Δ)) 1
+         (invℝ₊ x) 1
+         0<1-1/[x+Δ]
+         0<1-1/x
+         (invEq (invℝ₊-≤-invℝ₊ _ _)
+           (isTrans≡≤ᵣ _ _ _ (sym (+IdR _))
+            (≤ᵣ-o+ _ _ (fst x) (<ᵣWeaken≤ᵣ _ _ (snd Δ)))))
+            (≤ᵣ-refl 1)))
+            (cong₂ _-ᵣ_ (cong fst (ₙ√1 _))
+            (sym (^ⁿ-1 _) ∙
+             cong fst (sym (^ℚ-minus' _ _)))))
+
+
+
+
+monotoneStrictPreLn : ∀ Z → (z z' : ℝ₊) → 1 <ᵣ fst z →
+         (z≤Z : fst z ≤ᵣ fromNat (suc (suc Z)))
+         (1/Z≤z :  rat [ 1 / fromNat (suc (suc Z)) ] ≤ᵣ fst z)
+         (z'≤Z : fst z' ≤ᵣ fromNat (suc (suc Z)))
+         (1/Z≤z' :  rat [ 1 / fromNat (suc (suc Z)) ] ≤ᵣ fst z')
+         → fst z <ᵣ fst z'
+         → expPreDer.expPreDer'.preLn Z z z≤Z 1/Z≤z  <ᵣ
+           expPreDer.expPreDer'.preLn Z z' z'≤Z 1/Z≤z'
+monotoneStrictPreLn Z z z' 1<z z≤Z 1/Z≤z z'≤Z 1/Z≤z' z<z' =
+  PT.rec (isProp<ᵣ _ _)
+    (λ (K , X) →
+       isTrans<≤ᵣ _ _ _
+         (isTrans≤<ᵣ _ _ _
+           (BDL.preLn≤lnSeq z Z z≤Z 1/Z≤z K) X)
+
+         ((isTrans≡≤ᵣ _ _ _
+          (cong (λ zz → lnSeq' zz K) (ℝ₊≡ L𝐑.lem--05) )
+          (BDL.lnSeq'≤preLn z' Z z'≤Z 1/Z≤z' K)))
+          )
+    (eventually-lnSeq[x]<lnSeq'[x+Δ]
+      z (fst z' +ᵣ -ᵣ fst z , x<y→0<y-x _ _ z<z' )
+      1<z)
+
+
+ln-mon-str-1< :
+   ∀ (y y' : ℝ₊)
+   → 1 <ᵣ fst y
+   → fst y <ᵣ fst y'
+   → ln y <ᵣ ln y'
+ln-mon-str-1< y y' 1<y y<y' =
+ Seq-^-FI.∩$-elimProp2  (fst y) (snd y) (fst y') (snd y')
+  {B = λ (_ , ln-y) (_ , ln-y') → ln-y <ᵣ ln-y'}
+  (λ _ _ → isProp<ᵣ _ _)
+  λ Z x∈ y∈ → monotoneStrictPreLn Z (fst y , _) (fst y' , _)
+    1<y (snd x∈) (fst x∈) (snd y∈) (fst y∈) y<y'
+
+
+-- opaque
+--  unfolding _+ᵣ_
+invLipPreLn : ∀ Z → ∃[ K ∈ _ ]
+              Invlipschitz-ℝ→ℝℙ K
+               ((intervalℙ (rat [ 1 / fromNat (suc (suc Z)) ])
+              (fromNat (suc (suc Z)))))
+              λ x (≤x , x≤) →
+                expPreDer.expPreDer'.preLn Z
+                  (x , isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _)) ≤x)
+                 x≤ ≤x
+invLipPreLn Z =
+   PT.map
+     ww
+     (denseℚinℝ _ _ (snd Kᵣ))
+
+  where
+
+
+   Z<SZ : fst (fromNat (suc (suc Z))) ℚ.<
+       fst (fromNat (suc (suc (suc Z))))
+   Z<SZ =
+                (ℚ.<ℤ→<ℚ (pos (suc (suc Z))) (pos (suc (suc (suc Z))))
+                (invEq (ℤ.pos-<-pos≃ℕ< _ _)
+                  (ℕ.≤-refl {(suc (suc (suc Z)))})))
+   1<Z : [ pos 1 / 1+ 0 ] ℚ.< [ pos (suc (suc Z)) / 1+ 0 ]
+   1<Z =
+                (ℚ.<ℤ→<ℚ (pos (suc zero)) (pos (suc (suc Z)))
+                (invEq (ℤ.pos-<-pos≃ℕ< _ _)
+                  (ℕ.suc-≤-suc (ℕ.suc-≤-suc ℕ.zero-≤))))
+
+   [1/3+Z]≤[2+Z] : rat [ pos 1 / 2+ suc Z ] ≤ᵣ rat [ pos (suc (suc Z)) / 1+ 0 ]
+   [1/3+Z]≤[2+Z] = isTrans≤ᵣ _ 1 _
+     (≤ℚ→≤ᵣ _ _ (fst (ℚ.invℚ₊-≤-invℚ₊ 1 (fromNat (suc (suc (suc Z)))))
+       ((ℚ.<Weaken≤ _ _
+        (ℚ.isTrans< 1 (fst (fromNat (suc (suc Z)))) _ 1<Z (Z<SZ))))
+       ))
+     (<ᵣWeaken≤ᵣ _ _ (<ℚ→<ᵣ _ _ 1<Z))
+
+   2+Z∈ : (fromNat (suc (suc Z))) ∈
+            ((intervalℙ (rat [ 1 / fromNat (suc (suc (suc Z))) ])
+               (fromNat (suc (suc (suc Z))))))
+   2+Z∈ = [1/3+Z]≤[2+Z] , (<ᵣWeaken≤ᵣ _ _ (<ℚ→<ᵣ _ _ Z<SZ))
+
+
+   3+Z∈ : rat ([ (pos (suc (suc (suc Z)))) / 1 ]) ∈
+            ((intervalℙ (rat [ 1 / fromNat (suc (suc (suc Z))) ])
+               (fromNat (suc (suc (suc Z))))))
+   3+Z∈ =
+             (≤ℚ→≤ᵣ _ _
+                (ℚ.isTrans≤ _ 1 [ pos (suc (suc (suc Z))) / (1+ 0) ]
+                  (fst (ℚ.invℚ₊-≤-invℚ₊ 1 (fromNat (suc (suc (suc Z)))))
+                   ((ℚ.≤ℤ→≤ℚ _ (pos _) (invEq (ℤ.pos-≤-pos≃ℕ≤ _ _)
+                (ℕ.suc-≤-suc ℕ.zero-≤)))))
+                  ((ℚ.≤ℤ→≤ℚ _ (pos (suc (suc (suc Z)))) (invEq (ℤ.pos-≤-pos≃ℕ≤ _ _)
+                (ℕ.suc-≤-suc ℕ.zero-≤)))))) , (≤ᵣ-refl _)
+
+
+
+   SSSZ₊ SSZ₊ : ℝ₊
+   SSSZ₊ = (ℚ₊→ℝ₊ ([ (pos (suc (suc (suc Z)))) / 1 ] , _))
+   SSZ₊ = (ℚ₊→ℝ₊ ([ (pos (suc (suc Z))) / 1 ] , _))
+
+   Kᵣ : ℝ₊
+   Kᵣ =
+         BDL.preLn SSSZ₊ (suc Z) (snd 3+Z∈) (fst 3+Z∈)
+          +ᵣ -ᵣ
+
+          BDL.preLn SSZ₊ (suc Z) (snd 2+Z∈) (fst 2+Z∈)
+          ,
+          x<y→0<y-x
+           (BDL.preLn (ℚ₊→ℝ₊ ([ (pos (suc (suc Z))) / 1 ] , _)) (suc Z) (snd 2+Z∈) (fst 2+Z∈))
+           (BDL.preLn (ℚ₊→ℝ₊ ([ (pos (suc (suc (suc Z)))) / 1 ] , _))  (suc Z) (snd 3+Z∈)
+         (fst 3+Z∈))
+           (monotoneStrictPreLn (suc Z)
+             (ℚ₊→ℝ₊ ([ (pos (suc (suc Z))) / 1 ] , _))
+             (ℚ₊→ℝ₊ ([ (pos (suc (suc (suc Z)))) / 1 ] , _))
+             (<ℚ→<ᵣ _ _ 1<Z)
+             (snd 2+Z∈) (fst 2+Z∈)
+             (snd 3+Z∈) (fst 3+Z∈)
+             (<ℚ→<ᵣ _ _ Z<SZ))
+
+   ww : Σ ℚ (λ q → (rat [ pos 0 / 1+ 0 ] <ᵣ rat q) × (rat q <ᵣ Kᵣ .fst)) →
+         Σ ℚ₊
+         (λ K →
+            Invlipschitz-ℝ→ℝℙ K
+            (intervalℙ (rat [ pos 1 / 2+ Z ])
+             (rat [ pos (suc (suc Z)) / 1+ 0 ]))
+            λ x (x≤ , ≤x) → expPreDer.expPreDer'.preLn Z
+                  (x , isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _)) x≤)
+                 ≤x x≤)
+   ww (K , 0<K , K<Kᵣ) =  (invℚ₊ K₊) , zzz
+
+    where
+    K₊ : ℚ₊
+    K₊ = (K , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<K))
+    zzz : Invlipschitz-ℝ→ℝℙ (invℚ₊ K₊)
+      (intervalℙ (rat [ pos 1 / 2+ Z ])
+       (rat [ pos (suc (suc Z)) / 1+ 0 ]))
+      (λ x (≤x , x≤) →
+         BDL.preLn
+         (x ,
+          isTrans<≤ᵣ (rat [ pos 0 / 1+ 0 ]) (rat [ pos 1 / 2+ Z ]) x
+          (<ℚ→<ᵣ [ pos 0 / 1+ 0 ] [ pos 1 / 2+ Z ] (ℚ.0<pos 0 (2+ Z)))
+          ≤x)
+         Z x≤ ≤x )
+    zzz u u∈ v v∈ ε lnU∼lnV =
+     invEq (∼≃abs<ε _ _ _)
+              (isTrans<≡ᵣ _ _ _
+               (isTrans≤<ᵣ _ _ _
+                 zzzz
+                 (isTrans<≡ᵣ _ _ _
+                  (<ᵣ₊Monotone·ᵣ _ _ _ _
+                  (<ᵣWeaken≤ᵣ _ _ (snd (invℝ₊ Kᵣ)))
+                  (0≤absᵣ _)
+                  (invEq (invℝ₊-<-invℝ₊ Kᵣ _)
+                    K<Kᵣ) lnuv<)
+                     (cong₂ _·ᵣ_
+                      (invℝ₊-rat _)
+                      refl))
+                 )
+               (sym (rat·ᵣrat _ _)))
+     where
+      u₊ = _
+      v₊ = _
+
+      lnU = BDL.preLn u₊ Z (snd u∈) (fst u∈)
+      lnV = BDL.preLn v₊ Z (snd v∈) (fst v∈)
+
+
+
+
+      clp : ℝ → ℝ
+      clp = clampᵣ (rat [ 1 / (1+  (suc Z)) ])
+                   (rat [ pos (suc (suc Z)) / 1 ])
+
+      1/SSZ<SSZ = (ℚ.isTrans< _ 1 _
+                ((fst (ℚ.invℚ₊-<-invℚ₊ 1
+                   (([ pos (suc (suc Z)) / 1 ] , _))
+                   )
+                  (1<Z)))
+                ((1<Z)))
+
+
+      1/SSZ≤SSZ = ≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ 1/SSZ<SSZ)
+
+      0<clp : ∀ x → 0 <ᵣ clp x
+      0<clp x = isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<pos _ _))
+         (≤clampᵣ (rat [ 1 / (1+  (suc Z)) ]) _ x 1/SSZ≤SSZ)
+
+      clpCount : IsContinuous clp
+      clpCount = IsContinuousClamp
+         (rat [ 1 / (1+  (suc Z)) ])
+                   (rat [ pos (suc (suc Z)) / 1 ])
+
+      -- lnX : ℝ → ℝ
+      -- lnX x = BDL.preLn (clp x , 0<clp x) Z
+      --    (clamp≤ᵣ (rat [ 1 / fromNat (suc (suc Z)) ]) _ x)
+
+      --    (≤clampᵣ (rat [ 1 / fromNat (suc (suc Z)) ]) _ x
+      --       (isTrans≤ᵣ _ 1 _
+      --           (≤ℚ→≤ᵣ _ _ (fst (ℚ.invℚ₊-≤-invℚ₊ 1 (fromNat (suc (suc Z))))
+      --             (ℚ.<Weaken≤ _ _ 1<Z)))
+      --           (<ᵣWeaken≤ᵣ _ _ (<ℚ→<ᵣ _ _ 1<Z))))
+
+      lnX' : ℝ → ℝ
+      lnX' x = ln (clp x , 0<clp x)
+
+      lnX'ₙ : ∀ (x : ℝ₊) 0<x
+              (x∈ : fst x ∈ (intervalℙ (rat [ 1 /  (2+ (suc Z)) ])
+                        (rat [ pos (suc (suc (suc Z))) / 1 ]))) →
+                ln x ≡ BDL.preLn
+                         (fst x , 0<x) (suc Z) (snd x∈) (fst x∈)
+      lnX'ₙ x 0<x x∈ =
+        cong snd (Seq-^-FI.∩$-∈ₙ (fst x) (snd x) (suc Z) x∈)
+        ∙ cong (λ 0<x → BDL.preLn
+                         (fst x , 0<x) (suc Z) (snd x∈) (fst x∈))
+                         (isProp<ᵣ _ _ _ _)
+
+      clp≡ : ∀ u → u ∈ ((intervalℙ (rat [ 1 /  (1+ (suc Z)) ])
+               (rat [ pos (suc (suc Z)) / 1 ]))) → clp u ≡ u
+      clp≡ u u∈ = sym (∈ℚintervalℙ→clampᵣ≡ _ _ u u∈)
+
+      lnX'Cont : IsContinuous lnX'
+      lnX'Cont = IsContinuousWithPred∘IsContinuous
+       _ _ _ 0<clp
+       ln-cont clpCount
+
+      lnuv< = fst (∼≃abs<ε _ _ _) lnU∼lnV
+
+      zzzz= : ∀ x y → clampᵣ (rat [ pos 1 / 2+ Z ])
+       (rat [ pos (suc (suc Z)) / 1+ 0 ]) (rat x)
+       ≡
+       clampᵣ (rat [ pos 1 / 2+ Z ]) (rat [ pos (suc (suc Z)) / 1+ 0 ])
+       (rat y) →
+       fst Kᵣ ·ᵣ absᵣ (clp (rat x) -ᵣ clp (rat y)) ≤ᵣ
+       absᵣ (lnX' (rat x) -ᵣ lnX' (rat y))
+      zzzz= x y p =
+       ≡ᵣWeaken≤ᵣ _ _
+                 (𝐑'.0RightAnnihilates' _ _
+                   (cong absᵣ (𝐑'.+InvR' _ _ p) ∙ absᵣ-rat 0)
+                   ∙ sym (absᵣ-rat 0) ∙
+                   cong absᵣ (sym (𝐑'.+InvR' _ _
+                     (ll))))
+
+         where
+
+         ll : ln (clp (rat x) , 0<clp (rat x))  ≡ ln (clp (rat y) , 0<clp (rat y))
+         ll = cong ln (ℝ₊≡ p)
+
+      zzzz< : ∀ x y → clampᵣ (rat [ pos 1 / 2+ Z ])
+       (rat [ pos (suc (suc Z)) / 1+ 0 ]) (rat x)
+       <ᵣ
+       clampᵣ (rat [ pos 1 / 2+ Z ]) (rat [ pos (suc (suc Z)) / 1+ 0 ])
+       (rat y) →
+       fst Kᵣ ·ᵣ absᵣ (clp (rat x) -ᵣ clp (rat y)) ≤ᵣ
+       absᵣ (lnX' (rat x) -ᵣ lnX' (rat y))
+      zzzz< x y x<y =
+       isTrans≡≤ᵣ
+         (fst Kᵣ ·ᵣ absᵣ (clp (rat x) -ᵣ clp (rat y)))
+         (absᵣ (clp (rat x) -ᵣ clp (rat y)) ·ᵣ fst Kᵣ)
+         (absᵣ (lnX' (rat x) -ᵣ lnX' (rat y)))
+        (·ᵣComm _ _) (fst (z≤x/y₊≃y₊·z≤x _ _ _)
+          (subst2  _≤ᵣ_
+           (cong₂ _·ᵣ_ refl
+             (cong (fst ∘ invℝ₊)
+              (ℝ₊≡ {_ , _} {_ , isTrans<≡ᵣ _ _ _ decℚ<ᵣ?
+               (sym (cong (rat ∘ [_/ 1 ]) hhhh))} (-ᵣ-rat₂ _ _ ∙ cong rat (ℚ.ℤ-→ℚ- _ _
+               ∙ cong ([_/ 1 ]) (cong₂ ℤ._+_ (ℤ.pos+ _ _) refl ∙ sym (ℤ.+Assoc 1 (pos ((suc (suc Z))))
+                    (ℤ.- (pos (suc (suc Z)))))
+                ∙ 𝐙'.+IdR' _ _ refl )) ))
+             ∙ cong (fst ∘ invℝ₊) (ℝ₊≡ (cong rat (cong [_/ 1 ] hhhh))) ∙ cong fst invℝ₊1 )
+             ∙ (·IdR _) )
+           (cong₂ {y = absᵣ (lnX' (rat x) +ᵣ -ᵣ lnX' (rat y))} _·ᵣ_
+             ( sym (absᵣNonNeg _ (x≤y→0≤y-x _ _
+              (expPreDer.monotonePreLn (suc Z)
+               (clp (rat x) , 0<clp (rat x))
+               (clp (rat y) , 0<clp (rat y))
+                (snd x*∈) (fst x*∈) (snd y*∈) (fst y*∈) (<ᵣWeaken≤ᵣ _ _ x<y))))
+               ∙ cong absᵣ (cong₂ (λ u v → u +ᵣ -ᵣ v)
+               (sym (lnX'ₙ ((clp (rat y)) , 0<clp (rat y)) _ _)) --(sym (lnX'ₙ _ _ _))
+               ((sym (lnX'ₙ (clp (rat x) , 0<clp (rat x)) _ _))) --
+                )
+                 ∙ minusComm-absᵣ (lnX' (rat y)) (lnX' (rat x)))
+
+             (cong (fst ∘ invℝ₊)
+               (ℝ₊≡ {_} {_ , isTrans<≤ᵣ _ _ _ (x<y→0<y-x _ _ x<y)
+                     (isTrans≤≡ᵣ _ _ _ (≤absᵣ _) (minusComm-absᵣ _ _))}
+                  (sym (absᵣPos _ (x<y→0<y-x _ _ x<y))
+                 ∙ minusComm-absᵣ _ _))))
+           zzWW)) --
+         where
+
+         hhhh : 1 ℤ.+ ℤ.predℤ (pos (suc (suc Z)) ℤ.+negsuc Z) ≡ pos 1
+         hhhh = 𝐙'.+IdR' _ _ (cong {y = 1} ℤ.predℤ
+          ((cong (ℤ._+ ℤ.negsuc Z) (ℤ.pos+ _ _) ∙
+           sym (ℤ.+Assoc 1 (pos (suc Z)) (ℤ.negsuc Z))) ∙
+            𝐙'.+IdR' _ _ (ℤ.-Cancel (pos (suc Z))) ))
+
+         SSZ≤SSSZ : [ pos (suc (suc Z)) / 1 ] ℚ.≤ [ pos (suc (suc (suc Z))) / 1 ]
+         SSZ≤SSSZ = (ℚ.<Weaken≤ [ pos (suc (suc Z)) / 1 ] [ pos (suc (suc (suc Z))) / 1 ] Z<SZ)
+
+         1/SSSZ≤1/SSZ : rat [ pos 1 / 2+ suc Z ] ≤ᵣ rat [ pos 1 / 2+ Z ]
+         1/SSSZ≤1/SSZ = ≤ℚ→≤ᵣ _ _
+           (ℚ.invℚ≤invℚ ([ pos (suc (suc (suc Z))) / 1 ] , _)
+            ([ pos (suc (suc Z)) / 1 ] , _) SSZ≤SSSZ)
+
+         x*∈ : clp (rat x) ∈  (intervalℙ (rat [ 1 /  (2+ (suc Z)) ])
+                        (rat [ pos (suc (suc (suc Z))) / 1 ]))
+         x*∈ =
+          let (≤x , x≤) = ((clampᵣ∈ℚintervalℙ _ _ 1/SSZ≤SSZ (rat x)))
+          in isTrans≤ᵣ _ _ _ 1/SSSZ≤1/SSZ ≤x , isTrans≤ᵣ _ _ _ x≤
+            (≤ℚ→≤ᵣ _ _ SSZ≤SSSZ)
+
+         y*∈ : clp (rat y) ∈ (intervalℙ (rat [ 1 /  (2+ (suc Z)) ])
+                        (rat [ pos (suc (suc (suc Z))) / 1 ]))
+         y*∈ =
+          let (≤y , y≤) = ((clampᵣ∈ℚintervalℙ _ _ 1/SSZ≤SSZ (rat y)))
+          in (isTrans≤ᵣ _ _ _ 1/SSSZ≤1/SSZ ≤y) ,
+               isTrans≤ᵣ _ _ _ y≤ ((≤ℚ→≤ᵣ _ _ SSZ≤SSSZ))
+
+
+
+         zzWW : _ ≤ᵣ _
+         zzWW =
+          (expPreDer.slope-monotone-preLn
+             (suc Z) (clp (rat x) , 0<clp (rat x)) (clp (rat y) , 0<clp (rat y))
+              SSZ₊ SSSZ₊
+              (snd x*∈) (fst x*∈)
+              (snd y*∈) (fst y*∈)
+              (snd 2+Z∈) (fst 2+Z∈)
+              (snd 3+Z∈) (fst 3+Z∈)
+              x<y (<ℚ→<ᵣ _ _ Z<SZ) (snd ((clampᵣ∈ℚintervalℙ _ _ 1/SSZ≤SSZ (rat x)))) (snd y*∈))
+
+      opaque
+       unfolding _+ᵣ_
+       zzzz* : fst Kᵣ ·ᵣ absᵣ (clp u -ᵣ clp v) ≤ᵣ absᵣ (lnX' u -ᵣ lnX' v)
+       zzzz* =
+         ≤Cont₂
+            {λ u v → fst Kᵣ ·ᵣ absᵣ (clp u -ᵣ clp v)}
+            {λ u v → absᵣ (lnX' u -ᵣ lnX' v)}
+            (cont∘₂ (IsContinuous∘ _ _
+               (IsContinuous·ᵣL (fst Kᵣ))
+               IsContinuousAbsᵣ)
+              (cont₂∘  (contNE₂ sumR)
+                clpCount
+                (IsContinuous∘ _ _
+                  IsContinuous-ᵣ clpCount)) )
+            (cont∘₂ IsContinuousAbsᵣ
+              (cont₂∘  (contNE₂ sumR)
+                lnX'Cont
+                (IsContinuous∘ _ _
+                  IsContinuous-ᵣ lnX'Cont)
+                ))
+            (ℚ.elimBy≡⊎<
+               (λ x y X →
+                 subst2 (_≤ᵣ_ ∘ (fst Kᵣ ·ᵣ_))
+                   ((minusComm-absᵣ (clp (rat x)) (clp (rat y))))
+                   (minusComm-absᵣ (lnX' (rat x)) (lnX' (rat y)))
+                   X)
+               (λ x → ≡ᵣWeaken≤ᵣ _ _
+                    (𝐑'.0RightAnnihilates' _ _ (cong absᵣ (+-ᵣ _)
+                      ∙ absᵣ-rat 0)
+                     ∙∙ sym (absᵣ-rat 0)
+                     ∙∙ cong absᵣ ((sym (+-ᵣ (lnX' (rat x)))))))
+               λ x y →
+                  ⊎.rec
+                   (zzzz= x y)
+                   (zzzz< x y)
+                   ∘ ℚ-clamp-<-casesᵣ ([ 1 /  (1+ (suc Z)) ])
+                          ([ pos (suc (suc Z)) / 1 ])
+                          x y 1/SSZ<SSZ)
+            u v
+
+      zzzz : absᵣ (u -ᵣ v) ≤ᵣ
+             invℝ₊ Kᵣ .fst ·ᵣ absᵣ (lnU -ᵣ lnV)
+      zzzz =
+        isTrans≤≡ᵣ _ _ _
+          (invEq (z≤x/y₊≃y₊·z≤x _ _ _)
+            (isTrans≤≡ᵣ _ _ _
+              (isTrans≡≤ᵣ _ _ _
+                (cong₂ (λ u v → fst Kᵣ ·ᵣ absᵣ (u -ᵣ v))
+                  (∈ℚintervalℙ→clampᵣ≡ _ _ u u∈)
+                  (∈ℚintervalℙ→clampᵣ≡ _ _ v v∈))
+                zzzz*)
+              (cong absᵣ
+                (cong₂ _-ᵣ_
+                  (cong ln
+                      ((ℝ₊≡
+                         {clp u , 0<clp u} {u , snd u₊}
+                        (sym (∈ℚintervalℙ→clampᵣ≡ _ _ u u∈))))
+         ∙∙ cong snd (Seq-^-FI.∩$-∈ₙ u (snd u₊) Z u∈)
+         ∙∙ cong (λ 0<u → BDL.preLn (u , 0<u) Z (snd u∈) (fst u∈))
+               (isProp<ᵣ 0 u _ _))
+
+                  (cong ln
+                      ((ℝ₊≡
+                         {clp v , 0<clp v} {v , snd v₊}
+                        (sym (∈ℚintervalℙ→clampᵣ≡ _ _ v v∈))))
+         ∙∙ cong snd (Seq-^-FI.∩$-∈ₙ v (snd v₊) Z v∈)
+         ∙∙ cong (λ 0<v → BDL.preLn (v , 0<v) Z (snd v∈) (fst v∈))
+               (isProp<ᵣ 0 v _ _))
+                  ))))
+          (·ᵣComm _ _)
+
+^ᵣ· : (x : ℝ₊) (a b : ℝ) →
+      fst ((x ^ᵣ a) ^ᵣ b) ≡ fst (x ^ᵣ (a ·ᵣ b))
+^ᵣ· x a  =
+   ≡Continuous _ _
+      (cont-^ _)
+       (IsContinuous∘ _ _ (cont-^ x)
+         (IsContinuous·ᵣL a))
+     λ b' →
+      ^-rat _ _ ∙
+         ≡Continuous _ _
+           (IsContinuousWithPred∘IsContinuous _ _
+             _ (λ v → snd (x ^ᵣ v)) (IsContinuous^ℚ b') (cont-^ x))
+           (IsContinuous∘ _ _ (cont-^ x)
+         (IsContinuous·ᵣR (rat b')))
+           (λ a' →
+           (cong (fst ∘ _^ℚ b') (ℝ₊≡ (^-rat x a')))
+             ∙ cong fst (^ℚ-· x a' b') ∙
+             sym (^-rat _ _) ∙ cong (fst ∘ (x ^ᵣ_)) (rat·ᵣrat _ _))
+           a
+
+inj-ln : ∀ x y → ln x ≡ ln y → x ≡ y
+inj-ln (x , 0<x) (y , 0<y) =
+  Seq-^-FI.∩$-elimProp2 x 0<x y 0<y
+   {λ (_ , ln-x) (_ , ln-y) → ln-x ≡ ln-y → (x , 0<x) ≡ (y , 0<y) }
+   (λ _ _ → isPropΠ λ _ → isSetℝ₊ _ _)
+   λ Z x∈ y∈ p →
+     PT.rec (isSetℝ₊ _ _)
+       (λ (_ , isLip) →
+         ℝ₊≡ (Invlipschitz-ℝ→ℝ→injective-interval _ _ _ _ isLip x x∈ y y∈
+          p))
+      (invLipPreLn Z)
+
+ln[a^b₊]≡b₊·ln[a] : ∀ a (b : ℝ₊) → ln (a ^ᵣ (fst b)) ≡ fst b ·ᵣ ln a
+ln[a^b₊]≡b₊·ln[a] a (b , 0<b) =
+   limitUniq _ _ _ _ (zz b) (zz' b 0<b) ∙ ·ᵣComm _ _
+  where
+  zz : ∀ b → derivativeOf (fst ∘ a ^ᵣ_  ∘ (b ·ᵣ_)) at 0 is
+        (ln (a ^ᵣ b))
+  zz b = substDer
+     (λ r → ^ᵣ· _ _ _)
+     (subst (derivativeOf (fst ∘ (a ^ᵣ b) ^ᵣ_ ) at 0 is_)
+     ((𝐑'.·IdL' _ _ (^ᵣ0 _))) (^-der (a ^ᵣ b) 0))
+
+  zz'' : ∀ b (0<b : 0 <ᵣ b) → derivativeOf (fst ∘ a ^ᵣ_  ∘ (b ·ᵣ_))
+                at 0 ／ᵣ₊ (b , 0<b) is (b ·ᵣ (fst (a ^ᵣ 0) ·ᵣ ln a))
+  zz'' b 0<b = derivative-∘· _ _ _ (b , 0<b) (^-der a 0)
+
+  zz' : ∀ b (0<b : 0 <ᵣ b) → derivativeOf (fst ∘ a ^ᵣ_  ∘ (b ·ᵣ_)) at 0 is (ln a ·ᵣ b)
+  zz' b 0<b = subst2 (derivativeOf (fst ∘ a ^ᵣ_  ∘ (b ·ᵣ_)) at_is_)
+         (𝐑'.0LeftAnnihilates _) (cong (b ·ᵣ_) (𝐑'.·IdL' _ _ (^ᵣ0 a)) ∙ ·ᵣComm _ _) (zz'' b 0<b)
+
+ln[a^b]≡b·ln[a] : ∀ a b → ln (a ^ᵣ b) ≡ b ·ᵣ ln a
+ln[a^b]≡b·ln[a] a =
+  ≡Continuous _ _
+    (IsContinuousWithPred∘IsContinuous
+     _ _ _
+      (λ x → snd (a ^ᵣ x))
+      ln-cont
+      (cont-^ a)) (IsContinuous·ᵣR _)
+    (ℚ.byTrichotomy 0 ww)
+
+  where
+  ww : ℚ.TrichotomyRec 0 (λ z → ln (a ^ᵣ rat z) ≡ rat z ·ᵣ ln a)
+  ww .ℚ.TrichotomyRec.lt-case b b<0 =
+    cong ln (ℝ₊≡ (^-rat _ _ ∙∙ cong fst (^ℚ-minus _ _) ∙∙ sym (^-rat _ _)))
+     ∙∙ ln[a^b₊]≡b₊·ln[a] (invℝ₊ a) (rat (ℚ.- b) ,
+      <ℚ→<ᵣ _ _ (ℚ.minus-< _ _ b<0) ) ∙∙
+       (cong₂ _·ᵣ_ (sym (-ᵣ-rat b)) (ln-inv a) ∙  -ᵣ·-ᵣ _ _)
+  ww .ℚ.TrichotomyRec.eq-case = (cong ln (ℝ₊≡ (^ᵣ0 _)) ∙ ln-1≡0)
+    ∙ sym (𝐑'.0LeftAnnihilates (ln a))
+  ww .ℚ.TrichotomyRec.gt-case b 0<b =
+    ln[a^b₊]≡b₊·ln[a] a (rat b , <ℚ→<ᵣ _ _ 0<b)
diff --git a/Cubical/HITs/CauchyReals/Integration.agda b/Cubical/HITs/CauchyReals/Integration.agda
new file mode 100644
index 0000000000..da0ca167f6
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Integration.agda
@@ -0,0 +1,2608 @@
+{-# OPTIONS --safe #-}
+
+module Cubical.HITs.CauchyReals.Integration where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Equiv.Properties
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.Powerset
+open import Cubical.Functions.FunExtEquiv
+
+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.Data.Fin
+
+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
+open import Cubical.HITs.CauchyReals.Sequence
+open import Cubical.HITs.CauchyReals.Derivative
+
+private
+  variable
+    ℓ : Level
+    A A' B B' : Type ℓ
+
+clampCases : ∀ a b → a ℚ.≤ b → ∀ u v → u ℚ.≤ v →
+            (ℚ.clamp a b v ℚ.- ℚ.clamp a b u ≡ 0)
+              ⊎ ((a ℚ.≤ v) × (u ℚ.≤ b))
+clampCases a b a≤b u v u≤v =
+  ⊎.rec (λ a≤v →
+     ⊎.rec (λ u≤b → inr (a≤v , u≤b))
+       (λ b<u → inl (𝐐'.+InvR' (ℚ.clamp a b v) (ℚ.clamp a b u)
+         (ℚ.minComm (ℚ.max a v) b ∙∙
+           ℚ.≤→min _ (ℚ.max a v) ((ℚ.isTrans≤ b u _ (ℚ.<Weaken≤ b u b<u)
+            (ℚ.isTrans≤ u v _ u≤v (ℚ.≤max' a v )))) ∙
+            sym (ℚ.≤→min b (ℚ.max a u)
+              ((ℚ.isTrans≤ b u _ (ℚ.<Weaken≤ b u b<u)
+            ((ℚ.≤max' a u )))))
+             ∙∙ ℚ.minComm b (ℚ.max a u)  )) )
+      (ℚ.Dichotomyℚ u b))
+   (λ v<a → inl (𝐐'.+InvR' (ℚ.clamp a b v) (ℚ.clamp a b u)
+      (ℚ.minComm (ℚ.max a v) b ∙∙
+        cong (ℚ.min b) (ℚ.maxComm a v ∙ ℚ.≤→max v a (ℚ.<Weaken≤ v a v<a) ∙
+          sym (ℚ.≤→max u a (ℚ.isTrans≤  u v _ u≤v (ℚ.<Weaken≤ v a v<a)))
+           ∙ ℚ.maxComm u a )
+       ∙∙ ℚ.minComm b (ℚ.max a u))))
+   (ℚ.Dichotomyℚ a v)
+
+
+⊎-⊎-×-rec : A ⊎ B → A' ⊎ B' → (A ⊎ A') ⊎ (B × B')
+⊎-⊎-×-rec (inl x) _ = inl (inl x)
+⊎-⊎-×-rec (inr _) (inl x) = inl (inr x)
+⊎-⊎-×-rec (inr x) (inr x₁) = inr (x , x₁)
+
+≤x→clamp : ∀ L L' x → L' ℚ.≤ x → ℚ.clamp L L' x ≡ L'
+≤x→clamp L L' x L'≤x = ℚ.minComm (ℚ.max L x) L'
+  ∙ ℚ.≤→min L' (ℚ.max L x) (ℚ.isTrans≤ L' x _ L'≤x (ℚ.≤max' L x))
+
+x≤→clamp : ∀ L L' x → L ℚ.≤ L' → x ℚ.≤ L → ℚ.clamp L L' x ≡ L
+x≤→clamp L L' x L≤L' x≤L = ℚ.≤→min (ℚ.max L x) L'
+  (subst (ℚ.max L x ℚ.≤_) (ℚ.maxIdem L')
+   (ℚ.≤MonotoneMax L L' x L' L≤L' (ℚ.isTrans≤ x L L' x≤L L≤L')) ) ∙
+  ℚ.maxComm L x ∙ ℚ.≤→max x L x≤L
+
+
+clampDegen : ∀ a b x → b ℚ.≤ a → ℚ.clamp a b x ≡ b
+clampDegen a b x b≤a =
+  ℚ.minComm (ℚ.max a x) b ∙
+   ℚ.≤→min _ _ (ℚ.isTrans≤ b a _ b≤a (ℚ.≤max a x))
+
+
+
+ℚclampInterval-delta : ∀ a b a' b'
+          → a  ℚ.≤ b
+          → a' ℚ.≤ b'
+               → ℚ.clamp a  b  b' ℚ.- ℚ.clamp a  b  a'
+               ≡ ℚ.clamp a' b' b  ℚ.- ℚ.clamp a' b' a
+ℚclampInterval-delta a b a' b' a≤b a'≤b' =
+ ⊎.rec (⊎.rec
+         (hhh a b a' b' a≤b a'≤b'  )
+         (sym ∘ hhh a' b' a b a'≤b' a≤b))
+       (λ (a≤b' , a'≤b) →
+          hhh' a b a' b' a≤b a'≤b' a≤b' a'≤b
+           ∙∙ cong₂ ℚ._-_ (ℚ.minComm b' b) (ℚ.maxComm a a') ∙∙
+           sym (hhh' a' b' a b a'≤b' a≤b a'≤b a≤b') )
+       (⊎-⊎-×-rec
+          (ℚ.≤cases b' a)
+          (ℚ.≤cases b a'))
+
+  where
+
+  hhh' : ∀ a b a' b'
+         → a  ℚ.≤ b
+         → a' ℚ.≤ b'
+         → a ℚ.≤ b' → a' ℚ.≤ b
+              → ℚ.clamp a  b  b' ℚ.- ℚ.clamp a  b  a'
+              ≡ ℚ.min b' b ℚ.- ℚ.max a a'
+  hhh' a b a' b' a≤b a'≤b' a≤b' a'≤b =
+    cong₂ ℚ._-_ (cong (flip ℚ.min b) (ℚ.≤→max a b' a≤b'))
+            (ℚ.≤→min (ℚ.max a a') b
+             (subst (ℚ.max a a' ℚ.≤_) (ℚ.maxIdem b)
+              (ℚ.≤MonotoneMax a b a' b a≤b a'≤b)) )
+
+
+
+  hhh : ∀ a b a' b'
+         → a  ℚ.≤ b
+         → a' ℚ.≤ b'
+         → b' ℚ.≤ a
+              → ℚ.clamp a  b  b' ℚ.- ℚ.clamp a  b  a'
+              ≡ ℚ.clamp a' b' b  ℚ.- ℚ.clamp a' b' a
+  hhh a b a' b' a≤b a'≤b' b'≤a =
+     cong₂ ℚ._-_ (x≤→clamp a b b' a≤b b'≤a)
+                 (x≤→clamp a b a' a≤b (ℚ.isTrans≤ a' b' a a'≤b' b'≤a))
+      ∙∙ ℚ.+InvR a ∙ sym (ℚ.+InvR b') ∙∙
+      cong₂ ℚ._-_
+        (sym (≤x→clamp a' b' b (ℚ.isTrans≤ b' a b b'≤a a≤b)))
+        (sym (≤x→clamp a' b' a b'≤a))
+
+clamp-dist : ∀ a b x y →
+  ℚ.abs (ℚ.clamp a b x ℚ.- ℚ.clamp a b y) ℚ.≤ ℚ.abs (b ℚ.- a)
+clamp-dist a b =
+  ⊎.rec
+    (λ a≤b →
+      ℚ.elimBy≤
+       (λ x y X →
+         subst (ℚ._≤ ℚ.abs (b ℚ.- a))
+          (ℚ.absComm- (ℚ.clamp a b x) (ℚ.clamp a b y)) X)
+       λ x y x≤y →
+         subst (ℚ._≤ ℚ.abs (b ℚ.- a))
+           (cong ℚ.abs
+             (sym (ℚclampInterval-delta a b x y a≤b x≤y))
+           ∙ ℚ.absComm- (ℚ.clamp a b y) (ℚ.clamp a b x))
+           (ℚ.clampDist x y a b))
+    (λ b≤a x y →
+      subst (ℚ._≤ ℚ.abs (b ℚ.- a))
+       (cong ℚ.abs (sym (𝐐'.+InvR' _ _
+         (clampDegen a b x b≤a ∙ sym (clampDegen a b y b≤a)))))
+       (ℚ.0≤abs (b ℚ.- a)) )
+   (ℚ.≤cases a b)
+
+clampᵣ-dist : ∀ a b x y → absᵣ (clampᵣ a b x -ᵣ clampᵣ a b y) ≤ᵣ absᵣ (b -ᵣ a)
+clampᵣ-dist a b x y = ≤Cont₂
+ {f₀ x y} {λ a b → absᵣ (b -ᵣ a)}
+ (cont∘₂ IsContinuousAbsᵣ
+        (IsContinuous-₂∘ (IsContinuousClamp₂ _) (IsContinuousClamp₂ _)))
+   ((cont∘₂ IsContinuousAbsᵣ
+        (IsContinuous-₂∘
+
+          ((λ _ → IsContinuousId) , ((λ _ → IsContinuousConst _)))
+          (((λ _ → IsContinuousConst _)) ,
+            (λ _ → IsContinuousId))) ))
+  (λ aℚ bℚ →  let a = (rat aℚ) ; b = (rat bℚ) in
+    ≤Cont₂ {λ x y → f₀ x y a b} {λ _ _ → absᵣ (b -ᵣ a)}
+      (cont∘₂ IsContinuousAbsᵣ
+        (IsContinuous-₂∘
+          (((λ _ → IsContinuousConst _)) ,
+            (λ _ → IsContinuousClamp a b))
+          ((λ _ → IsContinuousClamp a b) , ((λ _ → IsContinuousConst _)))) )
+        ((λ _ → IsContinuousConst _) , (λ _ → IsContinuousConst _))
+      (λ x y → subst2 _≤ᵣ_
+        (sym (absᵣ-rat _) ∙
+           cong absᵣ (sym (-ᵣ-rat₂ _ _) ))
+        (sym (absᵣ-rat _) ∙ cong absᵣ (sym (-ᵣ-rat₂ _ _) ))
+        (≤ℚ→≤ᵣ _ _ (clamp-dist aℚ bℚ x y))) x y)
+ a b
+ where
+ f₀ : ℝ → ℝ → ℝ → ℝ → ℝ
+ f₀ x y a b  = absᵣ (clampᵣ a b x -ᵣ clampᵣ a b y)
+
+
+-- mkℝfun : (f : ℚ → ℝ) → (fc : ℚ₊ → ℚ₊)
+--        → (∀ x y → fst x ℚ.≤ fst y → fst (fc x) ℚ.≤ fst (fc y) )
+--        → (gG : ∀ (ε : ℚ₊) → Σ[ φ ∈ ℚ₊ ] fst (fc φ) ℚ.≤ fst ε)
+--        → ((∀ δ ε → fst (fst (gG δ) ℚ₊+ fst (gG ε)) ℚ.≤ fst (fst (gG (δ ℚ₊+ ε)))))
+--        → (∀ (ε δ δ' : ℚ₊) →
+--              (0<ε-[Δ+Δ'] : 0< (fst ε ℚ.- (fst δ ℚ.+ fst δ')))
+--              → Σ[ (σ , σ') ∈ (ℚ₊ × ℚ₊) ]
+--                   ((0< (fst (fc ε) ℚ.- (fst σ ℚ.+ fst σ')))
+--                    ×  (fst
+--                     (fc (fst (gG σ) ℚ₊+ δ) ℚ₊+
+--                      (fc ((fst ε ℚ.- (fst δ ℚ.+ fst δ')) , 0<ε-[Δ+Δ']) ℚ₊+
+--                       fc (δ' ℚ₊+ fst (gG σ'))))
+--                     ℚ.≤ (fc ε .fst ℚ.- (fst σ ℚ.+ fst σ')))))
+--        → ((q r : ℚ) (ε : ℚ₊) → ℚ.abs (q ℚ.- r) ℚ.< fst ε → f q ∼[ fc ε ] f r)
+--        →  (ℝ → ℝ)
+-- mkℝfun f fc fcMon cvf gConvex fp fC = go w
+--  where
+--   open Elimℝ
+--   g = fst ∘ cvf
+--   G : ∀ ε → fst (fc (g ε)) ℚ.≤ fst ε
+--   G = snd ∘ cvf
+
+--   w : Elimℝ (λ _ → ℝ)
+--        λ {x} {x'} fx fx' ε x∼x' → fx ∼[ fc ε ] fx'
+--   w .ratA = f
+--   w .limA x p a R =
+--     lim (a ∘ g)
+--       λ δ ε →
+--         ∼-monotone≤
+--          (ℚ.isTrans≤ _ _ _ (fcMon _ _ (gConvex _ _)) (G (δ ℚ₊+ ε)))
+--           (R (g δ) (g ε))
+
+--   w .eqA p a a' _ X =
+--     eqℝ _ _ (∼-monotone≤ (G _) ∘ X ∘ g)
+
+--   w .rat-rat-B q r ε x x₁ =
+--      fC q r ε (ℚ.absFrom<×< (fst ε) (q ℚ.- r) x x₁)
+--   w .rat-lim-B = {!!}
+--   w .lim-rat-B _ r ε δ p v u v' u' x₁ =
+--     {!!}
+--   w .lim-lim-B _ _ ε δ δ' _ _ 0<ε-[Δ+Δ'] _ v u v' u' X  =
+--     let (σ , σ') , S , Y = fp ε δ δ' 0<ε-[Δ+Δ']
+--     in lim-lim _ _ _ σ σ' _ _ S
+--            (∼-monotone≤ Y
+--               (triangle∼ (u (g σ) δ)
+--                 (triangle∼ X (u' δ' (g σ')))))
+
+
+
+--   w .isPropB a a' ε _ = isProp∼ _ _ _
+
+
+-- fromLLipschitz : ∀ f → LLipschitz-ℚ→ℝ f
+--   → Σ[ fᵣ ∈ (ℝ → ℝ) ] IsContinuous fᵣ × (∀ x → fᵣ (rat x) ≡ f x )
+-- fromLLipschitz f lli = {!!}
+--  -- fᵣ , {!!}
+--  -- where
+--  -- fᵣ : ℝ → ℝ
+--  -- fᵣ x  =
+--  --  rec→Set isSetℝ
+--  --    ff {!!}
+--  --    (lli x)
+--  --  where
+--  --   ff : (Σ[ (L , ε) ∈ (ℚ₊ × ℚ₊) ]
+--  --           ∀ q r → absᵣ (rat q -ᵣ x) <ᵣ rat (fst ε)
+--  --            → absᵣ (rat r -ᵣ x) <ᵣ rat (fst ε)
+--  --              → f q ∼[ L ℚ₊· ε  ] f r)
+--  --              → ℝ
+
+--  --   ff ((L , ε) , X) = {!!}
+--  --     where
+--  --     zz : {!!}
+--  --     zz = extend-Lipshitzℚ→ℝ L {!!} {!!} {!!}  {!!}
+--  --            {!!}
+
+
+--  --   cf : {!!}
+--  --   cf = {!!}
+
+ℕ₊₁→ℕ-lem : ∀ n m → n ≡ ℕ₊₁→ℕ m → (1+ predℕ n) ≡ m
+ℕ₊₁→ℕ-lem zero m x = ⊥.rec (ℕ.znots x )
+ℕ₊₁→ℕ-lem (suc n) m x = cong 1+_ (ℕ.injSuc x)
+
+
+
+
+
+
+foldlFin : ∀ {n} → (B → A → B) → B → (Fin n → A) → B
+foldlFin {n = zero} f b v = b
+foldlFin {n = suc n} f b v = foldlFin {n = n} f (f b (v fzero)) (v ∘ fsuc)
+
+substFin : ∀ {n} {m} → n ≡ m → Fin n → Fin m
+substFin p = map-snd (subst (_ ℕ.<_) p)
+
+foldFin+ᵣ : ∀ n V (f : A → ℝ) x x' →
+  foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f y) (x +ᵣ x') V ≡
+   x +ᵣ foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f y) x' V
+foldFin+ᵣ zero V f x x' = refl
+foldFin+ᵣ (suc n) V f x x' =
+  foldFin+ᵣ n (V ∘ fsuc) _ (x +ᵣ x') (f (V fzero)) ∙
+   sym (+ᵣAssoc x _ _) ∙
+   cong (x +ᵣ_) (sym (foldFin+ᵣ n (V ∘ fsuc) f x' (f (V fzero))))
+
+foldFin+0ᵣ : ∀ n V (f : A → ℝ) x →
+  foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f y) x V ≡
+   x +ᵣ foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f y) 0 V
+foldFin+0ᵣ n V f x =
+ cong (λ x → foldlFin (λ a y → a +ᵣ f y) x V) (sym (+IdR _))
+ ∙ foldFin+ᵣ n V f x 0
+
+
+zip-foldFin+ᵣ : ∀ n V V' (f : A → ℝ) (f' : A' → ℝ) x x' →
+  foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f y) x V
+    +ᵣ foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f' y) x' V' ≡
+   foldlFin {B = ℝ} {n = n} (λ a (y , y') → a +ᵣ (f y +ᵣ f' y')) (x +ᵣ x')
+    λ x → V x , V' x
+zip-foldFin+ᵣ zero V V' f f' _ _ = refl
+zip-foldFin+ᵣ (suc n) V V' f f' x x' =
+  zip-foldFin+ᵣ n (V ∘ fsuc) (V' ∘ fsuc) f f'
+     (x +ᵣ f (V fzero)) (x' +ᵣ f' (V' fzero))
+   ∙ cong (λ xx → foldlFin
+      _
+      xx
+      (λ x₁ → V (fsuc x₁) , V' (fsuc x₁)))
+      (L𝐑.lem--087 {x} {f (V fzero)} {x'} {f' (V' fzero)})
+
+zip-foldFin+ᵣ' : ∀ n V (f : A → ℝ) (f' : A → ℝ) x x' →
+  foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f y) x V
+    +ᵣ foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f' y) x' V ≡
+   foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ (f y +ᵣ f' y)) (x +ᵣ x')
+    V
+zip-foldFin+ᵣ' zero V f f' _ _ = refl
+zip-foldFin+ᵣ' (suc n) V  f f' x x' =
+  zip-foldFin+ᵣ' n (V ∘ fsuc) f f'
+     (x +ᵣ f (V fzero)) (x' +ᵣ f' (V fzero))
+   ∙ cong (λ xx → foldlFin
+      _
+      xx
+      (V ∘ fsuc) )
+      (L𝐑.lem--087 {x} {f (V fzero)} {x'} {f' (V fzero)})
+
+
+foldFin·DistL : ∀ n (f : A → ℝ) α x V →
+  foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ α ·ᵣ f y) (α ·ᵣ x) V
+      ≡ α ·ᵣ foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f y) (x) V
+foldFin·DistL zero f α x V = refl
+foldFin·DistL (suc n) f α x V =
+  cong (λ z → foldlFin (λ a y → a +ᵣ α ·ᵣ f y) z
+      (λ x₁ → V (fsuc x₁)))
+       (sym (·DistL+ _ _ _))
+  ∙ foldFin·DistL n f α (x +ᵣ f (V fzero)) (V ∘ fsuc)
+
+
+foldFin+map : ∀ n x (f : A → ℝ) (g : B → A) V →
+  foldlFin {B = ℝ} {A = A} {n = n} (λ a y → a +ᵣ f y) x (g ∘ V)
+    ≡ foldlFin {B = ℝ} {A = B} {n = n} (λ a y → a +ᵣ f (g y)) x V
+foldFin+map zero x f g V = refl
+foldFin+map (suc n) x f g V =
+ foldFin+map n (x +ᵣ f ((g ∘ V) fzero)) f g (V ∘ fsuc)
+
+
+foldFin+transpose : ∀ n n' (f : Fin n → Fin n' → ℝ) x →
+  foldlFin {B = ℝ} {n = n} (λ a k → a +ᵣ
+      foldlFin {B = ℝ} {n = n'} (λ a k' → a +ᵣ
+      f k k') (fromNat zero) (idfun _)) x (idfun _)
+      ≡ foldlFin {B = ℝ} {n = n'} (λ a k' → a +ᵣ
+           foldlFin {B = ℝ} {n = n} (λ a k → a +ᵣ
+           f k k') (fromNat zero) (idfun _)) x (idfun _)
+foldFin+transpose zero zero f x = refl
+foldFin+transpose (suc n) zero f x =
+   foldFin+map n (x +ᵣ 0) _ fsuc (idfun _) ∙
+    foldFin+transpose n zero (f ∘ fsuc) _ ∙ +IdR x
+foldFin+transpose n (suc n') f x =
+     ((cong (foldlFin {n = n})
+        (funExt₂ λ a k →
+           cong (a +ᵣ_)
+            ((λ i → foldFin+map _ (+IdL (f k (idfun (Fin (suc n')) fzero)) i)
+             (λ k' → f k k') fsuc (idfun _) i)
+              ∙ foldFin+0ᵣ n' (idfun _) _ _))
+         ≡$ x) ≡$ (idfun (Fin n)))
+   ∙ ((λ i → foldFin+map n (+IdL x (~ i))
+     (λ z →
+        f (z .fst) 0 +ᵣ
+        foldlFin (λ a₁ k' → a₁ +ᵣ f (z .snd) (fsuc k')) 0 (idfun (Fin n')))
+     (λ x → x , x) (idfun _) (~ i))
+   ∙ sym (zip-foldFin+ᵣ n _ _ _ _ 0 x)
+   ∙ sym (foldFin+ᵣ n _ _
+      (foldlFin (λ a k → a +ᵣ f k 0) 0 (idfun _)) x))
+    ∙ (cong (foldlFin {n = n}
+       (λ a k →
+          a +ᵣ
+          foldlFin (λ a₁ k' → a₁ +ᵣ f k (fsuc k')) 0
+          (idfun _)))
+           (+ᵣComm _ _) ≡$ (idfun (Fin n)))
+  ∙ foldFin+transpose n n' _ _
+  ∙ sym (foldFin+map n' _ _ fsuc (idfun _))
+
+
+
+foldFin·DistL' : ∀ n (f : A → ℝ) α V →
+  foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ α ·ᵣ f y) 0 V
+      ≡ α ·ᵣ foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f y) 0 V
+foldFin·DistL' n f α V =
+ cong  (λ x →   foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ α ·ᵣ f y) x V)
+     (sym (𝐑'.0RightAnnihilates _))
+ ∙ foldFin·DistL n f α 0 V
+
+
+
+zip-foldFin-ᵣ : ∀ n V V' (f : A → ℝ) (f' : A' → ℝ) x x' →
+  foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f y) x V
+    -ᵣ foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f' y) x' V' ≡
+   foldlFin {B = ℝ} {n = n} (λ a (y , y') → a +ᵣ (f y -ᵣ f' y')) (x -ᵣ x')
+    λ x → V x , V' x
+zip-foldFin-ᵣ n V V' f f' x x' =
+ cong ((foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f y) x V) +ᵣ_)
+  (-ᵣ≡[-1·ᵣ] (foldlFin {B = ℝ} {n = n} (λ a y → a +ᵣ f' y) x' V')
+   ∙ sym (foldFin·DistL n _ (-1) _ _)) ∙
+  zip-foldFin+ᵣ n V V' f _ _ _ ∙
+   ((cong₂ foldlFin (funExt₂ λ a u → cong ((a +ᵣ_) ∘ (f (fst u) +ᵣ_))
+    (sym (-ᵣ≡[-1·ᵣ] _)))
+     (cong (x +ᵣ_) (sym (-ᵣ≡[-1·ᵣ] _)))) ≡$ (λ x₁ → V x₁ , V' x₁))
+
+
+foldFin+≤ : ∀ n x x' (f : A → ℝ) (f' : A' → ℝ) V V' →
+   x ≤ᵣ x' →
+  (∀ k → f (V k) ≤ᵣ f' (V' k)) →
+  foldlFin {B = ℝ} {A = A} {n = n} (λ a y → a +ᵣ f y) x V
+    ≤ᵣ foldlFin {B = ℝ} {A = A'} {n = n} (λ a y → a +ᵣ f' y) x' V'
+
+foldFin+≤ zero x x' f f' V V' x≤x' f≤f' = x≤x'
+foldFin+≤ (suc n) x x' f f' V V' x≤x' f≤f' =
+  foldFin+≤ n _ _ f f' (V ∘ fsuc) (V' ∘ fsuc)
+    (≤ᵣMonotone+ᵣ _ _ _ _ x≤x' (f≤f' fzero)) (f≤f' ∘ fsuc)
+
+
+foldFin+< : ∀ n x x' (f : A → ℝ) (f' : A' → ℝ) V V' →
+   x ≤ᵣ x' →
+  (∀ k → f (V k) <ᵣ f' (V' k)) →
+  foldlFin {B = ℝ} {A = A} {n = (suc n)} (λ a y → a +ᵣ f y) x V
+    <ᵣ foldlFin {B = ℝ} {A = A'} {n = (suc n)} (λ a y → a +ᵣ f' y) x' V'
+
+foldFin+< zero x x' f f' V V' x≤x' X = ≤<ᵣMonotone+ᵣ _ _ _ _ x≤x' (X fzero)
+foldFin+< (suc n) x x' f f' V V' x≤x' X =
+ foldFin+< n _ _ f f' (V ∘ fsuc) (V' ∘ fsuc)
+          (≤ᵣMonotone+ᵣ _ _ _ _ x≤x' (<ᵣWeaken≤ᵣ _ _ $ X fzero)) (X ∘ fsuc)
+
+
+foldFin+<-abs : ∀ n → zero ℕ.< n → ∀ x x' (f : A → ℝ) (f' : A' → ℝ) V V'  →
+   absᵣ x ≤ᵣ x' →
+  (∀ k → absᵣ (f (V k)) <ᵣ f' (V' k)) →
+  absᵣ (foldlFin {B = ℝ} {A = A} {n = n} (λ a y → a +ᵣ f y) x V)
+    <ᵣ foldlFin {B = ℝ} {A = A'} {n = n} (λ a y → a +ᵣ f' y) x' V'
+
+foldFin+<-abs zero 0<n x x' f f' V V' x≤x' X = ⊥.rec (ℕ.¬-<-zero 0<n)
+
+foldFin+<-abs (suc zero) 0<n x x' f f' V V' x≤x' X =
+ isTrans≤<ᵣ _ _ _ (absᵣ-triangle _ _) (≤<ᵣMonotone+ᵣ _ _ _ _ x≤x' (X fzero))
+foldFin+<-abs (suc (suc n)) 0<n x x' f f' V V' x₁ X =
+  foldFin+<-abs (suc n) ℕ.zero-<-suc (x +ᵣ f (V fzero)) (x' +ᵣ f' (V' fzero))
+    f f' (V ∘ fsuc) (V' ∘ fsuc)
+     (isTrans≤ᵣ _ _ _ (absᵣ-triangle _ _)
+       (≤ᵣMonotone+ᵣ _ _ _ _ x₁ (<ᵣWeaken≤ᵣ _ _ $ X fzero)))
+       (X ∘ fsuc)
+
+foldFin+≤-abs : ∀ n → ∀ x x' (f : A → ℝ) (f' : A' → ℝ) V V'  →
+   absᵣ x ≤ᵣ x' →
+  (∀ k → absᵣ (f (V k)) ≤ᵣ f' (V' k)) →
+  absᵣ (foldlFin {B = ℝ} {A = A} {n = n} (λ a y → a +ᵣ f y) x V)
+    ≤ᵣ foldlFin {B = ℝ} {A = A'} {n = n} (λ a y → a +ᵣ f' y) x' V'
+
+foldFin+≤-abs zero x x' f f' V V' x≤x' X = x≤x'
+
+foldFin+≤-abs (suc zero) x x' f f' V V' x≤x' X =
+ isTrans≤ᵣ _ _ _ (absᵣ-triangle _ _) (≤ᵣMonotone+ᵣ _ _ _ _ x≤x' (X fzero))
+foldFin+≤-abs (suc (suc n)) x x' f f' V V' x₁ X =
+  foldFin+≤-abs (suc n)  (x +ᵣ f (V fzero)) (x' +ᵣ f' (V' fzero))
+    f f' (V ∘ fsuc) (V' ∘ fsuc)
+     (isTrans≤ᵣ _ _ _ (absᵣ-triangle _ _)
+       (≤ᵣMonotone+ᵣ _ _ _ _ x₁ (X fzero)))
+       (X ∘ fsuc)
+
+
+foldFin+Const : ∀ n x V →
+  foldlFin {B = ℝ} {A = A} {n = n} (λ a y → a +ᵣ x) 0 V
+    ≡ fromNat n ·ᵣ x
+foldFin+Const zero x V = sym (𝐑'.0LeftAnnihilates _)
+foldFin+Const (suc n) x V =
+      (λ i → foldFin+0ᵣ n (V ∘ fsuc) (λ _ → x) (+IdL x i) i)
+   ∙∙ cong₂ (_+ᵣ_) (sym (·IdL x)) (foldFin+Const n x (V ∘ fsuc))
+   ∙∙ (sym (·DistR+ 1 (fromNat n) x)
+      ∙ cong (_·ᵣ x) (+ᵣ-rat _ _  ∙ cong rat (ℚ.ℕ+→ℚ+ 1 n )))
+
+foldlFin-substN : ∀ {n n'} → (p : n ≡ n') → ∀ f b v →
+            foldlFin {B = B} {A = A} {n} f b v ≡
+              foldlFin {B = B} {A = A} {n'} f b (v ∘ substFin (sym p))
+foldlFin-substN {n = n} = J (λ n' p → ∀ f b v →
+            foldlFin f b v ≡
+              foldlFin f b (v ∘ substFin (sym p)))
+               λ f b v → cong (foldlFin {n = n} f b)
+                 (funExt λ x → cong v (sym (transportRefl _)))
+
+
+deltas-sum : ∀ n (f : Fin (suc n) → ℝ) →
+ foldlFin {n = n} (λ a k → a +ᵣ (f (fsuc k) -ᵣ f (finj k))) 0 (idfun _) ≡
+   f flast -ᵣ f fzero
+deltas-sum zero f = sym (𝐑'.+InvR' _ _ (cong f (toℕ-injective refl)))
+deltas-sum (suc n) f =
+ foldFin+0ᵣ n (fsuc) _ _
+  ∙ cong₂ _+ᵣ_
+    (+IdL _)
+    (foldFin+map n 0 _ fsuc (idfun _) ∙
+       (cong (foldlFin {n = n})
+        (funExt₂ (λ s k' →
+            cong ((s +ᵣ_) ∘ (_-ᵣ_ (f (fsuc (fsuc k')))) ∘ f)
+              (toℕ-injective refl)))
+        ≡$ 0 ≡$ (idfun _))
+     ∙ deltas-sum n (f ∘ fsuc))
+  ∙ L𝐑.lem--061 ∙ cong₂ _-ᵣ_ (cong f (toℕ-injective refl)) (cong f (toℕ-injective refl))
+
+
+ℕ^+ : ∀ k n m → k ℕ.^ (n ℕ.+ m) ≡ (k ℕ.^ n) ℕ.· (k ℕ.^ m)
+ℕ^+ k zero m = sym (ℕ.+-zero _)
+ℕ^+ k (suc n) m = cong (k ℕ.·_) (ℕ^+ k n m) ∙ ℕ.·-assoc k _ _
+
+
+2^ : ℕ → ℕ
+2^ zero = 1
+2^ (suc x) = (2^ x) ℕ.+ (2^ x)
+
+2^-^ : ∀ n → 2^ n ≡ 2 ^ n
+2^-^ zero = refl
+2^-^ (suc n) = cong₂ ℕ._+_ (2^-^ n) (2^-^ n)
+ ∙ cong ((2 ^ n) ℕ.+_) (sym (ℕ.+-zero _))
+
+2^+ : ∀ n m → 2^ (n ℕ.+ m) ≡ (2^ n) ℕ.· (2^ m)
+2^+ zero m = sym (ℕ.+-zero (2^ m))
+2^+ (suc n) m = cong₂ ℕ._+_ (2^+ n m) (2^+ n m)
+ ∙ ·-distribʳ (2^ n) _ (2^ m)
+
+injectFin+ : {m n : ℕ} → Fin m → Fin (n ℕ.+ m)
+injectFin+ {n = n} x = (n ℕ.+ fst x) ,  ℕ.<-k+ {k = n} (snd x)
+-- injectFin+ {n = suc n} x = fsuc (injectFin+ x)
+
+
+injectFin+' : {m n : ℕ} → Fin n → Fin (n ℕ.+ m)
+injectFin+' {m} {n = n} x = fst x , ℕ.<≤-trans (snd x) ℕ.≤SumLeft
+
+fsuc∘inj' : {n m : ℕ} → ∀ x → fsuc (injectFin+' {suc m} {n} x) ≡
+                 injectFin+' (fsuc x)
+fsuc∘inj' {n} x = toℕ-injective refl
+
+finj∘inj' : {n m : ℕ} → ∀ x → finj (injectFin+' {m} {n} x) ≡
+            injectFin+' {m} {suc n} (finj x)
+finj∘inj' x = toℕ-injective refl
+
+
+fsuc∘inj : {n m : ℕ} → ∀ x p →
+                 fsuc (injectFin+ {m} {n} x) ≡
+                 (fst (injectFin+ {suc m} {n} (fsuc x))
+                   , p)
+fsuc∘inj x p = toℕ-injective (sym (+-suc _ _))
+
+finj∘inj : {n m : ℕ} → ∀ x p → finj (injectFin+ {m} {n} x) ≡
+            (fst (injectFin+ {suc m} {n} (finj x)) , p)
+finj∘inj x p = toℕ-injective refl
+
+
+
+
+Fin+→⊎ : ∀ n m → Fin (n ℕ.+ m) → (Fin n ⊎ Fin m)
+Fin+→⊎ zero m = inr
+Fin+→⊎ (suc n) m (zero , snd₁) = inl fzero
+Fin+→⊎ (suc n) m (suc k , l , p) =
+ ⊎.map fsuc
+  (idfun _) (Fin+→⊎ n m (k , l ,
+   cong predℕ (sym (ℕ.+-suc l (suc k)) ∙ p)))
+
+
+rec⊎-injectFin+' : ∀ {A : Type} {m} {n} f g x →
+  ⊎.rec {C = A} f g (Fin+→⊎ n m (injectFin+' {m} {n} x))
+                       ≡ f x
+rec⊎-injectFin+' {n = zero} f g x = ⊥.rec (¬Fin0 x)
+rec⊎-injectFin+' {n = suc n} f g (zero , snd₁) = cong f (toℕ-injective refl)
+rec⊎-injectFin+' {m = m} {n = suc n} f g (suc k , l , p) =
+      (cong (λ k → ⊎.rec f g
+      (⊎.map fsuc (λ x → x)
+       (Fin+→⊎ n m k))) (toℕ-injective refl)
+       ∙ (rec-map f g fsuc (idfun _) (Fin+→⊎ n m (injectFin+' k'))))
+    ∙∙ rec⊎-injectFin+' {n = n} (f ∘ fsuc) g k'
+    ∙∙ cong f (toℕ-injective refl)
+ where
+ k' = (k , l , cong predℕ (sym (ℕ.+-suc l (suc k)) ∙ p))
+
+
+Fin+→⊎∘injectFin+' : ∀ n m x → inl x ≡ Fin+→⊎ n m (injectFin+' {m} {n} x)
+Fin+→⊎∘injectFin+' zero m x = ⊥.rec (¬Fin0 x)
+Fin+→⊎∘injectFin+' (suc n) m (zero , _) =
+  cong inl (toℕ-injective refl)
+Fin+→⊎∘injectFin+' (suc n) m (suc k , l , p) =
+  cong inl (toℕ-injective refl) ∙∙ cong (⊎.map fsuc (λ x → x))
+    (Fin+→⊎∘injectFin+' n m (k , l ,
+     injSuc (sym (+-suc l (suc k)) ∙ p)))
+    ∙∙ cong (λ p → ⊎.map fsuc (λ x → x)
+      (Fin+→⊎ n m
+       (k ,
+        l ℕ.+ m , p)))
+         (isSetℕ _ _ _ _)
+
+Fin+→⊎∘injectFin+ : ∀ n m x → inr x ≡ Fin+→⊎ n m (injectFin+ {m} {n} x)
+Fin+→⊎∘injectFin+ zero m x = cong inr (toℕ-injective refl)
+Fin+→⊎∘injectFin+ (suc n) m x =
+  cong (⊎.map fsuc (λ x → x)) (Fin+→⊎∘injectFin+ n m x
+   ∙ cong (Fin+→⊎ n m) (toℕ-injective refl))
+
+rec⊎-injectFin+ : ∀ {A : Type} {m} {n} f g x →
+  ⊎.rec {C = A} f g (Fin+→⊎ n m (injectFin+ {m} {n} x))
+                       ≡ g x
+rec⊎-injectFin+ {n = zero} f g x = cong g (toℕ-injective refl)
+rec⊎-injectFin+ {m = m} {n = suc n} f g x =
+
+  cong (λ k → ⊎.rec f g
+      (⊎.map fsuc (λ x₁ → x₁)
+       (Fin+→⊎ n m k))) (toℕ-injective refl)
+   ∙ (rec-map f g fsuc (idfun _) (Fin+→⊎ n m (injectFin+ x)))
+  ∙ rec⊎-injectFin+ {n = n} (f ∘ fsuc) g x
+
+injectFin+'-flast : ∀ n m k p p' →
+  Fin+→⊎ n m (injectFin+' {m} {n} (k , zero , p)) ≡
+    inl (k , zero , p')
+
+injectFin+'-flast zero m k p p' = ⊥.rec (ℕ.snotz p)
+injectFin+'-flast (suc n) m zero p p' = cong inl (toℕ-injective refl)
+injectFin+'-flast (suc n) m (suc k) p p' =
+  cong (⊎.map fsuc (λ x → x))
+    (cong (Fin+→⊎ n m) (toℕ-injective refl)
+     ∙ injectFin+'-flast n m k (ℕ.injSuc p) (ℕ.injSuc p'))
+   ∙ cong inl (toℕ-injective refl)
+
+
+Iso-Fin+⊎-leftInv : ∀ n m a → ⊎.rec injectFin+' injectFin+ (Fin+→⊎ n m a) ≡ a
+Iso-Fin+⊎-leftInv zero m a = toℕ-injective refl
+Iso-Fin+⊎-leftInv (suc n) m (zero , l , p) = toℕ-injective refl
+Iso-Fin+⊎-leftInv (suc n) m (suc k , l , p) =
+     h
+       (Fin+→⊎ n m
+        (k , l , (λ i → predℕ (((λ i₁ → +-suc l (suc k) (~ i₁)) ∙ p) i))))
+  ∙∙ cong fsuc
+     (Iso-Fin+⊎-leftInv n m (k , l , injSuc (sym (+-suc l (suc k)) ∙ p)))
+  ∙∙ toℕ-injective refl
+ where
+
+ h : ∀ x →
+       ⊎.rec (injectFin+' {m} {suc n}) (injectFin+ {m} {suc n})
+           (⊎.map fsuc (idfun (Fin m)) x)
+       ≡
+       fsuc (⊎.rec injectFin+' injectFin+ x)
+ h (inl x) = toℕ-injective refl
+ h (inr x) = toℕ-injective refl
+
+Iso-Fin+⊎ : ∀ n m → Iso (Fin (n ℕ.+ m)) (Fin n ⊎ Fin m)
+Iso-Fin+⊎ n m .Iso.fun = Fin+→⊎ n m
+Iso-Fin+⊎ n m .Iso.inv = ⊎.rec (injectFin+' {m} {n}) (injectFin+ {m} {n})
+Iso-Fin+⊎ n m .Iso.rightInv (inl x) = sym (Fin+→⊎∘injectFin+' _ _ _)
+Iso-Fin+⊎ n m .Iso.rightInv (inr x) = sym (Fin+→⊎∘injectFin+ _ _ _)
+Iso-Fin+⊎ n m .Iso.leftInv = Iso-Fin+⊎-leftInv n m
+
+injectFin+'-flast≡injectFin+-fzero :
+ ∀ n m →
+  fst (injectFin+' {m} {suc n} flast) ≡
+  fst (injectFin+ {suc m} {n} fzero)
+injectFin+'-flast≡injectFin+-fzero n m = sym (+-zero _)
+
+injectFin+'-flast-S : ∀ n m k p →
+     inr fzero ≡ Fin+→⊎ (suc n) (suc (suc m))
+       (k , suc m , p)
+injectFin+'-flast-S n m zero p =
+  ⊥.rec (ℕ.znots {n}
+   (ℕ.inj-+m {m = suc (suc m)} (cong suc (sym (+-comm m 1)) ∙ p)))
+injectFin+'-flast-S zero m (suc zero) p =
+ cong inr (toℕ-injective refl)
+injectFin+'-flast-S zero m (suc (suc k)) p =
+ ⊥.rec (ℕ.snotz {k} (ℕ.inj-+m {m = suc (suc (suc m))}
+       (cong suc (
+         (ℕ.+-assoc k 3 m ∙
+          cong (ℕ._+ m) (+-comm k 3))
+        ∙ +-comm (suc (suc (suc k))) m) ∙ p)))
+
+injectFin+'-flast-S (suc n) m (suc k) p =
+ cong (⊎.map fsuc (λ x → x)) (injectFin+'-flast-S n m k _)
+
+foldFin·2 : ∀ n m → (f : B → A → B) → (b : B) →
+              (V : Fin (n ℕ.+ m) → A) →
+             foldlFin {n = n ℕ.+ m} f b V ≡
+               foldlFin {n = m} f
+                 (foldlFin {n = n} f b (V ∘ injectFin+'))
+                  (V ∘ injectFin+)
+foldFin·2 zero m f b V =
+ cong (foldlFin {n = m} f b)
+  (funExt λ x → cong V (toℕ-injective refl) )
+foldFin·2 {B = B} {A = A} (suc n) m f b V =
+ foldFin·2 n m f (f b (V fzero)) (V ∘ fsuc)
+  ∙ cong₂ (foldlFin {_} {B} {_} {A} {m} f)
+    (cong₂ (foldlFin {_} {B} {_} {A} {n} f)
+      (cong (f b) (cong V (toℕ-injective refl)))
+        (funExt λ x → cong V (toℕ-injective refl)))
+     (funExt λ x → cong V (toℕ-injective refl))
+
+
+foldFin-sum-concat : ∀ n m → (f : Fin (n ℕ.+ m) → ℝ) →
+     foldlFin (λ a y → a +ᵣ f y) 0 (idfun _)
+      ≡ foldlFin (λ a y → a +ᵣ f (injectFin+' {m} {n} y)) 0 (idfun _)
+      +ᵣ foldlFin (λ a y → a +ᵣ f (injectFin+ {m} {n} y)) 0 (idfun _)
+
+foldFin-sum-concat n m f =
+  foldFin·2 n m (λ a y → a +ᵣ f y) 0 (idfun _)
+   ∙ foldFin+0ᵣ m (idfun _  ∘ injectFin+) f _
+   ∙ cong₂ _+ᵣ_
+     (foldFin+map n _ _ injectFin+' (idfun _))
+     (foldFin+map m _ _ injectFin+ (idfun _))
+
+0<2^ : ∀ n → 0 ℕ.< 2^ n
+0<2^ zero = ℕ.zero-<-suc
+0<2^ (suc n) = ℕ.<-+-< (0<2^ n) (0<2^ n)
+
+
+Fin^2· : ∀ n m → (Fin (2^ n) × Fin (2^ m))
+                      → (Fin (2^ (n ℕ.+ m)))
+Fin^2· n m ((l , l<) , (k , k<)) =
+ (((2^ m) ℕ.· l) ℕ.+ k) ,
+  (2^ m ℕ.· l ℕ.+ k
+      <≤⟨ ℕ.<-k+ {k = 2^ m ℕ.· l} k< ⟩
+     _ ≡≤⟨ (λ i → ℕ.+-comm (ℕ.·-comm (2^ m) l i) (2^ m) i) ⟩
+    _ ≤≡⟨ ℕ.≤-·k {k = 2^ m} l< ⟩
+         sym (2^+ n m))
+
+ where open ℕ.<-Reasoning
+
+Fin^2·-injectFin+' : ∀ n m x y →
+  (injectFin+' (Fin^2· n m (x , y))) ≡
+    (Fin^2· (suc n) m (injectFin+' x , y))
+Fin^2·-injectFin+' n m (fst₁ , snd₁) y = toℕ-injective refl
+
+Fin^2·-injectFin+ : ∀ n m x y → (injectFin+ (Fin^2· n m (x , y)))
+    ≡ (Fin^2· (suc n) m (injectFin+ x , y))
+Fin^2·-injectFin+ n m x y =
+ toℕ-injective
+  (cong (ℕ._+ (2^ m ℕ.· x .fst ℕ.+ y .fst)) (2^+ n m ∙ ℕ.·-comm (2^ n) (2^ m) )
+    ∙ (ℕ.+-assoc (2^ m ℕ.· 2^ n) _ (fst y) ∙
+      cong (ℕ._+ fst y) (·-distribˡ (2^ m) _ _)))
+
+foldFin·2^ : ∀ n m → (f : B → A → B) → (b : B) →
+              (V : Fin (2^ (n ℕ.+ m)) → A) →
+             foldlFin f b V ≡
+               foldlFin {n = 2^ n} (foldlFin {n = 2^ m} f)
+                 b (curry (V ∘ Fin^2· n m ))
+foldFin·2^ zero m f b V = cong (foldlFin {n = 2^ m} f b)
+  (funExt λ x → cong V (toℕ-injective
+    (cong (ℕ._+ fst x) (ℕ.0≡m·0 (2^ m)))))
+foldFin·2^ (suc n) m f b V =
+  foldFin·2 (2^ (n ℕ.+ m)) (2^ (n ℕ.+ m)) f b V
+   ∙ foldFin·2^ n m _ _ _
+    ∙ cong {x = (foldlFin {n = 2^ (n ℕ.+ m)}
+            f b (V ∘ injectFin+'))} (λ z → foldlFin (foldlFin f) z
+         (curry ((V ∘ injectFin+) ∘ Fin^2· n m)))
+         (foldFin·2^ n m _ _ _)
+
+    ∙ (λ i → foldlFin {n = 2^ n} ff'
+       (foldlFin {n = 2^ n} ff' b
+        (λ x y → V (Fin^2·-injectFin+' n m x y i)))
+       (λ x y → V (Fin^2·-injectFin+ n m x y i))) ∙
+      sym (foldFin·2 (2^ n) (2^ n) ff' _ _)
+ where
+ ff' = (foldlFin {n = 2^ m} f)
+
+
+record ElimFinSS (A : Type) (n : ℕ) : Type where
+ no-eta-equality
+ field
+  a₀ : A
+  f : Fin (suc n) → A
+  aₙ : A
+
+ go : Fin (3 ℕ.+ n) → A
+ go (zero , l , p) = a₀
+ go (suc k , zero , p) = aₙ
+ go (suc k , suc l , p) =
+   f (k , l , cong (predℕ ∘ predℕ) (sym (ℕ.+-suc (suc l) (suc k)) ∙ p))
+
+record Partition[_,_] (a b : ℝ) : Type₀ where
+ field
+  len : ℕ
+  pts : Fin (1 ℕ.+ len) → ℝ
+  a≤pts : ∀ k → a ≤ᵣ pts k
+  pts≤b : ∀ k → pts k ≤ᵣ b
+  pts≤pts : (k : Fin len) → pts (finj k) ≤ᵣ pts (fsuc k)
+
+ diffs : Fin len → Σ ℝ (0 ≤ᵣ_)
+ diffs k = _ , x≤y→0≤y-x (pts (finj k)) _ (pts≤pts k)
+
+ mesh : ℝ
+ mesh = foldlFin maxᵣ 0 (fst ∘ diffs)
+
+ a≤b : a ≤ᵣ b
+ a≤b = isTrans≤ᵣ a _ _ (a≤pts fzero) (pts≤b fzero)
+
+ pts'Σ-R : ElimFinSS (Σ-syntax ℝ (λ p → (a ≤ᵣ p) × (p ≤ᵣ b))) len
+ pts'Σ-R .ElimFinSS.a₀ = a , ≤ᵣ-refl a , a≤b
+ pts'Σ-R .ElimFinSS.f k = pts k , a≤pts _ , pts≤b _
+ pts'Σ-R .ElimFinSS.aₙ = b , a≤b , ≤ᵣ-refl b
+
+ pts'Σ : Fin (3 ℕ.+ len) → Σ[ p ∈ ℝ ] (a ≤ᵣ p) × (p ≤ᵣ b)
+ pts'Σ = ElimFinSS.go pts'Σ-R
+
+ pts' : Fin (3 ℕ.+ len) → ℝ
+ pts' = fst ∘ pts'Σ
+
+ a≤pts' : ∀ k → a ≤ᵣ pts' k
+ a≤pts' = fst ∘ snd ∘ pts'Σ
+
+ pts'≤b : ∀ k → pts' k ≤ᵣ b
+ pts'≤b = snd ∘ snd ∘ pts'Σ
+
+ pts'≤pts' : ∀ k → pts' (finj k) ≤ᵣ pts' (fsuc k)
+ pts'≤pts' (zero , l , p) = a≤pts' (1 , l , +-suc _ _ ∙ cong suc p)
+ pts'≤pts' k'@(suc k , zero , p) =
+  let z = pts'≤b (suc k , 1 , cong suc p)
+  in isTrans≡≤ᵣ (pts' (finj k'))
+        (pts' (suc k , 1 , (λ i → suc (p i))))
+        _ (cong {x = finj k'}
+                {(suc k , 1 , cong suc p)} pts'
+                 (toℕ-injective refl)) z
+ pts'≤pts' (suc k , suc l , p) =
+   let k' = k , l , cong (predℕ ∘ predℕ)
+               (sym (ℕ.+-suc (suc l) (suc k)) ∙ p)
+   in subst2 _≤ᵣ_
+         (cong (λ u → pts (k , l ℕ.+ (suc zero) , u))
+           (isSetℕ _ _ _ _))
+         (cong (λ u → pts (suc k , l , u))
+           (isSetℕ _ _ _ _))
+         (pts≤pts k')
+
+ isStrictPartition : Type
+ isStrictPartition = ∀ k → pts' (finj k) <ᵣ pts' (fsuc k)
+
+ mesh≤ᵣ : ℝ → Type
+ mesh≤ᵣ δ = ∀ k →  pts' (fsuc k) -ᵣ pts' (finj k)  ≤ᵣ δ
+
+ record Sample : Type₀ where
+  field
+   samples : Fin (2 ℕ.+ len) → ℝ
+   pts'≤samples : (k : Fin _) → pts' (finj k) ≤ᵣ samples k
+   samples≤pts' : (k : Fin _) → samples k ≤ᵣ pts' (fsuc k)
+
+
+  a≤samples : ∀ k → a  ≤ᵣ samples k
+  a≤samples k = isTrans≤ᵣ a _ _ (a≤pts' (finj k)) (pts'≤samples k)
+
+  samples≤b : ∀ k → samples k ≤ᵣ b
+  samples≤b k = isTrans≤ᵣ (samples k) _ b (samples≤pts' k) (pts'≤b (fsuc k))
+
+  samplesΣ : Fin (2 ℕ.+ len) → Σ[ t ∈ ℝ ] (a ≤ᵣ t ) × (t ≤ᵣ b)
+  samplesΣ k = samples k , a≤samples k , samples≤b k
+
+  riemannSum : (∀ r → a ≤ᵣ r → r ≤ᵣ b → ℝ) → ℝ
+  riemannSum f = foldlFin
+    (λ S ((t , a≤t , t≤b) , b-a) → S +ᵣ b-a ·ᵣ (f t a≤t t≤b) ) 0
+     (λ k →  samplesΣ k , pts' (fsuc k) -ᵣ pts' (finj k))
+
+  riemannSum' : (ℝ → ℝ) → ℝ
+  riemannSum' f = foldlFin {n = 2 ℕ.+ len}
+    (λ S ((t , a≤t , t≤b) , b-a) → S +ᵣ b-a ·ᵣ (f t) ) 0
+     (λ k →  samplesΣ k , pts' (fsuc k) -ᵣ pts' (finj k))
+
+
+  riemannSum'+ : (f g : ℝ → ℝ) →
+    riemannSum' f +ᵣ riemannSum' g
+      ≡ riemannSum' (λ x → f x +ᵣ g x)
+  riemannSum'+ f g = zip-foldFin+ᵣ' (2 ℕ.+ len)
+    (λ k →  samplesΣ k , pts' (fsuc k) -ᵣ pts' (finj k))
+    _ _ 0 0
+   ∙ (cong₂ foldlFin (funExt₂
+    λ S y → cong (S +ᵣ_) (sym (·DistL+ _ _ _)))
+   (+ᵣ-rat 0 0)
+    ≡$ (λ k →  samplesΣ k , pts' (fsuc k) -ᵣ pts' (finj k)))
+
+  riemannSum'≤ : (f g : ℝ → ℝ) →
+    (∀ r → a ≤ᵣ r → r ≤ᵣ b → f r ≤ᵣ g r) →
+    riemannSum' f ≤ᵣ riemannSum' g
+
+  riemannSum'≤ f g f≤g =
+     foldFin+≤ (2 ℕ.+ len) _ _ _  _
+       (λ k →  samplesΣ k , pts' (fsuc k) -ᵣ pts' (finj k))
+       (λ k →  samplesΣ k , pts' (fsuc k) -ᵣ pts' (finj k))
+       (≤ᵣ-refl 0) λ x → ≤ᵣ-o·ᵣ _ _ _ (x≤y→0≤y-x _ _ (pts'≤pts' x))
+         (f≤g _ (a≤samples x) (samples≤b x))
+
+  riemannSum'C· : ∀ C (f : ℝ → ℝ) →
+    riemannSum' (λ x → C ·ᵣ f x)
+     ≡ C ·ᵣ riemannSum' f
+
+  riemannSum'C· C f =
+    (cong foldlFin (funExt₂
+    λ S y → cong (S +ᵣ_)
+      (·ᵣAssoc _ _ _ ∙∙ cong (_·ᵣ f (y .fst .fst)) (·ᵣComm _ _)
+       ∙∙ sym (·ᵣAssoc _ _ _)))
+    ≡$ 0
+    ≡$ (λ k →  samplesΣ k , pts' (fsuc k) -ᵣ pts' (finj k)))
+    ∙ foldFin·DistL' (2 ℕ.+ len) _ _
+    (λ k →  samplesΣ k , pts' (fsuc k) -ᵣ pts' (finj k))
+
+
+
+  riemannSum'-alt : (ℝ → ℝ) → ℝ
+  riemannSum'-alt f = foldlFin {n = 2 ℕ.+ len}
+    (λ S k →
+     S +ᵣ (pts' (fsuc k) -ᵣ pts' (finj k)) ·ᵣ (f (fst (samplesΣ k))) ) 0
+     (idfun _)
+
+  riemannSum'-alt-lem : ∀ f → riemannSum' f ≡ riemannSum'-alt f
+  riemannSum'-alt-lem f =
+   foldFin+map (2 ℕ.+ len) 0 _
+    (λ k →  samplesΣ k , pts' (fsuc k) -ᵣ pts' (finj k))
+    (idfun _)
+
+
+  riemannSum'-absᵣ≤ : (f : ℝ → ℝ) →
+    absᵣ (riemannSum' f) ≤ᵣ riemannSum' (absᵣ ∘ f)
+  riemannSum'-absᵣ≤ f =
+    subst2 _≤ᵣ_
+      (cong absᵣ (sym (riemannSum'-alt-lem f)))
+      (sym (riemannSum'-alt-lem (absᵣ ∘ f)))
+      (foldFin+≤-abs (2 ℕ.+ len) 0 0 _ _
+        (idfun _) (idfun _)
+        (isTrans≡≤ᵣ _ _ _ absᵣ0 (≤ᵣ-refl 0))
+        λ k →
+          ≡ᵣWeaken≤ᵣ _ _
+            (·absᵣ _ _
+           ∙ cong₂ _·ᵣ_
+             (absᵣNonNeg _ (x≤y→0≤y-x _ _ (pts'≤pts' k)))
+             refl))
+
+
+
+  riemannSum'Const : ∀ C → riemannSum' (const C) ≡ C ·ᵣ (b -ᵣ a)
+  riemannSum'Const C = riemannSum'-alt-lem (const C)
+   ∙ (λ i → foldlFin {n = 2 ℕ.+ len}
+    (λ S k →
+     S +ᵣ ·ᵣComm (pts' (fsuc k) -ᵣ pts' (finj k)) C i ) 0
+     (idfun _))
+   ∙ foldFin·DistL' (2 ℕ.+ len) _ C (idfun _)
+   ∙ cong (C ·ᵣ_) (deltas-sum (2 ℕ.+ len) pts')
+
+
+ open Sample public
+
+ leftSample : Sample
+ leftSample .samples = pts' ∘ finj
+ leftSample .pts'≤samples = ≤ᵣ-refl ∘ pts' ∘ finj
+ leftSample .samples≤pts' = pts'≤pts'
+
+ rightSample : Sample
+ rightSample .samples = pts' ∘ fsuc
+ rightSample .pts'≤samples = pts'≤pts'
+ rightSample .samples≤pts' = ≤ᵣ-refl ∘ pts' ∘ fsuc
+
+
+-- clampDeltaᵣ : ∀ L L' x → clampᵣ L L' x ≡
+--                (x +ᵣ clampᵣ (L -ᵣ x) (L' -ᵣ x) 0)
+-- clampDeltaᵣ L L' x = {!!}
+
+
+-- clampDeltaSplitℚ : ∀ L L' x y → L ℚ.≤ L' → x ℚ.≤ y
+--             → (y ℚ.- x) ≡
+--               (ℚ.min L y ℚ.- ℚ.min L x)
+--                ℚ.+ (ℚ.clamp L L' y ℚ.- ℚ.clamp L L' x)
+--                ℚ.+ (ℚ.max L' y ℚ.- ℚ.max L' x)
+-- clampDeltaSplitℚ = {!!}
+
+open Partition[_,_] public hiding (a≤b)
+
+TaggedPartition[_,_] : ℝ → ℝ → Type
+TaggedPartition[ a , b ] = Σ (Partition[ a , b ]) Sample
+
+
+
+
+on[_,_]IntegralOf_is_ : ∀ a b → (∀ r → a ≤ᵣ r → r ≤ᵣ b → ℝ) → ℝ → Type
+
+on[ a , b ]IntegralOf f is s =
+   ∀ (ε : ℚ₊) → ∃[ δ ∈ ℚ₊ ]
+     ∀ ((p , t) : TaggedPartition[ a , b ]) →
+     (mesh≤ᵣ p (rat (fst δ)) →
+       absᵣ (riemannSum t f -ᵣ s) <ᵣ rat (fst ε))
+
+on[_,_]IntegralOf_is'_ : ∀ a b → (ℝ → ℝ) → ℝ → Type
+on[ a , b ]IntegralOf f is' s =
+   ∀ (ε : ℚ₊) → ∃[ δ ∈ ℚ₊ ]
+     ∀ ((p , t) : TaggedPartition[ a , b ]) →
+     (mesh≤ᵣ p (rat (fst δ)) →
+       absᵣ (riemannSum' t f -ᵣ s) <ᵣ rat (fst ε))
+
+
+0≤pos/ : ∀ {p q} → 0 ℚ.≤ [ pos p / q ]
+0≤pos/ {p} {q} =
+  subst (0 ℤ.≤_) (sym (ℤ.·IdR _))
+    (ℤ.ℕ≤→pos-≤-pos 0 p ℕ.zero-≤)
+
+
+module Integration a b (a≤b : a ≤ᵣ b) where
+
+ Δ : ℝ
+ Δ = b -ᵣ a
+
+ 0≤Δ : 0 ≤ᵣ Δ
+ 0≤Δ = x≤y→0≤y-x a _ a≤b
+
+
+ -- uContMesh : ∀ f → IsUContinuous f →
+ --        ∀ (ε₊ : ℚ₊) → ∃[ δ ∈ ℚ₊ ]
+ --                  (∀ ((p , t) : TaggedPartition[ a , b ]) →
+ --                     (mesh p <ᵣ rat (fst δ) →
+ --                       absᵣ (riemannSum' t f -ᵣ
+ --                             riemannSum' (leftSample p) f)
+ --                          <ᵣ Δ ·ᵣ rat (fst ε₊)))
+ -- uContMesh d iucf ε₊ = {!!}
+
+ module _ (n : ℕ) where
+
+  t : ℕ → ℚ
+  t k = [ pos (suc k) / 2+ n  ]
+
+  0≤t : ∀ k → 0 ≤ᵣ rat (t k)
+  0≤t k = ≤ℚ→≤ᵣ 0 (t k) (0≤pos/ {suc k} {2+ n})
+
+  t≤1 : ∀ (k : Fin (1 ℕ.+ n)) → rat (t (fst k)) ≤ᵣ 1
+  t≤1 k = ≤ℚ→≤ᵣ (t (fst k)) 1 w
+   where
+   w : pos (suc (k .fst)) ℤ.· ℚ.ℕ₊₁→ℤ 1 ℤ.≤ pos 1 ℤ.· ℚ.ℕ₊₁→ℤ (2+ n)
+   w = subst2 ℤ._≤_ (sym (ℤ.·IdR _)) (sym (ℤ.·IdL _))
+          (ℤ.ℕ≤→pos-≤-pos (suc (fst k))
+           _ (ℕ.suc-≤-suc $ ℕ.≤-suc $ ℕ.predℕ-≤-predℕ (snd k)))
+
+  tIncr : ∀ k → t k ℚ.≤ t (suc k)
+  tIncr k = ℤ.≤-·o {m = pos (suc k)} {n = pos (suc (suc k))} {k = suc (suc n)}
+            (ℤ.ℕ≤→pos-≤-pos _ _ ℕ.≤-sucℕ)
+
+  equalPartition : Partition[ a , b ]
+  equalPartition .len = n
+  equalPartition .pts k = a +ᵣ Δ ·ᵣ (rat (t (fst k)))
+  equalPartition .a≤pts k =
+    isTrans≡≤ᵣ a (a +ᵣ Δ ·ᵣ 0) _
+      (sym (𝐑'.+IdR' _ _ (𝐑'.0RightAnnihilates _)))
+       (≤ᵣ-o+ (Δ ·ᵣ 0) (Δ ·ᵣ (rat (t (fst k)))) a
+         (≤ᵣ-o·ᵣ 0 (rat (t (fst k))) Δ  0≤Δ (0≤t (fst k))))
+  equalPartition .pts≤b k =
+    isTrans≤≡ᵣ (a +ᵣ Δ ·ᵣ rat (t (fst k))) (a +ᵣ Δ) b
+    (≤ᵣ-o+ _ _ a
+     (isTrans≤≡ᵣ (Δ ·ᵣ rat (t (fst k))) (Δ ·ᵣ 1) Δ
+      (≤ᵣ-o·ᵣ (rat (t (fst k))) 1 Δ  0≤Δ (t≤1 k)) (·IdR Δ)))
+      (L𝐑.lem--05 {a} {b})
+  equalPartition .pts≤pts k =
+     ≤ᵣ-o+ _ _ a (≤ᵣ-o·ᵣ (rat (t ( (fst k)))) (rat (t (suc (fst k)))) Δ  0≤Δ
+      (≤ℚ→≤ᵣ (t (fst k)) _ (tIncr (fst k))))
+
+
+  equalPartitionPts' : ∀ k → pts' equalPartition k ≡
+        a +ᵣ Δ ·ᵣ rat [ pos (fst k) / 2+ n  ]
+  equalPartitionPts' (zero , zero , p) = ⊥.rec (ℕ.znots (cong predℕ p))
+  equalPartitionPts' (zero , suc l , p) =
+   sym (𝐑'.+IdR' _ _ (𝐑'.0RightAnnihilates' _ _ (cong rat (ℚ.[0/n]≡[0/m] _ _))))
+  equalPartitionPts' (suc k , zero , p) =
+    sym (L𝐑.lem--05 {a} {b}) ∙
+      cong (a +ᵣ_) (sym (𝐑'.·IdR' _ _ (cong (rat ∘ [_/ 2+ n ])
+       (cong (pos ∘ predℕ) p)
+       ∙ (cong rat $ ℚ.[n/n]≡[m/m] (suc n) 0))))
+  equalPartitionPts' (suc k , suc l , p) = refl
+
+  equalPartitionΔ : ∀ k →
+    pts' equalPartition (fsuc k) -ᵣ pts' equalPartition (finj k)
+    ≡ Δ ·ᵣ rat [ 1 / 2+ n ]
+  equalPartitionΔ (zero , zero , snd₁) = ⊥.rec (ℕ.znots (cong predℕ snd₁))
+  equalPartitionΔ (zero , suc fst₂ , snd₁) =
+   L𝐑.lem--063 {a}
+  equalPartitionΔ (suc fst₁ , zero , snd₁) =
+    L𝐑.lem--089 {b} {a} {Δ ·ᵣ rat [ pos (suc fst₁) / 2+ n ]}
+     ∙ cong₂ (_-ᵣ_)
+       (sym (·IdR Δ)) (cong (Δ ·ᵣ_) (cong (rat ∘ [_/ 2+ n ])
+         (cong (pos ∘ predℕ) snd₁)))
+       ∙ sym (𝐑'.·DistR- _ _ _) ∙
+        cong (Δ ·ᵣ_)
+         (cong₂ {x = 1}
+          {rat [ pos (suc (suc n)) / 2+ n ]}
+          _-ᵣ_ (cong rat (ℚ.[n/n]≡[m/m] 0 (suc n)))
+          {rat [ pos (suc n) / 2+ n ]}
+          {rat [ pos (suc n) / 2+ n ]}
+          refl
+          ∙ -ᵣ-rat₂ [ (pos (suc (suc n))) / 2+ n ] [ pos (suc n) / 2+ n ]
+           ∙ cong rat
+               (ℚ.n/k-m/k (pos (suc (suc n))) (pos (suc n)) (2+ n) ∙
+                  cong [_/ 2+ n ] (cong (ℤ._- pos (suc n))
+                      (ℤ.pos+ 1 (suc n)) ∙ ℤ.plusMinus (pos (suc n)) 1)))
+
+  equalPartitionΔ (suc k , suc l , p) =
+   L𝐑.lem--088 {a} ∙
+       sym (𝐑'.·DistR- _ _ _) ∙
+         cong (Δ ·ᵣ_) zz
+    where
+    zz : rat (t (suc k)) -ᵣ rat (t k) ≡ rat [ 1 / 2+ n ]
+    zz = cong₂ {x = rat (t (suc k))}
+          {rat [ pos (suc (suc k)) / 2+ n ]}
+          _-ᵣ_ refl {rat (t k)} {rat [ pos (suc k) / (2+ n) ]}
+           refl  ∙ -ᵣ-rat₂
+          ([ pos (suc (suc k)) / 2+ n ]) ([ pos (suc k) / 2+ n ]) ∙
+           cong
+             {x = [ pos (suc (suc k)) / 2+ n ] ℚ.- [ pos (suc k) / 2+ n ]}
+             {y = [ 1 / 2+ n ]}
+             rat (ℚ.n/k-m/k (pos (suc (suc k))) (pos (suc k)) (2+ n)  ∙
+                cong [_/ 2+ n ] (cong (ℤ._- pos (suc k)) (ℤ.pos+ 1 (suc k))
+
+                 ∙ ℤ.plusMinus (pos (suc k)) 1))
+
+ isStrictEqualPartition : a <ᵣ b → ∀ n → isStrictPartition (equalPartition n)
+ isStrictEqualPartition a<b n k =
+   subst2 _<ᵣ_
+     (sym (equalPartitionPts' n (finj k)))
+     (sym (equalPartitionPts' n (fsuc k)))
+     (<ᵣ-o+ _ _ a
+       (<ᵣ-o·ᵣ _ _
+         (Δ , x<y→0<y-x _ _ a<b)
+         (<ℚ→<ᵣ _ _ ((ℚ.[k/n]<[k'/n]
+          (pos (fst k)) (pos (suc (fst k))) (2+ n)
+            ℤ.isRefl≤)))))
+
+ equalPartition-2ⁿ : ℕ → Partition[ a , b ]
+ equalPartition-2ⁿ n = equalPartition (predℕ (predℕ (2^ (suc n))))
+
+ equalPartition-mesh : ∀ n →
+  mesh≤ᵣ (equalPartition n)
+   ((b -ᵣ a) ·ᵣ (rat [ 1 / 2+ n  ]) )
+ equalPartition-mesh n k = ≡ᵣWeaken≤ᵣ _ _
+  (equalPartitionΔ n k)
+
+∃Partition< : ∀ a b → a ≤ᵣ b → ∀ (ε : ℚ₊) →
+  ∃[ (p , tg) ∈ TaggedPartition[ a , b ] ] mesh≤ᵣ p (rat (fst ε))
+∃Partition< a b a≤b ε =
+  PT.map
+    (λ (x' , b-a<x' , _) →
+      let x'₊ = (x' , ℚ.<→0< x'
+                (<ᵣ→<ℚ 0 x' (isTrans≤<ᵣ 0 (b -ᵣ a) (rat x')
+                  (x≤y→0≤y-x a b a≤b) b-a<x')))
+          (N , _) , (p , (u , _)) = ℚ.ceil-[1-frac]ℚ₊ (invℚ₊ ε ℚ₊· x'₊)
+          ww : fst (x'₊ ℚ₊· invℚ₊ ε) ℚ.≤ fromNat (suc (suc N))
+          ww = ℚ.isTrans≤ (fst (x'₊ ℚ₊· invℚ₊ ε)) (fromNat N)
+                (fromNat (suc (suc N)))
+              (subst2 (ℚ._≤_) (ℚ.+IdR (fst (invℚ₊ ε ℚ₊· x'₊))
+             ∙ ℚ.·Comm (fst (invℚ₊ ε)) x') p
+               (ℚ.≤-o+ _ _ (fst (invℚ₊ ε ℚ₊· x'₊)) u))
+                ((ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos N (suc (suc N))
+                 (ℕ.≤-trans ℕ.≤-sucℕ ℕ.≤-sucℕ))))
+
+      in (_ , leftSample (∫ab.equalPartition N)) ,
+          λ k → isTrans≤ᵣ _ _ _ (∫ab.equalPartition-mesh N k)
+            (isTrans≤ᵣ _ _ _
+              (isTrans≤≡ᵣ _ _ _ (≤ᵣ-·ᵣo _ _ _ (≤ℚ→≤ᵣ _ _ (ℚ.0≤pos 1 (2+ N)))
+                (<ᵣWeaken≤ᵣ _ _ b-a<x'))
+                (sym (rat·ᵣrat x' _)))
+              (≤ℚ→≤ᵣ _ _ (ℚ.x≤y·z→x·invℚ₊y≤z x' (fst ε) (fromNat (suc (suc N)))
+               (subst (x' ℚ.≤_) (ℚ.·Comm (fst ε) _)
+              (ℚ.x·invℚ₊y≤z→x≤y·z x' (fromNat (suc (suc N))) ε
+              ww)))))
+      )
+    (denseℚinℝ (b -ᵣ a) ((b -ᵣ a) +ᵣ 1)
+       (isTrans≡<ᵣ _ _ _
+         (sym (+IdR _)) (<ᵣ-o+ 0 1 (b -ᵣ a) decℚ<ᵣ?)))
+ where
+ module ∫ab = Integration a b a≤b
+
+Integral'Uniq : ∀ a b → (a ≤ᵣ b) → ∀ f s s'
+  → on[ a , b ]IntegralOf f is' s
+  → on[ a , b ]IntegralOf f is' s'
+  → s ≡ s'
+Integral'Uniq a b a≤b f s s' S S' =
+   eqℝ _ _
+    λ ε →
+      PT.rec2 (isProp∼ _ _ _ )
+       (λ (δ , X) (δ' , X') →
+         let δ⊔δ' = ℚ.min₊ δ δ'
+         in PT.rec (isProp∼ _ _ _)
+             (λ (TP , TP<) → subst∼ (ℚ.ε/2+ε/2≡ε (fst ε))
+              (triangle∼ {ε = /2₊ ε} {/2₊ ε}
+                (sym∼ _ _ _ (invEq (∼≃abs<ε _ _ _)
+                 (X TP λ k → isTrans≤ᵣ _ _ _ (TP< k)
+                  (≤ℚ→≤ᵣ _ _ (ℚ.min≤ (fst δ) (fst δ'))))))
+                (invEq (∼≃abs<ε _ _ _)
+                  (X' TP λ k → isTrans≤ᵣ _ _ _ (TP< k)
+                   (≤ℚ→≤ᵣ _ _ (ℚ.min≤' (fst δ) (fst δ')))))))
+                (∃Partition< a b a≤b δ⊔δ'))
+       (S (/2₊ ε)) (S' (/2₊ ε))
+
+
+IntegratedProp : ∀ a b → a ≤ᵣ b → ∀ f → isProp (Σ _ on[ a , b ]IntegralOf f is'_)
+IntegratedProp a b a≤b f (s , S) (s' , S')  =
+  Σ≡Prop (λ _ → isPropΠ λ _ → squash₁ )
+   (Integral'Uniq a b a≤b f s s' S S')
+
+
+module Partition-pre+ (a b : ℝ) (α : ℝ) where
+ partition-pre+ :
+    ( (TaggedPartition[ a , b ]))
+    → ((TaggedPartition[ a +ᵣ α , b +ᵣ α ]))
+ partition-pre+  x .fst .len = x .fst .len
+ partition-pre+  x .fst .pts = (_+ᵣ α) ∘ x .fst .pts
+ partition-pre+  x .fst .a≤pts =
+   ≤ᵣ-+o _ _ _ ∘ x .fst .a≤pts
+ partition-pre+  x  .fst .pts≤b =
+    ≤ᵣ-+o _ _ _ ∘ x .fst .pts≤b
+ partition-pre+  x  .fst .pts≤pts =
+     ≤ᵣ-+o _ _ _ ∘ x .fst .pts≤pts
+ partition-pre+  x  .snd .samples =
+  (_+ᵣ α) ∘  x  .snd .samples
+ partition-pre+  x .snd .pts'≤samples =
+   λ { k@(0 , _ , _) → ≤ᵣ-+o _ _ _ (x .snd .pts'≤samples k)
+     ; k@(suc _ , 0 , _) → ≤ᵣ-+o _ _ _ (x  .snd .pts'≤samples k)
+     ; k@(suc _ , suc _ , _) → ≤ᵣ-+o _ _ _ (x .snd .pts'≤samples k)
+      }
+
+
+ partition-pre+  x .snd .samples≤pts' =
+   λ { k@(0 , 0 , _) → ≤ᵣ-+o _ _ _ (x .snd .samples≤pts' k)
+     ; k@(0 , suc _ , _) → ≤ᵣ-+o _ _ _ (x .snd .samples≤pts' k)
+     ; k@(suc _ , 0 , _) → ≤ᵣ-+o _ _ _ (x .snd .samples≤pts' k)
+     ; k@(suc _ , suc _ , _) → ≤ᵣ-+o _ _ _ (x .snd .samples≤pts' k)
+      }
+
+ partition-pre+-lem : ∀ tp k →
+      pts' (fst (partition-pre+ tp)) (fsuc k) -ᵣ
+      pts' (fst (partition-pre+ tp)) (finj k)
+      ≡
+      (pts' (fst tp) (fsuc k)) -ᵣ (pts' (fst tp) (finj k))
+ partition-pre+-lem tp (0 , 0 , _) = L𝐑.lem--075
+ partition-pre+-lem tp (0 , suc _ , _) = L𝐑.lem--075
+ partition-pre+-lem tp (suc _ , 0 , _) = L𝐑.lem--075
+ partition-pre+-lem tp (suc _ , suc _ , _) = L𝐑.lem--075
+
+ mesh-pre+ : ∀ δ → (tp : TaggedPartition[ a , b ]) →
+             mesh≤ᵣ (fst tp) δ
+            → mesh≤ᵣ (fst (partition-pre+ tp)) δ
+ mesh-pre+ δ tp x k =
+   isTrans≡≤ᵣ _ _ _ (partition-pre+-lem tp k) (x k)
+
+
+pts'-tranp : ∀ {a a' b b'} → (p : a ≡ a') (p' : b ≡ b') →
+ ((pa , tg) : TaggedPartition[ a , b ]) →
+ ∀ k k' → fst k ≡ fst k' →
+ pts' pa k ≡ pts' (fst (subst2 TaggedPartition[_,_] p p' (pa , tg))) k'
+pts'-tranp {a} {a'} {b} {b'} p p' =
+ J2 (λ a' p b' p' →
+              ((pa , tg) : TaggedPartition[ a , b ]) →
+            ∀ k k' → fst k ≡ fst k' →
+            pts' pa k ≡
+            pts' (fst (subst2 TaggedPartition[_,_] p p' (pa , tg))) k' )
+         (λ (pa , tg) k k' pp i →
+           fst (pts'Σ (transportRefl pa (~ i))
+             (toℕ-injective {suc (suc (suc (len pa)))}
+               {k} {k'} pp i)))
+           {a'} p {b'} p'
+
+integral'-transl : ∀ a b Δ f s
+         → (on[ a  , b ]IntegralOf (f ∘S (Δ +ᵣ_)) is' s)
+         → (on[ a +ᵣ Δ  , b +ᵣ Δ  ]IntegralOf f is' s)
+integral'-transl a b Δ f s X ε =
+  PT.map
+    (map-snd (λ {δ} Y (p , tp) m≤ →
+      isTrans≡<ᵣ _ _ _
+       (cong (λ rs → absᵣ (rs -ᵣ s))
+        (riemannSum'-alt-lem tp f ∙∙
+          cong (λ (gg : Fin (suc (suc (len p))) → ℝ) → foldlFin
+              (λ S k →
+               S +ᵣ gg k ) 0
+               (idfun _))
+            (funExt
+             (λ x → cong₂ _·ᵣ_
+                (sym (Partition-pre+.partition-pre+-lem
+                  (a +ᵣ Δ) (b +ᵣ Δ) (-ᵣ Δ) (p , tp) x) ∙
+                   cong₂ _-ᵣ_
+                    (pts'-tranp ((𝐑'.plusMinus a Δ)) ((𝐑'.plusMinus b Δ))
+                      (Partition-pre+.partition-pre+
+                     (a +ᵣ Δ) (b +ᵣ Δ) (-ᵣ Δ) (p , tp))
+                     (fsuc x) (fsuc x) refl)
+                    ((pts'-tranp ((𝐑'.plusMinus a Δ)) ((𝐑'.plusMinus b Δ))
+                      (Partition-pre+.partition-pre+
+                     (a +ᵣ Δ) (b +ᵣ Δ) (-ᵣ Δ) (p , tp))
+                     (finj x) (finj x) refl)) )
+               (cong f ((sym (𝐑'.minusPlus _ Δ)
+                 ∙ cong ((_+ᵣ Δ) ∘ (_+ᵣ (-ᵣ Δ)))
+                  (cong (samples tp) (toℕ-injective refl))) ∙ +ᵣComm _ _ ))))
+         ∙∙ sym (riemannSum'-alt-lem
+           (fst
+             (subst2
+              (λ a' b' →
+                 Σ TaggedPartition[ a' , b' ]
+                 (λ pp → mesh≤ᵣ (fst pp) (rat (fst δ))))
+              (𝐑'.plusMinus a Δ) (𝐑'.plusMinus b Δ)
+              (Partition-pre+.partition-pre+ (a +ᵣ Δ) (b +ᵣ Δ) (-ᵣ Δ)
+               _
+               ,
+               Partition-pre+.mesh-pre+ (a +ᵣ Δ) (b +ᵣ Δ) (-ᵣ Δ) (rat (fst δ))
+               (p , tp) m≤))
+             .snd) (f ∘S _+ᵣ_ Δ))))
+        (uncurry Y
+         (subst2 (λ a' b' →
+          Σ (TaggedPartition[ a' , b' ]) (λ (xx , _) →
+            mesh≤ᵣ xx (rat (fst δ)) ) )
+            (𝐑'.plusMinus a Δ) (𝐑'.plusMinus b Δ)
+         (Partition-pre+.partition-pre+
+          (a +ᵣ Δ) (b +ᵣ Δ) (-ᵣ Δ) (p , tp) ,
+           Partition-pre+.mesh-pre+
+          (a +ᵣ Δ) (b +ᵣ Δ) (-ᵣ Δ) (rat (fst δ)) (p , tp) m≤)))))
+    (X ε)
+
+
+
+module Partition-pre· (a b : ℝ) (α : ℝ) (0≤α : 0 ≤ᵣ α) where
+ partition-pre· :
+    ( (TaggedPartition[ a , b ]))
+    → ((TaggedPartition[ a ·ᵣ α , b ·ᵣ α ]))
+ partition-pre·  x .fst .len = x .fst .len
+ partition-pre·  x .fst .pts = (_·ᵣ α) ∘ x .fst .pts
+ partition-pre·  x .fst .a≤pts =
+   ≤ᵣ-·ᵣo _ _ _ 0≤α ∘ x .fst .a≤pts
+ partition-pre·  x  .fst .pts≤b =
+    ≤ᵣ-·ᵣo _ _ _ 0≤α ∘ x .fst .pts≤b
+ partition-pre·  x  .fst .pts≤pts =
+     ≤ᵣ-·ᵣo _ _ _ 0≤α ∘ x .fst .pts≤pts
+ partition-pre·  x  .snd .samples =
+  (_·ᵣ α) ∘  x  .snd .samples
+ partition-pre·  x .snd .pts'≤samples =
+   λ { k@(0 , _ , _) → ≤ᵣ-·ᵣo _ _ _ z (x .snd .pts'≤samples k)
+     ; k@(suc _ , 0 , _) → ≤ᵣ-·ᵣo _ _ _ z (x  .snd .pts'≤samples k)
+     ; k@(suc _ , suc _ , _) → ≤ᵣ-·ᵣo _ _ _ z (x .snd .pts'≤samples k)
+      }
+   where
+    z = 0≤α
+
+ partition-pre·  x .snd .samples≤pts' =
+   λ { k@(0 , 0 , _) → ≤ᵣ-·ᵣo _ _ _ z (x .snd .samples≤pts' k)
+     ; k@(0 , suc _ , _) → ≤ᵣ-·ᵣo _ _ _ z (x .snd .samples≤pts' k)
+     ; k@(suc _ , 0 , _) → ≤ᵣ-·ᵣo _ _ _ z (x .snd .samples≤pts' k)
+     ; k@(suc _ , suc _ , _) → ≤ᵣ-·ᵣo _ _ _ z (x .snd .samples≤pts' k)
+      }
+   where
+    z = 0≤α
+
+ partition-pre·-lem : ∀ tp k →
+      pts' (fst (partition-pre· tp)) (fsuc k) -ᵣ
+      pts' (fst (partition-pre· tp)) (finj k)
+      ≡
+      pts' (fst tp) (fsuc k) ·ᵣ α -ᵣ pts' (fst tp) (finj k) ·ᵣ α
+ partition-pre·-lem tp (0 , 0 , _) = refl
+ partition-pre·-lem tp (0 , suc _ , _) = refl
+ partition-pre·-lem tp (suc _ , 0 , _) = refl
+ partition-pre·-lem tp (suc _ , suc _ , _) = refl
+
+ mesh-pre· : ∀ δ → (tp : TaggedPartition[ a , b ]) →
+             mesh≤ᵣ (fst tp) δ
+            → mesh≤ᵣ (fst (partition-pre· tp)) (δ ·ᵣ α)
+ mesh-pre· δ tp x k =
+   isTrans≡≤ᵣ _ _ _
+     (partition-pre·-lem tp k ∙ sym (𝐑'.·DistL- _ _ _))
+     (≤ᵣ-·ᵣo _ _ _ 0≤α
+      (x k))
+
+ -- mesh-pre·-sample : ((p , tg) : TaggedPartition[ a , b ]) → ∀ k →
+ --     fst (samplesΣ tg k) ≡ {!!}
+ -- mesh-pre·-sample = {!!}
+
+-- module _ (a b : ℝ) (α : ℝ) (0≤α : 0 ≤ᵣ α) where
+
+--  integral'-pre· : ∀ f s
+--           → (on[ a  , b ]IntegralOf (f ∘S (_·ᵣ (α))) is' s)
+--           → (on[ a ·ᵣ α  , b ·ᵣ α  ]IntegralOf f is' (s ·ᵣ α))
+--  integral'-pre· f s X ε =
+--    PT.rec squash₁
+--       (λ (x' , (α<x' , _)) →
+--        let x'₊ : ℚ₊
+--            x'₊ = (x' , ℚ.<→0< x'
+--                   (<ᵣ→<ℚ [ pos 0 / 1+ 0 ] x'
+--                    (isTrans≤<ᵣ (rat [ pos 0 / 1+ 0 ]) α (rat x') 0≤α α<x')))
+--        in PT.map
+--          (map-snd λ {δ}
+--            (XX : ((p , tg) : TaggedPartition[ a , b ]) →
+--                                mesh≤ᵣ p (rat (fst δ)) →
+--                                absᵣ (riemannSum' tg (f ∘S (_·ᵣ α)) -ᵣ s) <ᵣ
+--                                rat (fst (ε ℚ₊· invℚ₊ x'₊)))
+--           (p , tg) (m≤ : mesh≤ᵣ p (rat (fst δ)))  →
+--            {! !})
+--           (X (ε ℚ₊· invℚ₊ x'₊)))
+--      ((denseℚinℝ α (α +ᵣ 1)
+--        (isTrans≡<ᵣ _ _ _
+--          (sym (+IdR _)) (<ᵣ-o+ 0 1 α decℚ<ᵣ?))))
+
+module _ (a b : ℝ) (α : ℝ) (0<α : 0 <ᵣ α) where
+
+ module PP = Partition-pre· (a ·ᵣ α) (b ·ᵣ α)
+  (fst (invℝ₊ (α , 0<α))) (<ᵣWeaken≤ᵣ _ _ (snd (invℝ₊ (α , 0<α))))
+
+ integral'-pre·< : ∀ f s
+          → (on[ a  , b ]IntegralOf (f ∘S (_·ᵣ (α))) is' s)
+          → (on[ a ·ᵣ α  , b ·ᵣ α  ]IntegralOf f is' (s ·ᵣ α))
+ integral'-pre·< f s X ε =
+   PT.rec2 squash₁
+      (λ (x'' , (0<x'' , x''<α)) (x' , (α<x' , _)) →
+       let x'₊ : ℚ₊
+           x'₊ = (x' , ℚ.<→0< x'
+                  (<ᵣ→<ℚ [ pos 0 / 1+ 0 ] x'
+                   (isTrans<ᵣ (rat [ pos 0 / 1+ 0 ]) α (rat x') 0<α α<x')))
+       in PT.map
+         (λ ((δ , XX) : Σ _ λ δ' → (((p , tg) : TaggedPartition[ a , b ]) →
+                               mesh≤ᵣ p (rat (fst δ')) →
+                               absᵣ (riemannSum' tg (f ∘S (_·ᵣ α)) -ᵣ s) <ᵣ
+                               rat (fst (ε ℚ₊· invℚ₊ x'₊)))) →
+          let x''₊ : ℚ₊
+              x''₊ = x'' , ℚ.<→0< x'' (<ᵣ→<ℚ 0 x'' 0<x'')
+              δ' : ℚ₊
+              δ' = δ ℚ₊· x''₊
+          in δ' ,
+               λ (p , tg) (m≤ : mesh≤ᵣ p (rat (fst δ')))  →
+               let (p' , tg') = PP.partition-pre· (p , tg)
+                   ZZ = subst2 (λ u v → Σ TaggedPartition[ u , v ]
+                              λ (p , _) → mesh≤ᵣ p (rat (fst δ)))
+                         ([x·yᵣ]/₊y a (α , 0<α)) ([x·yᵣ]/₊y b (α , 0<α))
+                        ((p' , tg') ,
+
+                          λ k →
+                            isTrans≤ᵣ _ _ _
+                              (PP.mesh-pre· (rat (fst δ')) (p , tg) m≤ k)
+                               (isTrans≤≡ᵣ _ _ _
+                                 (≤ᵣ-o·ᵣ _ (fst (invℝ₊ (ℚ₊→ℝ₊ x''₊))) _ (
+                                  <ᵣWeaken≤ᵣ _ _ (snd (ℚ₊→ℝ₊ δ')))
+                                  (invEq (invℝ₊-≤-invℝ₊ _ _)
+                                    (<ᵣWeaken≤ᵣ _ _ x''<α)))
+                                 (cong (_·ᵣ fst (invℝ₊ (ℚ₊→ℝ₊ x''₊)))
+                                   (rat·ᵣrat (fst δ) x'')
+                                  ∙ [x·yᵣ]/₊y (rat (fst δ)) (ℚ₊→ℝ₊ x''₊)))
+                                 )
+                   zzz = isTrans<≡ᵣ _ _ _ (uncurry XX ZZ)
+                           (rat·ᵣrat (fst ε) _ ∙
+                             cong (rat (fst ε) ·ᵣ_) (sym (invℝ₊-rat x'₊)))
+                   zzz' = fst (z<x/y₊≃y₊·z<x _ _ (ℚ₊→ℝ₊ x'₊)) zzz
+               in isTrans≡<ᵣ _ _ _
+                    (cong absᵣ
+                      (cong (_-ᵣ s ·ᵣ α)
+                        ( riemannSum'-alt-lem tg f
+                         ∙∙ (cong (λ (f : Fin _ → ℝ) → foldlFin
+                            {n = (2 ℕ.+ len (fst (fst ZZ)))}
+                              (λ S k → S +ᵣ f k) 0 (idfun _))
+                              (funExt
+                                λ (k : Fin _) →
+                                 cong₂ _·ᵣ_
+                                   (x/₊y≡z→x≡z·y _ _ (α , 0<α)
+                                     (𝐑'.·DistL- _ _ _
+                                       ∙
+                                        sym (PP.partition-pre·-lem (p , tg) k)
+                                         ∙
+                                         cong₂ _-ᵣ_
+                                          (pts'-tranp
+                                            ([x·yᵣ]/₊y a (α , 0<α))
+                                            ([x·yᵣ]/₊y b (α , 0<α))
+                                            (p' , tg') (fsuc k) (fsuc k) refl)
+                                          ((pts'-tranp
+                                            ([x·yᵣ]/₊y a (α , 0<α))
+                                            ([x·yᵣ]/₊y b (α , 0<α))
+                                            (p' , tg') (finj k) (finj k) refl)))
+                                    ∙ ·ᵣComm _ _)
+                                   (cong f
+                                    (x/₊y≡z→x≡z·y _ _ (α , 0<α)
+                                      (cong
+                                        (λ k
+                                         → (fst (samplesΣ tg k) ／ᵣ₊ (α , 0<α)))
+                                        (toℕ-injective refl)))) ∙
+                                  sym (·ᵣAssoc _ _ _))
+                          ∙ foldFin·DistL' (2 ℕ.+ len (fst (fst ZZ)))
+                             _
+                              α (idfun _))
+                           ∙ ·ᵣComm _ _ ∙∙
+                         cong (_·ᵣ α)
+                           (sym (riemannSum'-alt-lem
+                            (fst ZZ .snd) (λ x → f (x ·ᵣ α)))))
+                        ∙∙
+                       sym (𝐑'.·DistL- _ _ α) ∙∙ ·ᵣComm _ _)
+                      ∙∙ ·absᵣ _ _ ∙∙
+                      cong (_·ᵣ absᵣ (riemannSum' (fst ZZ .snd) (f ∘S (_·ᵣ α)) -ᵣ s))
+                          (absᵣPos _ 0<α))
+                    (isTrans≤<ᵣ _ _ _
+                       (≤ᵣ-·ᵣo _ _ _ (0≤absᵣ _) (<ᵣWeaken≤ᵣ _ _ α<x'))
+                      zzz'))
+          (X (ε ℚ₊· invℚ₊ x'₊)))
+     (denseℚinℝ 0 α 0<α)
+     (denseℚinℝ α (α +ᵣ 1)
+       (isTrans≡<ᵣ _ _ _
+         (sym (+IdR _)) (<ᵣ-o+ 0 1 α decℚ<ᵣ?)))
+
+
+
+
+-- integral'-pre· : ∀ a b f s (α : ℝ₊)
+--                  → (on[ a , b ]IntegralOf f is' s)
+--          → (on[ a ·ᵣ (fst α) , b ·ᵣ (fst α)
+--            ]IntegralOf (f ∘S (_·ᵣ fst (invℝ₊ α))) is' (s ·ᵣ (fst α)))
+-- integral'-pre· a b f s α X ε =
+--   PT.rec squash₁
+--     (λ (δ , (0<δ , δ<)) →
+--       PT.map (map-snd
+--          λ {δ'} →
+--            λ Y p p≤ →
+--             let pp = partition-pre·
+--                        (a ·ᵣ (fst α)) (b ·ᵣ (fst α)) (invℝ₊ α)
+--                      (p)
+--             in isTrans<ᵣ _ _ _
+--                (isTrans≡<ᵣ _ _ _ (({!!} ∙ ·absᵣ {!!} (fst α))
+--                     ∙ cong (absᵣ _ ·ᵣ_) (absᵣPos _ (snd α)) ∙ ·ᵣComm _ _ )
+--                     {!!}
+--                  -- (<ᵣ-o·ᵣ _ _  α (Y (subst2 TaggedPartition[_,_]
+--                  --  ([x·yᵣ]/₊y _ α) (([x·yᵣ]/₊y _ α)) pp)
+--                  --   {!p≤!}))
+--                    )
+--                 (fst (z<x/y₊≃y₊·z<x _ _ _) δ<)
+--               )
+--         (X (δ , {!!})))
+--     (denseℚinℝ 0 (rat (fst ε) ·ᵣ (fst (invℝ₊ α))) {!cfc!})
+
+
+
+opaque
+ unfolding _+ᵣ_
+
+ clamp-Δ-·f : ∀ a b → a ≤ᵣ b → ∀ f
+       → IsContinuous f
+       → ∀ (δ : ℚ₊)
+       → ∀ u v → u ≤ᵣ v
+       → v -ᵣ u ≤ᵣ rat (fst δ)
+       → ∀ x → x ∈ intervalℙ u v
+       → (clampᵣ a b v -ᵣ clampᵣ a b u) ·ᵣ f x
+         ≡ (clampᵣ a b v -ᵣ clampᵣ a b u)
+           ·ᵣ f (clampᵣ (a -ᵣ rat (fst δ)) (b +ᵣ rat (fst δ)) x)
+ clamp-Δ-·f a b a≤b f cf δ u v u≤v v∼u x x∈ =
+   sym (λ i → (clampᵣ a (b* i) (v* i) -ᵣ clampᵣ a (b* i) u) ·ᵣ f (x* i))
+   ∙∙
+   hhh'' a b u v x
+   ∙∙
+   λ i → (clampᵣ a (b* i) (v* i) -ᵣ clampᵣ a (b* i) u) ·ᵣ
+      f (clampᵣ (a -ᵣ δ* i) ((b* i) +ᵣ δ* i) (x* i))
+
+
+   where
+   b* v* x* δ* : I → ℝ
+   b* i = ≤→maxᵣ a b a≤b i
+   v* i = ≤→maxᵣ u v u≤v i
+   x* i = ((cong (clampᵣ u) (λ i → v* i) ≡$ x) ∙ sym (∈ℚintervalℙ→clampᵣ≡ u v x x∈)
+               ) i
+   δ* i = ((λ i → maxᵣ (v* i -ᵣ u) (rat (fst δ)))
+        ∙ ≤→maxᵣ  (v -ᵣ u) (rat (fst δ)) v∼u) i
+
+   fL : ℝ → ℝ → ℝ → ℝ → ℝ
+   fL a b u v = clampᵣ a (maxᵣ a b) (maxᵣ u v) -ᵣ clampᵣ a (maxᵣ a b) u
+
+   fLC : ∀ a b → IsContinuous₂ (fL a b)
+   fLC a b = IsContinuous-₂∘
+     (cont∘₂ (IsContinuousClamp a (maxᵣ a b)) (contNE₂ maxR))
+    (cont∘₂ (IsContinuousClamp a (maxᵣ a b)) cont₂-fst)
+
+   fLC' : ∀ u v → IsContinuous₂ (λ a b → fL a b u v)
+   fLC' u v = IsContinuous-₂∘
+     (IsContinuousClamp₂∘ (maxᵣ u v) cont₂-fst (contNE₂ maxR))
+    (IsContinuousClamp₂∘ u cont₂-fst (contNE₂ maxR))
+
+   f₀ f₁ : ℝ → ℝ → ℝ → ℝ → ℝ → ℝ
+   f₀ a b u v x = fL a b u v ·ᵣ f (clampᵣ u (maxᵣ u v) x)
+   f₁ a b u v x = fL a b u v ·ᵣ
+      f (clampᵣ (a -ᵣ (maxᵣ (maxᵣ u v -ᵣ u) (rat (fst δ))))
+       ((maxᵣ a b) +ᵣ (maxᵣ (maxᵣ u v -ᵣ u) (rat (fst δ))))
+       ((clampᵣ u (maxᵣ u v) x)))
+
+   f₀C : ∀ a b x → IsContinuous₂ (λ u v → f₀ a b u v x)
+   f₀C a b x = cont₂·₂ᵣ (fLC a b)
+     (cont∘₂ cf (IsContinuousClamp₂∘ x
+       cont₂-fst (contNE₂ maxR)))
+   f₁C : ∀ a b x → IsContinuous₂ (λ u v → f₁ a b u v x)
+   f₁C a b x = cont₂·₂ᵣ (fLC a b) (cont∘₂ cf
+      (IsContinuousClamp₂∘'
+        (IsContinuous-₂∘ (cont₂-id a)
+          (contNE₂∘ maxR
+            (IsContinuous-₂∘ (contNE₂ maxR) cont₂-fst) (cont₂-id _)))
+        ((contNE₂∘ sumR (cont₂-id (maxᵣ a b))
+          (contNE₂∘ maxR
+            (IsContinuous-₂∘ (contNE₂ maxR) cont₂-fst) (cont₂-id _))))
+        (IsContinuousClamp₂∘ x cont₂-fst (contNE₂ maxR))))
+
+   f₀C' : ∀ u v x → IsContinuous₂ (λ a b → f₀ a b u v x)
+   f₀C' u v x = cont∘₂ (IsContinuous·ᵣR _) (fLC' u v)
+   f₁C' : ∀ u v x → IsContinuous₂ (λ a b → f₁ a b u v x)
+   f₁C' u v x = cont₂·₂ᵣ (fLC' u v)
+      (cont∘₂ cf (IsContinuousClamp₂∘ (clampᵣ u (maxᵣ u v) x)
+        (cont∘₂ (IsContinuous+ᵣR (-ᵣ (maxᵣ (maxᵣ u v -ᵣ u) (rat (fst δ)))))
+          cont₂-fst)
+        ((cont∘₂ (IsContinuous+ᵣR (maxᵣ (maxᵣ u v -ᵣ u) (rat (fst δ))))
+          (contNE₂ maxR)))))
+
+   f₀C'' : ∀ a b u v → IsContinuous (f₀ a b u v)
+   f₀C'' a b u v = IsContinuous∘ _ _ (IsContinuous·ᵣL _)
+     (IsContinuous∘ _ _ cf (IsContinuousClamp u (maxᵣ u v)))
+   f₁C'' : ∀ a b u v → IsContinuous (f₁ a b u v)
+   f₁C'' a b u v = IsContinuous∘ _ _ (IsContinuous·ᵣL _)
+     (IsContinuous∘ _ _ cf
+       (IsContinuous∘ _ _
+        (IsContinuousClamp
+          (a -ᵣ (maxᵣ (maxᵣ u v -ᵣ u) (rat (fst δ))))
+          ((maxᵣ a b) +ᵣ (maxᵣ (maxᵣ u v -ᵣ u) (rat (fst δ)))))
+        (IsContinuousClamp u (maxᵣ u v))))
+
+
+   hhh : ∀ a b → a ℚ.≤ b
+       → ∀ u v → u ℚ.≤ v
+       → ∀ δ
+       → rat v -ᵣ rat u ≤ᵣ rat δ
+       → ∀ x → x ∈ ℚintervalℙ u v
+
+       → (clampᵣ (rat a) (rat b) (rat v) -ᵣ clampᵣ (rat a) (rat b) (rat u)) ·ᵣ f (rat x)
+         ≡ (clampᵣ (rat a) (rat b) (rat v) -ᵣ clampᵣ (rat a) (rat b) (rat u))
+           ·ᵣ f (clampᵣ (rat a -ᵣ rat δ) (rat b +ᵣ rat δ) (rat x))
+   hhh a b a≤b u v u≤v δ v-u≤δ x (≤x , x≤) = ⊎.rec
+        (λ p →
+         let q : clampᵣ (rat a) (rat b) (rat v)
+                 -ᵣ clampᵣ (rat a) (rat b) (rat u) ≡ 0
+             q = cong₂ _-ᵣ_ (clampᵣ-rat a b v) (clampᵣ-rat a b u)
+                   ∙ -ᵣ-rat₂ (ℚ.clamp a b v) (ℚ.clamp a b u)  ∙ cong rat p
+         in (𝐑'.0LeftAnnihilates'
+               (clampᵣ (rat a) (rat b) (rat v)
+                 -ᵣ clampᵣ (rat a) (rat b) (rat u)) (f (rat x)) q)
+          ∙ sym (𝐑'.0LeftAnnihilates'
+              (clampᵣ (rat a) (rat b) (rat v)
+                 -ᵣ clampᵣ (rat a) (rat b) (rat u))
+                  (f (clampᵣ (rat a -ᵣ rat (δ)) (rat b +ᵣ rat δ) (rat x))) q))
+                  (λ (a≤v , u≤b) →
+                     cong ( (clampᵣ (rat a) (rat b) (rat v) -ᵣ clampᵣ (rat a) (rat b) (rat u)) ·ᵣ_)
+                        (cong f
+                          (∈ℚintervalℙ→clampᵣ≡ (rat a -ᵣ rat δ) (rat b +ᵣ rat δ) (rat x)
+                           (isTrans≤ᵣ _ _ _
+                              (isTrans≤≡ᵣ _ _ _
+                                (≤ᵣMonotone+ᵣ _ _ _ _
+                                  (≤ℚ→≤ᵣ a _ a≤v) (-ᵣ≤ᵣ _ _ v-u≤δ) )
+                                (L𝐑.lem--079 {rat v} ))
+                              (≤ℚ→≤ᵣ u _ ≤x)
+                           , isTrans≤ᵣ _ _ _
+                                (≤ℚ→≤ᵣ _ v x≤)
+                                (isTrans≡≤ᵣ _ _ _
+                                  (sym (L𝐑.lem--05 {rat u}))
+                                  (≤ᵣMonotone+ᵣ _ _ _ _
+                                   (≤ℚ→≤ᵣ u _ u≤b) v-u≤δ))))))
+                  (clampCases a b a≤b u v u≤v)
+
+   hhh' : ∀ (a b u v x : ℚ) → f₀ (rat a) (rat b) (rat u) (rat v) (rat x)
+                 ≡
+               f₁ (rat a) (rat b) (rat u) (rat v) (rat x)
+   hhh' a b u v x = hhh a (ℚ.max a b) (ℚ.≤max a b) u (ℚ.max u v) (ℚ.≤max u v)
+      (ℚ.max ((ℚ.max u v) ℚ.- u) (fst δ))
+        (isTrans≡≤ᵣ _ _ _
+          ((-ᵣ-rat₂ (ℚ.max u v) u))
+          (≤ℚ→≤ᵣ ((ℚ.max u v) ℚ.- u) _
+            (ℚ.≤max ((ℚ.max u v) ℚ.- u) (fst δ))))
+
+          (ℚ.clamp u (ℚ.max u v) x)
+            (clam∈ℚintervalℙ u (ℚ.max u v) (ℚ.≤max u v) x)
+     ∙ cong₂ _·ᵣ_
+          refl
+          (cong f
+            (cong₃ clampᵣ (cong (_-ᵣ_ (rat a))
+              (cong (flip maxᵣ (rat (fst δ))) (sym (-ᵣ-rat₂ (ℚ.max u v) u))))
+              (cong (rat (ℚ.max a b) +ᵣ_)
+               (cong (flip maxᵣ (rat (fst δ))) (sym (-ᵣ-rat₂ (ℚ.max u v) u))))
+              refl))
+
+   hhh'' : ∀ (a b u v x : ℝ) → f₀ a b u v x ≡ f₁ a b u v x
+   hhh'' a b u v x =
+     ≡Cont₂ (f₀C a b x) (f₁C a b x)
+       (λ uℚ vℚ → let u = rat uℚ ; v = rat vℚ in
+         ≡Cont₂ (f₀C' u v x) (f₁C' u v x)
+          (λ aℚ bℚ → let a = rat aℚ ; b = rat bℚ in
+           ≡Continuous (f₀ a b u v) (f₁ a b u v)
+            (f₀C'' a b u v) (f₁C'' a b u v)
+             (hhh' aℚ bℚ uℚ vℚ) x)
+          a b)
+       u v
+
+
+ -- clamp-Δ-·f' : ∀ a b → a ≤ᵣ b → ∀ f
+ --      → IsContinuous f
+ --      → ∀ (δ : ℚ₊)
+ --      → ∀ u v → u ≤ᵣ v
+ --      → v -ᵣ u ≤ᵣ rat (fst δ)
+ --      → ∀ x → rat x ∈ intervalℙ u v
+ --      → (clampᵣ a b v -ᵣ clampᵣ a b u) ·ᵣ f (rat x)
+ --        ≡ (clampᵣ a b v -ᵣ clampᵣ a b u)
+ --          ·ᵣ f (clampᵣ (a -ᵣ rat (fst δ)) (b) (rat x))
+ -- clamp-Δ-·f' a b a≤b f cf δ u v u≤v v∼u x (≤x , x≤) =
+ --   subst {x = rat x} {clampᵣ u v (rat x)}
+ --      (λ x →
+ --      (clampᵣ a b v -ᵣ clampᵣ a b u) ·ᵣ f x
+ --        ≡ (clampᵣ a b v -ᵣ clampᵣ a b u)
+ --          ·ᵣ f (clampᵣ (a -ᵣ rat (fst δ)) (b) x))
+ --          ?
+ --       (subst2 (λ b u →
+ --      (clampᵣ a b v -ᵣ clampᵣ a b u) ·ᵣ f (rat x)
+ --        ≡ (clampᵣ a b v -ᵣ clampᵣ a b u)
+ --          ·ᵣ f (clampᵣ (a -ᵣ rat (fst δ)) (b) (rat x)))
+ --     (≤→maxᵣ _ _ a≤b)
+
+ --     (sym (∈ℚintervalℙ→clampᵣ≡
+ --       (v -ᵣ rat (fst δ)) v
+ --       u (≤u , u≤v)))
+ --       (≡Cont₂
+ --         {f₀ = λ a b → f₀ a b u v}
+ --         {f₁ = λ a b → f₁ a b u v}
+ --        (cont∘₂ (IsContinuous·ᵣR (f (u' ?))) ch)
+ --         (cont₂·₂ᵣ
+ --           ch
+ --           (cont∘₂ cf
+ --             (IsContinuousClamp₂∘ (clampᵣ (v -ᵣ rat (fst δ)) v ?)
+ --               ((λ _ → IsContinuousConst _) ,
+ --                (λ _ → IsContinuous+ᵣR (-ᵣ rat (fst δ)))
+ --                ) ((contNE₂ maxR)))))
+ --        (λ aℚ bℚ →
+ --          ≡Cont₂ {f₀ = f₀ (rat aℚ) (rat bℚ)}
+ --                 {f₁ = f₁ (rat aℚ) (rat bℚ)}
+ --             (cont₂·₂ᵣ (ch' aℚ bℚ)
+ --               (cont∘₂ cf ch''))
+ --             (cont₂·₂ᵣ (ch' aℚ bℚ)
+ --               (cont∘₂ cf
+ --                 (cont∘₂ (IsContinuousClamp (rat aℚ -ᵣ rat (fst δ))
+ --                       ((maxᵣ (rat aℚ) (rat bℚ)))) ch'')))
+ --             (λ uℚ vℚ →
+ --              let qqq = (cong (λ xx →
+ --                       clampᵣ xx (rat vℚ) (rat uℚ))
+ --                        (sym (-ᵣ-rat₂ vℚ  (fst δ))))
+ --                  ppp =
+ --                     cong (λ uu →
+ --                        clampᵣ (rat aℚ) (maxᵣ (rat aℚ) (rat bℚ)) (rat vℚ) -ᵣ
+ --                       clampᵣ (rat aℚ) (maxᵣ (rat aℚ) (rat bℚ))
+ --                       uu)
+ --                        qqq
+ --              in cong₂ _·ᵣ_
+ --                 (sym ppp)
+ --                 (cong f (sym qqq))
+ --                 ∙∙ hh aℚ ((ℚ.max aℚ bℚ))
+ --                       (ℚ.≤max aℚ bℚ)
+ --                    ((ℚ.clamp (vℚ ℚ.- (fst δ)) (vℚ) ( uℚ)))
+ --                       (vℚ) (ℚ.clamp≤ (vℚ ℚ.- fst δ) vℚ uℚ)
+ --                        (isTrans≤≡ᵣ _ _ _ (≤ᵣ-o+ (-ᵣ (rat (ℚ.clamp (vℚ ℚ.- fst δ) vℚ uℚ)))
+ --                         (-ᵣ rat (vℚ ℚ.- fst δ))
+ --                         (rat vℚ)
+ --                          (-ᵣ≤ᵣ _ _  (≤ℚ→≤ᵣ _ _ (ℚ.≤clamp (vℚ ℚ.- fst δ) vℚ uℚ
+ --                           (ℚ.≤-ℚ₊ vℚ vℚ δ (ℚ.isRefl≤ vℚ))))))
+ --                          (cong (_-ᵣ_ (rat vℚ)) (sym (-ᵣ-rat₂ vℚ (fst δ)))
+ --                           ∙ L𝐑.lem--079 {rat vℚ} {rat (fst δ)})
+ --                          ) ∙∙
+ --                 cong₂ _·ᵣ_
+ --                  ppp
+ --                  (cong f
+ --                    (cong (clampᵣ (rat aℚ -ᵣ rat (fst δ)) _)
+
+ --                      qqq)))
+ --             u v)
+ --         a b))
+
+
+ --   where
+ --    -- x'
+ --    ≤u : v -ᵣ rat (fst δ) ≤ᵣ u
+ --    ≤u = a-b≤c⇒a-c≤b v _ _ v∼u
+
+
+ --    u' : ℝ → ℝ
+ --    u' = clampᵣ (v -ᵣ rat (fst δ)) v
+
+ --    f₀ : ℝ → ℝ → ℝ → ℝ → ℝ
+ --    f₀ a b u v = ((clampᵣ a (maxᵣ a b)) v -ᵣ clampᵣ a (maxᵣ a b)
+ --      (clampᵣ (v -ᵣ rat (fst δ)) v u))
+ --       ·ᵣ f (clampᵣ (v -ᵣ rat (fst δ)) v (rat x))
+
+
+ --    f₁ : ℝ → ℝ → ℝ → ℝ → ℝ
+ --    f₁ a b u v = ((clampᵣ a (maxᵣ a b)) v -ᵣ clampᵣ a (maxᵣ a b)
+ --         (clampᵣ (v -ᵣ rat (fst δ)) v u))
+ --          ·ᵣ f (clampᵣ (a -ᵣ rat (fst δ)) ((maxᵣ a b))
+ --           (clampᵣ (v -ᵣ rat (fst δ)) v (rat x)))
+
+
+
+
+ --    b' : ℝ
+ --    b' = maxᵣ a b
+
+ --    ch : IsContinuous₂ λ z z₁ →
+ --                            NonExpanding₂-Lemmas.NE.go ℚ._+_ sumR
+ --                             (clampᵣ z (maxᵣ z z₁) v)
+ --                            (-ᵣ clampᵣ z (maxᵣ z z₁) (u' u))
+ --    ch = (IsContinuous-₂∘
+ --             (IsContinuousClamp₂∘ v
+ --                ((λ _ → IsContinuousConst _) , (λ _ → IsContinuousId))
+ --                (contNE₂ maxR))
+ --             (IsContinuousClamp₂∘ (clampᵣ (v -ᵣ rat (fst δ)) v u)
+ --                 ((λ _ → IsContinuousConst _) , (λ _ → IsContinuousId))
+ --                 (contNE₂ maxR)))
+
+ --    ch'' : IsContinuous₂ (λ z z₁ → (clampᵣ (z₁ -ᵣ rat (fst δ)) z₁ (rat x)))
+ --    ch'' = ?
+ --    -- contNE₂∘ minR
+ --    --      {λ z z₁ → maxᵣ ((z₁ -ᵣ rat (fst δ))) z}
+ --    --      {λ z z₁ → z₁}
+ --    --    (contNE₂∘ maxR
+ --    --      ((λ _ → IsContinuous+ᵣR (-ᵣ rat (fst δ))) , (λ _ → IsContinuousConst _))
+ --    --      ( (λ _ → IsContinuousConst _) ,  (λ _ → IsContinuousId)))
+ --    --   ((λ _ → IsContinuousId) , (λ _ → IsContinuousConst _))
+
+ --    ch' : ∀ aℚ bℚ → IsContinuous₂
+ --      (λ z z₁ →
+ --         clampᵣ (rat aℚ) (maxᵣ (rat aℚ) (rat bℚ)) z₁ -ᵣ
+ --         clampᵣ (rat aℚ) (maxᵣ (rat aℚ) (rat bℚ))
+ --         (clampᵣ (z₁ -ᵣ rat (fst δ)) z₁ _))
+ --    ch' aℚ bℚ = ?
+ --    -- IsContinuous-₂∘
+ --    --   ((λ _ → IsContinuousClamp (rat aℚ) (maxᵣ (rat aℚ) (rat bℚ)))
+ --    --    , λ _ → IsContinuousConst _ )
+ --    --   (cont∘₂ (IsContinuousClamp (rat aℚ) (maxᵣ (rat aℚ) (rat bℚ)))
+ --    --    ch'')
+
+ --    hh : ∀ a b → a ℚ.≤ b
+ --      → ∀ u v → u ℚ.≤ v
+ --      → rat v -ᵣ rat u ≤ᵣ rat (fst δ)
+
+ --      → (clampᵣ (rat a) (rat b) (rat v) -ᵣ clampᵣ (rat a) (rat b) (rat u))
+ --         ·ᵣ f (rat x)
+ --        ≡ (clampᵣ (rat a) (rat b) (rat v) -ᵣ clampᵣ (rat a) (rat b) (rat u))
+ --          ·ᵣ f (clampᵣ (rat a -ᵣ rat (fst δ)) (rat b) (rat x))
+ --    hh a b a≤b u v u≤v v-u≤δ = ?
+ --      -- ⊎.rec
+ --      --   (λ p →
+ --      --    let q : clampᵣ (rat a) (rat b) (rat v)
+ --      --            -ᵣ clampᵣ (rat a) (rat b) (rat u) ≡ 0
+ --      --        q = cong₂ _-ᵣ_ (clampᵣ-rat a b v) (clampᵣ-rat a b u)
+ --      --              ∙ -ᵣ-rat₂ (ℚ.clamp a b v) (ℚ.clamp a b u)  ∙ cong rat p
+ --      --    in (𝐑'.0LeftAnnihilates'
+ --      --          (clampᵣ (rat a) (rat b) (rat v)
+ --      --            -ᵣ clampᵣ (rat a) (rat b) (rat u)) (f (rat u)) q)
+ --      --     ∙ sym (𝐑'.0LeftAnnihilates'
+ --      --         (clampᵣ (rat a) (rat b) (rat v)
+ --      --            -ᵣ clampᵣ (rat a) (rat b) (rat u))
+ --      --             (f (clampᵣ (rat a -ᵣ rat (fst δ)) (rat b) (rat u))) q))
+ --      --   (λ (a≤v , u≤b) →
+ --      --      cong ( (clampᵣ (rat a) (rat b) (rat v) -ᵣ clampᵣ (rat a) (rat b) (rat u)) ·ᵣ_)
+ --      --     (cong f ((∈ℚintervalℙ→clampᵣ≡ (rat a -ᵣ rat (fst δ)) (rat b) (rat u)
+ --      --        ((isTrans≤ᵣ _ _ _
+ --      --          (≤ᵣ-+o _ _ (-ᵣ (rat (fst δ))) (≤ℚ→≤ᵣ a v a≤v)) (a-b≤c⇒a-c≤b (rat v) _ _ v-u≤δ))
+ --      --          , (≤ℚ→≤ᵣ u b u≤b)))
+ --      --           )))
+ --      --  (clampCases a b a≤b u v u≤v)
+
+clamp-interval-Δ-swap : ∀ a b a' b'
+           → a  ≤ᵣ b
+           → a' ≤ᵣ b'
+                → clampᵣ a  b  b' -ᵣ clampᵣ a  b  a'
+                ≡ clampᵣ a' b' b  -ᵣ clampᵣ a' b' a
+clamp-interval-Δ-swap a b a' b' a≤b a'≤b' =
+  subst2 (λ b' b → clampᵣ a  b  b' -ᵣ clampᵣ a  b  a'
+                ≡ clampᵣ a' b' b  -ᵣ clampᵣ a' b' a)
+      (≤→maxᵣ _ _ a'≤b') (≤→maxᵣ _ _ a≤b)
+      (≡Cont₂ {f₀ = λ a b → f a b a' b'}
+              {f₁ = λ a b → f a' b' a b}
+         (fC' a' b')
+         (fC a' b')
+         (λ aℚ bℚ → let a = (rat aℚ) ; b = (rat bℚ) in
+            ≡Cont₂ {f₀ = λ a' b' → f a b a' b'}
+                   {f₁ = λ a' b' → f a' b' a b}
+             (fC (rat aℚ) (rat bℚ))
+             (fC' (rat aℚ) (rat bℚ))
+             (λ aℚ' bℚ' →
+                -ᵣ-rat₂ _ _ ∙∙ cong rat
+                   (ℚclampInterval-delta aℚ _ aℚ' _ (ℚ.≤max aℚ bℚ) (ℚ.≤max aℚ' bℚ'))
+                 ∙∙ sym (-ᵣ-rat₂ _ _))
+             a' b')
+         a b)
+
+
+
+ where
+
+ f : ℝ → ℝ → ℝ → ℝ → ℝ
+ f a b a' b' = clampᵣ a (maxᵣ a b) (maxᵣ a' b') -ᵣ clampᵣ a (maxᵣ a b) a'
+
+ fC : ∀ a b → IsContinuous₂ (f a b)
+ fC a b = IsContinuous-₂∘
+    (cont∘₂ (IsContinuousClamp a (maxᵣ a b)) (contNE₂ maxR))
+    (cont∘₂ (IsContinuousClamp a (maxᵣ a b))
+     ((λ _ → IsContinuousConst _) ,  (λ _ → IsContinuousId)))
+
+ fC' : ∀ a b → IsContinuous₂ (λ a' b' → f a' b' a b)
+ fC' a' b' = IsContinuous-₂∘
+    (IsContinuousClamp₂∘ (maxᵣ a' b')
+     (((λ _ → IsContinuousConst _) ,  (λ _ → IsContinuousId)))
+     (contNE₂ maxR))
+    (IsContinuousClamp₂∘ a'
+     ((λ _ → IsContinuousConst _) ,  (λ _ → IsContinuousId)) (contNE₂ maxR))
+
+
+llll : absᵣ (rat [ pos 0 / 1+ 0 ] -ᵣ rat [ pos 0 / 1+ 0 ]) ≤ᵣ
+      rat [ pos 0 / 1+ 0 ]
+llll = ≡ᵣWeaken≤ᵣ _ _
+   (cong absᵣ (-ᵣ-rat₂ _ _) ∙ absᵣ0
+     ∙ cong {x = zero} (λ z → rat [ pos z / 1+ z ]) refl )
+
+0<2^-ℚ : ∀ n → ℚ.0< [ pos (2^ n) / 1+ 0 ]
+0<2^-ℚ n = ℚ.<→0< [ pos (2^ n) / 1+ 0 ] (ℚ.<ℤ→<ℚ 0 (pos (2^ n))
+ (invEq (ℤ.pos-<-pos≃ℕ< 0 _) (0<2^ n) ))
+
+2^-mon : ∀ n → 2^ n ℕ.< 2^ (suc n)
+2^-mon zero = ℕ.≤-solver 2 2
+2^-mon (suc n) = ℕ.<-+-< (2^-mon n) (2^-mon n)
+
+lemXX : ∀ n → 2 ℕ.+ predℕ (predℕ (2^ (suc n))) ≡ 2^ (suc n)
+lemXX n = ℕ.k+predℕₖ {2} {2^ (suc n)} (ℕ.≤-+-≤ {1} {2^ n} {1} {2^ n}
+ (0<2^ n) (0<2^ n))
+
+invℚ₊-inj : ∀ a b → fst (invℚ₊ a) ≡ fst (invℚ₊ b) → fst a ≡ fst b
+invℚ₊-inj a b x =
+  sym (ℚ.invℚ₊-invol _)
+  ∙∙ cong (fst ∘ invℚ₊) (ℚ₊≡ x) ∙∙
+  ℚ.invℚ₊-invol _
+
+module Resample where
+
+
+ -- resampledRiemannSum : ∀ a b → a ≤ᵣ b →  (∀ r → a ≤ᵣ r → r ≤ᵣ b → ℝ)
+ --   → (pa pa' : Partition[ a , b ])
+ --    (s : Sample pa) → ℝ
+ -- resampledRiemannSum a b a≤b f pa pa' sa =
+ --   foldlFin {n = 2 ℕ.+ P'.len}
+ --      (λ s  k →
+ --        let  a' = P'.pts' (finj k)
+ --             b' = P'.pts' (fsuc k)
+ --        in s +ᵣ
+ --            foldlFin {n = 2 ℕ.+ P.len}
+ --            (λ s ((t , a≤t , t≤b) , b-a) → s +ᵣ
+ --              b-a ·ᵣ (f (clampᵣ a' b' t)
+ --                (isTrans≤ᵣ _ _ _ (P'.a≤pts' (finj k))
+ --                  (≤clampᵣ a' b' t (P'.pts'≤pts' k)))
+ --                (isTrans≤ᵣ _ _ _ (clamp≤ᵣ a' b' t) (P'.pts'≤b (fsuc k)))) ) 0
+ --                (λ k →  S.samplesΣ k , P.pts' (fsuc k) -ᵣ P.pts' (finj k))
+ --        )
+ --      0
+ --      (idfun _)
+
+ --      -- (λ k →  k (P'.pts' (fsuc k) , P'.pts' (finj k)))
+ --  -- foldlFin {n = 2 ℕ.+ P.len}
+ --  --    (λ s ((t , a≤t , t≤b) , b-a) → s +ᵣ
+ --  --      b-a ·ᵣ (f t a≤t t≤b) ) 0
+ --  --        (λ k →  S.samplesΣ k , P.pts' (fsuc k) -ᵣ P.pts' (finj k))
+ --  where
+ --  module P = Partition[_,_] pa
+ --  module P' = Partition[_,_] pa'
+ --  module S = Sample sa
+
+
+ resampledRiemannSum' : ∀ a b →  (ℝ → ℝ)
+   → (pa pa' : Partition[ a , b ])
+    (s : Sample pa) → ℝ
+ resampledRiemannSum' a b f pa pa' sa =
+   foldlFin {n = 2 ℕ.+ P'.len}
+      (λ s  k →
+        let  a' = P'.pts' (finj k)
+             b' = P'.pts' (fsuc k)
+        in s +ᵣ
+            foldlFin {n = 2 ℕ.+ P.len}
+            (λ s ((t , a≤t , t≤b) , b-a) → s +ᵣ
+              b-a ·ᵣ (f t) ) 0
+                (λ k →  S.samplesΣ k ,
+                 clampᵣ a' b' (P.pts' (fsuc k))
+                  -ᵣ clampᵣ a' b' (P.pts' (finj k)))
+        ) 0 (idfun _)
+
+  where
+  module P = Partition[_,_] pa
+  module P' = Partition[_,_] pa'
+  module S = Sample sa
+
+
+ partitionClamp : ∀ a b  → ∀ a' b' → a' ≤ᵣ b'
+   → a ≤ᵣ a' →  b' ≤ᵣ b →
+   (pa : Partition[ a , b ]) →
+    b' -ᵣ a' ≡
+         foldlFin {n = 2 ℕ.+ len pa}
+      (λ s  k →
+        let  a* = pts' pa (finj k)
+             b* = pts' pa (fsuc k)
+        in s +ᵣ
+            ((clampᵣ a' b' b* -ᵣ clampᵣ a' b' a*))
+        )
+      0
+      (idfun _)
+ partitionClamp a b a' b' a'≤b' a≤a' b'≤b pa =
+   cong₂ _-ᵣ_
+     (sym (≤x→clampᵣ≡ a' b' (pts' pa flast) a'≤b' b'≤b))
+     (sym (x≤→clampᵣ≡ a' b' (pts' pa fzero)
+       a'≤b' a≤a'))
+    ∙ sym (deltas-sum (2 ℕ.+ len pa)
+      (clampᵣ a' b' ∘ pts' pa ))
+
+
+
+ resample : ∀ a b → a ≤ᵣ b → (pa pa' : Partition[ a , b ])
+    (sa : Sample pa)  → ∀ f
+    → resampledRiemannSum' a b f pa pa' sa
+       ≡ riemannSum' sa f
+ resample a b a≤b pa pa' sa f =
+    ((cong (foldlFin {n = 2 ℕ.+ P'.len})
+     (funExt₂ (λ s k' →
+       cong (s +ᵣ_)
+        (foldFin+map (2 ℕ.+ P.len) 0 _
+         (λ k →  S.samplesΣ k ,
+                 clampᵣ (P'.pts' (finj k')) (P'.pts' (fsuc k'))
+                  (P.pts' (fsuc k))
+                  -ᵣ clampᵣ (P'.pts' (finj k')) (P'.pts' (fsuc k'))
+                   (P.pts' (finj k))) (idfun _) )))
+     ≡$ 0) ≡$ (idfun _))
+     ∙ foldFin+transpose (2 ℕ.+ P'.len) (2 ℕ.+ P.len) _ 0
+     ∙ ((cong (foldlFin {n = 2 ℕ.+ P.len})
+          (funExt₂ (λ s k →
+            cong (s +ᵣ_)
+             (  (cong (foldlFin {n = 2 ℕ.+ P'.len})
+               (funExt₂ (λ s k' → cong (s +ᵣ_)
+                 (·ᵣComm _ _)))
+               ≡$ 0 ≡$ (idfun _))
+              ∙ foldFin·DistL' (2 ℕ.+ P'.len) _ (f (fst (S.samplesΣ k))) (idfun _)
+              ∙ cong (f (fst (S.samplesΣ k)) ·ᵣ_)
+                  (((cong (foldlFin {n = 2 ℕ.+ P'.len})
+                     (funExt₂ (λ s k' → cong (s +ᵣ_)
+                         ((clamp-interval-Δ-swap
+                          (P'.pts' (finj k')) (P'.pts' (fsuc k'))
+                          (P.pts' (finj k)) (P.pts' (fsuc k))
+                          (P'.pts'≤pts' k') (P.pts'≤pts' k)))
+                         )) ≡$ 0)
+                      ≡$ (idfun _))
+                   ∙ sym
+                     (partitionClamp a b (P.pts' (finj k)) (P.pts' (fsuc k))
+                      (P.pts'≤pts' k) (P.a≤pts' (finj k)) (P.pts'≤b (fsuc k)) pa'))
+              ∙ ·ᵣComm _ _
+             )
+                        ))
+          ≡$ 0) ≡$ (idfun _))
+     ∙ sym (foldFin+map (2 ℕ.+ P.len) 0 _
+       (λ k →  S.samplesΣ k , P.pts' (fsuc k) -ᵣ P.pts' (finj k)) (idfun _))
+
+
+  where
+  module P = Partition[_,_] pa
+  module P' = Partition[_,_] pa'
+  module S = Sample sa
+
+--
+ resampleΔ-UC : ∀ a b → (a<b : a ≤ᵣ b)   → ∀ f → IsUContinuous f → (ε : ℚ₊)
+    → (δ : ℚ₊ ) →  (∀ (u v : ℝ) →
+                   u ∼[ δ ] v →
+                   absᵣ (f u -ᵣ f v) <ᵣ
+                   fst (ℚ₊→ℝ₊ ε ₊·ᵣ
+                       invℝ₊ (maxᵣ 1 (b -ᵣ a) ,
+                         isTrans<≤ᵣ _ _ _ (decℚ<ᵣ? {0} {1}) (≤maxᵣ 1 (b -ᵣ a)))))
+    → (tpa tpa' : TaggedPartition[ a , b ])
+       → mesh≤ᵣ (fst tpa) (rat (fst (/4₊ δ)))
+       → mesh≤ᵣ (fst tpa') (rat (fst (/4₊ δ))) →
+      absᵣ (riemannSum' (snd tpa) f -ᵣ riemannSum' (snd tpa') f) ≤ᵣ
+     rat (fst ε)
+ resampleΔ-UC a b a≤b f fcu ε δ X (pa , sa) (pa' , sa') = zzzz
+   -- PT.map {A = Σ ℚ₊
+   --              (λ δ →
+   --                 (u v : ℝ) →
+   --                 u ∼[ δ ] v →
+   --                 absᵣ (f u -ᵣ f v) <ᵣ
+   --                 fst (ℚ₊→ℝ₊ ε ₊·ᵣ invℝ₊ (b +ᵣ -ᵣ a , x<y→0<y-x a b a<b)))}
+     -- (λ (δ , X) →  , λ )
+    -- (IsUContinuous-εᵣ f fcu
+    --  (ℚ₊→ℝ₊ ε ₊·ᵣ invℝ₊ (_ , x<y→0<y-x _ _ a<b)))
+
+  where
+    σ : ℝ₊
+    σ = maxᵣ 1 (b -ᵣ a) ,
+        isTrans<≤ᵣ _ _ _ (decℚ<ᵣ? {0} {1}) (≤maxᵣ 1 (b -ᵣ a))
+    η : ℝ₊
+    η = ℚ₊→ℝ₊ ε ₊·ᵣ invℝ₊ σ
+
+    cf : IsContinuous f
+    cf = IsUContinuous→IsContinuous f fcu
+
+
+    module P = Partition[_,_] pa
+    module P' = Partition[_,_] pa'
+    module S = Sample sa
+    module S' = Sample sa'
+
+    ruc'Δ : Fin (suc (suc P.len)) → Fin (suc (suc P'.len)) → ℝ
+    ruc'Δ k k' = (clampᵣ (P.pts' (finj k)) (P.pts' (fsuc k)) (P'.pts' (fsuc k'))
+         -ᵣ
+        clampᵣ (P.pts' (finj k)) (P.pts' (fsuc k)) (P'.pts' (finj k')))
+
+
+    zzzz :
+      P.mesh≤ᵣ (rat (fst (/4₊ δ))) →
+      P'.mesh≤ᵣ (rat (fst (/4₊ δ))) →
+      absᵣ (S.riemannSum' f -ᵣ S'.riemannSum' f) ≤ᵣ
+      rat (fst ε)
+    zzzz m-pa< m-pa'< =
+       isTrans≡≤ᵣ _ _ _
+        (cong absᵣ
+         (cong (_-ᵣ_ (S.riemannSum' f))
+           (sym (resample a b a≤b pa' pa sa' f))
+           ∙ zip-foldFin-ᵣ (2 ℕ.+ len pa)
+
+             (λ k →  S.samplesΣ k , P.pts' (fsuc k) -ᵣ P.pts' (finj k))
+             (idfun _)
+             _ _ _ _))
+        (isTrans≤ᵣ _ _ _ (isTrans≤≡ᵣ _ _ _
+
+          (foldFin+≤-abs (2 ℕ.+ len pa) _ 0
+            _ (λ k → (fst η ·ᵣ pts' pa (fsuc k) -ᵣ fst η ·ᵣ pts' pa (finj k))
+                         )
+                          (λ k →
+                            (S.samplesΣ k ,
+                             P.pts' (fsuc k) -ᵣ P.pts' (finj k)) , k)
+                          (idfun _)
+           llll
+           ruc
+           )
+          (deltas-sum (2 ℕ.+ len pa) ((fst η ·ᵣ_) ∘ pts' pa)
+           ∙ sym (𝐑'.·DistR- _ _ _)))
+            (isTrans≤≡ᵣ _ _ _
+              (≤ᵣ-o·ᵣ _ _ _ (<ᵣWeaken≤ᵣ _ _ (snd η))
+               (isTrans≤≡ᵣ _ _ _ (≤maxᵣ (b -ᵣ a) 1) (maxᵣComm (b -ᵣ a) 1)) )
+              ([x/₊y]·yᵣ _ σ)))
+
+     where
+
+-- ruc
+
+      ruc' : ∀ k k' →
+             absᵣ
+         (f (S.samplesΣ k .fst) ·ᵣ ruc'Δ k k' -ᵣ
+           ruc'Δ k k' ·ᵣ f (S'.samplesΣ k' .fst))
+         ≤ᵣ fst η ·ᵣ ruc'Δ k k'
+      ruc' k k' =
+       isTrans≡≤ᵣ _ _ _
+
+        (cong absᵣ (cong₂ _-ᵣ_
+         (·ᵣComm _ _)
+         ((clamp-Δ-·f _ _ (P.pts'≤pts' k)
+           f cf (/2₊ (/2₊ δ)) _ _ (P'.pts'≤pts' k')
+             (isTrans≤≡ᵣ _ _ _ (m-pa'< k')
+               (cong rat (ℚ./4₊≡/2₊/2₊ δ))) _
+                (S'.pts'≤samples k' ,
+                 S'.samples≤pts' k' )))
+
+                 ∙
+              sym (𝐑'.·DistR- (ruc'Δ k k') _ f') ) ∙
+               ·absᵣ _ _ ∙
+                cong (_·ᵣ (absᵣ (f (S.samplesΣ k .fst) -ᵣ
+                     f'))) (absᵣNonNeg _ hh
+                       ) ∙ ·ᵣComm _ _)
+        (≤ᵣ-·ᵣo _ _ _ hh (<ᵣWeaken≤ᵣ _ _ (X _ _ smpl-δ)))
+        where
+         δ/4<δ/2 = (isTrans≡<ᵣ _ _ _
+                           (cong rat (ℚ.·Assoc (fst δ) _ _))
+                           (<ℚ→<ᵣ (fst (/2₊ (/2₊ δ))) (fst (/2₊ δ)) (ℚ.x/2<x (/2₊ δ))))
+
+         f' = _
+         hh = (x≤y→0≤y-x _ _
+                        (clamp-monotone-≤ᵣ
+                         (P.pts' (finj k))
+                         (P.pts' (fsuc k))
+                         _ _ (P'.pts'≤pts' k')))
+
+         xzxd : absᵣ
+             (P.pts' (fsuc k) +ᵣ rat (fst (/2₊ (/2₊ δ))) +ᵣ -ᵣ P.pts' (finj k))
+             +ᵣ absᵣ (-ᵣ (-ᵣ rat (fst (/2₊ (/2₊ δ)))))
+             <ᵣ rat (fst δ)
+         xzxd =
+           a<b-c⇒a+c<b _ _ _
+           (subst2 _<ᵣ_
+            (sym (absᵣPos _
+               (isTrans≡<ᵣ _ _ _
+                (sym (+ᵣ-rat 0 0))
+                (<≤ᵣMonotone+ᵣ _ _ _ _
+                 (snd (ℚ₊→ℝ₊ (/2₊ (/2₊ δ))))
+                 (x≤y→0≤y-x _ _ (P.pts'≤pts' k)))))
+              ∙ cong absᵣ
+              (+ᵣAssoc _ _ _ ∙ cong (_+ᵣ (-ᵣ P.pts' (finj k))) (+ᵣComm _ _ )))
+              (cong rat (𝐐'.·DistR- (fst δ) 1 _) ∙ sym (-ᵣ-rat₂ (fst δ ℚ.· 1) _) ∙
+                cong₂ (_-ᵣ_)
+                   (cong rat (ℚ.·IdR _))
+                   ((cong rat (ℚ./4₊≡/2₊/2₊ δ)) ∙ sym (absᵣPos _ (snd (ℚ₊→ℝ₊ (/2₊ (/2₊ δ)))))
+                     ∙ cong absᵣ (sym (-ᵣInvol _))))
+            (isTrans≤<ᵣ _ _ _
+              (≤ᵣMonotone+ᵣ _ _ _ _
+               (≡ᵣWeaken≤ᵣ _ _ (cong rat (sym (ℚ./4₊≡/2₊/2₊ δ)))) (m-pa< k))
+              (isTrans≡<ᵣ _ _ _
+                (+ᵣ-rat _ _ ∙ cong rat (sym ((ℚ.·DistL+ (fst δ) _ _))))
+                (<ℚ→<ᵣ _ _
+                  ((ℚ.<-o· ([ 1 / 4 ] ℚ.+ [ 1 / 4 ])
+                    (1 ℚ.- [ 1 / 4 ]) (fst δ) (ℚ.0<ℚ₊ δ)
+                     (ℚ.decℚ<? {[ 1 / 4 ] ℚ.+ [ 1 / 4 ]}
+                        {1 ℚ.- [ 1 / 4 ]})))))))
+
+         smpl-δ : S.samplesΣ k .fst ∼[ δ ]
+              clampᵣ (P.pts' (finj k) -ᵣ rat (fst (/2₊ (/2₊ δ))))
+                     (P.pts' (fsuc k) +ᵣ rat (fst (/2₊ (/2₊ δ))))
+              (fst (S'.samplesΣ k'))
+         smpl-δ =
+           invEq (∼≃abs<ε _ _ _)
+           ((isTrans≤<ᵣ _ _ _
+             (isTrans≡≤ᵣ _ _ _
+               (cong absᵣ
+                ((cong₂ _-ᵣ_
+                  (∈ℚintervalℙ→clampᵣ≡ (P.pts' (finj k) -ᵣ rat (fst (/2₊ (/2₊ δ))))
+                   (P.pts' (fsuc k) +ᵣ rat (fst (/2₊ (/2₊ δ))))
+                    (fst (S.samplesΣ k))
+
+                     ((isTrans≤ᵣ _ _ _
+                       (isTrans≤≡ᵣ _ _ _
+                         (≤ᵣ-o+ _ _ (P.pts' (finj k))
+                          (-ᵣ≤ᵣ _ _ (≤ℚ→≤ᵣ 0 _ (ℚ.0≤ℚ₊ (/2₊ (/2₊ δ))))))
+                         (𝐑'.+IdR' _ _ (-ᵣ-rat 0)))
+                       (S.pts'≤samples k)) ,
+                        isTrans≤ᵣ _ _ _
+                        (S.samples≤pts' k)
+                        (isTrans≡≤ᵣ _ _ _ (sym (𝐑'.+IdR' _ _ refl))
+                          (≤ᵣ-o+ _ _ (P.pts' (fsuc k))
+                          (≤ℚ→≤ᵣ 0 _ (ℚ.0≤ℚ₊ (/2₊ (/2₊ δ))))))
+                       )
+                       )
+                  refl)))
+                 (clampᵣ-dist (P.pts' (finj k) -ᵣ rat (fst (/2₊ (/2₊ δ))))
+                  (P.pts' (fsuc k) +ᵣ rat (fst (/2₊ (/2₊ δ))))
+                    _ _))
+                 (isTrans≤<ᵣ _ _ _
+                  (isTrans≡≤ᵣ _ _ _ (cong absᵣ
+                   (cong ((P.pts' (fsuc k) +ᵣ rat (fst (/2₊ (/2₊ δ)))) +ᵣ_) ( -ᵣDistr _ _) ∙ +ᵣAssoc _ _ _))
+                    (absᵣ-triangle _ _))
+                     xzxd)))
+      ruc : ∀ k →
+          absᵣ
+        ((P.pts' (fsuc k) -ᵣ P.pts' (finj k)) ·ᵣ f (S.samplesΣ k .fst) -ᵣ
+         foldlFin
+         (λ s ((t , a≤t , t≤b) , b-a) → s +ᵣ b-a ·ᵣ f t) 0
+         (λ k₁ →
+            P'.samplesΣ sa' k₁ ,
+            clampᵣ (P.pts' (finj k)) (P.pts' (fsuc k)) (P'.pts' (fsuc k₁))
+            -ᵣ clampᵣ (P.pts' (finj k)) (P.pts' (fsuc k)) (P'.pts' (finj k₁))))
+        ≤ᵣ
+        (fst η ·ᵣ P.pts' (fsuc k) -ᵣ fst η ·ᵣ P.pts' (finj k))
+
+      ruc k =
+        isTrans≡≤ᵣ _ _ _
+          (cong (absᵣ ∘ (_-ᵣ (foldlFin
+         (λ s ((t , a≤t , t≤b) , b-a) → s +ᵣ b-a ·ᵣ f t) 0
+         (λ k₁ →
+            P'.samplesΣ sa' k₁ ,
+            clampᵣ (P.pts' (finj k)) (P.pts' (fsuc k)) (P'.pts' (fsuc k₁))
+            -ᵣ clampᵣ (P.pts' (finj k)) (P.pts' (fsuc k)) (P'.pts' (finj k₁))
+            ))))
+             (cong (_·ᵣ f (S.samplesΣ k .fst))
+               (partitionClamp a b
+                 (P.pts' (finj k))
+                 (P.pts' (fsuc k))
+                  (P.pts'≤pts' k)
+                 (P.a≤pts' (finj k)) (P.pts'≤b (fsuc k)) pa'
+                 ) ∙ ·ᵣComm _ _ ∙
+                  sym (foldFin·DistL (2 ℕ.+ len pa') _ _ _
+                   (idfun _))) ∙
+                  cong absᵣ
+                   (zip-foldFin-ᵣ (2 ℕ.+ len pa')
+                   (idfun _)
+                    (λ k₁ →
+                      (samplesΣ sa' k₁ ,
+                          clampᵣ (P.pts' (finj k))
+                           (P.pts' (fsuc k)) (P'.pts' (fsuc k₁))
+                       -ᵣ clampᵣ (P.pts' (finj k)) (P.pts' (fsuc k))
+                           (P'.pts' (finj k₁))))
+                      _ _ _
+                    0))
+             (isTrans≤≡ᵣ _ _ _
+              (foldFin+≤-abs (2 ℕ.+ len pa')
+                 _ 0 _
+                  (λ kk →  fst η ·ᵣ
+                   (clampᵣ (P.pts' (finj k)) ((P.pts' (fsuc k)))
+                    (P'.pts' (fsuc kk)) -ᵣ
+                     clampᵣ (P.pts' (finj k)) ((P.pts' (fsuc k)))
+                      (P'.pts' (finj kk)))
+                           )
+                  ((λ k₁ → k₁ ,
+                      (samplesΣ sa' k₁ ,
+                         clampᵣ (P.pts' (finj k))
+                          (P.pts' (fsuc k)) (P'.pts' (fsuc k₁))
+                            -ᵣ clampᵣ (P.pts' (finj k)) (P.pts' (fsuc k))
+                            (P'.pts' (finj k₁)))))
+                  (idfun _)
+                  (isTrans≡≤ᵣ _ _ _
+                     (cong absᵣ (cong (_-ᵣ 0) (𝐑'.0RightAnnihilates _)))
+                     llll)
+                (ruc' k))
+              ((foldFin·DistL' (2 ℕ.+ len pa') _ _ (idfun _) ∙
+               cong (fst η ·ᵣ_) (deltas-sum (2 ℕ.+ P'.len )
+                (clampᵣ (P.pts' (finj k)) (P.pts' (fsuc k)) ∘ (P'.pts'))
+                 ∙ cong₂ _-ᵣ_
+                   (≤x→clampᵣ≡ (P.pts' (finj k)) (P.pts' (fsuc k)) (P'.pts' flast)
+                     (P.pts'≤pts' k) (P.pts'≤b (fsuc k)) )
+                   (x≤→clampᵣ≡ (P.pts' (finj k)) (P.pts' (fsuc k)) (P'.pts' fzero)
+                    (P.pts'≤pts' k) (P.a≤pts' (finj k))))
+               ) ∙ 𝐑'.·DistR- _ _ _) )
+
+∃enclosingℚInterval : ∀ a b →
+                      ∃[ (A , B) ∈ (ℚ × ℚ) ]
+                        (rat A ≤ᵣ a) × (b ≤ᵣ rat B)
+∃enclosingℚInterval a b =
+  PT.map2 (λ (A , _ , A<a) (B , b<B , _)
+       → (A , B) , <ᵣWeaken≤ᵣ _ _ A<a , <ᵣWeaken≤ᵣ _ _ b<B)
+   (denseℚinℝ (a -ᵣ 1) a (isTrans<≡ᵣ _ _ _ (<ᵣ-o+ _ _ a (-ᵣ<ᵣ _ _ (decℚ<ᵣ? {0} {1})))
+       (𝐑'.+IdR' _ _ (-ᵣ-rat 0)) ))
+   (denseℚinℝ b (b +ᵣ 1)
+    (isTrans≡<ᵣ _ _ _ (sym (+IdR b)) (<ᵣ-o+ _ _ b (decℚ<ᵣ? {0} {1}))))
+
+
+record RefinableTaggedPartition[_,_] (a b : ℝ) : Type where
+ field
+  tpSeq : ℕ → TaggedPartition[ a , b ]
+  tpRef : ∀ (ε : ℚ₊) → Σ[ N ∈ ℕ ] (∀ n → N ℕ.< n →
+   mesh≤ᵣ (fst (tpSeq n)) (rat (fst ε)))
+
+ tpTP : ∀ (ε : ℚ₊) →
+   Σ[ tp ∈ TaggedPartition[ a , b ] ]
+    (mesh≤ᵣ (fst tp) (rat (fst ε)))
+ tpTP ε = tpSeq (suc (fst (tpRef ε))) , (snd (tpRef ε) _ ℕ.≤-refl)
+
+
+clamp-TaggedPartition : ∀ A B → A ≤ᵣ B → ∀ a b → a ≤ᵣ b →
+   TaggedPartition[ A , B ] →
+   TaggedPartition[ a , b ]
+clamp-TaggedPartition A B A≤B a b a≤b tp = w
+
+ where
+ w : TaggedPartition[ a , b ]
+ w .fst .len = fst (tp) .len
+ w .fst .pts = clampᵣ a b ∘ (fst (tp) .pts)
+ w .fst .a≤pts k = ≤clampᵣ a b _ a≤b
+ w .fst .pts≤b k = clamp≤ᵣ a b _
+ w .fst .pts≤pts k = clamp-monotone-≤ᵣ a b _ _
+   (tp  .fst .pts≤pts k)
+ w .snd .samples = clampᵣ a b ∘ (tp .snd .samples)
+ w .snd .pts'≤samples j@(zero , l , _) =
+   ≤clampᵣ a b  _ a≤b
+ w .snd .pts'≤samples j@(suc k , zero , _) =
+  clamp-monotone-≤ᵣ a b _ _
+   (tp .snd .pts'≤samples j)
+ w .snd .pts'≤samples j@(suc k , suc l , _) =
+  clamp-monotone-≤ᵣ a b _ _
+   (tp .snd .pts'≤samples j)
+ w .snd .samples≤pts' j@(zero , zero , p) =
+  ⊥.rec (ℕ.znots (cong predℕ p))
+ w .snd .samples≤pts' j@(zero , suc l , _) =
+  clamp-monotone-≤ᵣ a b _ _
+   (tp .snd .samples≤pts' j)
+ w .snd .samples≤pts' j@(suc k , zero , _) =
+  clamp≤ᵣ a b  _
+ w .snd .samples≤pts' j@(suc k , suc l , _) =
+  clamp-monotone-≤ᵣ a b _ _
+   (tp .snd .samples≤pts' j)
+
+clamp-TaggedPartition-mesh : ∀ A B A≤B a b a≤b
+  → a ∈ intervalℙ A B
+  → b ∈ intervalℙ A B
+  → ∀ tp δ
+  → mesh≤ᵣ (fst tp) δ
+  → mesh≤ᵣ (fst (clamp-TaggedPartition A B A≤B a b a≤b tp)) δ
+
+clamp-TaggedPartition-mesh A B A≤B a b a≤b (≤a , a≤) (≤b , b≤) tp δ mesh-tp k =
+   isTrans≤ᵣ _ _ _
+    (isTrans≡≤ᵣ _ _ _
+     (cong₂ _-ᵣ_  (w-pts (fsuc k)) (w-pts (finj k)))
+     ((subst2 _≤ᵣ_
+        (absᵣNonNeg _ ((x≤y→0≤y-x _ _
+          (clamp-monotone-≤ᵣ (pts' (fst tp) (finj k)) (pts' (fst tp) (fsuc k))
+            a b a≤b)))
+         ∙ sym (clamp-interval-Δ-swap
+              a b
+              (pts' (fst (tp)) (finj k))
+              (pts' (fst (tp)) (fsuc k))
+
+               a≤b ((pts'≤pts' (fst (tp)) k))))
+        (absᵣNonNeg _ (x≤y→0≤y-x _ _ (pts'≤pts' (fst (tp)) k)))
+        (clampᵣ-dist _ _ _ _))))
+    (mesh-tp k)
+ where
+
+
+ w-pts : ∀ k → pts' (fst (clamp-TaggedPartition A B A≤B a b a≤b tp)) k ≡
+  clampᵣ a b (pts' (fst tp) k)
+ w-pts j@(suc k , zero , _) = sym (≤x→clampᵣ≡ a b B a≤b b≤)
+ w-pts j@(zero , _ , _) = sym (x≤→clampᵣ≡ a b A a≤b ≤a)
+ w-pts j@(suc k , suc l , _) = refl
+
+clamp-RefinableTaggedPartition : ∀ A B → ∀ a b → a ≤ᵣ b
+   → a ∈ intervalℙ A B
+   → b ∈ intervalℙ A B →
+   RefinableTaggedPartition[ A , B ] →
+   RefinableTaggedPartition[ a , b ]
+clamp-RefinableTaggedPartition A B a b a≤b (≤a , a≤) (≤b , b≤) rfp = ww
+ where
+ open RefinableTaggedPartition[_,_]
+
+
+
+ w : ℕ → TaggedPartition[ a , b ]
+ w = clamp-TaggedPartition A B
+   (isTrans≤ᵣ _ _ _ (isTrans≤ᵣ _ _ _ ≤a a≤b) b≤)
+    a b a≤b ∘ rfp .tpSeq
+
+ w-pts : ∀ n k → pts' (fst (w n)) k ≡
+  clampᵣ a b (pts' (fst (rfp .tpSeq n)) k)
+ w-pts n j@(suc k , zero , _) = sym (≤x→clampᵣ≡ a b B a≤b b≤)
+ w-pts n j@(zero , _ , _) = sym (x≤→clampᵣ≡ a b A a≤b ≤a)
+ w-pts n j@(suc k , suc l , _) = refl
+
+ ww : RefinableTaggedPartition[ a , b ]
+ ww .tpSeq = w
+ ww .tpRef = map-snd (λ X n n< k →
+   isTrans≤ᵣ _ _ _
+     ((subst2 _≤ᵣ_
+        (cong absᵣ
+           (sym (cong₂ _-ᵣ_ (w-pts n (fsuc k)) (w-pts n (finj k))
+             ∙ (clamp-interval-Δ-swap
+              a b
+              (pts' (fst (rfp .tpSeq n)) (finj k))
+              (pts' (fst (rfp .tpSeq n)) (fsuc k))
+
+               a≤b ((pts'≤pts' (fst (rfp .tpSeq n)) k))))) ∙
+          absᵣNonNeg _ (x≤y→0≤y-x _ _ (pts'≤pts' (fst (w n)) k)))
+        (absᵣNonNeg _ (x≤y→0≤y-x _ _ (pts'≤pts' (fst (rfp .tpSeq n)) k)))
+        (clampᵣ-dist _ _ _ _))
+      ) (X n n< k) ) ∘ (tpRef rfp)
+
+
+
+
+module PreIntegration a b (a≤b : a ≤ᵣ b) (A B : ℚ)
+  (A≤a : rat A ≤ᵣ a)
+  (b≤B : b ≤ᵣ rat B) (rtp : RefinableTaggedPartition[ a , b ])
+  f (ucf : IsUContinuous f) where
+
+ open RefinableTaggedPartition[_,_] rtp
+
+ ∫-seq : Seq
+ ∫-seq = (flip Sample.riemannSum' f ∘ snd) ∘S tpSeq
+
+ module HLP (ε : ℚ₊) where
+  σ' : ℚ₊
+  σ' = ℚ.max 1 (B ℚ.- A) ,
+      ℚ.<→0< (ℚ.max 1 (B ℚ.- A))
+       (ℚ.isTrans<≤ 0 1 (ℚ.max 1 (B ℚ.- A))
+        (ℚ.decℚ<? {0} {1}) ((ℚ.≤max 1 (B ℚ.- A))))
+
+
+  η' : ℚ₊
+  η' = (/2₊ ε) ℚ₊· invℚ₊ σ'
+
+  σ : ℝ₊
+  σ = maxᵣ 1 (b -ᵣ a) ,
+      isTrans<≤ᵣ _ _ _ (decℚ<ᵣ? {0} {1}) (≤maxᵣ 1 (b -ᵣ a))
+
+  η : ℝ₊
+  η = ℚ₊→ℝ₊ (/2₊ ε) ₊·ᵣ invℝ₊ σ
+
+  η'≤η : rat (fst η') ≤ᵣ fst η
+  η'≤η = isTrans≡≤ᵣ _ _ _ (rat·ᵣrat _ _)
+             (≤ᵣ-o·ᵣ _ _ _
+              (<ᵣWeaken≤ᵣ _ _ (snd (ℚ₊→ℝ₊ (/2₊ ε))))
+              (isTrans≡≤ᵣ _ _ _
+               (sym (invℝ₊-rat σ'))
+               (invEq (invℝ₊-≤-invℝ₊ _ _)
+                 ((max-monotone-≤ᵣ 1 (b -ᵣ a) (rat (B ℚ.- A))
+                   (isTrans≤≡ᵣ _ _ _
+                    (a+d≤c+b⇒a-b≤c-d b a (rat B) (rat A)
+                    (≤ᵣMonotone+ᵣ _ _ _ _
+                     b≤B A≤a)) (-ᵣ-rat₂ _ _))))  )))
+
+
+ IsCauchySequence'-∫-seq : IsCauchySequence' ∫-seq
+ IsCauchySequence'-∫-seq ε =
+  let (δ , Y) = ucf η'
+      (N , X) = tpRef (/4₊ δ)
+  in N , λ m n N<n N<m →
+    let qqzq = Resample.resampleΔ-UC a b a≤b f ucf (/2₊ ε) δ
+          (λ u v x →
+           isTrans<≤ᵣ
+            _ _ _ (fst (∼≃abs<ε _ _ _) (Y u v x))
+            η'≤η)
+           (tpSeq n) (tpSeq m) (X n N<n) (X m N<m)
+     in isTrans≤<ᵣ _ _ _
+          qqzq (<ℚ→<ᵣ _ _ (x/2<x ε))
+  where
+  open HLP ε
+
+ IntegralOfUContinuous : ℝ
+ IntegralOfUContinuous =
+   fromCauchySequence' ∫-seq IsCauchySequence'-∫-seq
+
+ isIntegralOfUContinuous : on[ a , b ]IntegralOf f is' IntegralOfUContinuous
+ isIntegralOfUContinuous ε =
+  let (δ , Y) = ucf η'
+      (N , X) = tpRef (/4₊ δ)
+      zuio = fst (∼≃abs<ε _ _ _) (𝕣-lim-self _ (fromCauchySequence'-isCA
+               ∫-seq IsCauchySequence'-∫-seq)
+                (/2₊ (/2₊ ε)) ((/2₊ (/2₊ ε))))
+      zzLem : riemannSum' (snd (tpSeq (suc N))) f
+         ≡ ∫-seq (suc (fst (IsCauchySequence'-∫-seq (/2₊ (/2₊ ε)))))
+      zzLem = refl
+  in ∣ /4₊ δ ,
+     (λ (pa , tp) pa≤δ →
+       let qqzq = Resample.resampleΔ-UC a b a≤b f ucf (/2₊ (/2₊ (/2₊ ε))) δ
+              (λ u v x →
+                isTrans<≤ᵣ
+                 _ _ _ (fst (∼≃abs<ε _ _ _) (Y u v x))
+                 η'≤η)
+                (pa , tp) (tpSeq (suc N))
+                pa≤δ (X _ ℕ.≤-refl)
+           zuii = isTrans≤<ᵣ _ _ _ (absᵣ-triangle _ _)
+               (≤<ᵣMonotone+ᵣ _ _ _ _
+                 qqzq zuio)
+        in (isTrans<≤ᵣ _ _ _ (subst2 _<ᵣ_
+            (cong absᵣ L𝐑.lem--060)
+              (+ᵣ-rat _ _ ∙
+                cong rat (cong (fst (/2₊ (/2₊ (/2₊ ε))) ℚ.+_)
+               (ℚ.ε/2+ε/2≡ε (fst (/2₊ ε)))))
+
+            zuii )) (isTrans≤≡ᵣ _ _ _ (<ᵣWeaken≤ᵣ _ _ (<ℚ→<ᵣ _ _
+                ((ℚ.<-+o (fst (/2₊ (/2₊ (/2₊ ε))))
+                   ((fst (/2₊ ε))) ((fst (/2₊ ε)))
+                  (ℚ.isTrans<
+                    (fst (/2₊ (/2₊ (/2₊ ε))))
+                    (fst (/2₊ (/2₊ ε)))
+                    (fst (/2₊ ε))
+                    (x/2<x (/2₊ (/2₊ ε))) (x/2<x (/2₊ ε)))))))
+                  (cong rat (ℚ.ε/2+ε/2≡ε (fst ε))))) ∣₁
+  where
+  open HLP (/2₊ (/2₊ ε))
+
+
+rtp-1/n : ∀ (A B : ℚ) → A ℚ.≤ B → RefinableTaggedPartition[ rat A , rat B ]
+rtp-1/n A B A≤B .RefinableTaggedPartition[_,_].tpSeq n =
+  Integration.equalPartition (rat A) (rat B) (≤ℚ→≤ᵣ _ _ A≤B) n
+   , leftSample _
+rtp-1/n A B A≤B .RefinableTaggedPartition[_,_].tpRef ε =
+  let Δ₊ = ℚ.max (B ℚ.- A) 1 , ℚ.<→0< (ℚ.max (B ℚ.- A) 1)
+              (ℚ.isTrans<≤ 0 1 (ℚ.max (B ℚ.- A) 1)
+              (ℚ.decℚ<? {0} {1})
+              ((ℚ.≤max' (B ℚ.- A) 1)))
+      (1+ N , p)  = ℚ.ceilℚ₊ (Δ₊ ℚ₊· invℚ₊ ε)
+      in N , λ n N<n k →
+       let z = subst (ℚ.max (B ℚ.- A) [ pos 1 / 1+ 0 ] ℚ.≤_)
+             (ℚ.·Comm (fst ε) [ pos (suc (suc n)) / 1+ 0 ])
+              ((ℚ.x·invℚ₊y≤z→x≤y·z (ℚ.max (B ℚ.- A) [ pos 1 / 1+ 0 ])
+                   _ ε
+                (ℚ.<Weaken≤ (fst (Δ₊ ℚ₊· invℚ₊ ε)) (fromNat (suc (suc n)))
+                (ℚ.isTrans< (fst (Δ₊ ℚ₊· invℚ₊ ε)) _ (fromNat (suc (suc n))) p
+                 (ℚ.<ℤ→<ℚ
+                   (ℤ.pos (suc N)) (ℤ.pos (suc (suc n)))
+                     (invEq (ℤ.pos-<-pos≃ℕ< (suc N) (suc (suc n)))
+                        (ℕ.suc-≤-suc (ℕ.≤-suc N<n))))))))
+       in isTrans≡≤ᵣ _ _ _
+          (Integration.equalPartitionΔ (rat A) (rat B) (≤ℚ→≤ᵣ A B A≤B) n k ∙
+            cong (_·ᵣ rat [ pos 1 / 2+ n ]) (-ᵣ-rat₂ _ _) ∙
+             sym (rat·ᵣrat _ _))
+              (≤ℚ→≤ᵣ _ _
+                (ℚ.isTrans≤ ((B ℚ.- A) ℚ.· [ pos 1 / 2+ n ])
+                   _ (fst ε)
+                  ((ℚ.≤-·o (B ℚ.- A) (ℚ.max (B ℚ.- A) 1) ([ pos 1 / 2+ n ])
+                  (ℚ.0≤pos 1 (2+ n))
+                  (ℚ.≤max (B ℚ.- A) 1)))
+                  ( ℚ.x≤y·z→x·invℚ₊y≤z (ℚ.max (B ℚ.- A) 1)
+                   (fst ε) (fromNat (suc (suc n))) z)))
+
+∃RefinableTaggedPartition : (∀ (A B : ℚ) → A ℚ.≤ B → RefinableTaggedPartition[ rat A , rat B ])
+  → ∀ a b → a ≤ᵣ b → ∥ RefinableTaggedPartition[ a , b ] ∥₁
+∃RefinableTaggedPartition rtpℚ a b a≤b =
+  PT.map (λ ((A , B) , A≤a , b≤B) →
+    (clamp-RefinableTaggedPartition
+            _ _ a b a≤b
+             (A≤a , (isTrans≤ᵣ _ _ _ a≤b b≤B))
+             (isTrans≤ᵣ _ _ _ A≤a a≤b , b≤B)
+            (rtpℚ A B
+              (≤ᵣ→≤ℚ _ _ (isTrans≤ᵣ _ _ _
+                (isTrans≤ᵣ _ _ _ A≤a a≤b)
+                  b≤B)))))
+   (∃enclosingℚInterval a b)
diff --git a/Cubical/HITs/CauchyReals/IntegrationMore.agda b/Cubical/HITs/CauchyReals/IntegrationMore.agda
new file mode 100644
index 0000000000..36503b2722
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/IntegrationMore.agda
@@ -0,0 +1,1266 @@
+{-# OPTIONS --safe #-}
+
+module Cubical.HITs.CauchyReals.IntegrationMore where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Equiv.Properties
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.Powerset
+open import Cubical.Functions.FunExtEquiv
+
+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.Data.Fin
+
+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
+open import Cubical.HITs.CauchyReals.Sequence
+open import Cubical.HITs.CauchyReals.Derivative
+open import Cubical.HITs.CauchyReals.Integration
+open import Cubical.HITs.CauchyReals.Exponentiation
+open import Cubical.HITs.CauchyReals.ExponentiationDer
+open import Cubical.HITs.CauchyReals.MeanValue
+
+
+Integral'-abs≤ : ∀ a b → a ≤ᵣ b → ∀ f s s'
+            → on[ a , b ]IntegralOf f is' s
+            → on[ a , b ]IntegralOf (absᵣ ∘ f) is' s'
+            → absᵣ s ≤ᵣ s'
+Integral'-abs≤ a b a≤b f s s' ∫f ∫∣f∣ =
+ x<y+δ→x≤y _ _ λ ε →
+  PT.rec3 (isProp<ᵣ _ _) (w ε)
+   (∫f (/2₊ (/2₊ ε))) ( ∫∣f∣ (/2₊ (/2₊ ε)))
+   (∃RefinableTaggedPartition rtp-1/n a b a≤b)
+ where
+ w : (ε : ℚ₊) → Σ ℚ₊ _ → Σ ℚ₊ _ → _ →
+      absᵣ s <ᵣ s' +ᵣ rat (fst ε)
+ w ε (δ , X) (δ' , X') rtp =
+   let tp-ab , mesh-ab = tpTP δ⊓δ'
+       Y = ((isTrans≡<ᵣ _ _ _
+             (minusComm-absᵣ _ _)
+             (X tp-ab λ k →
+            isTrans≤ᵣ _ _ _
+              (mesh-ab k)
+              (≤ℚ→≤ᵣ (fst δ⊓δ')  (fst δ) (ℚ.min≤ (fst δ) (fst δ'))))))
+
+       Y' = (isTrans<≡ᵣ _ _ _
+            (a-b<c⇒a<c+b _ _ _
+            (isTrans≤<ᵣ _ _ _
+            (≤absᵣ _)
+           (X' tp-ab λ k →
+            isTrans≤ᵣ _ _ _
+              (mesh-ab k)
+              (≤ℚ→≤ᵣ (fst δ⊓δ')  (fst δ') (ℚ.min≤' (fst δ) (fst δ'))))))
+              (+ᵣComm _ _))
+
+
+       Z = riemannSum'-absᵣ≤ (snd tp-ab) f
+       ZZ = isTrans≤<ᵣ _ _ _(isTrans≤ᵣ _ _ _
+             (a-b≤c⇒a≤c+b _ _ _
+               (isTrans≤ᵣ _ _ _
+                 (absᵣ-triangle-minus _ _)
+                 (<ᵣWeaken≤ᵣ _ _ Y)))
+             (≤ᵣ-o+ _ _ (rat (fst (/2₊ (/2₊ ε))))
+              (isTrans≤ᵣ _ _ _ Z
+                (<ᵣWeaken≤ᵣ _ _ Y'))))
+             (isTrans≡<ᵣ _ _ _
+               (+ᵣComm _ _ ∙ sym (+ᵣAssoc _ _ _)
+                ∙ cong (s' +ᵣ_) (+ᵣ-rat _ _ ∙ cong rat (ℚ.ε/2+ε/2≡ε (fst (/2₊ ε)))))
+                (<ᵣ-o+ _ _ s' (<ℚ→<ᵣ _ _ (ℚ.x/2<x ε))))
+   in ZZ
+  where
+  δ⊓δ' = ℚ.min₊ δ δ'
+  open RefinableTaggedPartition[_,_] rtp
+
+
+Integral'-≤ : ∀ a b → a ≤ᵣ b → ∀ f f' s s'
+            → (∀ x → x ∈ intervalℙ a b → f x ≤ᵣ f' x)
+            → on[ a , b ]IntegralOf f is' s
+            → on[ a , b ]IntegralOf f' is' s'
+            → s ≤ᵣ s'
+Integral'-≤ a b a≤b f f' s s' f≤f' ∫f ∫f' =
+ x<y+δ→x≤y _ _ λ ε →
+  PT.rec3 (isProp<ᵣ _ _) (w ε)
+   (∫f (/2₊ (/2₊ ε))) (∫f' (/2₊ (/2₊ ε)))
+   (∃RefinableTaggedPartition rtp-1/n a b a≤b)
+ where
+ w : (ε : ℚ₊) → Σ ℚ₊ _ → Σ ℚ₊ _ → _ →
+      s <ᵣ s' +ᵣ rat (fst ε)
+ w ε (δ , X) (δ' , X') rtp =
+   let tp-ab , mesh-ab = tpTP δ⊓δ'
+       Y = a-b<c⇒a<c+b _ _ _
+           (isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+            (isTrans≡<ᵣ _ _ _
+             (minusComm-absᵣ _ _)
+             (X tp-ab λ k →
+            isTrans≤ᵣ _ _ _
+              (mesh-ab k)
+              (≤ℚ→≤ᵣ (fst δ⊓δ')  (fst δ) (ℚ.min≤ (fst δ) (fst δ'))))))
+
+       Y' = (isTrans<≡ᵣ _ _ _
+            (a-b<c⇒a<c+b _ _ _
+            (isTrans≤<ᵣ _ _ _
+            (≤absᵣ _)
+           (X' tp-ab λ k →
+            isTrans≤ᵣ _ _ _
+              (mesh-ab k)
+              (≤ℚ→≤ᵣ (fst δ⊓δ')  (fst δ') (ℚ.min≤' (fst δ) (fst δ'))))))
+              (+ᵣComm _ _))
+
+
+       Z = riemannSum'≤ (snd tp-ab) f f' (curry ∘ f≤f')
+   in isTrans<ᵣ _ _ _(isTrans<≤ᵣ _ _ _
+        Y
+        (≤ᵣ-o+ _ _ (rat (fst (/2₊ (/2₊ ε))))
+         (isTrans≤ᵣ _ _ _ Z
+           (<ᵣWeaken≤ᵣ _ _ Y'))))
+        (isTrans≡<ᵣ _ _ _
+          (+ᵣComm _ _ ∙ sym (+ᵣAssoc _ _ _)
+           ∙ cong (s' +ᵣ_) (+ᵣ-rat _ _ ∙ cong rat (ℚ.ε/2+ε/2≡ε (fst (/2₊ ε)))))
+           (<ᵣ-o+ _ _ s' (<ℚ→<ᵣ _ _ (ℚ.x/2<x ε))))
+  where
+  δ⊓δ' = ℚ.min₊ δ δ'
+  open RefinableTaggedPartition[_,_] rtp
+
+Integral'-C· : ∀ a b → a ≤ᵣ b → ∀ C f s  →
+  on[ a , b ]IntegralOf f is' s →
+  on[ a , b ]IntegralOf (λ x → C ·ᵣ f x) is' (C ·ᵣ s)
+Integral'-C· a b a≤b C f s ∫f ε =
+  PT.rec squash₁
+    (λ (C' , (absᵣC<C' , _)) →
+      let C'₊ = (C' , ℚ.<→0< C'
+               (<ᵣ→<ℚ 0 C' (isTrans≤<ᵣ 0 (absᵣ C) _ (0≤absᵣ _) absᵣC<C')))
+          ε' = ε ℚ₊· invℚ₊ C'₊
+      in PT.map
+           (map-snd (λ {δ} X tp mesh≤ →
+            isTrans≤<ᵣ _ _ _
+              (isTrans≡≤ᵣ _ _ _
+               (cong absᵣ (cong (_-ᵣ C ·ᵣ s)
+                 (riemannSum'C· (snd tp) C f)
+                ∙ sym (𝐑'.·DistR- _ _ _))
+                ∙ ·absᵣ _ _)
+               (≤ᵣ-·ᵣo _ _ _
+                 (0≤absᵣ _)
+                 (<ᵣWeaken≤ᵣ _ _ absᵣC<C')))
+              -- X tp mesh≤
+              (fst (z<x/y₊≃y₊·z<x _ _ (ℚ₊→ℝ₊ C'₊))
+                (isTrans<≡ᵣ _ _ _
+                  (X tp mesh≤)
+                  (rat·ᵣrat (fst ε) _ ∙
+                   cong (rat (fst ε) ·ᵣ_)
+                    (sym (invℝ₊-rat C'₊)))))))
+           (∫f ε'))
+    (denseℚinℝ (absᵣ C) ((absᵣ C) +ᵣ 1)
+       (isTrans≡<ᵣ _ _ _
+         (sym (+IdR _)) (<ᵣ-o+ 0 1 (absᵣ C) decℚ<ᵣ?)))
+
+Integral'-+ : ∀ a b → a ≤ᵣ b → ∀ f g s s' →
+  on[ a , b ]IntegralOf f is' s →
+  on[ a , b ]IntegralOf g is' s' →
+  on[ a , b ]IntegralOf (λ x → f x +ᵣ g x ) is' (s +ᵣ s')
+
+Integral'-+ a b x f g s s' ∫f ∫g  ε =
+ PT.map2
+  (λ (δ , X) (δ' , X') →
+    let δ⊓δ' = ℚ.min₊ δ δ'
+    in  δ⊓δ' , λ tp mesh≤  →
+      isTrans≤<ᵣ _ _ _
+        (isTrans≡≤ᵣ _ _ _
+          (cong absᵣ (
+            cong (_-ᵣ (s +ᵣ s')) (sym (riemannSum'+ (snd tp) f g))
+            ∙ L𝐑.lem--041))
+          (absᵣ-triangle _ _))
+        (isTrans<≡ᵣ _ _ _
+            (<ᵣMonotone+ᵣ _ _ _ _
+              (X tp (λ k → isTrans≤ᵣ _ _ _ (mesh≤ k) (min≤ᵣ _ (rat (fst δ')))))
+              (X' tp (λ k → isTrans≤ᵣ _ _ _ (mesh≤ k)
+               (min≤ᵣ' (rat (fst δ)) _))))
+            (+ᵣ-rat (fst (/2₊ ε)) _ ∙ cong rat (ℚ.ε/2+ε/2≡ε (fst ε)))))
+   (∫f (/2₊ ε)) (∫g (/2₊ ε))
+
+
+
+
+IsUContinuousConst : ∀ C → IsUContinuous (λ _ → C)
+IsUContinuousConst C ε = 1 , λ _ _ _ → refl∼ _ _
+
+opaque
+ unfolding absᵣ
+ IsUContinuousAbsᵣ : IsUContinuous absᵣ
+ IsUContinuousAbsᵣ = Lipschitiz→IsUContinuous 1 absᵣ (snd (absᵣL))
+
+IsUContinuous+ᵣ₂ : ∀ f g → IsUContinuous f → IsUContinuous g →
+   IsUContinuous λ x → f x +ᵣ g x
+IsUContinuous+ᵣ₂ f g fC gC ε =
+  let (δ  , X) = fC (/2₊ ε)
+      (δ' , X') = gC (/2₊ ε)
+      δ⊔δ' = ℚ.min₊ δ δ'
+  in δ⊔δ' ,
+   λ u v u∼v →
+     invEq (∼≃abs<ε _ _ _)
+      (isTrans<≡ᵣ _ _ _
+        (isTrans≤<ᵣ _ _ _
+          (isTrans≡≤ᵣ _ _ _
+            (cong absᵣ L𝐑.lem--041)
+            (absᵣ-triangle _ _))
+          (<ᵣMonotone+ᵣ _ _ _ _
+             (fst (∼≃abs<ε _ _ _) (X u v (∼-monotone≤ (ℚ.min≤ (fst δ) (fst δ')) u∼v)))
+             (fst (∼≃abs<ε _ _ _) (X' u v (∼-monotone≤ (ℚ.min≤' (fst δ) (fst δ')) u∼v) ))))
+        (+ᵣ-rat _ _ ∙ cong rat (ℚ.ε/2+ε/2≡ε (fst ε))) )
+
+IsUContinuousC·ᵣ : ∀ f → IsUContinuous f → (C : ℚ) →
+   IsUContinuous λ x → rat C ·ᵣ f x
+IsUContinuousC·ᵣ f icf C =
+  ⊎.rec
+    (λ p →
+      subst IsUContinuous
+        (funExt (λ x → sym (𝐑'.0LeftAnnihilates' _ _ (cong rat (sym p)))))
+        (IsUContinuousConst 0))
+   (λ 0＃C ε →
+      let Z = 0＃→0<abs (rat C) (invEq (rat＃ 0 C) 0＃C)
+          ∣C∣ = ℚ.abs C , ℚ.<→0< (ℚ.abs C) (<ᵣ→<ℚ 0 (ℚ.abs C)
+                 (isTrans<≡ᵣ _ _ _ Z (absᵣ-rat C)))
+          δ , X = icf (invℚ₊ ∣C∣ ℚ₊· ε)
+      in δ , λ u v u∼v →
+         let w = fst (∼≃abs<ε _ _ _) (X u v u∼v)
+         in invEq (∼≃abs<ε _ _ _)
+               (isTrans≡<ᵣ _ _ _
+                 (cong absᵣ (sym (𝐑'.·DistR- (rat C) _ _))
+                   ∙ ·absᵣ _ _ ∙ cong₂ _·ᵣ_ (absᵣ-rat C) refl )
+                 (fst (z<x/y₊≃y₊·z<x _ _ (ℚ₊→ℝ₊ ∣C∣))
+                  (isTrans<≡ᵣ _ _ _ w
+                   (rat·ᵣrat (fst (invℚ₊ ∣C∣)) _ ∙ ·ᵣComm _ _ ∙
+                    cong (rat (fst ε) ·ᵣ_)
+                    (sym (invℝ₊-rat _) ))))))
+    (ℚ.≡⊎# 0 C)
+
+IsUContinuous-ᵣ₂ : ∀ f g → IsUContinuous f → IsUContinuous g →
+   IsUContinuous λ x → f x -ᵣ g x
+IsUContinuous-ᵣ₂ f g fC gC =
+  subst IsUContinuous
+    (funExt λ x → cong (f x +ᵣ_) (sym (-ᵣ≡[-1·ᵣ] (g x))))
+    (IsUContinuous+ᵣ₂ _ _ fC (IsUContinuousC·ᵣ g gC -1))
+
+
+lim-const : ∀ x y → lim (const x) y ≡ x
+lim-const = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop _
+ w .Elimℝ-Prop.ratA x _ =
+   eqℝ _ _ λ ε →
+     lim-rat _ _ _ (/2₊ ε) _ _ (refl∼ _ (ℚ.<→ℚ₊ (fst (/2₊ ε)) (fst ε) (ℚ.x/2<x ε)) )
+ w .Elimℝ-Prop.limA x p x₁ y =
+   eqℝ _ _ λ ε →
+     lim-lim _ _ _ (/2₊ (/2₊ ε)) (/2₊ (/2₊ ε)) _ _
+       (subst 0<_
+          (cong (ℚ._-_ (fst ε)) (sym (ℚ.ε/2+ε/2≡ε (fst (/2₊ ε)))))
+          (snd (ℚ.<→ℚ₊ (fst (/2₊ ε)) (fst ε) (ℚ.x/2<x ε))))
+       (sym∼ _ _ _
+        (𝕣-lim' _ _ _ (/2₊ (/2₊ ε)) _
+        (snd ((ℚ.<→ℚ₊ (fst (/2₊ (/2₊ ε))) (fst ε ℚ.- (fst (/2₊ (/2₊ ε)) ℚ.+ fst (/2₊ (/2₊ ε))))
+         ((subst {x = fst (/2₊ ε)} (fst (/2₊ (/2₊ ε)) ℚ.<_)
+           (sym (𝐐'.plusMinus _ _) ∙ cong₂ (ℚ._-_) (ℚ.ε/2+ε/2≡ε (fst ε)) (sym (ℚ.ε/2+ε/2≡ε (fst (/2₊ ε)))) )
+            (ℚ.x/2<x (/2₊ ε)))))))
+         (refl∼ _ _)))
+ w .Elimℝ-Prop.isPropA _ = isPropΠ λ _ → isSetℝ _ _
+
+⊎-map-comm-ids : {A B A' B' : Type} (f : A → A') (g : B → B') →
+    ∀ x → ⊎.map f (idfun _) (⊎.map (idfun _) g x) ≡
+            ⊎.map (idfun _) g (⊎.map f (idfun _) x)
+⊎-map-comm-ids f g (inl x) = refl
+⊎-map-comm-ids f g (inr x) = refl
+
+concatTaggedPartition : ∀ a b c → a ≤ᵣ b → b ≤ᵣ c
+                → (tp-ab : TaggedPartition[ a , b ])
+                → (tp-bc : TaggedPartition[ b , c ])
+                → Σ[ tp-ac ∈ TaggedPartition[ a , c ] ]
+                  ((∀ f → riemannSum' (snd tp-ab) f +ᵣ riemannSum' (snd tp-bc) f ≡
+                          riemannSum' (snd tp-ac) f)
+                  × (∀ δ → mesh≤ᵣ (fst tp-ab) δ → mesh≤ᵣ (fst tp-bc) δ → mesh≤ᵣ (fst tp-ac) δ ))
+concatTaggedPartition a b c a≤b b≤c (p-ab , s-ab) (p-bc , s-bc) =
+
+  (w , w') , w'' , w'''
+
+ where
+
+
+ module ctp-hlp₀ (n : ℕ) where
+
+  F→⊎' = ⊎.map (idfun _) (Fin+→⊎ 1 (suc (p-bc .len)))
+  F→⊎'' = Fin+→⊎ (suc n) (suc (suc (p-bc .len)))
+  F→⊎ = F→⊎' ∘ F→⊎''
+
+  F→⊎* = (compIso (Iso-Fin+⊎ _ _) (⊎.⊎Iso' idIso (Iso-Fin+⊎ _ _)))
+
+ F→⊎≡iso : ∀ n x → ctp-hlp₀.F→⊎ n x
+          ≡ Iso.fun (ctp-hlp₀.F→⊎* n) x
+ F→⊎≡iso zero (zero , l , p) = refl
+ F→⊎≡iso zero (suc k , l , p) = refl
+ F→⊎≡iso (suc n) (zero , l , p) = refl
+ F→⊎≡iso (suc n) (suc k , l , p) =
+   let z = F→⊎≡iso n (k , l , injSuc (sym (+-suc _ _) ∙ p))
+   in sym (⊎-map-comm-ids _  _ _) ∙ cong (⊎.map fsuc (idfun _)) z
+       ∙ ⊎-map-comm-ids _  _ _
+
+
+ module ctp-hlp (n : ℕ)
+                (u : Fin (suc n) → Σ[ p ∈ ℝ ] (a ≤ᵣ p) × (p ≤ᵣ b))
+                (u≤u : ∀ (k : Fin n) → fst (u (finj k)) ≤ᵣ fst (u (fsuc k)))
+                  where
+  open ctp-hlp₀ n public
+  pts⊎ : Fin (suc n) ⊎ (Fin 1 ⊎ Fin (suc (len p-bc))) →
+    Σ[ p ∈ ℝ ] (a ≤ᵣ p) × (p ≤ᵣ c)
+  pts⊎ = ⊎.rec (map-snd (map-snd
+    (flip (isTrans≤ᵣ _ _ _) b≤c)) ∘ u)
+    (⊎.rec (λ _ → b , a≤b , b≤c)
+     λ x → p-bc .pts x ,
+       isTrans≤ᵣ _ _ _ a≤b (p-bc .a≤pts x) , p-bc .pts≤b x)
+
+
+
+
+  -- isEquivF→⊎ : isEquiv F→⊎
+  -- isEquivF→⊎ = isoToIsEquiv
+  --   (iso _ (⊎.rec injectFin+' (injectFin+ {n = suc n} ∘ ⊎.rec (λ _ → fzero) fsuc))
+  --     (⊎.elim (λ a → {!!}) (⊎.elim {!!} {!!}))
+  --     {!!})
+
+  pts* = pts⊎ ∘ F→⊎
+
+  -- module ctp-hlp' (sa : Fin (suc (suc n)) →  ℝ) where
+  --  sa⊎ : Fin (suc (suc n)) ⊎ Fin (suc (suc (len p-bc))) → ℝ
+  --  sa⊎ = ⊎
+   -- (inl x) = sa x
+   -- sa⊎ (inr x) = samples s-bc x
+
+
+ -- F→⊎-inl-N : ∀ n u u≤u l p → ctp-hlp.F→⊎ n u u≤u ({!!}) ≡ inr (inl fzero)
+ -- F→⊎-inl-N n u u≤u l p = {!!}
+
+
+
+ pts⊎-suc' : ∀ n u u≤u v → fst (ctp-hlp.pts⊎ n (λ z → u (fsuc z))
+         (subst2 (λ k₁ k' → fst (u k₁) ≤ᵣ fst (u k')) (toℕ-injective refl)
+          (toℕ-injective refl)
+          ∘ u≤u ∘ fsuc) v)
+      ≡ fst (ctp-hlp.pts⊎ (suc n) u u≤u (⊎.map fsuc (idfun (Fin 1 ⊎ Fin (suc (len p-bc)))) v))
+ pts⊎-suc' n u u≤u (inl x) = refl
+ pts⊎-suc' n u u≤u (inr (inl x)) = refl
+ pts⊎-suc' n u u≤u (inr (inr x)) = refl
+
+ pts⊎-suc : ∀ n k u u≤u →
+    fst ((ctp-hlp.pts* n
+       (u ∘ fsuc)
+       (subst2 (λ k k' →
+      fst (u k) ≤ᵣ fst (u k'))
+      (toℕ-injective refl)
+      (toℕ-injective refl)
+      ∘ u≤u ∘ fsuc)
+      k)) ≡ fst ((ctp-hlp.pts* (suc n) u u≤u (fsuc k)))
+
+ pts⊎-suc n k*@(k , l , p) u u≤u =
+   pts⊎-suc' n u u≤u (P.F→⊎ k*) ∙
+     cong (fst ∘ P'.pts⊎)
+      (⊎-map-comm-ids _ _ _ ∙
+        congS (λ p → ⊎.map (λ x → x) (Fin+→⊎ 1 (suc (len p-bc)))
+      (⊎.map fsuc (λ x → x)
+       (Fin+→⊎ (suc n) (suc (suc (len p-bc))) (k , l , p))))
+       (isSetℕ _ _ _ _))
+
+  where
+
+  module P = ctp-hlp n (λ z → u (fsuc z))
+         (subst2 (λ k₁ k' → fst (u k₁) ≤ᵣ fst (u k')) (toℕ-injective refl)
+          (toℕ-injective refl)
+          ∘ u≤u ∘ fsuc)
+
+  module P' = ctp-hlp (suc n) u u≤u
+
+
+
+ pts⊎≤pts⊎ : ∀ n u u≤u k → fst (ctp-hlp.pts* n u u≤u (finj k))
+     ≤ᵣ fst (ctp-hlp.pts* n u u≤u (fsuc k))
+ pts⊎≤pts⊎ zero u _ (zero , k) = snd (snd (u fzero))
+ pts⊎≤pts⊎ zero u _ (suc zero , fst₂ , snd₁) = a≤pts p-bc _
+ pts⊎≤pts⊎ zero u _ k*@(suc (suc k) , l , p) =
+  let k# : Fin (len p-bc)
+      k# = (k , l
+        ,  cong predℕ (sym (ℕ.+-suc l  (suc k))
+           ∙ cong predℕ ((sym (ℕ.+-suc l (suc (suc k)))) ∙ p)))
+  in subst2 (λ k k' →
+      pts p-bc k ≤ᵣ pts p-bc k')
+       (toℕ-injective refl)
+       (toℕ-injective refl)
+       (pts≤pts p-bc k#)
+ pts⊎≤pts⊎ (suc n) u u≤u (zero , l , p) =
+   subst2 (λ k k' →
+      fst (u k) ≤ᵣ fst (u k'))
+      (toℕ-injective refl)
+      (toℕ-injective refl)
+       (u≤u fzero)
+ pts⊎≤pts⊎ (suc n) u u≤u (suc k , l , p) =
+   subst2 _≤ᵣ_
+     (pts⊎-suc n (finj k*) u u≤u
+       ∙ cong (fst ∘ ctp-hlp.pts* (suc n) u u≤u)
+          (toℕ-injective {fj = fsuc (finj k*)} {finj (suc k , l , p)} refl))
+       (pts⊎-suc n (fsuc k*) u u≤u
+       ∙ cong (fst ∘ ctp-hlp.pts* (suc n) u u≤u)
+          (toℕ-injective {fj = (fsuc (fsuc k*))} {(fsuc (suc k , l , p))} refl))
+      w
+  where
+  k* : Fin ((n ℕ.+ (suc (suc (len p-bc)))))
+  k* = k , l , cong predℕ (sym (ℕ.+-suc l (suc k)) ∙ p)
+
+  w = pts⊎≤pts⊎ n (u ∘ fsuc)
+    (subst2 (λ k k' →
+      fst (u k) ≤ᵣ fst (u k'))
+      (toℕ-injective refl)
+      (toℕ-injective refl)
+      ∘ u≤u ∘ fsuc) k*
+
+ open ctp-hlp (p-ab .len) (λ k → p-ab .pts k , p-ab .a≤pts k , p-ab .pts≤b k)
+       (pts≤pts p-ab)
+
+
+ -- open ctp-hlp' (samples s-ab)
+
+ w : Partition[ a , c ]
+ w .len = (p-ab .len ℕ.+ suc (suc (p-bc .len)))
+ w .pts = fst ∘ pts*
+ w .a≤pts = fst ∘ snd ∘ pts*
+ w .pts≤b = snd ∘ snd ∘ pts*
+ w .pts≤pts = pts⊎≤pts⊎ _ _ (p-ab .pts≤pts)
+
+
+ pts'-inl* : ∀ x → pts p-ab x ≡ pts w (injectFin+' x)
+ pts'-inl* x = cong
+   (fst ∘ pts⊎ ∘ F→⊎')
+   (Fin+→⊎∘injectFin+' _ _ x)
+
+
+ pts'-inl : ∀ (x : Fin (3 ℕ.+ len p-ab)) → pts' p-ab x ≡ pts' w (injectFin+' x)
+ pts'-inl (zero , zero , p) = ⊥.rec (ℕ.znots (cong predℕ p))
+ pts'-inl (zero , suc l , p) = refl
+ pts'-inl x@(suc k , zero , p) =
+  cong {x = inr fzero}
+        {y = F→⊎'' pK}
+        (fst ∘ pts⊎ ∘ F→⊎')
+          (injectFin+'-flast-S _ _ _ (snd (snd pK)))
+
+  where
+
+  pK = (k , suc (len p-bc) , _)
+
+ pts'-inl (suc k , l@(suc _) , p) =
+  let k' = injectFin+' (suc k , l , p)
+    in (pts'-inl* _ ∙
+     cong (λ ll → fst
+      (pts⊎
+       (⊎.map (λ x → x) (Fin+→⊎ 1 (suc (len p-bc)))
+        (Fin+→⊎ (suc (len p-ab)) (suc (suc (len p-bc)))
+         (k , ll)))))
+         (cong snd (toℕ-injective refl))) ∙
+     cong (pts' w)
+       (toℕ-injective
+        {fj = suc k , (suc (suc (len p-bc))) ℕ.+ l ,
+          (cong (ℕ._+ suc (suc k))
+            (ℕ.+-comm (suc (suc (len p-bc))) l)) ∙ snd (snd k')}
+        {fk = k'}
+         refl)
+
+ pts'-inr : ∀ (x : Fin (3 ℕ.+ len p-bc)) x<' → pts' p-bc x ≡
+   pts' w (
+     fst (injectFin+ {suc (suc (suc (len p-bc)))}
+      {suc (suc (len p-ab))}
+      x)
+     , x<')
+
+ pts'-inr (zero , zero , p) (zero , snd₁) = ⊥.rec (znots (injSuc p))
+ pts'-inr (suc k , zero , p) (zero , snd₁) = refl
+ pts'-inr (k , zero , p) (suc k' , p') =
+   ⊥.rec (snotz (inj-+m {suc k'} {_} {zero} p''))
+   where
+   p'' = p' ∙
+     cong (λ x → suc (suc (suc (len p-ab ℕ.+ x))))
+      (sym (injSuc p))
+ pts'-inr (zero , suc l , p) (zero , p') =
+   ⊥.rec (znots (inj-m+ {suc (suc (suc (len p-ab)))} {0} p'))
+ pts'-inr (zero , suc l , p) (suc k' , p') =
+   pts'-inl flast ∙
+     cong (pts' w)
+       (toℕ-injective
+         {_}
+          {injectFin+' {suc (suc (len p-bc))}
+           {n = suc (suc (suc (len p-ab)))} flast}
+          {(fst (injectFin+ (zero , suc l , p)) , suc k' , p')}
+         (injectFin+'-flast≡injectFin+-fzero
+         (suc (suc (len p-ab))) (suc (suc (len p-bc)))))
+
+ pts'-inr (suc k , suc l , p) (zero , p') =
+   ⊥.rec (znots $
+    inj-+m {0} {k} {suc l}
+     (injSuc (p'' ∙ (sym (injSuc p)) ∙ +-suc l (suc k)) ∙ +-suc l k))
+   where
+   p'' = inj-m+ {suc (suc (suc (len p-ab)))} p'
+ pts'-inr (suc k , suc l , p) (suc k' , p') =
+   cong {x = inr (inr _)}
+     {F→⊎ (suc (len p-ab) ℕ.+ suc k , k' , _)}
+     (fst ∘ pts⊎)
+     ((sym (Iso.rightInv F→⊎* _) ∙
+      cong (Iso.fun F→⊎*) (toℕ-injective refl))
+        ∙ sym (F→⊎≡iso (len p-ab) _))
+
+  where
+  module H = Iso (compIso
+      (Iso-Fin+⊎ (suc (len p-ab)) (suc (suc (len p-bc))))
+      (⊎.⊎Iso (idIso {A = Fin (suc (len p-ab))})
+             (Iso-Fin+⊎ 1 (suc (len p-bc)))))
+
+ <w' : ∀ x → pts' w (finj (Iso.inv (Iso-Fin+⊎ _ _) x)) ≤ᵣ
+      ⊎.rec (samples s-ab) (samples s-bc)
+       x
+ <w' (inl x) = isTrans≡≤ᵣ _ _ _
+   (cong (pts' w) (finj∘inj' x)
+    ∙ sym (pts'-inl (finj x)))
+   (pts'≤samples s-ab x)
+ <w' (inr x) = isTrans≡≤ᵣ _ _ _
+     (cong (pts' w) (finj∘inj {2 ℕ.+ len p-ab} x
+      (snd (finj (injectFin+ {n = 2 ℕ.+ len p-ab} x))))
+       ∙ sym (pts'-inr (finj x)
+       ((snd (finj (injectFin+ {n = 2 ℕ.+ len p-ab} x))))))
+     (pts'≤samples s-bc x)
+
+
+ w'< : ∀ x → ⊎.rec (samples s-ab) (samples s-bc) x ≤ᵣ
+     pts' w (fsuc (Iso.inv (Iso-Fin+⊎ _ _) x))
+
+
+ w'< (inl x) =
+   isTrans≤≡ᵣ _ _ _
+     (samples≤pts' s-ab x)
+     (pts'-inl (fsuc x) ∙
+       cong (pts' w) (sym (fsuc∘inj' x)))
+ w'< (inr x) = isTrans≤≡ᵣ _ _ _
+   (samples≤pts' s-bc x)
+     (pts'-inr (fsuc x) h ∙
+       cong (pts' w) (sym (fsuc∘inj x
+        h))  )
+   where
+    h =
+       subst (ℕ._<
+      suc (suc (suc (len p-ab ℕ.+ suc (suc (len p-bc))))))
+       (cong (suc ∘ suc) (sym (+-suc _ _)))
+        (snd (fsuc (injectFin+ {n = 2 ℕ.+ len p-ab} x)))
+
+ w' : Sample w
+ w' .samples = ⊎.rec (samples s-ab) (samples s-bc) ∘ Fin+→⊎ _ _
+ w' .pts'≤samples x =  isTrans≡≤ᵣ _ _ _
+   (cong (pts' w ∘ finj)
+     (sym (Iso.leftInv (Iso-Fin+⊎ (suc (suc (p-ab .len))) _) x)))
+     (<w' (Iso.fun (Iso-Fin+⊎ _ _) x))
+ w' .samples≤pts' x =
+   isTrans≤≡ᵣ _ _ _ (w'< (Iso.fun (Iso-Fin+⊎ _ _) x))
+     ((cong (pts' w ∘ fsuc)
+     (Iso.leftInv (Iso-Fin+⊎ (suc (suc (p-ab .len))) _) x)))
+
+ w'' : (f : ℝ → ℝ) →
+        riemannSum' s-ab f +ᵣ riemannSum' s-bc f ≡ riemannSum' w' f
+ w'' f =
+   cong₂ _+ᵣ_
+     (riemannSum'-alt-lem s-ab f ∙
+      congS {A = Fin (suc (suc ( len p-ab))) → ℝ}
+
+        (λ f → foldlFin {n = suc (suc ( len p-ab))}
+          (λ S k →
+           S +ᵣ f k) (rat 0)
+           (idfun _))
+       (funExt λ x → cong₂ _·ᵣ_
+         (cong₂ _-ᵣ_
+           (pts'-inl (fsuc x) ∙
+             cong {x = (injectFin+' (fsuc x))}
+                   {(fsuc (injectFin+' x))} (pts' w)
+                   (toℕ-injective refl))
+           ((pts'-inl (finj x) ∙
+             cong {x = (injectFin+' (finj x))}
+                   {(finj (injectFin+' x))} (pts' w)
+                   (toℕ-injective refl))))
+         (cong f (sym (rec⊎-injectFin+' (fst ∘ samplesΣ s-ab) _ x) ))))
+     (riemannSum'-alt-lem s-bc f ∙
+       congS {A = Fin (suc (suc ( len p-bc))) → ℝ}
+
+        (λ f → foldlFin {n = suc (suc ( len p-bc))}
+          (λ S k →
+           S +ᵣ f k) (rat 0)
+           (idfun _))
+           (funExt λ x → cong₂ _·ᵣ_
+         (cong₂ _-ᵣ_
+           (pts'-inr (fsuc x)
+             (x< x)
+             ∙ sym (cong (pts' w) (fsuc∘inj x (x< x))))
+           (pts'-inr (finj x) (x<' x) ∙
+              sym (cong (pts' w)
+                (finj∘inj {n = 2 ℕ.+ len p-ab}  x (x<' x)))))
+         (cong f (sym (rec⊎-injectFin+ (fst ∘ samplesΣ s-ab) _ x))))) ∙∙
+     sym (foldFin-sum-concat
+      (suc (suc (len p-ab)))
+      (suc (suc (len p-bc))) _)
+   ∙∙ sym (riemannSum'-alt-lem w' f)
+   where
+   x< : (x : Fin (suc (suc (len p-bc)))) →
+         _ ℕ.< _
+   x< k =
+     subst (suc (suc (len p-ab ℕ.+ fst (fsuc k))) ℕ.<_)
+       (cong (suc ∘ suc) (+-suc _ _))
+       (ℕ.<-k+ {k = suc (suc (len p-ab))} (ℕ.<-k+ {k = 1} (snd k)))
+
+   x<' : (x : Fin (suc (suc (len p-bc)))) →
+         _ ℕ.< _
+   x<' k = subst (suc (suc (len p-ab ℕ.+ fst (finj k))) ℕ.<_)
+       (cong (suc ∘ suc) (+-suc _ _))
+       (ℕ.<-k+ {k = suc (suc (len p-ab))} (ℕ.≤-suc (snd k)))
+
+
+
+ ⊎suc ⊎inj : Fin (suc (suc (len p-ab))) ⊎ (Fin 1 ⊎ Fin (suc (len p-bc)))
+        → Fin (suc (suc (suc (len p-ab)))) ⊎ (Fin (suc (suc (len p-bc))))
+ ⊎suc = ⊎.rec (inl ∘ fsuc) (inr ∘ ⊎.rec (λ _ → fzero) (fsuc))
+ ⊎inj = ⊎.rec (inl ∘ finj) (⊎.rec (λ _ → inl flast) (inr ∘ finj))
+ -- ⊎.rec (inl ∘ finj)
+ --   (⊎.rec (λ _ → inl flast) (inr ∘ Fin+→⊎ 1 (suc (len p-bc)) ∘ finj))
+
+ ⊎→F''' : Fin (suc (suc (suc (len p-ab)))) ⊎ Fin (suc (suc (len p-bc))) →
+           Fin (suc (suc (suc (len p-ab))) ℕ.+ suc (suc (len p-bc)))
+ ⊎→F''' = Iso.inv (Iso-Fin+⊎ (suc (suc (suc (len p-ab)))) _)
+ w'''-⊎ : (δ : ℝ) → mesh≤ᵣ p-ab δ → mesh≤ᵣ p-bc δ →
+         ∀ k → (pts' w
+           (⊎→F''' (⊎suc k) ))
+            -ᵣ (pts' w (⊎→F''' (⊎inj k))) ≤ᵣ δ
+ w'''-⊎ δ me me' (inl x) =
+    isTrans≡≤ᵣ _ _ _
+      (cong₂ _-ᵣ_
+           (sym (pts'-inl (fsuc x)))
+           (sym (pts'-inl (finj x))))
+      (me x)
+ w'''-⊎ δ me me' (inr (inl x)) =
+    isTrans≡≤ᵣ _ _ _
+      (cong₂ _-ᵣ_
+           (cong {x = injectFin+ {n = suc (suc (suc (len p-ab)))} fzero}
+                 {fst (injectFin+ {suc (suc (len p-bc))}
+                  {n = suc (suc (len p-ab))} (fsuc fzero))
+                  , h} (pts' w)
+                   (toℕ-injective (cong (2 ℕ.+_) (sym (+-suc _ _))))
+             ∙ sym (pts'-inr (fsuc fzero)
+            (h)))
+           (sym (pts'-inl flast)))
+      (me' fzero)
+    where
+    h : _
+    h = snd $ finj (injectFin+ {suc (suc (len p-bc))} {n = suc (suc (len p-ab))}
+         (fsuc fzero))
+
+ w'''-⊎ δ me me' (inr (inr x)) =
+
+    isTrans≡≤ᵣ _ _ _
+      (cong₂ _-ᵣ_
+           (cong (pts' w) p1 ∙ sym (pts'-inr (fsuc (fsuc x))
+             (subst (suc (suc (len p-ab ℕ.+ fst (fsuc (fsuc x)))) ℕ.<_)
+       (cong (suc ∘ suc) (+-suc _ _))
+       (ℕ.<-k+ {k = suc (suc (len p-ab))} (ℕ.<-k+ {k = 2} (snd x))))))
+           (cong (pts' w) p2
+            ∙ sym (pts'-inr (finj (fsuc x))
+             (subst (suc (suc (len p-ab ℕ.+ fst (finj (fsuc x)))) ℕ.<_)
+       (cong (suc ∘ suc) (+-suc _ _))
+       (ℕ.<-k+ {k = suc (suc (len p-ab))} (ℕ.≤-suc (snd (fsuc x))))))))
+      (me' (fsuc x))
+   where
+    p1 : (⊎→F''' (⊎suc (inr (inr x)))) ≡
+        (fst (injectFin+ {suc (suc (suc (len p-bc)))} {suc (suc (len p-ab))}
+         (fsuc (fsuc x))) ,
+       subst (suc (suc (len p-ab ℕ.+ fst (fsuc (fsuc x)))) ℕ.<_)
+       (λ i → suc (suc (+-suc (len p-ab) (suc (suc (len p-bc))) i)))
+       (ℕ.<-k+ {2 ℕ.+ x .fst} {k = suc (suc (len p-ab))}
+          (ℕ.<-k+ {x .fst} (snd x))))
+    p1 = toℕ-injective (cong (suc ∘ suc) (sym (+-suc _ _)))
+
+    p2 :  (⊎→F''' (⊎inj (inr (inr x)))) ≡
+
+           (fst (injectFin+ {suc (suc (suc (len p-bc)))} {suc (suc (len p-ab))}
+              (finj (fsuc x))) ,
+            subst (suc (suc (len p-ab ℕ.+ fst (finj (fsuc x)))) ℕ.<_)
+            (λ i → suc (suc (+-suc (len p-ab) (suc (suc (len p-bc))) i)))
+            (ℕ.<-k+ {k = suc (suc (len p-ab))}
+             (ℕ.≤-suc (snd (fsuc x)))))
+    p2 = toℕ-injective (cong (suc ∘ suc) (sym (+-suc _ _)))
+
+ module F→⊎''' =
+   Iso (compIso (Iso-Fin+⊎ (suc (suc (len p-ab))) (suc (suc (len p-bc))))
+          (⊎.⊎Iso idIso
+             (Iso-Fin+⊎ 1 _)))
+
+-- (Fin (suc (suc (len p-ab)) ℕ.+ (suc (suc (len p-bc)))))
+--         (Fin (suc (suc (len p-ab))) ⊎ (Fin 1 ⊎ Fin (suc (len p-bc))))
+
+--  F→⊎''' = {!!}
+
+
+ w'''-F→⊎→F-fsuc : ∀ k → fsuc (F→⊎'''.inv k) ≡ ⊎→F''' (⊎suc k)
+ w'''-F→⊎→F-fsuc (inl x) = toℕ-injective refl
+ w'''-F→⊎→F-fsuc (inr (inl (k , l , p))) =
+  toℕ-injective
+   (cong (λ k → suc (suc (suc (len p-ab ℕ.+ k))))
+    (snd (m+n≡0→m≡0×n≡0 {l} {k} (injSuc (sym (+-suc l k) ∙ p)))))
+ w'''-F→⊎→F-fsuc (inr (inr x)) = toℕ-injective refl
+
+ w'''-F→⊎→F-finj : ∀ k → finj (F→⊎'''.inv k) ≡ ⊎→F''' (⊎inj k)
+ w'''-F→⊎→F-finj (inl x) = toℕ-injective refl
+ w'''-F→⊎→F-finj (inr (inl (k , l , p))) =
+  toℕ-injective (cong (suc ∘ suc)
+   (cong (len p-ab ℕ.+_) ((snd (m+n≡0→m≡0×n≡0 {l} {k}
+    (injSuc (sym (+-suc l k) ∙ p)))))
+    ∙ +-zero _))
+ w'''-F→⊎→F-finj (inr (inr x)) = toℕ-injective
+  (cong (2 ℕ.+_) (+-suc _ _))
+
+
+ w''' : (δ : ℝ) → mesh≤ᵣ p-ab δ → mesh≤ᵣ p-bc δ →
+         ∀ k → pts' w (fsuc k) -ᵣ pts' w (finj k) ≤ᵣ δ
+ w''' δ me me' k =
+   isTrans≡≤ᵣ _ _ _
+     (cong₂ _-ᵣ_
+       (cong (pts' w) (cong fsuc (sym (F→⊎'''.leftInv k))
+        ∙ w'''-F→⊎→F-fsuc (F→⊎'''.fun k)))
+       (cong (pts' w) (cong finj (sym (F→⊎'''.leftInv k))
+        ∙ w'''-F→⊎→F-finj (F→⊎'''.fun k))))
+     (w'''-⊎ δ me me' (F→⊎'''.fun k))
+
+
+Integral'-additive : ∀ a b c → a ≤ᵣ b → b ≤ᵣ c → ∀ f s s' s+s' →
+  on[ a , b ]IntegralOf f is' s →
+  on[ b , c ]IntegralOf f is' s' →
+  on[ a , c ]IntegralOf f is' s+s' →
+  s +ᵣ s' ≡ s+s'
+
+
+Integral'-additive a b c a≤b b≤c f s s' s+s' S S' S+S' =
+  eqℝ _ _ (invEq (∼≃abs<ε _ _ _) ∘ w)
+
+ where
+ w : (ε : ℚ₊) → absᵣ (s +ᵣ s' +ᵣ -ᵣ s+s') <ᵣ rat (fst ε)
+ w ε =
+   PT.rec3
+    (isProp<ᵣ _ _)
+    (λ (δ , X) (δ' , X') (δ'' , X'') →
+      PT.rec2 (isProp<ᵣ _ _)
+        (λ Y Y' →
+          let δ⊓δ' = ℚ.min₊ (ℚ.min₊ δ δ') δ''
+              tp-ab , mesh-ab = RefinableTaggedPartition[_,_].tpTP  Y δ⊓δ'
+              tp-bc , mesh-bc = RefinableTaggedPartition[_,_].tpTP Y' δ⊓δ'
+
+              tp-ac , rs+ , mesh-ac  = concatTaggedPartition a b c a≤b b≤c
+                     tp-ab tp-bc
+              R = X'' tp-ac λ k →
+                   isTrans≤ᵣ _ _ _
+                     (mesh-ac (rat (fst δ⊓δ')) mesh-ab mesh-bc k)
+                     (≤ℚ→≤ᵣ _ _ ((ℚ.min≤' (fst (ℚ.min₊ δ δ')) (fst δ''))))
+          in isTrans<ᵣ _ _ _
+                (isTrans≤<ᵣ _ _ _
+                  (isTrans≡≤ᵣ _ _ _
+                   (cong absᵣ
+                     ( sym (𝐑'.+IdR' _ _ (𝐑'.+InvR' _ _ (sym (rs+ f))))
+                      ∙ L𝐑.lem--066
+                     ∙ cong₂ _+ᵣ_ L𝐑.lem--041 refl
+                     ))
+                  (isTrans≤ᵣ _ _ _
+                   (absᵣ-triangle _ _)
+                   (≤ᵣ-+o _ _ _ (absᵣ-triangle _ _))))
+                  (<ᵣMonotone+ᵣ _ _ _ _
+                   (<ᵣMonotone+ᵣ _ _ _ _
+                    (isTrans≡<ᵣ _ _ _
+                     (minusComm-absᵣ _ _)
+                     (X tp-ab (λ k →
+                     isTrans≤ᵣ _ _ _ (mesh-ab k)
+                       (≤ℚ→≤ᵣ _ _
+                         ((ℚ.isTrans≤ (fst δ⊓δ') _ (fst δ)
+                         (ℚ.min≤ (ℚ.min (fst δ) (fst δ')) (fst δ''))
+                         (ℚ.min≤ (fst δ) (fst δ'))))) )))
+                    (isTrans≡<ᵣ _ _ _
+                     (minusComm-absᵣ _ _)
+                     (X' tp-bc (λ k →
+                     isTrans≤ᵣ _ _ _ (mesh-bc k) (≤ℚ→≤ᵣ _ _
+                       (ℚ.isTrans≤ (fst δ⊓δ') _ (fst δ')
+                         (ℚ.min≤ (ℚ.min (fst δ) (fst δ')) (fst δ''))
+                         (ℚ.min≤' (fst δ) (fst δ')))) ))))
+                   R
+                   ))
+                (isTrans<≡ᵣ _ _ _ (isTrans≡<ᵣ _ _ _
+                  (cong₂ _+ᵣ_
+                    (+ᵣ-rat _ _ ∙ cong rat (ℚ.ε/2+ε/2≡ε (fst (/2₊ ε))))
+                    (cong rat (sym (ℚ.·Assoc (fst ε) _ _)))
+                    ∙ +ᵣ-rat _ _
+                    ∙ cong rat
+                      (sym (ℚ.·DistL+ (fst ε) _ _)))
+                  (<ℚ→<ᵣ _ _
+                    (ℚ.<-o· _ _ (fst ε) (ℚ.0<ℚ₊ ε)
+                       (ℚ.decℚ<?
+                        {[ pos 1 / 1+ 1 ]
+                         ℚ.+ [ pos 1 / 1+ 1 ] ℚ.· [ pos 1 / 1+ 1 ]}
+                         {1}) )))
+                     (cong rat (ℚ.·IdR (fst ε)))))
+        (∃RefinableTaggedPartition rtp-1/n a b a≤b )
+        (∃RefinableTaggedPartition rtp-1/n b c b≤c))
+    (S (/2₊ (/2₊ ε))) (S' (/2₊ (/2₊ ε))) (S+S' (/2₊ (/2₊ ε)))
+
+Integral'-empty : ∀ a → ∀ f s →
+  on[ a , a ]IntegralOf f is' s →
+  s ≡ 0
+Integral'-empty a f s ∫f =
+  sym (𝐑'.plusMinus s s)
+   ∙∙ cong (_-ᵣ s)
+   (Integral'-additive a a a (≤ᵣ-refl a) (≤ᵣ-refl a) f s s s
+    ∫f ∫f ∫f )
+  ∙∙ +-ᵣ s
+
+
+module IntegrationUC
+ (rtpℚ : ∀ (A B : ℚ) → A ℚ.≤ B
+    → RefinableTaggedPartition[ rat A , rat B ] ) where
+
+
+ module _ (a b : ℝ) (a≤b : a ≤ᵣ b) where
+
+
+  Integrate-UContinuous' : ∀ f → IsUContinuous f →
+   Σ[ (A , B) ∈ (ℚ × ℚ) ] (rat A ≤ᵣ a) × (b ≤ᵣ rat B) → Σ ℝ λ R → on[ a , b ]IntegralOf f is' R
+  Integrate-UContinuous' f ucf ((A , B) , A≤a , b≤B) =
+        IntegralOfUContinuous , isIntegralOfUContinuous
+   where
+   clamped-pts =
+    (clamp-RefinableTaggedPartition
+             _ _ a b a≤b
+              (A≤a , (isTrans≤ᵣ _ _ _ a≤b b≤B))
+              (isTrans≤ᵣ _ _ _ A≤a a≤b , b≤B)
+             (rtpℚ A B
+               (≤ᵣ→≤ℚ _ _ (isTrans≤ᵣ _ _ _
+                 (isTrans≤ᵣ _ _ _ A≤a a≤b)
+                   b≤B))))
+   open PreIntegration a b a≤b A B A≤a b≤B clamped-pts f ucf
+
+  preIntegrate-UContinuous : ∀ f → IsUContinuous f
+   → ∃[ (A , B) ∈ (ℚ × ℚ) ] (rat A ≤ᵣ a) × (b ≤ᵣ rat B)
+   → Σ ℝ λ R → on[ a , b ]IntegralOf f is' R
+  preIntegrate-UContinuous f ucf =
+    PT.rec {A = Σ[ (A , B) ∈ (ℚ × ℚ) ] (rat A ≤ᵣ a) × (b ≤ᵣ rat B)}
+     (IntegratedProp a b a≤b f)
+     (Integrate-UContinuous' f ucf)
+
+  opaque
+   Integrate-UContinuous : ∀ f → IsUContinuous f →
+    Σ ℝ λ R → on[ a , b ]IntegralOf f is' R
+   Integrate-UContinuous f ucf = preIntegrate-UContinuous f ucf
+      (∃enclosingℚInterval a b)
+
+
+
+   IntegralConst : ∀ C fc
+      → fst (Integrate-UContinuous (λ _ → C) fc) ≡ (C ·ᵣ (b -ᵣ a))
+   IntegralConst C fc =
+    PT.elim
+      (λ q → isSetℝ
+        (fst (PT.rec {A = Σ[ (A , B) ∈ (ℚ × ℚ) ] (rat A ≤ᵣ a) × (b ≤ᵣ rat B)}
+      (IntegratedProp a b a≤b (λ _ → C))
+      (Integrate-UContinuous' (λ _ → C) fc) q))
+        ((C ·ᵣ (b -ᵣ a)) ))
+        AA
+      (∃enclosingℚInterval a b)
+    where
+    AA : (x : Σ[ (A , B) ∈ (ℚ × ℚ) ] (rat A ≤ᵣ a) × (b ≤ᵣ rat B)) →
+          fst
+          (PT.rec (IntegratedProp a b a≤b (λ _ → C))
+           (Integrate-UContinuous' (λ _ → C) fc) ∣ x ∣₁)
+          ≡ C ·ᵣ (b -ᵣ a)
+    AA ((A , B) , A≤a , b≤B) =
+      congLim' _ _ _ (λ ε →
+         Partition[_,_].riemannSum'Const
+           (snd (tpSeq (suc _))) C) ∙ lim-const _ _
+
+     where
+
+      rtp : RefinableTaggedPartition[ rat A , rat B ]
+      rtp = (rtpℚ A B ((≤ᵣ→≤ℚ _ _ (isTrans≤ᵣ _ _ _
+                 (isTrans≤ᵣ _ _ _ A≤a a≤b)
+                   b≤B))))
+
+      clamped-pts : RefinableTaggedPartition[ a , b ]
+      clamped-pts = (clamp-RefinableTaggedPartition
+             _ _ a b a≤b
+              (A≤a , (isTrans≤ᵣ _ _ _ a≤b b≤B))
+              (isTrans≤ᵣ _ _ _ A≤a a≤b , b≤B)
+             (rtpℚ A B
+               (≤ᵣ→≤ℚ _ _ (isTrans≤ᵣ _ _ _
+                 (isTrans≤ᵣ _ _ _ A≤a a≤b)
+                   b≤B))))
+      open RefinableTaggedPartition[_,_] clamped-pts
+
+      open PreIntegration a b a≤b A B A≤a b≤B clamped-pts
+        (λ _ → C) (IsUContinuousConst C)
+
+
+ IntegralConcat :
+   ∀ a b c (a≤b : a ≤ᵣ b) (b≤c : b ≤ᵣ c)
+     (f : ℝ → ℝ) (fc : IsUContinuous f) →
+     fst (Integrate-UContinuous a b a≤b f fc)
+     +ᵣ fst (Integrate-UContinuous b c b≤c f fc)
+     ≡ fst (Integrate-UContinuous a c (isTrans≤ᵣ _ _ _ a≤b b≤c) f fc)
+ IntegralConcat a b c a≤b b≤c f fc =
+   Integral'-additive a b c a≤b b≤c f
+        _ _ _
+        (snd (Integrate-UContinuous a b a≤b f fc))
+        (snd (Integrate-UContinuous b c b≤c f fc))
+        (snd (Integrate-UContinuous a c (isTrans≤ᵣ _ _ _ a≤b b≤c) f fc))
+
+ Integral+ : ∀ a b (a≤b : a ≤ᵣ b) f g fc gc
+    → fst (Integrate-UContinuous a b a≤b f fc)
+      +ᵣ  fst (Integrate-UContinuous a b a≤b g gc)
+       ≡ fst (Integrate-UContinuous a b a≤b
+         (λ x → f x +ᵣ g x) (IsUContinuous+ᵣ₂ f g fc gc))
+ Integral+ a b a≤b f g fc gc =
+   Integral'Uniq a b a≤b _ _ _
+    (Integral'-+ a b a≤b f g
+     _ _
+     (snd (Integrate-UContinuous a b a≤b f fc))
+     (snd (Integrate-UContinuous a b a≤b g gc)))
+    (snd (Integrate-UContinuous a b a≤b
+         (λ x → f x +ᵣ g x) (IsUContinuous+ᵣ₂ f g fc gc)))
+
+
+
+ Integral-C· : ∀ a b (a≤b : a ≤ᵣ b) C f fc fc'
+    → C ·ᵣ fst (Integrate-UContinuous a b a≤b f fc)
+
+       ≡ fst (Integrate-UContinuous a b a≤b
+         (λ x → C ·ᵣ f x) fc')
+ Integral-C· a b a≤b C f fc fc' =
+   Integral'Uniq a b a≤b _ _ _
+     (Integral'-C· a b a≤b C f _ (snd (Integrate-UContinuous a b a≤b f fc)) )
+     (snd (Integrate-UContinuous a b a≤b
+         (λ x → C ·ᵣ f x) fc'))
+
+
+ Integrate-UContinuous-≡ : ∀ a b (a≤b : a ≤ᵣ b) f g fc gc
+    → (∀ x → f x ≡ g x)
+    → fst (Integrate-UContinuous a b a≤b f fc)
+       ≡ fst (Integrate-UContinuous a b a≤b g gc)
+ Integrate-UContinuous-≡ a b a≤b f g fc gc x =
+   cong {A = Σ _ IsUContinuous}
+         {x = f , fc} {g , subst IsUContinuous (funExt x) fc }
+         (λ (g , gc) → fst (Integrate-UContinuous a b a≤b g gc))
+          (ΣPathP (funExt x , toPathP refl))
+     ∙ Integral'Uniq a b a≤b _ _ _
+       (snd (Integrate-UContinuous a b a≤b g
+          (subst IsUContinuous (funExt x) fc)))
+        (snd (Integrate-UContinuous a b a≤b g gc))
+
+ Integral- : ∀ a b (a≤b : a ≤ᵣ b) f g fc gc
+    → fst (Integrate-UContinuous a b a≤b f fc)
+      -ᵣ  fst (Integrate-UContinuous a b a≤b g gc)
+       ≡ fst (Integrate-UContinuous a b a≤b
+         (λ x → f x -ᵣ g x) (IsUContinuous-ᵣ₂ f g fc gc))
+ Integral- a b a≤b f g fc gc = PT.rec
+   (isSetℝ _ _)
+     (λ icNeg →
+        let -1·gc : IsUContinuous (λ x → (rat [ ℤ.negsuc zero / 1+ zero ]) ·ᵣ g x)
+            -1·gc = subst IsUContinuous
+                    (funExt (λ _ → ·ᵣComm _ _)) (IsUContinuous∘ icNeg gc)
+            -gc : IsUContinuous (λ x → -ᵣ (g x))
+            -gc = subst IsUContinuous
+                    (funExt λ x → sym (-ᵣ≡[-1·ᵣ] (g x))) -1·gc
+        in   cong (fst (Integrate-UContinuous a b a≤b f fc) +ᵣ_)
+                   (-ᵣ≡[-1·ᵣ] (fst (Integrate-UContinuous a b a≤b g gc))
+                     ∙∙ Integral-C· a b a≤b
+                         (rat [ ℤ.negsuc zero / 1+ zero ]) g gc -1·gc
+                     ∙∙ Integrate-UContinuous-≡ a b a≤b
+                         _ _ _ _
+                          (λ x → sym (-ᵣ≡[-1·ᵣ] (g x))))
+
+                ∙ Integral+ a b a≤b f (-ᵣ_ ∘ g) fc
+                  -gc
+                 ∙ Integrate-UContinuous-≡ a b a≤b _ _ _ _
+                   (λ x → sym (x-ᵣy≡x+ᵣ[-ᵣy] (f x) (g x))))
+     (IsUContinuous·ᵣR (rat [ ℤ.negsuc zero / 1+ zero ]) )
+
+ Integral-absᵣ≤ : ∀ a b (a≤b : a ≤ᵣ b) f fc fc' →
+       absᵣ (fst (Integrate-UContinuous a b a≤b f fc))
+         ≤ᵣ (fst (Integrate-UContinuous a b a≤b (absᵣ ∘ f) fc'))
+ Integral-absᵣ≤ a b a≤b f fc fc' =
+   Integral'-abs≤ a b a≤b f _ _
+     (snd (Integrate-UContinuous a b a≤b f fc))
+     (snd (Integrate-UContinuous a b a≤b (absᵣ ∘ f) fc'))
+
+
+ IntegralAbs : ∀ a b (a≤b : a ≤ᵣ b) f fc
+    → ∀ fc-sup → (∀ x → x ∈ intervalℙ a b → absᵣ (f x) ≤ᵣ fc-sup)
+    → absᵣ (fst (Integrate-UContinuous a b a≤b f fc)) ≤ᵣ fc-sup ·ᵣ (b -ᵣ a)
+ IntegralAbs a b a≤b f fc fc-sup x =
+  isTrans≤≡ᵣ _ _ _
+    (isTrans≤ᵣ _ _ _
+    (Integral-absᵣ≤  a b a≤b _ _ _)
+    (Integral'-≤ a b a≤b (absᵣ ∘ f) (λ _ → fc-sup) _ _
+      x
+      (snd (Integrate-UContinuous a b a≤b (absᵣ ∘ f)
+        (IsUContinuous∘ IsUContinuousAbsᵣ fc)) )
+      (snd (Integrate-UContinuous a b a≤b (λ _ → fc-sup)
+        (IsUContinuousConst _)))))
+    (IntegralConst a b a≤b fc-sup _)
+
+
+ FTOC⇒ : ∀ x₀ (f : ℝ → ℝ) → (ucf : IsUContinuous f)
+                 → (uDerivativeOfℙ (pred≥ x₀) ,
+                         (λ x x₀≤x →
+                           fst (Integrate-UContinuous x₀ x x₀≤x f ucf))
+                         is (λ x _ → f x))
+ FTOC⇒ x₀ f ucf ε =
+  PT.map (map-snd (ftoc _))
+   (IsUContinuous-εᵣ f ucf
+    (ℚ₊→ℝ₊ ([ 1 / 2 ] , _ ) ₊·ᵣ (ℚ₊→ℝ₊ ε)))
+  where
+  ftoc : ∀ δ → ((u v : ℝ) → u ∼[ δ ] v → absᵣ (f u -ᵣ f v) <ᵣ _)
+   → ∀ x x₀≤x (r : ℝ) (r∈ : r ∈ (λ x₁ → pred≥ x₀ (x +ᵣ x₁)))
+      (x＃r : 0 ＃ r) →
+      absᵣ r <ᵣ fst (ℚ₊→ℝ₊ δ) →
+      absᵣ
+      (f x -ᵣ
+       differenceAtℙ (pred≥ x₀)
+       (λ x₁ x₀≤x₁ → fst (Integrate-UContinuous x₀ x₁ x₀≤x₁ f ucf)) x r
+       x＃r x₀≤x r∈)
+      <ᵣ rat (fst ε)
+  ftoc δ X x x₀≤x h r∈ 0＃h x₁ =
+    invEq (z<x≃y₊·z<y₊·x _ _ h₊)
+     (isTrans≡<ᵣ _ _ _
+       (cong₂ _·ᵣ_ (sym (absᵣNonNeg (absᵣ h) (0≤absᵣ h))) refl ∙ sym (·absᵣ _ _) ∙
+        cong absᵣ (𝐑'.·DistR- (absᵣ h) _ _ ∙ cong₂ _-ᵣ_ (·ᵣComm _ _ ∙ fx-const-integral)
+           (cong₂ _·ᵣ_ (·sign-flip≡ h 0＃h) refl  ∙ (·ᵣComm _ _) ∙
+            ·ᵣAssoc _ _ _ ∙
+             cong₂ _·ᵣ_ ([x/y]·yᵣ _ h 0＃h) refl
+             ∙ h-sidesCases-lem 0＃h) ∙
+              Integral- x'* x* x*∈
+                (λ _ → f x) f
+                (IsUContinuousConst (f x)) ucf))
+       (isTrans<≡ᵣ _ _ _
+         (isTrans≤<ᵣ _ _ _ (IntegralAbs x'* x* x*∈
+            (λ x₂ → f x -ᵣ f x₂)
+           (IsUContinuous-ᵣ₂ (λ _ → f x) f (IsUContinuousConst (f x)) ucf) (rat [ 1 / 2 ] ·ᵣ rat (fst ε))
+         X')
+         (isTrans≡<ᵣ _ _ _
+           (sym (·ᵣAssoc _ _ _))
+           (<ᵣ-·ᵣo  _ _ ((ℚ₊→ℝ₊ ε) ₊·ᵣ (_ , 0<x*-x'*)) decℚ<ᵣ? )))
+         (·IdL _ ∙ cong (rat (fst ε) ·ᵣ_) x*-x'*≡∣h∣ ∙ ·ᵣComm _ _)))
+
+
+   where
+
+
+
+   x* : ℝ
+   x* = maxᵣ x (x +ᵣ h)
+
+   x'* : ℝ
+   x'* = minᵣ x (x +ᵣ h)
+
+   x*∈ = (isTrans≤ᵣ x'* _ x* (min≤ᵣ x (x +ᵣ h)) (≤maxᵣ x (x +ᵣ h)) )
+
+
+   x*-x'*≡∣h∣ : x* -ᵣ x'* ≡ absᵣ h
+   x*-x'*≡∣h∣ = ⊎.rec
+     (λ 0<h →
+      let z = <ᵣWeaken≤ᵣ x (x +ᵣ h)
+            (isTrans≡<ᵣ _ _ _ (sym (+IdR x)) (<ᵣ-o+ 0 h x 0<h))
+
+      in cong₂ _-ᵣ_ (≤→maxᵣ _ _ z) (≤→minᵣ x (x +ᵣ h) z)
+           ∙∙ L𝐑.lem--063 {x} {h} ∙∙ sym (absᵣPos h 0<h))
+     (λ h<0 →
+      let z = <ᵣWeaken≤ᵣ (x +ᵣ h) x
+             (isTrans<≡ᵣ _ _ _ (<ᵣ-o+ h 0 x h<0) (+IdR x))
+
+      in cong₂ _-ᵣ_
+         (maxᵣComm x (x +ᵣ h) ∙ ≤→maxᵣ _ _ z)
+         (minᵣComm x (x +ᵣ h) ∙ ≤→minᵣ _ _ z)
+         ∙∙ sym (L𝐑.lem--050 {h} {x}) ∙∙ sym (absᵣNeg _ h<0))
+    0＃h
+
+   h₊ : ℝ₊
+   h₊ = absᵣ h , 0＃→0<abs h 0＃h
+
+   0<x*-x'* : 0 <ᵣ x* -ᵣ x'*
+   0<x*-x'* = isTrans<≡ᵣ _ _ _ (snd h₊)
+     (sym x*-x'*≡∣h∣)
+
+   h-sidesCases-lem : ∀ 0＃h →
+     (fst (Integrate-UContinuous x₀ (x +ᵣ h) r∈ f ucf) -ᵣ
+        fst (Integrate-UContinuous x₀ x x₀≤x f ucf))
+       ·ᵣ signᵣ h 0＃h ≡
+        fst (Integrate-UContinuous x'* x* x*∈ f ucf)
+   h-sidesCases-lem (inl u) =
+       ·IdR _
+     ∙ cong (_-ᵣ fst (Integrate-UContinuous x₀ _ x₀≤x f ucf))
+       ( cong (λ r∈ → fst (Integrate-UContinuous x₀ (x +ᵣ h) r∈ f ucf))
+              (isProp≤ᵣ _ _ _ _)
+       ∙ sym (IntegralConcat x₀ x (x +ᵣ h) x₀≤x x≤x+h
+            f ucf))
+     ∙ L𝐑.lem--063 ∙
+        cong {A = Σ (ℝ × ℝ) (uncurry _≤ᵣ_)}
+            {x = (x , x +ᵣ h) , _}
+            {(x'* , x*) , _}
+          ((λ ((x'* ,  x*) , x*∈)  →
+             fst (Integrate-UContinuous x'* x* x*∈ f ucf)))
+          (Σ≡Prop (uncurry isProp≤ᵣ)
+           (cong₂ _,_
+               (sym (≤→minᵣ x (x +ᵣ h) (x≤x+h)))
+               (sym (≤→maxᵣ x (x +ᵣ h) (x≤x+h)))))
+
+      where
+      x≤x+h : x ≤ᵣ x +ᵣ h
+      x≤x+h = isTrans≡≤ᵣ _ _ _ (sym (+IdR x))
+            (≤ᵣ-o+ _ _ x (<ᵣWeaken≤ᵣ _ _ u))
+   h-sidesCases-lem (inr u) =
+      ·ᵣComm _ _
+    ∙∙ sym (-ᵣ≡[-1·ᵣ] _)
+    ∙∙ -[x-y]≡y-x _ _
+    ∙∙ cong (_-ᵣ fst (Integrate-UContinuous x₀ (x +ᵣ h) r∈ f ucf))
+            (cong (λ r∈ → fst (Integrate-UContinuous x₀ x r∈ f ucf))
+              (isProp≤ᵣ _ _ _ _)
+           ∙ sym (IntegralConcat x₀ (x +ᵣ h) x r∈ x+h≤x
+              f ucf))
+    ∙ L𝐑.lem--063
+    ∙∙ cong {A = Σ (ℝ × ℝ) (uncurry _≤ᵣ_)}
+            {x = (x +ᵣ h , x) , _}
+            {(x'* , x*) , _}
+          ((λ ((x'* ,  x*) , x*∈)  →
+             fst (Integrate-UContinuous x'* x* x*∈ f ucf)))
+          (Σ≡Prop (uncurry isProp≤ᵣ)
+           (cong₂ _,_
+               (sym (≤→minᵣ (x +ᵣ h) x (x+h≤x)) ∙ minᵣComm _ x)
+               (sym (≤→maxᵣ (x +ᵣ h) x (x+h≤x)) ∙ maxᵣComm _ x)))
+      where
+      x+h≤x : x +ᵣ h ≤ᵣ x
+      x+h≤x = isTrans≤≡ᵣ _ _ _
+            (≤ᵣ-o+ _ _ x (<ᵣWeaken≤ᵣ _ _ u))
+            (+IdR x)
+
+   fx-const-integral : f x ·ᵣ absᵣ h ≡
+        fst (Integrate-UContinuous x'* x* x*∈ (λ _ → f x) (IsUContinuousConst _))
+   fx-const-integral =
+       cong (f x ·ᵣ_) (sym x*-x'*≡∣h∣)
+     ∙ sym (IntegralConst x'* x* x*∈ (f x) (IsUContinuousConst _))
+
+
+   X' : (x' : ℝ) →
+         x' ∈ intervalℙ x'* x* →
+         absᵣ (f x -ᵣ f x') ≤ᵣ rat [ 1 / 2 ] ·ᵣ rat (fst ε)
+   X' x' (≤x' , x'≤) =
+     <ᵣWeaken≤ᵣ _ _ (X x x' (invEq (∼≃abs<ε _ _ _)
+      ((isTrans≤<ᵣ _ _ _
+       (isTrans≤≡ᵣ _ _ _
+        (hh 0＃h)
+         (x*-x'*≡∣h∣)) x₁))))
+
+     where
+      hh : rat [ pos 0 / 1+ 0 ] ＃ h →  absᵣ (x +ᵣ -ᵣ x') ≤ᵣ x* -ᵣ x'*
+      hh (inl 0<h) = isTrans≡≤ᵣ _ _ _
+        (minusComm-absᵣ _ _ )
+        (isTrans≡≤ᵣ _ _ _
+          (absᵣNonNeg _ (x≤y→0≤y-x _ _
+            (isTrans≡≤ᵣ _ _ _ (sym (≤→minᵣ x (x +ᵣ h) (x≤x+h))) ≤x')))
+          (≤ᵣMonotone+ᵣ _ _ _ _ x'≤ (-ᵣ≤ᵣ _ _ (min≤ᵣ x (x +ᵣ h)))))
+         where
+          x≤x+h : x ≤ᵣ x +ᵣ h
+          x≤x+h = isTrans≡≤ᵣ _ _ _ (sym (+IdR x))
+                (≤ᵣ-o+ _ _ x (<ᵣWeaken≤ᵣ _ _ 0<h))
+      hh (inr h<0) =
+        (isTrans≡≤ᵣ _ _ _
+          (absᵣNonNeg _ ((x≤y→0≤y-x _ _
+            (isTrans≤≡ᵣ _ _ _ x'≤ (maxᵣComm x (x +ᵣ h) ∙
+             (≤→maxᵣ (x +ᵣ h) x (x+h≤x)))))))
+           (≤ᵣMonotone+ᵣ _ _ _ _ (≤maxᵣ x (x +ᵣ h))
+            (-ᵣ≤ᵣ _ _ ≤x'))
+          )
+
+
+       where
+       x+h≤x : x +ᵣ h ≤ᵣ x
+       x+h≤x = isTrans≤≡ᵣ _ _ _
+             (≤ᵣ-o+ _ _ x (<ᵣWeaken≤ᵣ _ _ h<0))
+             (+IdR x)
+
+
+
+
+ FTOC⇐ : ∀ a b (a<b : a <ᵣ b) (f F : ℝ → ℝ) → ∀ ucf
+           → uDerivativeOfℙ (intervalℙ a b) , (λ x _ → F x) is (λ x _ → f x)
+           → fst (Integrate-UContinuous a b (<ᵣWeaken≤ᵣ _ _ a<b) f ucf)
+               ≡ F b -ᵣ F a
+ FTOC⇐ a b a<b f F ucf udc =
+   let a≤b = <ᵣWeaken≤ᵣ _ _ a<b
+       z =
+           subst2 (uDerivativeOfℙ (pred≥ a) ,_is_)
+             (funExt₂ λ _ _ → sym (-ᵣ≡[-1·ᵣ] _))
+             (funExt₂ λ _ _ → sym (-ᵣ≡[-1·ᵣ] _))
+             (C·uDerivativeℙ (pred≥ a) -1 _ _ (FTOC⇒ a f ucf))
+
+
+       f* : (r : ℝ) → r ∈ intervalℙ a b → ℝ
+       f* r r∈ = -ᵣ (fst (Integrate-UContinuous a r (fst r∈) f ucf))
+       zD : _
+       zD = +uDerivativeℙ (intervalℙ a b) _ _
+                f* (λ x _ → -ᵣ (f x))
+              udc λ ε →
+                PT.map (map-snd
+                  (λ X →
+                    λ x x∈ h h∈ 0＃h x₁ →
+                     X x (fst x∈) h (fst h∈) 0＃h x₁
+                     ))
+                  (z ε)
+       b∈ = a≤b , ≤ᵣ-refl _
+       a∈ = ≤ᵣ-refl _ , a≤b
+       z' : F a ≡ F b +ᵣ f* b b∈
+       z' = sym (𝐑'.+IdR' _ _
+             (cong -ᵣ_
+               (Integral'-empty a f _
+                (snd (Integrate-UContinuous a a (≤ᵣ-refl a) f ucf)))
+               ∙ -ᵣ-rat 0))
+             ∙ nullDerivative→const a b
+                a∈ b∈
+                a<b (λ r r∈ → F r +ᵣ f* r r∈)
+                 (subst (uDerivativeOfℙ (intervalℙ a b) ,
+                   (λ r r∈ → F r +ᵣ f* r r∈) is_)
+                   (funExt₂ (λ _ _ → +-ᵣ _)) zD)
+   in sym L𝐑.lem--079
+       ∙ cong₂ _-ᵣ_ refl (sym z')
+
diff --git a/Cubical/HITs/CauchyReals/Inverse.agda b/Cubical/HITs/CauchyReals/Inverse.agda
index bcdd9b9648..1459a90281 100644
--- a/Cubical/HITs/CauchyReals/Inverse.agda
+++ b/Cubical/HITs/CauchyReals/Inverse.agda
@@ -7,6 +7,8 @@ open import Cubical.Foundations.Structure
 open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
 open import Cubical.Foundations.Function
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.Powerset
 
 open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
 open import Cubical.Data.Empty as ⊥
@@ -41,9 +43,8 @@ open import Cubical.HITs.CauchyReals.Continuous
 open import Cubical.HITs.CauchyReals.Multiplication
 
 
-Rℝ = (CR.CommRing→Ring
-               (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ))
--- module CRℝ = ?
+Rℝ = (CR.CommRing→Ring (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ))
+module CRℝ = RP.RingStr (snd Rℝ)
 
 module 𝐑 = CR.CommRingTheory (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ)
 module 𝐑' = RP.RingTheory Rℝ
@@ -93,15 +94,18 @@ 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 )
+
+opaque
+ unfolding absᵣ _≤ᵣ_
+ ≤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)
@@ -113,70 +117,74 @@ from-abs< x y z p = isTrans≤<ᵣ _ _ _ (≤absᵣ _) 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₁
+
+opaque
+ unfolding _<ᵣ_ _≤ᵣ_ _+ᵣ_
+ ∃rationalApprox≤ : ∀ u → (ε : ℚ₊) →
+    ∃[ q ∈ ℚ ] (((rat q) +ᵣ (-ᵣ u)) ≤ᵣ rat (fst ε)) × (u ≤ᵣ rat q)
+ ∃rationalApprox≤ = Elimℝ-Prop.go w
+  where
+  w : Elimℝ-Prop λ u → (ε : ℚ₊) →
+    ∃[ q ∈ ℚ ] (((rat q) +ᵣ (-ᵣ u)) ≤ᵣ rat (fst ε)) × (u ≤ᵣ rat q)
+  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)
@@ -192,139 +200,162 @@ open ℚ.HLP
     (cong (x +ᵣ_) (+ᵣComm _ _) ∙
       L𝐑.lem--05 {x} { -ᵣ y}) (L𝐑.lem--05 {y} { -ᵣ x}) (≤ᵣ-+o _ _ ((-ᵣ x) +ᵣ (-ᵣ y)) p)
 
+≤ᵣ-ᵣ : ∀ x y → -ᵣ y ≤ᵣ -ᵣ x →  x ≤ᵣ y
+≤ᵣ-ᵣ x y = subst2 _≤ᵣ_ (-ᵣInvol x) (-ᵣInvol y) ∘ -ᵣ≤ᵣ (-ᵣ y) (-ᵣ x)
+
+opaque
+ unfolding _<ᵣ_
+ -ᵣ<ᵣ : ∀ x y → x <ᵣ y → -ᵣ y <ᵣ -ᵣ x
+ -ᵣ<ᵣ x y = PT.map
+   λ ((q , q') , z , z' , z'') →
+        (ℚ.- q' , ℚ.- q) , -ᵣ≤ᵣ _ _ z'' , ((ℚ.minus-< _ _ z') , -ᵣ≤ᵣ _ _ z)
 
--ᵣ<ᵣ : ∀ x y → x <ᵣ y → -ᵣ y <ᵣ -ᵣ x
--ᵣ<ᵣ x y = PT.map
-  λ ((q , q') , z , z' , z'') →
-       (ℚ.- q' , ℚ.- q) , -ᵣ≤ᵣ _ _ z'' , ((ℚ.minus-< _ _ z') , -ᵣ≤ᵣ _ _ z)
+<ᵣ-ᵣ : ∀ x y → -ᵣ y <ᵣ -ᵣ x →  x <ᵣ y
+<ᵣ-ᵣ x y = subst2 _<ᵣ_ (-ᵣInvol x) (-ᵣInvol y) ∘ -ᵣ<ᵣ (-ᵣ y) (-ᵣ x)
 
-∃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₊ ε)
+opaque
+ unfolding _≤ᵣ_
+
+ absᵣNonPos : ∀ x → x ≤ᵣ 0 → absᵣ x ≡ -ᵣ x
+ absᵣNonPos x p = abs-max x ∙ z
+  where
+    z : x ≤ᵣ (-ᵣ x)
+    z = isTrans≤ᵣ _ _ _ p (-ᵣ≤ᵣ _ _ p)
+
+opaque
+ unfolding _+ᵣ_
+
+ ∃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₊ Δ)))
+opaque
+ unfolding _<ᵣ_ _+ᵣ_
+ ∃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₊ ε)))
+
+
+opaque
+ unfolding _<ᵣ_ _+ᵣ_
+ <ᵣ-+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
+  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''
+ <ᵣ-+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'
+        y' : (rat q +ᵣ o) <ᵣ (rat q' +ᵣ o)
+        y' = <ᵣ-+o-pre q q' o x'
 
 
-   in isTrans<≤ᵣ _ _ _ (isTrans≤<ᵣ _ _ _ y y') y''
+    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
@@ -344,28 +375,24 @@ open ℚ.HLP
 
 
 ℝ₊+ : (m : ℝ₊) (n : ℝ₊) → 0 <ᵣ (fst m) +ᵣ (fst n)
-ℝ₊+ (m , <m) (n , <n) = <ᵣMonotone+ᵣ 0 m 0 n <m <n
-
+ℝ₊+ (m , <m) (n , <n) = isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat  _ _)) (<ᵣ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
-
+opaque
+ unfolding _<ᵣ_
+ isIrrefl<ᵣ : BinaryRelation.isIrrefl _<ᵣ_
+ isIrrefl<ᵣ a = PT.rec isProp⊥
+   λ ((q , q') , (a≤q , q<q' , q'≤a)) →
+     ℚ.≤→≯ _ _ (≤ᵣ→≤ℚ _ _ (isTrans≤ᵣ _ _ _ q'≤a a≤q)) q<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₁) (inl x₂) = cong inl (isProp<ᵣ _ _ 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₂)
+isProp＃ x y (inr x₁) (inr x₂) = cong inr (isProp<ᵣ _ _ x₁ x₂)
 
 
 rat＃ : ∀ q q' → (rat q ＃ rat q') ≃ (q ℚ.# q' )
@@ -398,11 +425,11 @@ decCut x 0<absX =
                                            (+-ᵣ x) (≤ᵣ-+o _ _ (-ᵣ x)
                                           (<ᵣWeaken≤ᵣ _ _ x<q)))))
                               (absᵣ-triangle (rat q) (x +ᵣ (-ᵣ (rat q))))
-                          zzzz' = subst (absᵣ x <ᵣ_) (cong rat
+                          zzzz' = subst (absᵣ x <ᵣ_) (+ᵣ-rat _ _ ∙ cong rat
                                (ℚ.ε/2+ε/2≡ε (fst Δ)))
                              (isTrans≤<ᵣ _ _ _ zzz'
-                                     (<ᵣMonotone+ᵣ
-                                       _ _ _ _ q<Δ/2 q-x<Δ/2))
+                                     ((<ᵣMonotone+ᵣ
+                                       _ _ _ _ q<Δ/2 q-x<Δ/2)))
                       in ⊥.rec (isAsym<ᵣ _ _ Δ<absX zzzz')
                 in ⊎.rec
                     (λ Δ≤q →
@@ -423,17 +450,18 @@ decCut x 0<absX =
      (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)))
+opaque
+ unfolding _<ᵣ_
+ ＃≃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< : ?
@@ -441,189 +469,216 @@ decCut x 0<absX =
 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
+opaque
+ unfolding _<ᵣ_
+ 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))
+
+opaque
+ unfolding _≤ᵣ_ _+ᵣ_
+ ≤ᵣ-·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 _ _
+
+ <ᵣ→Δ : ∀ 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⇒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+c<b⇒a<b-c : ∀ a b c → a +ᵣ c <ᵣ b  → a <ᵣ b -ᵣ c
+ a+c<b⇒a<b-c a b c p =
+    subst (_<ᵣ b -ᵣ c)
+         (𝐑'.plusMinus _ _)
+      (<ᵣ-+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)
+
+ 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)
+
+ a<c+b⇒a-c<b : ∀ a b c → a <ᵣ c +ᵣ b  → a -ᵣ c <ᵣ b
+ a<c+b⇒a-c<b a b c p =
+   subst ((a -ᵣ c) <ᵣ_) (+ᵣComm _ _ ∙ L𝐑.lem--04 {c} {b}) (<ᵣ-+o _ _ (-ᵣ c) p)
+
+ a<c+b⇒a-b<c : ∀ a b c → a <ᵣ c +ᵣ b  → a -ᵣ b <ᵣ c
+ a<c+b⇒a-b<c a b c p =
+   a<c+b⇒a-c<b a c b (isTrans<≡ᵣ _ _ _ p (+ᵣComm _ _))
+
+
+ a≤c+b⇒a-c≤b : ∀ a b c → a ≤ᵣ c +ᵣ b  → a -ᵣ c ≤ᵣ b
+ a≤c+b⇒a-c≤b a b c p =
+   subst ((a -ᵣ c) ≤ᵣ_) (+ᵣComm _ _ ∙ L𝐑.lem--04 {c} {b}) (≤ᵣ-+o _ _ (-ᵣ c) p)
+
+
+ a+b≤c⇒b≤c-b : ∀ a b c → a +ᵣ b ≤ᵣ c   → b  ≤ᵣ c -ᵣ a
+ a+b≤c⇒b≤c-b a b c p = subst2 _≤ᵣ_
+   L𝐑.lem--04 (+ᵣComm _ _)
+   (≤ᵣ-o+ _ _ (-ᵣ a) p)
+
+ b≤c-b⇒a+b≤c : ∀ a b c → b  ≤ᵣ c -ᵣ a → a +ᵣ b ≤ᵣ c
+ b≤c-b⇒a+b≤c a b c p = subst (_ ≤ᵣ_)
+   L𝐑.lem--05
+   (≤ᵣ-o+ _ _ a p)
+
+ a-b≤c-d⇒a+d≤c+b : ∀ a b c d → a -ᵣ b ≤ᵣ c -ᵣ d → a +ᵣ d ≤ᵣ c +ᵣ b
+ a-b≤c-d⇒a+d≤c+b a b c d x =
+   isTrans≡≤ᵣ _ _ _ (+ᵣComm _ _) (a-b≤c⇒a≤c+b _ _ _
+    (isTrans≡≤ᵣ _ _ _ (sym (+ᵣAssoc _ _ _))
+    (b≤c-b⇒a+b≤c _ _ _ x)))
+
+ a+d≤c+b⇒a-b≤c-d : ∀ a b c d → a +ᵣ d ≤ᵣ c +ᵣ b → a -ᵣ b ≤ᵣ c -ᵣ d
+ a+d≤c+b⇒a-b≤c-d a b c d x =
+   a-b≤c-d⇒a+d≤c+b a (-ᵣ d) c (-ᵣ b)
+    (subst2 (λ d b → a +ᵣ d ≤ᵣ c +ᵣ b)
+     (sym (-ᵣInvol d)) (sym (-ᵣInvol b)) x)
+
+ b<c-b⇒a+b<c : ∀ a b c → b  <ᵣ c -ᵣ a → a +ᵣ b <ᵣ c
+ b<c-b⇒a+b<c a b c p = subst (_ <ᵣ_)
+   L𝐑.lem--05
+   (<ᵣ-o+ _ _ a 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)
+
+ <-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)
+
+
+ ≤-+o-cancel : ∀ m n o →  m +ᵣ o ≤ᵣ n +ᵣ o → m ≤ᵣ n
+ ≤-+o-cancel m n o p =
+      subst2 (_≤ᵣ_) (sym L𝐑.lem--034) (sym L𝐑.lem--034)
+      (≤ᵣ-+o _ _ (-ᵣ o) p)
+
+ <-+o-cancel : ∀ m n o →  m +ᵣ o <ᵣ n +ᵣ o → m <ᵣ n
+ <-+o-cancel m n o p =
+      subst2 (_<ᵣ_) (sym L𝐑.lem--034) (sym L𝐑.lem--034)
+      (<ᵣ-+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)
+
+ x≤y≃0≤y-x : ∀ x y → (x ≤ᵣ y) ≃ (0 ≤ᵣ y -ᵣ x)
+ x≤y≃0≤y-x x y =   propBiimpl→Equiv (isSetℝ _ _) (isSetℝ _ _)
+    (x≤y→0≤y-x x y)
+     λ p →  subst2 (_≤ᵣ_)
+    (+IdL x) (sym (L𝐑.lem--035 {y} {x}))
+     (≤ᵣ-+o 0 (y +ᵣ (-ᵣ x)) x p)
 
 
-≤maxᵣ : ∀ m n →  m ≤ᵣ maxᵣ m n
-≤maxᵣ m n = maxᵣAssoc _ _ _ ∙ cong (flip maxᵣ n) (maxᵣIdem m)
+ x<y≃0<y-x : ∀ x y → (x <ᵣ y) ≃ (0 <ᵣ y -ᵣ x)
+ x<y≃0<y-x x y =   propBiimpl→Equiv squash₁ squash₁
+    (x<y→0<y-x x y) (0<y-x→x<y x y)
 
-≤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'')
+ x<y→x-y<0 : ∀ x y →  x <ᵣ y  → x -ᵣ y <ᵣ 0
+ x<y→x-y<0 x y p =
+   subst (x -ᵣ y <ᵣ_) (+-ᵣ y) (<ᵣ-+o x y (-ᵣ y) p)
 
+ x-y<0→x<y : ∀ x y → x -ᵣ y <ᵣ 0 →  x <ᵣ y
+ x-y<0→x<y x y p =
 
+    (0<y-x→x<y _  _ (subst (0 <ᵣ_) (-[x-y]≡y-x _ _) (-ᵣ<ᵣ (x -ᵣ y) 0 p)))
 
 
-ℝ₊min : (m : ℝ₊) (n : ℝ₊) → 0 <ᵣ minᵣ (fst m) (fst n)
-ℝ₊min (m , <m) (n , <n) = <min-lem m n 0 <m <n
+ x<y≃x-y<0 : ∀ x y → (x <ᵣ y) ≃ (x -ᵣ y <ᵣ 0)
+ x<y≃x-y<0 x y =   propBiimpl→Equiv squash₁ squash₁
+    (x<y→x-y<0 x y) (x-y<0→x<y x y)
 
-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ᵣ _ _
+ x≤y→x-y≤0 : ∀ x y →  x ≤ᵣ y  → x -ᵣ y ≤ᵣ 0
+ x≤y→x-y≤0 x y p =
+   subst (x -ᵣ y ≤ᵣ_) (+-ᵣ y) (≤ᵣ-+o x y (-ᵣ y) p)
+
+ x-y≤0→x≤y : ∀ x y → x -ᵣ y ≤ᵣ 0 →  x ≤ᵣ y
+ x-y≤0→x≤y x y p =
+
+    (invEq (x≤y≃0≤y-x _  _) (subst (0 ≤ᵣ_) (-[x-y]≡y-x _ _) (-ᵣ≤ᵣ (x -ᵣ y) 0 p)))
+
+ x≤y≃x-y≤0 : ∀ x y → (x ≤ᵣ y) ≃ (x -ᵣ y ≤ᵣ 0)
+ x≤y≃x-y≤0 x y =   propBiimpl→Equiv (isProp≤ᵣ _ _) (isProp≤ᵣ _ _)
+    (x≤y→x-y≤0 x y) (x-y≤0→x≤y x y)
+
 
-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₁))
+      λ _ → Σ (∀ r → 0 <ᵣ r → ℝ) (IsContinuousWithPred (λ r → _ , isProp<ᵣ _ _))
 invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
    ctnF
 
@@ -668,7 +723,7 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
                              (ℚ.<→ℚ₊ (fst σ⊔) q (<ᵣ→<ℚ _ _ σ⊔<q))
                           ))))
              in subst (rat (fst φ*) ≤ᵣ_)
-                (rat·ᵣrat _ _)
+                (rat·ᵣrat _ _ ∙ cong (_·ᵣ rat [ 1 / 2 ]) (sym (-ᵣ-rat₂ _ _)))
                   (≤ℚ→≤ᵣ (fst φ*)
                     (fst (/2₊
                              (ℚ.<→ℚ₊ (fst σ⊔) q (<ᵣ→<ℚ _ _ σ⊔<q))
@@ -699,7 +754,8 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
            limRestr : rat (fst σ⊔)
                ≤ᵣ ((lim x y +ᵣ (-ᵣ rat (fst φ* ℚ.+ fst φ*))))
            limRestr = subst2 _≤ᵣ_
-             (L𝐑.lem--00 {rat (fst σ⊔)} {(rat (fst φ*) +ᵣ rat (fst φ*))})
+             (cong₂ _+ᵣ_ (cong₂ _-ᵣ_ refl (sym (+ᵣ-rat _ _))) (sym (+ᵣ-rat _ _) )
+              ∙ L𝐑.lem--00 {rat (fst σ⊔)} {(rat (fst φ*) +ᵣ rat (fst φ*))})
                (L𝐑.lem--061
                  {rat (fst σ⊔)} {rat (fst φ* ℚ.+ fst φ*)} {lim x y} )
              (≤ᵣ-o+ _ _
@@ -841,7 +897,7 @@ invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
            zz (<ᵣ→Δ _ _ σ<u)
      in zz'
 
-invℝ' : Σ (∀ r → 0 <ᵣ r → ℝ) (IsContinuousWithPred (λ r → _ , squash₁))
+invℝ' : Σ (∀ r → 0 <ᵣ r → ℝ) (IsContinuousWithPred (λ r → _ , isProp<ᵣ _ _))
 invℝ' = snd invℝ''
 
 invℝ'-rat : ∀ q p' p →
@@ -857,53 +913,59 @@ invℝ'-rat q p' p = PT.elim (λ xx →
  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)
+opaque
+ unfolding _<ᵣ_
+ 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'))))
+                            (isTrans≡<ᵣ _ _ _ (+ᵣ-rat _ _) (<ℚ→<ᵣ _ _ x)))))))))
+
+              in isTrans≤<ᵣ _ _ _ (x≤y→0≤y-x _ _ z') z
+              )
+            (∃rationalApprox u σ))
+       (snd invℝ' u ([ 1 / n ]  , _) p))
+   (getClamps u)
+
+
+
+invℝ₊ : ℝ₊ → ℝ₊
+invℝ₊ (y , 0<y) = fst invℝ' y 0<y , invℝ'-pos y 0<y
 
 signᵣ : ∀ r → 0 ＃ r → ℝ
 signᵣ _ = ⊎.rec (λ _ → rat 1) (λ _ → rat -1)
@@ -921,32 +983,34 @@ signᵣ-rat r (inr x) = cong rat (sym (snd (snd (ℚ.<→sign r)) (<ᵣ→<ℚ _
 
 -- 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))
+opaque
+ unfolding _<ᵣ_
+ 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))
 
 
 
@@ -954,10 +1018,10 @@ IsContinuousWithPredSignᵣ u ε =
 -ᵣ≡[-1·ᵣ] = ≡Continuous _ _
    IsContinuous-ᵣ
    (IsContinuous·ᵣL -1)
-   λ r → rat·ᵣrat _ _
+   λ r → -ᵣ-rat _ ∙ rat·ᵣrat _ _
 
 
-openPred< : ∀ x → ⟨ openPred (λ y → (x <ᵣ y) , squash₁)  ⟩
+openPred< : ∀ x → ⟨ openPred (λ y → (x <ᵣ y) , isProp<ᵣ _ _)  ⟩
 openPred< x y =
      PT.map (map-snd (λ {q} a<y-x v
         →   isTrans<ᵣ _ _ _
@@ -968,7 +1032,7 @@ openPred< x y =
   ∘S lowerℚBound (y +ᵣ (-ᵣ x))
   ∘S x<y→0<y-x x y
 
-openPred> : ∀ x → ⟨ openPred (λ y → (y <ᵣ x) , squash₁)  ⟩
+openPred> : ∀ x → ⟨ openPred (λ y → (y <ᵣ x) , isProp<ᵣ _ _)  ⟩
 openPred> x y =
        PT.map (map-snd (λ {q} q<x-y v
         →     flip (isTrans<ᵣ _ _ _)
@@ -981,6 +1045,7 @@ openPred> x y =
   ∘S x<y→0<y-x y x
 
 
+
 isOpenPred0＃ : ⟨ openPred 0＃ₚ ⟩
 isOpenPred0＃ x =
  ⊎.rec
@@ -1000,29 +1065,110 @@ isOpenPred0＃ x =
           ∙∙ sym (rat·ᵣrat _ _) ∙∙ cong rat (ℚ.x·invℚ₊[x]
             (r , ℚ.<→0< _ (<ᵣ→<ℚ _ _ r∈)))) r
 
+opaque
+ unfolding _≤ᵣ_
+ ≤ContWP : ∀ {P f₀ f₁} → ⟨ openPred P ⟩
+          → IsContinuousWithPred P f₀
+          → IsContinuousWithPred P f₁
+          → (∀ u u∈ → f₀ (rat u) u∈ ≤ᵣ f₁ (rat u) u∈)
+              → ∀ x x∈ → f₀ x x∈  ≤ᵣ f₁ x x∈
+ ≤ContWP {P} {f₀} {f₁} oP f₀C f₁C X x x∈ =
+     ≡ContinuousWithPred P P  oP oP
+     _ _
+     (contDiagNE₂WP maxR P _ _ f₀C f₁C)
+     f₁C (λ r r∈ r∈' →
+        X _ _
+         ∙ cong (f₁ (rat r)) (∈-isProp P _ r∈ r∈')) x x∈ x∈
+
+ ≤ContWP＃≤ : ∀ {f₀ f₁} q → 0 ℚ.< q
+          → IsContinuousWithPred 0＃ₚ f₀
+          → IsContinuousWithPred 0＃ₚ f₁
+          → (∀ u u∈ → u ℚ.≤ q → f₀ (rat u) u∈ ≤ᵣ f₁ (rat u) u∈)
+              → ∀ x x∈ → x ≤ᵣ rat q →  f₀ x x∈  ≤ᵣ f₁ x x∈
+ ≤ContWP＃≤ {f₀} {f₁} q 0<q f₀C f₁C X x x∈ x≤q =
+   let ＃min : ∀ r → 0 ＃ r → 0 ＃ minᵣ r (rat q)
+       ＃min r = ⊎.map
+         (λ 0<r → <min-lem _ _ _ 0<r (<ℚ→<ᵣ _ _ 0<q))
+         λ r<0 → isTrans≤<ᵣ _ _ _ (min≤ᵣ _ _) r<0
+       z = ≤ContWP {_} {λ r z → f₀ (minᵣ r (rat q)) (＃min r z)}
+                       {λ r z → f₁ (minᵣ r (rat q)) (＃min r z)}
+              isOpenPred0＃
+                (IsContinuousWP∘ _ _ _ _ _
+                 f₀C (AsContinuousWithPred _ _ (IsContinuousMinR _)))
+                (IsContinuousWP∘ _ _ _ _ _
+                 f₁C (AsContinuousWithPred _ _ (IsContinuousMinR _)))
+                (λ u u∈ →
+                  X (ℚ.min u q) (＃min (rat u) u∈) (ℚ.min≤'  _ _))
+                 x x∈
+   in subst {A = Σ _ (_∈ 0＃ₚ) } (λ (x , x∈) → f₀ x x∈ ≤ᵣ f₁ x x∈)
+        (Σ≡Prop (∈-isProp 0＃ₚ) (≤→minᵣ _ _ x≤q))
+          z
+
+ ≤ContWP＃≤' : ∀ {f₀ f₁} q → q ℚ.< 0
+          → IsContinuousWithPred 0＃ₚ f₀
+          → IsContinuousWithPred 0＃ₚ f₁
+          → (∀ u u∈ → q ℚ.≤ u → f₀ (rat u) u∈ ≤ᵣ f₁ (rat u) u∈)
+              → ∀ x x∈ → rat q ≤ᵣ x →  f₀ x x∈  ≤ᵣ f₁ x x∈
+ ≤ContWP＃≤' {f₀} {f₁} q q<0 f₀C f₁C X x x∈ q≤x =
+   let ＃max : ∀ r → 0 ＃ r → 0 ＃ maxᵣ r (rat q)
+       ＃max r =  ⊎.map
+         (λ 0<r → isTrans<≤ᵣ _ _ _ 0<r (≤maxᵣ _ _) )
+         λ r<0 → max<-lem _ _ _ r<0 (<ℚ→<ᵣ _ _ q<0) --isTrans≤<ᵣ _ _ _ (min≤ᵣ _ _) r<0
+        -- ⊎.map
+        --  (λ 0<r → <min-lem _ _ _ 0<r (<ℚ→<ᵣ _ _ 0<q))
+        --  λ r<0 → isTrans≤<ᵣ _ _ _ (min≤ᵣ _ _) r<0
+       z = ≤ContWP {_} {λ r z → f₀ (maxᵣ r (rat q)) (＃max r z)}
+                       {λ r z → f₁ (maxᵣ r (rat q)) (＃max r z)}
+              isOpenPred0＃
+                (IsContinuousWP∘ _ _ _ _ _
+                 f₀C (AsContinuousWithPred _ _ (IsContinuousMaxR _)))
+                (IsContinuousWP∘ _ _ _ _ _
+                 f₁C (AsContinuousWithPred _ _ (IsContinuousMaxR _)))
+                (λ u u∈ →
+                  X (ℚ.max u q) (＃max (rat u) u∈) (ℚ.≤max' u q))
+                 x x∈
+   in subst {A = Σ _ (_∈ 0＃ₚ) } (λ (x , x∈) → f₀ x x∈ ≤ᵣ f₁ x x∈)
+        (Σ≡Prop (∈-isProp 0＃ₚ) (maxᵣComm _ _ ∙ ≤→maxᵣ _ _ q≤x))
+          z
+
 
 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
+opaque
+ unfolding absᵣ
+ 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
+
+
+ ·sign-flip≡ : ∀ r 0＃r → absᵣ r ≡ r ·ᵣ (signᵣ r 0＃r)
+ ·sign-flip≡ r 0＃r =
+  (sym (𝐑'.·IdR' _ _ (sign²=1 r 0＃r)) ∙ ·ᵣAssoc _ _ _)
+  ∙ cong (_·ᵣ (signᵣ r 0＃r)) (sign·absᵣ r 0＃r)
 
 -- HoTT Theorem (11.3.47)
 
-abstract
+opaque
+ unfolding absᵣ -ᵣ_
+ absᵣNeg : ∀ x → x <ᵣ 0 → absᵣ x ≡ -ᵣ x
+ absᵣNeg x x<0 = -absᵣ _ ∙ absᵣPos _ (-ᵣ<ᵣ _ _ x<0)
+
+
+opaque
+ unfolding -ᵣ_  absᵣ
  invℝ : ∀ r → 0 ＃ r → ℝ
  invℝ r 0＃r = signᵣ r 0＃r ·ᵣ fst invℝ' (absᵣ r) (0＃→0<abs r 0＃r)
 
@@ -1099,11 +1245,22 @@ abstract
          (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))
 
+ invℝ₊≡invℝ : ∀ x 0＃x → fst (invℝ₊ x) ≡ invℝ (fst x) 0＃x
+ invℝ₊≡invℝ x (inl x₁) = (cong (uncurry (fst invℝ'))
+   (Σ≡Prop (λ _ → squash₁) (sym (absᵣPos _ x₁)))
+  ∙ sym (·IdL _)) ∙ sym (invℝimpl _ _)
+ invℝ₊≡invℝ x (inr x₁) = ⊥.rec (isAsym<ᵣ _ _ x₁ (snd x))
+
+
+ x·invℝ₊[x] : ∀ x → (fst x) ·ᵣ fst (invℝ₊ x) ≡ 1
+ x·invℝ₊[x] x = cong ((fst x) ·ᵣ_) (invℝ₊≡invℝ x _)
+   ∙ x·invℝ[x] (fst x) (inl (snd x))
+
 _／ᵣ[_,_] : ℝ → ∀ r → 0 ＃ r  → ℝ
 q ／ᵣ[ r , 0＃r ] = q ·ᵣ (invℝ r 0＃r)
 
 _／ᵣ₊_ : ℝ → ℝ₊  → ℝ
-q ／ᵣ₊ (r , 0<r) = q ／ᵣ[ r , inl (0<r) ]
+q ／ᵣ₊ r = q ·ᵣ fst (invℝ₊ r)
 
 [x·y]/yᵣ : ∀ q r → (0＃r : 0 ＃ r) →
                ((q ·ᵣ r) ／ᵣ[ r , 0＃r ]) ≡ q
@@ -1113,6 +1270,25 @@ q ／ᵣ₊ (r , 0<r) = q ／ᵣ[ r , inl (0<r) ]
    ∙∙ ·IdR q
 
 
+
+
+[x/₊y]·yᵣ : ∀ q r →
+               (q ／ᵣ₊ r ) ·ᵣ (fst r) ≡ q
+[x/₊y]·yᵣ q r =
+      sym (·ᵣAssoc _ _ _)
+   ∙∙ cong (q ·ᵣ_) (·ᵣComm _ _ ∙ x·invℝ₊[x] r)
+   ∙∙ ·IdR q
+
+
+[x·yᵣ]/₊y : ∀ q r →
+               ((q ·ᵣ (fst r)) ／ᵣ₊ r )  ≡ q
+[x·yᵣ]/₊y q r =
+      sym (·ᵣAssoc _ _ _)
+   ∙∙ cong (q ·ᵣ_) (x·invℝ₊[x] 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 =
@@ -1126,16 +1302,676 @@ x/y≡z→x≡z·y : ∀ x q r → (0＃r : 0 ＃ 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
+               → (x ／ᵣ₊ r) ≡ q
+               → x ≡ q ·ᵣ (fst r)
+x/₊y≡z→x≡z·y x q r p =
+    sym ([x/₊y]·yᵣ _ _) ∙ cong (_·ᵣ fst 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·y≡z→x≡z/₊y : ∀ x q r
+               → (x ·ᵣ fst r) ≡ q
+               → x ≡ q ／ᵣ₊ r
+x·y≡z→x≡z/₊y x q r  p =
+    sym ([x·yᵣ]/₊y _ _) ∙ cong (_／ᵣ₊ 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})
+    ∙∙ cong (x ·ᵣ_) (+ᵣ-rat _ _ ∙ decℚ≡ᵣ? {_} {_} {p})
     ∙∙ ·IdR _
+
+x/y=x/z·z/y : ∀ x q r → (0＃q : 0 ＃ q) → (0＃r : 0 ＃ r)
+              → x ／ᵣ[ q , 0＃q ] ≡
+                  (x ／ᵣ[ r , 0＃r ]) ·ᵣ (r ／ᵣ[ q , 0＃q ])
+x/y=x/z·z/y x q r 0＃q 0＃r =
+  cong (_／ᵣ[ q , 0＃q ]) (sym ([x/y]·yᵣ x r 0＃r) )
+    ∙  sym (·ᵣAssoc _ _ _)
+
+invℝ1 : (0＃1 : 0 ＃ 1) → invℝ 1 0＃1 ≡ 1
+invℝ1 0＃1 =
+   sym (·IdL _) ∙ x·invℝ[x] (rat 1) 0＃1
+
+
+invℝ· : ∀ x y 0＃x 0＃y 0＃x·y →
+          invℝ (x ·ᵣ y) 0＃x·y ≡
+            (invℝ x 0＃x) ·ᵣ (invℝ y 0＃y)
+invℝ· x y 0＃x 0＃y 0＃x·y = sym (·IdL _) ∙
+  sym (x·y≡z→x≡z/y _ _ _ _
+    (·ᵣComm _ _
+     ∙∙    sym (·ᵣAssoc _ _ _)
+        ∙∙ cong (x ·ᵣ_) (·ᵣAssoc _ _ _ ∙ ·ᵣComm _ _)
+        ∙∙ (·ᵣAssoc _ _ _)
+     ∙∙ cong₂ _·ᵣ_ (x·invℝ[x] x 0＃x) (x·invℝ[x] y 0＃y) ∙ ·IdL _ ))
+   ∙ ·ᵣComm _ _
+
+-＃ : ∀ x y → x ＃ y → (-ᵣ x) ＃ (-ᵣ y)
+-＃ x y p = ⊎.map (-ᵣ<ᵣ _ _) (-ᵣ<ᵣ _ _) (isSym＃ _ _ p)
+
+
+opaque
+ unfolding -ᵣ_
+
+ -invℝ : ∀ x y → -ᵣ (invℝ x y) ≡ invℝ (-ᵣ x) (subst (_＃ (-ᵣ x)) (-ᵣ-rat 0) (-＃ _ _ y)) -- -＃ _ _ y
+ -invℝ x y =
+   (cong -ᵣ_ (sym (·IdL _)) ∙ sym (-ᵣ· _ _) ∙
+      cong (_·ᵣ invℝ x y) (sym (invℝ-rat _ (inr decℚ<ᵣ?) (inr ℚ.decℚ<?))))
+       ∙ sym (invℝ· _ _ _ _
+         (subst (0 ＃_) ((cong -ᵣ_ (sym (·IdL _))) ∙ sym (-ᵣ· _ _)) (-＃ 0 x y)))
+    ∙ cong₂ invℝ (-ᵣ· _ _ ∙ cong -ᵣ_ (𝐑'.·IdL' _ _ refl ))
+     (toPathP (isProp＃ _ _ _ _))
+
+ absᵣ-invℝ : ∀ x y → absᵣ (invℝ x y) ≡ fst (invℝ₊ (absᵣ x , 0＃→0<abs _ y))
+ absᵣ-invℝ x (inl x₁) = cong absᵣ (sym (invℝ₊≡invℝ (x , x₁) (inl x₁))) ∙∙
+    absᵣPos _ (snd (invℝ₊ (x , x₁))) ∙∙
+     cong (fst ∘ invℝ₊) (ℝ₊≡ (sym (absᵣPos x x₁)))
+ absᵣ-invℝ x (inr x₁) = absᵣNeg _ (invℝ-neg _ x₁)
+   ∙ -invℝ _ _  ∙ sym (invℝ₊≡invℝ (-ᵣ x , -ᵣ<ᵣ _ _ x₁) _)
+    ∙ cong (fst ∘ invℝ₊) (ℝ₊≡ (sym (absᵣNeg _ x₁)))
+
+
+
+opaque
+ unfolding _≤ᵣ_
+
+
+ ≤ᵣ-·ᵣ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)
+
+NonNeg·ᵣ : ∀ x y → 0 ≤ᵣ x → 0 ≤ᵣ y → 0 ≤ᵣ x ·ᵣ y
+NonNeg·ᵣ x y 0≤x 0≤y = isTrans≡≤ᵣ _ _ _ (rat·ᵣrat 0 0)
+ (≤ᵣ₊Monotone·ᵣ _ _ _ _ 0≤x (≤ᵣ-refl _) 0≤x 0≤y)
+
+
+
+opaque
+ unfolding _<ᵣ_
+
+ ℝ₊· : (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 ,
+ isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat _ _)) (<ᵣ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)
+
+
+absᵣ-triangle-minus : (x y : ℝ) → absᵣ x -ᵣ absᵣ y ≤ᵣ absᵣ (x -ᵣ y)
+absᵣ-triangle-minus x y =
+  isTrans≡≤ᵣ _ _ _ (cong (_-ᵣ _) (cong absᵣ (sym (L𝐑.lem--05))))
+   (a≤c+b⇒a-c≤b _ _ _ (absᵣ-triangle y (x -ᵣ y)))
+
+absᵣ-triangle' : (x y : ℝ) → absᵣ x  ≤ᵣ absᵣ (x -ᵣ y) +ᵣ absᵣ y
+absᵣ-triangle' x y =
+   isTrans≡≤ᵣ _ _ _ (cong absᵣ (sym (L𝐑.lem--00))) (absᵣ-triangle (x -ᵣ y) y)
+
+
+opaque
+ unfolding _<ᵣ_
+
+ <ᵣ₊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)))
+
+
+<≤ᵣ₊Monotone·ᵣ : ∀ (m : ℝ₀₊) n (o : ℝ₊) s
+       → fst m <ᵣ n → fst o ≤ᵣ s
+       → (fst m ·ᵣ fst o) <ᵣ (n ·ᵣ s)
+<≤ᵣ₊Monotone·ᵣ m n o s m<n o≤s =
+   isTrans<≤ᵣ _ _ _ (<ᵣ-·ᵣo _ _ o m<n)
+           (≤ᵣ-o·ᵣ _ _ n (isTrans≤ᵣ _ _ _ (snd m)
+              (<ᵣWeaken≤ᵣ _ _ m<n) ) o≤s)
+
+
+≤<ᵣ₊Monotone·ᵣ : ∀ (m : ℝ₊) n (o : ℝ₀₊) s
+       → fst m ≤ᵣ n → fst o <ᵣ s
+       → (fst m ·ᵣ fst o) <ᵣ (n ·ᵣ s)
+≤<ᵣ₊Monotone·ᵣ m n o s m≤n o<s =
+   isTrans≤<ᵣ _ _ _
+     (≤ᵣ-·ᵣo _ _ _ (snd o) m≤n)
+     (<ᵣ-o·ᵣ _ _ (n , isTrans<≤ᵣ _ _ _ (snd m) m≤n) o<s )
+
+
+
+opaque
+ unfolding _<ᵣ_
+
+ z<x≃y₊·z<y₊·x : ∀ x z (y : ℝ₊) → (z <ᵣ x) ≃ ((fst y) ·ᵣ z <ᵣ (fst y) ·ᵣ x)
+ z<x≃y₊·z<y₊·x x z y =  propBiimpl→Equiv squash₁ squash₁
+  (<ᵣ-o·ᵣ _ _ y) (subst2 _<ᵣ_
+   (·ᵣAssoc _ _ _ ∙ cong (_·ᵣ z) (·ᵣComm _ _ ∙ x·invℝ₊[x] y) ∙ ·IdL z)
+   (·ᵣAssoc _ _ _ ∙ cong (_·ᵣ x) (·ᵣComm _ _ ∙ x·invℝ₊[x] y) ∙ ·IdL x)
+   ∘S (<ᵣ-o·ᵣ _ _ (invℝ₊ y)))
+
+
+ z<x/y₊≃y₊·z<x : ∀ x z (y : ℝ₊) → (z <ᵣ x ·ᵣ (fst (invℝ₊ y))) ≃ ((fst y) ·ᵣ z <ᵣ x)
+ z<x/y₊≃y₊·z<x x z y =
+     z<x≃y₊·z<y₊·x (x ·ᵣ (fst (invℝ₊ y))) z y
+     ∙ₑ substEquiv (_ <ᵣ_) (·ᵣComm _ _ ∙ [x/₊y]·yᵣ x y )
+
+ z/y<x₊≃z<y₊·x : ∀ x z (y : ℝ₊) → (z  ·ᵣ (fst (invℝ₊ y)) <ᵣ x)
+                          ≃ (z <ᵣ (fst y) ·ᵣ  x)
+ z/y<x₊≃z<y₊·x x z y =
+       z<x≃y₊·z<y₊·x _ _ y ∙ₑ
+        substEquiv (_<ᵣ (fst y) ·ᵣ x) (·ᵣComm _ _ ∙ [x/₊y]·yᵣ z y )
+
+
+ z≤x≃y₊·z≤y₊·x : ∀ x z (y : ℝ₊) → (z ≤ᵣ x) ≃ ((fst y) ·ᵣ z ≤ᵣ (fst y) ·ᵣ x)
+ z≤x≃y₊·z≤y₊·x x z y =  propBiimpl→Equiv (isSetℝ _ _) (isSetℝ _ _)
+  (≤ᵣ-o·ᵣ _ _ (fst y) (<ᵣWeaken≤ᵣ _ _ (snd y)))
+  (subst2 _≤ᵣ_
+   (·ᵣAssoc _ _ _ ∙ cong (_·ᵣ z) (·ᵣComm _ _ ∙ x·invℝ₊[x] y) ∙ ·IdL z)
+   (·ᵣAssoc _ _ _ ∙ cong (_·ᵣ x) (·ᵣComm _ _ ∙ x·invℝ₊[x] y) ∙ ·IdL x)
+   ∘S (≤ᵣ-o·ᵣ _ _ (fst (invℝ₊ y)) (<ᵣWeaken≤ᵣ _ _ (snd (invℝ₊ y)))))
+
+ z/y≤x₊≃z≤y₊·x : ∀ x z (y : ℝ₊) → (z  ·ᵣ (fst (invℝ₊ y)) ≤ᵣ x)
+                          ≃ (z ≤ᵣ (fst y) ·ᵣ  x)
+ z/y≤x₊≃z≤y₊·x x z y =
+       z≤x≃y₊·z≤y₊·x _ _ y ∙ₑ
+        substEquiv (_≤ᵣ (fst y) ·ᵣ x) (·ᵣComm _ _ ∙ [x/₊y]·yᵣ z y )
+
+ z≤x/y₊≃y₊·z≤x : ∀ x z (y : ℝ₊) → (z  ≤ᵣ x ·ᵣ (fst (invℝ₊ y)))
+                          ≃ ((fst y) ·ᵣ  z ≤ᵣ x)
+ z≤x/y₊≃y₊·z≤x x z y =
+       z≤x≃y₊·z≤y₊·x _ _ y ∙ₑ
+         substEquiv ((fst y) ·ᵣ z ≤ᵣ_)
+            (·ᵣComm _ _ ∙ [x/₊y]·yᵣ x y )
+
+
+ z/y'≤x/y≃y₊·z≤y'₊·x : ∀ x z (y y' : ℝ₊) → (z ·ᵣ (fst (invℝ₊ y'))
+                                      ≤ᵣ x ·ᵣ (fst (invℝ₊ y))) ≃
+                       ((fst y) ·ᵣ z ≤ᵣ (fst y') ·ᵣ x)
+ z/y'≤x/y≃y₊·z≤y'₊·x x z y y' =
+      z≤x/y₊≃y₊·z≤x _ _ _
+   ∙ₑ substEquiv (_≤ᵣ x) (·ᵣAssoc _ _ _)
+   ∙ₑ z/y≤x₊≃z≤y₊·x _ _ _
+
+ -- x/x'≤y/y'≃x/y≤x'/y' : ∀ x (x' y y' : ℝ₊) → (z ·ᵣ (fst (invℝ₊ y'))
+ --                                      ≤ᵣ x ·ᵣ (fst (invℝ₊ y))) ≃
+ --                       ((fst y) ·ᵣ z ≤ᵣ (fst y') ·ᵣ x)
+ -- x/x'≤y/y'≃x/y≤x'/y' x z y y' = ?
+ --   --    z≤x/y₊≃y₊·z≤x _ _ _
+ --   -- ∙ₑ substEquiv (_≤ᵣ x) (·ᵣAssoc _ _ _)
+ --   -- ∙ₑ z/y≤x₊≃z≤y₊·x _ _ _
+
+
+ z/y'<x/y≃y₊·z<y'₊·x : ∀ x z (y y' : ℝ₊) → (z ·ᵣ (fst (invℝ₊ y'))
+                                      <ᵣ x ·ᵣ (fst (invℝ₊ y))) ≃
+                       ((fst y) ·ᵣ z <ᵣ (fst y') ·ᵣ x)
+ z/y'<x/y≃y₊·z<y'₊·x x z y y' =
+      z<x/y₊≃y₊·z<x _ _ _
+   ∙ₑ substEquiv (_<ᵣ x) (·ᵣAssoc _ _ _)
+   ∙ₑ z/y<x₊≃z<y₊·x _ _ _
+
+
+ x/y≤x'/y'≃y'/x'≤y/x : ∀ (x x' y y' : ℝ₊) → (fst x ·ᵣ (fst (invℝ₊ y))
+                                      ≤ᵣ fst x' ·ᵣ (fst (invℝ₊ y'))) ≃
+                       (fst y' ·ᵣ (fst (invℝ₊ x'))
+                                      ≤ᵣ fst y ·ᵣ (fst (invℝ₊ x)))
+ x/y≤x'/y'≃y'/x'≤y/x x x' y y' =
+   z/y'≤x/y≃y₊·z≤y'₊·x _ _ _ _
+   ∙ₑ subst2Equiv (_≤ᵣ_) (·ᵣComm _ _) (·ᵣComm _ _)
+   ∙ₑ invEquiv (z/y'≤x/y≃y₊·z≤y'₊·x _ _ _ _)
+
+ 0<x≃0<y₊·x : ∀ x (y : ℝ₊) → (0 <ᵣ x) ≃ (0 <ᵣ (fst y) ·ᵣ x)
+ 0<x≃0<y₊·x x y =   propBiimpl→Equiv squash₁ squash₁
+    (λ 0<x → isTrans≡<ᵣ _ _ _ (sym (𝐑'.0RightAnnihilates  (fst y)))
+       (<ᵣ-o·ᵣ 0 x y 0<x))
+    λ 0<y·x →
+      isTrans<≡ᵣ _ _ x (isTrans≡<ᵣ _ _ _ (sym (𝐑'.0RightAnnihilates
+        (fst (invℝ₊ y))))
+       (<ᵣ-o·ᵣ 0 ((fst y) ·ᵣ x) (invℝ₊ y) 0<y·x))
+         (·ᵣAssoc _ _ _ ∙ cong (_·ᵣ x) (·ᵣComm _ _ ∙ x·invℝ₊[x] _) ∙ ·IdL x)
+
+
+
+ invℝ₊-<-invℝ₊ : ∀ x y → (fst (invℝ₊ x) <ᵣ fst (invℝ₊ y))
+                       ≃ (fst y <ᵣ fst x)
+ invℝ₊-<-invℝ₊ x y =
+      subst2Equiv _<ᵣ_ (sym (·IdL _)) (sym (·IdL _))
+   ∙ₑ z/y'<x/y≃y₊·z<y'₊·x 1 1 y x
+   ∙ₑ subst2Equiv _<ᵣ_ (·IdR _) (·IdR _)
+
+invℝ₊-≤-invℝ₊ : ∀ x y → (fst (invℝ₊ x) ≤ᵣ fst (invℝ₊ y))
+                      ≃ (fst y ≤ᵣ fst x)
+invℝ₊-≤-invℝ₊ x y =
+     subst2Equiv _≤ᵣ_ (sym (·IdL _)) (sym (·IdL _))
+  ∙ₑ z/y'≤x/y≃y₊·z≤y'₊·x 1 1 y x
+  ∙ₑ subst2Equiv _≤ᵣ_ (·IdR _) (·IdR _)
+
+
+invℝ₊-rat : ∀ q → fst (invℝ₊ (ℚ₊→ℝ₊ q)) ≡ fst (ℚ₊→ℝ₊ (invℚ₊ q))
+invℝ₊-rat q = invℝ₊≡invℝ _ (inl (snd (ℚ₊→ℝ₊ q))) ∙∙
+    invℝ-rat _ _ (inl (ℚ.0<ℚ₊ q)) ∙∙
+     cong rat (ℚ.invℚ₊≡invℚ _ _)
+
+
+
+invℝ₊· : ∀ x y →
+          invℝ₊ (x ₊·ᵣ y) ≡
+            (invℝ₊ x) ₊·ᵣ (invℝ₊ y)
+invℝ₊· x y =
+  ℝ₊≡ (invℝ₊≡invℝ (x ₊·ᵣ y) (inl (ℝ₊· x y)) ∙∙
+       invℝ· _ _ _ _ _
+       ∙∙ cong₂ _·ᵣ_
+        (sym (invℝ₊≡invℝ x (inl (snd x)))) (sym (invℝ₊≡invℝ y (inl (snd y)))) )
+
+
+invℝ₊Invol : ∀ x → invℝ₊ (invℝ₊ x) ≡ x
+invℝ₊Invol x = ℝ₊≡ $
+   fst (invℝ₊ (invℝ₊ x))
+       ≡⟨ (cong (fst ∘ invℝ₊) (ℝ₊≡ (invℝ₊≡invℝ _ _))) ⟩ _
+       ≡⟨ invℝ₊≡invℝ (_ , invℝ-pos _ _) _  ⟩ _
+       ≡⟨ invℝInvol (fst x) (inl (snd x)) ⟩ _ ∎
+
+
+invℝ₊1 : invℝ₊ 1 ≡ 1
+invℝ₊1 = ℝ₊≡ (invℝ₊≡invℝ 1 (inl decℚ<ᵣ?)  ∙ (invℝ1 _))
+
+
+1/x<1≃1<x : ∀ x → (fst (invℝ₊ x) <ᵣ 1) ≃ (1 <ᵣ fst x)
+1/x<1≃1<x x =
+  substEquiv (fst (invℝ₊ x) <ᵣ_) (sym (cong fst invℝ₊1))
+    ∙ₑ invℝ₊-<-invℝ₊ x 1
+
+1<x/y≃y<x : ∀ x y → (1 <ᵣ x ／ᵣ₊ y) ≃ (fst y <ᵣ x)
+1<x/y≃y<x x y =
+      substEquiv (_<ᵣ x ／ᵣ₊ y) (sym (x·invℝ₊[x] 1))
+   ∙ₑ z/y'<x/y≃y₊·z<y'₊·x x 1 y 1
+   ∙ₑ subst2Equiv _<ᵣ_ (·IdR _) (·IdL _)
+
+
+
+x+y≤z+y≃x≤z : ∀ x z y → (x +ᵣ y ≤ᵣ z +ᵣ y)
+                      ≃ (x ≤ᵣ z)
+x+y≤z+y≃x≤z x z y = propBiimpl→Equiv (isProp≤ᵣ _ _) (isProp≤ᵣ _ _)
+  (subst2 _≤ᵣ_ (𝐑'.plusMinus _ _) (𝐑'.plusMinus _ _)
+    ∘ ≤ᵣ-+o _ _ (-ᵣ y))
+ (≤ᵣ-+o _ _ _)
+
+
+x+y<z+y≃x<z : ∀ x z y → (x +ᵣ y <ᵣ z +ᵣ y)
+                      ≃ (x <ᵣ z)
+x+y<z+y≃x<z x z y = propBiimpl→Equiv (isProp<ᵣ _ _) (isProp<ᵣ _ _)
+  (subst2 _<ᵣ_ (𝐑'.plusMinus _ _) (𝐑'.plusMinus _ _)
+    ∘ <ᵣ-+o _ _ (-ᵣ y))
+ (<ᵣ-+o _ _ _)
+
+
+x+y<x+z≃y<z : ∀ x z y → (x +ᵣ y <ᵣ x +ᵣ z)
+                      ≃ (y <ᵣ z)
+x+y<x+z≃y<z x z y = propBiimpl→Equiv (isProp<ᵣ _ _) (isProp<ᵣ _ _)
+  (subst2 _<ᵣ_
+     ((λ i → +ᵣComm (-ᵣ x) (+ᵣComm x y i) i) ∙ 𝐑'.plusMinus y x)
+     ((λ i → +ᵣComm (-ᵣ x) (+ᵣComm x z i) i) ∙ 𝐑'.plusMinus z x)
+    ∘ <ᵣ-o+ _ _ (-ᵣ x))
+ (<ᵣ-o+ _ _ _)
+
+
+x'/x<[x'+y']/[x+y]≃[x'+y']/[x+y]<y'/y :
+  ∀ x x' y y' →
+     ((x' ／ᵣ₊ x) <ᵣ ((x' +ᵣ y') ／ᵣ₊ (x ₊+ᵣ y))) ≃
+       (((x' +ᵣ y') ／ᵣ₊ (x ₊+ᵣ y)) <ᵣ (y' ／ᵣ₊ y))
+x'/x<[x'+y']/[x+y]≃[x'+y']/[x+y]<y'/y x x' y y' =
+  z/y'<x/y≃y₊·z<y'₊·x _ _ _ _
+  ∙ₑ subst2Equiv _<ᵣ_ (·DistR+ _ _ _) (·DistL+ _ _ _)
+  ∙ₑ x+y<x+z≃y<z _ _ _ ∙ₑ invEquiv (x+y<z+y≃x<z _ _ _)
+  ∙ₑ subst2Equiv _<ᵣ_
+       ((sym (·DistL+ _ _ _))) (sym (·DistR+ _ _ _))
+  ∙ₑ invEquiv (z/y'<x/y≃y₊·z<y'₊·x _ _ _ _)
+
+
+opaque
+ unfolding _<ᵣ_ _+ᵣ_
+
+ IsUContinuousℚℙ→IsUContinuousℙ : ∀ f →
+   (∀ x 0<x y 0<y → x ≤ᵣ y → f x 0<x ≤ᵣ f y 0<y)
+   → IsUContinuousℚℙ (λ x → (0 <ᵣ x) , isProp<ᵣ _ _ ) (f ∘ rat)
+   → IsUContinuousℙ (λ x → (0 <ᵣ x) , isProp<ᵣ _ _ ) f
+ IsUContinuousℚℙ→IsUContinuousℙ f incr uc ε =
+   let (δ , Δ) = uc ε
+   in δ , λ u v u∈ v∈ →
+     ((λ u-v<δ →
+        PT.rec2
+          (isProp∼ _ _ _)
+          (λ (η , 0<η , η<)
+             (τ , 0<τ , τ<) →
+            let η' = ℚ.min₊ (η , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<η))
+                            (τ , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<τ))
+
+            in PT.rec2 (isProp∼ _ _ _)
+                   (λ ((u⊓v , uu) , (<η' , u⊓v< , <uu))
+                      ((vv , u⊔v) , (<η'' , vv< , <u⊔v)) →
+                     let xx = isTrans≤ᵣ _ _ _ (min≤ᵣ _ _) (≤maxᵣ _ _)
+
+                         η<* = a<b-c⇒a+c<b _
+                            (rat (fst δ)) _
+                           $ fst (z<x/y₊≃y₊·z<x _ _ (ℚ₊→ℝ₊ 2))
+                            (isTrans<≡ᵣ _ _ _ η<
+                              (cong ((rat (fst δ) -ᵣ absᵣ (u -ᵣ v)) ·ᵣ_)
+                                (sym (invℝ'-rat 2 _ (snd (ℚ₊→ℝ₊ 2))))))
+                         u⊓v<u⊔v = isTrans<ᵣ _ _ _
+                                   (isTrans<≤ᵣ _ _ _
+                                    (u⊓v<) xx) (<u⊔v)
+                         0<u⊓v : 0 <ᵣ rat u⊓v
+                         0<u⊓v = isTrans<ᵣ _ _ _
+                              (x<y→0<y-x _ _
+                                (isTrans<ᵣ _ _ _
+                                  (isTrans≤<ᵣ _ _ _
+                                    (isTrans≡≤ᵣ _ _ _
+                                     (minᵣComm (rat η) (rat τ))
+                                      (min≤ᵣ _ (rat η))) τ<)
+                                  <uu)
+                                )
+                             (a-b<c⇒a-c<b (rat uu) _ _
+                                    (<ℚ→<ᵣ (uu ℚ.- u⊓v) _ <η'))
+
+                         <η* : -ᵣ (rat u⊓v) <ᵣ -ᵣ rat uu +ᵣ rat (fst η')
+                         <η* = isTrans≡<ᵣ _ _ _
+                                  (sym (L𝐑.lem--04 {rat uu}))
+                                     (<ᵣ-o+ _ _ (-ᵣ (rat uu))
+                                   (<ℚ→<ᵣ (uu ℚ.- u⊓v) _ <η'))
+
+                         <η** : (rat u⊔v) <ᵣ rat (fst η') +ᵣ rat vv
+                         <η** = a-b<c⇒a<c+b (rat u⊔v) (rat vv) _ (<ℚ→<ᵣ _ _ <η'')
+
+                         z = Δ u⊓v u⊔v 0<u⊓v
+                             (isTrans<ᵣ _ _ _
+                              ((snd (maxᵣ₊ (u , u∈) (v , v∈)))) <u⊔v)
+                               (<ᵣ→<ℚ (ℚ.abs (u⊓v ℚ.- u⊔v))
+                                (fst δ)
+                                 (isTrans≡<ᵣ _ _ _
+                                  (cong rat (ℚ.absComm- _ _ ∙ ℚ.absPos _
+                                   (<ᵣ→<ℚ _ _ (x<y→0<y-x _ _ u⊓v<u⊔v))))
+                                     (isTrans≤<ᵣ _ _ _
+                                        (isTrans≤≡ᵣ _ _ _
+                                          (isTrans≤ᵣ _ _ _
+                                            (<ᵣWeaken≤ᵣ _ _
+                                           (<ᵣMonotone+ᵣ _ _ _ _
+                                            <η** <η*))
+                                            (isTrans≡≤ᵣ _ _ _
+                                              (L𝐑.lem--080
+                                           {rat (fst η')} {rat vv} {rat uu})
+                                            (≤ᵣMonotone+ᵣ _ _
+                                             (rat vv -ᵣ rat uu) _
+                                             (≤ᵣMonotone+ᵣ _ _ _ _
+                                               (min≤ᵣ _ (rat τ))
+                                               (min≤ᵣ _ (rat τ)))
+                                             (isTrans≤≡ᵣ _ _ _
+                                               (≤ᵣMonotone+ᵣ _ _ _ _
+                                             (<ᵣWeaken≤ᵣ _ _ vv<)
+                                              (<ᵣWeaken≤ᵣ _ _
+                                                (-ᵣ<ᵣ _ _ <uu)))
+                                               ((sym (absᵣNonNeg _
+                                                   (x≤y→0≤y-x _ _
+                                                     (isTrans≤ᵣ _ _ _
+                                                    (min≤ᵣ _ _) (≤maxᵣ _ _)))))
+                                                      ∙
+                                                      absᵣ-min-max _ _)))
+                                              ))
+                                           (cong (_+ᵣ _)
+                                              (x+x≡2x _))) η<*)))
+
+                     in invEq (∼≃abs<ε _ _ _)
+                          (isTrans≡<ᵣ _ _ _
+                           (sym (absᵣ-min-max _ _))
+                           (isTrans≤<ᵣ _ _ _
+                             ((absᵣ-monotoneOnNonNeg
+                                 (_ , fst (x≤y≃0≤y-x _ _)
+                                    (isTrans≤ᵣ _ _ _ (min≤ᵣ _ _) (≤maxᵣ _ _)))
+
+                                (_ , fst (x≤y≃0≤y-x _ _)
+                                (incr _ _ _ _ (<ᵣWeaken≤ᵣ _ _ u⊓v<u⊔v)))
+                              (≤ᵣMonotone+ᵣ _ _ _ _
+                                (isTrans≤ᵣ _ _ _
+                                    (incr→max≤ f incr _ _ _ _)
+                                     (incr _ _ _ _
+                                  (<ᵣWeaken≤ᵣ _ _ <u⊔v)))
+                                (-ᵣ≤ᵣ _ _
+                                  (isTrans≤ᵣ _ _ _ (incr _ _ _ _
+                                    (<ᵣWeaken≤ᵣ _ _ u⊓v<
+                                      )) (incr→≤min f incr _ _ _ _))))))
+                              (fst (∼≃abs<ε _ _ _) (sym∼ _ _ _ z)))))
+                 (∃rationalApprox (minᵣ u v) η')
+                 (∃rationalApprox (maxᵣ u v) η'))
+         (denseℚinℝ 0 (((rat (fst δ)) -ᵣ absᵣ (u -ᵣ v)) ·ᵣ  rat [ 1 / 2 ])
+                (isTrans≡<ᵣ _ _ _
+                  (sym (𝐑'.0LeftAnnihilates _))
+                  ((<ᵣ-·ᵣo 0 ((rat (fst δ)) -ᵣ absᵣ (u -ᵣ v))
+                    (ℚ₊→ℝ₊ ([ 1 / 2 ] , _))
+                    (x<y→0<y-x _ _ u-v<δ)))))
+                    (denseℚinℝ 0 (minᵣ u v)
+                       (snd (minᵣ₊ (u , u∈) (v , v∈))))
+
+        )
+      ∘ fst (∼≃abs<ε _ _ _))
+
+opaque
+ unfolding -ᵣ_
+ Seq⊆-abs<N-s⊇-⊤Pred : Seq⊆-abs<N Seq⊆.s⊇ ⊤Pred
+ Seq⊆-abs<N-s⊇-⊤Pred x _ =     PT.map
+       (λ (1+ n , X) →
+         n , (isTrans<≤ᵣ _ _ _ (-ᵣ<ᵣ _ _ X)
+                   (isTrans≡≤ᵣ _ _ _ (cong -ᵣ_ (-absᵣ x) )
+                     (isTrans≤≡ᵣ _ _ _ (-ᵣ≤ᵣ _ _ (≤absᵣ (-ᵣ x)))
+                        (-ᵣInvol _))))
+            , isTrans≤<ᵣ _ _ _ (≤absᵣ x) X)
+       (getClamps x)
+
+
+≤Weaken<+ᵣ : ∀ x y (z : ℝ₊) →
+       x ≤ᵣ y → x <ᵣ y +ᵣ fst z
+≤Weaken<+ᵣ x y z x≤y =
+  isTrans≡<ᵣ _ _ _ (sym (+IdR _))
+   (≤<ᵣMonotone+ᵣ x y 0 (fst z) x≤y (snd z))
+
+
+
+clam∈ℚintervalℙ : ∀ a b → (a ℚ.≤ b) → ∀ x →
+  ℚ.clamp a b x ∈ ℚintervalℙ a b
+clam∈ℚintervalℙ a b a≤b x = ℚ.≤clamp _ _ _ a≤b , (ℚ.clamp≤ _ _ _)
+
+∈ℚintervalℙ→clam≡ : ∀ a b → ∀ x →
+    x ∈ ℚintervalℙ a b → x ≡ ℚ.clamp a b x
+∈ℚintervalℙ→clam≡ a b x = sym ∘ uncurry (ℚ.inClamps a b x)
+
+∈ℚintervalℙ→clampᵣ≡ : ∀ a b → ∀ x →
+    x ∈ intervalℙ a b → x ≡ clampᵣ a b x
+∈ℚintervalℙ→clampᵣ≡ a b x (a≤x , x≤b) =
+ sym (≤→minᵣ _ _ x≤b)  ∙ cong (λ y → minᵣ y b) (sym (≤ᵣ→≡ a≤x))
+
+
+clamp-contained-agree : ∀ (a b a' b' x : ℚ)
+  → a ℚ.≤ a'
+  → b' ℚ.≤ b
+  → x ∈ ℚintervalℙ a' b'
+  → ℚ.clamp a b x ≡ ℚ.clamp a' b' x
+clamp-contained-agree a b a' b' x a≤a' b'≤b x∈ =
+  sym (∈ℚintervalℙ→clam≡ a b x
+   ((ℚ.isTrans≤ _ _ _ a≤a' (fst x∈)) ,
+    (ℚ.isTrans≤ _ _ _ (snd x∈) b'≤b))) ∙ ∈ℚintervalℙ→clam≡ a' b' x x∈
+
+
+
+clampᵣ∈ℚintervalℙ : ∀ a b → (a ≤ᵣ b) → ∀ x →
+  clampᵣ a b x ∈ intervalℙ a b
+clampᵣ∈ℚintervalℙ a b a≤b x =
+        ≤clampᵣ _ _ _ a≤b , min≤ᵣ' (maxᵣ a x) b
+
+≡clampᵣ→∈intervalℙ : ∀ a b → (a ≤ᵣ b) → ∀ x →
+  x ≡ clampᵣ a b x → x ∈ intervalℙ a b
+≡clampᵣ→∈intervalℙ a b a≤b x p =
+        subst-∈ (intervalℙ a b ) (sym p) (clampᵣ∈ℚintervalℙ a b a≤b x)
+
+
+∈ℚintervalℙ→∈intervalℙ : ∀ a b x → x ∈ ℚintervalℙ a b
+                                 → rat x ∈ intervalℙ (rat a) (rat b)
+∈ℚintervalℙ→∈intervalℙ a b x (a≤x , x≤b) = ≤ℚ→≤ᵣ _ _ a≤x , ≤ℚ→≤ᵣ _ _ x≤b
+
+∈intervalℙ→∈ℚintervalℙ : ∀ a b x → rat x ∈ intervalℙ (rat a) (rat b)
+                                 → x ∈ ℚintervalℙ a b
+∈intervalℙ→∈ℚintervalℙ a b x (a≤x , x≤b) = ≤ᵣ→≤ℚ _ _ a≤x , ≤ᵣ→≤ℚ _ _ x≤b
+
+x≤→clampᵣ≡ : ∀ a b x → a ≤ᵣ b  → x ≤ᵣ a →  clampᵣ a b x ≡ a
+x≤→clampᵣ≡ a b x a≤b x≤a = (≤→minᵣ _ _
+ (isTrans≡≤ᵣ _ _ _ ((maxᵣComm _ _) ∙ (≤→maxᵣ _ _ x≤a)) a≤b) ∙ maxᵣComm _ _)
+ ∙ ≤→maxᵣ _ _ x≤a
+
+≤x→clampᵣ≡ : ∀ a b x → a ≤ᵣ b → b ≤ᵣ x →  clampᵣ a b x ≡ b
+≤x→clampᵣ≡ a b x a≤b b≤x =
+  cong (flip minᵣ b)
+    (≤→maxᵣ _ _ (isTrans≤ᵣ _ _ _ a≤b b≤x))
+   ∙ minᵣComm _ _ ∙ ≤→minᵣ _ _ b≤x
+
+
+min-monotone-≤ᵣ : ∀ a → ∀ x y  → x ≤ᵣ y →
+                       minᵣ x a ≤ᵣ minᵣ y a
+min-monotone-≤ᵣ a x y x≤y =
+ ≤min-lem _ _ _ (isTrans≤ᵣ _ _ _ (min≤ᵣ _ _) x≤y)
+  (isTrans≡≤ᵣ _ _ _ (minᵣComm _ _) (min≤ᵣ _ _) )
+
+max-monotone-≤ᵣ : ∀ a → ∀ x y  → x ≤ᵣ y →
+                       maxᵣ a x ≤ᵣ maxᵣ a y
+max-monotone-≤ᵣ a x y x≤y =
+ max≤-lem _ _ _
+   (≤maxᵣ _ _)
+   (isTrans≤ᵣ _ _ _ x≤y
+    (isTrans≤≡ᵣ _ _ _
+      (≤maxᵣ _ _)
+      (maxᵣComm _ _)))
+
+clamp-monotone-≤ᵣ : ∀ a b x y  → x ≤ᵣ y →
+                       clampᵣ a b x ≤ᵣ clampᵣ a b y
+clamp-monotone-≤ᵣ a b x y x≤y =
+  min-monotone-≤ᵣ b _ _ (max-monotone-≤ᵣ a _ _ x≤y)
+
+opaque
+ unfolding _+ᵣ_
+ clampDistᵣ' : ∀ L L' x y →
+     absᵣ (clampᵣ (rat L) (rat L') y -ᵣ clampᵣ (rat L) (rat L') x) ≤ᵣ absᵣ (y -ᵣ x)
+ clampDistᵣ' L L' = ≤Cont₂
+           (cont∘₂ IsContinuousAbsᵣ
+             (contNE₂∘ sumR ((λ _ → IsContinuousClamp (rat L) (rat L')) , λ _ → IsContinuousConst _)
+               ((λ _ → IsContinuousConst _) , λ _ → IsContinuous∘ _ _ IsContinuous-ᵣ (IsContinuousClamp (rat L) (rat L')))))
+           (cont∘₂ IsContinuousAbsᵣ
+              (contNE₂∘ sumR ((λ _ → IsContinuousId) , λ _ → IsContinuousConst _)
+               ((λ _ → IsContinuousConst _) , λ _ → IsContinuous-ᵣ )))
+           λ u u' →
+              subst2 _≤ᵣ_ (sym (absᵣ-rat _) ∙ cong absᵣ (sym (-ᵣ-rat₂ _ _)))
+                ( sym (absᵣ-rat _) ∙ cong absᵣ (sym (-ᵣ-rat₂ _ _)))
+                (≤ℚ→≤ᵣ _ _ (ℚ.clampDist L L' u u'))
diff --git a/Cubical/HITs/CauchyReals/Lems.agda b/Cubical/HITs/CauchyReals/Lems.agda
index 5bf319e904..ed7bdf3798 100644
--- a/Cubical/HITs/CauchyReals/Lems.agda
+++ b/Cubical/HITs/CauchyReals/Lems.agda
@@ -6,14 +6,21 @@ open import Cubical.Foundations.Structure
 
 
 open import Cubical.Data.List
+open import Cubical.Data.Nat using (ℕ)
 
 import Cubical.Algebra.CommRing as CR
 
 open import Cubical.Tactics.CommRingSolver
 
+
+
 module Lems (R : CR.CommRing ℓ-zero) where
  open CR.CommRingStr (snd R)
 
+ [_]r : ℕ → fst R
+ [ ℕ.zero ]r = 0r
+ [ ℕ.suc (ℕ.zero) ]r = 1r
+ [ ℕ.suc x@(ℕ.suc _) ]r = 1r + [ x ]r
 
  lem-01 : ∀ ε δ η η' a →
        (ε - (δ + η)) +
@@ -260,6 +267,88 @@ module Lems (R : CR.CommRing ℓ-zero) where
               ≡ y · (x' - x) + x' · (y' - y)
  lem--065 = solve! R
 
+ lem--066 : (x' - y') + (x - y)
+              ≡ (x' - y) + (x - y')
+ lem--066 = solve! R
+
+ lem--067 : (x' - y') - (y - x)
+              ≡ (x' - y) + (x - y')
+ lem--067 = solve! R
+
+ lem--068 : (x' - y') - (y - x)
+              ≡ (x' - y) - (y' - x)
+ lem--068 = solve! R
+
+ lem--069 : (((a · ((q + q') - δ)) - (a · (x - δ))) + y)
+             - (((a · (q - δ)) - (a · (x' - δ))) + y') ≡
+                (a · (q' - (x - x')) + (y - y'))
+ lem--069 = solve! R
+
+ lem--070 : - (a · b) ≡ a · (- b)
+ lem--070 = solve! R
+
+ lem--071 : x' - (y - ((x + y) - x)) ≡ x'
+ lem--071 = solve! R
+
+ lem--072 : x - (x + y) ≡ - y
+ lem--072 = solve! R
+
+ lem--073 : (x - y) · (x - y) ≡ (x · x + y · y) - (( x · y ) + ( x · y ))
+ lem--073 = solve! R
+
+ lem--074 : (x - y) + (y + x') ≡ x + x'
+ lem--074 = solve! R
+
+ lem--075 : (y + x') - (x + x')  ≡ y - x
+ lem--075 = solve! R
+
+ lem--076 : x - y + (x - y) - (x' - y) ≡ x + x - x' - y
+ lem--076 = solve! R
+
+ lem--077 : x - y ≡ (x' - y) + (x - x')
+ lem--077 = solve! R
+
+ lem--078 : y - x' ≡ (y + (y' - x')) - y'
+ lem--078 = solve! R
+
+ lem--079 : y - (y - x) ≡ x
+ lem--079 = solve! R
+
+ lem--080 : (ε + x) + ((- y) + ε) ≡ (ε + ε) + (x - y)
+ lem--080 = solve! R
+
+ lem--081 : (q + x) - (q + y) ≡ x - y
+ lem--081 = solve! R
+
+ lem--082 : (((ε - θ) - η) + (θ + η')) ≡ ε + (η' - η)
+ lem--082 = solve! R
+
+ lem--083 : x - y ≡ (- y) - (- x)
+ lem--083 = solve! R
+
+ lem--084 : δ - ε ≡ (- (ε - δ))
+ lem--084 = solve! R
+
+ lem--085 : (((x - 1r) · (x - 1r)) · ([ 2 ]r · x - 1r)) ≡ (x · ((([ 2 ]r) · (x - 1r)) · (x - 1r)
+           - (x - 1r) + 1r)) - 1r
+ lem--085 = solve! R
+
+ lem--086 : (x · y) · (x' · y') ≡ (x · x') · (y · y')
+ lem--086 = solve! R
+
+ lem--087 : x + y + (x' + y') ≡ x + x' + (y + y')
+ lem--087 = solve! R
+
+ lem--088 : (x + y) - (x + y') ≡ (y - y')
+ lem--088 = solve! R
+
+ lem--089 : y - (y' + x) ≡ (y - y') - x
+ lem--089 = solve! R
+
+ lem--090 : (η · (y · y')) · (x · η') ≡ (((x · y) · y') · η) · η'
+ lem--090 = solve! R
+
+
 open import Cubical.Data.Rationals as ℚ
 
 
diff --git a/Cubical/HITs/CauchyReals/Lipschitz.agda b/Cubical/HITs/CauchyReals/Lipschitz.agda
index 45592123f6..9b1cb3dc98 100644
--- a/Cubical/HITs/CauchyReals/Lipschitz.agda
+++ b/Cubical/HITs/CauchyReals/Lipschitz.agda
@@ -78,6 +78,18 @@ sΣℚ<' {u} {v} {ε} p x =
    subst∼ (sym (lem--035 {fst ε} {fst δ}))
      $ 𝕣-lim r y (fst ε ℚ.- fst δ , v₁) δ p x
 
+-- 𝕣-lim'← : ∀ r y p ε
+--          → r ∼[ ε ] (lim y p )
+--          → (∀ δ v → r ∼[ fst ε ℚ.- fst δ , v ] ( y δ ))
+
+-- 𝕣-lim'← r y p ε r~lim δ v  = {!!}
+
+-- 𝕣-lim'≃ : ∀ r y ε δ p v →
+--           (r ∼[ fst ε ℚ.- fst δ , v ] ( y δ )
+--             ≃ r ∼[ ε ] (lim y p ))
+-- 𝕣-lim'≃ r y ε δ p v₁ x =
+--    {!!}
+
 
 -- HoTT Lemma (11.3.10)
 lim-surj : ∀ r → ∃[ x ∈ _ ] (r ≡ (uncurry lim x) )
@@ -178,6 +190,7 @@ 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∼ _ _ _
 
@@ -257,6 +270,7 @@ fromLipschitz L (f , fL) = f' ,
  f' = Elimℝ.go w
 
 
+
 ∼-monotone< : ∀ {u v ε ε'} → fst ε ℚ.< fst ε' → u ∼[ ε ] v → u ∼[ ε' ] v
 ∼-monotone< {u} {v} {ε} {ε'} x x₁ =
   subst∼ (lem--05 {fst ε} {fst ε'})
@@ -651,3 +665,9 @@ fromLipshitzNEβ : ∀ f (fl : Lipschitz-ℚ→ℝ 1 f) x y →
      _
 fromLipshitzNEβ f fl x y = congLim' _ _ _
  λ q → cong (Elimℝ.go _ ∘ x) (ℚ₊≡ $ ℚ.·IdL _)
+
+fromLipshitzβLim : ∀ L f (fl : Lipschitz-ℚ→ℝ L f) x y →
+  fst (fromLipschitz L (f , fl)) (lim x y) ≡
+    lim (λ x₁ → Elimℝ.go _ (x (invℚ₊ L ℚ₊· x₁)))
+     _
+fromLipshitzβLim L f fl x y = refl
diff --git a/Cubical/HITs/CauchyReals/MeanValue.agda b/Cubical/HITs/CauchyReals/MeanValue.agda
new file mode 100644
index 0000000000..53799a40e2
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/MeanValue.agda
@@ -0,0 +1,610 @@
+{-# OPTIONS --safe #-}
+
+module Cubical.HITs.CauchyReals.MeanValue where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Equiv.Properties
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.Powerset
+open import Cubical.Functions.FunExtEquiv
+
+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.Data.Fin
+
+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
+open import Cubical.HITs.CauchyReals.Sequence
+open import Cubical.HITs.CauchyReals.Derivative
+open import Cubical.HITs.CauchyReals.Integration
+open import Cubical.HITs.CauchyReals.Exponentiation
+open import Cubical.HITs.CauchyReals.ExponentiationDer
+
+open import Cubical.Tactics.CommRingSolver
+
+
+
+Dichotomyℝ' : ∀ x y z → x <ᵣ z →
+              ∥ (y <ᵣ z) ⊎ (x <ᵣ y) ∥₁
+Dichotomyℝ' x y z x<z =
+  PT.map2
+   (λ (q  , x<q  , q<x+Δ)
+      (q' , y-Δ<q' , q'<y)
+     → ⊎.map
+         (λ q'≤q →
+           isTrans<ᵣ _ _ _
+             (a-b<c⇒a<c+b _ _ _ y-Δ<q')
+             (isTrans<≡ᵣ _ _ _
+               (<ᵣ-+o _ _ _
+                 ((isTrans≤<ᵣ _ _ _ (≤ℚ→≤ᵣ q' _ q'≤q)
+                  q<x+Δ )))
+               ((sym (+ᵣAssoc _ _ _)  ∙
+                cong (x +ᵣ_) (sym (·DistL+ _ _ _) ∙
+                 𝐑'.·IdR' _ _ (+ᵣ-rat _ _ ∙ decℚ≡ᵣ?) ))
+                ∙ L𝐑.lem--05 {x} {z})))
+         (λ q<q' →
+           isTrans<ᵣ _ _ _ (isTrans<ᵣ _ _ _
+               x<q
+               (<ℚ→<ᵣ q _ q<q'))
+             q'<y)
+         (ℚ.Dichotomyℚ q' q))
+    (denseℚinℝ x (x +ᵣ (fst Δ₊))
+      (isTrans≡<ᵣ _ _ _
+        (sym (+IdR x)) (<ᵣ-o+ _ _ _ (snd Δ₊))))
+    (denseℚinℝ (y -ᵣ (fst Δ₊)) y
+      (isTrans<≡ᵣ _ _ _
+         (<ᵣ-o+ _ _ _
+           (isTrans<≡ᵣ _ _ _ (-ᵣ<ᵣ _ _ (snd Δ₊)) (-ᵣ-rat 0)))
+         (+IdR y)))
+
+ where
+ Δ₊ : ℝ₊
+ Δ₊ = (z -ᵣ x , x<y→0<y-x _ _ x<z) ₊·ᵣ ℚ₊→ℝ₊ ([ 1 / 2 ] , _)
+
+Bishop-Proposition7 : ∀ n (f : Fin n → ℝ)
+ → 0 <ᵣ foldlFin {n = n} (λ a k → a +ᵣ f k) 0 (idfun _)
+ → ∃[ k ∈ Fin n ] 0 <ᵣ f k
+Bishop-Proposition7 zero f x = ⊥.rec (isIrrefl<ᵣ 0 x)
+Bishop-Proposition7 (suc n) f x =
+  PT.rec squash₁
+  (λ (ε , 0<ε , ε<∑) →
+    let ε₊ = (ε , ℚ.<→0< ε (<ᵣ→<ℚ 0 ε 0<ε))
+    in PT.rec squash₁
+          (⊎.rec
+            (λ f0<ε/2 →
+              let zz = isTrans<≡ᵣ _ _ _ (isTrans<ᵣ _ _ _
+                       (snd (ℚ₊→ℝ₊ (/2₊ ε₊))) (isTrans≡<ᵣ _ _ _
+                        (sym L𝐑.lem--04 ∙
+                          cong₂ _+ᵣ_ refl (+ᵣ-rat _ _
+                           ∙ cong rat (ℚ.ε/2+ε/2≡ε ε)))
+                        (<ᵣMonotone+ᵣ _ _ _ _
+                         (-ᵣ<ᵣ _ _ f0<ε/2)
+                         (isTrans<≡ᵣ _ _ _ ε<∑
+                           (foldFin+0ᵣ n (fsuc) (f) _
+                            ∙ cong₂ _+ᵣ_ (+IdL _) refl)))))
+                          (L𝐑.lem--04 ∙ foldFin+map n 0 f fsuc (idfun _))
+                  z = Bishop-Proposition7 n (f ∘ fsuc) zz
+              in PT.map ((_ ,_) ∘ snd) z)
+            (∣_∣₁ ∘ (_ ,_)))
+         ((Dichotomyℝ' 0 (f fzero) (rat (fst (/2₊ ε₊))) (snd (ℚ₊→ℝ₊ (/2₊ ε₊))) )))
+  (denseℚinℝ 0 _ x)
+
+
+
+
+-- uDerivativeOfℙ→at : ∀ P f f' x x∈
+--    → uDerivativeOfℙ P , f is f'
+--    → derivativeOfℙ P , f at (x , x∈) is (f' x x∈)
+-- uDerivativeOfℙ→at P f f' x x∈ X ε =
+--   PT.map (λ  λ X' h h∈ 0＃h ∣h∣<ε
+--     → X' x x∈ h h∈ 0＃h
+--       (isTrans≡<ᵣ _ _ _
+--         (-absᵣ h ∙ cong absᵣ (sym (+IdL _)))
+--         ∣h∣<ε)) {!X ?!}
+
+
+Fin-∀A⊎∃B : ∀ n → (A B : Fin n → Type₀)
+           → (∀ k → ∥ A k ⊎ B k ∥₁)
+           → ∥ (∀ k → A k) ⊎ Σ _ B ∥₁
+
+Fin-∀A⊎∃B zero A B ab? = ∣ inl (⊥.rec ∘ ¬Fin0) ∣₁
+Fin-∀A⊎∃B (suc n) A B ab? =
+  PT.map2
+     (⊎.rec (λ a0 →
+       ⊎.map (λ ∀kA →
+              λ { (zero , _) → subst A (toℕ-injective refl) a0
+                ; (suc k , l , p) →
+                  subst A (toℕ-injective refl) (∀kA (k , l ,
+                    injSuc (sym (+-suc _ _) ∙ p)))
+                })
+        λ (k , bk) → _ , bk) (λ b0 _ → inr (_ , b0)))
+    (ab? fzero)
+    (Fin-∀A⊎∃B n (A ∘ fsuc) (B ∘ fsuc) (ab? ∘ fsuc))
+
+ε<abs→ε<⊎<-ε : ∀ (ε : ℝ₊) x → fst ε <ᵣ absᵣ x →
+                        (x <ᵣ -ᵣ (fst ε)) ⊎ (fst ε <ᵣ x)
+ε<abs→ε<⊎<-ε ε x ε<∣x∣ =
+
+   ⊎.map (λ x<0 → isTrans≡<ᵣ _ _ _
+        (sym (-ᵣInvol _) ∙
+         cong -ᵣ_ (sym (absᵣNeg _ x<0))) (-ᵣ<ᵣ _ _ ε<∣x∣))
+      (λ 0<x → isTrans<≡ᵣ _ _ _ ε<∣x∣ (absᵣPos _ 0<x))
+   (invEq (＃≃0<dist x 0)
+      (isTrans<≡ᵣ _ _ _
+        (isTrans<ᵣ _ _ _ (snd ε) ε<∣x∣)
+        (cong absᵣ (sym (𝐑'.+IdR' _ _ (-ᵣ-rat 0))))))
+ where
+ -ε<ε = isTrans<ᵣ _ _ _
+    (isTrans<≡ᵣ _ _ _
+      (-ᵣ<ᵣ _ _ (snd ε))
+      (-ᵣ-rat 0))
+    (snd ε)
+
+equalPartitionStrict∃ : ∀ a b → a <ᵣ b → (ε : ℚ₊) →
+ ∃[ pa ∈ Partition[ a , b ] ] (isStrictPartition pa × mesh≤ᵣ pa (rat (fst ε)))
+equalPartitionStrict∃ a b a<b ε =
+  PT.map2 w
+    (denseℚinℝ a (a +ᵣ fst η)
+      (isTrans≡<ᵣ _ _ _
+        (sym (+IdR a)) (<ᵣ-o+ _ _ _ (snd η))))
+    (denseℚinℝ (b -ᵣ fst η) b
+     ((isTrans<≡ᵣ _ _ _
+         (<ᵣ-o+ _ _ _
+           (isTrans<≡ᵣ _ _ _ (-ᵣ<ᵣ _ _ (snd η)) (-ᵣ-rat 0)))
+         (+IdR b))))
+
+  where
+  Δ₊ : ℝ₊
+  Δ₊ = _ , x<y→0<y-x _ _ a<b
+  η : ℝ₊
+  η = minᵣ₊ (Δ₊ ₊·ᵣ (ℚ₊→ℝ₊ ([ 1 / 2 ] , _))) (ℚ₊→ℝ₊ ε)
+
+  w : _
+  w (a' , a<a' , a'<a+η) (b' , b-η<b' , b'<b) =
+    w' , ww' , www'
+   where
+   h = min≤ᵣ (fst (Δ₊ ₊·ᵣ (ℚ₊→ℝ₊ ([ 1 / 2 ] , _)))) (fst (ℚ₊→ℝ₊ ε))
+   a'<b' = <ᵣ→<ℚ _ _
+     (isTrans<ᵣ _ _ _
+       a'<a+η
+       (isTrans≤<ᵣ _ _ _
+         (a+b≤c⇒b≤c-b _ _ _
+           (isTrans≡≤ᵣ _ _ _
+             (+ᵣComm _ _
+              ∙ sym (+ᵣAssoc _ _ _))
+              (b≤c-b⇒a+b≤c _ _ _
+               (isTrans≤≡ᵣ _ _ _
+                   (≤ᵣMonotone+ᵣ _ _ _ _ h h)
+                   (sym
+                    (·DistL+ (fst Δ₊) (rat [ 1 / 2 ]) (rat [ 1 / 2 ]))
+                    ∙ 𝐑'.·IdR' _ _ (+ᵣ-rat _ _ ∙
+                     decℚ≡ᵣ?))))))
+         b-η<b'))
+   rtp = RefinableTaggedPartition[_,_].tpTP
+     (rtp-1/n a' b' (ℚ.<Weaken≤ a' b' a'<b')) ε
+
+   module eqp = Partition[_,_] (fst (fst rtp))
+   w' : Partition[ a , b ]
+   w' .len = suc (suc eqp.len)
+   w' .pts = eqp.pts'
+   w' .a≤pts k = isTrans≤ᵣ _ _ _
+       (<ᵣWeaken≤ᵣ _ _ a<a') (eqp.a≤pts' k)
+   w' .pts≤b k = isTrans≤ᵣ _ _ _ (eqp.pts'≤b k)
+         (<ᵣWeaken≤ᵣ _ _ b'<b)
+   w' .pts≤pts = eqp.pts'≤pts'
+
+   hlpr : ∀ k k< k<' → pts' w' (suc k , k<) ≡ eqp.pts' (k , k<')
+   hlpr k (zero , p) (l , p') =
+     ⊥.rec (znots (inj-m+
+         (+-zero k ∙ injSuc (injSuc p) ∙ sym p' ∙ +-comm l (suc k)
+       ∙ sym (+-suc k l))))
+   hlpr k k<@(suc l , snd₁) k<' =
+    cong {x = k , _} {(k , k<')}
+      eqp.pts' (toℕ-injective refl)
+
+   ww' : isStrictPartition w'
+   ww' (zero , zero , p) = ⊥.rec (znots (injSuc p))
+   ww' (zero , suc l , p) = a<a'
+   ww' (suc zero , zero , p) = ⊥.rec (znots (injSuc (injSuc p)))
+   ww' (suc (suc k) , zero , p) = b'<b
+   ww' (suc k , suc l , p) =
+     subst2 _<ᵣ_
+       (sym (hlpr k (snd (finj (suc k , suc l , p))) _))
+       (sym (hlpr (suc k) (snd (fsuc (suc k , suc l , p)))
+           (snd (fsuc (k , l , _)))))
+       (Integration.isStrictEqualPartition (rat a') (rat b')
+        _ (<ℚ→<ᵣ _ _ a'<b')
+        _
+         (k , l , injSuc (sym (+-suc _ _) ∙ injSuc p)))
+
+   www' : mesh≤ᵣ w' (rat (fst ε))
+   www' (zero , zero , p) = ⊥.rec (znots (injSuc p))
+   www' (zero , suc l , p) =
+     isTrans≤ᵣ _ _ _
+       (<ᵣWeaken≤ᵣ _ _ (a<c+b⇒a-c<b _ _ _ a'<a+η))
+       (min≤ᵣ' (fst (Δ₊ ₊·ᵣ (ℚ₊→ℝ₊ ([ 1 / 2 ] , _)))) (fst (ℚ₊→ℝ₊ ε)))
+   www' (suc zero , zero , p) = ⊥.rec (znots (injSuc (injSuc p)))
+   www' (suc (suc k) , zero , p) =
+     isTrans≤ᵣ _ _ _
+       (<ᵣWeaken≤ᵣ _ _ (a-b<c⇒a-c<b _ _ _ b-η<b'))
+       (min≤ᵣ' (fst (Δ₊ ₊·ᵣ (ℚ₊→ℝ₊ ([ 1 / 2 ] , _)))) (fst (ℚ₊→ℝ₊ ε)))
+   www' (suc k , suc l , p) =
+     isTrans≡≤ᵣ _ _ _
+       (cong₂ _-ᵣ_
+         (hlpr (suc k) (snd (fsuc (suc k , suc l , p)))
+           (snd (fsuc (k , l , _))))
+         (hlpr k (snd (finj (suc k , suc l , p))) _))
+       (snd rtp (k , l , injSuc (sym (+-suc _ _) ∙ injSuc p)))
+
+
+allOnOneSideLemma : ∀ n (ε : ℝ₊) (f : Fin (suc n) → ℝ)
+            → (∀ k → absᵣ (f (fsuc k) -ᵣ f (finj k)) <ᵣ fst ε )
+            → (∀ k → (f k <ᵣ -ᵣ (fst ε  ·ᵣ rat [ 1 / 2 ]))
+                ⊎ (fst ε ·ᵣ rat [ 1 / 2 ] <ᵣ f k))
+
+            → (∀ k → f k <ᵣ -ᵣ (fst ε  ·ᵣ rat [ 1 / 2 ])) ⊎
+              (∀ k → fst ε  ·ᵣ rat [ 1 / 2 ] <ᵣ f k)
+allOnOneSideLemma zero ε f fΔ f⊎ =
+  ⊎.map
+    (λ f0 k → isTrans≡<ᵣ _ _ _ (cong f (sym (snd (isContrFin1) k) )) f0)
+    (λ f0 k → isTrans<≡ᵣ _ _ _ f0 (cong f (snd (isContrFin1) k)))
+    (f⊎ fzero)
+allOnOneSideLemma (suc n) ε f fΔ f⊎ =
+  ⊎.map
+    (λ fs → ⊎.rec
+           (λ f0< →
+             λ { (zero , p) →
+                   isTrans≡<ᵣ _ _ _ (cong f (toℕ-injective refl)) f0<
+               ; (suc k , p) →
+                  isTrans≡<ᵣ _ _ _ (cong f (toℕ-injective refl))
+                   (fs (k , ℕ.pred-≤-pred p))})
+           (λ <f0 _ →
+              ⊥.rec
+                 (isAsym<ᵣ (fst ε)
+                           (absᵣ (f (fsuc fzero) -ᵣ f (finj fzero)))
+                   (isTrans<≤ᵣ _ _ _
+                     (isTrans≡<ᵣ _ _ _
+                     ((sym (𝐑'.·IdR' _ _ (+ᵣ-rat _ _ ∙
+                       decℚ≡ᵣ?))
+                      ∙ ·DistL+ _ _ _ )
+                      ∙ cong₂ _+ᵣ_
+                        (sym (-ᵣInvol _))
+                        refl)
+                      (<ᵣMonotone+ᵣ _ _ _ _ (-ᵣ<ᵣ _ _ (fs fzero)) (<f0)))
+                      (isTrans≤≡ᵣ _ _ _
+                        (≤absᵣ _)
+                        (cong absᵣ (+ᵣComm _ _)
+                          ∙ minusComm-absᵣ _ _)))
+                     (fΔ fzero)
+                     ))
+       (f⊎ (finj fzero)))
+    (λ fs → ⊎.rec
+           (λ f0< → ⊥.rec
+                 ((isAsym<ᵣ (fst ε)
+                           (absᵣ (f (fsuc fzero) -ᵣ f (finj fzero)))
+                  ((isTrans<≤ᵣ _ _ _
+                     (isTrans≡<ᵣ _ _ _
+                     ((sym (𝐑'.·IdR' _ _ (+ᵣ-rat _ _ ∙
+                       decℚ≡ᵣ?))
+                      ∙ ·DistL+ _ _ _ )
+                      ∙ cong₂ _+ᵣ_ refl
+                              (sym (-ᵣInvol _))
+                        )
+                          (isTrans<≡ᵣ _ _ _
+                           (<ᵣMonotone+ᵣ _ _ _ _
+                           (fs fzero) (-ᵣ<ᵣ _ _  (f0<)))
+                           (+ᵣComm _ _ ∙
+                             cong₂ _+ᵣ_
+                              (cong (-ᵣ_ ∘ f) (toℕ-injective refl))
+                               refl)))
+                      (isTrans≤≡ᵣ _ _ _
+                        (≤absᵣ _)
+                        (cong absᵣ (+ᵣComm _ _))))))
+                           (fΔ fzero)))
+           (λ <f0 →
+               λ { (zero , p) →
+                     isTrans<≡ᵣ _ _ _ <f0 (cong f (toℕ-injective refl))
+                 ; (suc k , p) →
+                   isTrans<≡ᵣ _ _ _ (fs (k , ℕ.pred-≤-pred p))
+                      (cong f (toℕ-injective refl))})
+       (f⊎ fzero))
+    (allOnOneSideLemma n ε (f ∘ fsuc)
+      ((λ {a} → isTrans≡<ᵣ _ _ _
+       (cong (λ ffa → absᵣ (f (fsuc (fsuc a)) -ᵣ f ffa))
+         (toℕ-injective refl) ))
+       ∘ (fΔ ∘ fsuc))
+       (f⊎ ∘ fsuc))
+
+
+Rolle'sTheorem : ∀ a b → a <ᵣ b → ∀ a∈ b∈ f f'
+  → IsUContinuousℙ (intervalℙ a b) f'
+  → uDerivativeOfℙ (intervalℙ a b) , f is f'
+  → f a a∈ ≡ f b b∈
+  → ∀ (ε : ℚ₊) → ∃[ (x₀ , x∈) ∈ Σ _ (_∈ intervalℙ a b) ]
+            absᵣ (f' x₀ x∈) <ᵣ rat (fst ε)
+Rolle'sTheorem a b a<b a∈ b∈ f f' ucf udf fa≡fb ε =
+  PT.rec squash₁ (w (ucf ε)) (udf (/2₊ ε))
+
+ where
+ w : _ → _ → _
+ w (δ , X) (δ' , X') = PT.rec squash₁ ww
+   (equalPartitionStrict∃ a b a<b δ⊓δ')
+  where
+  δ⊓δ' = ℚ.min₊ (/2₊ δ) (/2₊ δ')
+
+
+  ww : _
+  ww (pa , str-pa , mesh-pa) =
+    PT.rec squash₁
+      (⊎.rec (∀case ∘ (ε<abs→ε<⊎<-ε (ℚ₊→ℝ₊ (/2₊ ε)) _ ∘_))
+             (∣_∣₁ ∘ (_ ,_) ∘ snd))
+     (Fin-∀A⊎∃B (suc (suc Pa.len))
+       _ _
+        λ k → PT.map (Iso.fun ⊎-swap-Iso) (Dichotomyℝ'
+                        (rat (fst (/2₊ ε)))
+                   (absᵣ (f' (Pa.pts' (finj k))
+                     (Pa.a≤pts' (finj k) , Pa.pts'≤b (finj k))))
+                   ((rat (fst ε)))
+                   (<ℚ→<ᵣ _ _ (ℚ.x/2<x ε))))
+   where
+   module Pa = Partition[_,_] pa
+
+
+
+   z : ∀ f f' → f a a∈ ≡ f b b∈ →
+          ((x : ℝ) (x∈ : x ∈ intervalℙ a b) (h : ℝ)
+           (h∈ : x +ᵣ h ∈ intervalℙ a b) (0＃h : rat [ pos 0 / 1+ 0 ] ＃ h) →
+           absᵣ h <ᵣ rat (fst δ') →
+           absᵣ (f' x x∈ -ᵣ differenceAtℙ (intervalℙ a b) f x h 0＃h x∈ h∈) <ᵣ
+           rat (fst (/2₊ ε)))
+        → ∃-syntax (Fin (suc (suc Pa.len)))
+        (λ k → (-ᵣ rat (fst ε))
+          <ᵣ f' (Pa.pts' (finj k)) (Pa.a≤pts' (finj k) , Pa.pts'≤b (finj k)))
+   z f f' fa≡fb X' = PT.map
+          (map-snd
+           λ {l} X → 0<y-x→x<y _ _
+             (isTrans<≡ᵣ _ _ _
+              (isTrans≡<ᵣ _ _ _ (sym (𝐑'.0LeftAnnihilates _))
+              (invEq (z/y<x₊≃z<y₊·x _ _ (_ , x<y→0<y-x _ _ (str-pa l)))
+                (isTrans<≡ᵣ _ _ _ X
+                (·ᵣComm _ _))))
+                (cong₂ _+ᵣ_ refl
+                 (sym (-ᵣInvol _)))))
+        (Bishop-Proposition7 (suc (suc Pa.len))
+        (λ k → (f' (Pa.pts' (finj k))
+                     (Pa.a≤pts' (finj k) , Pa.pts'≤b (finj k))
+                    +ᵣ rat (fst ε))
+             ·ᵣ (Pa.pts' (fsuc k) -ᵣ Pa.pts' (finj k)))
+        (isTrans≡<ᵣ _ _ _
+           (sym (𝐑'.+InvR' _ _ (sym fa≡fb))
+             ∙ cong₂ _-ᵣ_
+                (cong (f b) (∈-isProp (intervalℙ a b) _ _ _))
+                (cong (f a) (∈-isProp (intervalℙ a b) _ _ _))
+             ∙ sym (deltas-sum (suc (suc Pa.len))
+               λ k → f (Pa.pts' k) (Pa.a≤pts' k , Pa.pts'≤b k)))
+           (foldFin+< (suc Pa.len) 0 0
+             _ _ (idfun _) (idfun _) (≤ᵣ-refl 0)
+             <f)))
+
+    where
+    <f : (k : Fin (suc (suc Pa.len))) →
+          f (Pa.pts' (fsuc k)) _ -ᵣ f (Pa.pts' (finj k)) _
+          <ᵣ
+          (f' (Pa.pts' (finj k)) _ +ᵣ rat (fst ε))
+          ·ᵣ
+          (Pa.pts' (fsuc k) -ᵣ Pa.pts' (finj k))
+    <f k = isTrans<ᵣ _ _ _ (isTrans<≡ᵣ _ _ _
+      (fst (z/y<x₊≃z<y₊·x _ _ _) fromX') (·ᵣComm _ _))
+           (<ᵣ-·ᵣo _ _
+             (_ , x<y→0<y-x _ _ (str-pa k))
+             (<ᵣ-o+ _ _ _ (<ℚ→<ᵣ _ _ (ℚ.x/2<x ε))))
+     where
+     fromX' : _ <ᵣ f' (Pa.pts' (finj k)) _ +ᵣ rat (fst (/2₊ ε))
+     fromX' = (isTrans≡<ᵣ _ _ _
+       (cong₂ _·ᵣ_
+         (cong₂ _-ᵣ_
+           (cong (uncurry f)
+             (Σ≡Prop (∈-isProp (intervalℙ a b)) (sym L𝐑.lem--05)) )
+           refl)
+        (invℝ₊≡invℝ (_ , x<y→0<y-x _ _ (str-pa k)) _))
+       (isTrans<≡ᵣ _ _ _ (a-b<c⇒a<c+b _ _ _
+        (isTrans≤<ᵣ _ _ _
+         (≤absᵣ _)
+         (isTrans≡<ᵣ _ _ _
+          (minusComm-absᵣ _ _)
+            (X' (Pa.pts' (finj k)) (Pa.a≤pts' (finj k) , Pa.pts'≤b (finj k))
+        (Pa.pts' (fsuc k) -ᵣ Pa.pts' (finj k))
+        (subst-∈ (intervalℙ a b)
+          (sym L𝐑.lem--05)
+           (Pa.a≤pts' (fsuc k) , Pa.pts'≤b (fsuc k)))
+        (invEq (＃Δ _ _) (inl (str-pa k)))
+        (isTrans≡<ᵣ _ _ _
+          (absᵣNonNeg _ (x≤y→0≤y-x _ _ (Pa.pts'≤pts' k)))
+          (isTrans≤<ᵣ _ _ _
+            (isTrans≤ᵣ _ _ _
+              (mesh-pa k)
+              (≤ℚ→≤ᵣ (fst δ⊓δ')  (fst (/2₊ δ'))
+                (ℚ.min≤' (fst (/2₊ δ)) (fst (/2₊ δ')))))
+            (<ℚ→<ᵣ _ _ (ℚ.x/2<x δ'))))))))
+            (+ᵣComm _ _)))
+
+
+   z' : ∃-syntax (Fin (suc (suc Pa.len)))
+        (λ k → f' (Pa.pts' (finj k)) _ <ᵣ rat (fst ε))
+   z' = PT.map (map-snd (<ᵣ-ᵣ _ _))
+          (z (λ x x∈ → -ᵣ (f x x∈))
+               (λ x x∈ → -ᵣ (f' x x∈))
+                (cong -ᵣ_ fa≡fb)
+                 λ x x∈ h h∈ 0＃h h<δ' →
+                  isTrans≡<ᵣ _ _ _
+                     (cong absᵣ (sym (-ᵣDistr _ _)) ∙
+                      sym (-absᵣ _)
+                        ∙ cong (absᵣ ∘ (f' x x∈ +ᵣ_))
+                          (cong (_·ᵣ invℝ h 0＃h)
+                            (sym (-ᵣDistr _ _))
+                            ∙ -ᵣ· _ _) )
+                     (X' x x∈ h h∈ 0＃h h<δ'))
+
+
+   ∀case : ((a₁ : Fin (suc (suc Pa.len))) →
+            (f' (Pa.pts' (finj a₁)) _ <ᵣ -ᵣ fst (ℚ₊→ℝ₊ (/2₊ ε)))
+            ⊎
+            (fst (ℚ₊→ℝ₊ (/2₊ ε)) <ᵣ f' (Pa.pts' (finj a₁)) _)) →
+            ∃ (Σ ℝ (_∈ intervalℙ a b))
+            (λ v → absᵣ (f' (v .fst) (v .snd)) <ᵣ rat (fst ε))
+   ∀case =
+        ⊎.rec
+          (λ ∀f< → PT.map
+              (λ (k , U) →
+                _ ,
+                 isTrans≡<ᵣ _ _ _
+                   (abs-max _)
+                    (max<-lem _ _ _
+                      (isTrans<ᵣ _ _ _ (∀f< k)
+                        (isTrans<ᵣ _ 0 _
+                          (isTrans<≡ᵣ _ _ _
+                            (-ᵣ<ᵣ _ _
+                              (snd ((ℚ₊→ℝ₊ ε) ₊·ᵣ ℚ₊→ℝ₊ ([ 1 / 2 ] , _))))
+                           (-ᵣ-rat 0)) (snd (ℚ₊→ℝ₊ ε))))
+                      (isTrans<≡ᵣ _ _ _ (-ᵣ<ᵣ _ _ U) (-ᵣInvol _))))
+              (z f f' fa≡fb X'))
+          (λ ∀<f → PT.map
+             (λ (k , U) →
+                _ ,
+                 isTrans≡<ᵣ _ _ _
+                   (abs-max _)
+                    (max<-lem _ _ _ U
+                      (isTrans<ᵣ _ _ _
+                        (-ᵣ<ᵣ _ _ (∀<f k))
+                        ((isTrans<ᵣ _ 0 _
+                          (isTrans<≡ᵣ _ _ _
+                            (-ᵣ<ᵣ _ _
+                              (snd ((ℚ₊→ℝ₊ ε) ₊·ᵣ ℚ₊→ℝ₊ ([ 1 / 2 ] , _))))
+                           (-ᵣ-rat 0)) (snd (ℚ₊→ℝ₊ ε)))))))
+             z')
+     ∘  allOnOneSideLemma (suc Pa.len) (ℚ₊→ℝ₊ ε) _
+             (fst (∼≃abs<ε _ _ ε) ∘
+               λ k → (X _ _ _ _
+                (invEq (∼≃abs<ε _ _ δ)
+                  (isTrans≤<ᵣ _ _ _
+                    (isTrans≡≤ᵣ _ _ _
+                      (cong {x = finj (fsuc k)} {(fsuc (finj k))}
+                       (λ aa → absᵣ (Pa.pts' aa
+                         +ᵣ -ᵣ Pa.pts' (finj (finj k))))
+                         (toℕ-injective refl)
+                        ∙ absᵣPos _ (x<y→0<y-x _ _
+                        (str-pa (finj k))))
+                      (mesh-pa (finj k)))
+                    (<ℚ→<ᵣ _ _
+                     (ℚ.isTrans≤< (fst δ⊓δ') _ _
+                       (ℚ.min≤ (fst (/2₊ δ)) (fst (/2₊ δ')))
+                       (ℚ.x/2<x δ))
+                     )))))
+     ∘ (⊎.map (flip (isTrans<≡ᵣ _ _ _) (cong -ᵣ_ (rat·ᵣrat (fst ε) _)))
+              (isTrans≡<ᵣ _ _ _ (sym (rat·ᵣrat (fst ε) _)))
+         ∘_)
+
+meanValue : ∀ a b → a <ᵣ b → ∀ a∈ b∈ f f'
+       →  IsUContinuousℙ (intervalℙ a b) f'
+       →  uDerivativeOfℙ (intervalℙ a b) , f is f'
+       → (ε : ℚ₊) →
+          ∃[ (x₀ , x∈) ∈ Σ _ (_∈ intervalℙ a b) ]
+           absᵣ ((f b b∈ -ᵣ f a a∈)  -ᵣ f' x₀ x∈ ·ᵣ (b -ᵣ a)) <ᵣ rat (fst ε)
+meanValue a b a<b a∈ b∈ f f' ucf udf =
+  PT.rec (isPropΠ λ _ → squash₁) (λ uch' → Rolle'sTheorem a b a<b a∈ b∈
+     h h' uch' udh ha≡hb)
+      uch
+
+
+ where
+  h h' : (x : ℝ) → x ∈ intervalℙ a b → ℝ
+  h x x∈ = ((x -ᵣ a) ·ᵣ (f b b∈ -ᵣ f a a∈))
+                -ᵣ f x x∈ ·ᵣ (b -ᵣ a)
+
+  h' x x∈ = (f b b∈ -ᵣ f a a∈) -ᵣ f' x x∈ ·ᵣ (b -ᵣ a)
+
+  uch : ∥ IsUContinuousℙ (intervalℙ a b) h' ∥₁
+  uch = PT.map (λ z → IsUContinuous∘ℙ (intervalℙ a b)
+       (IsUContinuous∘ (IsUContinuous+ᵣL (f b b∈ -ᵣ f a a∈))
+          (subst IsUContinuous (funExt λ x → ·-ᵣ _ _)
+            z))
+       ucf) (IsUContinuous·ᵣR (-ᵣ (b -ᵣ a)))
+
+  udh0 : _
+  udh0 = +uDerivativeℙ (intervalℙ a b)
+    (λ x _ → ((x -ᵣ a) ·ᵣ (f b b∈ -ᵣ f a a∈)))
+     (λ _ _ → (f b b∈ -ᵣ f a a∈))
+    _ _
+    (subst2 (uDerivativeOfℙ (intervalℙ a b) ,_is_)
+      (funExt₂ λ x x∈ → ·ᵣComm _ _)
+      (funExt₂ λ x x∈ → 𝐑'.·IdR' _ _ (+IdR 1))
+      (C·uDerivativeℙ (intervalℙ a b)
+       _ _ _ (+uDerivativeℙ (intervalℙ a b)
+        _ _ _ _
+        (uDerivativeℙ-id (intervalℙ a b))
+        (uDerivativeℙ-const (intervalℙ a b) (-ᵣ a))) ))
+    (C·uDerivativeℙ (intervalℙ a b) (-ᵣ (b -ᵣ a))
+     _ _
+     udf)
+
+  udh : uDerivativeOfℙ intervalℙ a b , h is h'
+  udh = subst2 (uDerivativeOfℙ (intervalℙ a b) ,_is_)
+           (funExt₂ λ x x∈ →
+            cong₂ _+ᵣ_ refl (-ᵣ· _ _ ∙ cong -ᵣ_ (·ᵣComm _ _)))
+           (funExt₂ λ x x∈ →
+            cong₂ _+ᵣ_ refl (-ᵣ· _ _ ∙ cong -ᵣ_ (·ᵣComm _ _)))
+           udh0
+
+
+  ha≡hb : h a a∈ ≡ h b b∈
+  ha≡hb = 𝐑'.+IdL' _ _ (𝐑'.0LeftAnnihilates' _ _ (+-ᵣ a))
+    ∙ sym (-ᵣ· _ _)
+    ∙ cong (_·ᵣ (b -ᵣ a)) (sym L𝐑.lem--063)
+    ∙ 𝐑'.·DistL- (f b b∈ -ᵣ f a a∈) (f b b∈) (b -ᵣ a)
+    ∙ cong₂ _-ᵣ_ (·ᵣComm _ _) refl
+
+nullDerivative→const : ∀ a b a∈ b∈ → a <ᵣ b → ∀ f
+       → uDerivativeOfℙ (intervalℙ a b) , f is (λ _ _ → 0)
+       → f a a∈ ≡ f b b∈
+nullDerivative→const a b a∈ b∈ a<b f udf  =
+  eqℝ _ _ λ ε →
+    PT.rec (isProp∼ _ _ _)
+      (λ (_ , X) →
+        sym∼ _ _ _ (invEq (∼≃abs<ε _ _ _)
+          (isTrans≡<ᵣ _ _ _
+            (cong absᵣ
+              (sym (𝐑'.+IdR' _ _
+                (cong -ᵣ_ (𝐑'.0LeftAnnihilates (b -ᵣ a))
+                 ∙ -ᵣ-rat 0))))
+            X)))
+      (meanValue a b a<b a∈ b∈ f
+        (λ _ _ → 0) (λ ε₁ → 1 , λ _ _ _ _ _ → refl∼ _ _) udf ε)
+
diff --git a/Cubical/HITs/CauchyReals/Multiplication.agda b/Cubical/HITs/CauchyReals/Multiplication.agda
index d11378d2f6..cc67d449fb 100644
--- a/Cubical/HITs/CauchyReals/Multiplication.agda
+++ b/Cubical/HITs/CauchyReals/Multiplication.agda
@@ -5,12 +5,16 @@ 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.Isomorphism
 open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Powerset
 
 open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
 open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Nat.Order as ℕ
 open import Cubical.Data.Unit
+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
@@ -28,6 +32,7 @@ open import Cubical.Data.Rationals.Order as ℚ using
 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
@@ -35,405 +40,674 @@ open import Cubical.HITs.CauchyReals.Lipschitz
 open import Cubical.HITs.CauchyReals.Order
 open import Cubical.HITs.CauchyReals.Continuous
 
+open import Cubical.HITs.SequentialColimit as SCL
+open import Cubical.Data.Sequence
+
+private
+  variable
+    ℓ ℓ' : Level
+
+record Seq⊆ : Type₁ where
+ field
+  𝕡 : ℕ → ℙ ℝ
+  𝕡⊆ : ∀ n → 𝕡 n ⊆ 𝕡 (suc n)
+
+
+ 𝕡⊆+ : ∀ n m → 𝕡 n ⊆ 𝕡 (m ℕ.+ n)
+ 𝕡⊆+ n zero = ⊆-refl _
+ 𝕡⊆+ n (suc m) x = 𝕡⊆ _ x ∘ 𝕡⊆+ n m x
+
+ 𝕡⊆' : ∀ n m → n ℕ.≤ m → 𝕡 n ⊆ 𝕡 m
+ 𝕡⊆' n m (k , p) x = subst (λ l → x ∈ 𝕡 l) p ∘ 𝕡⊆+ _ _ x
+
+ _s⊇_ : ℙ ℝ → Type₀
+ _s⊇_ P = ∀ x → x ∈ P → ∃[ n ∈ ℕ ] x ∈ 𝕡 n
+
+
+ _s⊆_ : ℙ ℝ → Type₀
+ _s⊆_ P = ∀ n → 𝕡 n ⊆ P
+
+
+ elimProp-∩ : ∀ P → ∀ x → x ∈ P  → (P⊇ : _s⊇_ P) → (A : ℝ → Type)
+    → (∀ x → isProp (A x))
+    → (∀ n → x ∈ 𝕡 n → A x)
+    → A x
+ elimProp-∩ P x x∈P P⊇ A propA a  =
+   PT.rec (propA _)
+     (λ (n , x∈ₙ) → a n x∈ₙ)
+     (P⊇ x x∈P)
+
+ elimProp-∩' : ∀ P → ∀ x x∈P  → (_s⊇_ P) → (s⊆P : _s⊆_ P)
+   → (A : ∀ x → x ∈ P  → Type)
+    → (∀ x∈ → isProp (A x x∈))
+    → (∀ n x∈ₙ → A x (s⊆P n x x∈ₙ ))
+    → A x x∈P
+ elimProp-∩' P x x∈P P⊇ Ps⊆ A propA a  =
+   PT.rec (propA _)
+     (λ (n , x∈ₙ) → subst (A x) (∈-isProp P x _ _) (a n x∈ₙ))
+     (P⊇ x x∈P)
+
+
+ elem𝕡-Seq : Sequence ℓ-zero
+ elem𝕡-Seq .Sequence.obj n = Σ _ (_∈ 𝕡 n)
+ elem𝕡-Seq .Sequence.map = map-snd (𝕡⊆ _ _)
+
+ elem𝕡-Seq* : ℝ → Sequence ℓ-zero
+ elem𝕡-Seq* x .Sequence.obj n = x ∈ 𝕡 n
+ elem𝕡-Seq* x .Sequence.map = 𝕡⊆ _ _
+
+ -- module _ P (s⊇P : _s⊇_ P) (s⊆P : _s⊆_ P) where
+
+ --  toSC : ∀ x → ∃[ n ∈ ℕ ] x ∈ 𝕡 n → ElemLim-𝕡
+ --  toSC x = {!s⊇P x!}
+
+ --  fromSC : ElimData elem𝕡-Seq (λ _ → Σ ℝ (_∈ P))
+ --  fromSC .ElimData.inclP {k} = map-snd (s⊆P k _)
+ --  fromSC .ElimData.pushP _ = Σ≡Prop (snd ∘ P) refl
+
+
+ --  isoElemP : Iso (Σ _ (_∈ P)) ElemLim-𝕡
+ --  isoElemP .Iso.fun (x , x∈) = toSC x (s⊇P x x∈)
+ --  isoElemP .Iso.inv = SCL.elim _ _ fromSC
+ --  isoElemP .Iso.rightInv = {!!}
+ --  isoElemP .Iso.leftInv = {!!}
+
+open Seq⊆
+
+ℝU : ℙ ℝ
+ℝU x .fst = Unit
+ℝU x .snd = isPropUnit
+
+Seq⊆-<N : Seq⊆
+Seq⊆-<N .Seq⊆.𝕡 n x = (x <ᵣ fromNat (suc n)) , isProp<ᵣ _ _
+Seq⊆-<N .Seq⊆.𝕡⊆ n x x∈ =
+  isTrans<ᵣ _ _ _ x∈
+   (<ℚ→<ᵣ _ _ (ℚ.<ℤ→<ℚ _ _ ℤ.isRefl≤))
+
+Seq⊆-abs<N : Seq⊆
+Seq⊆-abs<N .Seq⊆.𝕡 n x =
+   (fromNeg (suc n) <ᵣ x) × (x <ᵣ fromNat (suc n)) ,
+     isProp× (isProp<ᵣ _ _) (isProp<ᵣ _ _)
+Seq⊆-abs<N .Seq⊆.𝕡⊆ n x (<x , x<) =
+  isTrans<ᵣ _ _ _
+   (<ℚ→<ᵣ _ _ (ℚ.<ℤ→<ℚ _ _ ℤ.isRefl≤)) <x
+   , isTrans<ᵣ _ _ _ x<
+   (<ℚ→<ᵣ _ _ (ℚ.<ℤ→<ℚ _ _ ℤ.isRefl≤))
+
+
+
+record Seq⊆→ (A : Type ℓ) (s : Seq⊆) : Type ℓ where
+ field
+  fun : ∀ x n → x ∈ 𝕡 s n → A
+  fun⊆ : ∀ x n m x∈ x∈' → n ℕ.< m → fun x n x∈ ≡ fun x m x∈'
+
+ module FromIntersection (isSetA : isSet A) P (s⊆P : s s⊇ P) where
+
+  2c : ∀ x n n' n∈ n∈' → fun x n n∈ ≡ fun x n' n∈'
+  2c x = ℕ.elimBy≤ (λ n n' X n∈ n'∈  → sym (X n'∈ n∈))
+         λ n n' → ⊎.rec (λ n<n' _ _ → fun⊆ _ _ _ _ _ n<n')
+           (λ p _ _ → cong (uncurry (fun x))
+           (Σ≡Prop (λ n → ∈-isProp (𝕡 s n) x) p)) ∘ ≤-split
+
+  ∩$ : ∀ x → x ∈ P  → A
+  ∩$ x x∈ =
+    PT.rec→Set isSetA (λ (n , n∈) → fun x n n∈)
+       (λ (n , n∈) (n' , n'∈) → 2c x n n' n∈ n'∈) (s⊆P x x∈)
+
+
+  -- it shouulb by possisble also for hSet
+  ∩$-elimProp : ∀ x x∈ → {B : A → Type ℓ}
+     → (∀ a → isProp (B a))
+     → (∀ n x∈ → B (fun x n x∈))
+     → B (∩$ x x∈)
+  ∩$-elimProp x x∈ {B} isPropB g =
+    PT.elim (isPropB ∘ PT.rec→Set isSetA (λ (n , n∈) → fun x n n∈)
+       (λ (n , n∈) (n' , n'∈) → 2c x n n' n∈ n'∈))
+      (uncurry g)
+      (s⊆P x x∈)
+
+
+  ∩$-lem : ∀ x x∈ → ∃[ n ∈ ℕ ] Σ _ λ x∈𝕡 → ∩$ x x∈ ≡ fun x n x∈𝕡
+  ∩$-lem x x∈ = ∩$-elimProp x x∈
+    {B = λ a → ∃[ n ∈ ℕ ] Σ _ λ x∈𝕡 → a ≡ fun x n x∈𝕡} (λ _ → squash₁)
+   λ n x∈' → ∣ n , x∈' , refl ∣₁
+
+  ∩$-∈ₙ : ∀ x x∈ n (x∈ₙ : x ∈ 𝕡 s n)
+             → ∩$ x x∈ ≡ fun x n x∈ₙ
+  ∩$-∈ₙ x x∈ = ∩$-elimProp x x∈
+              {λ y → ∀ n → (x∈ₙ : x ∈ 𝕡 s n)
+             → y ≡ fun x n x∈ₙ} (λ _ → isPropΠ2 λ _ _ → isSetA _ _)
+               λ _ _ _ _ → 2c x _ _ _ _
+
+
+  -- it shouulb by possisble also for hSet
+  ∩$-elimProp2 : ∀ x x∈ y y∈ → {B : A → A → Type ℓ}
+     → (∀ a a' → isProp (B a a'))
+     → (∀ n x∈ y∈ → B (fun x n x∈) (fun y n y∈))
+     → B (∩$ x x∈) (∩$ y y∈)
+  ∩$-elimProp2 x x∈ y y∈ {B} isPropB g =
+    PT.elim2 (λ z z' →
+      isPropB
+       (PT.rec→Set isSetA (λ (n , n∈) → fun x n n∈)
+       (λ (n , n∈) (n' , n'∈) → 2c x n n' n∈ n'∈) z)
+       (PT.rec→Set isSetA (λ (n , n∈) → fun y n n∈)
+       (λ (n , n∈) (n' , n'∈) → 2c y n n' n∈ n'∈) z'))
+
+      (λ (n , x∈) (m , y∈) →
+        subst2 B (2c _ _ _ _ _) (2c _ _ _ _ _)
+         (g (ℕ.max n m) (𝕡⊆' s _ _ ℕ.left-≤-max x x∈) (𝕡⊆' s _ _ ℕ.right-≤-max y y∈)))
+      (s⊆P x x∈) (s⊆P y y∈)
+
+
+∩$-cont : ∀ P s → (∀ n → ⟨ openPred (Seq⊆.𝕡 s n) ⟩) → ∀ r s⊇P
+    → (∀ n → IsContinuousWithPred (𝕡 s n) (flip (Seq⊆→.fun r) n))
+    → IsContinuousWithPred P
+   (Seq⊆→.FromIntersection.∩$ {A = ℝ} {s = s} r isSetℝ P s⊇P)
+
+∩$-cont P s op r s⊇P cₙ x ε x∈ =
+ PT.rec squash₁ (λ (n , p , q) →
+   PT.map2 (λ (δ , X) (η , Y) →
+        ℚ.min₊ δ η , λ v v∈ x∼v →
+          let z = Y v (X v (∼-monotone≤ (ℚ.min≤ _ _) x∼v))
+                           (∼-monotone≤ (ℚ.min≤' _ _) x∼v)
+          in subst2 _∼[ ε ]_
+               (sym (Seq⊆→.FromIntersection.∩$-∈ₙ {A = ℝ} {s = s} r isSetℝ P s⊇P
+                _ _ _ _))
+               (sym (Seq⊆→.FromIntersection.∩$-∈ₙ {A = ℝ} {s = s} r isSetℝ P s⊇P
+                _ _ _ _)) z)
+     (op n x p) (cₙ n x ε p))
+
+  (Seq⊆→.FromIntersection.∩$-lem {A = ℝ} {s = s} r isSetℝ P s⊇P
+     x x∈)
+
+∩$-cont' : ∀ P s → (∀ n x →
+               x ∈ (𝕡 s n) →
+               ∃[ δ ∈ ℚ₊ ] (∀ y → x ∼[ δ ] y → y ∈ (𝕡 s (suc n))  )) → ∀ r s⊇P
+    → (∀ n → IsContinuousWithPred (𝕡 s n) (flip (Seq⊆→.fun r) n))
+    → IsContinuousWithPred P
+   (Seq⊆→.FromIntersection.∩$ {A = ℝ} {s = s} r isSetℝ P s⊇P)
+
+∩$-cont' P s op r s⊇P cₙ x ε x∈ =
+ PT.rec squash₁ (λ (n , p , q) →
+   PT.map2 (λ (δ , X) (η , Y) →
+        ℚ.min₊ δ η , λ v v∈ x∼v →
+          let z = Y v (X v (∼-monotone≤ (ℚ.min≤ _ _) x∼v))
+                           (∼-monotone≤ (ℚ.min≤' _ _) x∼v)
+          in subst2 _∼[ ε ]_
+               (sym (Seq⊆→.FromIntersection.∩$-∈ₙ {A = ℝ} {s = s} r isSetℝ P s⊇P
+                _ _ _ _))
+               (sym (Seq⊆→.FromIntersection.∩$-∈ₙ {A = ℝ} {s = s} r isSetℝ P s⊇P
+                _ _ _ _)) z)
+     (op n x p) (cₙ (suc n) x ε (𝕡⊆ s n x p)))
+
+  (Seq⊆→.FromIntersection.∩$-lem {A = ℝ} {s = s} r isSetℝ P s⊇P
+     x x∈)
+
+
+∩$-cont'' : ∀ P s → (∀ n x →
+               x ∈ (𝕡 s n) →
+               ∃[ δ ∈ ℚ₊ ] (∀ y → y ∈ P → x ∼[ δ ] y → y ∈ (𝕡 s (suc n))  )) → ∀ r s⊇P
+    → (∀ n → IsContinuousWithPred (𝕡 s n) (flip (Seq⊆→.fun r) n))
+    → IsContinuousWithPred P
+   (Seq⊆→.FromIntersection.∩$ {A = ℝ} {s = s} r isSetℝ P s⊇P)
+
+∩$-cont'' P s op r s⊇P cₙ x ε x∈ =
+ PT.rec squash₁ (λ (n , p , q) →
+   PT.map2 (λ (δ , X) (η , Y) →
+        ℚ.min₊ δ η , λ v v∈ x∼v →
+          let z = Y v (X v v∈ (∼-monotone≤ (ℚ.min≤ _ _) x∼v))
+                           (∼-monotone≤ (ℚ.min≤' _ _) x∼v)
+          in subst2 _∼[ ε ]_
+               (sym (Seq⊆→.FromIntersection.∩$-∈ₙ {A = ℝ} {s = s} r isSetℝ P s⊇P
+                _ _ _ _))
+               (sym (Seq⊆→.FromIntersection.∩$-∈ₙ {A = ℝ} {s = s} r isSetℝ P s⊇P
+                _ _ _ _)) z)
+     (op n x p) (cₙ (suc n) x ε (𝕡⊆ s n x p)))
+
+  (Seq⊆→.FromIntersection.∩$-lem {A = ℝ} {s = s} r isSetℝ P s⊇P
+     x x∈)
+
+
+infixl 7 _·ᵣ_
+
+
+
+open ℚ.HLP
+
+
 -- 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
+opaque
+ unfolding _<ᵣ_ absᵣ -ᵣ_
+ 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
-  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⊓
 
+  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⊓)
+
 
-   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'))
+
+    n⊓ n⊔ : ℕ
+    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'))}))))
-                        (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
+                                   (ℤ.≤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 η)) , 0<ε-[δ+η] ]
+              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 → Σ ℕ₊₁ (λ n → absᵣ r <ᵣ rat [ pos (ℕ₊₁→ℕ n) / 1+ 0 ])  → ℝ
+  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 : Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ ([ 1 / 2 ] , _))
+ /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ᵣ : ℝ → ℝ
+ /2ᵣ = fst /2ᵣ-L
+
+
+ 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' = (_//_.[ x ])
 
-infixl 7 _·ᵣ_
+     c : ℚ
+     c = (fst (fromNat (suc (suc (getClampsOnQ x' .fst .ℕ₊₁.n))))
+         ℚ.- _//_.[ 1 , 4 ])
 
-_·ᵣ_ : ℝ → ℝ → ℝ
-u ·ᵣ v = /2ᵣ ((sqᵣ (u +ᵣ v)) +ᵣ (-ᵣ (sqᵣ u +ᵣ sqᵣ v)))
 
+     c' : ℚ
+     c' = fromNat ((suc (getClampsOnQ x' .fst .ℕ₊₁.n)))
 
-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)
+     <c' : ℚ.abs' x' ℚ.< c'
+     <c' = <ᵣ→<ℚ _ _ (snd (getClampsOnQ x'))
 
-    where
-    x' = (_//_.[ 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 : ℚ
-    c = (fst (fromNat (suc (suc (getClampsOnQ x' .fst .ℕ₊₁.n))))
-        ℚ.- _//_.[ 1 , 4 ])
+     <c : ℚ.abs' x' ℚ.≤ c
+     <c = ℚ.isTrans≤ (ℚ.abs' x') c' c
+        (ℚ.<Weaken≤ (ℚ.abs' x') c' <c') c'≤c
 
 
-    c' = fromNat ((suc (getClampsOnQ x' .fst .ℕ₊₁.n)))
+     -c<x : ℚ.- c ℚ.≤ x'
+     -c<x = subst (ℚ.- c ℚ.≤_) (ℚ.-Invol x') (ℚ.minus-≤ (ℚ.- x') c
+        (ℚ.isTrans≤ (ℚ.- x') (ℚ.abs' x') c (ℚ.-≤abs' x') <c))
 
-    <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ℚ≤?  )
+     x<c :  _//_.[ x ] ℚ.≤ c
+     x<c = ℚ.isTrans≤ x' (ℚ.abs' x') c (ℚ.≤abs' x') <c
 
-    <c : ℚ.abs' x' ℚ.≤ c
-    <c = ℚ.isTrans≤ (ℚ.abs' x') c' c
-       (ℚ.<Weaken≤ (ℚ.abs' x') c' <c') c'≤c
 
+ IsContinuous/2ᵣ : IsContinuous /2ᵣ
+ IsContinuous/2ᵣ = Lipschitz→IsContinuous _ /2ᵣ (snd /2ᵣ-L)
 
-    -c<x : ℚ.- c ℚ.≤ x'
-    -c<x = subst (ℚ.- c ℚ.≤_) (ℚ.-Invol x') (ℚ.minus-≤ (ℚ.- x') c
-       (ℚ.isTrans≤ (ℚ.- x') (ℚ.abs' x') c (ℚ.-≤abs' x') <c))
 
+ IsContinuousSqᵣ : IsContinuous sqᵣ
+ IsContinuousSqᵣ = snd sqᵣ'
 
-    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))))
 
+ _·ᵣ_ : ℝ → ℝ → ℝ
+ u ·ᵣ v = /2ᵣ ((sqᵣ (u +ᵣ v)) +ᵣ (-ᵣ (sqᵣ u +ᵣ sqᵣ v)))
+
+
+
+
+
+ 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ᵣ'
+ ·ᵣComm : ∀ x y → x ·ᵣ y ≡ y ·ᵣ x
+ ·ᵣComm u v i =
+   /2ᵣ ((sqᵣ (+ᵣComm u v i)) +ᵣ (-ᵣ (+ᵣComm (sqᵣ u) (sqᵣ v) i)))
 
-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·ᵣ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ᵣ)))
+
+ 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)))))
+
+cont₂·₂ᵣ : ∀ {f₀ f₁} → (IsContinuous₂ f₀) → (IsContinuous₂ f₁)
+  → IsContinuous₂ (λ x x' → f₀ x x' ·ᵣ f₁ x x')
+cont₂·₂ᵣ {f₀} {f₁} f₀C f₁C =
+  (λ x → cont₂·ᵣ _ _ (fst f₀C x) (fst f₁C x)) ,
+  λ x → cont₂·ᵣ _ _ (snd f₀C x) (snd f₁C x)
 
 IsContinuous·ᵣL : ∀ x → IsContinuous (x ·ᵣ_)
 IsContinuous·ᵣL x = subst IsContinuous
@@ -478,32 +752,34 @@ IsContinuous·ᵣL x = subst IsContinuous
 ·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 _ _)
+opaque
+ unfolding _+ᵣ_
+ ·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
@@ -511,6 +787,12 @@ IsCommRingℝ = CR.makeIsCommRing
   +ᵣAssoc +IdR +-ᵣ +ᵣComm ·ᵣAssoc
    ·IdR ·DistL+ ·ᵣComm
 
+x+x≡2x : ∀ x → x +ᵣ x ≡ 2 ·ᵣ x
+x+x≡2x x = cong₂ _+ᵣ_
+    (sym (·IdL x))
+    (sym (·IdL x))
+    ∙ sym (·DistR+ 1 1 x)
+    ∙ cong (_·ᵣ x) (+ᵣ-rat _ _)
 
 
 ·ᵣMaxDistrPos : ∀ x y z → 0 ℚ.≤ z →  (maxᵣ x y) ·ᵣ (rat z) ≡ maxᵣ (x ·ᵣ rat z) (y ·ᵣ rat z)
@@ -537,129 +819,33 @@ IsCommRingℝ = CR.makeIsCommRing
    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))))))
+
+
+
+
+
+
+opaque
+
+ unfolding _·ᵣ_
+
+ 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)
@@ -671,8 +857,8 @@ cont₂·ᵣWP P f g fC gC = IsContinuousWP∘' P _
          ≡Continuous _ _
              (IsContinuous·ᵣR (-ᵣ (rat y')))
               ((IsContinuous∘ _ _ IsContinuous-ᵣ (IsContinuous·ᵣR (rat y'))))
-          (λ x' → sym (rat·ᵣrat _ _) ∙∙ cong rat (·- x' y') ∙∙
-              (cong -ᵣ_ (rat·ᵣrat _ _)))
+          (λ x' → cong (rat x' ·ᵣ_) (-ᵣ-rat _) ∙ sym (rat·ᵣrat _ _) ∙∙ cong rat (·- x' y') ∙∙
+              sym (-ᵣ-rat _) ∙ (cong -ᵣ_ (rat·ᵣrat _ _)))
           x
 
 ·DistL- : (x y z : ℝ) → (x ·ᵣ (y -ᵣ z)) ≡ ((x ·ᵣ y) -ᵣ (x ·ᵣ z))
@@ -682,24 +868,41 @@ cont₂·ᵣWP P f g fC gC = IsContinuousWP∘' P _
 -ᵣ· : ∀ x y →  ((-ᵣ x) ·ᵣ y) ≡  -ᵣ (x ·ᵣ y)
 -ᵣ· x y = ·ᵣComm _ _ ∙∙ ·-ᵣ y x ∙∙ cong -ᵣ_ (·ᵣComm _ _)
 
+-ᵣ·-ᵣ : ∀ x y →  ((-ᵣ x) ·ᵣ (-ᵣ y)) ≡  (x ·ᵣ y)
+-ᵣ·-ᵣ x y = -ᵣ· x (-ᵣ y) ∙ cong (-ᵣ_) (·-ᵣ x y) ∙ -ᵣInvol _
+
 
 _^ⁿ_ : ℝ → ℕ → ℝ
 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
+^ⁿ-ℚ^ⁿ : ∀ n q → ((rat q) ^ⁿ n) ≡ rat (q ℚ.ℚ^ⁿ n)
+^ⁿ-ℚ^ⁿ zero _ = refl
+^ⁿ-ℚ^ⁿ (suc n) a =
+  cong (_·ᵣ rat a) (^ⁿ-ℚ^ⁿ n a) ∙
+          sym (rat·ᵣrat _ _)
+
+
+opaque
+ unfolding absᵣ
+ ·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
+
+
+IsContinuous₂·ᵣ :  IsContinuous₂ _·ᵣ_
+IsContinuous₂·ᵣ = IsContinuous·ᵣL , IsContinuous·ᵣR
+
diff --git a/Cubical/HITs/CauchyReals/NthRoot.agda b/Cubical/HITs/CauchyReals/NthRoot.agda
new file mode 100644
index 0000000000..79ec22d2d6
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/NthRoot.agda
@@ -0,0 +1,581 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.NthRoot 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.Foundations.Powerset
+
+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.HITs.SetQuotients as SQ hiding ([_])
+
+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
+open import Cubical.HITs.CauchyReals.Sequence
+open import Cubical.HITs.CauchyReals.Bisect
+
+
+
+
+sqrRestr< : ∀ n → (fst (invℚ₊ (fromNat (2 ℕ.+ n)))) ℚ.< (fromNat (2 ℕ.+ n))
+sqrRestr< n =
+  (ℚ.isTrans< (fst (invℚ₊ (fromNat (2 ℕ.+ n)))) 1 (fromNat (2 ℕ.+ n))
+               (fst (ℚ.invℚ₊-<-invℚ₊ 1 _)
+                 (ℚ.<ℤ→<ℚ 1 _ (ℤ.suc-≤-suc (ℤ.suc-≤-suc (ℤ.zero-≤pos {n})))))
+               (ℚ.<ℤ→<ℚ 1 _
+               (ℤ.suc-≤-suc (ℤ.suc-≤-suc (ℤ.zero-≤pos {n})))))
+
+module NthRoot (m : ℕ) where
+
+
+ module _ (n : ℕ) where
+
+
+  open bⁿ-aⁿ m hiding (n)
+
+
+  A B : ℝ
+  A = rat (fst (invℚ₊ (fromNat (2 ℕ.+ n))))
+  B = (fromNat (2 ℕ.+ n))
+  0<A = (snd (ℚ₊→ℝ₊ (invℚ₊ (fromNat (2 ℕ.+ n)))))
+  0<B = (snd (ℚ₊→ℝ₊ (fromNat (2 ℕ.+ n))))
+  A<B : A <ᵣ B
+  A<B = <ℚ→<ᵣ _ _ (sqrRestr< n)
+
+
+
+  L = (((fromNat (2 ℕ.+ n)) ℚ₊^ⁿ (suc m))
+      ℚ₊· (fromNat (2 ℕ.+ m)))
+
+  K = (fromNat (2 ℕ.+ n)) ℚ₊^ⁿ (suc m)
+
+  incrF : isIncrasingℙ
+   (ℚintervalℙ (fst (invℚ₊ (fromNat (2 ℕ.+ n))))
+               (fromNat (2 ℕ.+ n))) (λ x _ → x ℚ^ⁿ (2 ℕ.+ m))
+  incrF  x x∈ y y∈ =
+    ℚ^ⁿ-StrictMonotone (2 ℕ.+ m)
+     (ℕ.≤-suc (ℕ.suc-≤-suc (ℕ.zero-≤ {m})))
+     (ℚ.isTrans≤ 0 (fst (invℚ₊ (fromNat (2 ℕ.+ n))))
+          x (ℚ.0≤ℚ₊ (invℚ₊ (fromNat (2 ℕ.+ n)))) (fst x∈))
+     (ℚ.isTrans≤ 0 (fst (invℚ₊ (fromNat (2 ℕ.+ n))))
+          y (ℚ.0≤ℚ₊ (invℚ₊ (fromNat (2 ℕ.+ n)))) (fst y∈))
+
+  1/K<L : fst (invℚ₊ K) ℚ.< fst L
+  1/K<L = ℚ.isTrans≤< _ 1 _
+    (subst (ℚ._≤ 1) (sym (ℚ.invℚ₊-ℚ^ⁿ _ _))
+      (ℚ.x^ⁿ≤1 _ _ ℤ.zero-≤pos
+       (fst (ℚ.invℚ₊-≤-invℚ₊ 1 (fromNat (2 ℕ.+ n)))
+        (ℚ.≤ℤ→≤ℚ _ _ (ℤ.suc-≤-suc ℤ.zero-≤pos)))))
+         (ℚ.isTrans≤< _ _ _
+           (ℚ.1≤x^ⁿ (fromNat (2 ℕ.+ n))
+            (fromNat (1 ℕ.+ m)) (ℚ.≤ℤ→≤ℚ 1 _ (ℤ.suc-≤-suc ℤ.zero-≤pos)))
+            (subst (ℚ._< fst L)
+
+               (ℚ.·IdR _)
+                 (ℚ.<-o· 1 (fromNat (2 ℕ.+ m))
+                   _ (ℚ.0<ℚ₊ ((fromNat (2 ℕ.+ n)) ℚ₊^ⁿ (suc m)))
+            ((ℚ.<ℤ→<ℚ 1 (ℤ.pos (suc (suc m)))
+             ( ℤ.suc-≤-suc (ℤ.suc-≤-suc (ℤ.zero-≤pos {m})))))))
+            )
+
+
+  rootRest : IsBilipschitz
+               (fst (invℚ₊ (fromNat (2 ℕ.+ n))))
+               (fromNat (2 ℕ.+ n))
+               (sqrRestr< n)
+               λ x _ → x ℚ^ⁿ (2 ℕ.+ m)
+  rootRest .IsBilipschitz.incrF = incrF
+  rootRest .IsBilipschitz.L = L
+  rootRest .IsBilipschitz.K = K
+  rootRest .IsBilipschitz.1/K≤L = ℚ.<Weaken≤ _ _ 1/K<L
+
+  rootRest .IsBilipschitz.lipF =
+    Lipschitz-ℚ→ℝℙ<→Lipschitz-ℚ→ℝℙ _ _ _
+      λ q q∈ r r∈ r<q  →
+       let 0<r : 0 <ᵣ (rat r)
+           0<r = isTrans<≤ᵣ 0 A (rat r) 0<A (fst r∈)
+           0<q : 0 <ᵣ (rat q)
+           0<q = isTrans<ᵣ 0 (rat r) (rat q) 0<r (<ℚ→<ᵣ _ _ r<q)
+
+           ineqL : (rat q ^ⁿ suc (suc m)) -ᵣ (rat r ^ⁿ suc (suc m))
+                      ≤ᵣ rat ((fst L) ℚ.· (q ℚ.- r))
+
+           ineqL =
+             isTrans≡≤ᵣ _ _ _ (sym $
+                  [b-a]·S≡bⁿ-aⁿ (rat r) (rat q)
+                     0<r 0<q)
+               (isTrans≤≡ᵣ _ _ _ (≤ᵣ-o·ᵣ _ _ _
+                      (isTrans≤≡ᵣ _ _ _  (≤ℚ→≤ᵣ _ _  $ ℚ.<Weaken≤ _ _ (ℚ.<→<minus _ _ r<q))
+                       (sym (-ᵣ-rat₂ _ _))) --
+                    (isTrans≤≡ᵣ _ _ _
+               (S≤Bⁿ·n (rat r) (rat q) 0<r 0<q A B 0<A
+                     (isTrans≤<ᵣ _ _ _
+                       (fst r∈ ) (<ℚ→<ᵣ _ _ r<q)) 0<B A<B
+                  (snd q∈)
+                  (<ℚ→<ᵣ _ _ r<q))
+                      (sym ((rat·ᵣrat _ _
+                        ∙ cong (_·ᵣ (rat ((fromNat (2 ℕ.+ m)))))
+                          (sym (^ⁿ-ℚ^ⁿ _ _)))))
+                          ))
+                           (cong₂ _·ᵣ_ (-ᵣ-rat₂ _ _) refl ∙ (sym (rat·ᵣrat _ _) ∙ (cong rat (ℚ.·Comm _ _)))) --
+                           )
+
+
+       in isTrans≡≤ᵣ _ _ _ (cong absᵣ (-ᵣ-rat₂ _ _) ∙ absᵣPos _
+            (<ℚ→<ᵣ _ _  (ℚ.<→<minus _ _ (incrF r
+                     (∈intervalℙ→∈ℚintervalℙ _ _ _ r∈)
+                     q
+                     (∈intervalℙ→∈ℚintervalℙ _ _ _ q∈)
+                     r<q)))
+                 ∙ sym (-ᵣ-rat₂ _ _)  ∙ cong₂ _-ᵣ_
+                   (sym (^ⁿ-ℚ^ⁿ _ _))
+                   (sym (^ⁿ-ℚ^ⁿ _ _))) ineqL
+
+  rootRest .IsBilipschitz.lip⁻¹F =
+    Invlipschitz-ℚ→ℚℙ'<→Invlipschitz-ℚ→ℚℙ _ _ _
+       λ q q∈ r r∈ r<q →
+          let r∈' = (∈ℚintervalℙ→∈intervalℙ _ _ _ r∈)
+              q∈' = (∈ℚintervalℙ→∈intervalℙ
+                      (fst (invℚ₊ (fromNat (2 ℕ.+ n)))) _ _ q∈)
+              0<r : 0 <ᵣ (rat r)
+              0<r = isTrans<≤ᵣ 0 A (rat r) 0<A (fst r∈')
+              0<q : 0 <ᵣ (rat q)
+              0<q = isTrans<ᵣ 0 (rat r) (rat q) 0<r (<ℚ→<ᵣ _ _ r<q)
+
+          in ℚ.x·invℚ₊y≤z→x≤y·z _ _ _ (≤ᵣ→≤ℚ _ _
+                $ isTrans≡≤ᵣ _ _ _ (cong rat
+                  (cong ((q ℚ.+ ℚ.- r) ℚ.·_)
+                    (ℚ.invℚ₊-ℚ^ⁿ _ (suc m)) )
+                  ∙ rat·ᵣrat _ _) $
+                isTrans≤≡ᵣ _ _ _
+                  (≤ᵣ-o·ᵣ _ _ _
+                        (≤ℚ→≤ᵣ _ _  $ ℚ.<Weaken≤ _ _ (ℚ.<→<minus _ _ r<q))
+                  (isTrans≡≤ᵣ _ _ _
+                     (sym (^ⁿ-ℚ^ⁿ _ _))
+                             (Aⁿ≤S (rat r) (rat q) 0<r 0<q
+                              A B 0<A
+                              (isTrans≤<ᵣ _ _ _
+                                (fst r∈' ) (<ℚ→<ᵣ _ _ r<q))
+                              0<B A<B
+                             (snd q∈')
+                             (<ℚ→<ᵣ _ _ r<q))
+                             ))
+                    (cong₂ _·ᵣ_ (sym (-ᵣ-rat₂ _ _)) refl ∙ [b-a]·S≡bⁿ-aⁿ (rat r) (rat q) 0<r 0<q
+                       ∙
+                      cong₂ _-ᵣ_ (^ⁿ-ℚ^ⁿ _ _) (^ⁿ-ℚ^ⁿ _ _)
+                      ∙ -ᵣ-rat₂ _ _ ∙ cong rat (sym (ℚ.absPos _
+                      (ℚ.<→<minus _ _ (incrF r r∈ q q∈ r<q))) ∙
+                       ℚ.abs'≡abs _))
+                       )
+
+
+
+
+ loB hiB : ∀ n → ℚ
+ loB n = (((fst (invℚ₊ (fromNat (2 ℕ.+ n))))) ℚ^ⁿ (2 ℕ.+ m))
+ hiB n = ((fromNat (2 ℕ.+ n)) ℚ^ⁿ (2 ℕ.+ m))
+
+ loB-mon : ∀ n → loB (suc n) ℚ.< loB n
+ loB-mon n = (
+     (ℚ^ⁿ-StrictMonotone (2 ℕ.+ m) (ℕ.suc-≤-suc ℕ.zero-≤)
+      (ℚ.0≤ℚ₊ _) (ℚ.0≤ℚ₊ _)
+      (fst (ℚ.invℚ₊-<-invℚ₊
+    (fromNat (2 ℕ.+ n)) (fromNat (3 ℕ.+ n)))
+      (ℚ.<ℤ→<ℚ _ _ ℤ.isRefl≤))))
+
+ hiB-mon : ∀ n → hiB n ℚ.< hiB (suc n)
+ hiB-mon n = ℚ^ⁿ-StrictMonotone (2 ℕ.+ m)
+        (ℕ.suc-≤-suc ℕ.zero-≤) (ℚ.0≤ℚ₊ _) (ℚ.0≤ℚ₊ _)
+      ((ℚ.<ℤ→<ℚ _ _ (ℤ.suc-≤-suc ℤ.isRefl≤)))
+
+ rootSeq⊆ : Seq⊆
+ rootSeq⊆ .Seq⊆.𝕡 n = intervalℙ
+   (rat (loB n))
+   (rat (hiB n))
+ rootSeq⊆ .Seq⊆.𝕡⊆ n x (≤x , x≤) =
+   isTrans≤ᵣ _ _ _ (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ (loB-mon n))) ≤x ,
+   isTrans≤ᵣ _ _ _ x≤ (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ (hiB-mon n)))
+
+
+
+
+ f⊆ : (x : ℝ) (n n' : ℕ)
+      (x∈ : x ∈ intervalℙ (rat (loB n)) (rat (hiB n)))
+      (x∈' : x ∈ intervalℙ (rat (loB n')) (rat (hiB n'))) →
+      n ℕ.< n' →
+      IsBilipschitz.𝒇⁻¹ (rootRest n) x ≡
+      IsBilipschitz.𝒇⁻¹ (rootRest n') x
+ f⊆ x n n' x∈ x∈' n<n' =
+   h
+
+  where
+  open IsBilipschitz
+  ib = rootRest n
+  ib' = rootRest n'
+
+  -- zz' : {!!}
+  -- zz' =
+
+  𝒇'≡𝒇 : ∀ y → y ∈
+      intervalℙ (rat (fst (invℚ₊ (fromNat (2 ℕ.+ n)))))
+            (rat (fromNat (2 ℕ.+ n)))
+    → (𝒇 ib') y ≡ (𝒇 ib) y
+  𝒇'≡𝒇 = elimInClampsᵣ _ _
+    (≡Continuous _ _
+       ((IsContinuous∘ _ _
+             (Lipschitz→IsContinuous _ _ (snd (fl-ebl ib')))
+             (IsContinuousClamp (rat (fst (invℚ₊ (fromNat (2 ℕ.+ n))))) _)))
+       (IsContinuous∘ _ _
+             (Lipschitz→IsContinuous _ _ (snd (fl-ebl ib)))
+              (IsContinuousClamp (rat (fst (invℚ₊ (fromNat (2 ℕ.+ n))))) _))
+      λ r → cong rat
+           ( ((ebl ib') .snd .snd .snd  _
+             (inClmp' r))
+
+         ∙ sym
+          (((ebl ib) .snd .snd .snd  _
+        (clam∈ℚintervalℙ _ _ (ℚ.<Weaken≤ _ _ (sqrRestr< n)) r))))
+        )
+    where
+    h = ℚ.≤ℤ→≤ℚ _ _ (ℤ.suc-≤-suc (ℤ.≤-suc (ℤ.ℕ≤→pos-≤-pos _ _ n<n')))
+    inClmp' : ∀ r → ℚ.clamp (fst (invℚ₊ (ℚ.[ pos (suc (suc n)) , (1+ 0) ] , tt)))
+      [ pos (suc (suc n)) / 1+ 0 ] r
+      ∈
+      ℚintervalℙ (fst (invℚ₊ (ℚ.[ pos (suc (suc n')) , (1+ 0) ] , tt)))
+      [ pos (suc (suc n')) / 1+ 0 ]
+    inClmp' r =
+       ℚ.isTrans≤
+         (fst (invℚ₊ (ℚ.[ pos (suc (suc n')) , (1+ 0) ] , tt)))
+         (fst (invℚ₊ (ℚ.[ pos (suc (suc n)) , (1+ 0) ] , tt)))
+         (ℚ.clamp (fst (invℚ₊ (ℚ.[ pos (suc (suc n)) , (1+ 0) ]
+        , tt)))
+      [ pos (suc (suc n)) / 1+ 0 ] r)
+         ((fst (ℚ.invℚ₊-≤-invℚ₊
+           ([ pos (suc (suc n)) / 1+ 0 ] , _)
+           ([ pos (suc (suc n')) / 1+ 0 ] , _)) h))
+          (ℚ.≤clamp (fst (invℚ₊ (ℚ.[ pos (suc (suc n)) , (1+ 0) ] , tt)))
+      [ pos (suc (suc n)) / 1+ 0 ] r (
+        (ℚ.<Weaken≤
+          (fst (invℚ₊ (fromNat (2 ℕ.+ n))))
+          (fromNat (2 ℕ.+ n))
+
+         (sqrRestr< n))))
+       , ℚ.isTrans≤ _
+            (ℚ.[ pos (suc (suc n)) , (1+ 0) ]) _
+           (ℚ.clamp≤
+             (fst (invℚ₊ (ℚ.[ pos (suc (suc n)) , (1+ 0) ] , tt)))
+             _ r)
+           h
+
+
+  2+n≤ℚ2+n' = (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _ (ℕ.<-weaken (ℕ.<-k+ n<n'))))
+
+  x⁻¹∈ : 𝒇⁻¹ ib x ∈
+            intervalℙ (rat (fst (invℚ₊ (fromNat (2 ℕ.+ n')))))
+            (rat (fromNat (2 ℕ.+ n')))
+  x⁻¹∈ = (isTrans≤ᵣ _ _ _ (≤ℚ→≤ᵣ _ _
+           (fst (ℚ.invℚ₊-≤-invℚ₊ (fromNat (2 ℕ.+ n)) (fromNat (2 ℕ.+ n')))
+        2+n≤ℚ2+n'))
+       (fst x∈*))
+    , (isTrans≤ᵣ _ _ _ (snd x∈*) (≤ℚ→≤ᵣ _ _ 2+n≤ℚ2+n'))
+
+   where
+   x∈* : 𝒇⁻¹ ib x ∈
+            intervalℙ (rat (fst (invℚ₊ (fromNat (2 ℕ.+ n)))))
+            (rat (fromNat (2 ℕ.+ n)))
+   x∈* = 𝒇⁻¹∈ ib x x∈
+
+  h : 𝒇⁻¹ ib x ≡ 𝒇⁻¹ ib' x
+  h = sym (𝒇⁻¹∘𝒇 ib' (𝒇⁻¹ ib x) x⁻¹∈ )
+    ∙ cong (𝒇⁻¹ ib') (𝒇'≡𝒇 (𝒇⁻¹ ib x) (𝒇⁻¹∈ ib x x∈)
+       ∙ 𝒇∘𝒇⁻¹ ib _ x∈ )
+
+
+
+ rootSeq⊆→ : Seq⊆→ ℝ rootSeq⊆
+ rootSeq⊆→ .Seq⊆→.fun x n _ = IsBilipschitz.𝒇⁻¹ (rootRest n) x
+ rootSeq⊆→ .Seq⊆→.fun⊆ = f⊆
+
+ getBounds : ∀ x → 0 <ᵣ x → Σ ℚ (λ q → (0 <ᵣ rat q) × (rat q <ᵣ x)) →
+      Σ[ M ∈ ℕ₊₁ ] (absᵣ x <ᵣ fromNat (ℕ₊₁→ℕ M)) →
+      Σ[ N ∈ ℕ   ] (x ∈ intervalℙ (rat (loB N)) (rat (hiB N)))
+ getBounds x 0<x (q , 0<q , q<x) ((1+ M) , x<1+M ) =
+    𝑵 , loB≤x , x≤hiB
+    -- 𝑵 ,
+   -- (loB≤x , x≤hiB)
+  where
+
+  q₊ : ℚ₊
+  q₊ = (q , ℚ.<→0< _ (<ᵣ→<ℚ _ _ 0<q))
+
+  flr-q = ℚ.floor-fracℚ₊ (invℚ₊ q₊)
+
+  lo𝑵 = suc (fst (fst flr-q))
+  hi𝑵 = M
+
+  𝑵 = ℕ.max lo𝑵 hi𝑵
+
+  loB≤q : loB 𝑵 ℚ.≤ q
+  loB≤q = subst2 (ℚ._≤_)
+     (ℚ.invℚ₊-ℚ^ⁿ _ _) (ℚ.invℚ₊-invol q₊)
+     (fst (ℚ.invℚ₊-≤-invℚ₊ _ _)
+      (ℚ.isTrans≤ (fst (ℚ.invℚ₊ q₊)) _ _
+        (ℚ.<Weaken≤ _ _ (ℚ.≤floor-fracℚ₊ (invℚ₊ q₊))) -- (ℚ.≤floor-fracℚ₊ (invℚ₊ q₊))
+         (ℚ.isTrans≤ _ _ _
+           (ℚ.isTrans≤ _ _ _ (ℚ.≤ℤ→≤ℚ _ _
+             (ℤ.ℕ≤→pos-≤-pos _ _
+                 (subst (ℕ._≤ (lo𝑵 ^ suc (suc m)))
+                   (ℕ.·-identityʳ lo𝑵)
+                    ((ℕ.^-monotone lo𝑵 0 (suc m) ℕ.zero-≤)))))
+             (ℚ.≡Weaken≤ (fromNat (lo𝑵 ^ suc (suc m)))
+               ((fromNat lo𝑵 ℚ^ⁿ (2 ℕ.+ m)))
+                (sym ((ℚ.fromNat-^ lo𝑵 (suc (suc m)))))))
+           (ℚ^ⁿ-Monotone {fromNat lo𝑵} (suc (suc m))
+             (ℚ.≤ℤ→≤ℚ _ _ ℤ.zero-≤pos)
+             (ℚ.≤ℤ→≤ℚ _ _ ℤ.zero-≤pos)
+             (((ℚ.≤ℤ→≤ℚ _ _
+          (ℤ.ℕ≤→pos-≤-pos _ _
+          (ℕ.≤-trans (ℕ.≤-suc (ℕ.≤-suc ℕ.≤-refl))
+           (ℕ.left-≤-max {suc (suc lo𝑵)} {suc (suc hi𝑵)}))))))))
+          ))
+
+  loB≤x : rat (loB 𝑵) ≤ᵣ x
+  loB≤x = isTrans≤ᵣ _ _ _
+    (≤ℚ→≤ᵣ _ _ loB≤q)
+      (<ᵣWeaken≤ᵣ _ _ q<x)
+
+  1+M≤hiB : fromNat (suc M) ℚ.≤ (hiB M)
+  1+M≤hiB =
+   subst (fromNat (suc M) ℚ.≤_) (sym (ℚ.fromNat-^ _ _))
+    ((ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _
+      (ℕ.≤-trans (ℕ.≤-suc ℕ.≤-refl) (subst (ℕ._≤ (suc (suc M) ^ suc (suc m)))
+          (sym (cong (suc ∘ suc) (sym (·-identityʳ M))))
+           (ℕ.^-monotone (suc (suc M)) 0 (suc m) ℕ.zero-≤ )))
+      )))
+
+
+  x≤hiB : x ≤ᵣ rat (hiB 𝑵)
+  x≤hiB =
+   isTrans≡≤ᵣ _ _ _  (sym (absᵣPos _ 0<x))
+      (isTrans≤ᵣ _ _ _
+       (<ᵣWeaken≤ᵣ _ _ x<1+M)
+         ((≤ℚ→≤ᵣ _ _ (ℚ.isTrans≤ (fromNat (suc M)) _ _ 1+M≤hiB
+           ((ℚ^ⁿ-Monotone (suc (suc m))
+              (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _ ℕ.zero-≤))
+              (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _ ℕ.zero-≤))
+            (ℚ.≤ℤ→≤ℚ _ _ (ℤ.ℕ≤→pos-≤-pos _ _
+             ((ℕ.right-≤-max {suc (suc hi𝑵)} {suc (suc lo𝑵)})) ))
+             )))
+             ))
+
+             )
+
+ ℝ₊⊆rootSeq : rootSeq⊆ Seq⊆.s⊇ (λ x → (0 <ᵣ x ) , isProp<ᵣ _ _)
+ ℝ₊⊆rootSeq x 0<x =
+   PT.map2
+     (getBounds x 0<x)
+      (denseℚinℝ _ _ 0<x)
+      (getClamps x)
+
+
+ 0<root : (x : ℝ) (n : ℕ)
+     (x∈ : x ∈ intervalℙ (rat (loB n)) (rat (hiB n))) →
+     rat [ pos 0 / 1+ 0 ] <ᵣ IsBilipschitz.𝒇⁻¹ (rootRest n) x
+ 0<root x n x∈ =
+   isTrans<≤ᵣ _ _ _
+     (<ℚ→<ᵣ _ _ (ℚ.0<ℚ₊ (invℚ₊ (ℚ.[ pos (suc (suc n)) , (1+ 0) ] , tt))))
+     (fst (IsBilipschitz.𝒇⁻¹∈ (rootRest n) x x∈))
+
+
+ open Seq⊆→.FromIntersection rootSeq⊆→ isSetℝ (λ x → (0 <ᵣ x ) , isProp<ᵣ _ _) ℝ₊⊆rootSeq public
+
+
+ 𝒇=f : ∀ n x → x ∈ intervalℙ
+                     (rat (fst (invℚ₊ (ℚ.[ pos (suc (suc n)) , (1+ 0) ] , tt))))
+                     (rat (fromNat (2 ℕ.+ n)))  →
+          (x ^ⁿ (suc (suc m))) ≡ fst (IsBilipschitz.fl-ebl (rootRest n)) x
+ 𝒇=f n = elimInClampsᵣ (rat (fst (invℚ₊ (ℚ.[ pos (suc (suc n)) , (1+ 0) ] , tt)))) (rat _)
+  (≡Continuous _ _
+       (IsContinuous∘ _ _ (IsContinuous^ⁿ (suc (suc m)) ) (IsContinuousClamp (rat _) (rat _)))
+       (IsContinuous∘ _ _ (IsBilipschitz.isCont𝒇 (rootRest n)) (IsContinuousClamp (rat _) (rat _)))
+      λ r → ^ⁿ-ℚ^ⁿ (suc (suc m)) _ ∙ cong rat (sym (IsBilipschitz.ebl (rootRest n) .snd .snd .snd
+              (ℚ.clamp _ _ r) (clam∈ℚintervalℙ _ _
+               (ℚ.<Weaken≤ _ _ (sqrRestr< n)) r))))
+
+
+
+ bounds⊂ : (n : ℕ) (x : ℝ) →
+      x ∈ (λ z → Seq⊆.𝕡 rootSeq⊆ n z) →
+      ∃-syntax ℚ₊
+      (λ δ →
+         (y : ℝ) → x ∼[ δ ] y → y ∈ (λ z → Seq⊆.𝕡 rootSeq⊆ (suc n) z))
+ bounds⊂ n x (lo<x , x<hi)  = ∣ δ
+         , (λ y → (λ abs< →
+             let u = isTrans≤ᵣ (x -ᵣ y) _
+                        (rat (loB n ℚ.- loB (suc n) )) (≤absᵣ (x -ᵣ y))
+                        (<ᵣWeaken≤ᵣ (absᵣ (x -ᵣ y)) _
+                           (isTrans<≤ᵣ _ (rat (fst δ)) _ abs<
+                       (≤ℚ→≤ᵣ _ _ (ℚ.min≤ _ _))))
+                 v =
+                   isTrans≤ᵣ (y -ᵣ x) _
+                        (rat (hiB (suc n) ℚ.- hiB n )) (≤absᵣ (y -ᵣ x))
+                      (isTrans≡≤ᵣ _ _ _ (minusComm-absᵣ _ _)
+                        (<ᵣWeaken≤ᵣ (absᵣ (x -ᵣ y)) _ (isTrans<≤ᵣ _ _ _ abs<
+                       (≤ℚ→≤ᵣ _ _ (ℚ.min≤' _ _)))))
+             in  subst2 _≤ᵣ_
+                    (L𝐑.lem--079 {rat (loB n)})
+                     L𝐑.lem--079
+                    (≤ᵣMonotone+ᵣ _ _ _ _
+                       lo<x (-ᵣ≤ᵣ _ _ (isTrans≤≡ᵣ _ _ _ u (sym (-ᵣ-rat₂ _ _) ))))
+                    , subst2 _≤ᵣ_
+                          (𝐑'.minusPlus _ x)
+                          (𝐑'.minusPlus (rat (hiB (suc n))) (rat (hiB n)))
+                          (isTrans≤≡ᵣ _ _ _ (≤ᵣMonotone+ᵣ _ _ _ _
+                             v x<hi) (cong (_+ᵣ rat (hiB n)) (sym (-ᵣ-rat₂ _ _))))
+
+                             )
+             ∘ fst (∼≃abs<ε _ _ _)) ∣₁
+  where
+  δ = ℚ.min₊ (ℚ.<→ℚ₊ _ _ (loB-mon n))
+                        (ℚ.<→ℚ₊ _ _ (hiB-mon n))
+ opaque
+  nth-root : ℝ₊ → ℝ₊
+  nth-root (x , 0<x) =
+      ∩$ x 0<x
+    , ∩$-elimProp x 0<x {B = λ y → 0 <ᵣ y} (λ _ → isProp<ᵣ _ _)
+       (0<root x)
+
+  ^ⁿ∘ⁿ√ : ∀ x 0<x → (fst (nth-root (x , 0<x)) ^ⁿ (2 ℕ.+ m)) ≡ x
+  ^ⁿ∘ⁿ√ x 0<x = ∩$-elimProp x 0<x
+    {B = λ a → (a ^ⁿ (2 ℕ.+ m)) ≡ x}
+    (λ _ → isSetℝ _ _)
+      λ n x∈ →
+           𝒇=f _ _ (IsBilipschitz.𝒇⁻¹∈ (rootRest n) x x∈)
+        ∙ IsBilipschitz.𝒇∘𝒇⁻¹ (rootRest n) x x∈
+
+  ⁿ√∘^ⁿ : ∀ x 0<x → fst (nth-root (x  ^ⁿ (2 ℕ.+ m) , 0<x^ⁿ x (2 ℕ.+ m) 0<x)) ≡ x
+  ⁿ√∘^ⁿ x 0<x = ∩$-elimProp (x  ^ⁿ (2 ℕ.+ m)) (0<x^ⁿ x (2 ℕ.+ m) 0<x)
+    {B = λ a → a ≡ x}
+    (λ _ → isSetℝ _ _)
+     λ n x∈' →
+      let 0<n = ℕ.suc-≤-suc ℕ.zero-≤
+          zzs : rat (fst (invℚ₊ (_/_.[ pos (suc (suc n)) , (1+ 0) ] , tt))) ≤ᵣ x
+          zzs = (^ⁿMonotone⁻¹ (suc (suc m)) 0<n
+                 (0<A n) 0<x (isTrans≡≤ᵣ _ _ _ (^ⁿ-ℚ^ⁿ _ _) (fst x∈')))
+
+          zzss : x ≤ᵣ rat [ pos (suc (suc n)) / 1+ 0 ]
+          zzss = (^ⁿMonotone⁻¹ (suc (suc m)) 0<n 0<x (0<B n)
+                     (isTrans≤≡ᵣ _ _ _ (snd x∈') (sym (^ⁿ-ℚ^ⁿ _ _))))
+          x∈ : (rat (fst (invℚ₊ (_/_.[ pos (suc (suc n)) , (1+ 0) ] , tt))) ≤ᵣ x) ×
+               (x ≤ᵣ rat (fromNat (2 ℕ.+ n)))
+          x∈ =  zzs , zzss
+
+
+
+
+      in cong (fst (IsBilipschitz.f⁻¹R-L (rootRest n)))
+                 (𝒇=f n x x∈)
+                ∙ IsBilipschitz.𝒇⁻¹∘𝒇 (rootRest n) x x∈
+
+
+  nth-root-cont : IsContinuousWithPred
+          (λ x → _ , isProp<ᵣ _ _) (curry (fst ∘ nth-root))
+  nth-root-cont = ∩$-cont' _ _
+     bounds⊂ _ _
+      λ n → AsContinuousWithPred _ _
+               (IsBilipschitz.isCont𝒇⁻¹ (rootRest n))
+
+  ℚApproxℙ-nth-root : ℚApproxℙ'
+                          (λ x → (0 <ᵣ x) , isProp<ᵣ _ _)
+                          (λ x → (0 <ᵣ x) , isProp<ᵣ _ _)
+                          (curry (nth-root))
+  ℚApproxℙ-nth-root q q∈ =
+   let q₊ = (q , ℚ.<→0< _ (<ᵣ→<ℚ _ _ q∈))
+       (m , q<m) = ℚ.ceilℚ₊ q₊
+       (n' , q∈') = getBounds (rat q) q∈
+          (fst (/2₊ q₊) ,
+            snd (ℚ₊→ℝ₊ (/2₊ q₊))
+              , <ℚ→<ᵣ _ _ (x/2<x q₊))
+               (1+ (ℕ₊₁→ℕ m) , isTrans<ᵣ _ _ _
+                   (isTrans≡<ᵣ _ _ _
+                     (absᵣPos _ (snd (ℚ₊→ℝ₊ q₊)))
+                     (<ℚ→<ᵣ _ _ q<m))
+                   (<ℚ→<ᵣ _ _ (ℚ.<ℤ→<ℚ _ _
+                     ℤ.isRefl≤)))
+       (a , b , c , d) =
+          ( (IsBilipschitz.ℚApproxℙ-𝒇⁻¹ (rootRest n')))
+   in a q q∈' , (λ ε →
+      isTrans<≤ᵣ _ _ _ (snd (ℚ₊→ℝ₊ (invℚ₊ (fromNat (2 ℕ.+ _)))))
+         (fst (b q q∈' ε))) , c q q∈' ,
+      d q q∈'
+      ∙ sym (∩$-∈ₙ (rat q) q∈ n' q∈')
+
+
+ nth-pow-root-iso₊₂ : Iso ℝ₊ ℝ₊
+ nth-pow-root-iso₊₂ .Iso.fun (x , 0<x) =
+   (x ^ⁿ (2 ℕ.+ m)) , 0<x^ⁿ _ _ 0<x
+ nth-pow-root-iso₊₂ .Iso.inv = nth-root
+ nth-pow-root-iso₊₂ .Iso.rightInv =
+   ℝ₊≡ ∘ uncurry ^ⁿ∘ⁿ√
+ nth-pow-root-iso₊₂ .Iso.leftInv =
+   ℝ₊≡ ∘ uncurry ⁿ√∘^ⁿ
+
+
+root : ℕ₊₁ → ℝ₊ →  ℝ₊
+root one x = x
+root (2+ n) x = NthRoot.nth-root n x
+
+ℚApproxℙ-root : ∀ n → ℚApproxℙ'
+                        (λ x → (0 <ᵣ x) , isProp<ᵣ _ _)
+                        (λ x → (0 <ᵣ x) , isProp<ᵣ _ _)
+                        (curry ((root n)))
+ℚApproxℙ-root one q q∈ = (λ _ → q) , (λ _ → q∈) , (λ _ _ → refl∼ _ _) , limConstRat _ _
+
+ℚApproxℙ-root (2+ n) = NthRoot.ℚApproxℙ-nth-root n
+
+IsContinuousRoot : ∀ n → IsContinuousWithPred
+         (λ x → _ , isProp<ᵣ _ _)
+         λ x 0<x → fst (root n (x , 0<x))
+IsContinuousRoot one =
+  AsContinuousWithPred _ _ IsContinuousId
+IsContinuousRoot (2+ n) = NthRoot.nth-root-cont n
+
+
+nth-pow-root-iso : ℕ₊₁ → Iso ℝ₊ ℝ₊
+nth-pow-root-iso k .Iso.fun (x , 0<x) = (x ^ⁿ ℕ₊₁→ℕ k) , 0<x^ⁿ _ _ 0<x
+nth-pow-root-iso k .Iso.inv = root k
+nth-pow-root-iso one .Iso.rightInv _ = ℝ₊≡ (·IdL _)
+nth-pow-root-iso (2+ n) .Iso.rightInv = Iso.rightInv
+  (NthRoot.nth-pow-root-iso₊₂ n)
+nth-pow-root-iso one .Iso.leftInv _ = ℝ₊≡ (·IdL _)
+nth-pow-root-iso (2+ n) .Iso.leftInv = Iso.leftInv
+  (NthRoot.nth-pow-root-iso₊₂ n)
diff --git a/Cubical/HITs/CauchyReals/Order.agda b/Cubical/HITs/CauchyReals/Order.agda
index bd88e12a10..3bc6bea7fa 100644
--- a/Cubical/HITs/CauchyReals/Order.agda
+++ b/Cubical/HITs/CauchyReals/Order.agda
@@ -7,6 +7,7 @@ open import Cubical.Foundations.Structure
 open import Cubical.Foundations.Function
 open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Powerset
 
 open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
 open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
@@ -33,6 +34,7 @@ open import Cubical.Data.NatPlusOne
 open import Cubical.Foundations.Path
 open import Cubical.Foundations.CartesianKanOps
 
+open import Cubical.Relation.Binary
 
 open import Cubical.HITs.CauchyReals.Base
 open import Cubical.HITs.CauchyReals.Lems
@@ -53,12 +55,32 @@ infix  8 -ᵣ_
 infixl 6 _+ᵣ_ _-ᵣ_
 
 
-_+ᵣ_ : ℝ → ℝ → ℝ
-_+ᵣ_ = NonExpanding₂.go sumR
+opaque
+ _+ᵣ_ : ℝ → ℝ → ℝ
+ _+ᵣ_ = NonExpanding₂.go sumR
+
+ +ᵣ-∼ : ∀ u v r ε → u ∼[ ε ] v → (u +ᵣ r) ∼[ ε ] (v +ᵣ r)
+ +ᵣ-∼ u v r =
+   NonExpanding₂.go∼L sumR r u v
+
+ +ᵣ-rat : ∀ p q → rat p +ᵣ rat q ≡ rat (p ℚ.+ q)
+ +ᵣ-rat p q = refl
+
+
+ +ᵣComm : ∀ x y → x +ᵣ y ≡ y +ᵣ x
+ +ᵣComm x y =
+   nonExpanding₂Ext ℚ._+_ (flip ℚ._+_)
+     sumR (NonExpanding₂-flip ℚ._+_ sumR) ℚ.+Comm x y ∙
+    (NonExpanding₂-flip-go ℚ._+_ sumR
+      (NonExpanding₂-flip ℚ._+_ sumR) x y )
+
+
+
+ +ᵣAssoc : ∀ x y z →  x +ᵣ (y +ᵣ z) ≡ (x +ᵣ y) +ᵣ z
+ +ᵣAssoc x y z =
+   (fst (∼≃≡ _ _)) (NonExpanding₂-Lemmas.gAssoc∼ _
+     sumR +ᵣComm ℚ.+Assoc x y z)
 
-+ᵣ-∼ : ∀ u v r ε → u ∼[ ε ] v → (u +ᵣ r) ∼[ ε ] (v +ᵣ r)
-+ᵣ-∼ u v r =
-  NonExpanding₂.go∼L sumR r u v
 
 minR : NonExpanding₂ ℚ.min
 minR = w
@@ -124,8 +146,11 @@ maxR = w
 minᵣ = NonExpanding₂.go minR
 maxᵣ = NonExpanding₂.go maxR
 
-_≤ᵣ_ : ℝ → ℝ → Type
-u ≤ᵣ v = maxᵣ u v ≡ v
+clampᵣ : ℝ → ℝ → ℝ → ℝ
+clampᵣ d u x = minᵣ (maxᵣ d x) u
+
+clampᵣ-rat : ∀ a b x → clampᵣ (rat a) (rat b) (rat x) ≡ rat (ℚ.clamp a b x)
+clampᵣ-rat a b x = refl
 
 Lipschitz-ℝ→ℝ-1→NonExpanding : ∀ f
   → Lipschitz-ℝ→ℝ 1 f → ⟨ NonExpandingₚ f ⟩
@@ -148,12 +173,11 @@ minᵣComm x y =
      (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 )
+
+clamp-lim : ∀ d u x y →
+         clampᵣ d u (lim x y) ≡ lim (λ ε → clampᵣ d u (x ε)) _
+clamp-lim d u x y = cong (flip minᵣ u) (maxᵣComm _ _)
+  ∙ congLim' _ _ _ λ _ → cong (flip minᵣ u) (maxᵣComm _ _)
 
 
 
@@ -168,18 +192,6 @@ inj-rat q r x with (ℚ.discreteℚ 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
@@ -207,246 +219,499 @@ maxᵣIdem = Elimℝ-Prop.go w
 
  w .Elimℝ-Prop.isPropA _ = isSetℝ _ _
 
+infix 4 _≤ᵣ_ _<ᵣ_
 
+open ℚ.HLP
 
-≤ᵣ-refl : ∀ x → x ≤ᵣ x
-≤ᵣ-refl x = maxᵣIdem x
+opaque
 
+ _≤ᵣ_ : ℝ → ℝ → Type
+ u ≤ᵣ v = maxᵣ u v ≡ v
 
-_Σ<ᵣ_ : ℝ → ℝ → Type
-u Σ<ᵣ v = Σ[ (q , r) ∈ (ℚ × ℚ) ] (u ≤ᵣ rat q) × (q ℚ.< r) × (rat r ≤ᵣ v)
+ ≤ᵣ→≡ : ∀ {u v} → u ≤ᵣ v → maxᵣ u v ≡ v
+ ≤ᵣ→≡ p = p
 
-infix 4 _≤ᵣ_ _<ᵣ_
+ ≡→≤ᵣ : ∀ {u v} → maxᵣ u v ≡ v → u ≤ᵣ v
+ ≡→≤ᵣ p = p
 
-_<ᵣ_ : ℝ → ℝ → 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
+ ≤ℚ→≤ᵣ : ∀ 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)
 
-_-ᵣ_ : ℝ → ℝ → ℝ
-x -ᵣ y = x +ᵣ (-ᵣ y)
 
+ ≤ᵣ≃≤ℚ : ∀ q r → (rat q ≤ᵣ rat r) ≃ (q ℚ.≤ r)
+ ≤ᵣ≃≤ℚ q r = propBiimpl→Equiv
+  (isSetℝ _ _) (ℚ.isProp≤ _ _)
+   (≤ᵣ→≤ℚ q r) (≤ℚ→≤ᵣ q r)
 
-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₁)))
+ ≤ᵣ-refl : ∀ x → x ≤ᵣ x
+ ≤ᵣ-refl x = maxᵣIdem x
+
+
+ _Σ<ᵣ_ : ℝ → ℝ → Type
+ u Σ<ᵣ v = Σ[ (q , r) ∈ (ℚ × ℚ) ] (u ≤ᵣ rat q) × (q ℚ.< r) × (rat r ≤ᵣ v)
+
+
+ _<ᵣ_ : ℝ → ℝ → Type
+ u <ᵣ v = ∃[ (q , r) ∈ (ℚ × ℚ) ] (u ≤ᵣ rat q) × (q ℚ.< r) × (rat r ≤ᵣ v)
+
+ <ᵣ-impl : ∀ u v → (u <ᵣ v) ≃ (∃[ (q , r) ∈ (ℚ × ℚ) ] (u ≤ᵣ rat q) × (q ℚ.< r) × (rat r ≤ᵣ v))
+ <ᵣ-impl _ _ = idEquiv _
+
+ isProp≤ᵣ : ∀ x y → isProp (x ≤ᵣ y)
+ isProp≤ᵣ _ _ = isSetℝ _ _
+
+ isProp<ᵣ : ∀ x y → isProp (x <ᵣ y)
+ isProp<ᵣ _ _ = squash₁
+
+
+ <ℚ→<ᵣ : ∀ 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)
 
-absᵣ = fst absᵣL
 
-absᵣ-nonExpanding : ⟨ NonExpandingₚ absᵣ ⟩
-absᵣ-nonExpanding u v ε x =
-  subst∼ (ℚ.·IdL _) $ snd absᵣL u v ε x
+ 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)
 
-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₁ (∼→∼' _ _ _) (∼'→∼ _ _ _)
+ 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)
 
+ 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
 
-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)
 
+ 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
+
+ <ᵣ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
+
+
+ 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
+
+
+ -ᵣ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
+
+ -ᵣ-rat : ∀ q → -ᵣ (rat q) ≡ rat (ℚ.- q)
+ -ᵣ-rat q = refl
+
+
+
+ -ᵣ-lip : Lipschitz-ℝ→ℝ 1 -ᵣ_
+ -ᵣ-lip = snd -ᵣR
+
+_-ᵣ_ : ℝ → ℝ → ℝ
+x -ᵣ y = x +ᵣ (-ᵣ y)
+
+x-ᵣy≡x+ᵣ[-ᵣy] : ∀ x y → x -ᵣ y ≡ x +ᵣ -ᵣ y
+x-ᵣy≡x+ᵣ[-ᵣy] x y = refl
+
+
+-ᵣ-rat₂ : ∀ u q → (rat u) -ᵣ (rat q) ≡ rat (u ℚ.- q)
+-ᵣ-rat₂ u q = cong (rat u +ᵣ_) (-ᵣ-rat q) ∙ +ᵣ-rat _ _
+
+
+opaque
+ unfolding -ᵣ_ _+ᵣ_
+ +-ᵣ : ∀ x → x -ᵣ x ≡ 0
+ +-ᵣ = fst (∼≃≡ _ _) ∘ Elimℝ-Prop.go w
+  where
+  w : Elimℝ-Prop λ z → (ε : ℚ₊) → (z -ᵣ z) ∼[ ε ] 0 --(λ 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 : Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ 1)
+ 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ᵣ : ℝ → ℝ
+ absᵣ = fst absᵣL
+
+ absᵣ0 : absᵣ 0 ≡ 0
+ absᵣ0 = refl
+
+
+ absᵣ-lip : Lipschitz-ℝ→ℝ 1 absᵣ
+ absᵣ-lip = snd absᵣL
+
+ absᵣ-rat' : ∀ q → absᵣ (rat q) ≡ rat (ℚ.abs' q)
+ absᵣ-rat' q = refl
+
+ absᵣ-rat : ∀ q → absᵣ (rat q) ≡ rat (ℚ.abs q)
+ absᵣ-rat q = cong rat (sym (ℚ.abs'≡abs q))
+
+ 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 (∼≃≡ (maxᵣ (lim x y) (rat r)) (rat r) ) ∙ₑ
+     equivΠCod λ ε →
+       propBiimpl→Equiv (isProp∼ _ _ _) squash₁
+        (∼→∼' (maxᵣ (lim x y) (rat r)) (rat r) ε)
+        (∼'→∼ (maxᵣ (lim x y) (rat r)) (rat r) ε)
+
+
+
+
+ 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)
+
+ 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 λ x → -ᵣ (-ᵣ x) ≡ x
+  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 λ x → absᵣ x ≡ absᵣ (-ᵣ x)
+  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)
+
+
+ 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'')) ∣₁
+
+
+
+
+ℝ₊ : Type
 ℝ₊ = Σ _ λ r → 0 <ᵣ r
 
+ℝ₀₊ : Type
+ℝ₀₊ = Σ _ λ r → 0 ≤ᵣ r
+
+
+isSetℝ₊ : isSet ℝ₊
+isSetℝ₊ = isSetΣ isSetℝ (λ _ → isProp→isSet (isProp<ᵣ _ _))
+
+isSetℝ₀₊ : isSet ℝ₀₊
+isSetℝ₀₊ = isSetΣ isSetℝ (λ _ → isProp→isSet (isProp≤ᵣ _ _))
+
+
+ℝ₊≡ : {x y : ℝ₊} → fst x ≡ fst y → x ≡ y
+ℝ₊≡ = Σ≡Prop λ _ → isProp<ᵣ _ _
+
+
+ℝ₀₊≡ : {x y : ℝ₀₊} → fst x ≡ fst y → x ≡ y
+ℝ₀₊≡ = Σ≡Prop λ _ → isProp≤ᵣ _ _
+
 
 ℚ₊→ℝ₊ : ℚ₊ → ℝ₊
 ℚ₊→ℝ₊ (x , y) = rat x , <ℚ→<ᵣ 0 x (ℚ.0<→< x y)
@@ -467,3 +732,48 @@ instance
    ; fromNat = λ { zero {{()}}  ; (suc n) →
      (rat [ pos (suc n) / 1 ]) , <ℚ→<ᵣ _ _
        (ℚ.<ℤ→<ℚ _ _ (ℤ.suc-≤-suc ℤ.zero-≤pos)) }}
+
+
+fromNat+ᵣ : ∀ n m → fromNat n +ᵣ fromNat m ≡ fromNat (n ℕ.+ m)
+fromNat+ᵣ n m = +ᵣ-rat _ _ ∙ cong rat (ℚ.ℕ+→ℚ+ n m)
+
+isIncrasing : (ℝ → ℝ) → Type₀
+isIncrasing f = ∀ x y → x <ᵣ y → f x <ᵣ f y
+
+isPropIsIncrasing : ∀ f → isProp (isIncrasing f)
+isPropIsIncrasing f = isPropΠ3 λ _ _ _ → isProp<ᵣ _ _
+
+
+ℚintervalℙ : ℚ → ℚ → ℙ ℚ
+ℚintervalℙ a b x = ((a ℚ.≤ x) × (x ℚ.≤ b)) ,
+  isProp× (ℚ.isProp≤ _ _)  (ℚ.isProp≤ _ _)
+
+
+intervalℙ : ℝ → ℝ → ℙ ℝ
+intervalℙ a b x = ((a ≤ᵣ x) × (x ≤ᵣ b)) ,
+  isProp× (isProp≤ᵣ _ _ )  (isProp≤ᵣ _ _ )
+
+
+
+ointervalℙ : ℝ → ℝ → ℙ ℝ
+ointervalℙ a b x = ((a <ᵣ x) × (x <ᵣ b)) ,
+  isProp× (isProp<ᵣ _ _ )  (isProp<ᵣ _ _ )
+
+
+pred< : ℝ → ℙ ℝ
+pred< x y = (y <ᵣ x) , isProp<ᵣ _ _
+
+pred≤ : ℝ → ℙ ℝ
+pred≤ x y = (y ≤ᵣ x) , isProp≤ᵣ _ _
+
+pred≥ : ℝ → ℙ ℝ
+pred≥ x y = (x ≤ᵣ y) , isProp≤ᵣ _ _
+
+pred> : ℝ → ℙ ℝ
+pred> x y = (x <ᵣ y) , isProp<ᵣ _ _
+
+pred≤< : ℝ → ℝ → ℙ ℝ
+pred≤< a b x = ((a ≤ᵣ x) × (x <ᵣ b)) , isProp× (isProp≤ᵣ _ _) (isProp<ᵣ _ _)
+
+pred<≤ : ℝ → ℝ → ℙ ℝ
+pred<≤ a b x = ((a <ᵣ x) × (x ≤ᵣ b)) , isProp× (isProp<ᵣ _ _) (isProp≤ᵣ _ _)
diff --git a/Cubical/HITs/CauchyReals/Sequence.agda b/Cubical/HITs/CauchyReals/Sequence.agda
index fd7054d972..73840e0540 100644
--- a/Cubical/HITs/CauchyReals/Sequence.agda
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -7,6 +7,12 @@ open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.Isomorphism
 open import Cubical.Foundations.HLevels
 open import Cubical.Foundations.Function
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Powerset
+
+import Cubical.Functions.Logic as L
+
 
 open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
 open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
@@ -39,137 +45,86 @@ open import Cubical.HITs.CauchyReals.Multiplication
 open import Cubical.HITs.CauchyReals.Inverse
 
 
+Lipschitz-ℚ→ℝℙ : ℚ₊ → (P : ℙ ℝ) → (∀ x → rat x ∈ P  → ℝ) → Type
+Lipschitz-ℚ→ℝℙ L P f =
+  (∀ q q∈ r r∈ → (ε : ℚ₊) →
+    ℚ.abs (q ℚ.- r) ℚ.< (fst ε) → absᵣ (f q q∈ -ᵣ f r r∈)
+     <ᵣ rat (fst (L ℚ₊· ε  )))
 
 
+extend-Lipshitzℚ→ℝ : ∀ L →  ∀ a b → (a ℚ.≤ b) → ∀ f →
+        Lipschitz-ℚ→ℝℙ L (intervalℙ (rat a) (rat b)) f →
+        Σ[ f' ∈ (ℚ → ℝ) ]
+          (Lipschitz-ℚ→ℝ L f' × (∀ x x∈ → f' x ≡ f x x∈ ))
 
-Seq : Type
-Seq = ℕ → ℝ
-
+extend-Lipshitzℚ→ℝ L a b a≤b f li =
+ (λ x → f (ℚ.clamp a b x) (∈ℚintervalℙ→∈intervalℙ _ _ _
+  (clam∈ℚintervalℙ a b a≤b x))) ,
+   w , (λ x x∈ → cong (uncurry f)
+    (Σ≡Prop (∈-isProp (intervalℙ (rat a) (rat b) ∘ rat))
+    (ℚ.inClamps a b x (≤ᵣ→≤ℚ _ _ (fst x∈)) (≤ᵣ→≤ℚ _ _ (snd x∈)) )))
 
-≤ᵣ-·ᵣ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)))
-
+ w : Lipschitz-ℚ→ℝ L
+       (λ x →
+          f (ℚ.clamp a b x)
+          (∈ℚintervalℙ→∈intervalℙ a b (ℚ.clamp a b x)
+           (clam∈ℚintervalℙ a b a≤b x)))
+ w q r ε u v = invEq (∼≃abs<ε _ _ _)
+  (li _ _
+   _ _ ε (ℚ.isTrans≤<
+    (ℚ.abs (ℚ.clamp a b q ℚ.- ℚ.clamp a b r)) (ℚ.abs (q ℚ.- r)) (fst ε)
+    (ℚ.clampDist a b r q) (ℚ.absFrom<×< (fst ε) (q ℚ.- r) u v)))
+
+
+LLipschitz-ℚ→ℝ : (ℚ → ℝ) → Type
+LLipschitz-ℚ→ℝ f =
+  (∀ x → ∃[ (L , ε) ∈ (ℚ₊ × ℚ₊) ]
+    ∀ q r → absᵣ (rat q -ᵣ x) <ᵣ rat (fst ε)
+          → absᵣ (rat r -ᵣ x) <ᵣ rat (fst ε)
+            → f q ∼[ L ℚ₊· ε  ] f r)
+
+
+Dichotomyℝ : ∀ (ε : ℚ₊) x y →
+    ⟨ ((x  <ᵣ y +ᵣ rat (fst ε)) , isProp<ᵣ _ _)
+       L.⊔ ((y <ᵣ x +ᵣ rat (fst ε)) , isProp<ᵣ _ _) ⟩
+Dichotomyℝ ε x x' =
+     (PT.map2
+         (λ (r , x<r , r<x+ε/2) (r' , x'-ε/2<r' , r'<x') →
+           ⊎.map
+
+              (λ r≤r' → isTrans<ᵣ _ _ _
+                 x<r (isTrans≤<ᵣ _ _ _
+                   (≤ℚ→≤ᵣ r r' r≤r') r'<x'))
+              (λ r'<r →
+                 isTrans<ᵣ _ _ _
+                  (isTrans<ᵣ _ _ _ x'-ε/2<r' (<ℚ→<ᵣ r' r r'<r))
+                  r<x+ε/2 )
+             (ℚ.Dichotomyℚ r r'))
+        (denseℚinℝ x (x +ᵣ rat (fst (ε)))
+          (≤Weaken<+ᵣ _ _ (ℚ₊→ℝ₊ (ε)) (≤ᵣ-refl _)))
+        (denseℚinℝ x' (x' +ᵣ rat (fst (ε)))
+         ((≤Weaken<+ᵣ _ _ (ℚ₊→ℝ₊ (ε)) (≤ᵣ-refl _)))))
+
+-- Dichotomyℝ' : ∀ x →
+--     ⟨ ((x ≤ᵣ 0) , isProp≤ᵣ _ _)
+--        L.⊔ ((0 ≤ᵣ x) , isProp≤ᵣ _ _) ⟩
+-- Dichotomyℝ' = Elimℝ-Prop.go w
+--  where
+--  w : Elimℝ-Prop _
+--  w .Elimℝ-Prop.ratA x =
+--    PT.map (⊎.map (≤ℚ→≤ᵣ _ _) (≤ℚ→≤ᵣ _ _))
+--      (ℚ.isStronglyConnected≤ x 0)
+--  w .Elimℝ-Prop.limA x p X = {!!}
+--   where
+--   ww : {!!}
+--   ww = {!X!}
+--  w .Elimℝ-Prop.isPropA x = snd
+--     (((x ≤ᵣ 0) , isProp≤ᵣ _ _)
+--        L.⊔ ((0 ≤ᵣ x) , isProp≤ᵣ _ _))
 
+Seq : Type
+Seq = ℕ → ℝ
 
 /nᵣ-L : (n : ℕ₊₁) → Σ _ (Lipschitz-ℝ→ℝ _)
 /nᵣ-L n = (fromLipschitz ([ 1 / n ] , _)
@@ -207,12 +162,25 @@ seqSumUpTo : (ℕ → ℝ) → ℕ →  ℝ
 seqSumUpTo s zero = 0
 seqSumUpTo s (suc n) = s zero +ᵣ seqSumUpTo (s ∘ suc) n
 
+seqSumUpToConst : ∀ x n → seqSumUpTo (const x) n ≡ x ·ᵣ fromNat n
+seqSumUpToConst x zero = sym (𝐑'.0RightAnnihilates x)
+seqSumUpToConst x (suc n) =
+ cong₂ (_+ᵣ_) (sym (·IdR x)) (seqSumUpToConst x n) ∙
+   sym (·DistL+ x 1 (fromNat n))
+    ∙ cong ((x ·ᵣ_))
+     (+ᵣ-rat _ _ ∙ cong rat (ℚ.ℕ+→ℚ+ _ _))
+
 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≤ : ∀ s s' → (∀ n → s n ≤ᵣ s' n) →
+  ∀ n → seqSumUpTo s n ≤ᵣ seqSumUpTo s' n
+seqSumUpTo≤ s s' X zero = ≤ᵣ-refl _
+seqSumUpTo≤ s s' X (suc n) =
+  ≤ᵣMonotone+ᵣ _ _ _ _ (X 0) (seqSumUpTo≤ _ _ (X ∘ suc) n)
 
 
 seqSumUpTo' : (ℕ → ℝ) → ℕ →  ℝ
@@ -313,9 +281,72 @@ log2ℕ n = w n n ℕ.≤-refl
 
 
 0<x^ⁿ : ∀ x n → 0 <ᵣ x → 0 <ᵣ (x ^ⁿ n)
-0<x^ⁿ x zero x₁ = <ℚ→<ᵣ _ _ (𝟚.toWitness {Q = ℚ.<Dec 0 1} tt)
+0<x^ⁿ x zero x₁ = decℚ<ᵣ?
 0<x^ⁿ x (suc n) x₁ = ℝ₊· (_ , 0<x^ⁿ x n x₁) (_ , x₁)
 
+0≤x^ⁿ : ∀ x n → 0 ≤ᵣ x → 0 ≤ᵣ (x ^ⁿ n)
+0≤x^ⁿ x zero _ = decℚ≤ᵣ?
+0≤x^ⁿ x (suc n) 0≤x =
+ isTrans≡≤ᵣ _ _ _ (sym (𝐑'.0RightAnnihilates _))
+   (≤ᵣ-o·ᵣ 0 _ _ (0≤x^ⁿ x n 0≤x) 0≤x)
+
+
+opaque
+ unfolding _<ᵣ_
+ ^ⁿ-invℝ : ∀ n x 0＃x 0＃x^ →
+             ((invℝ x 0＃x) ^ⁿ n) ≡ (invℝ (x ^ⁿ n) (0＃x^))
+ ^ⁿ-invℝ zero x _ _ = sym (invℝ1 _)
+ ^ⁿ-invℝ (suc n) x 0＃x _ =
+   cong (_·ᵣ invℝ x _) (^ⁿ-invℝ n x _ z) ∙
+     sym (invℝ· _ _ _ _ _)
+  where
+
+  z' : ∀ n → x <ᵣ 0 → 0 ＃ (x ^ⁿ n)
+  z' zero _ = inl decℚ<ᵣ?
+  z' (suc n) x<0 =
+   ⊎.rec (λ p → inr
+      (isTrans≡<ᵣ _ _ _
+       (sym (-ᵣ·-ᵣ _ _) ∙ -ᵣ· _ _)
+       (isTrans<≡ᵣ _ _ _ (-ᵣ<ᵣ _ _ (<ᵣ₊Monotone·ᵣ _ _ _ _
+        (≤ᵣ-refl 0) (≤ᵣ-refl _ )
+      p 0<-x)) (cong (-ᵣ_) (sym (rat·ᵣrat 0 0)))) ))
+     (λ p →
+       inl (isTrans≡<ᵣ _ _ _ (rat·ᵣrat 0 0)
+          (isTrans<≡ᵣ _ _ _
+             (<ᵣ₊Monotone·ᵣ _ _ _ _
+               (≤ᵣ-refl 0) (≤ᵣ-refl 0)
+               (-ᵣ<ᵣ _ _ p) 0<-x)
+                          (-ᵣ·-ᵣ _ _))))
+     (z' n x<0)
+   where
+    0<-x : 0 <ᵣ -ᵣ x
+    0<-x = -ᵣ<ᵣ _ _ x<0
+
+  z : 0 ＃ (x ^ⁿ n)
+  z = ⊎.rec (inl ∘ 0<x^ⁿ x n)
+        (z' n) 0＃x
+
+^ⁿDist·ᵣ : ∀ n x y →
+            ((x ·ᵣ y) ^ⁿ n) ≡ (x ^ⁿ n) ·ᵣ (y ^ⁿ n)
+^ⁿDist·ᵣ zero x y = rat·ᵣrat _ _
+^ⁿDist·ᵣ (suc n) x y =
+   cong (_·ᵣ (x ·ᵣ y)) (^ⁿDist·ᵣ n x y)
+ ∙ (sym (·ᵣAssoc _ _ _)
+     ∙∙ cong ((x ^ⁿ n) ·ᵣ_)
+       ((·ᵣAssoc _ _ _)
+     ∙∙ cong (_·ᵣ y) (·ᵣComm _ _)
+     ∙∙ sym (·ᵣAssoc _ _ _))
+     ∙∙ ·ᵣAssoc _ _ _)
+
+
+
+／^ⁿ : ∀ n x y 0＃y 0＃y^ⁿ →
+         (x ^ⁿ n) ／ᵣ[ y ^ⁿ n , 0＃y^ⁿ ] ≡
+           ((x ／ᵣ[ y , 0＃y ]) ^ⁿ n)
+／^ⁿ n x y 0＃y 0＃y^ⁿ =
+  cong ((x ^ⁿ n) ·ᵣ_) (sym (^ⁿ-invℝ n y _ _))
+    ∙ sym (^ⁿDist·ᵣ n _ _)
+
 
 geometricProgression : ℝ → ℝ → ℕ → ℝ
 geometricProgression a r zero = a
@@ -397,16 +428,27 @@ Sₙ-sup a r n a<0 0<r 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≤ᵣ _ _ ((𝐑'.+IdR' _ _ (-ᵣ-rat 0)))) ))
           (≡ᵣ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 →
+  (∀ m → m ℕ.≤ n  → s m <ᵣ s' m) →
+   seqSumUpTo s (suc n) <ᵣ seqSumUpTo s' (suc n)
+Seq<→Σ< s s' zero x = subst2 _<ᵣ_
+  (sym (+IdR _)) (sym (+IdR _)) (x 0 ℕ.≤-refl)
+Seq<→Σ< s s' (suc n) x =
+ <ᵣMonotone+ᵣ _ _ _ _
+  (x 0 ℕ.zero-≤) (Seq<→Σ< (s ∘ suc) (s' ∘ suc) n
+   (λ m x₁ → x (suc m) (ℕ.suc-≤-suc x₁ )))
+
+
+
+Seq<→Σ<-+1 : (s s' : Seq) →
+  (s 0 ≤ᵣ s' 0) →
+  (∀ n → s (suc n) <ᵣ s' (suc n)) →
+   ∀ n → seqSumUpTo s (suc (suc n)) <ᵣ seqSumUpTo s' (suc (suc n))
+Seq<→Σ<-+1 s s' x0 x n = ≤<ᵣMonotone+ᵣ _ _ _ _
+  x0 (Seq<→Σ< (s ∘ suc) (s' ∘ suc) n (const ∘ x))
 
 Seq≤→Σ≤ : (s s' : Seq) →
   (∀ n → s n ≤ᵣ s' n) →
@@ -415,6 +457,15 @@ Seq≤→Σ≤ s s' x zero = ≤ᵣ-refl _
 Seq≤→Σ≤ s s' x (suc n) = ≤ᵣMonotone+ᵣ _ _ _ _
  (x 0) (Seq≤→Σ≤ (s ∘ suc) (s' ∘ suc) (x ∘ suc) n)
 
+Seq≤→Σ≤-upto : (s s' : Seq) → ∀ N →
+  (∀ n → n ℕ.< N → s n ≤ᵣ s' n) →
+   seqSumUpTo s N ≤ᵣ seqSumUpTo s' N
+Seq≤→Σ≤-upto s s' zero x = ≤ᵣ-refl _
+Seq≤→Σ≤-upto s s' (suc N) x = ≤ᵣMonotone+ᵣ _ _ _ _
+ (x 0 ℕ.zero-<-suc) (Seq≤→Σ≤-upto (s ∘ suc) (s' ∘ suc) N
+   λ n u → x (suc n) (ℕ.suc-≤-suc u))
+
+
 Seq'≤→Σ≤ : (s s' : Seq) →
   (∀ n → s n ≤ᵣ s' n) →
    ∀ n → seqSumUpTo' s n ≤ᵣ seqSumUpTo' s' n
@@ -427,7 +478,25 @@ Seq'≤→Σ≤ s s' x (suc 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)
+  isTrans≡≤ᵣ _ _ _
+    (sym (+ᵣ-rat _ _)) (≤ᵣMonotone+ᵣ _ _ _ _ (0≤seqΣ 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) =
+  isTrans≡≤ᵣ _ _ _
+    (sym (+ᵣ-rat _ _))
+    $ ≤ᵣMonotone+ᵣ _ _ _ _ (x 0) (0≤seqΣ' (s ∘ suc) (x ∘ suc) n)
+
+0<seqΣ' : ∀ s → (∀ n → 0 <ᵣ s n)
+            → ∀ n → 0 <ᵣ seqΣ' s (suc n)
+0<seqΣ' s x zero = isTrans<≡ᵣ _ _ _ (x 0) (sym (+IdR (s 0)))
+0<seqΣ' s x (suc n) =
+    isTrans≡<ᵣ _ _ _
+    (sym (+ᵣ-rat _ _))
+    $ <ᵣMonotone+ᵣ _ _ _ _ (x 0) (0<seqΣ' (s ∘ suc) (x ∘ suc) n)
+
 
 seriesDiff : (s : Seq)  →
   ∀ N n → (seqΣ s (n ℕ.+ N) +ᵣ (-ᵣ seqΣ s N)) ≡
@@ -439,11 +508,350 @@ seriesDiff s N (suc n) =
    cong (s (n ℕ.+ N) +ᵣ_) (seriesDiff s N n)
     ∙ +ᵣComm (s (n ℕ.+ N)) (seqΣ (s ∘ (ℕ._+ N)) n)
 
+opaque
+ unfolding -ᵣ_
+ 0＃· : ∀ x y → 0 ＃ x → 0 ＃ y → 0 ＃ (x ·ᵣ y)
+ 0＃· x y =
+  ⊎.rec (λ 0<x → ⊎.rec
+         (λ 0<y → inl (isTrans≡<ᵣ _ _ _ (rat·ᵣrat _ _)
+             (<ᵣ₊Monotone·ᵣ _ _ _ _
+               (≤ᵣ-refl _) (≤ᵣ-refl _) 0<x 0<y)))
+             λ y<0 → inr (
+               let z = isTrans≡<ᵣ _ _ _ (rat·ᵣrat _ _) $
+                        <ᵣ₊Monotone·ᵣ _ _ _ _
+                         (≤ᵣ-refl _) (≤ᵣ-refl _) 0<x (-ᵣ<ᵣ _ _ y<0)
+               in isTrans≡<ᵣ _ _ _ (cong (x ·ᵣ_) (sym (-ᵣInvol _))
+                     ∙  (·-ᵣ _ _)) (-ᵣ<ᵣ _ _ z)))
+        λ x<0 → ⊎.rec
+          (λ 0<y → inr (
+               let z = isTrans≡<ᵣ _ _ _ (rat·ᵣrat _ _) $
+                        <ᵣ₊Monotone·ᵣ _ _ _ _
+                         (≤ᵣ-refl _) (≤ᵣ-refl _) (-ᵣ<ᵣ _ _  x<0) 0<y
+               in isTrans≡<ᵣ _ _ _ (sym (-ᵣInvol _)
+                  ∙ cong (-ᵣ_) (sym (-ᵣ· _ _))) (-ᵣ<ᵣ _ _ z)))
+          λ y<0 → inl
+             let z = isTrans≡<ᵣ _ _ _ (rat·ᵣrat _ _) $
+                        <ᵣ₊Monotone·ᵣ _ _ _ _
+                         (≤ᵣ-refl _) (≤ᵣ-refl _) (-ᵣ<ᵣ _ _  x<0) (-ᵣ<ᵣ _ _  y<0)
+               in isTrans<≡ᵣ _ _ _ z (-ᵣ·-ᵣ x y)
+
+＃Δ : ∀ x y → (0 ＃ (x -ᵣ y)) ≃ y ＃ x
+＃Δ x y = ⊎.⊎-equiv
+  (invEquiv (x<y≃0<y-x _ _))
+  (invEquiv (x<y≃x-y<0 _ _))
+
+invℝ<invℝ-pos : ∀ x y → ∀ 0<x 0<y →
+                   (x <ᵣ y) ≃ (invℝ y (inl 0<y) <ᵣ invℝ x (inl 0<x))
+invℝ<invℝ-pos x y 0<x 0<y =
+ z<x≃y₊·z<y₊·x y x (invℝ y (inl 0<y) ·ᵣ invℝ x (inl 0<x) ,
+   ℝ₊· (invℝ y (inl 0<y) , invℝ-pos y 0<y)
+       (invℝ x (inl 0<x) , invℝ-pos x 0<x))
+  ∙ₑ substEquiv' (_<ᵣ (invℝ y (inl 0<y) ·ᵣ invℝ x (inl 0<x) ·ᵣ y))
+      (sym (·ᵣAssoc _ _ _) ∙∙
+       cong (invℝ y (inl 0<y) ·ᵣ_)
+        (·ᵣComm _ _ ∙ x·invℝ[x] _ _)
+        ∙∙ ·IdR _)
+  ∙ₑ substEquiv' (invℝ y (inl 0<y) <ᵣ_)
+    (cong (_·ᵣ y) (·ᵣComm _ _)
+     ∙ ((sym (·ᵣAssoc _ _ _) ∙∙
+       cong (invℝ x (inl 0<x) ·ᵣ_)
+        (·ᵣComm _ _ ∙ x·invℝ[x] _ _)
+        ∙∙ ·IdR _)))
+
+1<x/y : ∀ x y → (0 <ᵣ x) → (0<y : 0 <ᵣ y)  →
+  (y <ᵣ x) ≃ (1 <ᵣ (x ／ᵣ[ y , inl 0<y ]))
+1<x/y x y 0<x 0<y =
+  ((substEquiv' (_<ᵣ x) (sym (·IdR y))) ∙ₑ
+    substEquiv' (y ·ᵣ 1 <ᵣ_)
+     (sym ([x/y]·yᵣ _ _ (inl 0<y)) ∙ ·ᵣComm _ _ )
+    ∙ₑ invEquiv (z<x≃y₊·z<y₊·x (x ／ᵣ[ y , inl 0<y ]) 1 (y , 0<y)))
+
+x/y<1 : ∀ x y → (0 <ᵣ x) → (0<y : 0 <ᵣ y)  →
+  (x <ᵣ y) ≃ ((x ／ᵣ[ y , inl 0<y ]) <ᵣ 1)
+x/y<1 x y 0<x 0<y =
+  (((substEquiv' (x <ᵣ_) (sym (·IdR y))) ∙ₑ
+    substEquiv' (_<ᵣ (y ·ᵣ 1))
+     (sym ([x/y]·yᵣ _ _ (inl 0<y)) ∙ ·ᵣComm _ _ ))
+    ∙ₑ invEquiv (z<x≃y₊·z<y₊·x 1 (x ／ᵣ[ y , inl 0<y ]) (y , 0<y)))
+
+-- x/y≤z : ∀ x y z → (0 ≤ᵣ x) → (0<y : 0 <ᵣ y)  →
+--   (x ≤ᵣ z ·ᵣ y) ≃ ((x ／ᵣ[ y , inl 0<y ]) ≤ᵣ z)
+-- x/y≤z x y z 0≤x 0<y = {!!}
+--   -- (((substEquiv' (x <ᵣ_) (sym (·IdR y))) ∙ₑ
+--   --   substEquiv' (_<ᵣ (y ·ᵣ 1))
+--   --    (sym ([x/y]·yᵣ _ _ (inl 0<y)) ∙ ·ᵣComm _ _ ))
+--   --   ∙ₑ invEquiv (z<x≃y₊·z<y₊·x 1 (x ／ᵣ[ y , inl 0<y ]) (y , 0<y)))
+
+-- x≤z/y : ∀ x y z → (0 ≤ᵣ x) → (0<y : 0 <ᵣ y)  →
+--   (x ·ᵣ y ≤ᵣ z) ≃ (x ≤ᵣ (z  ／ᵣ[ y , inl 0<y ]))
+-- x≤z/y x y z 0≤x 0<y = {!!}
+--   -- (((substEquiv' (x <ᵣ_) (sym (·IdR y))) ∙ₑ
+--   --   substEquiv' (_<ᵣ (y ·ᵣ 1))
+--   --    (sym ([x/y]·yᵣ _ _ (inl 0<y)) ∙ ·ᵣComm _ _ ))
+--   --   ∙ₑ invEquiv (z<x≃y₊·z<y₊·x 1 (x ／ᵣ[ y , inl 0<y ]) (y , 0<y)))
+
+
+1＃x/y : ∀ x y → (0 <ᵣ x) → (0<y : 0 <ᵣ y)  →
+  (y ＃ x) ≃ 1 ＃ (x ／ᵣ[ y , inl 0<y ])
+1＃x/y x y 0<x 0<y =
+ ⊎.⊎-equiv
+  (1<x/y x y 0<x 0<y)
+  (x/y<1 x y 0<x 0<y)
+
+
+
+1<^ : ∀ x  → ∀ n → (1 <ᵣ x) → (1 <ᵣ (x ^ⁿ (suc n)))
+1<^ x zero = subst (1 <ᵣ_) (sym (·IdR _) ∙  ·ᵣComm _ _)
+1<^ x (suc n) 1<x =
+ isTrans≡<ᵣ _ _ _ (sym (·IdR _))
+   (<ᵣ₊Monotone·ᵣ _ _ _ _
+     decℚ≤ᵣ? decℚ≤ᵣ?  (1<^ x (n) 1<x) 1<x)
+
+^<1 : ∀ x → 0 ≤ᵣ x  → ∀ n → (x <ᵣ 1) → ((x ^ⁿ (suc n)) <ᵣ 1)
+^<1 x _ zero = subst (_<ᵣ 1) (sym (·IdR _) ∙  ·ᵣComm _ _)
+^<1 x 0≤x (suc n) x<1 =
+ isTrans<≡ᵣ _ _ _
+   (<ᵣ₊Monotone·ᵣ _ _ _ _
+     (0≤x^ⁿ _ _ 0≤x) 0≤x (^<1 x 0≤x n x<1) x<1)
+   (·IdR _)
+
+
+^≤1 : ∀ x → 0 ≤ᵣ x  → ∀ n → (x ≤ᵣ 1) → ((x ^ⁿ n) ≤ᵣ 1)
+^≤1 x _  zero _ = ≤ᵣ-refl 1
+^≤1 x 0≤x (suc n) x≤1 =
+ isTrans≤≡ᵣ _ _ _
+   (≤ᵣ₊Monotone·ᵣ _ _ _ _
+     decℚ≤ᵣ? 0≤x ((^≤1 _ 0≤x n x≤1)) x≤1)
+   (·IdR _)
+
+
+
+
+1＃^ : ∀ x → 0 ≤ᵣ x → ∀ n → (1 ＃ x) → (1 ＃ (x ^ⁿ (suc n)))
+1＃^ x 0≤x n = ⊎.map (1<^ x n) (^<1 x 0≤x n)
+
+-- bⁿ-aⁿ : ℝ → ℝ → ℕ → ℝ
+-- bⁿ-aⁿ a b n = (b -ᵣ a) ·ᵣ seqΣ (λ k → b ^ⁿ k ·ᵣ (a ^ⁿ (n ∸ suc k))) n
+
+
+^ⁿ-StrictMonotone : ∀ {x y : ℝ} (n : ℕ) → (0 ℕ.< n)
+ → 0 ≤ᵣ x → 0 ≤ᵣ y → x <ᵣ y → (x ^ⁿ n) <ᵣ (y ^ⁿ n)
+
+^ⁿ-StrictMonotone {x} {y} 0 0<n 0≤x 0≤y x<y = ⊥.rec (ℕ.¬-<-zero 0<n)
+^ⁿ-StrictMonotone {x} {y} 1 0<n 0≤x 0≤y x<y =
+  subst2 _<ᵣ_ (sym (·IdL _)) (sym (·IdL _)) x<y
+^ⁿ-StrictMonotone {x} {y} (suc (suc n)) 0<n 0≤x 0≤y x<y =
+  <ᵣ₊Monotone·ᵣ _ _ _ _
+    (0≤x^ⁿ _ _ 0≤x)
+    0≤x
+    ((^ⁿ-StrictMonotone (suc n) (ℕ.suc-≤-suc (ℕ.zero-≤ {n})) 0≤x 0≤y x<y))
+    x<y
+
+^ⁿ-Monotone : ∀ {x y : ℝ} (n : ℕ)
+ → 0 ≤ᵣ x → x ≤ᵣ y → (x ^ⁿ n) ≤ᵣ (y ^ⁿ n)
+^ⁿ-Monotone zero _ _ = ≤ᵣ-refl _
+^ⁿ-Monotone (suc n) 0≤x x≤y =
+   ≤ᵣ₊Monotone·ᵣ _ _ _ _
+    (0≤x^ⁿ _ n (isTrans≤ᵣ _ _ _ 0≤x x≤y)) 0≤x (^ⁿ-Monotone n 0≤x x≤y) x≤y
+
+
+
+ℚ^ⁿ-Monotone : ∀ {x y : ℚ} (n : ℕ) → 0 ℚ.≤ x → 0 ℚ.≤ y → x ℚ.≤ y
+ → (x ℚ^ⁿ n) ℚ.≤ (y ℚ^ⁿ n)
+ℚ^ⁿ-Monotone zero 0≤x 0≤y x≤y = ℚ.isRefl≤ 1
+ℚ^ⁿ-Monotone {x} {y} (suc n) 0≤x 0≤y x≤y =
+  ℚ.≤Monotone·-onNonNeg _ _ _ _
+    (ℚ^ⁿ-Monotone n 0≤x 0≤y x≤y)
+    x≤y
+    (ℚ.0≤ℚ^ⁿ x 0≤x n)
+    0≤x
+
+ℚ^ⁿ-StrictMonotone : ∀ {x y : ℚ} (n : ℕ) → (0 ℕ.< n) → 0 ℚ.≤ x → 0 ℚ.≤ y → x ℚ.< y → (x ℚ.ℚ^ⁿ n) ℚ.< (y ℚ.ℚ^ⁿ n)
+ℚ^ⁿ-StrictMonotone {x} {y} 0 0<n 0≤x 0≤y x<y = ⊥.rec (ℕ.¬-<-zero 0<n)
+ℚ^ⁿ-StrictMonotone {x} {y} 1 0<n 0≤x 0≤y x<y =
+  subst2 ℚ._<_ (sym (ℚ.·IdL _)) (sym (ℚ.·IdL _)) x<y
+ℚ^ⁿ-StrictMonotone {x} {y} (suc (suc n)) 0<n 0≤x 0≤y x<y =
+  ℚ.<Monotone·-onPos _ _ _ _
+    (ℚ^ⁿ-StrictMonotone (suc n) (ℕ.suc-≤-suc (ℕ.zero-≤ {n})) 0≤x 0≤y x<y)
+    x<y
+    (ℚ.0≤ℚ^ⁿ x 0≤x (suc n))
+    0≤x
+
+
+ℚ^ⁿ-Monotone⁻¹ : ∀ {x y : ℚ} (n : ℕ) → (0 ℕ.< n) → 0 ℚ.≤ x → 0 ℚ.≤ y
+ → (x ℚ^ⁿ n) ℚ.≤ (y ℚ^ⁿ n) → x ℚ.≤ y
+ℚ^ⁿ-Monotone⁻¹ n 0<n 0≤x 0≤y xⁿ≤yⁿ =
+ ℚ.≮→≥ _ _ (ℚ.≤→≯ _ _ xⁿ≤yⁿ ∘ ℚ^ⁿ-StrictMonotone n 0<n 0≤y 0≤x  )
+
+^ⁿ-StrictMonotoneR : ∀ {x : ℝ} (m n : ℕ)
+ → 1 <ᵣ x → m ℕ.< n → (x ^ⁿ m) <ᵣ (x ^ⁿ n)
+^ⁿ-StrictMonotoneR m zero x x₁ = ⊥.rec (ℕ.¬-<-zero x₁)
+^ⁿ-StrictMonotoneR {x} zero (suc n) 1<x m<n = 1<^ x n 1<x
+^ⁿ-StrictMonotoneR (suc m) (suc n) 1<x sm<sn =
+ <ᵣ-·ᵣo _ _ (_ , isTrans<ᵣ 0 1 _ (<ℚ→<ᵣ _ _ ℚ.decℚ<?) 1<x)
+  (^ⁿ-StrictMonotoneR m n 1<x (ℕ.predℕ-≤-predℕ sm<sn))
+
+IsContinuous^ⁿ : ∀ n → IsContinuous (_^ⁿ n)
+IsContinuous^ⁿ zero = IsContinuousConst _
+IsContinuous^ⁿ (suc n) = cont₂·ᵣ _ _ (IsContinuous^ⁿ n) IsContinuousId
+
+
+
+module bⁿ-aⁿ n'  where
+
+ n = suc (suc n')
+
+ nᵣ₊ : ℝ₊
+ nᵣ₊ = fromNat n
+
+
+ module factor a b (0<a : 0 <ᵣ a) (0<b : 0 <ᵣ b) where
+
+
+
+  0＃b : 0 ＃ b
+  0＃b = inl 0<b
+  r = (a ／ᵣ[ b , 0＃b ])
+
+  S = Sₙ (b ^ⁿ (suc n')) r n
+
+
+  0<r : 0 <ᵣ r
+  0<r = isTrans<≡ᵣ _ _ _
+   (  (fst (0<x≃0<y₊·x a (invℝ₊ (b , 0<b))) 0<a))
+      (·ᵣComm _ _ ∙
+        cong (a ·ᵣ_) (invℝ₊≡invℝ _ _ ))
+
+
+  0<S : 0 <ᵣ S
+  0<S = 0<seqΣ' (geometricProgression (b ^ⁿ (suc n')) r)
+        (λ n → subst (0 <ᵣ_)
+           (sym (geometricProgressionClosed (b ^ⁿ (suc n')) r n))
+            (ℝ₊· (_ , (0<x^ⁿ b (suc n') 0<b)) (_ , (0<x^ⁿ r n 0<r))))
+        (suc n')
+
+  S₊ : ℝ₊
+  S₊ = S , 0<S
+
+  0≤r : 0 ≤ᵣ r
+  0≤r = <ᵣWeaken≤ᵣ _ _ 0<r
+
+
+
+  [b-a]·S≡bⁿ-aⁿ : (b -ᵣ a) ·ᵣ Sₙ ((b ^ⁿ (suc n'))) r n ≡ (b ^ⁿ n) -ᵣ (a ^ⁿ n)
+  [b-a]·S≡bⁿ-aⁿ =
+     ·ᵣComm _ _ ∙ cong ((Sₙ ((b ^ⁿ (suc n'))) r n) ·ᵣ_)
+        (cong₂ _+ᵣ_ (sym (·IdL b)) (cong (-ᵣ_) (sym ([x/y]·yᵣ a b 0＃b))
+         ∙ sym (-ᵣ· _ _)) ∙ sym (·DistR+ _ _ _))
+       ∙ ·ᵣAssoc _ _ _ ∙ cong (_·ᵣ b) (SₙLem' (b ^ⁿ (suc n')) n r)
+        ∙  cong (_·ᵣ b) (·ᵣComm _ _)
+       ∙ sym (·ᵣAssoc _ _ _)
+       ∙ ·DistR+ _ _ _
+       ∙ cong₂ _+ᵣ_ (·IdL _)
+          (-ᵣ· _ _ ∙ cong (-ᵣ_)
+           (sym (x/y≡z→x≡z·y _ _ _ _ (／^ⁿ n _ _ _ (inl (0<x^ⁿ b n 0<b))))) )
+
+  module _ A B (0<A : 0 <ᵣ A) (A<b : A <ᵣ b)
+    (0<B : 0 <ᵣ B) (A<B : A <ᵣ B) (b≤B : b ≤ᵣ B) (a<b : a <ᵣ b) where
+
+   a＃b : a ＃ b
+   a＃b = inl a<b
+
+
+   p : 0 ＃ ((1 -ᵣ (r ^ⁿ n)) ·ᵣ b )
+   p = 0＃· _ _ (invEq (＃Δ _ _)
+     (isSym＃ _ _ (1＃^ _ (
+       <ᵣWeaken≤ᵣ _ _ (isTrans<≡ᵣ _ _ _
+        (fst (0<x≃0<y₊·x a (invℝ₊ (b , 0<b))) 0<a) (·ᵣComm _ _ ∙
+           cong (a ·ᵣ_) (invℝ₊≡invℝ _ _))))
+       _ ((fst (1＃x/y _ _ 0<a 0<b) (isSym＃ _ _ (a＃b))))))) 0＃b
+
+
+   r<1 : r <ᵣ 1
+   r<1 = fst (x/y<1 a b 0<a 0<b) a<b
+
+
+   S≤Bⁿ·n : S ≤ᵣ ((B ^ⁿ (suc n')) ·ᵣ (fromNat n))
+   S≤Bⁿ·n =
+       (isTrans≤≡ᵣ _ _ _ (Seq≤→Σ≤ (geometricProgression (b ^ⁿ (suc n')) r)
+      (const (B ^ⁿ (suc n')))
+       (λ m →
+         isTrans≡≤ᵣ _ _ _
+           (geometricProgressionClosed _ _ _)
+            (isTrans≤≡ᵣ _ _ _ (
+             isTrans≤ᵣ _ _ _
+              (≤ᵣ-·ᵣo _ _ _  (0≤x^ⁿ _ _ 0≤r) (
+                ^ⁿ-Monotone (suc n')
+                 (<ᵣWeaken≤ᵣ _ _ 0<b) b≤B))
+                 (≤ᵣ-o·ᵣ (r ^ⁿ m) 1 (B ^ⁿ (suc n'))
+                  (0≤x^ⁿ _ _ (<ᵣWeaken≤ᵣ _ _ 0<B))
+                    (^≤1 _ 0≤r m (<ᵣWeaken≤ᵣ _ _  r<1))))
+                (·IdR _)))
+       (suc (suc n')))
+       ((seqSumUpToConst (B ^ⁿ (suc n')) n)))
+
+
+
+   Aⁿ≤S : (A ^ⁿ suc n') ≤ᵣ S
+   Aⁿ≤S = <ᵣWeaken≤ᵣ _ _ $
+     isTrans<≤ᵣ _ _ _
+      (^ⁿ-StrictMonotone (suc n') (ℕ.suc-≤-suc (ℕ.zero-≤ {n'}))
+          (<ᵣWeaken≤ᵣ _ _ 0<A) (<ᵣWeaken≤ᵣ _ _ 0<b) A<b)
+           (isTrans≡≤ᵣ _ _ _  (sym (+IdR _)) (≤ᵣ-o+ 0 _ _
+                  (0≤seqΣ' (λ x → geometricProgression ((b ^ⁿ n') ·ᵣ b) r (suc x))
+                       (λ n → isTrans≤≡ᵣ _ _ _
+                          (<ᵣWeaken≤ᵣ _ _ (ℝ₊· (_ , 0<x^ⁿ _ _ 0<b)
+                               (_ , 0<x^ⁿ _ _ 0<r)))
+                           ((sym (geometricProgressionClosed
+                           ((b ^ⁿ n') ·ᵣ b) r (suc n)))))
+                        (suc n'))))
+ open factor public
+
+
+^ⁿMonotone⁻¹ : ∀ {x y : ℝ} (n : ℕ) → (0 ℕ.< n) → 0 <ᵣ x → 0 <ᵣ y
+ → (x ^ⁿ n) ≤ᵣ (y ^ⁿ n) → x ≤ᵣ y
+^ⁿMonotone⁻¹ zero 0<n 0≤x 0≤y xⁿ≤yⁿ = ⊥.rec (ℕ.¬-<-zero 0<n)
+^ⁿMonotone⁻¹ (suc zero) 0<n 0≤x 0≤y xⁿ≤yⁿ =
+  subst2 _≤ᵣ_ (·IdL _) (·IdL _) xⁿ≤yⁿ
+^ⁿMonotone⁻¹ {x} {y} (suc (suc n)) 0<n 0<x 0<y xⁿ<yⁿ =
+ let z = isTrans≤≡ᵣ _ _ _ (x≤y→0≤y-x _ _ xⁿ<yⁿ)
+          (sym $ bⁿ-aⁿ.[b-a]·S≡bⁿ-aⁿ n x y 0<x 0<y)
+ in invEq (x≤y≃0≤y-x x y)
+      ((invEq (z≤x≃y₊·z≤y₊·x (y -ᵣ x) 0
+          ((bⁿ-aⁿ.S n x y 0<x 0<y ,
+                  bⁿ-aⁿ.0<S n x y 0<x 0<y)))
+         (subst2 _≤ᵣ_
+           (sym (𝐑'.0RightAnnihilates (bⁿ-aⁿ.S n x y 0<x 0<y)))
+            (·ᵣComm (y -ᵣ x) _) z)))
+
+
+^ⁿStrictMonotone⁻¹ : ∀ {x y : ℝ} (n : ℕ) → (0 ℕ.< n) → 0 <ᵣ x → 0 <ᵣ y
+ → (x ^ⁿ n) <ᵣ (y ^ⁿ n) → x <ᵣ y
+^ⁿStrictMonotone⁻¹ zero 0<n 0≤x 0≤y xⁿ<yⁿ = ⊥.rec (ℕ.¬-<-zero 0<n)
+^ⁿStrictMonotone⁻¹ (suc zero) 0<n 0≤x 0≤y xⁿ<yⁿ =
+  subst2 _<ᵣ_ (·IdL _) (·IdL _) xⁿ<yⁿ
+^ⁿStrictMonotone⁻¹ {x} {y} (suc (suc n)) 0<n 0<x 0<y xⁿ<yⁿ =
+ let z = isTrans<≡ᵣ _ _ _ (x<y→0<y-x _ _ xⁿ<yⁿ)
+          (sym $ bⁿ-aⁿ.[b-a]·S≡bⁿ-aⁿ n x y 0<x 0<y)
+ in 0<y-x→x<y _ _
+      (invEq (z<x≃y₊·z<y₊·x (y -ᵣ x) 0
+          ((bⁿ-aⁿ.S n x y 0<x 0<y ,
+                  bⁿ-aⁿ.0<S n x y 0<x 0<y)))
+         (subst2 _<ᵣ_
+           (sym (𝐑'.0RightAnnihilates (bⁿ-aⁿ.S n x y 0<x 0<y)))
+            (·ᵣComm (y -ᵣ x) _) z))
+
+
+_~seq_ : Seq → Seq → Type
+s ~seq s' = ∀ (ε : ℚ₊) → Σ[ N ∈ ℕ ] (∀ m n → N ℕ.< n → N ℕ.< m →
+   absᵣ ((s n) +ᵣ (-ᵣ (s' m))) <ᵣ rat (fst ε)   )
+
 
 IsCauchySequence : Seq → Type
 IsCauchySequence s =
   ∀ (ε : ℝ₊) → Σ[ N ∈ ℕ ] (∀ m n → N ℕ.< n → N ℕ.< m →
-    absᵣ ((s n) +ᵣ (-ᵣ (s m))) <ᵣ fst ε   )
+    absᵣ ((s n) +ᵣ (-ᵣ (s m))) <ᵣ fst ε)
+
 
 IsCauchySequence' : Seq → Type
 IsCauchySequence' s =
@@ -451,6 +859,27 @@ IsCauchySequence' s =
     absᵣ ((s n) +ᵣ (-ᵣ (s m))) <ᵣ rat (fst ε)   )
 
 
+IsCauchySequence'-via-~seq : ∀ s s' → s ~seq s' → IsCauchySequence' s → IsCauchySequence' s'
+IsCauchySequence'-via-~seq s s' s~s' icS ε =
+  let (N , X) = icS (/2₊ ε)
+      (M , Y) = s~s' (/2₊ ε)
+  in M , (λ m n <m <n →
+     let zz = Y m n <m <n
+         yy = Y n n <m <m
+         uu = isTrans≡<ᵣ _ _ _ (cong absᵣ (sym L𝐑.lem--060))
+                (isTrans≤<ᵣ _ _ _
+                 (absᵣ-triangle _ _)
+                  (<ᵣMonotone+ᵣ _ _ _ _ (isTrans≡<ᵣ _ _ _ (minusComm-absᵣ _ _) yy) zz))
+      in isTrans<≡ᵣ _ _ _ uu (+ᵣ-rat _ _ ∙ cong rat (ℚ.ε/2+ε/2≡ε _)))
+
+
+
+IsCauchySequence'ℚ : (ℕ → ℚ) → Type
+IsCauchySequence'ℚ s =
+  ∀ (ε : ℚ₊) → Σ[ N ∈ ℕ ] (∀ m n → N ℕ.< n → N ℕ.< m →
+    ℚ.abs ((s n) ℚ.- (s m)) ℚ.< (fst ε)   )
+
+
 IsConvSeries : Seq → Type
 IsConvSeries s =
     ∀ (ε : ℝ₊) →
@@ -469,8 +898,8 @@ IsoIsConvSeriesIsCauchySequenceSum : (s : Seq) →
 IsoIsConvSeriesIsCauchySequenceSum s =
    codomainIsoDep λ ε →
      Σ-cong-iso-snd λ N →
-        isProp→Iso (isPropΠ2 λ _ _ → squash₁)
-         (isPropΠ4 λ _ _ _ _ → squash₁ )
+        isProp→Iso (isPropΠ2 λ _ _ → isProp<ᵣ _ _)
+         (isPropΠ4 λ _ _ _ _ → isProp<ᵣ _ _ )
          (λ f → ℕ.elimBy≤
            (λ n n' X <n <n' → subst (_<ᵣ fst ε)
              (minusComm-absᵣ _ _) (X <n' <n))
@@ -502,8 +931,8 @@ IsoIsConvSeries'IsCauchySequenceSum' : (s : Seq) →
 IsoIsConvSeries'IsCauchySequenceSum' s =
  codomainIsoDep λ ε →
      Σ-cong-iso-snd λ N →
-        isProp→Iso (isPropΠ2 λ _ _ → squash₁)
-         (isPropΠ4 λ _ _ _ _ → squash₁ )
+        isProp→Iso (isPropΠ2 λ _ _ → isProp<ᵣ _ _)
+         (isPropΠ4 λ _ _ _ _ → isProp<ᵣ _ _)
 
          (λ f → ℕ.elimBy≤
            (λ n n' X <n <n' → subst (_<ᵣ rat (fst ε))
@@ -574,18 +1003,17 @@ fromCauchySequence s ics =
 
 -- 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<ε _ _ _)
+fromCauchySequence'-isCA : ∀ s → (ics : IsCauchySequence' s) →
+      (δ ε : ℚ₊) → s (suc (fst (ics δ)))  ∼[ δ ℚ₊+ ε ]
+                    s (suc (fst (ics ε)))
+fromCauchySequence'-isCA s ics δ ε = invEq (∼≃abs<ε _ _ _)
     (ww (ℕ.Dichotomyℕ δₙ εₙ) )
   where
+
+  x : ℚ₊ → ℝ
+  x q = s (suc (fst (ics q)))
+
   δₙ = fst (ics δ)
   εₙ = fst (ics ε)
 
@@ -606,6 +1034,58 @@ fromCauchySequence' s ics =
                (ℚ.<+ℚ₊' (fst ε) (fst ε) δ (ℚ.isRefl≤ (fst ε))))))
 
 
+fromCauchySequence' : ∀ s → IsCauchySequence' s → ℝ
+fromCauchySequence' s ics =
+  lim _ (fromCauchySequence'-isCA s ics)
+
+open ℚ.HLP
+
+
+fromCauchySequence'-≡-lem : ∀ s ics ics'
+        →  fromCauchySequence' s ics ≡ fromCauchySequence' s ics'
+fromCauchySequence'-≡-lem s ics ics' =
+  eqℝ _ _
+    λ ε →
+      let (n , N) = ics (/4₊ ε)
+          (m , M) = ics' (/4₊ ε)
+          n⊔m = ℕ.max (suc n) (suc m)
+       in lim-lim _ _ _ (/4₊ ε) (/4₊ ε) _ _
+           (distℚ0<! ε (
+               ge1 +ge (neg-ge ((ge[ ℚ.[ 1 / 4 ] ] +ge ge[ ℚ.[ 1 / 4 ] ]))) ))
+           (subst∼ distℚ! (fst ε) ·[ (ge[ ℚ.[ 1 / 4 ] ] +ge ge[ ℚ.[ 1 / 4 ] ]) ≡
+               ge1 +ge (neg-ge ((ge[ ℚ.[ 1 / 4 ] ] +ge ge[ ℚ.[ 1 / 4 ] ]))) ]
+          (triangle∼
+            (invEq (∼≃abs<ε _ _ (/4₊ ε)) (N n⊔m (suc n) ℕ.≤-refl ℕ.left-≤-max))
+            (invEq (∼≃abs<ε _ _ (/4₊ ε)) (M (suc m) n⊔m ℕ.right-≤-max ℕ.≤-refl))))
+
+fromCauchySequence'≡ : ∀ s ics x
+         → ((∀ (ε : ℚ₊) →
+             ∃[ N ∈ ℕ ] (∀ n → N ℕ.< n →
+                  absᵣ ((s n) -ᵣ x) <ᵣ rat (fst ε))))
+         → fromCauchySequence' s ics ≡ x
+fromCauchySequence'≡ s ics x p =
+   eqℝ _ _
+  λ ε → PT.rec (isProp∼ _ _ _)
+    (λ (N , X) →
+     let z = ℕ.max (suc N) (suc (fst (ics (/4₊ ε))))
+         uu = invEq (∼≃abs<ε _ _ ((/4₊ ε))) ((X z ℕ.left-≤-max))
+         uuu = triangle∼ (sym∼ _ _ _
+          (𝕣-lim-self _ (fromCauchySequence'-isCA s ics) (/4₊ ε) (/4₊ ε)))
+            (triangle∼
+          (invEq (∼≃abs<ε _ _ (/4₊ ε))
+            ((snd (ics (/4₊ ε))
+              z ((suc (fst (ics (/4₊ ε))))) ℕ.≤-refl
+               ℕ.right-≤-max))) uu)
+     in subst∼ (cong₂ ℚ._+_ (cong fst (ℚ./4₊+/4₊≡/2₊ ε))
+        ((cong fst (ℚ./4₊+/4₊≡/2₊ ε))) ∙ ℚ.ε/2+ε/2≡ε _) uuu)
+    (p (/4₊ ε))
+
+
+-- fromCauchySequence'≤ : ∀ s ics → (∀ n m → n ℕ.≤ m → s m ≤ᵣ s n)
+--     → ∀ n → fromCauchySequence' s ics ≤ᵣ s n
+-- fromCauchySequence'≤ s ics decr n =
+--   {!!}
+
 limₙ→∞_is_ : Seq → ℝ → Type
 limₙ→∞ s is x =
   ∀ (ε : ℝ₊) → Σ[ N ∈ ℕ ]
@@ -619,19 +1099,31 @@ lim'ₙ→∞ s is x =
       absᵣ ((s n) +ᵣ (-ᵣ x)) <ᵣ (rat (fst ε)))
 
 
+fromCauchySequence'-lim : ∀ s ics → lim'ₙ→∞ s is (fromCauchySequence' s ics)
+fromCauchySequence'-lim s ics ε =
+ let (N , X) = ics (/4₊ ε)
+ in N , λ n N<n →
+      let u = (𝕣-lim-self _ (fromCauchySequence'-isCA s ics) (/4₊ ε) (/4₊ ε))
+          u' = fst (∼≃abs<ε _ _ _)
+               (triangle∼ (invEq (∼≃abs<ε _ _ (/4₊ ε)) ((X  _ _  N<n (ℕ.≤-refl {suc N})) )) u)
+       in isTrans<ᵣ _ _ _ u'
+            (<ℚ→<ᵣ _ _
+              distℚ<! ε [ ge[ ℚ.[ 1 / 4 ] ]
+                            +ge  (ge[ ℚ.[ 1 / 4 ] ] +ge ge[ ℚ.[ 1 / 4 ] ]) < ge1 ])
+
 
 Limₙ→∞ : Seq → Type
 Limₙ→∞ s = Σ _ (limₙ→∞ s is_)
 
 
 ε<2ⁿ : (ε : ℚ₊) → Σ[ n ∈ ℕ ] fst ε ℚ.< 2 ℚ^ⁿ n
-ε<2ⁿ ε = let n = fst (log2ℕ (fst (ℚ.ceilℚ₊ ε))) in n ,
+ε<2ⁿ ε = let n = fst (log2ℕ (ℕ₊₁→ℕ  (fst (ℚ.ceilℚ₊ ε)))) in n ,
          subst (fst ε ℚ.<_) (sym (ℚ.fromNat-^ _ _))
           (ℚ.isTrans< _ _ (fromNat (2 ^ n))
                   ((snd (ℚ.ceilℚ₊ ε)))
-                   (ℚ.<ℤ→<ℚ (ℤ.pos ((fst (ℚ.ceilℚ₊ ε))))
+                   (ℚ.<ℤ→<ℚ (ℤ.pos (ℕ₊₁→ℕ (fst (ℚ.ceilℚ₊ ε))))
                      _ (ℤ.ℕ≤→pos-≤-pos  _ _
-                    (fst (snd (log2ℕ (fst (ℚ.ceilℚ₊ ε))))))))
+                    (fst (snd (log2ℕ (ℕ₊₁→ℕ (fst (ℚ.ceilℚ₊ ε)))))))))
 
 
 1/2ⁿ<ε : (ε : ℚ₊) → Σ[ n ∈ ℕ ] [ 1 / 2 ] ℚ^ⁿ n ℚ.< fst ε
@@ -643,6 +1135,7 @@ Limₙ→∞ s = Σ _ (limₙ→∞ s is_)
 
 
 
+
 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
@@ -652,88 +1145,90 @@ ratio→seqLimit s sRat sPos l (ε , 0<ε) =
     (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))
+ opaque
+  unfolding -ᵣ_
+  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
@@ -762,81 +1257,85 @@ ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) =
      (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 _)))
-
-                        ))))
+  opaque
+   unfolding -ᵣ_ _+ᵣ_
+
+   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' : ∀ n → seqSumUpTo' s' n ≤ᵣ seqSumUpTo' (geometricProgression (s (m ℕ.+ N)) (fst ½ᵣ)) 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
@@ -856,7 +1355,7 @@ 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'
+  in (e ℚ.+ e') , cong₂ _+ᵣ_ p p' ∙ +ᵣ-rat _ _
 
 expSeqPos : ∀ x → 0 <ᵣ x → ∀ n → 0 <ᵣ expSeq x n
 expSeqPos x 0<x zero = decℚ<ᵣ?
@@ -870,77 +1369,81 @@ limₙ→∞[expSeqRatio]=0 : ∀ x → ∀ (0<x : 0 ℚ.< x)  → lim'ₙ→∞
       is 0
 limₙ→∞[expSeqRatio]=0 x 0<x =
   subst (lim'ₙ→∞_is 0)
-    (funExt (w (rat x) _))
+    (funExt (w (rat x) (<ℚ→<ᵣ 0 x 0<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')))
+ opaque
+  unfolding -ᵣ_
+
+  x₊ : ℚ₊
+  x₊ = x , ℚ.<→0< _ 0<x
+
+  0<ᵣx : 0 <ᵣ rat 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'ₙ→∞ (λ n → (rat x ·ᵣ rat ([ 1 / 1+ n ]))) 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
diff --git a/Cubical/HITs/James/Stable.agda b/Cubical/HITs/James/Stable.agda
new file mode 100644
index 0000000000..b58022f227
--- /dev/null
+++ b/Cubical/HITs/James/Stable.agda
@@ -0,0 +1,87 @@
+{-# OPTIONS --safe #-}
+
+{-
+  The stable version of the James splitting:
+    ΣΩΣX ≃ ΣX ⋁ Σ(X ⋀ ΩΣX)
+-}
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Pointed
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+
+open import Cubical.Data.Sigma
+open import Cubical.Data.Unit
+
+open import Cubical.HITs.Susp
+open import Cubical.HITs.Susp.SuspProduct
+open import Cubical.HITs.Pushout
+open import Cubical.HITs.Pushout.Flattening
+open import Cubical.HITs.Wedge
+open import Cubical.HITs.SmashProduct
+
+open import Cubical.Homotopy.Loopspace
+
+module Cubical.HITs.James.Stable {ℓ} (X∙@(X , x₀) : Pointed ℓ) where
+
+module ContrPushout where
+  Code : Pushout (terminal X) (terminal X) → Type ℓ
+  Code x = inl _ ≡ x
+
+  ΩΣX = Code (inl _)
+  ΩΣX∙ : Pointed _
+  ΩΣX∙ = ΩΣX , refl
+
+  α : X × ΩΣX → ΩΣX
+  α (x , p) = (p ∙ push x) ∙ sym (push x₀)
+
+  open FlatteningLemma
+    (terminal X) (terminal X)
+    (Code ∘ inl) (Code ∘ inr)
+    (pathToEquiv ∘ cong (inl tt ≡_) ∘ push)
+
+  pushoutEq : Pushout Σf Σg ≃ Pushout snd α
+  pushoutEq = pushoutEquiv _ _ _ _
+    (idEquiv (X × ΩΣX)) (ΣUnit _)
+    (ΣUnit _ ∙ₑ compPathrEquiv (sym (push x₀)))
+    refl (funExt λ (x , p)
+      → cong (_∙ sym (push x₀)) (substInPathsL (push x) p))
+
+  Code≡E : ∀ x → Code x ≡ E x
+  Code≡E (inl _) = refl
+  Code≡E (inr _) = refl
+  Code≡E (push a i) j = uaη (cong Code (push a)) (~ j) i
+
+  isContrΣE : isContr (Σ _ E)
+  isContrΣE = subst isContr (Σ-cong-snd Code≡E) (isContrSingl (inl tt))
+
+  isContrPushout : isContr (Pushout snd α)
+  isContrPushout = isOfHLevelRespectEquiv _ (flatten ∙ₑ pushoutEq) isContrΣE
+
+open ContrPushout
+
+LoopSuspSquare : commSquare
+LoopSuspSquare = record
+  { sp = 3span snd α
+  ; P = Unit* {ℓ}
+  ; comm = refl }
+
+LoopSuspPushoutSquare : PushoutSquare
+LoopSuspPushoutSquare = (LoopSuspSquare , isContr→≃Unit* isContrPushout .snd)
+
+open PushoutPasteLeft LoopSuspPushoutSquare
+  (λ _ → lift {j = ℓ} tt) _ _ (funExt merid)
+
+cofib-snd-James : cofib (λ (r : X × ΩΣX) → snd r) ≃ Susp ΩΣX
+cofib-snd-James = pushoutSwitchEquiv
+  ∙ₑ pushoutEquiv snd _ snd _
+    (idEquiv _) (idEquiv _) Unit≃Unit* refl refl
+  ∙ₑ (_ , isPushoutRightSquare→isPushoutTotSquare
+    (SuspPushoutSquare _ _ ΩΣX))
+
+StableJames : Susp ΩΣX ≃ Susp∙ X ⋁ Susp∙ (X∙ ⋀ ΩΣX∙)
+StableJames = invEquiv cofib-snd-James ∙ₑ cofib-snd X∙ (ΩΣX , refl)
diff --git a/Cubical/HITs/Join/Properties.agda b/Cubical/HITs/Join/Properties.agda
index ae82d7800d..c2a9c1bcb3 100644
--- a/Cubical/HITs/Join/Properties.agda
+++ b/Cubical/HITs/Join/Properties.agda
@@ -36,6 +36,15 @@ private
   variable
     ℓ ℓ' : Level
 
+-- the inclusion maps are null-homotopic
+join-inl-null : {X : Pointed ℓ} {Y : Pointed ℓ'} (x : typ X)
+  → Path (join (typ X) (typ Y)) (inl x) (inl (pt X))
+join-inl-null {X = X} {Y} x = push x (pt Y) ∙ sym (push (pt X) (pt Y))
+
+join-inr-null : {X : Pointed ℓ} {Y : Type ℓ'} (y : Y)
+  → Path (join (typ X) Y) (inr y) (inl (pt X))
+join-inr-null {X = X} y = sym (push (pt X) y)
+
 open Iso
 
 -- Characterisation of function type join A B → C
diff --git a/Cubical/HITs/Pushout/Properties.agda b/Cubical/HITs/Pushout/Properties.agda
index e8fa8c5cd4..56da6d606c 100644
--- a/Cubical/HITs/Pushout/Properties.agda
+++ b/Cubical/HITs/Pushout/Properties.agda
@@ -75,6 +75,28 @@ pushoutSwitchEquiv = isoToEquiv (iso f inv leftInv rightInv)
         leftInv = λ {(inl x) → refl; (inr x) → refl; (push a i) → refl}
         rightInv = λ {(inl x) → refl; (inr x) → refl; (push a i) → refl}
 
+
+{-
+  Direct proof that pushout along the identity gives an equivalence.
+-}
+pushoutIdfunEquiv : ∀ {ℓ ℓ'} {X : Type ℓ} {Y : Type ℓ'} (f : X → Y)
+  → Y ≃ Pushout f (idfun X)
+pushoutIdfunEquiv f = isoToEquiv (iso inl inv leftInv λ _ → refl)
+  where
+    inv : Pushout f (idfun _) → _
+    inv (inl y) = y
+    inv (inr x) = f x
+    inv (push x i) = f x
+
+    leftInv : section inl inv
+    leftInv (inl y) = refl
+    leftInv (inr x) = push x
+    leftInv (push a i) j = push a (i ∧ j)
+
+pushoutIdfunEquiv' : ∀ {ℓ ℓ'} {X : Type ℓ} {Y : Type ℓ'} (f : X → Y)
+  → Y ≃ Pushout (idfun X) f
+pushoutIdfunEquiv' f = compEquiv (pushoutIdfunEquiv _) pushoutSwitchEquiv
+
 {-
   Definition of pushout diagrams
 -}
@@ -809,6 +831,48 @@ module _ {ℓ₀ ℓ₂ ℓ₄ ℓP : Level} where
   PushoutSquare : Type (ℓ-suc ℓ*)
   PushoutSquare = Σ commSquare isPushoutSquare
 
+module _ {ℓ₀ ℓ₂ ℓ₄ ℓP ℓP' : Level}
+  {P' : Type ℓP'} where
+  open commSquare
+  extendCommSquare : (sk : commSquare {ℓ₀} {ℓ₂} {ℓ₄} {ℓP})
+    → (sk .P → P') → commSquare
+  extendCommSquare sk f .sp = sk .sp
+  extendCommSquare sk f .P = P'
+  extendCommSquare sk f .inlP = f ∘ sk .inlP
+  extendCommSquare sk f .inrP = f ∘ sk .inrP
+  extendCommSquare sk f .comm = cong (f ∘_) (sk .comm)
+
+
+  extendPushoutSquare : (sk : PushoutSquare {ℓ₀} {ℓ₂} {ℓ₄} {ℓP})
+    → (e : sk .fst .P ≃ P') → PushoutSquare
+  extendPushoutSquare sk e = (extendCommSquare (sk .fst) (e .fst) ,
+    subst isEquiv H (compEquiv (_ , sk .snd) e .snd))
+    where
+      H : e .fst ∘ _ ≡ _
+      H = funExt λ
+        { (inl x) → refl
+        ; (inr x) → refl
+        ; (push a i) → refl }
+
+-- Pushout itself fits into a pushout square
+pushoutToSquare : 3-span {ℓ} {ℓ'} {ℓ''} → PushoutSquare
+pushoutToSquare spn .fst = cSq
+  where
+  open commSquare
+  cSq : commSquare
+  cSq .sp = spn
+  cSq .P = spanPushout spn
+  cSq .inlP = inl
+  cSq .inrP = inr
+  cSq .comm = funExt push
+pushoutToSquare sp .snd =
+  subst isEquiv (funExt H) (idIsEquiv _)
+  where
+  H : ∀ p → p ≡ Pushout→commSquare _ p
+  H (inl x) = refl
+  H (inr x) = refl
+  H (push a i) = refl
+
 -- Rotations of commutative squares and pushout squares
 module _ {ℓ₀ ℓ₂ ℓ₄ ℓP : Level} where
   open commSquare
diff --git a/Cubical/HITs/SetTruncation/Properties.agda b/Cubical/HITs/SetTruncation/Properties.agda
index bc42ebb1d1..8131825882 100644
--- a/Cubical/HITs/SetTruncation/Properties.agda
+++ b/Cubical/HITs/SetTruncation/Properties.agda
@@ -260,22 +260,6 @@ Iso.leftInv (setTruncIso is) =
   elim (λ _ → isOfHLevelPath 2 isSetSetTrunc _ _)
         λ a → cong ∣_∣₂ (Iso.leftInv is a)
 
-setSigmaIso : {B : A → Type ℓ} → Iso ∥ Σ A B ∥₂ ∥ Σ A (λ x → ∥ B x ∥₂) ∥₂
-setSigmaIso {A = A} {B = B} = iso fun funinv sect retr
-  where
-  {- writing it out explicitly to avoid yellow highlighting -}
-  fun : ∥ Σ A B ∥₂ → ∥ Σ A (λ x → ∥ B x ∥₂) ∥₂
-  fun = rec isSetSetTrunc λ {(a , p) → ∣ a , ∣ p ∣₂ ∣₂}
-  funinv : ∥ Σ A (λ x → ∥ B x ∥₂) ∥₂ → ∥ Σ A B ∥₂
-  funinv = rec isSetSetTrunc (λ {(a , p) → rec isSetSetTrunc (λ p → ∣ a , p ∣₂) p})
-  sect : section fun funinv
-  sect = elim (λ _ → isOfHLevelPath 2 isSetSetTrunc _ _)
-              λ { (a , p) → elim {B = λ p → fun (funinv ∣ a , p ∣₂) ≡ ∣ a , p ∣₂}
-              (λ p → isOfHLevelPath 2 isSetSetTrunc _ _) (λ _ → refl) p }
-  retr : retract fun funinv
-  retr = elim (λ _ → isOfHLevelPath 2 isSetSetTrunc _ _)
-              λ { _ → refl }
-
 sigmaElim : {B : ∥ A ∥₂ → Type ℓ} {C : Σ ∥ A ∥₂ B  → Type ℓ'}
             (Bset : (x : Σ ∥ A ∥₂ B) → isSet (C x))
             (g : (a : A) (b : B ∣ a ∣₂) → C (∣ a ∣₂ , b))
@@ -311,7 +295,7 @@ prodElim2 isset f = prodElim (λ _ → isSetΠ λ _ → isset _ _)
                                      λ c d → f a b c d
 
 setTruncOfProdIso :  Iso ∥ A × B ∥₂ (∥ A ∥₂ × ∥ B ∥₂)
-Iso.fun setTruncOfProdIso = rec (isSet× isSetSetTrunc isSetSetTrunc) λ { (a , b) → ∣ a ∣₂ , ∣ b ∣₂ }
+Iso.fun setTruncOfProdIso = rec (isSet× isSetSetTrunc isSetSetTrunc) λ (a , b) → ∣ a ∣₂ , ∣ b ∣₂
 Iso.inv setTruncOfProdIso = prodRec isSetSetTrunc λ a b → ∣ a , b ∣₂
 Iso.rightInv setTruncOfProdIso =
   prodElim (λ _ → isOfHLevelPath 2 (isSet× isSetSetTrunc isSetSetTrunc) _ _) λ _ _ → refl
@@ -319,15 +303,14 @@ Iso.leftInv setTruncOfProdIso =
   elim (λ _ → isOfHLevelPath 2 isSetSetTrunc _ _) λ {(a , b) → refl}
 
 IsoSetTruncateSndΣ : {A : Type ℓ} {B : A → Type ℓ'} → Iso ∥ Σ A B ∥₂ ∥ Σ A (λ x → ∥ B x ∥₂) ∥₂
-Iso.fun IsoSetTruncateSndΣ = map λ a → (fst a) , ∣ snd a ∣₂
-Iso.inv IsoSetTruncateSndΣ = rec isSetSetTrunc (uncurry λ x → map λ b → x , b)
-Iso.rightInv IsoSetTruncateSndΣ =
-  elim (λ _ → isOfHLevelPath 2 isSetSetTrunc _ _)
-        (uncurry λ a → elim (λ _ → isOfHLevelPath 2 isSetSetTrunc _ _)
-        λ _ → refl)
-Iso.leftInv IsoSetTruncateSndΣ =
-  elim (λ _ → isOfHLevelPath 2 isSetSetTrunc _ _)
-         λ _ → refl
+Iso.fun IsoSetTruncateSndΣ = map λ (a , b) → a , ∣ b ∣₂
+Iso.inv IsoSetTruncateSndΣ = rec isSetSetTrunc (uncurry λ a → map λ b → a , b)
+Iso.rightInv IsoSetTruncateSndΣ = elim (λ _ → isSetPathImplicit) (uncurry λ _ → elim (λ _ → isSetPathImplicit) λ _ → refl)
+Iso.leftInv IsoSetTruncateSndΣ = elim (λ _ → isSetPathImplicit) λ _ → refl
+
+-- Deprecated. Use `IsoSetTruncateSndΣ` instead.
+setSigmaIso : {B : A → Type ℓ} → Iso ∥ Σ A B ∥₂ ∥ Σ A (λ x → ∥ B x ∥₂) ∥₂
+setSigmaIso = IsoSetTruncateSndΣ
 
 PathIdTrunc₀Iso : {a b : A} → Iso (∣ a ∣₂ ≡ ∣ b ∣₂) ∥ a ≡ b ∥₁
 Iso.fun (PathIdTrunc₀Iso {b = b}) p =
diff --git a/Cubical/HITs/SmashProduct/Base.agda b/Cubical/HITs/SmashProduct/Base.agda
index 2c591a2797..0a5cfe16e4 100644
--- a/Cubical/HITs/SmashProduct/Base.agda
+++ b/Cubical/HITs/SmashProduct/Base.agda
@@ -67,13 +67,8 @@ commK (gluer b x) = refl
 
 --- Alternative definition
 
-i∧ : {A : Pointed ℓ} {B : Pointed ℓ'} → A ⋁ B → (typ A) × (typ B)
-i∧ {A = A , ptA} {B = B , ptB} (inl x) = x , ptB
-i∧ {A = A , ptA} {B = B , ptB} (inr x) = ptA , x
-i∧ {A = A , ptA} {B = B , ptB} (push tt i) = ptA , ptB
-
 _⋀_ : Pointed ℓ → Pointed ℓ' → Type (ℓ-max ℓ ℓ')
-A ⋀ B = Pushout {A = (A ⋁ B)} (λ _ → tt) i∧
+A ⋀ B = Pushout {A = (A ⋁ B)} (λ _ → tt) ⋁↪
 
 _⋀∙_ : Pointed ℓ → Pointed ℓ' → Pointed (ℓ-max ℓ ℓ')
 A ⋀∙ B = (A ⋀ B) , (inl tt)
diff --git a/Cubical/HITs/Susp/Properties.agda b/Cubical/HITs/Susp/Properties.agda
index 98f7c2a2ab..1b226b0f4a 100644
--- a/Cubical/HITs/Susp/Properties.agda
+++ b/Cubical/HITs/Susp/Properties.agda
@@ -10,12 +10,15 @@ open import Cubical.Foundations.Pointed
 open import Cubical.Foundations.Pointed.Homogeneous
 open import Cubical.Foundations.GroupoidLaws
 open import Cubical.Foundations.Function
+open import Cubical.Foundations.Univalence
 
 open import Cubical.Data.Bool
 open import Cubical.Data.Sigma
+open import Cubical.Data.Unit
 
 open import Cubical.HITs.Join
 open import Cubical.HITs.Susp.Base
+open import Cubical.HITs.Pushout
 open import Cubical.Homotopy.Loopspace
 
 private
@@ -73,6 +76,47 @@ Susp≃joinBool = isoToEquiv Susp-iso-joinBool
 Susp≡joinBool : ∀ {ℓ} {A : Type ℓ} → Susp A ≡ join A Bool
 Susp≡joinBool = isoToPath Susp-iso-joinBool
 
+-- Here Unit* types are more convenient for general A
+SuspSpan : ∀ {ℓ} ℓ' ℓ'' (A : Type ℓ) → 3-span {ℓ'} {ℓ} {ℓ''}
+SuspSpan ℓ' ℓ'' A = record { A2 = A ; A0 = Unit* {ℓ'} ; A4 = Unit* {ℓ''} }
+
+SuspSquare : ∀ {ℓ} ℓ' ℓ'' (A : Type ℓ) → commSquare {ℓ'} {ℓ} {ℓ''}
+SuspSquare ℓ' ℓ'' A = cSq
+  where
+  open commSquare
+  cSq : commSquare
+  cSq .sp = SuspSpan ℓ' ℓ'' A
+  cSq .P = Susp A
+  cSq .inlP _ = north
+  cSq .inrP _ = south
+  cSq .comm = funExt merid
+
+SuspPushoutSquare : ∀ {ℓ} ℓ' ℓ'' (A : Type ℓ)
+  → isPushoutSquare (SuspSquare ℓ' ℓ'' A)
+SuspPushoutSquare ℓ' ℓ'' A = isoToIsEquiv (iso _ inverse rInv lInv)
+  where
+    inverse : _
+    inverse north = inl _
+    inverse south = inr _
+    inverse (merid a i) = push a i
+
+    rInv : _
+    rInv north = refl
+    rInv south = refl
+    rInv (merid a i) = refl
+
+    lInv : _
+    lInv (inl x) = refl
+    lInv (inr x) = refl
+    lInv (push a i) = refl
+
+Susp≃PushoutSusp* : ∀ {ℓ ℓ' ℓ''} {A : Type ℓ} → Susp A ≃ spanPushout (SuspSpan ℓ' ℓ'' A)
+Susp≃PushoutSusp* {ℓ} {ℓ'} {ℓ''} {A} = invEquiv (_ , SuspPushoutSquare ℓ' ℓ'' A)
+
+Susp≡PushoutSusp* : ∀ {ℓ ℓ' ℓ''} {A : Type _} → Susp A ≡ spanPushout (SuspSpan ℓ' ℓ'' A)
+Susp≡PushoutSusp* {ℓ} {ℓ'} {ℓ''} = ua
+  (Susp≃PushoutSusp* {ℓ-max ℓ (ℓ-max ℓ' ℓ'')} {ℓ'} {ℓ''})
+
 congSuspIso : ∀ {ℓ ℓ'} {A : Type ℓ} {B : Type ℓ'} → Iso A B → Iso (Susp A) (Susp B)
 fun (congSuspIso is) = suspFun (fun is)
 inv (congSuspIso is) = suspFun (inv is)
diff --git a/Cubical/HITs/Susp/SuspProduct.agda b/Cubical/HITs/Susp/SuspProduct.agda
new file mode 100644
index 0000000000..72f2764180
--- /dev/null
+++ b/Cubical/HITs/Susp/SuspProduct.agda
@@ -0,0 +1,236 @@
+{-# OPTIONS --safe #-}
+
+{-
+  The suspension of a Cartesian product is given by a triple wedge sum
+    Σ (X × Y) = Σ X ⋁ Σ Y ⋁ Σ (X ⋀ Y)
+-}
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.Pointed
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+
+open import Cubical.Data.Sigma
+open import Cubical.Data.Unit
+
+open import Cubical.HITs.Pushout
+open import Cubical.HITs.Susp
+open import Cubical.HITs.SmashProduct
+open import Cubical.HITs.Join
+open import Cubical.HITs.Wedge
+
+module Cubical.HITs.Susp.SuspProduct where
+
+module PushoutNull {ℓ ℓ'} (X : Type ℓ) (Y : Type ℓ') (y₀ : Y) where
+
+  {- The pushout of a null map is equivalent to a wedge with the suspension
+    X --> 1 --> Y
+    ↓     ↓     ↓
+    1 -> Σ X -> ? = B
+  -}
+
+  module _ where
+    open PushoutPasteLeft
+      (rotatePushoutSquare (_ , SuspPushoutSquare ℓ-zero ℓ-zero X))
+      {B = (Susp X , north) ⋁ (Y , y₀)}
+      (const y₀) inr inl (funExt (λ _ → push _))
+
+    squareL : commSquare
+    squareL = totSquare
+
+    pushoutSquareL : PushoutSquare
+    pushoutSquareL = squareL , isPushoutRightSquare→isPushoutTotSquare
+      (snd (⋁-PushoutSquare _ _ ℓ-zero))
+
+  module _ where
+    open PushoutPasteDown
+      (_ , SuspPushoutSquare ℓ-zero ℓ-zero X)
+      {B = (Susp X , north) ⋁ (Y , y₀)}
+      (const y₀) inr inl (funExt (λ _ → sym (push _)))
+
+    squareR : commSquare
+    squareR = totSquare
+
+    pushoutSquareR : PushoutSquare
+    pushoutSquareR = squareR , isPushoutBottomSquare→isPushoutTotSquare
+      (snd (rotatePushoutSquare (⋁-PushoutSquare _ _ ℓ-zero)))
+
+module WedgePushout {ℓ ℓ' ℓ''} (A : Pointed ℓ) (B : Pointed ℓ') (C : Pointed ℓ'') where
+
+  open 3x3-span
+  span : 3x3-span
+  span .A40 = typ A
+  span .A42 = typ A
+  span .A44 = typ A
+  span .A20 = Unit
+  span .A22 = Unit
+  span .A24 = Unit
+  span .A00 = typ B
+  span .A02 = Unit
+  span .A04 = typ C
+  span .f30 _ = pt A
+  span .f32 _ = pt A
+  span .f34 _ = pt A
+  span .f10 _ = pt B
+  span .f12 _ = _
+  span .f14 _ = pt C
+  span .f41 = idfun (typ A)
+  span .f21 = _
+  span .f01 _ = pt B
+  span .f43 = idfun (typ A)
+  span .f23 = _
+  span .f03 _ = pt C
+  span .H11 _ = refl
+  span .H13 _ = refl
+  span .H31 _ = refl
+  span .H33 _ = refl
+
+  A□2≃ : A□2 span ≃ typ A
+  A□2≃ = invEquiv (pushoutIdfunEquiv' _)
+
+  f : typ A → B ⋁ A
+  f = inr
+
+  g : typ A → C ⋁ A
+  g = inr
+
+  A□○≃ : A□○ span ≃ Pushout f g
+  A□○≃ = pushoutEquiv _ _ _ _
+    A□2≃ (idEquiv _) (idEquiv _)
+    (funExt λ
+      { (inl x) → push _
+      ; (inr x) → refl
+      ; (push a i) j → sq (~ i) (~ j) })
+    (funExt λ
+      { (inl x) → push _
+      ; (inr x) → refl
+      ; (push a i) j → sq (~ i) (~ j) })
+    where
+      sq : ∀ {ℓ} {C : Type ℓ} {c : C}
+        → Square refl (sym (Pushout.push _))
+          refl (sym (push {f = λ x → c} {g = λ _ → pt A}
+            tt ∙ refl))
+      sq = slideSquare (sym (rUnit _))
+
+  A4□≃ : A4□ span ≃ typ A
+  A4□≃ = invEquiv (pushoutIdfunEquiv _)
+
+  A2□≃ : A2□ span ≃ Unit
+  A2□≃ = invEquiv (pushoutIdfunEquiv _)
+
+  A2□isContr : isContr (A2□ span)
+  A2□isContr = isOfHLevelRespectEquiv 0 (pushoutIdfunEquiv _) isContrUnit
+
+  A○□≃ : A○□ span ≃ (B ⋁∙ₗ C) ⋁ A
+  A○□≃ = pushoutEquiv _ _ _ _
+    A2□≃ (idEquiv _) A4□≃
+    (lemma A2□isContr refl) (lemma A2□isContr refl)
+    where
+      -- functions on contractible domains are determined by the basepoint
+      lemma : ∀ {ℓ ℓ'}
+        → {A : Type ℓ} {B : Type ℓ'}
+        → {f g : A → B}
+        → (c : isContr A)
+        → f (c .fst) ≡ g (c .fst)
+        → f ≡ g
+      lemma {f = f} {g} c p = funExt λ x
+        → cong f (sym (c .snd x))
+        ∙ p
+        ∙ cong g (c .snd x)
+
+  opaque
+    extendWedgeEq : Pushout f g ≃ ((B ⋁∙ₗ C) ⋁ A)
+    extendWedgeEq = invEquiv A□○≃ ∙ₑ pathToEquiv (3x3-lemma span) ∙ₑ A○□≃
+
+  wedgePushout : PushoutSquare
+  wedgePushout = extendPushoutSquare
+    (pushoutToSquare record { f1 = f ; f3 = g })
+    extendWedgeEq
+
+
+module _ {ℓ ℓ'} (X : Pointed ℓ) (Y : Pointed ℓ') where
+  open commSquare
+  open 3-span
+
+  {-
+    X × Y ---> Y --------> 1
+      ↓   A    ↓     C     ↓
+      X ---> Σ(X∧Y) --> ΣY ∨ Σ(X∧Y)
+      ↓   B    ↓     D     ↓
+      1 -> ΣX ∨ Σ(X∧Y) --> ? = ΣX ∨ ΣY ∨ Σ(X∧Y)
+  -}
+
+  pushoutA₀ : PushoutSquare  -- inrP maps to south, but we want north
+  pushoutA₀ = extendPushoutSquare
+      (pushoutToSquare (3span fst snd))
+      (pathToEquiv (joinPushout≡join _ _) ∙ₑ
+        invEquiv (isoToEquiv (SmashJoinIso {A = X} {B = Y})))
+
+  squareA : I → commSquare
+  squareA i = record
+    { commSquare (pushoutA₀ .fst)
+    ; inrP = λ _ → merid (inl _) i
+    ; comm = transp (λ j →
+      Path (typ X × typ Y → Susp (X ⋀ Y))
+        (λ _ → north) (λ _ → merid (inl _) (i ∨ ~ j)))
+      i (pushoutA₀ .fst .commSquare.comm)
+    }
+
+  pushoutA : PushoutSquare
+  pushoutA = squareA i0 ,
+    subst isPushoutSquare (λ i → squareA (~ i)) (pushoutA₀ .snd)
+
+  module _ where
+    open PushoutNull (typ X) (Susp (X ⋀ Y)) north
+    open PushoutPasteDown pushoutA
+      (squareL .sp .f1)
+      (squareL .inlP)
+      (squareL .inrP)
+      (squareL .commSquare.comm)
+
+    pushoutB : PushoutSquare
+    pushoutB = pushoutSquareL
+
+    pushoutAB : PushoutSquare
+    pushoutAB = _ , isPushoutBottomSquare→isPushoutTotSquare (pushoutB .snd)
+
+    cofib-snd : cofib snd ≃ Susp∙ (typ X) ⋁ Susp∙ (X ⋀ Y)
+    cofib-snd = pushoutEquiv _ _ _ _
+        (idEquiv _) Unit≃Unit* (idEquiv _)
+        refl refl
+      ∙ₑ (_ , pushoutAB .snd)
+
+  pushoutC : PushoutSquare
+  pushoutC = PushoutNull.pushoutSquareR (typ Y) (Susp (X ⋀ Y)) north
+
+  pushoutD : PushoutSquare
+  pushoutD = WedgePushout.wedgePushout
+    (Susp∙ (X ⋀ Y)) (Susp∙ (typ X)) (Susp∙ (typ Y))
+
+  pushoutCD : PushoutSquare
+  pushoutCD = _ , isPushoutBottomSquare→isPushoutTotSquare (pushoutD .snd)
+    where
+      open PushoutPasteDown pushoutC
+        (pushoutD .fst .sp .f1)
+        (pushoutD .fst .inlP)
+        (pushoutD .fst .inrP)
+        (pushoutD .fst .commSquare.comm)
+
+  pushoutTot : PushoutSquare
+  pushoutTot = _ , isPushoutRightSquare→isPushoutTotSquare (pushoutCD .snd)
+    where
+      open PushoutPasteLeft pushoutAB
+        (pushoutCD .fst .sp .f3)
+        (pushoutCD .fst .inrP)
+        (pushoutCD .fst .inlP)
+        (pushoutCD .fst .commSquare.comm)
+
+  SuspProduct : (Susp∙ (typ X) ⋁∙ₗ Susp∙ (typ Y)) ⋁ Susp∙ (X ⋀ Y)
+    ≃ Susp (typ X × typ Y)
+  SuspProduct = invEquiv (_ , pushoutTot .snd)
+    ∙ₑ (_ , SuspPushoutSquare ℓ-zero ℓ-zero (typ X × typ Y))
diff --git a/Cubical/HITs/Wedge/Base.agda b/Cubical/HITs/Wedge/Base.agda
index 192c7aedcc..80c1c98a03 100644
--- a/Cubical/HITs/Wedge/Base.agda
+++ b/Cubical/HITs/Wedge/Base.agda
@@ -34,6 +34,14 @@ _∨→_ : ∀ {ℓ ℓ' ℓ''} {A : Pointed ℓ} {B : Pointed ℓ'} {C : Pointe
 (f ∨→ g) (inr x) = fst g x
 (f ∨→ g) (push a i₁) = (snd f ∙ sym (snd g)) i₁
 
+⋁proj₁ : ∀ {ℓ ℓ'} (A : Pointed ℓ) (B : Pointed ℓ')
+      → A ⋁ B → typ A
+⋁proj₁ A B = idfun∙ A ∨→ const∙ B A
+
+⋁proj₂ : ∀ {ℓ ℓ'} (A : Pointed ℓ) (B : Pointed ℓ')
+      → A ⋁ B → typ B
+⋁proj₂ A B = const∙ A B ∨→ idfun∙ B
+
 -- Pointed version
 ∨→∙ : ∀ {ℓ ℓ' ℓ''} {A : Pointed ℓ} {B : Pointed ℓ'} {C : Pointed ℓ''}
    → (f : A →∙ C) (g : B →∙ C) → ((A ⋁∙ₗ B) →∙ C)
diff --git a/Cubical/HITs/Wedge/Properties.agda b/Cubical/HITs/Wedge/Properties.agda
index c357e94d00..d2099fe4c4 100644
--- a/Cubical/HITs/Wedge/Properties.agda
+++ b/Cubical/HITs/Wedge/Properties.agda
@@ -12,7 +12,6 @@ open import Cubical.Data.Sigma
 open import Cubical.Data.Unit
 open import Cubical.Data.Sum as ⊎
 
-open import Cubical.HITs.Pushout.Base
 open import Cubical.HITs.Wedge.Base
 open import Cubical.HITs.Susp
 open import Cubical.HITs.Pushout
@@ -44,6 +43,40 @@ Iso.inv ⋁-commIso = ⋁-commFun
 Iso.rightInv ⋁-commIso = ⋁-commFun²
 Iso.leftInv ⋁-commIso = ⋁-commFun²
 
+-- Pushout square using Unit* for convenience
+⋁-PushoutSquare : ∀ (A : Pointed ℓ) (B : Pointed ℓ') ℓ'' → PushoutSquare
+⋁-PushoutSquare A B ℓ'' .fst = cSq
+  where
+  open commSquare
+  open 3-span
+  cSq : commSquare
+  cSq .sp .A0 = typ A
+  cSq .sp .A2 = Unit* {ℓ''}
+  cSq .sp .A4 = typ B
+  cSq .sp .f1 _ = pt A
+  cSq .sp .f3 _ = pt B
+  cSq .P = A ⋁ B
+  cSq .inlP = inl
+  cSq .inrP = inr
+  cSq .comm = funExt λ _ → push _
+⋁-PushoutSquare A B ℓ'' .snd =
+  isoToIsEquiv (iso _ inv lInv rInv)
+  where
+    inv : _
+    inv (inl a) = inl a
+    inv (inr b) = inr b
+    inv (push _ i) = push _ i
+
+    rInv : _
+    rInv (inl a) = refl
+    rInv (inr b) = refl
+    rInv (push _ i) = refl
+
+    lInv : _
+    lInv (inl a) = refl
+    lInv (inr b) = refl
+    lInv (push _ i) = refl
+
 -- cofibre of A --inl→ A ⋁ B is B
 cofibInl-⋁ : {A : Pointed ℓ} {B : Pointed ℓ'}
   → Iso (cofib {B = A ⋁ B} inl) (fst B)
@@ -548,3 +581,70 @@ module _ {ℓA ℓB ℓC : Level} {A : Type ℓA} {B : A → Pointed ℓB} (C :
   ⋁-cofib-Iso = compIso (compIso (invIso A○□Iso)
                                   (invIso (3x3-Iso inst)))
                                   A□○Iso
+
+{-
+  We prove the square
+    X ⋁ Y --> X
+      ↓       ↓
+      Y ----> *
+  is a pushout.
+-}
+
+module _ (X∙ @ (X , x₀) : Pointed ℓ) (Y∙ @ (Y , y₀) : Pointed ℓ') where
+
+  open 3-span
+  open commSquare
+
+  private
+    weirdSquare : ∀ {ℓ ℓ' ℓ''} {X : Type ℓ} {Y : Type ℓ'} {Z : Type ℓ''}
+      → (f : X → Y) (g : Y → Z) → commSquare
+    weirdSquare f g .sp = 3span (idfun _) f
+    weirdSquare f g .P = _
+    weirdSquare f g .inlP = f
+    weirdSquare f g .inrP = idfun _
+    weirdSquare f g .comm = refl ∙ refl ∙ refl
+
+    weirdPushoutSquare : ∀ {ℓ ℓ' ℓ''} {X : Type ℓ} {Y : Type ℓ'} {Z : Type ℓ''}
+      → (f : X → Y) (g : Y → Z) → isPushoutSquare (weirdSquare f g)
+    weirdPushoutSquare f g = isoToIsEquiv (iso _ inr (λ _ → refl)
+        λ { (inl x) → sym (push _)
+          ; (inr x) → refl
+          ; (push a i) j → subst
+            (λ t → Square (sym (push _)) refl t (push _))
+              (cong (cong Pushout.inr) (lUnit _ ∙ lUnit _))
+              (λ i j → push a (i ∨ ~ j))
+              i j
+          })
+
+    {-
+    The proof proceeds by applying the pasting lemma twice:
+      1 ----> Y
+      ↓       ↓
+      X --> X ⋁ Y --> X
+      ↓  mid  ↓  bot  ↓
+      1 ----> Y ----> 1
+    -}
+
+    midPushout : isPushoutSquare _
+    midPushout = isPushoutTotSquare→isPushoutBottomSquare
+      (weirdPushoutSquare _ (terminal Y))
+      where
+        open PushoutPasteDown
+          (pushoutToSquare (3span (const x₀) (const y₀)))
+          (terminal X) (const y₀) (⋁proj₂ X∙ Y∙) refl
+
+    -- slight help to the unifier here
+    botPushout : isPushoutSquare record { comm = refl }
+    botPushout = isPushoutTotSquare→isPushoutBottomSquare $
+      rotatePushoutSquare (record { comm = refl } , isoToIsEquiv
+        (iso _ inl (λ _ → refl) λ {
+          (inl _) i → inl _
+        ; (inr a) i → push a i
+        ; (push a j) i → push a (i ∧ j)
+        })) .snd
+      where
+        open PushoutPasteDown (rotatePushoutSquare (_ , midPushout))
+          (⋁proj₁ X∙ Y∙) (terminal X) (terminal Y) refl
+
+  Pushout⋁≃Unit : Pushout (⋁proj₁ X∙ Y∙) (⋁proj₂ X∙ Y∙) ≃ Unit
+  Pushout⋁≃Unit = _ , botPushout
diff --git a/Cubical/Homotopy/EilenbergMacLane/Properties.agda b/Cubical/Homotopy/EilenbergMacLane/Properties.agda
index 953ce48309..1d613b4eaa 100644
--- a/Cubical/Homotopy/EilenbergMacLane/Properties.agda
+++ b/Cubical/Homotopy/EilenbergMacLane/Properties.agda
@@ -812,6 +812,25 @@ module _ where
              →∙ →∙EMPath {G = L} (EM-raw'∙ H (suc m)) (suc (suc (l + n + m))) (~ i))
         (isOfHLevel↑∙∙'' n m l)
 
+-- A homomorphism φ : G → H of (not necessarily abelian) groups induces a homomorphism
+-- φ' : K(G,1) → K(H,1)
+
+inducedFun-EM₁ : {G : Group ℓ} {H : Group ℓ'} (f : GroupHom G H) → EM₁ G → EM₁ H
+inducedFun-EM₁ f = EMrec _ emsquash embase (λ g → emloop (fst f g)) λ g h i j → hcomp (λ k → λ where
+    (i = i0) → emloop (f .fst g) j
+    (i = i1) → emloop (f .snd .pres· g h (~ k)) j
+    (j = i0) → embase
+    (j = i1) → emloop (f .fst h) i
+  ) (emcomp (f .fst g) (f. fst h) i j)
+  where open IsGroupHom
+
+inducedFun-EM₁-id : {G : Group ℓ} (x : EM₁ G) → inducedFun-EM₁ idGroupHom x ≡ x
+inducedFun-EM₁-id = elimSet _ (λ _ → emsquash _ _) refl λ x i → refl
+
+inducedFun-EM₁-comp : {G : Group ℓ} {H : Group ℓ'} {L : Group ℓ''} (f : GroupHom G H) (g : GroupHom H L) (x : EM₁ G)
+                    → inducedFun-EM₁ (compGroupHom f g) x ≡ inducedFun-EM₁ g (inducedFun-EM₁ f x)
+inducedFun-EM₁-comp f g = elimSet _ (λ _ → emsquash _ _) refl λ x i → refl
+
 -- A homomorphism φ : G → H of AbGroups induces a homomorphism
 -- φ' : K(G,n) → K(H,n)
 inducedFun-EM-raw : {G' : AbGroup ℓ} {H' : AbGroup ℓ'}
@@ -1015,6 +1034,15 @@ Iso.leftInv (inducedFun-EM-rawIso e n) = h n
                ; south → refl
                ; (merid a i) k → merid (p a k) i}
 
+Iso→EM₁Iso : {G : Group ℓ} {H : Group ℓ'} → GroupIso G H → Iso (EM₁ G) (EM₁ H)
+Iso→EM₁Iso e .Iso.fun = inducedFun-EM₁ (GroupIso→GroupHom e)
+Iso→EM₁Iso e .Iso.inv = inducedFun-EM₁ (GroupIso→GroupHom (invGroupIso e))
+Iso→EM₁Iso e .Iso.rightInv = elimSet _ (λ _ → emsquash _ _) refl λ x i j → emloop (e .fst .Iso.rightInv x j) i
+Iso→EM₁Iso e .Iso.leftInv = elimSet _ (λ _ → emsquash _ _) refl λ x i j → emloop (e .fst .Iso.leftInv x j) i
+
+Equiv→EM₁Equiv : {G : Group ℓ} {H : Group ℓ'} → GroupEquiv G H → EM₁ G ≃ EM₁ H
+Equiv→EM₁Equiv e = isoToEquiv (Iso→EM₁Iso (GroupEquiv→GroupIso e))
+
 module _ {G : AbGroup ℓ} {H : AbGroup ℓ'} (e : AbGroupEquiv G H) where
   Iso→EMIso : ∀ n → Iso (EM G n) (EM H n)
   Iso.fun (Iso→EMIso n) = inducedFun-EM (GroupEquiv→GroupHom e) n
diff --git a/Cubical/Homotopy/HiltonMilnor.agda b/Cubical/Homotopy/HiltonMilnor.agda
new file mode 100644
index 0000000000..425a5e7977
--- /dev/null
+++ b/Cubical/Homotopy/HiltonMilnor.agda
@@ -0,0 +1,96 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+{-
+  The finitary Hilton–Milnor splitting
+    Ω(X ⋁ Y) ≃ ΩX × ΩY × ΩΣ(ΩY ⋀ ΩX)
+  for pointed types X and Y.
+-}
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Isomorphism using (isoToPath; isoToEquiv)
+open import Cubical.Foundations.GroupoidLaws
+open import Cubical.Foundations.Pointed
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Univalence
+
+open import Cubical.Homotopy.Loopspace
+
+open import Cubical.Data.Sigma
+open import Cubical.Data.Unit
+
+open import Cubical.HITs.Pushout
+open import Cubical.HITs.Pushout.Flattening
+open import Cubical.HITs.SmashProduct
+open import Cubical.HITs.Susp
+open import Cubical.HITs.Join
+open import Cubical.HITs.Wedge
+
+module Cubical.Homotopy.HiltonMilnor {ℓ} (X∙@(X , x₀) Y∙@(Y , y₀) : Pointed ℓ) where
+
+fun : X∙ ⋁ Y∙ → typ X∙ × typ Y∙
+fun = ⋁↪ {A = X∙} {B = Y∙}
+
+-- The required section, given by concatenating the paths
+sect : typ (Ω (X∙ ×∙ Y∙)) → typ (Ω (X∙ ⋁∙ₗ Y∙))
+sect p = cong (inl ∘ fst) p ∙ push _ ∙ cong (inr ∘ snd) p ∙ sym (push _)
+
+rInv : ∀ c → cong fun (sect c) ≡ c
+rInv c = congFunct fun _ _
+  ∙ cong (cong (fun ∘ inl ∘ fst) c ∙_)
+    (congFunct fun (push _) _
+    ∙ sym (lUnit _)
+    ∙ lemma₂  -- can't be inlined because lossy unification
+    ∙ sym (rUnit _))
+  ∙ lemma₁ (cong fst c) (cong snd c)
+  where
+    lemma₁ : (p : x₀ ≡ x₀) (q : y₀ ≡ y₀)
+      → cong (_, y₀) p ∙ cong (x₀ ,_) q ≡ cong₂ _,_ p q
+    lemma₁ p q = cong ΣPathP (ΣPathP
+      (congFunct fst (cong (_, y₀) p) _ ∙ sym (rUnit _) ,
+      congFunct snd (cong (_, y₀) p) _ ∙ sym (lUnit _)))
+
+    lemma₂ : cong fun
+      (cong (inr ∘ snd) c ∙ sym (push _))
+      ≡ cong (⋁↪ ∘ inr ∘ snd) c ∙ refl
+    lemma₂ = congFunct fun _ _
+
+-- Now the splitting lemma gives us something in terms of the fiber of ⋁↪.
+-- So we try to characterize the type.
+module _ where
+  open FlatteningLemma
+    (λ (_ : Unit) → x₀) (λ _ → y₀)
+    (λ x → (x , y₀) ≡ (x₀ , y₀)) (λ y → (x₀ , y) ≡ (x₀ , y₀))
+    (λ _ → idEquiv _)
+
+  private
+    E≡ : ∀ u → E u ≡ (⋁↪ u ≡ (x₀ , y₀))
+    E≡ (inl x) = refl
+    E≡ (inr x) = refl
+    E≡ (push a i) j = uaIdEquiv {A = typ (Ω (X∙ ×∙ Y∙))} j i
+
+    Pushout≃ : Pushout Σf Σg ≃ join (typ (Ω Y∙)) (typ (Ω X∙))
+    Pushout≃ = pushoutEquiv _ _ _ _
+        (ΣUnit _ ∙ₑ invEquiv ΣPathP≃PathPΣ ∙ₑ Σ-swap-≃)
+        (Σ-cong-equiv-snd (λ _ → invEquiv ΣPathP≃PathPΣ ∙ₑ Σ-swap-≃)
+          ∙ₑ invEquiv Σ-assoc-≃
+          ∙ₑ invEquiv (fiberProjEquiv X _ x₀))
+        (Σ-cong-equiv-snd (λ _ → invEquiv ΣPathP≃PathPΣ)
+          ∙ₑ invEquiv Σ-assoc-≃
+          ∙ₑ invEquiv (fiberProjEquiv Y _ y₀))
+        (funExt λ _ → transportRefl _)
+        (funExt λ _ → transportRefl _)
+      ∙ₑ joinPushout≃join _ _
+
+  fiber⋁↪≃ : fiber fun (x₀ , y₀) ≃ join (typ (Ω Y∙)) (typ (Ω X∙))
+  fiber⋁↪≃ = Σ-cong-equiv-snd (λ a → pathToEquiv (sym (E≡ a)))
+    ∙ₑ flatten ∙ₑ Pushout≃
+
+HMSplit : typ (Ω (X∙ ⋁∙ₗ Y∙)) ≡ typ (Ω X∙) × typ (Ω Y∙) × typ (Ω (Susp∙ (Ω Y∙ ⋀ Ω X∙)))
+HMSplit = splitting
+  ∙ cong₂ (λ A B∙ → A × typ (Ω B∙)) (sym ΣPathP≡PathPΣ)
+      (ua∙ fiber⋁↪≃ refl ∙ ΣPathP
+        (sym (isoToPath SmashJoinIso) , toPathP refl))
+  ∙ ua Σ-assoc-≃
+  where open Split (inl x₀) ⋁↪ sect rInv
diff --git a/Cubical/Homotopy/Loopspace.agda b/Cubical/Homotopy/Loopspace.agda
index 36fef7ea1f..2f687d7aba 100644
--- a/Cubical/Homotopy/Loopspace.agda
+++ b/Cubical/Homotopy/Loopspace.agda
@@ -13,8 +13,10 @@ open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.Equiv.HalfAdjoint
 open import Cubical.Foundations.Function
 open import Cubical.Foundations.Path
+open import Cubical.Foundations.Univalence
 
 open import Cubical.Functions.Morphism
+open import Cubical.Functions.Fibration
 
 open import Cubical.Data.Nat
 open import Cubical.Data.Sigma
@@ -460,3 +462,79 @@ EH-π : ∀ {ℓ} {A : Pointed ℓ} (n : ℕ) (p q : ∥ typ ((Ω^ (2 + n)) A) 
                → π-comp (1 + n) p q ≡ π-comp (1 + n) q p
 EH-π  n = elim2 (λ x y → isOfHLevelPath 2 isSetSetTrunc _ _)
                              λ p q → cong ∣_∣₂ (EH n p q)
+
+{-
+  If A -> B -> C is a fiber sequence, and Ω B -> Ω C has a section,
+  then Ω B is the product Ω A × Ω C.
+
+  https://gist.github.com/ecavallo/5b75313d36977c51ca3563de82506123
+-}
+
+module _ {ℓ} {B C : Type ℓ} (b₀ : B) (π : B → C) where
+  private
+    c₀ = π b₀
+    A = fiber π c₀
+    a₀ : A
+    a₀ = b₀ , refl
+    ι : A → B
+    ι = fst
+    π∘ι≡0 : ∀ a → π (ι a) ≡ c₀
+    π∘ι≡0 = snd
+
+    A∙ B∙ C∙ : Pointed _
+    A∙ = (A , a₀)
+    B∙ = (B , b₀)
+    C∙ = (C , c₀)
+
+    TwistedProduct : Pointed _
+    TwistedProduct = ((Σ[ p ∈ typ (Ω C∙) ] (b₀ , p) ≡ a₀) , refl , refl)
+
+  -- The middle term of a fiber sequence always splits
+  -- as a twisted product without any conditions.
+  presplit : Ω B∙ ≡ TwistedProduct
+  presplit = cong Ω (ua∙ (totalEquiv π) refl)
+    ∙ sym (ua∙ ΣPath≃PathΣ refl)
+    ∙ Σ-cong-equiv-snd∙ (λ p
+      → PathP≃Path _ _ _ ∙ₑ
+        compPathlEquiv (sym (fromPathP
+          (ΣPathP (refl , λ i j → p (i ∧ j))))))
+      (rCancel λ j → transp (λ _ → A) (~ j) a₀)
+
+  module Split (s : typ (Ω C∙) → typ (Ω B∙))
+      (section : ∀ p → cong π (s p) ≡ p) where
+    movePoint : ∀ p → a₀ ≡ (b₀ , sym p)
+    movePoint p = ΣPathP (s p ,
+      λ i j → slideSquare (section p) i (~ j))
+
+    splitting : typ (Ω B∙) ≡ typ (Ω C∙) × typ (Ω A∙)
+    splitting = cong typ presplit ∙ ua
+      (Σ-cong-equiv-snd λ p → compPathlEquiv (movePoint _))
+
+    -- If the section furthermore respects the base point, then
+    -- the splitting does too.
+    module _ (h : s refl ≡ refl) (coh : cong (cong π) h ≡ section refl) where
+      movePoint-refl : movePoint refl ≡ refl
+      movePoint-refl i j = h i j , λ k →
+        slideSquare (cong sym coh ∙ lemma _ _) (~ i) (~ k) j
+        where
+          lemma : ∀ {ℓ} {X : Type ℓ} {x : X} (p : x ≡ x) (q : p ≡ refl)
+            → sym q ≡ flipSquare (slideSquare q)
+          lemma {x = x} p q = J (λ p (q : refl ≡ p)
+              → q ≡ flipSquare (slideSquare (sym q)))
+            (λ i j k → hfill
+              (slideSquareFaces
+                {a₀₀ = x} {a₋ = refl} {a₁₋ = refl} {a₋₀ = refl}
+                j k) (inS x) i)
+            (sym q)
+
+      twisted∙ : TwistedProduct ≡ Ω C∙ ×∙ Ω A∙
+      twisted∙ = Σ-cong-equiv-snd∙
+        (λ p → compPathlEquiv (movePoint _))
+        (cong (λ t → compPathlEquiv t .fst refl) movePoint-refl ∙ sym (rUnit _))
+
+      splitting∙ : Ω B∙ ≡ Ω C∙ ×∙ Ω A∙
+      splitting∙ = presplit ∙ twisted∙
+
+      -- splitting and splitting∙ agrees
+      splitting-typ : cong typ splitting∙ ≡ splitting
+      splitting-typ = congFunct typ presplit twisted∙
diff --git a/Cubical/README.agda b/Cubical/README.agda
index bfe8dee179..af375d0d6e 100644
--- a/Cubical/README.agda
+++ b/Cubical/README.agda
@@ -4,7 +4,7 @@ module Cubical.README where
 
 ------------------------------------------------------------------------
 -- An experimental library for Cubical Agda
------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 -- The library comes with a .agda-lib file, for use with the library
 -- management system.
diff --git a/Cubical/Relation/Binary/Base.agda b/Cubical/Relation/Binary/Base.agda
index 07d31701af..b6e658f74b 100644
--- a/Cubical/Relation/Binary/Base.agda
+++ b/Cubical/Relation/Binary/Base.agda
@@ -77,19 +77,16 @@ module BinaryRelation {ℓ ℓ' : Level} {A : Type ℓ} (R : Rel A A ℓ') where
 
   -- Sum types don't play nicely with props, so we truncate
   isCotrans : Type (ℓ-max ℓ ℓ')
-  isCotrans = (a b c : A) → R a b → (R a c ⊔′ R b c)
+  isCotrans = (a b c : A) → R a b → R a c ⊔′ R b c
 
   isWeaklyLinear : Type (ℓ-max ℓ ℓ')
   isWeaklyLinear = (a b c : A) → R a b → R a c ⊔′ R c b
 
   isConnected : Type (ℓ-max ℓ ℓ')
-  isConnected = (a b : A) → ¬ (a ≡ b) → R a b ⊔′ R b a
+  isConnected = (a b : A) → (¬ R a b) × (¬ R b a) → a ≡ b
 
-  isStronglyConnected : Type (ℓ-max ℓ ℓ')
-  isStronglyConnected = (a b : A) → R a b ⊔′ R b a
-
-  isStronglyConnected→isConnected : isStronglyConnected → isConnected
-  isStronglyConnected→isConnected strong a b _ = strong a b
+  isTotal : Type (ℓ-max ℓ ℓ')
+  isTotal = (a b : A) → R a b ⊔′ R b a
 
   isIrrefl×isTrans→isAsym : isIrrefl × isTrans → isAsym
   isIrrefl×isTrans→isAsym (irrefl , trans) a₀ a₁ Ra₀a₁ Ra₁a₀
@@ -98,6 +95,9 @@ module BinaryRelation {ℓ ℓ' : Level} {A : Type ℓ} (R : Rel A A ℓ') where
   WellFounded→isIrrefl : WellFounded R → isIrrefl
   WellFounded→isIrrefl well = WFI.induction well λ a f Raa → f a Raa Raa
 
+  isAsym→isIrrefl : isAsym → isIrrefl
+  isAsym→isIrrefl asym a Raa = asym a a Raa Raa
+
   IrreflKernel : Rel A A (ℓ-max ℓ ℓ')
   IrreflKernel a b = R a b × (¬ a ≡ b)
 
@@ -116,6 +116,9 @@ module BinaryRelation {ℓ ℓ' : Level} {A : Type ℓ} (R : Rel A A ℓ') where
   NegationRel : Rel A A ℓ'
   NegationRel a b = ¬ (R a b)
 
+  Dual : Rel A A ℓ'
+  Dual a b = R b a
+
   module _
     {ℓ'' : Level}
     (P : Embedding A ℓ'')
@@ -154,10 +157,15 @@ module BinaryRelation {ℓ ℓ' : Level} {A : Type ℓ} (R : Rel A A ℓ') where
   isEffective =
     (a b : A) → isEquiv (eq/ {R = R} a b)
 
+  isDecidable : Type (ℓ-max ℓ ℓ')
+  isDecidable = (a b : A) → Dec (R a b)
 
   impliesIdentity : Type _
   impliesIdentity = {a a' : A} → (R a a') → (a ≡ a')
 
+  isTight : Type _
+  isTight = (a b : A) → ¬ R a b → a ≡ b
+
   inequalityImplies : Type _
   inequalityImplies = (a b : A) → ¬ a ≡ b → R a b
 
@@ -241,14 +249,6 @@ isIrreflIrreflKernel _ _ (_ , ¬a≡a) = ¬a≡a refl
 isReflReflClosure : ∀{ℓ ℓ'} {A : Type ℓ} (R : Rel A A ℓ') → isRefl (ReflClosure R)
 isReflReflClosure _ _ = inr refl
 
-isConnectedStronglyConnectedIrreflKernel : ∀{ℓ ℓ'} {A : Type ℓ} (R : Rel A A ℓ')
-                                         → isStronglyConnected R
-                                         → isConnected (IrreflKernel R)
-isConnectedStronglyConnectedIrreflKernel R strong a b ¬a≡b
-  = ∥₁.map (λ x → ⊎.rec (λ Rab → inl (Rab , ¬a≡b))
-                        (λ Rba → inr (Rba , (λ b≡a → ¬a≡b (sym b≡a)))) x)
-                        (strong a b)
-
 isSymSymKernel : ∀{ℓ ℓ'} {A : Type ℓ} (R : Rel A A ℓ') → isSym (SymKernel R)
 isSymSymKernel _ _ _ (Rab , Rba) = Rba , Rab
 
diff --git a/Cubical/Relation/Binary/Order.agda b/Cubical/Relation/Binary/Order.agda
index 9c15bb7931..7b777b96d8 100644
--- a/Cubical/Relation/Binary/Order.agda
+++ b/Cubical/Relation/Binary/Order.agda
@@ -2,9 +2,9 @@
 module Cubical.Relation.Binary.Order where
 
 open import Cubical.Relation.Binary.Order.Apartness public
-open import Cubical.Relation.Binary.Order.Preorder public
+open import Cubical.Relation.Binary.Order.Proset public
 open import Cubical.Relation.Binary.Order.Poset public
 open import Cubical.Relation.Binary.Order.Toset public
-open import Cubical.Relation.Binary.Order.StrictPoset public
+open import Cubical.Relation.Binary.Order.Quoset public
+open import Cubical.Relation.Binary.Order.StrictOrder public
 open import Cubical.Relation.Binary.Order.Loset public
-open import Cubical.Relation.Binary.Order.Properties public
diff --git a/Cubical/Relation/Binary/Order/Apartness/Base.agda b/Cubical/Relation/Binary/Order/Apartness/Base.agda
index 35dc95528f..5801016a17 100644
--- a/Cubical/Relation/Binary/Order/Apartness/Base.agda
+++ b/Cubical/Relation/Binary/Order/Apartness/Base.agda
@@ -66,8 +66,8 @@ record ApartnessStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc 
 Apartness : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
 Apartness ℓ ℓ' = TypeWithStr ℓ (ApartnessStr ℓ')
 
-apartness : (A : Type ℓ) (_#_ : A → A → Type ℓ') (h : IsApartness _#_) → Apartness ℓ ℓ'
-apartness A _#_ h = A , apartnessstr _#_ h
+apartness : (A : Type ℓ) → (_#_ : Rel A A ℓ') → IsApartness _#_ → Apartness ℓ ℓ'
+apartness A _#_ apart = A , (apartnessstr _#_ apart)
 
 record IsApartnessEquiv {A : Type ℓ₀} {B : Type ℓ₁}
   (M : ApartnessStr ℓ₀' A) (e : A ≃ B) (N : ApartnessStr ℓ₁' B)
diff --git a/Cubical/Relation/Binary/Order/Apartness/Properties.agda b/Cubical/Relation/Binary/Order/Apartness/Properties.agda
index 77f24ce04f..c82e5d77fc 100644
--- a/Cubical/Relation/Binary/Order/Apartness/Properties.agda
+++ b/Cubical/Relation/Binary/Order/Apartness/Properties.agda
@@ -1,6 +1,7 @@
 {-# OPTIONS --safe #-}
 module Cubical.Relation.Binary.Order.Apartness.Properties where
 
+open import Cubical.Foundations.Function
 open import Cubical.Foundations.Prelude
 
 open import Cubical.Functions.Embedding
@@ -51,3 +52,20 @@ module _
                   (λ a → IsApartness.is-irrefl apa (f a))
                   (λ a b c → IsApartness.is-cotrans apa (f a) (f b) (f c))
                   λ a b → IsApartness.is-sym apa (f a) (f b)
+
+  isApartnessDual : IsApartness R → IsApartness (Dual R)
+  isApartnessDual apa
+    = isapartness (IsApartness.is-set apa)
+                  (λ a b → IsApartness.is-prop-valued apa b a)
+                  (IsApartness.is-irrefl apa)
+                  (λ a b c Rba → ∥₁.map (⊎.rec (inl ∘ s c a)
+                                               (inr ∘ s c b))
+                                        (IsApartness.is-cotrans apa a b c (s a b Rba)))
+                   s
+    where s : isSym (Dual R)
+          s a b = IsApartness.is-sym apa b a
+
+DualApartness : Apartness ℓ ℓ' → Apartness ℓ ℓ'
+DualApartness (_ , apa)
+  = apartness _ (BinaryRelation.Dual (ApartnessStr._#_ apa))
+                (isApartnessDual (ApartnessStr.isApartness apa))
diff --git a/Cubical/Relation/Binary/Order/Loset/Base.agda b/Cubical/Relation/Binary/Order/Loset/Base.agda
index 0f2d3bd941..ee0fc5f99d 100644
--- a/Cubical/Relation/Binary/Order/Loset/Base.agda
+++ b/Cubical/Relation/Binary/Order/Loset/Base.agda
@@ -69,8 +69,8 @@ record LosetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')
 Loset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
 Loset ℓ ℓ' = TypeWithStr ℓ (LosetStr ℓ')
 
-loset : (A : Type ℓ) (_<_ : A → A → Type ℓ') (h : IsLoset _<_) → Loset ℓ ℓ'
-loset A _<_ h = A , losetstr _<_ h
+loset : (A : Type ℓ) → (_<_ : Rel A A ℓ') → IsLoset _<_ → Loset ℓ ℓ'
+loset A _<_ los = A , (losetstr _<_ los)
 
 record IsLosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
   (M : LosetStr ℓ₀' A) (e : A ≃ B) (N : LosetStr ℓ₁' B)
@@ -98,7 +98,7 @@ isPropIsLoset _<_ = isOfHLevelRetractFromIso 1 IsLosetIsoΣ
                                  (isPropΠ5 (λ _ _ _ _ _ → isPropValued< _ _))
                                  (isPropΠ3 (λ x y _ → isProp¬ (y < x)))
                                  (isPropΠ4 λ _ _ _ _ → squash₁)
-                                 (isPropΠ3 λ _ _ _ → squash₁))
+                                 (isPropΠ3 λ _ _ _ → isSetA _ _))
 
 𝒮ᴰ-Loset : DUARel (𝒮-Univ ℓ) (LosetStr ℓ') (ℓ-max ℓ ℓ')
 𝒮ᴰ-Loset =
diff --git a/Cubical/Relation/Binary/Order/Loset/Properties.agda b/Cubical/Relation/Binary/Order/Loset/Properties.agda
index 34e0e14e72..943f105a63 100644
--- a/Cubical/Relation/Binary/Order/Loset/Properties.agda
+++ b/Cubical/Relation/Binary/Order/Loset/Properties.agda
@@ -12,8 +12,9 @@ open import Cubical.HITs.PropositionalTruncation as ∥₁
 
 open import Cubical.Relation.Binary.Base
 open import Cubical.Relation.Binary.Order.Apartness.Base
-open import Cubical.Relation.Binary.Order.Toset.Base
-open import Cubical.Relation.Binary.Order.StrictPoset.Base
+open import Cubical.Relation.Binary.Order.Toset
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.StrictOrder.Base
 open import Cubical.Relation.Binary.Order.Loset.Base
 
 open import Cubical.Relation.Nullary
@@ -29,13 +30,14 @@ module _
 
   open BinaryRelation
 
-  isLoset→isStrictPoset : IsLoset R → IsStrictPoset R
-  isLoset→isStrictPoset loset = isstrictposet
-                                (IsLoset.is-set loset)
-                                (IsLoset.is-prop-valued loset)
-                                (IsLoset.is-irrefl loset)
-                                (IsLoset.is-trans loset)
-                                (IsLoset.is-asym loset)
+  isLoset→isStrictOrder : IsLoset R → IsStrictOrder R
+  isLoset→isStrictOrder loset = isstrictorder
+                          (IsLoset.is-set loset)
+                          (IsLoset.is-prop-valued loset)
+                          (IsLoset.is-irrefl loset)
+                          (IsLoset.is-trans loset)
+                          (IsLoset.is-asym loset)
+                          (IsLoset.is-weakly-linear loset)
 
   private
     transrefl : isTrans R → isTrans (ReflClosure R)
@@ -49,8 +51,8 @@ module _
     antisym irr trans a b (inl _) (inr b≡a) = sym b≡a
     antisym irr trans a b (inr a≡b) _ = a≡b
 
-  isLoset→isTosetReflClosure : Discrete A → IsLoset R → IsToset (ReflClosure R)
-  isLoset→isTosetReflClosure disc loset
+  isLoset→isTosetReflClosure : IsLoset R → isDecidable R → IsToset (ReflClosure R)
+  isLoset→isTosetReflClosure loset dec
     = istoset (IsLoset.is-set loset)
               (λ a b → isProp⊎ (IsLoset.is-prop-valued loset a b)
                                (IsLoset.is-set loset a b)
@@ -61,9 +63,33 @@ module _
               (transrefl (IsLoset.is-trans loset))
               (antisym (IsLoset.is-irrefl loset)
                        (IsLoset.is-trans loset))
-              λ a b → decRec (λ a≡b → ∣ inl (inr a≡b) ∣₁)
-                             (λ ¬a≡b → ∥₁.map (⊎.map (λ Rab → inl Rab) λ Rba → inl Rba)
-                             (IsLoset.is-connected loset a b ¬a≡b)) (disc a b)
+               λ a b → decRec (λ Rab → ∣ inl (inl Rab) ∣₁)
+                              (λ ¬Rab → decRec (λ Rba → ∣ inr (inl Rba) ∣₁)
+                                               (λ ¬Rba → ∣ inl (inr (IsLoset.is-connected loset a b
+                                                                    (¬Rab , ¬Rba))) ∣₁)
+                                        (dec b a))
+                       (dec a b)
+
+  isLosetDecidable→isTosetDecidable : IsLoset R → isDecidable R → isDecidable (ReflClosure R)
+  isLosetDecidable→isTosetDecidable los dec a b with dec a b
+  ... | yes Rab = yes (inl Rab)
+  ... | no ¬Rab with dec b a
+  ...       | yes Rba = no (⊎.rec ¬Rab λ a≡b → IsLoset.is-irrefl los b (subst (R b) a≡b Rba))
+  ...       | no ¬Rba = yes (inr (IsLoset.is-connected los a b (¬Rab , ¬Rba)))
+
+  isLosetDecidable→Discrete : IsLoset R → isDecidable R → Discrete A
+  isLosetDecidable→Discrete los dec = isTosetDecidable→Discrete
+                                     (isLoset→isTosetReflClosure los dec)
+                                     (isLosetDecidable→isTosetDecidable los dec)
+
+  isLoset→isPosetNegationRel : IsLoset R → IsPoset (NegationRel R)
+  isLoset→isPosetNegationRel loset
+    = isposet (IsLoset.is-set loset)
+              (λ a b → isProp¬ (R a b))
+              (IsLoset.is-irrefl loset)
+              (λ a b c ¬Rab ¬Rbc Rac → ∥₁.rec isProp⊥ (⊎.rec ¬Rab ¬Rbc)
+                                             (IsLoset.is-weakly-linear loset a c b Rac))
+               λ a b ¬Rab ¬Rba → IsLoset.is-connected loset a b (¬Rab , ¬Rba)
 
   isLosetInduced : IsLoset R → (B : Type ℓ'') → (f : B ↪ A)
                  → IsLoset (InducedRelation R (B , f))
@@ -74,18 +100,33 @@ module _
               (λ a b c → IsLoset.is-trans los (f a) (f b) (f c))
               (λ a b → IsLoset.is-asym los (f a) (f b))
               (λ a b c → IsLoset.is-weakly-linear los (f a) (f b) (f c))
-              λ a b ¬a≡b → IsLoset.is-connected los (f a) (f b)
-                λ fa≡fb → ¬a≡b (isEmbedding→Inj emb a b fa≡fb)
-
-Loset→StrictPoset : Loset ℓ ℓ' → StrictPoset ℓ ℓ'
-Loset→StrictPoset (_ , los)
-  = _ , strictposetstr (LosetStr._<_ los)
-                       (isLoset→isStrictPoset (LosetStr.isLoset los))
+               λ a b ineq → isEmbedding→Inj emb a b
+                           (IsLoset.is-connected los (f a) (f b) ineq)
+
+  isLosetDual : IsLoset R → IsLoset (Dual R)
+  isLosetDual los
+    = isloset (IsLoset.is-set los)
+              (λ a b → IsLoset.is-prop-valued los b a)
+              (IsLoset.is-irrefl los)
+              (λ a b c Rab Rbc → IsLoset.is-trans los c b a Rbc Rab)
+              (λ a b → IsLoset.is-asym los b a)
+              (λ a b c Rba → ∥₁.map (⊎.rec inr inl)
+                                    (IsLoset.is-weakly-linear los b a c Rba))
+               λ { a b (¬Rba , ¬Rab) → IsLoset.is-connected los a b (¬Rab , ¬Rba) }
+
+Loset→StrictOrder : Loset ℓ ℓ' → StrictOrder ℓ ℓ'
+Loset→StrictOrder (_ , los)
+  = strictorder _ (LosetStr._<_ los)
+                  (isLoset→isStrictOrder (LosetStr.isLoset los))
 
 Loset→Toset : (los : Loset ℓ ℓ')
-            → Discrete (fst los)
+            → BinaryRelation.isDecidable (LosetStr._<_ (snd los))
             → Toset ℓ (ℓ-max ℓ ℓ')
-Loset→Toset (_ , los) disc
-  = _ , tosetstr (BinaryRelation.ReflClosure (LosetStr._<_ los))
-                 (isLoset→isTosetReflClosure disc
-                                             (LosetStr.isLoset los))
+Loset→Toset (_ , los) dec
+  = toset _ (BinaryRelation.ReflClosure (LosetStr._<_ los))
+            (isLoset→isTosetReflClosure (LosetStr.isLoset los) dec)
+
+DualLoset : Loset ℓ ℓ' → Loset ℓ ℓ'
+DualLoset (_ , los)
+  = loset _ (BinaryRelation.Dual (LosetStr._<_ los))
+            (isLosetDual (LosetStr.isLoset los))
diff --git a/Cubical/Relation/Binary/Order/Poset/Base.agda b/Cubical/Relation/Binary/Order/Poset/Base.agda
index 8d6fddd9e4..35ae0fef5c 100644
--- a/Cubical/Relation/Binary/Order/Poset/Base.agda
+++ b/Cubical/Relation/Binary/Order/Poset/Base.agda
@@ -59,8 +59,8 @@ record PosetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')
 Poset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
 Poset ℓ ℓ' = TypeWithStr ℓ (PosetStr ℓ')
 
-poset : (A : Type ℓ) (_≤_ : A → A → Type ℓ') (h : IsPoset _≤_) → Poset ℓ ℓ'
-poset A _≤_ h = A , posetstr _≤_ h
+poset : (A : Type ℓ) → (_≤_ : Rel A A ℓ') → IsPoset _≤_ → Poset ℓ ℓ'
+poset A _≤_ pos = A , (posetstr _≤_ pos)
 
 record IsPosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
   (M : PosetStr ℓ₀' A) (e : A ≃ B) (N : PosetStr ℓ₁' B)
@@ -76,6 +76,12 @@ record IsPosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
   field
     pres≤ : (x y : A) → x M.≤ y ≃ equivFun e x N.≤ equivFun e y
 
+  -- This also holds in the other direction, which helps a lot in proofs
+  pres≤⁻ : (x y : B) → x N.≤ y ≃ invEq e x M.≤ invEq e y
+  pres≤⁻ x y = invEquiv (compEquiv (pres≤ (invEq e x) (invEq e y))
+                                    (subst2Equiv N._≤_ (secEq e x) (secEq e y)))
+
+unquoteDecl IsPosetEquivIsoΣ = declareRecordIsoΣ IsPosetEquivIsoΣ (quote IsPosetEquiv)
 
 PosetEquiv : (M : Poset ℓ₀ ℓ₀') (M : Poset ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
 PosetEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsPosetEquiv (M .snd) e (N .snd)
@@ -89,6 +95,16 @@ isPropIsPoset _≤_ = isOfHLevelRetractFromIso 1 IsPosetIsoΣ
                            (isPropΠ5 λ _ _ _ _ _ → isPropValued≤ _ _)
                              (isPropΠ4 λ _ _ _ _ → isSetA _ _))
 
+isPropIsPosetEquiv : {A : Type ℓ₀} {B : Type ℓ₁}
+                     (M : PosetStr ℓ₀' A)
+                     (e : A ≃ B)
+                     (N : PosetStr ℓ₁' B)
+                   → isProp (IsPosetEquiv M e N)
+isPropIsPosetEquiv M e N = isOfHLevelRetractFromIso 1 IsPosetEquivIsoΣ
+  (isPropΠ2 λ _ _ → isOfHLevel≃ 1
+                                (IsPoset.is-prop-valued (PosetStr.isPoset M) _ _)
+                                (IsPoset.is-prop-valued (PosetStr.isPoset N) _ _))
+
 𝒮ᴰ-Poset : DUARel (𝒮-Univ ℓ) (PosetStr ℓ') (ℓ-max ℓ ℓ')
 𝒮ᴰ-Poset =
   𝒮ᴰ-Record (𝒮-Univ _) IsPosetEquiv
diff --git a/Cubical/Relation/Binary/Order/Poset/Instances/Embedding.agda b/Cubical/Relation/Binary/Order/Poset/Instances/Embedding.agda
new file mode 100644
index 0000000000..648cc67fd4
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Poset/Instances/Embedding.agda
@@ -0,0 +1,145 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Poset.Instances.Embedding where
+
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Empty as ⊥
+
+open import Cubical.Functions.Embedding
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+open import Cubical.Relation.Binary.Order.Proset.Properties
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Poset.Properties
+
+private
+  variable
+    ℓ ℓ' : Level
+
+-- The collection of embeddings on a type happens to form a complete lattice
+
+-- First, we show that it's a poset
+isPoset⊆ₑ : {A : Type ℓ} → IsPoset {A = Embedding A ℓ'} _⊆ₑ_
+isPoset⊆ₑ = isposet isSetEmbedding
+                    isProp⊆ₑ
+                    isRefl⊆ₑ
+                    isTrans⊆ₑ
+                    isAntisym⊆ₑ
+
+EmbeddingPoset : (A : Type ℓ) (ℓ' : Level) → Poset _ _
+EmbeddingPoset A ℓ'
+  = poset (Embedding A ℓ') _⊆ₑ_ (isPoset⊆ₑ)
+
+-- Then we describe it as both a lattice and a complete lattice
+isMeet∩ₑ : {A : Type ℓ}
+           (X Y : Embedding A ℓ)
+         → isMeet (isPoset→isProset isPoset⊆ₑ) X Y (X ∩ₑ Y)
+isMeet∩ₑ X Y Z = propBiimpl→Equiv (isProp⊆ₑ Z (X ∩ₑ Y))
+                                  (isProp× (isProp⊆ₑ Z X)
+                                  (isProp⊆ₑ Z Y))
+                                  (λ Z⊆X∩Y →
+                                    (λ x x∈Z →
+                                       subst (_∈ₑ X)
+                                             (Z⊆X∩Y x x∈Z .snd)
+                                             (Z⊆X∩Y x x∈Z .fst .snd .fst)) ,
+                                    (λ x x∈Z →
+                                       subst (_∈ₑ Y)
+                                             (Z⊆X∩Y x x∈Z .snd)
+                                             (Z⊆X∩Y x x∈Z .fst .snd .snd)))
+                                   λ { (Z⊆X , Z⊆Y) x x∈Z →
+                                       (x , ((Z⊆X x x∈Z) ,
+                                             (Z⊆Y x x∈Z))) , refl }
+
+isMeetSemipseudolatticeEmbeddingPoset : {A : Type ℓ}
+                                      → isMeetSemipseudolattice (EmbeddingPoset A ℓ)
+isMeetSemipseudolatticeEmbeddingPoset X Y
+  = X ∩ₑ Y , isMeet∩ₑ X Y
+
+isGreatestEmbeddingPosetTotal : {A : Type ℓ}
+                              → isGreatest (isPoset→isProset isPoset⊆ₑ)
+                                           (Embedding A ℓ , id↪ (Embedding A ℓ))
+                                           (A , (id↪ A))
+isGreatestEmbeddingPosetTotal _ x _
+  = x , refl
+
+isMeetSemilatticeEmbeddingPoset : {A : Type ℓ}
+                                → isMeetSemilattice (EmbeddingPoset A ℓ)
+isMeetSemilatticeEmbeddingPoset {A = A}
+  = isMeetSemipseudolatticeEmbeddingPoset ,
+    (A , (id↪ A)) ,
+    isGreatestEmbeddingPosetTotal
+
+isJoin∪ₑ : {A : Type ℓ}
+           (X Y : Embedding A ℓ)
+         → isJoin (isPoset→isProset isPoset⊆ₑ) X Y (X ∪ₑ Y)
+isJoin∪ₑ X Y Z
+  = propBiimpl→Equiv (isProp⊆ₑ (X ∪ₑ Y) Z)
+                     (isProp× (isProp⊆ₑ X Z)
+                              (isProp⊆ₑ Y Z))
+                     (λ X∪Y⊆Z →
+                          (λ x x∈X → X∪Y⊆Z x ((x , ∣ inl x∈X ∣₁) , refl)) ,
+                          (λ x x∈Y → X∪Y⊆Z x ((x , ∣ inr x∈Y ∣₁) , refl)))
+                      λ { (X⊆Z , Y⊆Z) x x∈X∪Y →
+                          ∥₁.rec (isProp∈ₑ x Z)
+                                 (⊎.rec (λ a∈X → subst (_∈ₑ Z)
+                                                       (x∈X∪Y .snd)
+                                                       (X⊆Z _ a∈X))
+                                        (λ a∈Y → subst (_∈ₑ Z)
+                                                       (x∈X∪Y .snd)
+                                                       (Y⊆Z _ a∈Y)))
+                                 (x∈X∪Y .fst .snd) }
+
+isJoinSemipseudolatticeEmbeddingPoset : {A : Type ℓ}
+                                      → isJoinSemipseudolattice (EmbeddingPoset A ℓ)
+isJoinSemipseudolatticeEmbeddingPoset X Y
+  = X ∪ₑ Y , isJoin∪ₑ X Y
+
+isLeast∅ : {A : Type ℓ}
+         → isLeast (isPoset→isProset isPoset⊆ₑ) (Embedding A ℓ , id↪ (Embedding A ℓ)) ((Σ[ x ∈ A ] ⊥) , EmbeddingΣProp λ _ → isProp⊥)
+isLeast∅ _ _ ((_ , ()) , _)
+
+isJoinSemilatticeEmbeddingPoset : {A : Type ℓ}
+                                → isJoinSemilattice (EmbeddingPoset A ℓ)
+isJoinSemilatticeEmbeddingPoset {A = A}
+  = isJoinSemipseudolatticeEmbeddingPoset ,
+    ((Σ[ x ∈ A ] ⊥) , EmbeddingΣProp λ _ → isProp⊥) ,
+    isLeast∅
+
+isLatticeEmbeddingPoset : {A : Type ℓ}
+                        → isLattice (EmbeddingPoset A ℓ)
+isLatticeEmbeddingPoset = isMeetSemilatticeEmbeddingPoset ,
+                          isJoinSemilatticeEmbeddingPoset
+
+isInfimum⋂ₑ : {A : Type ℓ}
+               {I : Type ℓ}
+               (P : I → Embedding A ℓ)
+             → isInfimum (isPoset→isProset isPoset⊆ₑ) P (⋂ₑ P)
+fst (isInfimum⋂ₑ P) i y ((a , ∀i) , a≡y) = subst (_∈ₑ P i) a≡y (∀i i)
+snd (isInfimum⋂ₑ P) (X , lwr) y y∈X = (y , λ i → lwr i y y∈X) , refl
+
+isMeetCompleteSemipseudolatticeEmbeddingPoset : {A : Type ℓ}
+                                              → isMeetCompleteSemipseudolattice (EmbeddingPoset A ℓ)
+isMeetCompleteSemipseudolatticeEmbeddingPoset P
+  = (⋂ₑ P) , (isInfimum⋂ₑ P)
+
+isSupremum⋃ₑ : {A : Type ℓ}
+               {I : Type ℓ}
+               (P : I → Embedding A ℓ)
+              → isSupremum (isPoset→isProset isPoset⊆ₑ) P (⋃ₑ P)
+fst (isSupremum⋃ₑ P) i y y∈Pi = (y , ∣ i , y∈Pi ∣₁) , refl
+snd (isSupremum⋃ₑ P) (X , upr) y ((a , ∃i) , a≡y)
+  = ∥₁.rec (isProp∈ₑ y X) (λ (i , a∈Pi) → upr i y (subst (_∈ₑ P i) a≡y a∈Pi)) ∃i
+
+isJoinCompleteSemipseudolatticeEmbeddingPoset : {A : Type ℓ}
+                                              → isJoinCompleteSemipseudolattice (EmbeddingPoset A ℓ)
+isJoinCompleteSemipseudolatticeEmbeddingPoset P
+  = (⋃ₑ P) , (isSupremum⋃ₑ P)
+
+isCompleteLatticeEmbeddingPoset : {A : Type ℓ}
+                                → isCompleteLattice (EmbeddingPoset A ℓ)
+isCompleteLatticeEmbeddingPoset = isMeetCompleteSemipseudolatticeEmbeddingPoset ,
+                                  isJoinCompleteSemipseudolatticeEmbeddingPoset
diff --git a/Cubical/Relation/Binary/Order/Poset/Mappings.agda b/Cubical/Relation/Binary/Order/Poset/Mappings.agda
new file mode 100644
index 0000000000..161f366072
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Poset/Mappings.agda
@@ -0,0 +1,1228 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Poset.Mappings where
+
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Univalence
+
+open import Cubical.Algebra.Semigroup
+
+open import Cubical.Data.Sigma
+
+open import Cubical.Functions.Embedding
+open import Cubical.Functions.Image
+open import Cubical.Functions.Logic using (_⊔′_)
+open import Cubical.Functions.Preimage
+
+open import Cubical.Reflection.RecordEquiv
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+open import Cubical.HITs.SetQuotients
+
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Poset.Properties
+open import Cubical.Relation.Binary.Order.Poset.Subset
+open import Cubical.Relation.Binary.Order.Poset.Instances.Embedding
+open import Cubical.Relation.Binary.Order.Proset
+open import Cubical.Relation.Binary.Base
+
+
+private
+  variable
+    ℓ ℓ' ℓ'' ℓ''' ℓ₀ ℓ₀' ℓ₁ ℓ₁' ℓ₂ ℓ₂' : Level
+
+record IsIsotone {A : Type ℓ₀} {B : Type ℓ₁}
+  (M : PosetStr ℓ₀' A) (f : A → B) (N : PosetStr ℓ₁' B)
+  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
+  where
+  -- Shorter qualified names
+  private
+    module M = PosetStr M
+    module N = PosetStr N
+
+  field
+    pres≤ : (x y : A) → x M.≤ y → f x N.≤ f y
+
+unquoteDecl IsIsotoneIsoΣ = declareRecordIsoΣ IsIsotoneIsoΣ (quote IsIsotone)
+
+isPropIsIsotone : {A : Type ℓ₀} {B : Type ℓ₁}
+                  (M : PosetStr ℓ₀' A) (f : A → B) (N : PosetStr ℓ₁' B)
+                → isProp (IsIsotone M f N)
+isPropIsIsotone M f N = isOfHLevelRetractFromIso 1 IsIsotoneIsoΣ
+  (isPropΠ3 λ x y _ → IsPoset.is-prop-valued (PosetStr.isPoset N) (f x) (f y))
+
+IsIsotone-∘ : {A : Type ℓ₀} {B : Type ℓ₁} {C : Type ℓ₂}
+            → (M : PosetStr ℓ₀' A) (f : A → B)
+              (N : PosetStr ℓ₁' B) (g : B → C) (O : PosetStr ℓ₂' C)
+            → IsIsotone M f N
+            → IsIsotone N g O
+            → IsIsotone M (g ∘ f) O
+IsIsotone.pres≤ (IsIsotone-∘ M f N g O isf isg) x y x≤y
+  = IsIsotone.pres≤ isg (f x) (f y) (IsIsotone.pres≤ isf x y x≤y)
+
+record IsAntitone {A : Type ℓ₀} {B : Type ℓ₁}
+  (M : PosetStr ℓ₀' A) (f : A → B) (N : PosetStr ℓ₁' B)
+  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
+  where
+  constructor
+    isantitone
+  -- Shorter qualified names
+  private
+    module M = PosetStr M
+    module N = PosetStr N
+
+  field
+    inv≤ : (x y : A) → x M.≤ y → f y N.≤ f x
+
+unquoteDecl IsAntitoneIsoΣ = declareRecordIsoΣ IsAntitoneIsoΣ (quote IsAntitone)
+
+isPropIsAntitone : {A : Type ℓ₀} {B : Type ℓ₁}
+                   (M : PosetStr ℓ₀' A) (f : A → B) (N : PosetStr ℓ₁' B)
+                 → isProp (IsAntitone M f N)
+isPropIsAntitone M f N = isOfHLevelRetractFromIso 1 IsAntitoneIsoΣ
+  (isPropΠ3 λ x y _ → IsPoset.is-prop-valued (PosetStr.isPoset N) (f y) (f x))
+
+module _
+  (A : Poset ℓ₀ ℓ₀')
+  (B : Poset ℓ₁ ℓ₁')
+  (f : ⟨ A ⟩ → ⟨ B ⟩)
+  where
+
+    DualIsotone : IsIsotone (snd A) f (snd B)
+                → IsAntitone (snd (DualPoset A)) f (snd B)
+    IsAntitone.inv≤ (DualIsotone is) x y = IsIsotone.pres≤ is y x
+
+    DualIsotone' : IsIsotone (snd (DualPoset A)) f (snd B)
+                 → IsAntitone (snd A) f (snd B)
+    IsAntitone.inv≤ (DualIsotone' is) x y = IsIsotone.pres≤ is y x
+
+    IsotoneDual : IsIsotone (snd A) f (snd B)
+                → IsAntitone (snd A) f (snd (DualPoset B))
+    IsAntitone.inv≤ (IsotoneDual is) = IsIsotone.pres≤ is
+
+    IsotoneDual' : IsIsotone (snd A) f (snd (DualPoset B))
+                 → IsAntitone (snd A) f (snd B)
+    IsAntitone.inv≤ (IsotoneDual' is) = IsIsotone.pres≤ is
+
+    DualAntitone : IsAntitone (snd A) f (snd B)
+                 → IsIsotone (snd (DualPoset A)) f (snd B)
+    IsIsotone.pres≤ (DualAntitone is) x y = IsAntitone.inv≤ is y x
+
+    DualAntitone' : IsAntitone (snd (DualPoset A)) f (snd B)
+                  → IsIsotone (snd A) f (snd B)
+    IsIsotone.pres≤ (DualAntitone' is) x y = IsAntitone.inv≤ is y x
+
+    AntitoneDual : IsAntitone (snd A) f (snd B)
+                 → IsIsotone (snd A) f (snd (DualPoset B))
+    IsIsotone.pres≤ (AntitoneDual is) = IsAntitone.inv≤ is
+
+    AntitoneDual' : IsAntitone (snd A) f (snd (DualPoset B))
+                  → IsIsotone (snd A) f (snd B)
+    IsIsotone.pres≤ (AntitoneDual' is) = IsAntitone.inv≤ is
+
+    DualIsotoneDual : IsIsotone (snd A) f (snd B)
+                    → IsIsotone (snd (DualPoset A)) f (snd (DualPoset B))
+    IsIsotone.pres≤ (DualIsotoneDual is) x y = IsIsotone.pres≤ is y x
+
+    DualIsotoneDual' : IsIsotone (snd (DualPoset A)) f (snd (DualPoset B))
+                     → IsIsotone (snd A) f (snd B)
+    IsIsotone.pres≤ (DualIsotoneDual' is) x y = IsIsotone.pres≤ is y x
+
+    DualAntitoneDual : IsAntitone (snd A) f (snd B)
+                     → IsAntitone (snd (DualPoset A)) f (snd (DualPoset B))
+    IsAntitone.inv≤ (DualAntitoneDual is) x y = IsAntitone.inv≤ is y x
+
+    DualAntitoneDual' : IsAntitone (snd (DualPoset A)) f (snd (DualPoset B))
+                      → IsAntitone (snd A) f (snd B)
+    IsAntitone.inv≤ (DualAntitoneDual' is) x y = IsAntitone.inv≤ is y x
+
+IsPosetEquiv→IsIsotone : (P S : Poset ℓ ℓ')
+                         (e : ⟨ P ⟩ ≃ ⟨ S ⟩)
+                       → IsPosetEquiv (snd P) e (snd S)
+                       → IsIsotone (snd P) (equivFun e) (snd S)
+IsIsotone.pres≤ (IsPosetEquiv→IsIsotone P S e eq) x y = equivFun (IsPosetEquiv.pres≤ eq x y)
+
+-- Isotone maps are characterized by their actions on down-sets and up-sets
+module _
+  {P : Poset ℓ₀ ℓ₀'}
+  {S : Poset ℓ₁ ℓ₁'}
+  (f : ⟨ P ⟩ → ⟨ S ⟩)
+  where
+    private
+      isP = PosetStr.isPoset (snd P)
+      isS = PosetStr.isPoset (snd S)
+
+      _≤P_ = PosetStr._≤_ (snd P)
+      _≤S_ = PosetStr._≤_ (snd S)
+
+      propS = IsPoset.is-prop-valued isS
+      rflS = IsPoset.is-refl isS
+      transS = IsPoset.is-trans isS
+
+    IsIsotone→PreimagePrincipalDownsetIsDownset : IsIsotone (snd P) f (snd S)
+                                                → ∀ y → isDownset P (f ⃖ (principalDownset S y))
+    IsIsotone→PreimagePrincipalDownsetIsDownset is y (x , inPrex) z z≤x
+      = ∥₁.rec (isEmbedding→hasPropFibers (preimageInclusion f (principalDownset S y) .snd) z)
+               (λ { ((b , b≤y) , fibb) →
+                    (z , ∣ (f z , transS (f z) (f x) y
+                                         (IsIsotone.pres≤ is z x z≤x)
+                                         (subst (_≤S y) fibb b≤y)) ,
+                                          refl ∣₁) ,
+                     refl }) inPrex
+
+    IsIsotone→PreimagePrincipalUpsetIsUpset : IsIsotone (snd P) f (snd S)
+                                            → ∀ y → isUpset P (f ⃖ (principalUpset S y))
+    IsIsotone→PreimagePrincipalUpsetIsUpset is y (x , inPrex) z x≤z
+      = ∥₁.rec (isEmbedding→hasPropFibers (preimageInclusion f (principalUpset S y) .snd) z)
+               (λ { ((b , y≤b) , fibb) →
+                    (z , ∣ (f z , transS y (f x) (f z)
+                                        (subst (y ≤S_) fibb y≤b)
+                                        (IsIsotone.pres≤ is x z x≤z)) ,
+                                         refl ∣₁) ,
+                     refl }) inPrex
+
+    PreimagePrincipalDownsetIsDownset→IsIsotone : (∀ x → isDownset P (f ⃖ (principalDownset S x)))
+                                                → IsIsotone (snd P) f (snd S)
+    IsIsotone.pres≤ (PreimagePrincipalDownsetIsDownset→IsIsotone down) y x y≤x
+      = ∥₁.rec (propS _ _) (λ { ((b , b≤fx) , fibb) → subst (_≤S f x) (fibb ∙ cong f fiba) b≤fx }) pre
+        where fib = down (f x) (x , ∣ ((f x) , (rflS (f x))) , refl ∣₁) y y≤x
+
+              pre = fib .fst .snd
+              fiba = fib .snd
+
+    PreimagePrincipalUpsetIsUpset→IsIsotone : (∀ x → isUpset P (f ⃖ (principalUpset S x)))
+                                            → IsIsotone (snd P) f (snd S)
+    IsIsotone.pres≤ (PreimagePrincipalUpsetIsUpset→IsIsotone up) x y x≤y
+      = ∥₁.rec (propS _ _) (λ { ((b , fx≤b) , fibb) → subst (f x ≤S_) (fibb ∙ cong f fiba) fx≤b }) pre
+        where fib = up (f x) (x , ∣ ((f x) , (rflS (f x))) , refl ∣₁) y x≤y
+
+              pre = fib .fst .snd
+              fiba = fib .snd
+
+-- The next part requires our posets to operate over the same universes
+module _
+  (P S : Poset ℓ ℓ')
+  (f : ⟨ P ⟩ → ⟨ S ⟩)
+  where
+    private
+      isP = PosetStr.isPoset (snd P)
+      isS = PosetStr.isPoset (snd S)
+
+      _≤P_ = PosetStr._≤_ (snd P)
+      _≤S_ = PosetStr._≤_ (snd S)
+
+      propP = IsPoset.is-prop-valued isP
+      rflP = IsPoset.is-refl isP
+      antiP = IsPoset.is-antisym isP
+      transP = IsPoset.is-trans isP
+
+      propS = IsPoset.is-prop-valued isS
+      rflS = IsPoset.is-refl isS
+      antiS = IsPoset.is-antisym isS
+      transS = IsPoset.is-trans isS
+
+    -- We can now define the type of residuated maps
+    isResiduated : Type _
+    isResiduated = ∀ y → isPrincipalDownset P (f ⃖ (principalDownset S y))
+
+    hasResidual : Type (ℓ-max ℓ ℓ')
+    hasResidual = (IsIsotone (snd P) f (snd S)) ×
+                   (Σ[ g ∈ (⟨ S ⟩ → ⟨ P ⟩) ] (IsIsotone (snd S) g (snd P) ×
+                                             (∀ x → x ≤P (g ∘ f) x) ×
+                                             (∀ x → (f ∘ g) x ≤S x)))
+
+    isResiduated→hasResidual : isResiduated
+                             → hasResidual
+    isResiduated→hasResidual down = isotonef , g , isotoneg , g∘f , f∘g
+      where isotonef : IsIsotone (snd P) f (snd S)
+            isotonef = PreimagePrincipalDownsetIsDownset→IsIsotone f
+                       λ x → isPrincipalDownset→isDownset P (f ⃖ principalDownset S x) (down x)
+
+            isotonef⃖ : ∀ x y → x ≤S y → (f ⃖ (principalDownset S x)) ⊆ₑ (f ⃖ (principalDownset S y))
+            isotonef⃖ x y x≤y z ((a , pre) , fiba)
+              = ∥₁.rec (isProp∈ₑ z (f ⃖ principalDownset S y))
+                       (λ { ((b , b≤x) , fibb) → (a , ∣ (b , (transS b x y b≤x x≤y)) , fibb ∣₁) , fiba }) pre
+
+            g : ⟨ S ⟩ → ⟨ P ⟩
+            g x = down x .fst
+
+            isotoneg : IsIsotone (snd S) g (snd P)
+            IsIsotone.pres≤ isotoneg x y x≤y
+              = invEq
+                  (principalDownsetMembership P (g x) (g y))
+                  (subst
+                    (g x ∈ₑ_)
+                    (down y .snd)
+                    (isotonef⃖ x y x≤y (g x)
+                      (subst (g x ∈ₑ_)
+                        (sym (down x .snd))
+                        (equivFun (principalDownsetMembership P (g x) (g x)) (rflP (g x))))))
+
+            g∘f : ∀ x → x ≤P (g ∘ f) x
+            g∘f x = invEq (principalDownsetMembership P x (g (f x)))
+                          (subst (x ∈ₑ_) (down (f x) .snd)
+                                 ((x , ∣ ((f x) , (rflS (f x))) , refl ∣₁) , refl))
+
+            f∘g : ∀ y → (f ∘ g) y ≤S y
+            f∘g y = ∥₁.rec (propS _ _)
+                           (λ { ((a , a≤y) , fib) →
+                                subst (_≤S y) (fib ∙ cong f (gy∈pre .snd)) a≤y })
+                           (gy∈pre .fst .snd)
+              where gy∈pre : g y ∈ₑ (f ⃖ (principalDownset S y))
+                    gy∈pre = subst (g y ∈ₑ_) (sym (down y .snd))
+                                   (equivFun (principalDownsetMembership P (g y) (g y)) (rflP (g y)))
+
+    hasResidual→isResiduated : hasResidual
+                             → isResiduated
+    hasResidual→isResiduated (isf , g , isg , g∘f , f∘g) y
+      = (g y) , (equivFun (EmbeddingIP _ _)
+                ((λ x ((a , pre) , fiba) →
+                  ∥₁.rec (isProp∈ₑ x (principalDownset P (g y)))
+                                     (λ { ((b , b≤y) , fibb) →
+                                          equivFun (principalDownsetMembership P x (g y))
+                                                   (transP x (g (f x)) (g y) (g∘f x)
+                                                     (IsIsotone.pres≤ isg (f x) y
+                                                       (subst (_≤S y)
+                                                         (fibb ∙ cong f fiba) b≤y))) }) pre) ,
+                  λ x x∈g → (x , ∣ ((f x) ,
+                                   (transS (f x) (f (g y)) y
+                                     (IsIsotone.pres≤ isf x (g y)
+                                       (invEq (principalDownsetMembership P x (g y)) x∈g))
+                                     (f∘g y))) , refl ∣₁) , refl))
+
+    isPropIsResiduated : isProp isResiduated
+    isPropIsResiduated = isPropΠ λ _ → isPropIsPrincipalDownset P _
+
+    residualUnique : (p q : hasResidual)
+                   → p .snd .fst ≡ q .snd .fst
+    residualUnique (isf₀ , g  , isg  , g∘f  , f∘g)
+                   (isf₁ , g* , isg* , g*∘f , f∘g*)
+                   = funExt λ x → antiP (g x) (g* x) (g≤g* x) (g*≤g x)
+                   where g≤g* : ∀ x → g x ≤P g* x
+                         g≤g* x = transP (g x) ((g* ∘ f) (g x)) (g* x) (g*∘f (g x))
+                                          (IsIsotone.pres≤ isg* (f (g x)) x (f∘g x))
+
+                         g*≤g : ∀ x → g* x ≤P g x
+                         g*≤g x = transP (g* x) ((g ∘ f) (g* x)) (g x) (g∘f (g* x))
+                                         (IsIsotone.pres≤ isg (f (g* x)) x (f∘g* x))
+
+    isPropHasResidual : isProp hasResidual
+    isPropHasResidual p q = ≡-× (isPropIsIsotone _ f _ _ _)
+                                 (Σ≡Prop (λ g → isProp× (isPropIsIsotone _ g _)
+                                                (isProp× (isPropΠ (λ x → propP x (g (f x))))
+                                                         (isPropΠ λ x → propS (f (g x)) x)))
+                                          (residualUnique p q))
+
+    residual : hasResidual → ⟨ S ⟩ → ⟨ P ⟩
+    residual (_ , g , _) = g
+
+    AbsorbResidual : (res : hasResidual)
+                   → f ∘ (residual res) ∘ f ≡ f
+    AbsorbResidual (isf , f⁺ , _ , f⁺∘f , f∘f⁺)
+      = funExt λ x → antiS ((f ∘ f⁺ ∘ f) x) (f x)
+                           (f∘f⁺ (f x))
+                           (IsIsotone.pres≤ isf x (f⁺ (f x)) (f⁺∘f x))
+
+    ResidualAbsorb : (res : hasResidual)
+                   → (residual res) ∘ f ∘ (residual res) ≡ (residual res)
+    ResidualAbsorb (_ , f⁺ , isf⁺ , f⁺∘f , f∘f⁺)
+      = funExt λ x → antiP ((f⁺ ∘ f ∘ f⁺) x) (f⁺ x)
+                           (IsIsotone.pres≤ isf⁺ (f (f⁺ x)) x (f∘f⁺ x))
+                           (f⁺∘f (f⁺ x))
+
+isResidual : (P S : Poset ℓ ℓ')
+           → (f⁺ : ⟨ S ⟩ → ⟨ P ⟩)
+           → Type (ℓ-max ℓ ℓ')
+isResidual P S f⁺ = Σ[ f ∈ (⟨ P ⟩ → ⟨ S ⟩) ] (Σ[ res ∈ hasResidual P S f ] f⁺ ≡ residual P S f res)
+
+isResidualOfUnique : (P S : Poset ℓ ℓ')
+                   → (f⁺ : ⟨ S ⟩ → ⟨ P ⟩)
+                   → (p q : isResidual P S f⁺)
+                   → p .fst ≡ q .fst
+isResidualOfUnique P S h (f , (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺) , h≡f⁺)
+                         (g , (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺) , h≡g⁺)
+                   = funExt λ x → anti (f x) (g x)
+                                 (trans (f x) (f (f⁺ (g x))) (g x)
+                                        (IsIsotone.pres≤ isf x (f⁺ (g x))
+                                          (subst (x ≤_) (sym (p (g x))) (g⁺∘g x)))
+                                        (f∘f⁺ (g x)))
+                                  (trans (g x) (g (g⁺ (f x))) (f x)
+                                         (IsIsotone.pres≤ isg x (g⁺ (f x))
+                                           (subst (x ≤_) (p (f x)) (f⁺∘f x)))
+                                         (g∘g⁺ (f x)))
+                   where _≤_ = PosetStr._≤_ (snd P)
+                         anti = IsPoset.is-antisym (PosetStr.isPoset (snd S))
+                         trans = IsPoset.is-trans (PosetStr.isPoset (snd S))
+                         p = funExt⁻ ((sym h≡f⁺) ∙ h≡g⁺)
+
+isPropIsResidual : (P S : Poset ℓ ℓ')
+                 → (f⁺ : ⟨ S ⟩ → ⟨ P ⟩)
+                 → isProp (isResidual P S f⁺)
+isPropIsResidual P S f⁺ p q
+  = Σ≡Prop (λ f → isPropΣ (isPropHasResidual P S f)
+                            λ _ → isSet→ (IsPoset.is-set (PosetStr.isPoset (snd P))) _ _)
+                           (isResidualOfUnique P S f⁺ p q)
+
+hasResidual-∘ : (E F G : Poset ℓ ℓ')
+              → (f : ⟨ E ⟩ → ⟨ F ⟩)
+              → (g : ⟨ F ⟩ → ⟨ G ⟩)
+              → hasResidual E F f
+              → hasResidual F G g
+              → hasResidual E G (g ∘ f)
+hasResidual-∘ E F G f g (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺) (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺)
+  = is , f⁺ ∘ g⁺ , is⁺ , ⁺∘ , ∘⁺
+  where _≤E_ = PosetStr._≤_ (snd E)
+        _≤G_ = PosetStr._≤_ (snd G)
+
+        transE = IsPoset.is-trans (PosetStr.isPoset (snd E))
+        transG = IsPoset.is-trans (PosetStr.isPoset (snd G))
+
+        is : IsIsotone (snd E) (g ∘ f) (snd G)
+        is = IsIsotone-∘ (snd E) f (snd F) g (snd G) isf isg
+
+        is⁺ : IsIsotone (snd G) (f⁺ ∘ g⁺) (snd E)
+        is⁺ = IsIsotone-∘ (snd G) g⁺ (snd F) f⁺ (snd E) isg⁺ isf⁺
+
+        ⁺∘ : ∀ x → x ≤E ((f⁺ ∘ g⁺) ∘ (g ∘ f)) x
+        ⁺∘ x = transE x ((f⁺ ∘ f) x) (((f⁺ ∘ g⁺) ∘ g ∘ f) x)
+                      (f⁺∘f x)
+                      (IsIsotone.pres≤ isf⁺ (f x) (g⁺ (g (f x))) (g⁺∘g (f x)))
+
+        ∘⁺ : ∀ x → ((g ∘ f) ∘ (f⁺ ∘ g⁺)) x ≤G x
+        ∘⁺ x = transG (((g ∘ f) ∘ f⁺ ∘ g⁺) x) ((g ∘ g⁺) x) x
+                      (IsIsotone.pres≤ isg (f (f⁺ (g⁺ x))) (g⁺ x) (f∘f⁺ (g⁺ x)))
+                      (g∘g⁺ x)
+
+isResidual-∘ : (E F G : Poset ℓ ℓ')
+             → (f⁺ : ⟨ F ⟩ → ⟨ E ⟩)
+             → (g⁺ : ⟨ G ⟩ → ⟨ F ⟩)
+             → isResidual E F f⁺
+             → isResidual F G g⁺
+             → isResidual E G (f⁺ ∘ g⁺)
+isResidual-∘ E F G f⁺ g⁺ (f , resf , f⁺≡f*)
+                         (g , resg , g⁺≡g*)
+             = (g ∘ f) ,
+               (hasResidual-∘ E F G f g resf resg) ,
+               (funExt (λ x → cong f⁺ (funExt⁻ g⁺≡g* x) ∙ funExt⁻ f⁺≡f* _))
+
+EqualResidual→Involution : (P : Poset ℓ ℓ')
+                         → (f : ⟨ P ⟩ → ⟨ P ⟩)
+                         → (res : hasResidual P P f)
+                         → f ≡ (residual P P f res)
+                         → f ∘ f ≡ idfun ⟨ P ⟩
+EqualResidual→Involution P f (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺) f≡f⁺
+  = funExt λ x → anti (f (f x)) x
+                      (subst (λ g → (f ∘ g) x ≤ x) (sym f≡f⁺) (f∘f⁺ x))
+                      (subst (λ g → x ≤ (g ∘ f) x) (sym f≡f⁺) (f⁺∘f x))
+  where pos = PosetStr.isPoset (snd P)
+        _≤_ = PosetStr._≤_ (snd P)
+        anti = IsPoset.is-antisym pos
+
+Involution→EqualResidual : (P : Poset ℓ ℓ')
+                         → (f : ⟨ P ⟩ → ⟨ P ⟩)
+                         → (res : hasResidual P P f)
+                         → f ∘ f ≡ idfun ⟨ P ⟩
+                         → f ≡ (residual P P f res)
+Involution→EqualResidual P f res inv
+  = sym (cong₂ (λ g h → g ∘ f⁺ ∘ h) (sym inv) (sym inv) ∙
+         cong (λ g → f ∘ g ∘ f) (AbsorbResidual P P f res) ∙
+         cong (f ∘_) inv)
+  where f⁺ = res .snd .fst
+
+Res : Poset ℓ ℓ' → Semigroup (ℓ-max ℓ ℓ')
+fst (Res E) = Σ[ f ∈ (⟨ E ⟩ → ⟨ E ⟩) ] hasResidual E E f
+SemigroupStr._·_ (snd (Res E)) (f , resf) (g , resg)
+  = (g ∘ f) , (hasResidual-∘ E E E f g resf resg)
+IsSemigroup.is-set (SemigroupStr.isSemigroup (snd (Res E)))
+  = isSetΣ (isSet→ (IsPoset.is-set (PosetStr.isPoset (snd E))))
+      λ f → isProp→isSet (isPropHasResidual E E f)
+IsSemigroup.·Assoc (SemigroupStr.isSemigroup (snd (Res E))) (f , _) (g , _) (h , _)
+  = Σ≡Prop (λ f → isPropHasResidual E E f) refl
+
+Res⁺ : Poset ℓ ℓ' → Semigroup (ℓ-max ℓ ℓ')
+fst (Res⁺ E) = Σ[ f⁺ ∈ (⟨ E ⟩ → ⟨ E ⟩) ] isResidual E E f⁺
+SemigroupStr._·_ (snd (Res⁺ E)) (f⁺ , isresf⁺) (g⁺ , isresg⁺)
+  = (f⁺ ∘ g⁺) , isResidual-∘ E E E f⁺ g⁺ isresf⁺ isresg⁺
+IsSemigroup.is-set (SemigroupStr.isSemigroup (snd (Res⁺ E)))
+  = isSetΣ (isSet→ (IsPoset.is-set (PosetStr.isPoset (snd E))))
+      λ f⁺ → isProp→isSet (isPropIsResidual E E f⁺)
+IsSemigroup.·Assoc (SemigroupStr.isSemigroup (snd (Res⁺ E))) (f⁺ , _) (g⁺ , _) (h⁺ , _)
+  = Σ≡Prop (λ f⁺ → isPropIsResidual E E f⁺) refl
+
+isClosure : (E : Poset ℓ ℓ')
+            (f : ⟨ E ⟩ → ⟨ E ⟩)
+          → Type (ℓ-max ℓ ℓ')
+isClosure E f = IsIsotone (snd E) f (snd E) × (f ≡ f ∘ f) × (∀ x → x ≤ f x)
+  where _≤_ = PosetStr._≤_ (snd E)
+
+isDualClosure : (E : Poset ℓ ℓ')
+                (f : ⟨ E ⟩ → ⟨ E ⟩)
+              → Type (ℓ-max ℓ ℓ')
+isDualClosure E f = IsIsotone (snd E) f (snd E) × (f ≡ f ∘ f) × (∀ x → f x ≤ x)
+  where _≤_ = PosetStr._≤_ (snd E)
+
+-- This can be made more succinct
+isClosure' : (E : Poset ℓ ℓ')
+             (f : ⟨ E ⟩ → ⟨ E ⟩)
+           → Type (ℓ-max ℓ ℓ')
+isClosure' E f = ∀ x y → x ≤ f y ≃ f x ≤ f y
+  where _≤_ = PosetStr._≤_ (snd E)
+
+isDualClosure' : (E : Poset ℓ ℓ')
+                 (f : ⟨ E ⟩ → ⟨ E ⟩)
+               → Type (ℓ-max ℓ ℓ')
+isDualClosure' E f = ∀ x y → f x ≤ y ≃ f x ≤ f y
+  where _≤_ = PosetStr._≤_ (snd E)
+
+isClosure→isClosure' : (E : Poset ℓ ℓ')
+                     → ∀ f
+                     → isClosure E f
+                     → isClosure' E f
+isClosure→isClosure' E f (isf , f≡f∘f , x≤fx) x y
+  = propBiimpl→Equiv (prop _ _) (prop _ _)
+                     (λ x≤fy → subst (f x ≤_) (sym (funExt⁻ f≡f∘f y))
+                                     (IsIsotone.pres≤ isf x (f y) x≤fy))
+                     (trans x (f x) (f y) (x≤fx x))
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        prop = IsPoset.is-prop-valued is
+        trans = IsPoset.is-trans is
+
+isDualClosure→isDualClosure' : (E : Poset ℓ ℓ')
+                             → ∀ f
+                             → isDualClosure E f
+                             → isDualClosure' E f
+isDualClosure→isDualClosure' E f (isf , f≡f∘f , fx≤x) x y
+  = propBiimpl→Equiv (prop _ _) (prop _ _)
+                     (λ fx≤y → subst (_≤ f y) (sym (funExt⁻ f≡f∘f x))
+                                     (IsIsotone.pres≤ isf (f x) y fx≤y))
+                      λ fx≤fy → trans (f x) (f y) y fx≤fy (fx≤x y)
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        prop = IsPoset.is-prop-valued is
+        trans = IsPoset.is-trans is
+
+isClosure'→isClosure : (E : Poset ℓ ℓ')
+                     → ∀ f
+                     → isClosure' E f
+                     → isClosure E f
+isClosure'→isClosure E f eq
+  = isf ,
+   (funExt λ x → anti (f x) (f (f x))
+                      (IsIsotone.pres≤ isf x (f x) (x≤fx x))
+                      (equivFun (eq (f x) x) (rfl (f x)))) ,
+    x≤fx
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        rfl = IsPoset.is-refl is
+        anti = IsPoset.is-antisym is
+        trans = IsPoset.is-trans is
+
+        x≤fx : ∀ x → x ≤ f x
+        x≤fx x = invEq (eq x x) (rfl (f x))
+
+        isf : IsIsotone (snd E) f (snd E)
+        IsIsotone.pres≤ isf x y x≤y
+          = equivFun (eq x y)
+                     (trans x y (f y) x≤y (x≤fx y))
+
+isDualClosure'→isDualClosure : (E : Poset ℓ ℓ')
+                             → ∀ f
+                             → isDualClosure' E f
+                             → isDualClosure E f
+isDualClosure'→isDualClosure E f eq
+  = isf ,
+    (funExt (λ x → anti (f x) (f (f x))
+                        (equivFun (eq x (f x)) (rfl (f x)))
+                        (IsIsotone.pres≤ isf (f x) x (fx≤x x)))) ,
+    fx≤x
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        rfl = IsPoset.is-refl is
+        anti = IsPoset.is-antisym is
+        trans = IsPoset.is-trans is
+
+        fx≤x : ∀ x → f x ≤ x
+        fx≤x x = invEq (eq x x) (rfl (f x))
+
+        isf : IsIsotone (snd E) f (snd E)
+        IsIsotone.pres≤ isf x y x≤y
+          = equivFun (eq x y)
+                     (trans (f x) x y (fx≤x x) x≤y)
+
+isClosure→ComposedResidual : {E : Poset ℓ ℓ'}
+                             {f : ⟨ E ⟩ → ⟨ E ⟩}
+                           → isClosure E f
+                           → Σ[ F ∈ Poset ℓ ℓ' ] (Σ[ g ∈ (⟨ E ⟩ → ⟨ F ⟩) ] (Σ[ res ∈ hasResidual E F g ] f ≡ (residual E F g res) ∘ g))
+isClosure→ComposedResidual {ℓ} {ℓ'} {E = E} {f = f} (isf , f≡f∘f , x≤fx) = F , ♮ , (is♮ , ♮⁺ , is♮⁺ , x≤fx , ♮∘♮⁺) , refl
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+        set = IsPoset.is-set is
+        prop = IsPoset.is-prop-valued is
+        rfl = IsPoset.is-refl is
+        anti = IsPoset.is-antisym is
+        trans = IsPoset.is-trans is
+
+        kerf : Rel ⟨ E ⟩ ⟨ E ⟩ ℓ
+        kerf x y = f x ≡ f y
+
+        F' = ⟨ E ⟩ / kerf
+
+        _⊑'_ : F' → F' → hProp _
+        _⊑'_ = fun
+          where
+            fun₀ : ⟨ E ⟩ → F' → hProp _
+            fst (fun₀ x [ y ]) = f x ≤ f y
+            snd (fun₀ x [ y ]) = prop (f x) (f y)
+            fun₀ x (eq/ a b fa≡fb i) = record
+              { fst = cong (f x ≤_) fa≡fb i
+              ; snd = isProp→PathP (λ i → isPropIsProp {A = cong (f x ≤_) fa≡fb i})
+                                   (prop (f x) (f a)) (prop (f x) (f b)) i
+              }
+            fun₀ x (squash/ a b p q i j) = isSet→SquareP (λ _ _ → isSetHProp)
+              (λ _ → fun₀ x a)
+              (λ _ → fun₀ x b)
+              (λ i → fun₀ x (p i))
+              (λ i → fun₀ x (q i)) j i
+
+            toPath : ∀ a b (p : kerf a b) (y : F') → fun₀ a y ≡ fun₀ b y
+            toPath a b fa≡fb = elimProp (λ _ → isSetHProp _ _) λ c →
+              Σ≡Prop (λ _ → isPropIsProp) (cong (_≤ f c) fa≡fb)
+
+            fun : F' → F' → hProp _
+            fun [ a ] y = fun₀ a y
+            fun (eq/ a b fa≡fb i) y = toPath a b fa≡fb y i
+            fun (squash/ x y p q i j) z = isSet→SquareP (λ _ _ → isSetHProp)
+              (λ _ → fun x z) (λ _ → fun y z) (λ i → fun (p i) z) (λ i → fun (q i) z) j i
+
+        _⊑_ : Rel F' F' ℓ'
+        a ⊑ b = (a ⊑' b) .fst
+
+        open BinaryRelation _⊑_
+
+        isProp⊑ : isPropValued
+        isProp⊑ a b = (a ⊑' b) .snd
+
+        isRefl⊑ : isRefl
+        isRefl⊑ = elimProp (λ x → isProp⊑ x x)
+                           (rfl ∘ f)
+
+        isAntisym⊑ : isAntisym
+        isAntisym⊑ = elimProp2 (λ x y → isPropΠ2 λ _ _ → squash/ x y)
+                                λ a b fa≤fb fb≤fa → eq/ a b (anti (f a) (f b) fa≤fb fb≤fa)
+
+        isTrans⊑ : isTrans
+        isTrans⊑ = elimProp3 (λ x _ z → isPropΠ2 λ _ _ → isProp⊑ x z)
+                              λ a b c → trans (f a) (f b) (f c)
+
+        poset⊑ : IsPoset _⊑_
+        poset⊑ = isposet squash/ isProp⊑ isRefl⊑ isTrans⊑ isAntisym⊑
+
+        F : Poset ℓ ℓ'
+        F = F' , (posetstr _⊑_ poset⊑)
+
+        ♮ : ⟨ E ⟩ → ⟨ F ⟩
+        ♮ = [_]
+
+        is♮ : IsIsotone (snd E) ♮ (snd F)
+        IsIsotone.pres≤ is♮ x y x≤y = IsIsotone.pres≤ isf x y x≤y
+
+        ♮⁺ : ⟨ F ⟩ → ⟨ E ⟩
+        ♮⁺ [ x ] = f x
+        ♮⁺ (eq/ a b fa≡fb i) = fa≡fb i
+        ♮⁺ (squash/ x y p q i j) = isSet→SquareP (λ _ _ → set)
+          (λ _ → ♮⁺ x)
+          (λ _ → ♮⁺ y)
+          (λ i → ♮⁺ (p i))
+          (λ i → ♮⁺ (q i)) j i
+
+        is♮⁺ : IsIsotone (snd F) ♮⁺ (snd E)
+        IsIsotone.pres≤ is♮⁺ = elimProp2 (λ x y → isPropΠ λ _ → prop (♮⁺ x) (♮⁺ y))
+                                          λ x y fx≤fy → fx≤fy
+
+        ♮∘♮⁺ : ∀ x → (♮ ∘ ♮⁺) x ⊑ x
+        ♮∘♮⁺ = elimProp (λ x → isProp⊑ ((♮ ∘ ♮⁺) x) x)
+                        λ x → subst (_≤ f x) (funExt⁻ f≡f∘f x) (rfl (f x))
+
+isDualClosure→ComposedResidual : {E : Poset ℓ ℓ'}
+                                 {f : ⟨ E ⟩ → ⟨ E ⟩}
+                               → isDualClosure E f
+                               → Σ[ F ∈ Poset ℓ ℓ' ] (Σ[ g ∈ (⟨ F ⟩ → ⟨ E ⟩) ] (Σ[ res ∈ hasResidual F E g ] f ≡ g ∘ (residual F E g res)))
+isDualClosure→ComposedResidual {ℓ} {ℓ'} {E = E} {f = f} (isf , f≡f∘f , fx≤x) = F , ♮ , (is♮ , ♮⁺ , is♮⁺ , ♮⁺∘♮ , fx≤x) , refl
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+        set = IsPoset.is-set is
+        prop = IsPoset.is-prop-valued is
+        rfl = IsPoset.is-refl is
+        anti = IsPoset.is-antisym is
+        trans = IsPoset.is-trans is
+
+        kerf : Rel ⟨ E ⟩ ⟨ E ⟩ ℓ
+        kerf x y = f x ≡ f y
+
+        F' = ⟨ E ⟩ / kerf
+
+        _⊑'_ : F' → F' → hProp _
+        _⊑'_ = fun
+          where
+            fun₀ : ⟨ E ⟩ → F' → hProp _
+            fst (fun₀ x [ y ]) = f x ≤ f y
+            snd (fun₀ x [ y ]) = prop (f x) (f y)
+            fun₀ x (eq/ a b fa≡fb i) = record
+              { fst = cong (f x ≤_) fa≡fb i
+              ; snd = isProp→PathP (λ i → isPropIsProp {A = cong (f x ≤_) fa≡fb i})
+                                   (prop (f x) (f a)) (prop (f x) (f b)) i
+              }
+            fun₀ x (squash/ a b p q i j) = isSet→SquareP (λ _ _ → isSetHProp)
+              (λ _ → fun₀ x a)
+              (λ _ → fun₀ x b)
+              (λ i → fun₀ x (p i))
+              (λ i → fun₀ x (q i)) j i
+
+            toPath : ∀ a b (p : kerf a b) (y : F') → fun₀ a y ≡ fun₀ b y
+            toPath a b fa≡fb = elimProp (λ _ → isSetHProp _ _) λ c →
+              Σ≡Prop (λ _ → isPropIsProp) (cong (_≤ f c) fa≡fb)
+
+            fun : F' → F' → hProp _
+            fun [ a ] y = fun₀ a y
+            fun (eq/ a b fa≡fb i) y = toPath a b fa≡fb y i
+            fun (squash/ x y p q i j) z = isSet→SquareP (λ _ _ → isSetHProp)
+              (λ _ → fun x z) (λ _ → fun y z) (λ i → fun (p i) z) (λ i → fun (q i) z) j i
+
+        _⊑_ : Rel F' F' ℓ'
+        a ⊑ b = (a ⊑' b) .fst
+
+        open BinaryRelation _⊑_
+
+        isProp⊑ : isPropValued
+        isProp⊑ a b = (a ⊑' b) .snd
+
+        isRefl⊑ : isRefl
+        isRefl⊑ = elimProp (λ x → isProp⊑ x x)
+                           (rfl ∘ f)
+
+        isAntisym⊑ : isAntisym
+        isAntisym⊑ = elimProp2 (λ x y → isPropΠ2 λ _ _ → squash/ x y)
+                                λ a b fa≤fb fb≤fa → eq/ a b (anti (f a) (f b) fa≤fb fb≤fa)
+
+        isTrans⊑ : isTrans
+        isTrans⊑ = elimProp3 (λ x _ z → isPropΠ2 λ _ _ → isProp⊑ x z)
+                              λ a b c → trans (f a) (f b) (f c)
+
+        poset⊑ : IsPoset _⊑_
+        poset⊑ = isposet squash/ isProp⊑ isRefl⊑ isTrans⊑ isAntisym⊑
+
+        F : Poset ℓ ℓ'
+        F = F' , (posetstr _⊑_ poset⊑)
+
+        ♮⁺ : ⟨ E ⟩ → ⟨ F ⟩
+        ♮⁺ = [_]
+
+        is♮⁺ : IsIsotone (snd E) ♮⁺ (snd F)
+        IsIsotone.pres≤ is♮⁺ x y x≤y = IsIsotone.pres≤ isf x y x≤y
+
+        ♮ : ⟨ F ⟩ → ⟨ E ⟩
+        ♮ [ x ] = f x
+        ♮ (eq/ a b fa≡fb i) = fa≡fb i
+        ♮ (squash/ x y p q i j) = isSet→SquareP (λ _ _ → set)
+          (λ _ → ♮ x)
+          (λ _ → ♮ y)
+          (λ i → ♮ (p i))
+          (λ i → ♮ (q i)) j i
+
+        is♮ : IsIsotone (snd F) ♮ (snd E)
+        IsIsotone.pres≤ is♮ = elimProp2 (λ x y → isPropΠ λ _ → prop (♮ x) (♮ y))
+                                         λ x y fx≤fy → fx≤fy
+
+        ♮⁺∘♮ : ∀ x → x ⊑ (♮⁺ ∘ ♮) x
+        ♮⁺∘♮ = elimProp (λ x → isProp⊑ x ((♮⁺ ∘ ♮) x))
+                        λ x → subst (f x ≤_) (funExt⁻ f≡f∘f x) (rfl (f x))
+
+ComposedResidual→isClosure : {E : Poset ℓ ℓ'}
+                             {f : ⟨ E ⟩ → ⟨ E ⟩}
+                           → Σ[ F ∈ Poset ℓ ℓ' ] (Σ[ g ∈ (⟨ E ⟩ → ⟨ F ⟩) ] (Σ[ res ∈ hasResidual E F g ] f ≡ (residual E F g res) ∘ g))
+                           → isClosure E f
+ComposedResidual→isClosure {E = E} {f = f} (F , g , (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺) , f≡g⁺∘g)
+  = subst (λ x → IsIsotone (snd E) x (snd E)) (sym f≡g⁺∘g) (IsIsotone-∘ (snd E) g (snd F) g⁺ (snd E) isg isg⁺) ,
+    f≡g⁺∘g ∙
+    sym (cong (g⁺ ∘_)
+              (AbsorbResidual E F g (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺))) ∙
+    cong (_∘ g⁺ ∘ g) (sym f≡g⁺∘g) ∙
+    cong (f ∘_) (sym f≡g⁺∘g) ,
+    λ x → subst (x ≤_) (sym (funExt⁻ f≡g⁺∘g x)) (g⁺∘g x)
+    where _≤_ = PosetStr._≤_ (snd E)
+
+ComposedResidual→isDualClosure : {E : Poset ℓ ℓ'}
+                                 {f : ⟨ E ⟩ → ⟨ E ⟩}
+                               → Σ[ F ∈ Poset ℓ ℓ' ] (Σ[ g ∈ (⟨ F ⟩ → ⟨ E ⟩) ] (Σ[ res ∈ hasResidual F E g ] f ≡ g ∘ (residual F E g res)))
+                               → isDualClosure E f
+ComposedResidual→isDualClosure {E = E} {f = f} (F , g , (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺) , f≡g∘g⁺)
+  = subst (λ x → IsIsotone (snd E) x (snd E)) (sym f≡g∘g⁺) (IsIsotone-∘ (snd E) g⁺ (snd F) g (snd E) isg⁺ isg) ,
+  f≡g∘g⁺ ∙
+  sym (cong (g ∘_) (ResidualAbsorb F E g (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺))) ∙
+  cong (_∘ g ∘ g⁺) (sym f≡g∘g⁺) ∙
+  cong (f ∘_) (sym f≡g∘g⁺) ,
+  λ x → subst (_≤ x) (sym (funExt⁻ f≡g∘g⁺ x)) (g∘g⁺ x)
+  where _≤_ = PosetStr._≤_ (snd E)
+
+isPropIsClosure : {E : Poset ℓ ℓ'}
+                  {f : ⟨ E ⟩ → ⟨ E ⟩}
+                → isProp (isClosure E f)
+isPropIsClosure {E = E} {f = f}
+  = isProp× (isPropIsIsotone (snd E) f (snd E))
+            (isProp× (isSet→ (IsPoset.is-set is) _ _)
+                     (isPropΠ λ x → IsPoset.is-prop-valued is x (f x)))
+  where is = PosetStr.isPoset (snd E)
+
+isPropIsClosure' : {E : Poset ℓ ℓ'}
+                   {f : ⟨ E ⟩ → ⟨ E ⟩}
+                 → isProp (isClosure' E f)
+isPropIsClosure' {E = E} {f = f}
+  = isPropΠ2 λ x y → isOfHLevel≃ 1 (prop x (f y)) (prop (f x) (f y))
+  where prop = IsPoset.is-prop-valued (PosetStr.isPoset (snd E))
+
+isPropIsDualClosure : {E : Poset ℓ ℓ'}
+                      {f : ⟨ E ⟩ → ⟨ E ⟩}
+                    → isProp (isDualClosure E f)
+isPropIsDualClosure {E = E} {f = f}
+  = isProp× (isPropIsIsotone (snd E) f (snd E))
+            (isProp× (isSet→ (IsPoset.is-set is) _ _)
+                     (isPropΠ λ x → IsPoset.is-prop-valued is (f x) x))
+  where is = PosetStr.isPoset (snd E)
+
+isPropIsDualClosure' : {E : Poset ℓ ℓ'}
+                       {f : ⟨ E ⟩ → ⟨ E ⟩}
+                     → isProp (isDualClosure' E f)
+isPropIsDualClosure' {E = E} {f = f}
+  = isPropΠ2 λ x y → isOfHLevel≃ 1 (prop (f x) y) (prop (f x) (f y))
+  where prop = IsPoset.is-prop-valued (PosetStr.isPoset (snd E))
+
+isClosureSubset : (E : Poset ℓ ℓ')
+                → (F : Embedding ⟨ E ⟩ ℓ)
+                → Type _
+isClosureSubset E F = Σ[ f ∈ (⟨ E ⟩ → ⟨ E ⟩) ] (isClosure E f × (F ≡ (Image f , imageInclusion f)))
+
+isDualClosureSubset : (E : Poset ℓ ℓ')
+                    → (F : Embedding ⟨ E ⟩ ℓ)
+                    → Type _
+isDualClosureSubset E F = Σ[ f ∈ (⟨ E ⟩ → ⟨ E ⟩) ] (isDualClosure E f × (F ≡ (Image f , imageInclusion f)))
+
+ClosureSubsetOperatorUnique : {E : Poset ℓ ℓ'}
+                              {F : Embedding ⟨ E ⟩ ℓ}
+                            → (f g : isClosureSubset E F)
+                            → f .fst ≡ g .fst
+ClosureSubsetOperatorUnique {E = E} {F = F}
+                            (f , (isf , f≡f∘f , x≤fx) , F≡Imf)
+                            (g , (isg , g≡g∘g , x≤gx) , F≡Img)
+  = funExt λ x → anti (f x) (g x) (fx≤gx x) (gx≤fx x)
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        prop = IsPoset.is-prop-valued is
+        anti = IsPoset.is-antisym is
+
+        Imf⊆Img : (Image f , imageInclusion f) ⊆ₑ (Image g , imageInclusion g)
+        Imf⊆Img x = subst (x ∈ₑ_) (sym F≡Imf ∙ F≡Img)
+
+        Img⊆Imf : (Image g , imageInclusion g) ⊆ₑ (Image f , imageInclusion f)
+        Img⊆Imf x = subst (x ∈ₑ_) (sym F≡Img ∙ F≡Imf)
+
+        fx≤gx : ∀ x → f x ≤ g x
+        fx≤gx x = ∥₁.rec (prop (f x) (g x))
+                          (λ { (a , fa≡gx) → subst (f x ≤_)
+                                               (sym (funExt⁻ f≡f∘f a) ∙
+                                                fa≡gx ∙
+                                                lemma .snd)
+                                               (IsIsotone.pres≤ isf x (f a)
+                                                (subst (x ≤_)
+                                                  (sym (fa≡gx ∙ lemma .snd))
+                                                    (x≤gx x))) })
+                          (lemma .fst .snd)
+              where lemma = Img⊆Imf (g x) (((g x) , ∣ x , refl ∣₁) , refl)
+
+        gx≤fx : ∀ x → g x ≤ f x
+        gx≤fx x = ∥₁.rec (prop (g x) (f x))
+                         (λ { (a , ga≡fx) → subst (g x ≤_)
+                                              (sym (funExt⁻ g≡g∘g a) ∙
+                                                    ga≡fx ∙
+                                                    lemma .snd)
+                                              (IsIsotone.pres≤ isg x (g a)
+                                               (subst (x ≤_)
+                                                 (sym (ga≡fx ∙ lemma .snd))
+                                                   (x≤fx x))) })
+                         (lemma .fst .snd)
+              where lemma = Imf⊆Img (f x) (((f x) , ∣ x , refl ∣₁) , refl)
+
+DualClosureSubsetOperatorUnique : {E : Poset ℓ ℓ'}
+                                  {F : Embedding ⟨ E ⟩ ℓ}
+                                → (f g : isDualClosureSubset E F)
+                                → f .fst ≡ g .fst
+DualClosureSubsetOperatorUnique {E = E} {F = F}
+                                (f , (isf , f≡f∘f , fx≤x) , F≡Imf)
+                                (g , (isg , g≡g∘g , gx≤x) , F≡Img)
+  = funExt λ x → anti (f x) (g x) (fx≤gx x) (gx≤fx x)
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        prop = IsPoset.is-prop-valued is
+        anti = IsPoset.is-antisym is
+
+        Imf⊆Img : (Image f , imageInclusion f) ⊆ₑ (Image g , imageInclusion g)
+        Imf⊆Img x = subst (x ∈ₑ_) (sym F≡Imf ∙ F≡Img)
+
+        Img⊆Imf : (Image g , imageInclusion g) ⊆ₑ (Image f , imageInclusion f)
+        Img⊆Imf x = subst (x ∈ₑ_) (sym F≡Img ∙ F≡Imf)
+
+        gx≤fx : ∀ x → g x ≤ f x
+        gx≤fx x = ∥₁.rec (prop (g x) (f x))
+                         (λ { (a , fa≡gx) → subst (_≤ f x) (sym (funExt⁻ f≡f∘f a) ∙
+                                                                  fa≡gx ∙
+                                                                  lemma .snd)
+                                                            (IsIsotone.pres≤ isf (f a) x
+                                                             (subst (_≤ x)
+                                                               (sym (fa≡gx ∙ lemma .snd))
+                                                                 (gx≤x x))) })
+                         (lemma .fst .snd)
+              where lemma = Img⊆Imf (g x) (((g x) , ∣ x , refl ∣₁) , refl)
+
+        fx≤gx : ∀ x → f x ≤ g x
+        fx≤gx x = ∥₁.rec (prop (f x) (g x))
+                         (λ { (a , ga≡fx) → subst (_≤ g x)
+                                              (sym (funExt⁻ g≡g∘g a) ∙
+                                                    ga≡fx ∙
+                                                    lemma .snd)
+                                              (IsIsotone.pres≤ isg (g a) x
+                                                (subst (_≤ x)
+                                                  (sym (ga≡fx ∙ lemma .snd))
+                                                    (fx≤x x))) })
+                         (lemma .fst .snd)
+              where lemma = Imf⊆Img (f x) (((f x) , ∣ x , refl ∣₁) , refl)
+
+isPropIsClosureSubset : {E : Poset ℓ ℓ'}
+                        {F : Embedding ⟨ E ⟩ ℓ}
+                      → isProp (isClosureSubset E F)
+isPropIsClosureSubset p q = Σ≡Prop (λ f → isProp× isPropIsClosure (isSetEmbedding _ _))
+                                    (ClosureSubsetOperatorUnique p q)
+
+isPropIsDualClosureSubset : {E : Poset ℓ ℓ'}
+                            {F : Embedding ⟨ E ⟩ ℓ}
+                          → isProp (isDualClosureSubset E F)
+isPropIsDualClosureSubset p q = Σ≡Prop (λ f → isProp× isPropIsDualClosure (isSetEmbedding _ _))
+                                        (DualClosureSubsetOperatorUnique p q)
+
+isClosureSubset→IntersectionBottom : (E : Poset ℓ ℓ')
+                                     (F : Embedding ⟨ E ⟩ ℓ)
+                                   → isClosureSubset E F
+                                   → ∀ x
+                                   → Least (isPoset→isProset (PosetStr.isPoset (snd E))) (principalUpset E x ∩ₑ F)
+isClosureSubset→IntersectionBottom E F (f , (isf , f≡f∘f , x≤fx) , F≡Imf) x
+  = (f x , fx∈x↑ , fx∈F ) , least
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        prop = IsPoset.is-prop-valued is
+
+        fx∈x↑ : f x ∈ₑ principalUpset E x
+        fx∈x↑ = equivFun (principalUpsetMembership E x (f x)) (x≤fx x)
+
+        fx∈F : f x ∈ₑ F
+        fx∈F = subst (f x ∈ₑ_) (sym F≡Imf) ((f x , ∣ x , refl ∣₁) , refl)
+
+        least : isLeast (isPoset→isProset is) (principalUpset E x ∩ₑ F) (f x , fx∈x↑ , fx∈F)
+        least (y , y∈x↑ , y∈F) = ∥₁.rec (prop _ _)
+                                        (λ { (a , fa≡fz)
+                                           → subst (f x ≤_)
+                                            (sym (funExt⁻ f≡f∘f a ∙
+                                                 cong f (fa≡fz ∙
+                                                         lemma .snd)) ∙
+                                                 fa≡fz ∙
+                                                 lemma .snd)
+                                            (IsIsotone.pres≤ isf x y
+                                              (invEq (principalUpsetMembership E x y) y∈x↑)) })
+                                         (lemma .fst .snd)
+          where lemma = subst (y ∈ₑ_) F≡Imf y∈F
+
+IntersectionBottom→isClosureSubset : (E : Poset ℓ ℓ)
+                                     (F : Embedding ⟨ E ⟩ ℓ)
+                                   → (∀ x → Least (isPoset→isProset (PosetStr.isPoset (snd E))) (principalUpset E x ∩ₑ F))
+                                   → isClosureSubset E F
+IntersectionBottom→isClosureSubset E F least
+  = f , (isf , f≡f∘f , x≤f) , F≡Imf
+    where _≤_ = PosetStr._≤_ (snd E)
+          is = PosetStr.isPoset (snd E)
+
+          rfl = IsPoset.is-refl is
+          anti = IsPoset.is-antisym is
+
+          f : ⟨ E ⟩ → ⟨ E ⟩
+          f x = least x .fst .fst
+
+          isf : IsIsotone (snd E) f (snd E)
+          IsIsotone.pres≤ isf x y x≤y = least x .snd (f y , y↑∩F⊆x↑∩F (f y) ((least y .fst) , refl) .fst .snd)
+            where x↑ = principalUpset E x
+                  y↑ = principalUpset E y
+
+                  y↑⊆x↑ = principalUpsetInclusion E x y x≤y
+                  y↑∩F⊆x↑∩F = isMeetIsotone
+                              (isPoset→isProset isPoset⊆ₑ) y↑ x↑ F F
+                              (y↑ ∩ₑ F)
+                              (x↑ ∩ₑ F)
+                              (isMeet∩ₑ y↑ F)
+                              (isMeet∩ₑ x↑ F)
+                               y↑⊆x↑
+                              (isRefl⊆ₑ F)
+
+          x≤f : ∀ x → x ≤ f x
+          x≤f x = invEq (principalUpsetMembership E x (f x)) (least x .fst .snd .fst)
+
+          F≡fF : ∀ y → y ∈ₑ F
+                      → y ≡ f y
+          F≡fF y y∈F = anti y (f y) (x≤f y)
+                       (least y .snd (y , equivFun (principalUpsetMembership E y y) (rfl y) , y∈F))
+
+          f≡f∘f : f ≡ (f ∘ f)
+          f≡f∘f = funExt λ x → F≡fF (f x) (least x .fst .snd .snd)
+
+          F⊆Imf : F ⊆ₑ (Image f , imageInclusion f)
+          F⊆Imf x x∈F = (x , ∣ x , (sym (F≡fF x x∈F)) ∣₁) , refl
+
+          Imf⊆F : (Image f , imageInclusion f) ⊆ₑ F
+          Imf⊆F x ((a , ima) , fib)
+            = ∥₁.rec (isProp∈ₑ x F)
+                     (λ { (b , fb≡a) →
+                           subst (_∈ₑ F)
+                                 (fb≡a ∙ fib)
+                                 (least b .fst .snd .snd) }) ima
+
+          F≡Imf : F ≡ (Image f , imageInclusion f)
+          F≡Imf = isAntisym⊆ₑ F (Image f , imageInclusion f) F⊆Imf Imf⊆F
+
+isBicomplete : (E : Poset ℓ ℓ')
+               (F : Embedding ⟨ E ⟩ ℓ)
+             → Type _
+isBicomplete E F = isClosureSubset E F × isClosureSubset (DualPoset E) F
+
+isBicompleteResiduatedClosureImage : (E : Poset ℓ ℓ')
+                                     (f : ⟨ E ⟩ → ⟨ E ⟩)
+                                   → hasResidual E E f
+                                   → isClosure E f
+                                   → isBicomplete E (Image f , imageInclusion f)
+isBicompleteResiduatedClosureImage E f (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺) (_ , f≡f∘f , x≤fx)
+  = (f , clsf , refl) , f⁺ , clsf⁺ , Imf≡Imf⁺
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        anti = IsPoset.is-antisym is
+
+        resf = (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺)
+        clsf = (isf , f≡f∘f , x≤fx)
+
+        f≡f⁺∘f : f ≡ f⁺ ∘ f
+        f≡f⁺∘f = funExt λ x → anti (f x) ((f⁺ ∘ f) x) (f≤f⁺∘f x) (f⁺∘f≤f x)
+          where f≤f⁺∘f : ∀ x → f x ≤ (f⁺ ∘ f) x
+                f≤f⁺∘f x = subst (f x ≤_)
+                                 (cong f⁺ (sym (funExt⁻ f≡f∘f x))) (f⁺∘f (f x))
+
+                f⁺∘f≤f : ∀ x → (f⁺ ∘ f) x ≤ f x
+                f⁺∘f≤f x = subst ((f⁺ ∘ f) x ≤_)
+                                 (funExt⁻ (AbsorbResidual E E f resf) x)
+                                 (x≤fx ((f⁺ ∘ f) x))
+
+        f⁺≡f∘f⁺ : f⁺ ≡ f ∘ f⁺
+        f⁺≡f∘f⁺ = funExt λ x → sym (funExt⁻ (ResidualAbsorb E E f resf) x) ∙
+                               funExt⁻ (sym f≡f⁺∘f) (f⁺ x)
+
+        Imf⊆Imf⁺ : (Image f , imageInclusion f) ⊆ₑ (Image f⁺ , imageInclusion f⁺)
+        Imf⊆Imf⁺ x ((a , ima) , fib) = ∥₁.rec (isProp∈ₑ x (Image f⁺ , imageInclusion f⁺))
+                                              (λ { (b , fb≡a) → (x , ∣ x , (cong f⁺ (sym (fb≡a ∙ fib)) ∙
+                                                                            funExt⁻ (sym f≡f⁺∘f) b ∙
+                                                                            fb≡a ∙
+                                                                            fib) ∣₁) , refl })
+                                               ima
+
+        Imf⁺⊆Imf : (Image f⁺ , imageInclusion f⁺) ⊆ₑ (Image f , imageInclusion f)
+        Imf⁺⊆Imf x ((a , ima) , fib) = ∥₁.rec (isProp∈ₑ x (Image f , imageInclusion f))
+                                              (λ { (b , f⁺b≡a) → (x , ∣ x , (cong f (sym (f⁺b≡a ∙ fib)) ∙
+                                                                             funExt⁻ (sym f⁺≡f∘f⁺) b ∙
+                                                                             f⁺b≡a ∙
+                                                                             fib) ∣₁) , refl })
+                                               ima
+
+        Imf≡Imf⁺ : (Image f , imageInclusion f) ≡ (Image f⁺ , imageInclusion f⁺)
+        Imf≡Imf⁺ = isAntisym⊆ₑ _ _ Imf⊆Imf⁺ Imf⁺⊆Imf
+
+        clsf⁺ : isClosure (DualPoset E) f⁺
+        clsf⁺ = DualIsotoneDual E E f⁺ isf⁺ ,
+                f⁺≡f∘f⁺ ∙ cong (_∘ f⁺) f≡f⁺∘f ∙ cong (f⁺ ∘_) (sym f⁺≡f∘f⁺) ,
+                λ x → subst (_≤ x) (funExt⁻ (sym f⁺≡f∘f⁺) x) (f∘f⁺ x)
+
+isBicomplete→ClosureOperatorHasResidual : (E : Poset ℓ ℓ')
+                                          (F : Embedding ⟨ E ⟩ ℓ)
+                                        → (bi : isBicomplete E F)
+                                        → hasResidual E E (bi . fst .fst)
+isBicomplete→ClosureOperatorHasResidual E F ((f , (isf , f≡f∘f , x≤fx) , F≡Imf) ,
+                                              f⁺ , (isf⁺ , f⁺≡f⁺∘f⁺ , f⁺x≤x) , F≡Imf⁺)
+  = isf , f⁺ , DualIsotoneDual' E E f⁺ isf⁺ , f⁺∘f , f∘f⁺
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+        set = IsPoset.is-set is
+
+        Imf⁺⊆Imf : (Image f⁺ , imageInclusion f⁺) ⊆ₑ (Image f , imageInclusion f)
+        Imf⁺⊆Imf = subst (Imf⁺ ⊆ₑ_) ((sym F≡Imf⁺) ∙ F≡Imf) (isRefl⊆ₑ Imf⁺)
+          where Imf⁺ = (Image f⁺ , imageInclusion f⁺)
+
+        Imf⊆Imf⁺ : (Image f , imageInclusion f) ⊆ₑ (Image f⁺ , imageInclusion f⁺)
+        Imf⊆Imf⁺ = subst (Imf ⊆ₑ_) ((sym F≡Imf) ∙ F≡Imf⁺) (isRefl⊆ₑ Imf)
+          where Imf = (Image f , imageInclusion f)
+
+        f≡f⁺∘f : ∀ x → f x ≡ (f⁺ ∘ f) x
+        f≡f⁺∘f x = ∥₁.rec (set _ _) (λ { (b , f⁺b≡a) → (sym (f⁺b≡a ∙ fib) ∙ funExt⁻ f⁺≡f⁺∘f⁺ b) ∙ cong f⁺ (f⁺b≡a ∙ fib) }) ima
+          where lemma = Imf⊆Imf⁺ (f x) (((f x) , ∣ x , refl ∣₁) , refl)
+
+                ima = lemma .fst .snd
+                fib = lemma .snd
+
+        f⁺≡f∘f⁺ : ∀ x → f⁺ x ≡ (f ∘ f⁺) x
+        f⁺≡f∘f⁺ x = ∥₁.rec (set _ _) (λ { (b , fb≡a) → (sym (fb≡a ∙ fib) ∙ funExt⁻ f≡f∘f b) ∙ cong f (fb≡a ∙ fib) }) ima
+          where lemma = Imf⁺⊆Imf (f⁺ x) (((f⁺ x) , ∣ x , refl ∣₁) , refl)
+
+                ima = lemma .fst .snd
+                fib = lemma .snd
+
+        f⁺∘f : ∀ x → x ≤ (f⁺ ∘ f) x
+        f⁺∘f x = subst (x ≤_) (f≡f⁺∘f x) (x≤fx x)
+
+        f∘f⁺ : ∀ x → (f ∘ f⁺) x ≤ x
+        f∘f⁺ x = subst (_≤ x) (f⁺≡f∘f⁺ x) (f⁺x≤x x)
+
+IsPosetEquiv→isResiduatedBijection : (P S : Poset ℓ ℓ')
+                                     (e : ⟨ P ⟩ ≃ ⟨ S ⟩)
+                                   → IsPosetEquiv (snd P) e (snd S)
+                                   → hasResidual P S (equivFun e)
+IsPosetEquiv→isResiduatedBijection P S e eq
+  = IsPosetEquiv→IsIsotone P S e eq , invEq e , is⁻ ,
+   (λ x → subst (x ≤P_) (sym (retEq e x)) (rflP x)) ,
+    λ x → subst (_≤S x) (sym (secEq e x)) (rflS x)
+  where _≤P_ = PosetStr._≤_ (snd P)
+        _≤S_ = PosetStr._≤_ (snd S)
+
+        rflP = IsPoset.is-refl (PosetStr.isPoset (snd P))
+        rflS = IsPoset.is-refl (PosetStr.isPoset (snd S))
+
+        is⁻ : IsIsotone (snd S) (invEq e) (snd P)
+        IsIsotone.pres≤ is⁻ x y = equivFun (IsPosetEquiv.pres≤⁻ eq x y)
+
+isResiduatedBijection→IsPosetEquiv : (P S : Poset ℓ ℓ')
+                                     (e : ⟨ P ⟩ ≃ ⟨ S ⟩)
+                                   → hasResidual P S (equivFun e)
+                                   → IsPosetEquiv (snd P) e (snd S)
+IsPosetEquiv.pres≤ (isResiduatedBijection→IsPosetEquiv P S e
+                    (ise , e⁻ , ise⁻ , e⁻∘e , e∘e⁻)) x y
+  = propBiimpl→Equiv (propP _ _) (propS _ _) (IsIsotone.pres≤ ise x y) (subst2 _≤P_ (lemma x) (lemma y) ∘ IsIsotone.pres≤ ise⁻ _ _)
+  where _≤P_ = PosetStr._≤_ (snd P)
+        isP = PosetStr.isPoset (snd P)
+        propP = IsPoset.is-prop-valued isP
+        rflP = IsPoset.is-refl isP
+
+        _≤S_ = PosetStr._≤_ (snd S)
+        isS = PosetStr.isPoset (snd S)
+        propS = IsPoset.is-prop-valued isS
+        antiS = IsPoset.is-antisym isS
+
+        e∘e⁻x≡x : ∀ x → equivFun e (e⁻ x) ≡ x
+        e∘e⁻x≡x x = antiS _ x (e∘e⁻ x)
+                              (subst2 _≤S_ (secEq e x)
+                                           (cong (equivFun e ∘ e⁻) (secEq e x))
+                                           (IsIsotone.pres≤ ise _ _ (e⁻∘e (invEq e x))))
+
+        e⁻≡inv : ∀ x → e⁻ x ≡ invEq e x
+        e⁻≡inv x = sym (retEq e (e⁻ x)) ∙ cong (invEq e) (e∘e⁻x≡x x)
+
+        lemma : ∀ x → e⁻ (equivFun e x) ≡ x
+        lemma x = e⁻≡inv (equivFun e x) ∙ retEq e x
+
+-- We can weaken the equivalence of a poset equivalence to a surjection
+isOrderRecovering→isEmbedding : (P S : Poset ℓ ℓ')
+                                (f : ⟨ P ⟩ → ⟨ S ⟩)
+                              → (∀ x y → (PosetStr._≤_ (snd S) (f x) (f y))
+                                       → (PosetStr._≤_ (snd P) x y))
+                              → isEmbedding f
+isOrderRecovering→isEmbedding P S f is = emb
+  where _≤_ = PosetStr._≤_ (snd S)
+
+        isP = PosetStr.isPoset (snd P)
+        isS = PosetStr.isPoset (snd S)
+
+        setS = IsPoset.is-set isS
+
+        antiP = IsPoset.is-antisym isP
+        rflS = IsPoset.is-refl isS
+
+        emb : isEmbedding f
+        emb = injEmbedding setS λ {w} {x} fw≡fx
+            → antiP w x (is w x (subst (f w ≤_) fw≡fx (rflS (f w))))
+                        (is x w (subst (_≤ f w) fw≡fx (rflS (f w))))
+
+-- Galois connections work similarly to residuals, but are antitone
+module _
+  (E F : Poset ℓ ℓ')
+  (f : ⟨ E ⟩ → ⟨ F ⟩)
+  (g : ⟨ F ⟩ → ⟨ E ⟩)
+  where
+    private
+      _≤E_ = PosetStr._≤_ (snd E)
+      _≤F_ = PosetStr._≤_ (snd F)
+
+      propE = IsPoset.is-prop-valued (PosetStr.isPoset (snd E))
+      propF = IsPoset.is-prop-valued (PosetStr.isPoset (snd F))
+
+    isGaloisConnection : Type (ℓ-max ℓ ℓ')
+    isGaloisConnection = IsAntitone (snd E) f (snd F) ×
+                         IsAntitone (snd F) g (snd E) ×
+                        (∀ x → x ≤F (f ∘ g) x) ×
+                        (∀ x → x ≤E (g ∘ f) x)
+
+    isPropIsGaloisConnection : isProp isGaloisConnection
+    isPropIsGaloisConnection = isProp× (isPropIsAntitone _ _ _)
+                              (isProp× (isPropIsAntitone _ _ _)
+                              (isProp× (isPropΠ λ x → propF x _)
+                                       (isPropΠ λ x → propE x _)))
+
+    isGaloisConnection→hasResidualDual : isGaloisConnection
+                                       → hasResidual E (DualPoset F) f
+    isGaloisConnection→hasResidualDual (antif , antig , f∘g , g∘f)
+      = AntitoneDual E F f antif , g , DualAntitone F E g antig , g∘f , f∘g
+
+    AbsorbGaloisConnection : isGaloisConnection
+                           → f ∘ g ∘ f ≡ f
+    AbsorbGaloisConnection conn
+      = AbsorbResidual E (DualPoset F) f (isGaloisConnection→hasResidualDual conn)
+
+    GaloisConnectionAbsorb : isGaloisConnection
+                           → g ∘ f ∘ g ≡ g
+    GaloisConnectionAbsorb conn
+      = ResidualAbsorb E (DualPoset F) f (isGaloisConnection→hasResidualDual conn)
+
+    GaloisConnectionClosure : isGaloisConnection
+                            → isClosure E (g ∘ f)
+    GaloisConnectionClosure conn
+      = ComposedResidual→isClosure (DualPoset F , f , isGaloisConnection→hasResidualDual conn , refl)
+
+    GaloisConnectionDualClosure : isGaloisConnection
+                                → isDualClosure (DualPoset F) (f ∘ g)
+    GaloisConnectionDualClosure conn
+      = ComposedResidual→isDualClosure (E , f , isGaloisConnection→hasResidualDual conn , refl)
+
+hasResidual→isGaloisConnectionDual : (E F : Poset ℓ ℓ')
+                                     (f : ⟨ E ⟩ → ⟨ F ⟩)
+                                   → (res : hasResidual E F f)
+                                   → isGaloisConnection E (DualPoset F) f (residual E F f res)
+hasResidual→isGaloisConnectionDual E F f (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺)
+  = (IsotoneDual E F f isf) , (DualIsotone F E f⁺ isf⁺) , f∘f⁺ , f⁺∘f
diff --git a/Cubical/Relation/Binary/Order/Poset/Properties.agda b/Cubical/Relation/Binary/Order/Poset/Properties.agda
index a3122fb1ca..323689256e 100644
--- a/Cubical/Relation/Binary/Order/Poset/Properties.agda
+++ b/Cubical/Relation/Binary/Order/Poset/Properties.agda
@@ -1,8 +1,14 @@
 {-# OPTIONS --safe #-}
 module Cubical.Relation.Binary.Order.Poset.Properties where
 
-open import Cubical.Foundations.Prelude
+open import Cubical.Data.Sigma
+open import Cubical.Data.Sum
+
+open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Transport
 
 open import Cubical.Functions.Embedding
 
@@ -12,14 +18,14 @@ open import Cubical.Data.Sigma
 
 open import Cubical.Relation.Binary.Base
 open import Cubical.Relation.Binary.Order.Poset.Base
-open import Cubical.Relation.Binary.Order.Preorder.Base
-open import Cubical.Relation.Binary.Order.StrictPoset.Base
+open import Cubical.Relation.Binary.Order.Proset
+open import Cubical.Relation.Binary.Order.Quoset.Base
 
 open import Cubical.Relation.Nullary
 
 private
   variable
-    ℓ ℓ' ℓ'' : Level
+    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
 
 module _
   {A : Type ℓ}
@@ -28,22 +34,30 @@ module _
 
   open BinaryRelation
 
-  isPoset→isPreorder : IsPoset R → IsPreorder R
-  isPoset→isPreorder poset = ispreorder
+  isPoset→isProset : IsPoset R → IsProset R
+  isPoset→isProset poset = isproset
                              (IsPoset.is-set poset)
                              (IsPoset.is-prop-valued poset)
                              (IsPoset.is-refl poset)
                              (IsPoset.is-trans poset)
 
+  isPosetDecidable→Discrete : IsPoset R → isDecidable R → Discrete A
+  isPosetDecidable→Discrete pos dec a b with dec a b
+  ... | no ¬Rab = no (λ a≡b → ¬Rab (subst (R a) a≡b (IsPoset.is-refl pos a)))
+  ... | yes Rab with dec b a
+  ...       | no ¬Rba = no (λ a≡b → ¬Rba (subst (λ x → R x a) a≡b
+                                         (IsPoset.is-refl pos a)))
+  ...       | yes Rba = yes (IsPoset.is-antisym pos a b Rab Rba)
+
   private
     transirrefl : isTrans R → isAntisym R → isTrans (IrreflKernel R)
     transirrefl trans anti a b c (Rab , ¬a≡b) (Rbc , ¬b≡c)
       = trans a b c Rab Rbc
       , λ a≡c → ¬a≡b (anti a b Rab (subst (R b) (sym a≡c) Rbc))
 
-  isPoset→isStrictPosetIrreflKernel : IsPoset R → IsStrictPoset (IrreflKernel R)
-  isPoset→isStrictPosetIrreflKernel poset
-    = isstrictposet (IsPoset.is-set poset)
+  isPoset→isQuosetIrreflKernel : IsPoset R → IsQuoset (IrreflKernel R)
+  isPoset→isQuosetIrreflKernel poset
+    = isquoset (IsPoset.is-set poset)
                     (λ a b → isProp× (IsPoset.is-prop-valued poset a b)
                                      (isProp¬ (a ≡ b)))
                     (isIrreflIrreflKernel R)
@@ -54,6 +68,13 @@ module _
                                              , transirrefl (IsPoset.is-trans poset)
                                                            (IsPoset.is-antisym poset)))
 
+  isPosetDecidable→isQuosetDecidable : IsPoset R → isDecidable R → isDecidable (IrreflKernel R)
+  isPosetDecidable→isQuosetDecidable pos dec a b with dec a b
+  ... | no ¬Rab = no λ { (Rab , _) → ¬Rab Rab }
+  ... | yes Rab with (isPosetDecidable→Discrete pos dec) a b
+  ...       | yes a≡b = no λ { (_ , ¬a≡b) → ¬a≡b a≡b }
+  ...       | no a≢b = yes (Rab , a≢b)
+
   isPosetInduced : IsPoset R → (B : Type ℓ'') → (f : B ↪ A) → IsPoset (InducedRelation R (B , f))
   isPosetInduced pos B (f , emb)
     = isposet (Embedding-into-isSet→isSet (f , emb) (IsPoset.is-set pos))
@@ -63,28 +84,532 @@ module _
               λ a b a≤b b≤a → isEmbedding→Inj emb a b
                 (IsPoset.is-antisym pos (f a) (f b) a≤b b≤a)
 
-Poset→Preorder : Poset ℓ ℓ' → Preorder ℓ ℓ'
-Poset→Preorder (_ , pos) = _ , preorderstr (PosetStr._≤_ pos)
-                                           (isPoset→isPreorder (PosetStr.isPoset pos))
+  isPosetDual : IsPoset R → IsPoset (Dual R)
+  isPosetDual pos
+    = isposet (IsPoset.is-set pos)
+              (λ a b → IsPoset.is-prop-valued pos b a)
+              (IsPoset.is-refl pos)
+              (λ a b c Rab Rbc → IsPoset.is-trans pos c b a Rbc Rab)
+              (λ a b Rab Rba → IsPoset.is-antisym pos a b Rba Rab)
+
+Poset→Proset : Poset ℓ ℓ' → Proset ℓ ℓ'
+Poset→Proset (_ , pos)
+  = proset _ (PosetStr._≤_ pos)
+             (isPoset→isProset (PosetStr.isPoset pos))
+
+Poset→Quoset : Poset ℓ ℓ' → Quoset ℓ (ℓ-max ℓ ℓ')
+Poset→Quoset (_ , pos)
+  = quoset _ (BinaryRelation.IrreflKernel (PosetStr._≤_ pos))
+             (isPoset→isQuosetIrreflKernel (PosetStr.isPoset pos))
+
+DualPoset : Poset ℓ ℓ' → Poset ℓ ℓ'
+DualPoset (_ , pos)
+  = poset _ (BinaryRelation.Dual (PosetStr._≤_ pos))
+            (isPosetDual (PosetStr.isPoset pos))
+
+module _
+  {A : Type ℓ}
+  {_≤_ : Rel A A ℓ'}
+  (pos : IsPoset _≤_)
+  where
+
+  private
+      pre = isPoset→isProset pos
+
+      set = IsPoset.is-set pos
+
+      prop = IsPoset.is-prop-valued pos
+
+      rfl = IsPoset.is-refl pos
+
+      anti = IsPoset.is-antisym pos
+
+      trans = IsPoset.is-trans pos
+
+  module _
+    {P : Embedding A ℓ''}
+    where
+
+    private
+      toA = fst (snd P)
+
+      emb = snd (snd P)
+
+    isLeast→ContrMinimal : ∀ n → isLeast pre P n  → ∀ m → isMinimal pre P m → n ≡ m
+    isLeast→ContrMinimal n isln m ismm
+      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isln m) (ismm n (isln m)))
+
+    isGreatest→ContrMaximal : ∀ n → isGreatest pre P n → ∀ m → isMaximal pre P m → n ≡ m
+    isGreatest→ContrMaximal n isgn m ismm
+      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (ismm n (isgn m)) (isgn m))
+
+    isLeastUnique : ∀ n m → isLeast pre P n → isLeast pre P m → n ≡ m
+    isLeastUnique n m isln islm
+      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isln m) (islm n))
+
+    isGreatestUnique : ∀ n m → isGreatest pre P n → isGreatest pre P m → n ≡ m
+    isGreatestUnique n m isgn isgm
+      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isgm n) (isgn m))
+
+    LeastUnique : (n m : Least pre P) → n ≡ m
+    LeastUnique (n , ln) (m , lm) = Σ≡Prop (λ _ → isPropIsLeast pre P _) (isLeastUnique n m ln lm)
+
+    GreatestUnique : (n m : Greatest pre P) → n ≡ m
+    GreatestUnique (n , gn) (m , gm) = Σ≡Prop (λ _ → isPropIsGreatest pre P _) (isGreatestUnique n m gn gm)
+
+  module _
+    {B : Type ℓ''}
+    {P : B → A}
+    where
+
+    isInfimum→ContrMaximalLowerBound : ∀ n → isInfimum pre P n
+                                     → ∀ m → isMaximalLowerBound pre P m
+                                     → n ≡ m
+    isInfimum→ContrMaximalLowerBound n (isln , isglbn) m (islm , ismlbm)
+      = anti n m (ismlbm (n , isln) (isglbn (m , islm))) (isglbn (m , islm))
+
+    isSupremum→ContrMinimalUpperBound : ∀ n → isSupremum pre P n
+                                      → ∀ m → isMinimalUpperBound pre P m
+                                      → n ≡ m
+    isSupremum→ContrMinimalUpperBound n (isun , islubn) m (isum , ismubm)
+      = anti n m (islubn (m , isum)) (ismubm (n , isun) (islubn (m , isum)))
+
+    isInfimumUnique : ∀ n m → isInfimum pre P n → isInfimum pre P m → n ≡ m
+    isInfimumUnique n m (isln , infn) (islm , infm)
+      = anti n m (infm (n , isln)) (infn (m , islm))
+
+    isSupremumUnique : ∀ n m → isSupremum pre P n → isSupremum pre P m → n ≡ m
+    isSupremumUnique n m (isun , supn) (isum , supm)
+      = anti n m (supn (m , isum)) (supm (n , isun))
+
+    InfimumUnique : (n m : Infimum pre P) → n ≡ m
+    InfimumUnique (n , infn) (m , infm) = Σ≡Prop (λ _ → isPropIsInfimum pre P _)
+                                                  (isInfimumUnique n m infn infm)
+
+    SupremumUnique : (n m : Supremum pre P) → n ≡ m
+    SupremumUnique (n , supn) (m , supm) = Σ≡Prop (λ _ → isPropIsSupremum pre P _)
+                                                   (isSupremumUnique n m supn supm)
+
+  isMeetUnique : ∀ a b x y → isMeet pre a b x → isMeet pre a b y → x ≡ y
+  isMeetUnique a b x y infx infy = anti x y x≤y y≤x
+    where x≤y : x ≤ y
+          x≤y = invEq (infy x) (infx x .fst (rfl x))
+
+          y≤x : y ≤ x
+          y≤x = invEq (infx y) (infy y .fst (rfl y))
+
+  isJoinUnique : ∀ a b x y → isJoin pre a b x → isJoin pre a b y → x ≡ y
+  isJoinUnique a b x y supx supy = anti x y x≤y y≤x
+          where x≤y : x ≤ y
+                x≤y = invEq (supx y) (supy y .fst (rfl y))
+
+                y≤x : y ≤ x
+                y≤x = invEq (supy x) (supx x .fst (rfl x))
+
+  MeetUnique : ∀ a b → (x y : Meet pre a b) → x ≡ y
+  MeetUnique a b (x , mx) (y , my) = Σ≡Prop (isPropIsMeet pre a b)
+                                            (isMeetUnique a b x y mx my)
+
+  JoinUnique : ∀ a b → (x y : Join pre a b) → x ≡ y
+  JoinUnique a b (x , jx) (y , jy) = Σ≡Prop (isPropIsJoin pre a b)
+                                            (isJoinUnique a b x y jx jy)
+
+  module _
+    (meet : ∀ a b → Meet pre a b)
+    where
+
+      meetIdemp : ∀ a → meet a a .fst ≡ a
+      meetIdemp a
+        = PathPΣ (MeetUnique a a (meet a a)
+                                 (a , (isReflIsMeet pre a))) .fst
+
+      meetComm : ∀ a b → meet a b .fst ≡ meet b a .fst
+      meetComm a b = sym (PathPΣ (MeetUnique b a (meet b a)
+                                           ((meet a b .fst) ,
+                                            (isMeetComm pre a b
+                                                       (meet a b .fst)
+                                                       (meet a b .snd)))) .fst)
+
+      meetAssoc : ∀ a b c
+                → meet a (meet b c .fst) .fst ≡ meet (meet a b .fst) c .fst
+      meetAssoc a b c
+        = sym (PathPΣ (MeetUnique
+                          (meet a b .fst) c
+                          (meet (meet a b .fst) c)
+                         ((meet a (meet b c .fst) .fst) ,
+                          (isMeetAssoc pre a b c
+                                      (meet a b .fst)
+                                      (meet b c .fst)
+                                      (meet a (meet b c .fst) .fst)
+                                      (meet a b .snd)
+                                      (meet b c .snd)
+                                      (meet a (meet b c .fst) .snd)))) .fst)
+
+  module _
+    (join : ∀ a b → Join pre a b)
+    where
+
+      joinIdem : ∀ a → join a a .fst ≡ a
+      joinIdem a
+        = PathPΣ (JoinUnique a a (join a a)
+                                 (a , (isReflIsJoin pre a))) .fst
+
+      joinComm : ∀ a b → join a b .fst ≡ join b a .fst
+      joinComm a b = sym (PathPΣ (JoinUnique b a (join b a)
+                                           ((join a b .fst) ,
+                                            (isJoinComm pre a b
+                                                       (join a b .fst)
+                                                       (join a b .snd)))) .fst)
+
+      joinAssoc : ∀ a b c
+                → join a (join b c .fst) .fst ≡ join (join a b .fst) c .fst
+      joinAssoc a b c
+        = sym (PathPΣ (JoinUnique
+                          (join a b .fst) c
+                          (join (join a b .fst) c)
+                         ((join a (join b c .fst) .fst) ,
+                          (isJoinAssoc pre a b c
+                                      (join a b .fst)
+                                      (join b c .fst)
+                                      (join a (join b c .fst) .fst)
+                                      (join a b .snd)
+                                      (join b c .snd)
+                                      (join a (join b c .fst) .snd)))) .fst)
+
+  order≃meet : ∀ a b a∧b
+             → isMeet pre a b a∧b
+             → (a ≤ b) ≃ (a ≡ a∧b)
+  order≃meet a b a∧b funa∧b
+    = propBiimpl→Equiv (prop a b)
+                       (set a a∧b)
+                       (λ a≤b → anti a a∧b (invEq (funa∧b a) (rfl a , a≤b))
+                                            (funa∧b a∧b .fst (rfl a∧b) .fst))
+                        λ a≡a∧b → subst (_≤ b) (sym a≡a∧b)
+                                         (funa∧b a∧b .fst (rfl a∧b) .snd)
+
+  order≃join : ∀ a b a∨b
+             → isJoin pre a b a∨b
+             → (a ≤ b) ≃ (b ≡ a∨b)
+  order≃join a b a∨b funa∨b
+    = propBiimpl→Equiv (prop a b)
+                       (set b a∨b)
+                       (λ a≤b → anti b a∨b (funa∨b a∨b .fst (rfl a∨b) .snd)
+                                            (invEq (funa∨b b) (a≤b , rfl b)))
+                        λ b≡a∨b → subst (a ≤_) (sym b≡a∨b)
+                                        (funa∨b a∨b .fst (rfl a∨b) .fst)
+
+-- Equivalences of posets respect meets and joins
+IsPosetEquivRespectsMeet : {P : Poset ℓ₀ ℓ₀'} {S : Poset ℓ₁ ℓ₁'} (e : PosetEquiv P S)
+                        → ∀ a b a∧b
+                        → isMeet (isPoset→isProset (PosetStr.isPoset (P .snd))) a b a∧b
+                        ≃ isMeet (isPoset→isProset (PosetStr.isPoset (S .snd)))
+                                 (equivFun (e .fst) a)
+                                 (equivFun (e .fst) b)
+                                 (equivFun (e .fst) a∧b)
+IsPosetEquivRespectsMeet {P = P} {S = S} (e , posEq) a b a∧b
+  = propBiimpl→Equiv (isPropIsMeet proP a b a∧b)
+                     (isPropIsMeet proS (equivFun e a) (equivFun e b) (equivFun e a∧b))
+                     (λ meet x
+                       → IsPosetEquiv.pres≤⁻ posEq x (equivFun e a∧b) ∙ₑ
+                         substEquiv (invEq e x ≤P_) (retEq e a∧b) ∙ₑ
+                         meet (invEq e x) ∙ₑ
+                         ≃-× (IsPosetEquiv.pres≤ posEq (invEq e x) a ∙ₑ
+                              substEquiv (_≤S equivFun e a) (secEq e x))
+                             (IsPosetEquiv.pres≤ posEq (invEq e x) b ∙ₑ
+                              substEquiv (_≤S equivFun e b) (secEq e x)))
+                      λ meet x
+                       → IsPosetEquiv.pres≤ posEq x a∧b ∙ₑ
+                         meet (equivFun e x) ∙ₑ
+                         ≃-× (IsPosetEquiv.pres≤⁻ posEq (equivFun e x) (equivFun e a) ∙ₑ
+                               subst2Equiv _≤P_ (retEq e x) (retEq e a))
+                             (IsPosetEquiv.pres≤⁻ posEq (equivFun e x) (equivFun e b) ∙ₑ
+                               subst2Equiv _≤P_ (retEq e x) (retEq e b))
+  where _≤P_ = PosetStr._≤_ (P .snd)
+        _≤S_ = PosetStr._≤_ (S .snd)
+
+        posP = PosetStr.isPoset (P .snd)
+        posS = PosetStr.isPoset (S .snd)
+
+        proP = isPoset→isProset posP
+        proS = isPoset→isProset posS
+
+IsPosetEquivRespectsJoin : {P : Poset ℓ₀ ℓ₀'} {S : Poset ℓ₁ ℓ₁'} (e : PosetEquiv P S)
+                        → ∀ a b a∨b
+                        → isJoin (isPoset→isProset (PosetStr.isPoset (P .snd))) a b a∨b
+                        ≃ isJoin (isPoset→isProset (PosetStr.isPoset (S .snd)))
+                                 (equivFun (e .fst) a)
+                                 (equivFun (e .fst) b)
+                                 (equivFun (e .fst) a∨b)
+
+IsPosetEquivRespectsJoin {P = P} {S = S} (e , posEq) a b a∨b
+  = propBiimpl→Equiv (isPropIsJoin proP a b a∨b)
+                     (isPropIsJoin proS (equivFun e a) (equivFun e b) (equivFun e a∨b))
+                     (λ join x
+                       → IsPosetEquiv.pres≤⁻ posEq (equivFun e a∨b) x ∙ₑ
+                         substEquiv (_≤P invEq e x) (retEq e a∨b) ∙ₑ
+                         join (invEq e x) ∙ₑ
+                         ≃-× (IsPosetEquiv.pres≤ posEq a (invEq e x) ∙ₑ
+                               substEquiv (equivFun e a ≤S_) (secEq e x))
+                              (IsPosetEquiv.pres≤ posEq b (invEq e x) ∙ₑ
+                               substEquiv (equivFun e b ≤S_) (secEq e x)))
+                      λ join x
+                       → IsPosetEquiv.pres≤ posEq a∨b x ∙ₑ
+                         join (equivFun e x) ∙ₑ
+                         ≃-× (IsPosetEquiv.pres≤⁻ posEq (equivFun e a) (equivFun e x) ∙ₑ
+                               subst2Equiv _≤P_ (retEq e a) (retEq e x))
+                              (IsPosetEquiv.pres≤⁻ posEq (equivFun e b) (equivFun e x) ∙ₑ
+                               subst2Equiv _≤P_ (retEq e b) (retEq e x))
+  where _≤P_ = PosetStr._≤_ (P .snd)
+        _≤S_ = PosetStr._≤_ (S .snd)
+
+        posP = PosetStr.isPoset (P .snd)
+        posS = PosetStr.isPoset (S .snd)
+
+        proP = isPoset→isProset posP
+        proS = isPoset→isProset posS
+
+module _
+  (pos : Poset ℓ ℓ')
+  where
+    private
+      pro = isPoset→isProset (PosetStr.isPoset (snd pos))
+
+      is = PosetStr.isPoset (snd pos)
+
+    isMeetSemipseudolattice : Type (ℓ-max ℓ ℓ')
+    isMeetSemipseudolattice = ∀ a b → Meet pro a b
+
+    isMeetCompleteSemipseudolattice : {ℓ'' : Level} → Type (ℓ-max (ℓ-max ℓ ℓ') (ℓ-suc ℓ''))
+    isMeetCompleteSemipseudolattice {ℓ'' = ℓ''} = {B : Type ℓ''}
+                                                → (P : B → ⟨ pos ⟩)
+                                                → Infimum pro P
+
+    isJoinSemipseudolattice : Type (ℓ-max ℓ ℓ')
+    isJoinSemipseudolattice = ∀ a b → Join pro a b
+
+    isJoinCompleteSemipseudolattice : {ℓ'' : Level} → Type (ℓ-max (ℓ-max ℓ ℓ') (ℓ-suc ℓ''))
+    isJoinCompleteSemipseudolattice {ℓ'' = ℓ''} = {B : Type ℓ''}
+                                                → (P : B → ⟨ pos ⟩)
+                                                → Supremum pro P
+
+    isMeetSemilattice : Type (ℓ-max ℓ ℓ')
+    isMeetSemilattice = isMeetSemipseudolattice × Greatest pro (⟨ pos ⟩ , (id↪ _))
+
+    isJoinSemilattice : Type (ℓ-max ℓ ℓ')
+    isJoinSemilattice = isJoinSemipseudolattice × Least pro (⟨ pos ⟩ , (id↪ _))
+
+    isPseudolattice : Type (ℓ-max ℓ ℓ')
+    isPseudolattice = isMeetSemipseudolattice × isJoinSemipseudolattice
+
+    isLattice : Type (ℓ-max ℓ ℓ')
+    isLattice = isMeetSemilattice × isJoinSemilattice
+
+    isCompleteLattice : {ℓ'' : Level} → Type (ℓ-max (ℓ-max ℓ ℓ') (ℓ-suc ℓ''))
+    isCompleteLattice {ℓ'' = ℓ''} = isMeetCompleteSemipseudolattice {ℓ''} × isJoinCompleteSemipseudolattice {ℓ''}
+
+    -- These are all propositonal statements
+    isPropIsMeetSemipseudolattice : isProp isMeetSemipseudolattice
+    isPropIsMeetSemipseudolattice
+      = isPropΠ2 λ a b → MeetUnique is a b
+
+    isPropIsMeetCompleteSemipseudolattice : {ℓ'' : Level} → isProp (isMeetCompleteSemipseudolattice {ℓ''})
+    isPropIsMeetCompleteSemipseudolattice
+      = isPropImplicitΠ λ _ → isPropΠ λ _ → InfimumUnique is
+
+    isPropIsJoinSemipseudolattice : isProp isJoinSemipseudolattice
+    isPropIsJoinSemipseudolattice
+      = isPropΠ2 λ a b → JoinUnique is a b
+
+    isPropIsJoinCompleteSemipseudolattice : {ℓ'' : Level} → isProp (isJoinCompleteSemipseudolattice {ℓ''})
+    isPropIsJoinCompleteSemipseudolattice
+      = isPropImplicitΠ λ _ → isPropΠ λ _ → SupremumUnique is
+
+    isPropIsMeetSemilattice : isProp isMeetSemilattice
+    isPropIsMeetSemilattice = isProp× isPropIsMeetSemipseudolattice
+                                     (GreatestUnique is {P = ⟨ pos ⟩ , (id↪ ⟨ pos ⟩)})
+
+    isPropIsJoinSemilattice : isProp isJoinSemilattice
+    isPropIsJoinSemilattice = isProp× isPropIsJoinSemipseudolattice
+                                     (LeastUnique is {P = ⟨ pos ⟩ , (id↪ ⟨ pos ⟩)})
+
+    isPropIsPseudolattice : isProp isPseudolattice
+    isPropIsPseudolattice = isProp× isPropIsMeetSemipseudolattice
+                                    isPropIsJoinSemipseudolattice
+
+    isPropIsLattice : isProp isLattice
+    isPropIsLattice = isProp× isPropIsMeetSemilattice
+                              isPropIsJoinSemilattice
+
+    isPropIsCompleteLattice : {ℓ'' : Level} → isProp (isCompleteLattice {ℓ''})
+    isPropIsCompleteLattice = isProp× isPropIsMeetCompleteSemipseudolattice
+                                      isPropIsJoinCompleteSemipseudolattice
+
+    -- Complete semipseudolattices are semipseudolattices
+    isMeetCompleteSemipseudolattice→isMeetSemipseudolattice : isMeetCompleteSemipseudolattice
+                                                            → isMeetSemipseudolattice
+    isMeetCompleteSemipseudolattice→isMeetSemipseudolattice meet
+      = (λ a b → (meet fst .fst) , invEq (isMeet≃isInfimum pro a b _)
+                                         (meet fst .snd))
+
+    isJoinCompleteSemipseudolattice→isJoinSemipseudolattice : isJoinCompleteSemipseudolattice
+                                                            → isJoinSemipseudolattice
+    isJoinCompleteSemipseudolattice→isJoinSemipseudolattice join
+      = (λ a b → (join fst .fst) , invEq (isJoin≃isSupremum pro a b _)
+                                         (join fst .snd))
+
+    -- They also imply each other, though we keep the two distinct for morphism reasons
+    isMeetCompleteSemipseudolattice≃isJoinCompleteSemipseudolattice : (isMeetCompleteSemipseudolattice {ℓ-max ℓ ℓ'})
+                                                                    ≃ (isJoinCompleteSemipseudolattice {ℓ-max ℓ ℓ'})
+    isMeetCompleteSemipseudolattice≃isJoinCompleteSemipseudolattice
+      = propBiimpl→Equiv isPropIsMeetCompleteSemipseudolattice
+                         isPropIsJoinCompleteSemipseudolattice to from
+      where to : isMeetCompleteSemipseudolattice
+               → isJoinCompleteSemipseudolattice {ℓ-max ℓ ℓ'}
+            to meet P = (fst lemma) ,
+                         isInfimumOfUpperBounds→isSupremum pro P (fst lemma)
+                                                                 (snd lemma)
+              where P↑ : Type _
+                    P↑ = UpperBound pro P
+
+                    lemma = meet {B = P↑} fst
+
+            from : isJoinCompleteSemipseudolattice
+                 → isMeetCompleteSemipseudolattice {ℓ-max ℓ ℓ'}
+            from join P = (fst lemma) ,
+                           isSupremumOfLowerBounds→isInfimum pro P (fst lemma)
+                                                                   (snd lemma)
+              where P↓ : Type _
+                    P↓ = LowerBound pro P
+
+                    lemma = join {B = P↓} fst
+
+    isCompleteLattice→isLattice : isCompleteLattice
+                                → isLattice
+    isCompleteLattice→isLattice (meet , join)
+      = ((isMeetCompleteSemipseudolattice→isMeetSemipseudolattice meet) ,
+         (join (λ x → x) .fst) ,
+          isUpperBoundOfSelf→isGreatestOfSelf pro (join (λ x → x) .snd .fst)) ,
+        ((isJoinCompleteSemipseudolattice→isJoinSemipseudolattice join) ,
+          meet (λ x → x) .fst ,
+          isLowerBoundOfSelf→isLeastOfSelf pro (meet (λ x → x) .snd .fst))
+
+    module _
+      (lat : isPseudolattice)
+      where
+        private
+          _∧l_ : ⟨ pos ⟩ → ⟨ pos ⟩ → ⟨ pos ⟩
+          a ∧l b = (lat .fst a b) .fst
+
+          _∨l_ : ⟨ pos ⟩ → ⟨ pos ⟩ → ⟨ pos ⟩
+          a ∨l b = (lat .snd a b) .fst
+
+          set = IsPoset.is-set is
+
+          rfl = IsPoset.is-refl is
+
+        MeetDistLJoin : Type ℓ
+        MeetDistLJoin = ∀ a b c → a ∧l (b ∨l c) ≡ (a ∧l b) ∨l (a ∧l c)
+
+        MeetDistRJoin : Type ℓ
+        MeetDistRJoin = ∀ a b c → (a ∨l b) ∧l c ≡ (a ∧l c) ∨l (b ∧l c)
+
+        JoinDistLMeet : Type ℓ
+        JoinDistLMeet = ∀ a b c → a ∨l (b ∧l c) ≡ (a ∨l b) ∧l (a ∨l c)
+
+        JoinDistRMeet : Type ℓ
+        JoinDistRMeet = ∀ a b c → (a ∧l b) ∨l c ≡ (a ∨l c) ∧l (b ∨l c)
+
+        MeetAbsorbLJoin : ∀ a b → a ∧l (a ∨l b) ≡ a
+        MeetAbsorbLJoin a b
+          = sym (equivFun
+                (order≃meet
+                   is a (a ∨l b) (a ∧l (a ∨l b))
+                  (lat .fst a (a ∨l b) .snd))
+                (equivFun (lat .snd a b .snd (a ∨l b))
+                          (rfl (a ∨l b)) .fst))
+
+        MeetAbsorbRJoin : ∀ a b → (a ∨l b) ∧l a ≡ a
+        MeetAbsorbRJoin a b
+          = meetComm is (lat .fst) (a ∨l b) a ∙
+            MeetAbsorbLJoin a b
+
+        JoinAbsorbLMeet : ∀ a b → a ∨l (a ∧l b) ≡ a
+        JoinAbsorbLMeet a b
+          = sym (equivFun
+                (order≃join
+                  is (a ∧l b) a (a ∨l (a ∧l b))
+                                (isJoinComm pro a (a ∧l b) (a ∨l (a ∧l b))
+                                           (lat .snd a (a ∧l b) .snd)))
+                (equivFun (lat .fst a b .snd (a ∧l b)) (rfl (a ∧l b)) .fst))
+
+        JoinAbsorbRMeet : ∀ a b → (a ∧l b) ∨l a ≡ a
+        JoinAbsorbRMeet a b
+          = joinComm is (lat .snd) (a ∧l b) a ∙
+            JoinAbsorbLMeet a b
+
+        isPropMeetDistLJoin : isProp MeetDistLJoin
+        isPropMeetDistLJoin = isPropΠ3 λ _ _ _ → set _ _
+
+        isPropMeetDistRJoin : isProp MeetDistRJoin
+        isPropMeetDistRJoin = isPropΠ3 λ _ _ _ → set _ _
+
+        isPropJoinDistLMeet : isProp JoinDistLMeet
+        isPropJoinDistLMeet = isPropΠ3 λ _ _ _ → set _ _
+
+        isPropJoinDistRMeet : isProp JoinDistRMeet
+        isPropJoinDistRMeet = isPropΠ3 λ _ _ _ → set _ _
+
+        MeetDistLJoin≃MeetDistRJoin : MeetDistLJoin ≃ MeetDistRJoin
+        MeetDistLJoin≃MeetDistRJoin
+          = propBiimpl→Equiv isPropMeetDistLJoin
+                             isPropMeetDistRJoin
+                            (λ distl a b c → meetComm is (lat .fst) (a ∨l b) c ∙
+                                             distl c a b ∙
+                                             cong₂ _∨l_ (meetComm is (lat .fst) c a)
+                                                        (meetComm is (lat .fst) c b))
+                             λ distr a b c → meetComm is (lat .fst) a (b ∨l c) ∙
+                                             distr b c a ∙
+                                             cong₂ _∨l_ (meetComm is (lat .fst) b a)
+                                                        (meetComm is (lat .fst) c a)
 
-Poset→StrictPoset : Poset ℓ ℓ' → StrictPoset ℓ (ℓ-max ℓ ℓ')
-Poset→StrictPoset (_ , pos)
-  = _ , strictposetstr (BinaryRelation.IrreflKernel (PosetStr._≤_ pos))
-                       (isPoset→isStrictPosetIrreflKernel (PosetStr.isPoset pos))
+        JoinDistLMeet≃JoinDistRMeet : JoinDistLMeet ≃ JoinDistRMeet
+        JoinDistLMeet≃JoinDistRMeet
+          = propBiimpl→Equiv isPropJoinDistLMeet
+                             isPropJoinDistRMeet
+                            (λ distl a b c → joinComm is (lat .snd) (a ∧l b) c ∙
+                                             distl c a b ∙
+                                             cong₂ _∧l_ (joinComm is (lat .snd) c a)
+                                                        (joinComm is (lat .snd) c b))
+                             λ distr a b c → joinComm is (lat .snd) a (b ∧l c) ∙
+                                             distr b c a ∙
+                                             cong₂ _∧l_ (joinComm is (lat .snd) b a)
+                                                        (joinComm is (lat .snd) c a)
 
+        MeetDistLJoin≃JoinDistLMeet : MeetDistLJoin ≃ JoinDistLMeet
+        MeetDistLJoin≃JoinDistLMeet
+          = propBiimpl→Equiv isPropMeetDistLJoin
+                             isPropJoinDistLMeet
+                             (λ dist a b c  → (a ∨l  (b  ∧l  c))                      ≡⟨ cong (_∨l (b ∧l c)) (sym (JoinAbsorbLMeet a c)) ⟩
+                                             ((a ∨l  (a  ∧l  c)) ∨l  (b ∧l c))        ≡⟨ sym (joinAssoc is (lat .snd) a (a ∧l c) (b ∧l c)) ⟩
+                                              (a ∨l ((a  ∧l  c)  ∨l  (b ∧l c)))       ≡⟨ cong (a ∨l_) (sym (equivFun MeetDistLJoin≃MeetDistRJoin dist a b c)) ⟩
+                                              (a ∨l ((a  ∨l  b)  ∧l   c))             ≡⟨ cong (_∨l ((a ∨l b) ∧l c)) (sym (MeetAbsorbRJoin a b)) ⟩
+                                            (((a ∨l   b) ∧l  a)  ∨l ((a ∨l b) ∧l c)) ≡⟨ sym (dist (a ∨l b) a c) ⟩
+                                             ((a ∨l   b) ∧l (a   ∨l   c))             ∎)
+                              λ dist' a b c → (a ∧l  (b  ∨l c))                      ≡⟨ cong (_∧l (b ∨l c)) (sym (MeetAbsorbLJoin a c)) ⟩
+                                             ((a ∧l  (a  ∨l c)) ∧l  (b ∨l c))        ≡⟨ sym (meetAssoc is (lat .fst) a (a ∨l c) (b ∨l c)) ⟩
+                                              (a ∧l ((a  ∨l c)  ∧l  (b ∨l c)))      ≡⟨ cong (a ∧l_) (sym (equivFun JoinDistLMeet≃JoinDistRMeet dist' a b c)) ⟩
+                                              (a ∧l ((a  ∧l b)  ∨l   c))             ≡⟨ cong (_∧l ((a ∧l b) ∨l c)) (sym (JoinAbsorbRMeet a b)) ⟩
+                                            (((a ∧l   b) ∨l a)  ∧l ((a ∧l b) ∨l c)) ≡⟨ sym (dist' (a ∧l b) a c) ⟩
+                                             ((a ∧l   b) ∨l (a  ∧l   c))             ∎
 
-module PosetDownset (P' : Poset ℓ ℓ') where
-  private P = fst P'
-  open PosetStr (snd P')
+        MeetDistRJoin≃JoinDistRMeet : MeetDistRJoin ≃ JoinDistRMeet
+        MeetDistRJoin≃JoinDistRMeet = invEquiv MeetDistLJoin≃MeetDistRJoin ∙ₑ
+                                      MeetDistLJoin≃JoinDistLMeet ∙ₑ
+                                      JoinDistLMeet≃JoinDistRMeet
 
-  ↓ : P → Type (ℓ-max ℓ ℓ')
-  ↓ u = Σ[ v ∈ P ] v ≤ u
+        -- Since all of those varieties of distributivity are equivalent, we say that MeetDistLJoin is our canonical version of distributivity
+        isDistributive : Type ℓ
+        isDistributive = MeetDistLJoin
 
-  ↓ᴾ : P → Poset (ℓ-max ℓ ℓ') ℓ'
-  fst (↓ᴾ u) = ↓ u
-  PosetStr._≤_ (snd (↓ᴾ u)) v w = v .fst ≤ w .fst
-  PosetStr.isPoset (snd (↓ᴾ u)) =
-    isPosetInduced
-      (PosetStr.isPoset (snd P'))
-      _
-      (EmbeddingΣProp (λ a → is-prop-valued _ _))
+        isPropIsDistributive : isProp isDistributive
+        isPropIsDistributive = isPropMeetDistLJoin
diff --git a/Cubical/Relation/Binary/Order/Poset/Subset.agda b/Cubical/Relation/Binary/Order/Poset/Subset.agda
new file mode 100644
index 0000000000..9153602a41
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Poset/Subset.agda
@@ -0,0 +1,249 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Poset.Subset where
+
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Transport
+
+open import Cubical.Data.Sigma
+open import Cubical.Data.Sum as ⊎
+
+open import Cubical.Functions.Embedding
+open import Cubical.Functions.Preimage
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Poset.Properties
+
+
+private
+  variable
+    ℓ ℓ' ℓ'' ℓ''' ℓ₀ ℓ₁ : Level
+
+module _
+  (P : Poset ℓ ℓ')
+  where
+    private
+      _≤_ = PosetStr._≤_ (snd P)
+
+      is = PosetStr.isPoset (snd P)
+      prop = IsPoset.is-prop-valued is
+
+      rfl = IsPoset.is-refl is
+      anti = IsPoset.is-antisym is
+      trans = IsPoset.is-trans is
+
+    module _
+      (S : Embedding ⟨ P ⟩ ℓ'')
+      where
+        private
+          f = S .snd .fst
+        isDownset : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+        isDownset = ∀ x → ∀ y → y ≤ f x → y ∈ₑ S
+
+        isPropIsDownset : isProp isDownset
+        isPropIsDownset = isPropΠ3 λ _ y _ → isProp∈ₑ y S
+
+        isUpset : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+        isUpset = ∀ x → ∀ y → f x ≤ y → y ∈ₑ S
+
+        isPropIsUpset : isProp isUpset
+        isPropIsUpset = isPropΠ3 λ _ y _ → isProp∈ₑ y S
+
+    module _
+      (A : Embedding ⟨ P ⟩ ℓ₀)
+      (B : Embedding ⟨ P ⟩ ℓ₁)
+      where
+        module _
+          (downA : isDownset A)
+          (downB : isDownset B)
+          where
+            isDownset∩ : isDownset (A ∩ₑ B)
+            isDownset∩ (x , (a , a≡x) , (b , b≡x)) y y≤x
+              = (y , (downA a y (subst (y ≤_) (sym a≡x) y≤x) ,
+                      downB b y (subst (y ≤_) (sym b≡x) y≤x))) , refl
+
+            isDownset∪ : isDownset (A ∪ₑ B)
+            isDownset∪ (x , A⊎B) y y≤x
+              = ∥₁.rec (isProp∈ₑ y (A ∪ₑ B))
+                       (⊎.rec (λ { (a , a≡x) →
+                              (y , ∣ inl (downA a y (subst (y ≤_)
+                                                           (sym a≡x) y≤x)) ∣₁) , refl })
+                              (λ { (b , b≡x) →
+                              (y , ∣ inr (downB b y (subst (y ≤_)
+                                                           (sym b≡x) y≤x)) ∣₁) , refl })) A⊎B
+
+        module _
+          (upA : isUpset A)
+          (upB : isUpset B)
+          where
+            isUpset∩ : isUpset (A ∩ₑ B)
+            isUpset∩ (x , (a , a≡x) , (b , b≡x)) y x≤y
+              = (y , (upA a y (subst (_≤ y) (sym a≡x) x≤y) ,
+                      upB b y (subst (_≤ y) (sym b≡x) x≤y))) , refl
+
+            isUpset∪ : isUpset (A ∪ₑ B)
+            isUpset∪ (x , A⊎B) y x≤y
+              = ∥₁.rec (isProp∈ₑ y (A ∪ₑ B))
+                       (⊎.rec (λ { (a , a≡x) →
+                              (y , ∣ inl (upA a y (subst (_≤ y)
+                                                         (sym a≡x) x≤y)) ∣₁) , refl })
+                              (λ { (b , b≡x) →
+                              (y , ∣ inr (upB b y (subst (_≤ y)
+                                                         (sym b≡x) x≤y)) ∣₁) , refl })) A⊎B
+
+    module _
+      {I : Type ℓ''}
+      (S : I → Embedding ⟨ P ⟩ ℓ''')
+      where
+        module _
+          (downS : ∀ i → isDownset (S i))
+          where
+            isDownset⋂ : isDownset (⋂ₑ S)
+            isDownset⋂ (x , ∀x) y y≤x
+              = (y , λ i → downS i (∀x i .fst) y (subst (y ≤_) (sym (∀x i .snd)) y≤x)) , refl
+
+            isDownset⋃ : isDownset (⋃ₑ S)
+            isDownset⋃ (x , ∃i) y y≤x
+              = (y , (∥₁.map (λ { (i , a , a≡x) → i , downS i a y (subst (y ≤_) (sym a≡x) y≤x) }) ∃i)) , refl
+
+        module _
+          (upS : ∀ i → isUpset (S i))
+          where
+            isUpset⋂ : isUpset (⋂ₑ S)
+            isUpset⋂ (x , ∀x) y x≤y
+              = (y , λ i → upS i (∀x i .fst) y (subst (_≤ y) (sym (∀x i .snd)) x≤y)) , refl
+
+            isUpset⋃ : isUpset (⋃ₑ S)
+            isUpset⋃ (x , ∃i) y x≤y
+              = (y , (∥₁.map (λ { (i , a , a≡x) → i , upS i a y (subst (_≤ y) (sym a≡x) x≤y)  }) ∃i)) , refl
+
+
+    module _
+      (x : ⟨ P ⟩)
+      where
+        principalDownset : Embedding ⟨ P ⟩ (ℓ-max ℓ ℓ')
+        principalDownset = (Σ[ y ∈ ⟨ P ⟩ ] y ≤ x) , EmbeddingΣProp λ _ → prop _ x
+
+        principalUpset : Embedding ⟨ P ⟩ (ℓ-max ℓ ℓ')
+        principalUpset = (Σ[ y ∈ ⟨ P ⟩ ] x ≤ y) , EmbeddingΣProp λ _ → prop x _
+
+    isDownsetPrincipalDownset : ∀ x → isDownset (principalDownset x)
+    isDownsetPrincipalDownset x (y , y≤x) z z≤y = (z , (trans z y x z≤y y≤x)) , refl
+
+    isUpsetPrincipalUpset : ∀ x → isUpset (principalUpset x)
+    isUpsetPrincipalUpset x (y , x≤y) z y≤z = (z , (trans x y z x≤y y≤z)) , refl
+
+    principalDownsetMembership : ∀ x y
+                               → x ≤ y
+                               ≃ x ∈ₑ principalDownset y
+    principalDownsetMembership x y
+      = propBiimpl→Equiv (prop x y)
+                         (isProp∈ₑ x (principalDownset y))
+                         (λ x≤y → (x , x≤y) , refl)
+                          λ { ((a , a≤y) , fib) → subst (_≤ y) fib a≤y}
+
+    principalUpsetMembership : ∀ x y
+                             → x ≤ y
+                             ≃ y ∈ₑ principalUpset x
+    principalUpsetMembership x y
+      = propBiimpl→Equiv (prop x y)
+                         (isProp∈ₑ y (principalUpset x))
+                         (λ x≤y → (y , x≤y) , refl)
+                          λ { ((a , x≤a) , fib) → subst (x ≤_) fib x≤a }
+
+    principalUpsetInclusion : ∀ x y
+                            → x ≤ y
+                            → principalUpset y ⊆ₑ principalUpset x
+    principalUpsetInclusion x y x≤y z z∈y↑
+      = equivFun (principalUpsetMembership x z)
+                 (trans x y z x≤y (invEq (principalUpsetMembership y z) z∈y↑))
+
+    principalDownsetInclusion : ∀ x y
+                              → x ≤ y
+                              → principalDownset x ⊆ₑ principalDownset y
+    principalDownsetInclusion x y x≤y z z∈x↓
+      = equivFun (principalDownsetMembership z y)
+                 (trans z x y (invEq (principalDownsetMembership z x) z∈x↓) x≤y)
+
+    module _
+      (S : Embedding ⟨ P ⟩ (ℓ-max ℓ ℓ'))
+      where
+        isPrincipalDownset : Type _
+        isPrincipalDownset = Σ[ x ∈ ⟨ P ⟩ ] S ≡ (principalDownset x)
+
+        isPropIsPrincipalDownset : isProp isPrincipalDownset
+        isPropIsPrincipalDownset (x , S≡x↓) (y , S≡y↓)
+          = Σ≡Prop (λ x → isSetEmbedding S (principalDownset x))
+                    (anti x y x≤y y≤x)
+          where x≤y : x ≤ y
+                x≤y = invEq (principalDownsetMembership x y)
+                            (subst (x ∈ₑ_)
+                                   (sym S≡x↓ ∙ S≡y↓)
+                                   (equivFun (principalDownsetMembership x x) (rfl x)))
+
+                y≤x : y ≤ x
+                y≤x = invEq (principalDownsetMembership y x)
+                            (subst (y ∈ₑ_)
+                                   (sym S≡y↓ ∙ S≡x↓)
+                                   (equivFun (principalDownsetMembership y y) (rfl y)))
+
+        isPrincipalUpset : Type _
+        isPrincipalUpset = Σ[ x ∈ ⟨ P ⟩ ] S ≡ (principalUpset x)
+
+        isPropIsPrincipalUpset : isProp isPrincipalUpset
+        isPropIsPrincipalUpset (x , S≡x↑) (y , S≡y↑)
+          = Σ≡Prop (λ x → isSetEmbedding S (principalUpset x))
+                    (anti x y x≤y y≤x)
+          where x≤y : x ≤ y
+                x≤y = invEq (principalUpsetMembership x y)
+                             (subst (y ∈ₑ_)
+                                    (sym S≡y↑ ∙ S≡x↑)
+                                    (equivFun (principalUpsetMembership y y) (rfl y)))
+
+                y≤x : y ≤ x
+                y≤x = invEq (principalUpsetMembership y x)
+                            (subst (x ∈ₑ_)
+                                   (sym S≡x↑ ∙ S≡y↑)
+                                   (equivFun (principalUpsetMembership x x) (rfl x)))
+
+        isPrincipalDownset→isDownset : isPrincipalDownset → (isDownset S)
+        isPrincipalDownset→isDownset (x , p) = transport⁻ (cong isDownset p) (isDownsetPrincipalDownset x)
+
+        isPrincipalUpset→isUpset : isPrincipalUpset → (isUpset S)
+        isPrincipalUpset→isUpset (x , p) = transport⁻ (cong isUpset p) (isUpsetPrincipalUpset x)
+
+module PosetDownset (P' : Poset ℓ ℓ') where
+  private P = ⟨ P' ⟩
+  open PosetStr (snd P')
+
+  ↓ : P → Type (ℓ-max ℓ ℓ')
+  ↓ u = principalDownset P' u .fst
+
+  ↓ᴾ : P → Poset (ℓ-max ℓ ℓ') ℓ'
+  fst (↓ᴾ u) = ↓ u
+  PosetStr._≤_ (snd (↓ᴾ u)) v w = v .fst ≤ w .fst
+  PosetStr.isPoset (snd (↓ᴾ u)) =
+    isPosetInduced
+      (PosetStr.isPoset (snd P'))
+       _
+      (principalDownset P' u .snd)
+
+module PosetUpset (P' : Poset ℓ ℓ') where
+  private P = ⟨ P' ⟩
+  open PosetStr (snd P')
+
+  ↑ : P → Type (ℓ-max ℓ ℓ')
+  ↑ u = principalUpset P' u .fst
+
+  ↑ᴾ : P → Poset (ℓ-max ℓ ℓ') ℓ'
+  fst (↑ᴾ u) = principalUpset P' u .fst
+  PosetStr._≤_ (snd (↑ᴾ u)) v w = v .fst ≤ w .fst
+  PosetStr.isPoset (snd (↑ᴾ u)) =
+    isPosetInduced
+      (PosetStr.isPoset (snd P'))
+       _
+      (principalUpset P' u .snd)
diff --git a/Cubical/Relation/Binary/Order/Preorder.agda b/Cubical/Relation/Binary/Order/Preorder.agda
deleted file mode 100644
index 6b9ce2af2f..0000000000
--- a/Cubical/Relation/Binary/Order/Preorder.agda
+++ /dev/null
@@ -1,5 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.Preorder where
-
-open import Cubical.Relation.Binary.Order.Preorder.Base public
-open import Cubical.Relation.Binary.Order.Preorder.Properties public
diff --git a/Cubical/Relation/Binary/Order/Preorder/Base.agda b/Cubical/Relation/Binary/Order/Preorder/Base.agda
deleted file mode 100644
index 5bf7dfd797..0000000000
--- a/Cubical/Relation/Binary/Order/Preorder/Base.agda
+++ /dev/null
@@ -1,135 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.Preorder.Base where
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.Equiv
-open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.Univalence
-open import Cubical.Foundations.Transport
-open import Cubical.Foundations.SIP
-
-open import Cubical.Data.Sigma
-
-open import Cubical.Reflection.RecordEquiv
-open import Cubical.Reflection.StrictEquiv
-
-open import Cubical.Displayed.Base
-open import Cubical.Displayed.Auto
-open import Cubical.Displayed.Record
-open import Cubical.Displayed.Universe
-
-open import Cubical.Relation.Binary.Base
-
-open Iso
-open BinaryRelation
-
-
-private
-  variable
-    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
-
-record IsPreorder {A : Type ℓ} (_≲_ : A → A → Type ℓ') : Type (ℓ-max ℓ ℓ') where
-  no-eta-equality
-  constructor ispreorder
-
-  field
-    is-set : isSet A
-    is-prop-valued : isPropValued _≲_
-    is-refl : isRefl _≲_
-    is-trans : isTrans _≲_
-
-unquoteDecl IsPreorderIsoΣ = declareRecordIsoΣ IsPreorderIsoΣ (quote IsPreorder)
-
-
-record PreorderStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')) where
-
-  constructor preorderstr
-
-  field
-    _≲_     : A → A → Type ℓ'
-    isPreorder : IsPreorder _≲_
-
-  infixl 7 _≲_
-
-  open IsPreorder isPreorder public
-
-Preorder : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
-Preorder ℓ ℓ' = TypeWithStr ℓ (PreorderStr ℓ')
-
-preorder : (A : Type ℓ) (_≲_ : A → A → Type ℓ') (h : IsPreorder _≲_) → Preorder ℓ ℓ'
-preorder A _≲_ h = A , preorderstr _≲_ h
-
-record IsPreorderEquiv {A : Type ℓ₀} {B : Type ℓ₁}
-  (M : PreorderStr ℓ₀' A) (e : A ≃ B) (N : PreorderStr ℓ₁' B)
-  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
-  where
-  constructor
-   ispreorderequiv
-  -- Shorter qualified names
-  private
-    module M = PreorderStr M
-    module N = PreorderStr N
-
-  field
-    pres≲ : (x y : A) → x M.≲ y ≃ equivFun e x N.≲ equivFun e y
-
-
-PreorderEquiv : (M : Preorder ℓ₀ ℓ₀') (M : Preorder ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
-PreorderEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsPreorderEquiv (M .snd) e (N .snd)
-
-isPropIsPreorder : {A : Type ℓ} (_≲_ : A → A → Type ℓ') → isProp (IsPreorder _≲_)
-isPropIsPreorder _≲_ = isOfHLevelRetractFromIso 1 IsPreorderIsoΣ
-  (isPropΣ isPropIsSet
-    λ isSetA → isPropΣ (isPropΠ2 (λ _ _ → isPropIsProp))
-      λ isPropValued≲ → isProp×
-                        (isPropΠ (λ _ → isPropValued≲ _ _))
-                        (isPropΠ4 λ _ _ _ _ → isPropΠ λ _ → isPropValued≲ _ _))
-
-𝒮ᴰ-Preorder : DUARel (𝒮-Univ ℓ) (PreorderStr ℓ') (ℓ-max ℓ ℓ')
-𝒮ᴰ-Preorder =
-  𝒮ᴰ-Record (𝒮-Univ _) IsPreorderEquiv
-    (fields:
-      data[ _≲_ ∣ autoDUARel _ _ ∣ pres≲ ]
-      prop[ isPreorder ∣ (λ _ _ → isPropIsPreorder _) ])
-    where
-    open PreorderStr
-    open IsPreorder
-    open IsPreorderEquiv
-
-PreorderPath : (M N : Preorder ℓ ℓ') → PreorderEquiv M N ≃ (M ≡ N)
-PreorderPath = ∫ 𝒮ᴰ-Preorder .UARel.ua
-
--- an easier way of establishing an equivalence of preorders
-module _ {P : Preorder ℓ₀ ℓ₀'} {S : Preorder ℓ₁ ℓ₁'} (e : ⟨ P ⟩ ≃ ⟨ S ⟩) where
-  private
-    module P = PreorderStr (P .snd)
-    module S = PreorderStr (S .snd)
-
-  module _ (isMon : ∀ x y → x P.≲ y → equivFun e x S.≲ equivFun e y)
-           (isMonInv : ∀ x y → x S.≲ y → invEq e x P.≲ invEq e y) where
-    open IsPreorderEquiv
-    open IsPreorder
-
-    makeIsPreorderEquiv : IsPreorderEquiv (P .snd) e (S .snd)
-    pres≲ makeIsPreorderEquiv x y = propBiimpl→Equiv (P.isPreorder .is-prop-valued _ _)
-                                                  (S.isPreorder .is-prop-valued _ _)
-                                                  (isMon _ _) (isMonInv' _ _)
-      where
-      isMonInv' : ∀ x y → equivFun e x S.≲ equivFun e y → x P.≲ y
-      isMonInv' x y ex≲ey = transport (λ i → retEq e x i P.≲ retEq e y i) (isMonInv _ _ ex≲ey)
-
-
-module PreorderReasoning (P' : Preorder ℓ ℓ') where
- private P = fst P'
- open PreorderStr (snd P')
- open IsPreorder
-
- _≲⟨_⟩_ : (x : P) {y z : P} → x ≲ y → y ≲ z → x ≲ z
- x ≲⟨ p ⟩ q = isPreorder .is-trans x _ _ p q
-
- _◾ : (x : P) → x ≲ x
- x ◾ = isPreorder .is-refl x
-
- infixr 0 _≲⟨_⟩_
- infix  1 _◾
diff --git a/Cubical/Relation/Binary/Order/Preorder/Properties.agda b/Cubical/Relation/Binary/Order/Preorder/Properties.agda
deleted file mode 100644
index deec933ddf..0000000000
--- a/Cubical/Relation/Binary/Order/Preorder/Properties.agda
+++ /dev/null
@@ -1,57 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.Preorder.Properties where
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.HLevels
-
-open import Cubical.Functions.Embedding
-
-open import Cubical.HITs.PropositionalTruncation as ∥₁
-
-open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Preorder.Base
-open import Cubical.Relation.Binary.Order.StrictPoset.Base
-
-open import Cubical.Relation.Nullary
-
-private
-  variable
-    ℓ ℓ' ℓ'' : Level
-
-module _
-  {A : Type ℓ}
-  {R : Rel A A ℓ'}
-  where
-
-  open BinaryRelation
-
-  isPreorder→isEquivRelSymKernel : IsPreorder R → isEquivRel (SymKernel R)
-  isPreorder→isEquivRelSymKernel preorder
-    = equivRel (λ a → (IsPreorder.is-refl preorder a)
-                    , (IsPreorder.is-refl preorder a))
-               (isSymSymKernel R)
-               (λ a b c (Rab , Rba) (Rbc , Rcb)
-                 → IsPreorder.is-trans preorder a b c Rab Rbc
-                 , IsPreorder.is-trans preorder c b a Rcb Rba)
-
-  isPreorder→isStrictPosetAsymKernel : IsPreorder R → IsStrictPoset (AsymKernel R)
-  isPreorder→isStrictPosetAsymKernel preorder
-    = isstrictposet (IsPreorder.is-set preorder)
-                    (λ a b → isProp× (IsPreorder.is-prop-valued preorder a b) (isProp¬ (R b a)))
-                    (λ a (Raa , ¬Raa) → ¬Raa (IsPreorder.is-refl preorder a))
-                    (λ a b c (Rab , ¬Rba) (Rbc , ¬Rcb)
-                      → IsPreorder.is-trans preorder a b c Rab Rbc
-                      , λ Rca → ¬Rcb (IsPreorder.is-trans preorder c a b Rca Rab))
-                    (isAsymAsymKernel R)
-
-  isPreorderInduced : IsPreorder R → (B : Type ℓ'') → (f : B ↪ A) → IsPreorder (InducedRelation R (B , f))
-  isPreorderInduced pre B (f , emb)
-    = ispreorder (Embedding-into-isSet→isSet (f , emb) (IsPreorder.is-set pre))
-                 (λ a b → IsPreorder.is-prop-valued pre (f a) (f b))
-                 (λ a → IsPreorder.is-refl pre (f a))
-                 λ a b c → IsPreorder.is-trans pre (f a) (f b) (f c)
-
-Preorder→StrictPoset : Preorder ℓ ℓ' → StrictPoset ℓ ℓ'
-Preorder→StrictPoset (_ , pre)
-  = _ , strictposetstr (BinaryRelation.AsymKernel (PreorderStr._≲_ pre))
-                       (isPreorder→isStrictPosetAsymKernel (PreorderStr.isPreorder pre))
diff --git a/Cubical/Relation/Binary/Order/Properties.agda b/Cubical/Relation/Binary/Order/Properties.agda
deleted file mode 100644
index 5f1eaaafdb..0000000000
--- a/Cubical/Relation/Binary/Order/Properties.agda
+++ /dev/null
@@ -1,302 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.Properties where
-
-open import Cubical.Data.Sigma
-open import Cubical.Data.Sum as ⊎
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.HLevels
-
-open import Cubical.Functions.Embedding
-
-open import Cubical.HITs.PropositionalTruncation as ∥₁
-
-open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Poset
-open import Cubical.Relation.Binary.Order.Toset
-open import Cubical.Relation.Binary.Order.Preorder.Base
-
-private
-  variable
-    ℓ ℓ' ℓ'' : Level
-
-module _
-  {A : Type ℓ}
-  {_≲_ : Rel A A ℓ'}
-  (pre : IsPreorder _≲_)
-  where
-
-  private
-      prop : ∀ a b → isProp (a ≲ b)
-      prop = IsPreorder.is-prop-valued pre
-
-  module _
-    (P : Embedding A ℓ'')
-    where
-
-    private
-      subtype : Type ℓ''
-      subtype = fst P
-
-      toA : subtype → A
-      toA = fst (snd P)
-
-    isMinimal : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
-    isMinimal n = (x : subtype) → toA x ≲ toA n → toA n ≲ toA x
-
-    isPropIsMinimal : ∀ n → isProp (isMinimal n)
-    isPropIsMinimal n = isPropΠ2 λ x _ → prop (toA n) (toA x)
-
-    Minimal : Type (ℓ-max ℓ' ℓ'')
-    Minimal = Σ[ n ∈ subtype ] isMinimal n
-
-    isMaximal : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
-    isMaximal n = (x : subtype) → toA n ≲ toA x → toA x ≲ toA n
-
-    isPropIsMaximal : ∀ n → isProp (isMaximal n)
-    isPropIsMaximal n = isPropΠ2 λ x _ → prop (toA x) (toA n)
-
-    Maximal : Type (ℓ-max ℓ' ℓ'')
-    Maximal = Σ[ n ∈ subtype ] isMaximal n
-
-    isLeast : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
-    isLeast n = (x : subtype) → toA n ≲ toA x
-
-    isPropIsLeast : ∀ n → isProp (isLeast n)
-    isPropIsLeast n = isPropΠ λ x → prop (toA n) (toA x)
-
-    Least : Type (ℓ-max ℓ' ℓ'')
-    Least = Σ[ n ∈ subtype ] isLeast n
-
-    isGreatest : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
-    isGreatest n = (x : subtype) → toA x ≲ toA n
-
-    isPropIsGreatest : ∀ n → isProp (isGreatest n)
-    isPropIsGreatest n = isPropΠ λ x → prop (toA x) (toA n)
-
-    Greatest : Type (ℓ-max ℓ' ℓ'')
-    Greatest = Σ[ n ∈ subtype ] isGreatest n
-
-  module _
-    {B : Type ℓ''}
-    (P : B → A)
-    where
-
-    isLowerBound : (n : A) → Type (ℓ-max ℓ' ℓ'')
-    isLowerBound n = (x : B) → n ≲ P x
-
-    isPropIsLowerBound : ∀ n → isProp (isLowerBound n)
-    isPropIsLowerBound n = isPropΠ λ x → prop n (P x)
-
-    LowerBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    LowerBound = Σ[ n ∈ A ] isLowerBound n
-
-    isUpperBound : (n : A) → Type (ℓ-max ℓ' ℓ'')
-    isUpperBound n = (x : B) → P x ≲ n
-
-    isPropIsUpperBound : ∀ n → isProp (isUpperBound n)
-    isPropIsUpperBound n = isPropΠ λ x → prop (P x) n
-
-    UpperBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    UpperBound = Σ[ n ∈ A ] isUpperBound n
-
-  module _
-    {B : Type ℓ''}
-    (P : B → A)
-    where
-
-    isMaximalLowerBound : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    isMaximalLowerBound n
-      = Σ[ islb ∈ isLowerBound P n ]
-        isMaximal (LowerBound P
-                  , (EmbeddingΣProp (isPropIsLowerBound P))) (n , islb)
-
-    isPropIsMaximalLowerBound : ∀ n → isProp (isMaximalLowerBound n)
-    isPropIsMaximalLowerBound n
-      = isPropΣ (isPropIsLowerBound P n)
-                λ islb → isPropIsMaximal (LowerBound P
-                       , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
-
-    MaximalLowerBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    MaximalLowerBound = Σ[ n ∈ A ] isMaximalLowerBound n
-
-    isMinimalUpperBound : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    isMinimalUpperBound n
-      = Σ[ isub ∈ isUpperBound P n ]
-        isMinimal (UpperBound P
-                  , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
-
-    isPropIsMinimalUpperBound : ∀ n → isProp (isMinimalUpperBound n)
-    isPropIsMinimalUpperBound n
-      = isPropΣ (isPropIsUpperBound P n)
-                λ isub → isPropIsMinimal (UpperBound P
-                       , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
-
-    MinimalUpperBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    MinimalUpperBound = Σ[ n ∈ A ] isMinimalUpperBound n
-
-    isInfimum : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    isInfimum n
-      = Σ[ islb ∈ isLowerBound P n ]
-        isGreatest (LowerBound P
-                   , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
-
-    isPropIsInfimum : ∀ n → isProp (isInfimum n)
-    isPropIsInfimum n
-      = isPropΣ (isPropIsLowerBound P n)
-                λ islb → isPropIsGreatest (LowerBound P
-                       , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
-
-    Infimum : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    Infimum = Σ[ n ∈ A ] isInfimum n
-
-    isSupremum : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    isSupremum n
-      = Σ[ isub ∈ isUpperBound P n ]
-        isLeast (UpperBound P
-                , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
-
-    isPropIsSupremum : ∀ n → isProp (isSupremum n)
-    isPropIsSupremum n
-      = isPropΣ (isPropIsUpperBound P n)
-                λ isub → isPropIsLeast (UpperBound P
-                       , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
-
-    Supremum : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    Supremum = Σ[ n ∈ A ] isSupremum n
-
-module _
-  {A : Type ℓ}
-  {_≲_ : Rel A A ℓ'}
-  (pre : IsPreorder _≲_)
-  where
-
-  module _
-    {P : Embedding A ℓ''}
-    where
-
-    private
-      toA : (fst P) → A
-      toA = fst (snd P)
-
-    isLeast→isMinimal : ∀ n → isLeast pre P n → isMinimal pre P n
-    isLeast→isMinimal _ isl x _ = isl x
-
-    isGreatest→isMaximal : ∀ n → isGreatest pre P n → isMaximal pre P n
-    isGreatest→isMaximal _ isg x _ = isg x
-
-    isLeast→isLowerBound : ∀ n → isLeast pre P n → isLowerBound pre toA (toA n)
-    isLeast→isLowerBound _ isl = isl
-
-    isGreatest→isUpperBound : ∀ n → isGreatest pre P n → isUpperBound pre toA (toA n)
-    isGreatest→isUpperBound _ isg = isg
-
-    isLeast→isInfimum : ∀ n → isLeast pre P n → isInfimum pre toA (toA n)
-    isLeast→isInfimum n isl = (isLeast→isLowerBound n isl) , (λ x → snd x n)
-
-    isGreatest→isSupremum : ∀ n → isGreatest pre P n → isSupremum pre toA (toA n)
-    isGreatest→isSupremum n isg = (isGreatest→isUpperBound n isg) , (λ x → snd x n)
-
-  module _
-    {B : Type ℓ''}
-    {P : B → A}
-    where
-
-    isInfimum→isLowerBound : ∀ n → isInfimum pre P n → isLowerBound pre P n
-    isInfimum→isLowerBound _ = fst
-
-    isSupremum→isUpperBound : ∀ n → isSupremum pre P n → isUpperBound pre P n
-    isSupremum→isUpperBound _ = fst
-
-module _
-  {A : Type ℓ}
-  {_≤_ : Rel A A ℓ'}
-  (pos : IsPoset _≤_)
-  where
-
-  private
-    pre : IsPreorder _≤_
-    pre = isPoset→isPreorder pos
-
-    anti : BinaryRelation.isAntisym _≤_
-    anti = IsPoset.is-antisym pos
-
-  module _
-    {P : Embedding A ℓ''}
-    where
-
-    private
-      toA : (fst P) → A
-      toA = fst (snd P)
-
-      emb : isEmbedding toA
-      emb = snd (snd P)
-
-    isLeast→ContrMinimal : ∀ n → isLeast pre P n  → ∀ m → isMinimal pre P m → n ≡ m
-    isLeast→ContrMinimal n isln m ismm
-      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isln m) (ismm n (isln m)))
-
-    isGreatest→ContrMaximal : ∀ n → isGreatest pre P n → ∀ m → isMaximal pre P m → n ≡ m
-    isGreatest→ContrMaximal n isgn m ismm
-      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (ismm n (isgn m)) (isgn m))
-
-    isLeastUnique : ∀ n m → isLeast pre P n → isLeast pre P m → n ≡ m
-    isLeastUnique n m isln islm
-      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isln m) (islm n))
-
-    isGreatestUnique : ∀ n m → isGreatest pre P n → isGreatest pre P m → n ≡ m
-    isGreatestUnique n m isgn isgm
-      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isgm n) (isgn m))
-
-  module _
-    {B : Type ℓ''}
-    {P : B → A}
-    where
-
-    isInfimum→ContrMaximalLowerBound : ∀ n → isInfimum pre P n
-                                     → ∀ m → isMaximalLowerBound pre P m
-                                     → n ≡ m
-    isInfimum→ContrMaximalLowerBound n (isln , isglbn) m (islm , ismlbm)
-      = anti n m (ismlbm (n , isln) (isglbn (m , islm))) (isglbn (m , islm))
-
-    isSupremum→ContrMinimalUpperBound : ∀ n → isSupremum pre P n
-                                      → ∀ m → isMinimalUpperBound pre P m
-                                      → n ≡ m
-    isSupremum→ContrMinimalUpperBound n (isun , islubn) m (isum , ismubm)
-      = anti n m (islubn (m , isum)) (ismubm (n , isun) (islubn (m , isum)))
-
-    isInfimumUnique : ∀ n m → isInfimum pre P n → isInfimum pre P m → n ≡ m
-    isInfimumUnique n m (isln , infn) (islm , infm)
-      = anti n m (infm (n , isln)) (infn (m , islm))
-
-    isSupremumUnique : ∀ n m → isSupremum pre P n → isSupremum pre P m → n ≡ m
-    isSupremumUnique n m (isun , supn) (isum , supm)
-      = anti n m (supn (m , isum)) (supm (n , isun))
-
-module _
-  {A : Type ℓ}
-  {P : Embedding A ℓ''}
-  {_≤_ : Rel A A ℓ'}
-  (tos : IsToset _≤_)
-  where
-
-  private
-    prop : ∀ a b → isProp (a ≤ b)
-    prop = IsToset.is-prop-valued tos
-
-    conn : BinaryRelation.isStronglyConnected _≤_
-    conn = IsToset.is-strongly-connected tos
-
-    pre : IsPreorder _≤_
-    pre = isPoset→isPreorder (isToset→isPoset tos)
-
-    toA : (fst P) → A
-    toA = fst (snd P)
-
-  isMinimal→isLeast : ∀ n → isMinimal pre P n → isLeast pre P n
-  isMinimal→isLeast n ism m
-    = ∥₁.rec (prop _ _) (⊎.rec (λ n≤m → n≤m) (λ m≤n → ism m m≤n)) (conn (toA n) (toA m))
-
-  isMaximal→isGreatest : ∀ n → isMaximal pre P n → isGreatest pre P n
-  isMaximal→isGreatest n ism m
-    = ∥₁.rec (prop _ _) (⊎.rec (λ n≤m → ism m n≤m) (λ m≤n → m≤n)) (conn (toA n) (toA m))
diff --git a/Cubical/Relation/Binary/Order/Proset.agda b/Cubical/Relation/Binary/Order/Proset.agda
new file mode 100644
index 0000000000..c96c4cc15c
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Proset.agda
@@ -0,0 +1,5 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Proset where
+
+open import Cubical.Relation.Binary.Order.Proset.Base public
+open import Cubical.Relation.Binary.Order.Proset.Properties public
diff --git a/Cubical/Relation/Binary/Order/Proset/Base.agda b/Cubical/Relation/Binary/Order/Proset/Base.agda
new file mode 100644
index 0000000000..dc80d72b29
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Proset/Base.agda
@@ -0,0 +1,138 @@
+{-# OPTIONS --safe #-}
+{-
+  Prosets are preordered sets; a set with a reflexive, transitive relation
+-}
+module Cubical.Relation.Binary.Order.Proset.Base where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.SIP
+
+open import Cubical.Data.Sigma
+
+open import Cubical.Reflection.RecordEquiv
+open import Cubical.Reflection.StrictEquiv
+
+open import Cubical.Displayed.Base
+open import Cubical.Displayed.Auto
+open import Cubical.Displayed.Record
+open import Cubical.Displayed.Universe
+
+open import Cubical.Relation.Binary.Base
+
+open Iso
+open BinaryRelation
+
+
+private
+  variable
+    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
+
+record IsProset {A : Type ℓ} (_≲_ : A → A → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+  no-eta-equality
+  constructor isproset
+
+  field
+    is-set : isSet A
+    is-prop-valued : isPropValued _≲_
+    is-refl : isRefl _≲_
+    is-trans : isTrans _≲_
+
+unquoteDecl IsProsetIsoΣ = declareRecordIsoΣ IsProsetIsoΣ (quote IsProset)
+
+
+record ProsetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')) where
+
+  constructor prosetstr
+
+  field
+    _≲_     : A → A → Type ℓ'
+    isProset : IsProset _≲_
+
+  infixl 7 _≲_
+
+  open IsProset isProset public
+
+Proset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
+Proset ℓ ℓ' = TypeWithStr ℓ (ProsetStr ℓ')
+
+proset : (A : Type ℓ) → (_≲_ : Rel A A ℓ') → IsProset _≲_ → Proset ℓ ℓ'
+proset A _≲_ pros = A , (prosetstr _≲_ pros)
+
+record IsProsetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
+  (M : ProsetStr ℓ₀' A) (e : A ≃ B) (N : ProsetStr ℓ₁' B)
+  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
+  where
+  constructor
+   isprosetequiv
+  -- Shorter qualified names
+  private
+    module M = ProsetStr M
+    module N = ProsetStr N
+
+  field
+    pres≲ : (x y : A) → x M.≲ y ≃ equivFun e x N.≲ equivFun e y
+
+
+ProsetEquiv : (M : Proset ℓ₀ ℓ₀') (M : Proset ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
+ProsetEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsProsetEquiv (M .snd) e (N .snd)
+
+isPropIsProset : {A : Type ℓ} (_≲_ : A → A → Type ℓ') → isProp (IsProset _≲_)
+isPropIsProset _≲_ = isOfHLevelRetractFromIso 1 IsProsetIsoΣ
+  (isPropΣ isPropIsSet
+    λ isSetA → isPropΣ (isPropΠ2 (λ _ _ → isPropIsProp))
+      λ isPropValued≲ → isProp×
+                        (isPropΠ (λ _ → isPropValued≲ _ _))
+                        (isPropΠ4 λ _ _ _ _ → isPropΠ λ _ → isPropValued≲ _ _))
+
+𝒮ᴰ-Proset : DUARel (𝒮-Univ ℓ) (ProsetStr ℓ') (ℓ-max ℓ ℓ')
+𝒮ᴰ-Proset =
+  𝒮ᴰ-Record (𝒮-Univ _) IsProsetEquiv
+    (fields:
+      data[ _≲_ ∣ autoDUARel _ _ ∣ pres≲ ]
+      prop[ isProset ∣ (λ _ _ → isPropIsProset _) ])
+    where
+    open ProsetStr
+    open IsProset
+    open IsProsetEquiv
+
+ProsetPath : (M N : Proset ℓ ℓ') → ProsetEquiv M N ≃ (M ≡ N)
+ProsetPath = ∫ 𝒮ᴰ-Proset .UARel.ua
+
+-- an easier way of establishing an equivalence of prosets
+module _ {P : Proset ℓ₀ ℓ₀'} {S : Proset ℓ₁ ℓ₁'} (e : ⟨ P ⟩ ≃ ⟨ S ⟩) where
+  private
+    module P = ProsetStr (P .snd)
+    module S = ProsetStr (S .snd)
+
+  module _ (isMon : ∀ x y → x P.≲ y → equivFun e x S.≲ equivFun e y)
+           (isMonInv : ∀ x y → x S.≲ y → invEq e x P.≲ invEq e y) where
+    open IsProsetEquiv
+    open IsProset
+
+    makeIsProsetEquiv : IsProsetEquiv (P .snd) e (S .snd)
+    pres≲ makeIsProsetEquiv x y = propBiimpl→Equiv (P.isProset .is-prop-valued _ _)
+                                                  (S.isProset .is-prop-valued _ _)
+                                                  (isMon _ _) (isMonInv' _ _)
+      where
+      isMonInv' : ∀ x y → equivFun e x S.≲ equivFun e y → x P.≲ y
+      isMonInv' x y ex≲ey = transport (λ i → retEq e x i P.≲ retEq e y i) (isMonInv _ _ ex≲ey)
+
+
+module ProsetReasoning (P' : Proset ℓ ℓ') where
+ private P = fst P'
+ open ProsetStr (snd P')
+ open IsProset
+
+ _≲⟨_⟩_ : (x : P) {y z : P} → x ≲ y → y ≲ z → x ≲ z
+ x ≲⟨ p ⟩ q = isProset .is-trans x _ _ p q
+
+ _◾ : (x : P) → x ≲ x
+ x ◾ = isProset .is-refl x
+
+ infixr 0 _≲⟨_⟩_
+ infix  1 _◾
diff --git a/Cubical/Relation/Binary/Order/Proset/Properties.agda b/Cubical/Relation/Binary/Order/Proset/Properties.agda
new file mode 100644
index 0000000000..61343c624a
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Proset/Properties.agda
@@ -0,0 +1,434 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Proset.Properties where
+
+open import Cubical.Data.Sigma
+open import Cubical.Data.Sum as ⊎
+
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Functions.Embedding
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Binary.Order.Proset.Base
+open import Cubical.Relation.Binary.Order.Quoset.Base
+
+open import Cubical.Relation.Nullary
+
+private
+  variable
+    ℓ ℓ' ℓ'' : Level
+
+module _
+  {A : Type ℓ}
+  {R : Rel A A ℓ'}
+  where
+
+  open BinaryRelation
+
+  isProset→isEquivRelSymKernel : IsProset R → isEquivRel (SymKernel R)
+  isProset→isEquivRelSymKernel proset
+    = equivRel (λ a → (IsProset.is-refl proset a)
+                    , (IsProset.is-refl proset a))
+               (isSymSymKernel R)
+               (λ a b c (Rab , Rba) (Rbc , Rcb)
+                 → IsProset.is-trans proset a b c Rab Rbc
+                 , IsProset.is-trans proset c b a Rcb Rba)
+
+  isProset→isQuosetAsymKernel : IsProset R → IsQuoset (AsymKernel R)
+  isProset→isQuosetAsymKernel proset
+    = isquoset (IsProset.is-set proset)
+                    (λ a b → isProp× (IsProset.is-prop-valued proset a b) (isProp¬ (R b a)))
+                    (λ a (Raa , ¬Raa) → ¬Raa (IsProset.is-refl proset a))
+                    (λ a b c (Rab , ¬Rba) (Rbc , ¬Rcb)
+                      → IsProset.is-trans proset a b c Rab Rbc
+                      , λ Rca → ¬Rcb (IsProset.is-trans proset c a b Rca Rab))
+                    (isAsymAsymKernel R)
+
+  isProsetInduced : IsProset R → (B : Type ℓ'') → (f : B ↪ A) → IsProset (InducedRelation R (B , f))
+  isProsetInduced pre B (f , emb)
+    = isproset (Embedding-into-isSet→isSet (f , emb) (IsProset.is-set pre))
+                 (λ a b → IsProset.is-prop-valued pre (f a) (f b))
+                 (λ a → IsProset.is-refl pre (f a))
+                 λ a b c → IsProset.is-trans pre (f a) (f b) (f c)
+
+  isProsetDual : IsProset R → IsProset (Dual R)
+  isProsetDual pre
+    = isproset (IsProset.is-set pre)
+               (λ a b → IsProset.is-prop-valued pre b a)
+               (IsProset.is-refl pre) (λ a b c Rab Rbc → IsProset.is-trans pre c b a Rbc Rab)
+
+Proset→Quoset : Proset ℓ ℓ' → Quoset ℓ ℓ'
+Proset→Quoset (_ , pre)
+  = quoset _ (BinaryRelation.AsymKernel (ProsetStr._≲_ pre))
+             (isProset→isQuosetAsymKernel (ProsetStr.isProset pre))
+
+DualProset : Proset ℓ ℓ' → Proset ℓ ℓ'
+DualProset (_ , pre)
+  = proset _ (BinaryRelation.Dual (ProsetStr._≲_ pre))
+             (isProsetDual (ProsetStr.isProset pre))
+
+module _
+  {A : Type ℓ}
+  {_≲_ : Rel A A ℓ'}
+  (pre : IsProset _≲_)
+  where
+
+  private
+      prop = IsProset.is-prop-valued pre
+
+      rfl = IsProset.is-refl pre
+
+      trans = IsProset.is-trans pre
+
+  module _
+    (P : Embedding A ℓ'')
+    where
+
+    private
+      subtype = fst P
+
+      toA = fst (snd P)
+
+    isMinimal : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
+    isMinimal n = (x : subtype) → toA x ≲ toA n → toA n ≲ toA x
+
+    isPropIsMinimal : ∀ n → isProp (isMinimal n)
+    isPropIsMinimal n = isPropΠ2 λ x _ → prop (toA n) (toA x)
+
+    Minimal : Type (ℓ-max ℓ' ℓ'')
+    Minimal = Σ[ n ∈ subtype ] isMinimal n
+
+    isMaximal : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
+    isMaximal n = (x : subtype) → toA n ≲ toA x → toA x ≲ toA n
+
+    isPropIsMaximal : ∀ n → isProp (isMaximal n)
+    isPropIsMaximal n = isPropΠ2 λ x _ → prop (toA x) (toA n)
+
+    Maximal : Type (ℓ-max ℓ' ℓ'')
+    Maximal = Σ[ n ∈ subtype ] isMaximal n
+
+    isLeast : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
+    isLeast n = (x : subtype) → toA n ≲ toA x
+
+    isPropIsLeast : ∀ n → isProp (isLeast n)
+    isPropIsLeast n = isPropΠ λ x → prop (toA n) (toA x)
+
+    Least : Type (ℓ-max ℓ' ℓ'')
+    Least = Σ[ n ∈ subtype ] isLeast n
+
+    isGreatest : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
+    isGreatest n = (x : subtype) → toA x ≲ toA n
+
+    isPropIsGreatest : ∀ n → isProp (isGreatest n)
+    isPropIsGreatest n = isPropΠ λ x → prop (toA x) (toA n)
+
+    Greatest : Type (ℓ-max ℓ' ℓ'')
+    Greatest = Σ[ n ∈ subtype ] isGreatest n
+
+  module _
+    {B : Type ℓ''}
+    (P : B → A)
+    where
+
+    isLowerBound : (n : A) → Type (ℓ-max ℓ' ℓ'')
+    isLowerBound n = (x : B) → n ≲ P x
+
+    isPropIsLowerBound : ∀ n → isProp (isLowerBound n)
+    isPropIsLowerBound n = isPropΠ λ x → prop n (P x)
+
+    LowerBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    LowerBound = Σ[ n ∈ A ] isLowerBound n
+
+    isUpperBound : (n : A) → Type (ℓ-max ℓ' ℓ'')
+    isUpperBound n = (x : B) → P x ≲ n
+
+    isPropIsUpperBound : ∀ n → isProp (isUpperBound n)
+    isPropIsUpperBound n = isPropΠ λ x → prop (P x) n
+
+    UpperBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    UpperBound = Σ[ n ∈ A ] isUpperBound n
+
+  module _
+    {B : Type ℓ''}
+    (P : B → A)
+    where
+
+    isMaximalLowerBound : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    isMaximalLowerBound n
+      = Σ[ islb ∈ isLowerBound P n ]
+        isMaximal (LowerBound P
+                  , (EmbeddingΣProp (isPropIsLowerBound P))) (n , islb)
+
+    isPropIsMaximalLowerBound : ∀ n → isProp (isMaximalLowerBound n)
+    isPropIsMaximalLowerBound n
+      = isPropΣ (isPropIsLowerBound P n)
+                λ islb → isPropIsMaximal (LowerBound P
+                       , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
+
+    MaximalLowerBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    MaximalLowerBound = Σ[ n ∈ A ] isMaximalLowerBound n
+
+    isMinimalUpperBound : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    isMinimalUpperBound n
+      = Σ[ isub ∈ isUpperBound P n ]
+        isMinimal (UpperBound P
+                  , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
+
+    isPropIsMinimalUpperBound : ∀ n → isProp (isMinimalUpperBound n)
+    isPropIsMinimalUpperBound n
+      = isPropΣ (isPropIsUpperBound P n)
+                λ isub → isPropIsMinimal (UpperBound P
+                       , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
+
+    MinimalUpperBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    MinimalUpperBound = Σ[ n ∈ A ] isMinimalUpperBound n
+
+    isInfimum : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    isInfimum n
+      = Σ[ islb ∈ isLowerBound P n ]
+        isGreatest (LowerBound P
+                   , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
+
+    isPropIsInfimum : ∀ n → isProp (isInfimum n)
+    isPropIsInfimum n
+      = isPropΣ (isPropIsLowerBound P n)
+                λ islb → isPropIsGreatest (LowerBound P
+                       , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
+
+    Infimum : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    Infimum = Σ[ n ∈ A ] isInfimum n
+
+    isSupremum : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    isSupremum n
+      = Σ[ isub ∈ isUpperBound P n ]
+        isLeast (UpperBound P
+                , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
+
+    isPropIsSupremum : ∀ n → isProp (isSupremum n)
+    isPropIsSupremum n
+      = isPropΣ (isPropIsUpperBound P n)
+                λ isub → isPropIsLeast (UpperBound P
+                       , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
+
+    Supremum : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    Supremum = Σ[ n ∈ A ] isSupremum n
+
+  isUpperBoundOfSelf→isGreatestOfSelf : ∀{n} → isUpperBound {B = A} (λ x → x) n
+                                      → isGreatest (A , (id↪ A)) n
+  isUpperBoundOfSelf→isGreatestOfSelf ub = ub
+
+  isLowerBoundOfSelf→isLeastOfSelf : ∀{n} → isLowerBound {B = A} (λ x → x) n
+                                   → isLeast (A , (id↪ A)) n
+  isLowerBoundOfSelf→isLeastOfSelf lb = lb
+
+  isInfimumOfUpperBounds→isUpperBound : {B : Type ℓ''}
+                                      → (P : B → A)
+                                      → ∀ n
+                                      → isInfimum {B = UpperBound P} fst n
+                                      → isUpperBound P n
+  isInfimumOfUpperBounds→isUpperBound P _ (_ , gt) x = gt ((P x) , λ { (_ , upy) → upy x })
+
+  isInfimumOfUpperBounds→isSupremum : {B : Type ℓ''}
+                                    → (P : B → A)
+                                    → ∀ n
+                                    → isInfimum {B = UpperBound P} fst n
+                                    → isSupremum P n
+  isInfimumOfUpperBounds→isSupremum P n (lt , gt)
+    = isInfimumOfUpperBounds→isUpperBound P n (lt , gt) , lt
+
+  isSupremumOfLowerBounds→isLowerBound : {B : Type ℓ''}
+                                       → (P : B → A)
+                                       → ∀ n
+                                       → isSupremum {B = LowerBound P} fst n
+                                       → isLowerBound P n
+  isSupremumOfLowerBounds→isLowerBound P _ (_ , ls) x = ls ((P x) , λ { (_ , lwy) → lwy x })
+
+  isSupremumOfLowerBounds→isInfimum : {B : Type ℓ''}
+                                    → (P : B → A)
+                                    → ∀ n
+                                    → isSupremum {B = LowerBound P} fst n
+                                    → isInfimum P n
+  isSupremumOfLowerBounds→isInfimum P n (gs , ls)
+    = isSupremumOfLowerBounds→isLowerBound P n (gs , ls) , gs
+
+  isMeet : A → A → A → Type (ℓ-max ℓ ℓ')
+  isMeet a b a∧b = ∀ x → x ≲ a∧b ≃ (x ≲ a × x ≲ b)
+
+  isJoin : A → A → A → Type (ℓ-max ℓ ℓ')
+  isJoin a b a∨b = ∀ x → a∨b ≲ x ≃ (a ≲ x × b ≲ x)
+
+  Meet : ∀ a b → Type (ℓ-max ℓ ℓ')
+  Meet a b = Σ[ a∧b ∈ A ] isMeet a b a∧b
+
+  Join : ∀ a b → Type (ℓ-max ℓ ℓ')
+  Join a b = Σ[ a∨b ∈ A ] isJoin a b a∨b
+
+  isPropIsMeet : ∀ a b a∧b → isProp (isMeet a b a∧b)
+  isPropIsMeet a b c = isPropΠ λ x → isOfHLevel≃ 1 (prop x c)
+                                                    (isProp× (prop x a)
+                                                             (prop x b))
+
+  isPropIsJoin : ∀ a b a∨b → isProp (isJoin a b a∨b)
+  isPropIsJoin a b c = isPropΠ λ x → isOfHLevel≃ 1 (prop c x)
+                                                    (isProp× (prop a x)
+                                                             (prop b x))
+
+  isReflIsMeet : ∀ a → isMeet a a a
+  isReflIsMeet a x = propBiimpl→Equiv (prop x a)
+                                      (isProp× (prop x a) (prop x a))
+                                      (λ a → a , a)
+                                       fst
+
+  isReflIsJoin : ∀ a → isJoin a a a
+  isReflIsJoin a x = propBiimpl→Equiv (prop a x)
+                                      (isProp× (prop a x) (prop a x))
+                                      (λ a → a , a)
+                                       fst
+
+  isMeet≃isInfimum : ∀ a b c
+                   → isMeet a b c
+                   ≃ isInfimum {B = Σ[ x ∈ A ] (x ≡ a) ⊎ (x ≡ b)} fst c
+  isMeet≃isInfimum a b a∧b
+    = propBiimpl→Equiv (isPropIsMeet a b a∧b) (isPropIsInfimum fst a∧b)
+                       (λ fun → ⊎.rec (λ x≡a → subst
+                                               (a∧b ≲_)
+                                               (sym x≡a)
+                                               (fun a∧b .fst (rfl a∧b) .fst))
+                                      (λ x≡b → subst
+                                               (a∧b ≲_)
+                                               (sym x≡b)
+                                               (fun a∧b .fst (rfl a∧b) .snd))
+                                ∘ snd ,
+                        λ { (c , uprc)
+                          → invEq (fun c) ((uprc (a , (inl refl))) ,
+                                           (uprc (b , (inr refl)))) })
+                        λ { (lb , gt) x
+                          → propBiimpl→Equiv
+                           (prop x a∧b)
+                           (isProp× (prop x a) (prop x b))
+                       (λ x≤a∧b → (trans x a∧b a x≤a∧b
+                                         (lb (a , inl refl))) ,
+                                   (trans x a∧b b x≤a∧b
+                                         (lb (b , inr refl))))
+                        λ { (x≤a , x≤b)
+                          → gt (x ,
+                               (⊎.rec (λ y≡a → subst
+                                               (x ≲_)
+                                               (sym y≡a)
+                                                x≤a)
+                                      (λ y≡b → subst
+                                               (x ≲_)
+                                               (sym y≡b)
+                                                x≤b)
+                                       ∘ snd)) } }
+
+  isJoin≃isSupremum : ∀ a b c
+                    → isJoin a b c
+                    ≃ isSupremum {B = Σ[ x ∈ A ] (x ≡ a) ⊎ (x ≡ b)} fst c
+  isJoin≃isSupremum a b a∨b
+    = propBiimpl→Equiv (isPropIsJoin a b a∨b) (isPropIsSupremum fst a∨b)
+                       (λ fun → ⊎.rec (λ x≡a → subst
+                                               (_≲ a∨b)
+                                               (sym x≡a)
+                                               (fun a∨b .fst (rfl a∨b) .fst))
+                                      (λ x≡b → subst
+                                               (_≲ a∨b)
+                                               (sym x≡b)
+                                               (fun a∨b .fst (rfl a∨b) .snd))
+                                ∘ snd ,
+                        λ { (c , lwrc)
+                          → invEq (fun c) ((lwrc (a , (inl refl))) ,
+                                           (lwrc (b , (inr refl)))) })
+                        λ { (ub , lt) x
+                          → propBiimpl→Equiv
+                           (prop a∨b x)
+                           (isProp× (prop a x) (prop b x))
+                       (λ a∨b≤x → trans a a∨b x
+                                        (ub (a , inl refl))
+                                         a∨b≤x ,
+                                   trans b a∨b x
+                                        (ub (b , inr refl))
+                                         a∨b≤x)
+                        λ { (a≤x , b≤x)
+                          → lt (x ,
+                               (⊎.rec (λ y≡a → subst
+                                               (_≲ x)
+                                               (sym y≡a)
+                                                a≤x)
+                                      (λ y≡b → subst
+                                               (_≲ x)
+                                               (sym y≡b)
+                                                b≤x)
+                                ∘ snd)) } }
+
+  isMeetComm : ∀ a b a∧b → isMeet a b a∧b → isMeet b a a∧b
+  isMeetComm _ _ _ fun x = compEquiv (fun x) Σ-swap-≃
+
+  isJoinComm : ∀ a b a∨b → isJoin a b a∨b → isJoin b a a∨b
+  isJoinComm _ _ _ fun x = compEquiv (fun x) Σ-swap-≃
+
+  isMeetAssoc : ∀ a b c a∧b b∧c a∧b∧c
+              → isMeet a b a∧b
+              → isMeet b c b∧c
+              → isMeet a b∧c a∧b∧c
+              → isMeet a∧b c a∧b∧c
+  isMeetAssoc a b c a∧b b∧c a∧b∧c funa∧b funb∧c funa∧b∧c x
+    = compEquiv (funa∧b∧c x)
+                (propBiimpl→Equiv (isProp× (prop x a) (prop x b∧c))
+                                  (isProp× (prop x a∧b) (prop x c))
+                                  (λ { (x≤a , x≤b∧c)
+                                     → invEq (funa∧b x)
+                                             (x≤a ,
+                                             (funb∧c x .fst x≤b∧c .fst)) ,
+                                              funb∧c x .fst x≤b∧c .snd })
+                                   λ { (x≤a∧b , x≤c)
+                                     → funa∧b x .fst x≤a∧b .fst ,
+                                       invEq (funb∧c x)
+                                            ((funa∧b x .fst x≤a∧b .snd) ,
+                                              x≤c) })
+
+  isJoinAssoc : ∀ a b c a∨b b∨c a∨b∨c
+              → isJoin a b a∨b
+              → isJoin b c b∨c
+              → isJoin a b∨c a∨b∨c
+              → isJoin a∨b c a∨b∨c
+  isJoinAssoc a b c a∨b b∨c a∨b∨c funa∨b funb∨c funa∨b∨c x
+    = compEquiv (funa∨b∨c x)
+                (propBiimpl→Equiv (isProp× (prop a x) (prop b∨c x))
+                                  (isProp× (prop a∨b x) (prop c x))
+                                  (λ { (a≤x , b∨c≤x)
+                                     → invEq (funa∨b x) (a≤x ,
+                                      (funb∨c x .fst b∨c≤x .fst)) ,
+                                       funb∨c x .fst b∨c≤x .snd })
+                                   λ { (a∨b≤x , c≤x)
+                                     → funa∨b x .fst a∨b≤x .fst ,
+                                       invEq (funb∨c x)
+                                     ((funa∨b x .fst a∨b≤x .snd) ,
+                                       c≤x) })
+
+  isMeetIsotone : ∀ a b c d a∧c b∧d
+                → isMeet a c a∧c
+                → isMeet b d b∧d
+                → a ≲ b
+                → c ≲ d
+                → a∧c ≲ b∧d
+  isMeetIsotone a b c d a∧c b∧d meeta∧c meetb∧d a≲b c≲d
+    = invEq (meetb∧d a∧c) (trans a∧c a b a∧c≲a a≲b , trans a∧c c d a∧c≲c c≲d)
+      where a∧c≲a = equivFun (meeta∧c a∧c) (rfl a∧c) .fst
+            a∧c≲c = equivFun (meeta∧c a∧c) (rfl a∧c) .snd
+
+  isJoinIsotone : ∀ a b c d a∨c b∨d
+                → isJoin a c a∨c
+                → isJoin b d b∨d
+                → a ≲ b
+                → c ≲ d
+                → a∨c ≲ b∨d
+  isJoinIsotone a b c d a∨c b∨d joina∨c joinb∨d a≲b c≲d
+    = invEq (joina∨c b∨d) (trans a b b∨d a≲b b≲b∨d , trans c d b∨d c≲d d≲b∨d)
+    where b≲b∨d = equivFun (joinb∨d b∨d) (rfl b∨d) .fst
+          d≲b∨d = equivFun (joinb∨d b∨d) (rfl b∨d) .snd
diff --git a/Cubical/Relation/Binary/Order/Quoset.agda b/Cubical/Relation/Binary/Order/Quoset.agda
new file mode 100644
index 0000000000..c40af09a6f
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Quoset.agda
@@ -0,0 +1,5 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Quoset where
+
+open import Cubical.Relation.Binary.Order.Quoset.Base public
+open import Cubical.Relation.Binary.Order.Quoset.Properties public
diff --git a/Cubical/Relation/Binary/Order/Quoset/Base.agda b/Cubical/Relation/Binary/Order/Quoset/Base.agda
new file mode 100644
index 0000000000..41e78ef8b9
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Quoset/Base.agda
@@ -0,0 +1,126 @@
+{-# OPTIONS --safe #-}
+{-
+  Quosets, or quasiordered sets, are posets where the relation is strict,
+  i.e. irreflexive rather than reflexive
+-}
+module Cubical.Relation.Binary.Order.Quoset.Base where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.SIP
+
+open import Cubical.Data.Sigma
+
+open import Cubical.Reflection.RecordEquiv
+open import Cubical.Reflection.StrictEquiv
+
+open import Cubical.Displayed.Base
+open import Cubical.Displayed.Auto
+open import Cubical.Displayed.Record
+open import Cubical.Displayed.Universe
+
+open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Nullary.Properties
+
+open Iso
+open BinaryRelation
+
+
+private
+  variable
+    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
+
+record IsQuoset {A : Type ℓ} (_<_ : A → A → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+  no-eta-equality
+  constructor isquoset
+
+  field
+    is-set : isSet A
+    is-prop-valued : isPropValued _<_
+    is-irrefl : isIrrefl _<_
+    is-trans : isTrans _<_
+    is-asym : isAsym _<_
+
+unquoteDecl IsQuosetIsoΣ = declareRecordIsoΣ IsQuosetIsoΣ (quote IsQuoset)
+
+
+record QuosetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')) where
+
+  constructor quosetstr
+
+  field
+    _<_     : A → A → Type ℓ'
+    isQuoset : IsQuoset _<_
+
+  infixl 7 _<_
+
+  open IsQuoset isQuoset public
+
+Quoset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
+Quoset ℓ ℓ' = TypeWithStr ℓ (QuosetStr ℓ')
+
+quoset : (A : Type ℓ) → (_<_ : Rel A A ℓ') → IsQuoset _<_ → Quoset ℓ ℓ'
+quoset A _<_ quo = A , (quosetstr _<_ quo)
+
+record IsQuosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
+  (M : QuosetStr ℓ₀' A) (e : A ≃ B) (N : QuosetStr ℓ₁' B)
+  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
+  where
+  constructor
+   isquosetequiv
+  -- Shorter qualified names
+  private
+    module M = QuosetStr M
+    module N = QuosetStr N
+
+  field
+    pres< : (x y : A) → x M.< y ≃ equivFun e x N.< equivFun e y
+
+
+QuosetEquiv : (M : Quoset ℓ₀ ℓ₀') (M : Quoset ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
+QuosetEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsQuosetEquiv (M .snd) e (N .snd)
+
+isPropIsQuoset : {A : Type ℓ} (_<_ : A → A → Type ℓ') → isProp (IsQuoset _<_)
+isPropIsQuoset _<_ = isOfHLevelRetractFromIso 1 IsQuosetIsoΣ
+  (isPropΣ isPropIsSet
+    λ isSetA → isPropΣ (isPropΠ2 (λ _ _ → isPropIsProp))
+      λ isPropValued< → isProp×2 (isPropΠ (λ x → isProp¬ (x < x)))
+                                 (isPropΠ5 (λ _ _ _ _ _ → isPropValued< _ _))
+                                 (isPropΠ3 λ x y _ → isProp¬ (y < x)))
+
+𝒮ᴰ-Quoset : DUARel (𝒮-Univ ℓ) (QuosetStr ℓ') (ℓ-max ℓ ℓ')
+𝒮ᴰ-Quoset =
+  𝒮ᴰ-Record (𝒮-Univ _) IsQuosetEquiv
+    (fields:
+      data[ _<_ ∣ autoDUARel _ _ ∣ pres< ]
+      prop[ isQuoset ∣ (λ _ _ → isPropIsQuoset _) ])
+    where
+    open QuosetStr
+    open IsQuoset
+    open IsQuosetEquiv
+
+QuosetPath : (M N : Quoset ℓ ℓ') → QuosetEquiv M N ≃ (M ≡ N)
+QuosetPath = ∫ 𝒮ᴰ-Quoset .UARel.ua
+
+-- an easier way of establishing an equivalence of strict posets
+module _ {P : Quoset ℓ₀ ℓ₀'} {S : Quoset ℓ₁ ℓ₁'} (e : ⟨ P ⟩ ≃ ⟨ S ⟩) where
+  private
+    module P = QuosetStr (P .snd)
+    module S = QuosetStr (S .snd)
+
+  module _ (isMon : ∀ x y → x P.< y → equivFun e x S.< equivFun e y)
+           (isMonInv : ∀ x y → x S.< y → invEq e x P.< invEq e y) where
+    open IsQuosetEquiv
+    open IsQuoset
+
+    makeIsQuosetEquiv : IsQuosetEquiv (P .snd) e (S .snd)
+    pres< makeIsQuosetEquiv x y = propBiimpl→Equiv (P.isQuoset .is-prop-valued _ _)
+                                                  (S.isQuoset .is-prop-valued _ _)
+                                                  (isMon _ _) (isMonInv' _ _)
+      where
+      isMonInv' : ∀ x y → equivFun e x S.< equivFun e y → x P.< y
+      isMonInv' x y ex<ey = transport (λ i → retEq e x i P.< retEq e y i) (isMonInv _ _ ex<ey)
diff --git a/Cubical/Relation/Binary/Order/Quoset/Properties.agda b/Cubical/Relation/Binary/Order/Quoset/Properties.agda
new file mode 100644
index 0000000000..12ddc6fe5a
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Quoset/Properties.agda
@@ -0,0 +1,80 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Quoset.Properties where
+
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Empty as ⊥
+
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Functions.Embedding
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Binary.Order.Apartness.Base
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Quoset.Base
+
+private
+  variable
+    ℓ ℓ' ℓ'' : Level
+
+module _
+  {A : Type ℓ}
+  {R : Rel A A ℓ'}
+  where
+
+  open BinaryRelation
+
+  private
+    transrefl : isTrans R → isTrans (ReflClosure R)
+    transrefl trans a b c (inl Rab) (inl Rbc) = inl (trans a b c Rab Rbc)
+    transrefl trans a b c (inl Rab) (inr b≡c) = inl (subst (R a) b≡c Rab)
+    transrefl trans a b c (inr a≡b) (inl Rbc) = inl (subst (λ z → R z c) (sym a≡b) Rbc)
+    transrefl trans a b c (inr a≡b) (inr b≡c) = inr (a≡b ∙ b≡c)
+
+    antisym : isIrrefl R → isTrans R → isAntisym (ReflClosure R)
+    antisym irr trans a b (inl Rab) (inl Rba) = ⊥.rec (irr a (trans a b a Rab Rba))
+    antisym irr trans a b (inl _) (inr b≡a) = sym b≡a
+    antisym irr trans a b (inr a≡b) _ = a≡b
+
+  isQuoset→isPosetReflClosure : IsQuoset R → IsPoset (ReflClosure R)
+  isQuoset→isPosetReflClosure quoset
+    = isposet (IsQuoset.is-set quoset)
+              (λ a b → isProp⊎ (IsQuoset.is-prop-valued quoset a b)
+                               (IsQuoset.is-set quoset a b)
+                                 λ Rab a≡b
+                                   → IsQuoset.is-irrefl quoset a (subst (R a)
+                                                                           (sym a≡b) Rab))
+              (isReflReflClosure R)
+              (transrefl (IsQuoset.is-trans quoset))
+              (antisym (IsQuoset.is-irrefl quoset)
+                       (IsQuoset.is-trans quoset))
+
+  isQuosetInduced : IsQuoset R → (B : Type ℓ'') → (f : B ↪ A)
+                       → IsQuoset (InducedRelation R (B , f))
+  isQuosetInduced quo B (f , emb)
+    = isquoset (Embedding-into-isSet→isSet (f , emb)
+                                                (IsQuoset.is-set quo))
+                    (λ a b → IsQuoset.is-prop-valued quo (f a) (f b))
+                    (λ a → IsQuoset.is-irrefl quo (f a))
+                    (λ a b c → IsQuoset.is-trans quo (f a) (f b) (f c))
+                    λ a b → IsQuoset.is-asym quo (f a) (f b)
+
+  isQuosetDual : IsQuoset R → IsQuoset (Dual R)
+  isQuosetDual quo
+    = isquoset (IsQuoset.is-set quo)
+               (λ a b → IsQuoset.is-prop-valued quo b a)
+               (IsQuoset.is-irrefl quo)
+               (λ a b c Rab Rbc → IsQuoset.is-trans quo c b a Rbc Rab)
+                λ a b → IsQuoset.is-asym quo b a
+
+Quoset→Poset : Quoset ℓ ℓ' → Poset ℓ (ℓ-max ℓ ℓ')
+Quoset→Poset (_ , quo)
+  = poset _ (BinaryRelation.ReflClosure (QuosetStr._<_ quo))
+            (isQuoset→isPosetReflClosure (QuosetStr.isQuoset quo))
+
+DualQuoset : Quoset ℓ ℓ' → Quoset ℓ ℓ'
+DualQuoset (_ , quo)
+  = quoset _ (BinaryRelation.Dual (QuosetStr._<_ quo))
+             (isQuosetDual (QuosetStr.isQuoset quo))
diff --git a/Cubical/Relation/Binary/Order/QuosetReasoning.agda b/Cubical/Relation/Binary/Order/QuosetReasoning.agda
new file mode 100644
index 0000000000..daa0df2d10
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/QuosetReasoning.agda
@@ -0,0 +1,138 @@
+-- Example of usage:
+--
+--    open <-syntax
+--    open ≤-syntax
+--    open ≡-syntax
+--
+--    example : ∀ (x y z u v w α γ δ : P)
+--            → x < y
+--            → y ≤ z
+--            → z ≡ u
+--            → u < v
+--            → v ≤ w
+--            → w ≡ α
+--            → α ≡ γ
+--            → γ ≡ δ
+--            → x < δ
+--    example x y z u v w α γ δ x<y y≤z z≡u u<v v≤w w≡α α≡γ γ≡δ = begin
+--      x   <⟨   x<y      ⟩
+--      y   ≤⟨   y≤z      ⟩
+--      z   ≡→≤⟨ z ≡⟨ z≡u        ⟩
+--               u ≡⟨ sym z≡u    ⟩
+--               z ≡[ i ]⟨ z≡u i ⟩
+--               u ∎     ⟩
+--      u   <⟨   u<v      ⟩
+--      v   ≤⟨   v≤w      ⟩
+--      w   ≡→≤⟨
+--              w   ≡⟨ w≡α ⟩
+--              α   ≡⟨ α≡γ ⟩
+--              γ   ≡[ i ]⟨ γ≡δ i ⟩
+--              δ   ∎
+--            ⟩
+--      δ ◾
+
+{-# OPTIONS --safe #-}
+{-
+  Equational reasoning in a Quoset that is also a Poset, i.e.
+  for writing a chain of <,≤,≡ with at least a <
+-}
+module Cubical.Relation.Binary.Order.QuosetReasoning where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Data.Bool.Base
+open import Cubical.Data.Empty.Base as ⊥
+
+open import Cubical.Relation.Nullary.Base
+
+open import Cubical.Relation.Binary.Base
+open BinaryRelation
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Quoset.Base
+
+private
+  variable
+    ℓ ℓ≤ ℓ< : Level
+
+-- Record with all the parts needed to extract a subrelation from a relation
+-- (e.g. from a chain of <,≤,=, with at least a <, to a <)
+-- Note:
+-- It could be better to move this record in Relation.Binary.Base,
+-- but there isn't yet a proper module for subrelations.
+record SubRelation
+  {ℓR}
+  {P : Type ℓ}
+  (_R_ : Rel P P ℓR ) ℓS ℓIsS : Type (ℓ-max ℓ (ℓ-max ℓR (ℓ-max (ℓ-suc ℓS) (ℓ-suc ℓIsS)))) where
+    no-eta-equality
+    field
+      _S_ : Rel P P ℓS
+      IsS : ∀ {x y} → x R y → Type ℓIsS
+      IsS? : ∀ {x y} → (xRy : x R y) → Dec (IsS xRy)
+      extract : ∀ {x y} → {xRy : x R y} → IsS xRy → x S y
+
+module <-≤-Reasoning
+  (P : Type ℓ)
+  ((posetstr (_≤_) isPoset)   : PosetStr ℓ≤ P)
+  ((quosetstr (_<_) isQuoset) : QuosetStr ℓ< P)
+  (<-≤-trans : ∀ x {y z} → x < y → y ≤ z → x < z)
+  (≤-<-trans : ∀ x {y z} → x ≤ y → y < z → x < z) where
+
+  open IsPoset
+  open IsQuoset
+  open SubRelation
+
+  private
+    variable
+      x y z : P
+    data _<≤≡_ : P → P → Type (ℓ-max ℓ (ℓ-max ℓ< ℓ≤)) where
+      strict    : x < y → x <≤≡ y
+      nonstrict : x ≤ y → x <≤≡ y
+      equal     : x ≡ y → x <≤≡ y
+
+    sub : SubRelation _<≤≡_ ℓ< ℓ<
+    sub ._S_ = _<_
+    sub .IsS {x} {y} r with r
+    ...                   | strict x<y  = x < y
+    ...                   | equal _     = ⊥*
+    ...                   | nonstrict _ = ⊥*
+    sub .IsS? r with r
+    ...            | strict x<y  = yes x<y
+    ...            | nonstrict _ = no λ ()
+    ...            | equal     _ = no λ ()
+    sub .extract {xRy = strict _ } x<y = x<y
+
+  open SubRelation sub renaming (IsS? to Is<? ; extract to extract<)
+  infix 1 begin_
+  begin_ : (r : x <≤≡ y) → {True (Is<? r)} → x < y
+  begin_ r {s} = extract< {xRy = r} (toWitness s)
+
+  -- Partial order syntax
+  module ≤-syntax where
+    infixr 2 step-≤
+    step-≤ : ∀ (x : P) → y <≤≡ z → x ≤ y → x <≤≡ z
+    step-≤ x r x≤y with r
+    ...               | strict    y<z = strict (≤-<-trans x x≤y y<z)
+    ...               | nonstrict y≤z = nonstrict (isPoset .is-trans x _ _ x≤y y≤z)
+    ...               | equal     y≡z = nonstrict (subst (x ≤_) y≡z x≤y)
+
+    syntax step-≤ x yRz x≤y = x ≤⟨ x≤y ⟩ yRz
+
+  module <-syntax where
+    infixr 2 step-<
+    step-< : ∀ (x : P) → y <≤≡ z → x < y → x <≤≡ z
+    step-< x r x<y with r
+    ...               | strict    y<z = strict (isQuoset .is-trans x _ _ x<y y<z)
+    ...               | nonstrict y≤z = strict (<-≤-trans x x<y y≤z)
+    ...               | equal     y≡z = strict (subst (x <_) y≡z x<y)
+
+    syntax step-< x yRz x<y = x <⟨ x<y ⟩ yRz
+
+  module ≡-syntax where
+    infixr 2 step-≡→≤
+    step-≡→≤ : ∀ (x : P) → y <≤≡ z → x ≡ y → x <≤≡ z
+    step-≡→≤ x y<≤≡z x≡y = subst (_<≤≡ _) (λ i → x≡y (~ i)) y<≤≡z
+
+    syntax step-≡→≤ x yRz x≡y = x ≡→≤⟨ x≡y ⟩ yRz
+
+  infix 3 _◾
+  _◾ : ∀ x → x <≤≡ x
+  x ◾ = equal refl
diff --git a/Cubical/Relation/Binary/Order/StrictOrder.agda b/Cubical/Relation/Binary/Order/StrictOrder.agda
new file mode 100644
index 0000000000..81a6946c9d
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/StrictOrder.agda
@@ -0,0 +1,5 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.StrictOrder where
+
+open import Cubical.Relation.Binary.Order.StrictOrder.Base public
+open import Cubical.Relation.Binary.Order.StrictOrder.Properties public
diff --git a/Cubical/Relation/Binary/Order/StrictOrder/Base.agda b/Cubical/Relation/Binary/Order/StrictOrder/Base.agda
new file mode 100644
index 0000000000..f70a9ab16a
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/StrictOrder/Base.agda
@@ -0,0 +1,130 @@
+{-# OPTIONS --safe #-}
+{-
+  Strict orders are linear orders that aren't connected,
+  or a quasiorder with comparison
+-}
+module Cubical.Relation.Binary.Order.StrictOrder.Base where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.SIP
+
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation
+
+open import Cubical.Reflection.RecordEquiv
+open import Cubical.Reflection.StrictEquiv
+
+open import Cubical.Displayed.Base
+open import Cubical.Displayed.Auto
+open import Cubical.Displayed.Record
+open import Cubical.Displayed.Universe
+
+open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Nullary.Properties
+
+open Iso
+open BinaryRelation
+
+
+private
+  variable
+    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
+
+record IsStrictOrder {A : Type ℓ} (_<_ : A → A → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+  no-eta-equality
+  constructor isstrictorder
+
+  field
+    is-set : isSet A
+    is-prop-valued : isPropValued _<_
+    is-irrefl : isIrrefl _<_
+    is-trans : isTrans _<_
+    is-asym : isAsym _<_
+    is-weakly-linear : isWeaklyLinear _<_
+
+unquoteDecl IsStrictOrderIsoΣ = declareRecordIsoΣ IsStrictOrderIsoΣ (quote IsStrictOrder)
+
+
+record StrictOrderStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')) where
+
+  constructor strictorderstr
+
+  field
+    _<_     : A → A → Type ℓ'
+    isStrictOrder : IsStrictOrder _<_
+
+  infixl 7 _<_
+
+  open IsStrictOrder isStrictOrder public
+
+StrictOrder : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
+StrictOrder ℓ ℓ' = TypeWithStr ℓ (StrictOrderStr ℓ')
+
+strictorder : (A : Type ℓ) → (_<_ : Rel A A ℓ') → IsStrictOrder _<_ → StrictOrder ℓ ℓ'
+strictorder A _<_ strict = A , (strictorderstr _<_ strict)
+
+record IsStrictOrderEquiv {A : Type ℓ₀} {B : Type ℓ₁}
+  (M : StrictOrderStr ℓ₀' A) (e : A ≃ B) (N : StrictOrderStr ℓ₁' B)
+  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
+  where
+  constructor
+   isstrictorderequiv
+  -- Shorter qualified names
+  private
+    module M = StrictOrderStr M
+    module N = StrictOrderStr N
+
+  field
+    pres< : (x y : A) → x M.< y ≃ equivFun e x N.< equivFun e y
+
+
+StrictOrderEquiv : (M : StrictOrder ℓ₀ ℓ₀') (M : StrictOrder ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
+StrictOrderEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsStrictOrderEquiv (M .snd) e (N .snd)
+
+isPropIsStrictOrder : {A : Type ℓ} (_<_ : A → A → Type ℓ') → isProp (IsStrictOrder _<_)
+isPropIsStrictOrder _<_ = isOfHLevelRetractFromIso 1 IsStrictOrderIsoΣ
+  (isPropΣ isPropIsSet
+    λ isSetA → isPropΣ (isPropΠ2 (λ _ _ → isPropIsProp))
+      λ isPropValued< → isProp×3 (isPropΠ (λ x → isProp¬ (x < x)))
+                                 (isPropΠ5 (λ _ _ _ _ _ → isPropValued< _ _))
+                                 (isPropΠ3 (λ x y _ → isProp¬ (y < x)))
+                                 (isPropΠ4 λ _ _ _ _ → squash₁))
+
+𝒮ᴰ-StrictOrder : DUARel (𝒮-Univ ℓ) (StrictOrderStr ℓ') (ℓ-max ℓ ℓ')
+𝒮ᴰ-StrictOrder =
+  𝒮ᴰ-Record (𝒮-Univ _) IsStrictOrderEquiv
+    (fields:
+      data[ _<_ ∣ autoDUARel _ _ ∣ pres< ]
+      prop[ isStrictOrder ∣ (λ _ _ → isPropIsStrictOrder _) ])
+    where
+    open StrictOrderStr
+    open IsStrictOrder
+    open IsStrictOrderEquiv
+
+StrictOrderPath : (M N : StrictOrder ℓ ℓ') → StrictOrderEquiv M N ≃ (M ≡ N)
+StrictOrderPath = ∫ 𝒮ᴰ-StrictOrder .UARel.ua
+
+-- an easier way of establishing an equivalence of strict orders
+module _ {P : StrictOrder ℓ₀ ℓ₀'} {S : StrictOrder ℓ₁ ℓ₁'} (e : ⟨ P ⟩ ≃ ⟨ S ⟩) where
+  private
+    module P = StrictOrderStr (P .snd)
+    module S = StrictOrderStr (S .snd)
+
+  module _ (isMon : ∀ x y → x P.< y → equivFun e x S.< equivFun e y)
+           (isMonInv : ∀ x y → x S.< y → invEq e x P.< invEq e y) where
+    open IsStrictOrderEquiv
+    open IsStrictOrder
+
+    makeIsStrictOrderEquiv : IsStrictOrderEquiv (P .snd) e (S .snd)
+    pres< makeIsStrictOrderEquiv x y = propBiimpl→Equiv (P.isStrictOrder .is-prop-valued _ _)
+                                                  (S.isStrictOrder .is-prop-valued _ _)
+                                                  (isMon _ _) (isMonInv' _ _)
+      where
+      isMonInv' : ∀ x y → equivFun e x S.< equivFun e y → x P.< y
+      isMonInv' x y ex<ey = transport (λ i → retEq e x i P.< retEq e y i) (isMonInv _ _ ex<ey)
diff --git a/Cubical/Relation/Binary/Order/StrictOrder/Properties.agda b/Cubical/Relation/Binary/Order/StrictOrder/Properties.agda
new file mode 100644
index 0000000000..8c9066dc05
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/StrictOrder/Properties.agda
@@ -0,0 +1,120 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.StrictOrder.Properties where
+
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Empty as ⊥
+
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Functions.Embedding
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Binary.Order.Apartness.Base
+open import Cubical.Relation.Binary.Order.Toset
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Proset.Base
+open import Cubical.Relation.Binary.Order.Quoset.Base
+open import Cubical.Relation.Binary.Order.StrictOrder.Base
+
+open import Cubical.Relation.Nullary
+
+private
+  variable
+    ℓ ℓ' ℓ'' : Level
+
+module _
+  {A : Type ℓ}
+  {R : Rel A A ℓ'}
+  where
+
+  open BinaryRelation
+
+  isStrictOrder→isQuoset : IsStrictOrder R → IsQuoset R
+  isStrictOrder→isQuoset strictorder = isquoset
+                        (IsStrictOrder.is-set strictorder)
+                        (IsStrictOrder.is-prop-valued strictorder)
+                        (IsStrictOrder.is-irrefl strictorder)
+                        (IsStrictOrder.is-trans strictorder)
+                        (IsStrictOrder.is-asym strictorder)
+
+  private
+    transrefl : isTrans R → isTrans (ReflClosure R)
+    transrefl trans a b c (inl Rab) (inl Rbc) = inl (trans a b c Rab Rbc)
+    transrefl trans a b c (inl Rab) (inr b≡c) = inl (subst (R a) b≡c Rab)
+    transrefl trans a b c (inr a≡b) (inl Rbc) = inl (subst (λ z → R z c) (sym a≡b) Rbc)
+    transrefl trans a b c (inr a≡b) (inr b≡c) = inr (a≡b ∙ b≡c)
+
+    antisym : isIrrefl R → isTrans R → isAntisym (ReflClosure R)
+    antisym irr trans a b (inl Rab) (inl Rba) = ⊥.rec (irr a (trans a b a Rab Rba))
+    antisym irr trans a b (inl _) (inr b≡a) = sym b≡a
+    antisym irr trans a b (inr a≡b) _ = a≡b
+
+  isStrictOrder→isApartnessSymClosure : IsStrictOrder R
+                                      → IsApartness (SymClosure R)
+  isStrictOrder→isApartnessSymClosure strict
+    = isapartness (IsStrictOrder.is-set strict)
+                  (λ a b → isProp⊎ (IsStrictOrder.is-prop-valued strict a b)
+                                   (IsStrictOrder.is-prop-valued strict b a)
+                                   (IsStrictOrder.is-asym strict a b))
+                  (λ a x → ⊎.rec (IsStrictOrder.is-irrefl strict a)
+                                 (IsStrictOrder.is-irrefl strict a) x)
+                  (λ a b c x → ⊎.rec (λ Rab → ∥₁.map (⊎.map (λ Rac → inl Rac)
+                                                             (λ Rcb → inr Rcb))
+                                                      (IsStrictOrder.is-weakly-linear strict a b c Rab))
+                                     (λ Rba → ∥₁.rec isPropPropTrunc
+                                                     (λ y → ∣ ⊎.rec (λ Rbc → inr (inl Rbc))
+                                                     (λ Rca → inl (inr Rca)) y ∣₁)
+                                                     (IsStrictOrder.is-weakly-linear strict b a c Rba)) x)
+                  (isSymSymClosure R)
+
+  isStrictOrder→isProsetNegationRel : IsStrictOrder R
+                                    → IsProset (NegationRel R)
+  isStrictOrder→isProsetNegationRel strict
+    = isproset (IsStrictOrder.is-set strict)
+               (λ _ _ → isProp¬ _)
+               (IsStrictOrder.is-irrefl strict)
+                λ a b c ¬Rab ¬Rbc Rac →
+                    ∥₁.rec isProp⊥ (⊎.rec ¬Rab ¬Rbc)
+                          (IsStrictOrder.is-weakly-linear strict a c b Rac)
+
+  isStrictOrderInduced : IsStrictOrder R → (B : Type ℓ'') → (f : B ↪ A)
+                 → IsStrictOrder (InducedRelation R (B , f))
+  isStrictOrderInduced strict B (f , emb)
+    = isstrictorder (Embedding-into-isSet→isSet (f , emb) (IsStrictOrder.is-set strict))
+              (λ a b → IsStrictOrder.is-prop-valued strict (f a) (f b))
+              (λ a → IsStrictOrder.is-irrefl strict (f a))
+              (λ a b c → IsStrictOrder.is-trans strict (f a) (f b) (f c))
+              (λ a b → IsStrictOrder.is-asym strict (f a) (f b))
+               λ a b c → IsStrictOrder.is-weakly-linear strict (f a) (f b) (f c)
+
+  isStrictOrderDual : IsStrictOrder R → IsStrictOrder (Dual R)
+  isStrictOrderDual strict
+    = isstrictorder (IsStrictOrder.is-set strict)
+                    (λ a b → IsStrictOrder.is-prop-valued strict b a)
+                    (IsStrictOrder.is-irrefl strict)
+                    (λ a b c Rab Rbc → IsStrictOrder.is-trans strict c b a Rbc Rab)
+                    (λ a b → IsStrictOrder.is-asym strict b a)
+                    (λ a b c Rba → ∥₁.map (⊎.rec inr inl)
+                                          (IsStrictOrder.is-weakly-linear strict b a c Rba))
+
+StrictOrder→Quoset : StrictOrder ℓ ℓ' → Quoset ℓ ℓ'
+StrictOrder→Quoset (_ , strict)
+  = quoset _ (StrictOrderStr._<_ strict)
+             (isStrictOrder→isQuoset (StrictOrderStr.isStrictOrder strict))
+
+StrictOrder→Apartness : StrictOrder ℓ ℓ' → Apartness ℓ ℓ'
+StrictOrder→Apartness (_ , strict)
+  = apartness _ (BinaryRelation.SymClosure (StrictOrderStr._<_ strict))
+                (isStrictOrder→isApartnessSymClosure (StrictOrderStr.isStrictOrder strict))
+
+StrictOrder→Proset : StrictOrder ℓ ℓ' → Proset ℓ ℓ'
+StrictOrder→Proset (_ , strict)
+  = proset _ (BinaryRelation.NegationRel (StrictOrderStr._<_ strict))
+             (isStrictOrder→isProsetNegationRel (StrictOrderStr.isStrictOrder strict))
+
+DualStrictOrder : StrictOrder ℓ ℓ' → StrictOrder ℓ ℓ'
+DualStrictOrder (_ , strict)
+  = strictorder _ (BinaryRelation.Dual (StrictOrderStr._<_ strict))
+                  (isStrictOrderDual (StrictOrderStr.isStrictOrder strict))
diff --git a/Cubical/Relation/Binary/Order/StrictPoset.agda b/Cubical/Relation/Binary/Order/StrictPoset.agda
deleted file mode 100644
index 40760b020a..0000000000
--- a/Cubical/Relation/Binary/Order/StrictPoset.agda
+++ /dev/null
@@ -1,5 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.StrictPoset where
-
-open import Cubical.Relation.Binary.Order.StrictPoset.Base public
-open import Cubical.Relation.Binary.Order.StrictPoset.Properties public
diff --git a/Cubical/Relation/Binary/Order/StrictPoset/Base.agda b/Cubical/Relation/Binary/Order/StrictPoset/Base.agda
deleted file mode 100644
index 750ddf9f4d..0000000000
--- a/Cubical/Relation/Binary/Order/StrictPoset/Base.agda
+++ /dev/null
@@ -1,126 +0,0 @@
-{-# OPTIONS --safe #-}
-{-
-  Strict posets are posets where the relation is strict,
-  i.e. irreflexive rather than reflexive
--}
-module Cubical.Relation.Binary.Order.StrictPoset.Base where
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.Equiv
-open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.Univalence
-open import Cubical.Foundations.Transport
-open import Cubical.Foundations.SIP
-
-open import Cubical.Data.Sigma
-
-open import Cubical.Reflection.RecordEquiv
-open import Cubical.Reflection.StrictEquiv
-
-open import Cubical.Displayed.Base
-open import Cubical.Displayed.Auto
-open import Cubical.Displayed.Record
-open import Cubical.Displayed.Universe
-
-open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Nullary.Properties
-
-open Iso
-open BinaryRelation
-
-
-private
-  variable
-    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
-
-record IsStrictPoset {A : Type ℓ} (_<_ : A → A → Type ℓ') : Type (ℓ-max ℓ ℓ') where
-  no-eta-equality
-  constructor isstrictposet
-
-  field
-    is-set : isSet A
-    is-prop-valued : isPropValued _<_
-    is-irrefl : isIrrefl _<_
-    is-trans : isTrans _<_
-    is-asym : isAsym _<_
-
-unquoteDecl IsStrictPosetIsoΣ = declareRecordIsoΣ IsStrictPosetIsoΣ (quote IsStrictPoset)
-
-
-record StrictPosetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')) where
-
-  constructor strictposetstr
-
-  field
-    _<_     : A → A → Type ℓ'
-    isStrictPoset : IsStrictPoset _<_
-
-  infixl 7 _<_
-
-  open IsStrictPoset isStrictPoset public
-
-StrictPoset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
-StrictPoset ℓ ℓ' = TypeWithStr ℓ (StrictPosetStr ℓ')
-
-strictposet : (A : Type ℓ) (_<_ : A → A → Type ℓ') (h : IsStrictPoset _<_) → StrictPoset ℓ ℓ'
-strictposet A _<_ h = A , strictposetstr _<_ h
-
-record IsStrictPosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
-  (M : StrictPosetStr ℓ₀' A) (e : A ≃ B) (N : StrictPosetStr ℓ₁' B)
-  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
-  where
-  constructor
-   isstrictposetequiv
-  -- Shorter qualified names
-  private
-    module M = StrictPosetStr M
-    module N = StrictPosetStr N
-
-  field
-    pres< : (x y : A) → x M.< y ≃ equivFun e x N.< equivFun e y
-
-
-StrictPosetEquiv : (M : StrictPoset ℓ₀ ℓ₀') (M : StrictPoset ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
-StrictPosetEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsStrictPosetEquiv (M .snd) e (N .snd)
-
-isPropIsStrictPoset : {A : Type ℓ} (_<_ : A → A → Type ℓ') → isProp (IsStrictPoset _<_)
-isPropIsStrictPoset _<_ = isOfHLevelRetractFromIso 1 IsStrictPosetIsoΣ
-  (isPropΣ isPropIsSet
-    λ isSetA → isPropΣ (isPropΠ2 (λ _ _ → isPropIsProp))
-      λ isPropValued< → isProp×2 (isPropΠ (λ x → isProp¬ (x < x)))
-                                 (isPropΠ5 (λ _ _ _ _ _ → isPropValued< _ _))
-                                 (isPropΠ3 λ x y _ → isProp¬ (y < x)))
-
-𝒮ᴰ-StrictPoset : DUARel (𝒮-Univ ℓ) (StrictPosetStr ℓ') (ℓ-max ℓ ℓ')
-𝒮ᴰ-StrictPoset =
-  𝒮ᴰ-Record (𝒮-Univ _) IsStrictPosetEquiv
-    (fields:
-      data[ _<_ ∣ autoDUARel _ _ ∣ pres< ]
-      prop[ isStrictPoset ∣ (λ _ _ → isPropIsStrictPoset _) ])
-    where
-    open StrictPosetStr
-    open IsStrictPoset
-    open IsStrictPosetEquiv
-
-StrictPosetPath : (M N : StrictPoset ℓ ℓ') → StrictPosetEquiv M N ≃ (M ≡ N)
-StrictPosetPath = ∫ 𝒮ᴰ-StrictPoset .UARel.ua
-
--- an easier way of establishing an equivalence of strict posets
-module _ {P : StrictPoset ℓ₀ ℓ₀'} {S : StrictPoset ℓ₁ ℓ₁'} (e : ⟨ P ⟩ ≃ ⟨ S ⟩) where
-  private
-    module P = StrictPosetStr (P .snd)
-    module S = StrictPosetStr (S .snd)
-
-  module _ (isMon : ∀ x y → x P.< y → equivFun e x S.< equivFun e y)
-           (isMonInv : ∀ x y → x S.< y → invEq e x P.< invEq e y) where
-    open IsStrictPosetEquiv
-    open IsStrictPoset
-
-    makeIsStrictPosetEquiv : IsStrictPosetEquiv (P .snd) e (S .snd)
-    pres< makeIsStrictPosetEquiv x y = propBiimpl→Equiv (P.isStrictPoset .is-prop-valued _ _)
-                                                  (S.isStrictPoset .is-prop-valued _ _)
-                                                  (isMon _ _) (isMonInv' _ _)
-      where
-      isMonInv' : ∀ x y → equivFun e x S.< equivFun e y → x P.< y
-      isMonInv' x y ex<ey = transport (λ i → retEq e x i P.< retEq e y i) (isMonInv _ _ ex<ey)
diff --git a/Cubical/Relation/Binary/Order/StrictPoset/Properties.agda b/Cubical/Relation/Binary/Order/StrictPoset/Properties.agda
deleted file mode 100644
index b9a1098516..0000000000
--- a/Cubical/Relation/Binary/Order/StrictPoset/Properties.agda
+++ /dev/null
@@ -1,94 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.StrictPoset.Properties where
-
-open import Cubical.Data.Sum as ⊎
-open import Cubical.Data.Empty as ⊥
-
-open import Cubical.Foundations.Prelude
-
-open import Cubical.Functions.Embedding
-
-open import Cubical.HITs.PropositionalTruncation as ∥₁
-
-open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Apartness.Base
-open import Cubical.Relation.Binary.Order.Poset.Base
-open import Cubical.Relation.Binary.Order.StrictPoset.Base
-
-private
-  variable
-    ℓ ℓ' ℓ'' : Level
-
-module _
-  {A : Type ℓ}
-  {R : Rel A A ℓ'}
-  where
-
-  open BinaryRelation
-
-  private
-    transrefl : isTrans R → isTrans (ReflClosure R)
-    transrefl trans a b c (inl Rab) (inl Rbc) = inl (trans a b c Rab Rbc)
-    transrefl trans a b c (inl Rab) (inr b≡c) = inl (subst (R a) b≡c Rab)
-    transrefl trans a b c (inr a≡b) (inl Rbc) = inl (subst (λ z → R z c) (sym a≡b) Rbc)
-    transrefl trans a b c (inr a≡b) (inr b≡c) = inr (a≡b ∙ b≡c)
-
-    antisym : isIrrefl R → isTrans R → isAntisym (ReflClosure R)
-    antisym irr trans a b (inl Rab) (inl Rba) = ⊥.rec (irr a (trans a b a Rab Rba))
-    antisym irr trans a b (inl _) (inr b≡a) = sym b≡a
-    antisym irr trans a b (inr a≡b) _ = a≡b
-
-  isStrictPoset→isPosetReflClosure : IsStrictPoset R → IsPoset (ReflClosure R)
-  isStrictPoset→isPosetReflClosure strictposet
-    = isposet (IsStrictPoset.is-set strictposet)
-              (λ a b → isProp⊎ (IsStrictPoset.is-prop-valued strictposet a b)
-                               (IsStrictPoset.is-set strictposet a b)
-                                 λ Rab a≡b
-                                   → IsStrictPoset.is-irrefl strictposet a (subst (R a)
-                                                                           (sym a≡b) Rab))
-              (isReflReflClosure R)
-              (transrefl (IsStrictPoset.is-trans strictposet))
-              (antisym (IsStrictPoset.is-irrefl strictposet)
-                       (IsStrictPoset.is-trans strictposet))
-
-  isStrictPoset→isApartnessSymClosure : IsStrictPoset R
-                                      → isWeaklyLinear R
-                                      → IsApartness (SymClosure R)
-  isStrictPoset→isApartnessSymClosure strictposet weak
-    = isapartness (IsStrictPoset.is-set strictposet)
-                  (λ a b → isProp⊎ (IsStrictPoset.is-prop-valued strictposet a b)
-                                   (IsStrictPoset.is-prop-valued strictposet b a)
-                                   (IsStrictPoset.is-asym strictposet a b))
-                  (λ a x → ⊎.rec (IsStrictPoset.is-irrefl strictposet a)
-                                 (IsStrictPoset.is-irrefl strictposet a) x)
-                  (λ a b c x → ⊎.rec (λ Rab → ∥₁.map (⊎.map (λ Rac → inl Rac)
-                                                             (λ Rcb → inr Rcb))
-                                                      (weak a b c Rab))
-                                     (λ Rba → ∥₁.rec isPropPropTrunc
-                                                     (λ y → ∣ ⊎.rec (λ Rbc → inr (inl Rbc))
-                                                     (λ Rca → inl (inr Rca)) y ∣₁)
-                                                     (weak b a c Rba)) x)
-                  (isSymSymClosure R)
-
-  isStrictPosetInduced : IsStrictPoset R → (B : Type ℓ'') → (f : B ↪ A)
-                       → IsStrictPoset (InducedRelation R (B , f))
-  isStrictPosetInduced strictpos B (f , emb)
-    = isstrictposet (Embedding-into-isSet→isSet (f , emb)
-                                                (IsStrictPoset.is-set strictpos))
-                    (λ a b → IsStrictPoset.is-prop-valued strictpos (f a) (f b))
-                    (λ a → IsStrictPoset.is-irrefl strictpos (f a))
-                    (λ a b c → IsStrictPoset.is-trans strictpos (f a) (f b) (f c))
-                    λ a b → IsStrictPoset.is-asym strictpos (f a) (f b)
-
-StrictPoset→Poset : StrictPoset ℓ ℓ' → Poset ℓ (ℓ-max ℓ ℓ')
-StrictPoset→Poset (_ , strictpos)
-  = _ , posetstr (BinaryRelation.ReflClosure (StrictPosetStr._<_ strictpos))
-                 (isStrictPoset→isPosetReflClosure (StrictPosetStr.isStrictPoset strictpos))
-
-StrictPoset→Apartness : (R : StrictPoset ℓ ℓ')
-                      → BinaryRelation.isWeaklyLinear (StrictPosetStr._<_ (snd R))
-                      → Apartness ℓ ℓ'
-StrictPoset→Apartness (_ , strictpos) weak
-  = _ , apartnessstr (BinaryRelation.SymClosure (StrictPosetStr._<_ strictpos))
-                     (isStrictPoset→isApartnessSymClosure
-                       (StrictPosetStr.isStrictPoset strictpos) weak)
diff --git a/Cubical/Relation/Binary/Order/Toset/Base.agda b/Cubical/Relation/Binary/Order/Toset/Base.agda
index d91fa08768..37d3b5cb30 100644
--- a/Cubical/Relation/Binary/Order/Toset/Base.agda
+++ b/Cubical/Relation/Binary/Order/Toset/Base.agda
@@ -46,7 +46,7 @@ record IsToset {A : Type ℓ} (_≤_ : A → A → Type ℓ') : Type (ℓ-max 
     is-refl : isRefl _≤_
     is-trans : isTrans _≤_
     is-antisym : isAntisym _≤_
-    is-strongly-connected : isStronglyConnected _≤_
+    is-total : isTotal _≤_
 
 unquoteDecl IsTosetIsoΣ = declareRecordIsoΣ IsTosetIsoΣ (quote IsToset)
 
@@ -66,8 +66,8 @@ record TosetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')
 Toset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
 Toset ℓ ℓ' = TypeWithStr ℓ (TosetStr ℓ')
 
-toset : (A : Type ℓ) (_≤_ : A → A → Type ℓ') (h : IsToset _≤_) → Toset ℓ ℓ'
-toset A _≤_ h = A , tosetstr _≤_ h
+toset : (A : Type ℓ) → (_≤_ : Rel A A ℓ') → IsToset _≤_ → Toset ℓ ℓ'
+toset A _≤_ tos = A , (tosetstr _≤_ tos)
 
 record IsTosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
   (M : TosetStr ℓ₀' A) (e : A ≃ B) (N : TosetStr ℓ₁' B)
diff --git a/Cubical/Relation/Binary/Order/Toset/Properties.agda b/Cubical/Relation/Binary/Order/Toset/Properties.agda
index a7299ccc22..2bb17ea382 100644
--- a/Cubical/Relation/Binary/Order/Toset/Properties.agda
+++ b/Cubical/Relation/Binary/Order/Toset/Properties.agda
@@ -1,18 +1,23 @@
 {-# OPTIONS --safe #-}
 module Cubical.Relation.Binary.Order.Toset.Properties where
 
+open import Cubical.Data.Sigma
 open import Cubical.Data.Sum as ⊎
 open import Cubical.Data.Empty as ⊥
 
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.Prelude
 open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Structure
 
 open import Cubical.Functions.Embedding
 
 open import Cubical.HITs.PropositionalTruncation as ∥₁
 
 open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Proset.Properties
+open import Cubical.Relation.Binary.Order.Poset
 open import Cubical.Relation.Binary.Order.Toset.Base
 open import Cubical.Relation.Binary.Order.Loset.Base
 
@@ -36,14 +41,18 @@ module _
                           (IsToset.is-refl toset)
                           (IsToset.is-trans toset)
                           (IsToset.is-antisym toset)
+
+  isTosetDecidable→Discrete : IsToset R → isDecidable R → Discrete A
+  isTosetDecidable→Discrete = isPosetDecidable→Discrete ∘ isToset→isPoset
+
   private
     transirrefl : isTrans R → isAntisym R → isTrans (IrreflKernel R)
     transirrefl trans anti a b c (Rab , ¬a≡b) (Rbc , ¬b≡c)
       = trans a b c Rab Rbc
       , λ a≡c → ¬a≡b (anti a b Rab (subst (R b) (sym a≡c) Rbc))
 
-  isToset→isLosetIrreflKernel : Discrete A → IsToset R → IsLoset (IrreflKernel R)
-  isToset→isLosetIrreflKernel disc toset
+  isToset→isLosetIrreflKernel : IsToset R → isDecidable R → IsLoset (IrreflKernel R)
+  isToset→isLosetIrreflKernel toset dec
     = isloset (IsToset.is-set toset)
               (λ a b → isProp× (IsToset.is-prop-valued toset a b)
                                (isProp¬ (a ≡ b)))
@@ -59,15 +68,35 @@ module _
                          (λ Rbc → inr (Rbc , λ b≡c → ¬a≡c (a≡b ∙ b≡c)))
                                 λ Rcb → ⊥.rec (¬a≡c (IsToset.is-antisym toset a c Rac
                                               (subst (λ x → R c x) (sym a≡b) Rcb))))
-                                  (IsToset.is-strongly-connected toset b c))
+                                  (IsToset.is-total toset b c))
                          (λ ¬a≡b → ∥₁.map (⊎.map (λ Rab → Rab , ¬a≡b)
                                    (λ Rba → (IsToset.is-trans toset b a c Rba Rac)
                                    , λ b≡c → ¬a≡b (IsToset.is-antisym toset a b
                                        (subst (λ x → R a x) (sym b≡c) Rac) Rba)))
-                                 (IsToset.is-strongly-connected toset a b))
+                                 (IsToset.is-total toset a b))
                          (disc a b))
-              (isConnectedStronglyConnectedIrreflKernel R
-                (IsToset.is-strongly-connected toset))
+               λ { a b (¬¬Rab , ¬¬Rba) → IsToset.is-antisym toset a b
+                                         (decRec (λ Rab → Rab)
+                                           (λ ¬Rab → ⊥.rec (∥₁.rec isProp⊥
+                                             (⊎.rec ¬Rab λ Rba → ¬¬Rba (Rba ,
+                                               (λ b≡a → ¬Rab (subst (λ x → R x b) b≡a
+                                                 (IsToset.is-refl toset b)))))
+                                             (IsToset.is-total toset a b))) (dec a b))
+                                         (decRec (λ Rba → Rba)
+                                           (λ ¬Rba → ⊥.rec (∥₁.rec isProp⊥
+                                             (⊎.rec ¬Rba λ Rab → ¬¬Rab (Rab ,
+                                               (λ a≡b → ¬Rba (subst (λ x → R x a) a≡b
+                                                 (IsToset.is-refl toset a)))))
+                                             (IsToset.is-total toset b a))) (dec b a))}
+    where disc : Discrete A
+          disc = isTosetDecidable→Discrete toset dec
+
+  isTosetDecidable→isLosetDecidable : IsToset R → isDecidable R → isDecidable (IrreflKernel R)
+  isTosetDecidable→isLosetDecidable tos dec a b with dec a b
+  ... | no ¬Rab = no λ { (Rab , _) → ¬Rab Rab }
+  ... | yes Rab with (isTosetDecidable→Discrete tos dec) a b
+  ...       | yes a≡b = no λ { (_ , ¬a≡b) → ¬a≡b a≡b }
+  ...       | no  a≢b = yes (Rab , a≢b)
 
   isTosetInduced : IsToset R → (B : Type ℓ'') → (f : B ↪ A)
                  → IsToset (InducedRelation R (B , f))
@@ -78,14 +107,290 @@ module _
               (λ a b c → IsToset.is-trans tos (f a) (f b) (f c))
               (λ a b a≤b b≤a → isEmbedding→Inj emb a b
                 (IsToset.is-antisym tos (f a) (f b) a≤b b≤a))
-              λ a b → IsToset.is-strongly-connected tos (f a) (f b)
+              λ a b → IsToset.is-total tos (f a) (f b)
+
+  isTosetDual : IsToset R → IsToset (Dual R)
+  isTosetDual tos
+    = istoset (IsToset.is-set tos)
+              (λ a b → IsToset.is-prop-valued tos b a)
+              (IsToset.is-refl tos)
+              (λ a b c Rab Rbc → IsToset.is-trans tos c b a Rbc Rab)
+              (λ a b Rab Rba → IsToset.is-antisym tos a b Rba Rab)
+               λ a b → IsToset.is-total tos b a
 
 Toset→Poset : Toset ℓ ℓ' → Poset ℓ ℓ'
-Toset→Poset (_ , tos) = _ , posetstr (TosetStr._≤_ tos)
-                                     (isToset→isPoset (TosetStr.isToset tos))
-
-Toset→Loset : (tos : Toset ℓ ℓ') → Discrete (fst tos) → Loset ℓ (ℓ-max ℓ ℓ')
-Toset→Loset (_ , tos) disc
-  = _ , losetstr (BinaryRelation.IrreflKernel (TosetStr._≤_ tos))
-                       (isToset→isLosetIrreflKernel disc
-                                                    (TosetStr.isToset tos))
+Toset→Poset (_ , tos)
+  = poset _ (TosetStr._≤_ tos)
+            (isToset→isPoset (TosetStr.isToset tos))
+
+Toset→Loset : (tos : Toset ℓ ℓ')
+            → BinaryRelation.isDecidable (TosetStr._≤_ (snd tos))
+            → Loset ℓ (ℓ-max ℓ ℓ')
+Toset→Loset (_ , tos) dec
+  = loset _ (BinaryRelation.IrreflKernel (TosetStr._≤_ tos))
+            (isToset→isLosetIrreflKernel (TosetStr.isToset tos) dec)
+
+DualToset : Toset ℓ ℓ' → Toset ℓ ℓ'
+DualToset (_ , tos)
+  = toset _ (BinaryRelation.Dual (TosetStr._≤_ tos))
+            (isTosetDual (TosetStr.isToset tos))
+
+module _
+  {A : Type ℓ}
+  {_≤_ : Rel A A ℓ'}
+  (tos : IsToset _≤_)
+  where
+
+  private
+      pos = isToset→isPoset tos
+
+      pre = isPoset→isProset pos
+
+      prop = IsToset.is-prop-valued tos
+
+      rfl = IsToset.is-refl tos
+
+      anti = IsToset.is-antisym tos
+
+      trans = IsToset.is-trans tos
+
+      total = IsToset.is-total tos
+
+  module _
+    {P : Embedding A ℓ''}
+    where
+
+    private
+      toA = fst (snd P)
+
+    isMinimal→isLeast : ∀ n → isMinimal pre P n → isLeast pre P n
+    isMinimal→isLeast n ism m
+      = ∥₁.rec (prop _ _) (⊎.rec (λ n≤m → n≤m) (λ m≤n → ism m m≤n)) (total (toA n) (toA m))
+
+    isMaximal→isGreatest : ∀ n → isMaximal pre P n → isGreatest pre P n
+    isMaximal→isGreatest n ism m
+      = ∥₁.rec (prop _ _) (⊎.rec (λ n≤m → ism m n≤m) (λ m≤n → m≤n)) (total (toA n) (toA m))
+
+TosetIsPseudolattice : (tos : Toset ℓ ℓ')
+                     → isPseudolattice (Toset→Poset tos)
+TosetIsPseudolattice tos = meet , join
+  where
+    is = TosetStr.isToset (tos .snd)
+
+    posis = PosetStr.isPoset (Toset→Poset tos .snd)
+
+    prop = IsToset.is-prop-valued is
+
+    rfl = IsToset.is-refl is
+
+    trans = IsToset.is-trans is
+
+    total = IsToset.is-total is
+
+    meet : isMeetSemipseudolattice (Toset→Poset tos)
+    meet a b = ∥₁.rec (MeetUnique posis a b)
+                 (⊎.rec
+                   (λ a≤b → a ,
+                     λ x → propBiimpl→Equiv
+                             (prop _ _)
+                             (isProp× (prop _ _) (prop _ _))
+                             (λ x≤a → x≤a , (trans x a b x≤a a≤b))
+                              fst)
+                   (λ b≤a → b ,
+                     λ x → propBiimpl→Equiv
+                             (prop _ _)
+                             (isProp× (prop _ _) (prop _ _))
+                             (λ x≤b → trans x b a x≤b b≤a , x≤b)
+                              snd))
+                 (total a b)
+
+    join : isJoinSemipseudolattice (Toset→Poset tos)
+    join a b = ∥₁.rec (JoinUnique posis a b)
+                 (⊎.rec
+                   (λ a≤b → b ,
+                     λ x → propBiimpl→Equiv
+                             (prop _ _)
+                             (isProp× (prop _ _) (prop _ _))
+                             (λ b≤x → trans a b x a≤b b≤x , b≤x)
+                              snd)
+                   (λ b≤a → a ,
+                     λ x → propBiimpl→Equiv
+                             (prop _ _)
+                             (isProp× (prop _ _) (prop _ _))
+                             (λ a≤x → a≤x , trans b a x b≤a a≤x)
+                              fst))
+                 (total a b)
+
+-- We take the pseudolattice component in as an assumption because more likely than not,
+-- the goal is to prove some meet and join on a toset is distributive, not the
+-- meet and join that implicitly come with any toset
+TosetIsDistributivePseudolattice : (tos : Toset ℓ ℓ')
+                                 → (lat : isPseudolattice (Toset→Poset tos))
+                                 → MeetDistLJoin (Toset→Poset tos) lat
+TosetIsDistributivePseudolattice tos lat = dist
+  where
+    _≤_ = TosetStr._≤_ (tos .snd)
+    is = TosetStr.isToset (tos .snd)
+
+    pos = isToset→isPoset is
+
+    pro = isPoset→isProset pos
+
+    set = IsToset.is-set is
+
+    rfl = IsToset.is-refl is
+
+    trans = IsToset.is-trans is
+
+    anti = IsToset.is-antisym is
+
+    total = IsToset.is-total is
+
+    _∧l_ : ⟨ tos ⟩ → ⟨ tos ⟩ → ⟨ tos ⟩
+    a ∧l b = lat .fst a b .fst
+
+    meet : ∀ a b → isMeet pro a b (a ∧l b)
+    meet a b = lat .fst a b .snd
+
+    _∨l_ : ⟨ tos ⟩ → ⟨ tos ⟩ → ⟨ tos ⟩
+    a ∨l b = lat .snd a b .fst
+
+    join : ∀ a b → isJoin pro a b (a ∨l b)
+    join a b = lat .snd a b .snd
+
+    order→meet : ∀{a b} → a ≤ b → a ∧l b ≡ a
+    order→meet {a} {b} a≤b = sym (equivFun (order≃meet pos a b (a ∧l b) (meet a b)) a≤b)
+
+    order→join : ∀{a b} → a ≤ b → a ∨l b ≡ b
+    order→join {a} {b} a≤b = sym (equivFun (order≃join pos a b (a ∨l b) (join a b)) a≤b)
+
+    ∧Comm : ∀{a b} → a ∧l b ≡ b ∧l a
+    ∧Comm {a} {b} = meetComm pos (λ x y → (x ∧l y) , meet x y) a b
+
+    ∨Comm : ∀{ a b } → a ∨l b ≡ b ∨l a
+    ∨Comm {a} {b} = joinComm pos (λ x y → (x ∨l y) , join x y) a b
+
+    dist : ∀ a b c
+         → a ∧l (b ∨l c) ≡ (a ∧l b) ∨l (a ∧l c)
+    dist a b c = lem1+2+3+4+5+6+7+8
+      where
+        goal = a ∧l (b ∨l c) ≡ (a ∧l b) ∨l (a ∧l c)
+
+        lem1 : a ≤ b
+             → b ≤ c
+             → a ≤ c
+             → goal
+        lem1 a≤b b≤c a≤c = (cong (a ∧l_) (order→join b≤c) ∙
+                                   order→meet a≤c) ∙
+                             sym (cong₂ _∨l_ (order→meet a≤b)
+                                             (order→meet a≤c) ∙
+                                  order→join (rfl a))
+
+        lem2 : a ≤ b
+             → b ≤ c
+             → c ≤ a
+             → goal
+        lem2 a≤b b≤c c≤a = (cong (a ∧l_) (order→join b≤c) ∙
+                                   ∧Comm ∙
+                                   order→meet c≤a) ∙
+                             sym (cong₂ _∨l_ (order→meet a≤b)
+                                             (∧Comm ∙ order→meet c≤a) ∙
+                                  ∨Comm ∙
+                                  order→join c≤a ∙
+                                  anti a c (trans a b c a≤b b≤c) c≤a)
+
+        lem1+2 : a ≤ b
+               → b ≤ c
+               → goal
+        lem1+2 a≤b b≤c = ∥₁.rec (set _ _) (⊎.rec (lem1 a≤b b≤c) (lem2 a≤b b≤c)) (total a c)
+
+        lem3 : a ≤ b
+             → c ≤ b
+             → a ≤ c
+             → goal
+        lem3 a≤b c≤b a≤c = (cong (a ∧l_) (∨Comm ∙
+                                            order→join c≤b) ∙
+                                    order→meet a≤b) ∙
+                             sym (cong₂ _∨l_ (order→meet a≤b)
+                                             (order→meet a≤c) ∙
+                                  order→join (rfl a))
+
+        lem4 : a ≤ b
+             → c ≤ b
+             → c ≤ a
+             → goal
+        lem4 a≤b c≤b c≤a = (cong (a ∧l_) (∨Comm ∙
+                                            order→join c≤b) ∙
+                                    order→meet a≤b) ∙
+                             sym (cong₂ _∨l_ (order→meet a≤b)
+                                             (∧Comm ∙ order→meet c≤a) ∙
+                                  ∨Comm ∙
+                                  order→join c≤a)
+
+        lem3+4 : a ≤ b
+               → c ≤ b
+               → goal
+        lem3+4 a≤b c≤b = ∥₁.rec (set _ _ ) (⊎.rec (lem3 a≤b c≤b) (lem4 a≤b c≤b)) (total a c)
+
+        lem1+2+3+4 : a ≤ b
+                   → goal
+        lem1+2+3+4 a≤b = ∥₁.rec (set _ _) (⊎.rec (lem1+2 a≤b) (lem3+4 a≤b)) (total b c)
+
+        lem5 : b ≤ a
+             → b ≤ c
+             → a ≤ c
+             → goal
+        lem5 b≤a b≤c a≤c = (cong (a ∧l_) (order→join b≤c) ∙
+                                   order→meet a≤c) ∙
+                             sym (cong₂ _∨l_ (∧Comm ∙ order→meet b≤a) (order→meet a≤c) ∙
+                                  order→join b≤a)
+
+        lem6 : b ≤ a
+             → b ≤ c
+             → c ≤ a
+             → goal
+        lem6 b≤a b≤c c≤a = (cong (a ∧l_) (order→join b≤c) ∙
+                                   ∧Comm ∙
+                                   order→meet c≤a) ∙
+                             sym (cong₂ _∨l_ (∧Comm ∙ order→meet b≤a)
+                                             (∧Comm ∙ order→meet c≤a) ∙
+                                  order→join b≤c)
+
+        lem5+6 : b ≤ a
+               → b ≤ c
+               → goal
+        lem5+6 b≤a b≤c = ∥₁.rec (set _ _) (⊎.rec (lem5 b≤a b≤c) (lem6 b≤a b≤c)) (total a c)
+
+        lem7 : b ≤ a
+             → c ≤ b
+             → a ≤ c
+             → goal
+        lem7 b≤a c≤b a≤c = (cong (a ∧l_) (∨Comm ∙ order→join c≤b) ∙
+                                   ∧Comm ∙
+                                   order→meet b≤a) ∙
+                             sym (cong₂ _∨l_ (∧Comm ∙ order→meet b≤a)
+                                             (order→meet a≤c) ∙
+                                  order→join b≤a ∙ anti a b (trans a c b a≤c c≤b) b≤a)
+
+        lem8 : b ≤ a
+             → c ≤ b
+             → c ≤ a
+             → goal
+        lem8 b≤a c≤b c≤a = (cong (a ∧l_) (∨Comm ∙ order→join c≤b) ∙
+                                   ∧Comm ∙
+                                   order→meet b≤a) ∙
+                             sym (cong₂ _∨l_ (∧Comm ∙ order→meet b≤a)
+                                             (∧Comm ∙ order→meet c≤a) ∙
+                                  ∨Comm ∙ order→join c≤b)
+
+        lem7+8 : b ≤ a
+               → c ≤ b
+               → goal
+        lem7+8 b≤a c≤b = ∥₁.rec (set _ _) (⊎.rec (lem7 b≤a c≤b) (lem8 b≤a c≤b)) (total a c)
+
+        lem5+6+7+8 : b ≤ a
+                   → goal
+        lem5+6+7+8 b≤a = ∥₁.rec (set _ _) (⊎.rec (lem5+6 b≤a) (lem7+8 b≤a)) (total b c)
+
+        lem1+2+3+4+5+6+7+8 : goal
+        lem1+2+3+4+5+6+7+8 = ∥₁.rec (set _ _) (⊎.rec lem1+2+3+4 lem5+6+7+8) (total a b)
diff --git a/Cubical/Relation/Binary/Order/Woset/Properties.agda b/Cubical/Relation/Binary/Order/Woset/Properties.agda
index 9a2e0a52e3..6ab5edecdc 100644
--- a/Cubical/Relation/Binary/Order/Woset/Properties.agda
+++ b/Cubical/Relation/Binary/Order/Woset/Properties.agda
@@ -5,7 +5,7 @@ open import Cubical.Foundations.Prelude
 
 open import Cubical.Relation.Binary.Base
 open import Cubical.Relation.Binary.Order.Woset.Base
-open import Cubical.Relation.Binary.Order.StrictPoset.Base
+open import Cubical.Relation.Binary.Order.Quoset.Base
 
 open import Cubical.Induction.WellFounded
 
@@ -20,18 +20,18 @@ module _
 
   open BinaryRelation
 
-  isWoset→isStrictPoset : IsWoset R → IsStrictPoset R
-  isWoset→isStrictPoset wos = isstrictposet
-                              (IsWoset.is-set wos)
-                              (IsWoset.is-prop-valued wos)
-                              irrefl
-                              (IsWoset.is-trans wos)
-                              (isIrrefl×isTrans→isAsym R
-                                (irrefl , (IsWoset.is-trans wos)))
-                        where irrefl : isIrrefl R
-                              irrefl = WellFounded→isIrrefl R
-                                       (IsWoset.is-well-founded wos)
-
-Woset→StrictPoset : Woset ℓ ℓ' → StrictPoset ℓ ℓ'
-Woset→StrictPoset (_ , wos) = _ , strictposetstr (WosetStr._≺_ wos)
-                                  (isWoset→isStrictPoset (WosetStr.isWoset wos))
+  isWoset→isQuoset : IsWoset R → IsQuoset R
+  isWoset→isQuoset wos = isquoset
+                        (IsWoset.is-set wos)
+                        (IsWoset.is-prop-valued wos)
+                         irrefl
+                        (IsWoset.is-trans wos)
+                        (isIrrefl×isTrans→isAsym R
+                          (irrefl , (IsWoset.is-trans wos)))
+                   where irrefl : isIrrefl R
+                         irrefl = WellFounded→isIrrefl R
+                                 (IsWoset.is-well-founded wos)
+
+Woset→Quoset : Woset ℓ ℓ' → Quoset ℓ ℓ'
+Woset→Quoset (_ , wos) = _ , quosetstr (WosetStr._≺_ wos)
+                            (isWoset→isQuoset (WosetStr.isWoset wos))
diff --git a/Cubical/Relation/Binary/Order/Woset/Simulation.agda b/Cubical/Relation/Binary/Order/Woset/Simulation.agda
index 51b789b6e8..48235f4a3c 100644
--- a/Cubical/Relation/Binary/Order/Woset/Simulation.agda
+++ b/Cubical/Relation/Binary/Order/Woset/Simulation.agda
@@ -24,7 +24,7 @@ open import Cubical.Relation.Binary.Order.Woset.Base
 open import Cubical.Relation.Binary.Order.Poset
 open import Cubical.Relation.Binary.Base
 open import Cubical.Relation.Binary.Extensionality
-open import Cubical.Relation.Binary.Order.Properties
+open import Cubical.Relation.Binary.Order.Proset.Properties
 
 private
   variable
diff --git a/Cubical/Relation/Binary/Properties.agda b/Cubical/Relation/Binary/Properties.agda
index 0a245bc189..85bb6e89fc 100644
--- a/Cubical/Relation/Binary/Properties.agda
+++ b/Cubical/Relation/Binary/Properties.agda
@@ -11,12 +11,34 @@ open import Cubical.Functions.FunExtEquiv
 open import Cubical.Data.Sigma
 
 open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Nullary
 
 private
   variable
     ℓ ℓ' : Level
     A B : Type ℓ
 
+-- Theorem 7.2.2 in the HoTT Book
+module _ (R : Rel A A ℓ') where
+  open BinaryRelation R
+
+  reflPropRelImpliesIdentity→isSet : isRefl
+                                   → isPropValued
+                                   → impliesIdentity
+                                   → isSet A
+  reflPropRelImpliesIdentity→isSet Rrefl Rprop R→≡ = Collapsible≡→isSet λ where
+    x y .fst p → R→≡ (subst (R x) p (Rrefl x))
+    x y .snd p q → cong R→≡ (Rprop _ _ _ _)
+
+  reflPropRelImpliesIdentity→isUnivalent : isRefl
+                                         → isPropValued
+                                         → impliesIdentity
+                                         → isUnivalent
+  reflPropRelImpliesIdentity→isUnivalent Rrefl Rprop R→≡ x y =
+    propBiimpl→Equiv (Rprop x y) (Aset x y) R→≡ (λ p → subst (R x) p (Rrefl x)) where
+
+    Aset : isSet A
+    Aset = reflPropRelImpliesIdentity→isSet Rrefl Rprop R→≡
 
 -- Pulling back a relation along a function.
 -- This can for example be used when restricting an equivalence relation to a subset:
@@ -53,8 +75,8 @@ module _ {A B : Type ℓ} (e : A ≃ B) {_∼_ : Rel A A ℓ'} {_∻_ : Rel B B
 
   RelPathP : PathP (λ i → ua e i → ua e i → Type _)
               _∼_ _∻_
-  RelPathP i x y = Glue  (ua-unglue e i x ∻ ua-unglue e i y)
-      λ { (i = i0) → _ ,  x h y
+  RelPathP i x y = Glue (ua-unglue e i x ∻ ua-unglue e i y)
+      λ { (i = i0) → _ , x h y
         ; (i = i1) → _ , idEquiv _ }
 
 
@@ -62,7 +84,7 @@ module _ {ℓ''} {B : Type ℓ} {_∻_ : B → B → Type ℓ'} where
 
   JRelPathP-Goal : Type _
   JRelPathP-Goal = ∀ (A : Type ℓ) (e : A ≃ B) (_~_ : A → A → Type ℓ')
-             → (_h_ :  ∀ x y → x ~ y ≃ (fst e x ∻ fst e  y)) → Type ℓ''
+             → (_h_ :  ∀ x y → x ~ y ≃ (fst e x ∻ fst e y)) → Type ℓ''
 
 
   EquivJRel : (Goal : JRelPathP-Goal)
diff --git a/GNUmakefile b/GNUmakefile
index f9d8a6e9b5..e96b5383c9 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -57,7 +57,7 @@ timings: clean gen-everythings
 	$(AGDA) -v profile.modules:10 Cubical/README.agda
 
 .PHONY : listings
-listings: $(wildcard Cubical/**/*.agda)
+listings: gen-everythings $(wildcard Cubical/**/*.agda)
 	$(AGDA) -i. -isrc --html Cubical/README.agda -v0
 
 .PHONY : clean
diff --git a/README.md b/README.md
index 384c186946..7b34cd241f 100644
--- a/README.md
+++ b/README.md
@@ -12,12 +12,14 @@ For detailed install instructions see the
 [INSTALL](https://github.com/agda/cubical/blob/master/INSTALL.md)
 file.
 If you want to use some specific release of Agda,
-the following table lists which releases of Agda you can use with which release of this library.
+the following table lists which releases of Agda are known to work with which release of this library.
+Most likely, a lot more combinations work as well.
 Agda versions as written below, correspond to tags.
 
 | cubical library version | Agda versions                  |
 |-------------------------|--------------------------------|
-| current master          | `v2.6.4` `v2.6.4.1` `v2.6.4.3` |
+| current master          | `v2.7.0.1`                     |
+| `v0.8`                  | `v2.6.4.1` `v2.7.0.1`          |
 | `v0.7`                  | `v2.6.4` `v2.6.4.1`            |
 | `v0.6`                  | `v2.6.4`                       |
 | `v0.5`                  | `v2.6.3` `v2.6.4`              |
diff --git a/RELEASE.md b/RELEASE.md
index a96f8d306f..758f6814d8 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -43,3 +43,5 @@ Fill in the form with something like this:
   zip -r cubical-0.5.zip cubical
   tar cfz cubical-0.5.tar.gz cubical
   ```
+
+Create and push a tag for the new version of the library.
diff --git a/cubical-utils.cabal b/cubical-utils.cabal
index 42464c3d07..a684fc4595 100644
--- a/cubical-utils.cabal
+++ b/cubical-utils.cabal
@@ -4,11 +4,11 @@ cabal-version:   >= 1.10
 build-type:      Simple
 description:     Helper programs.
 license:         MIT
-tested-with:     GHC == 8.6.5
+tested-with:     GHC == 9.10.2
 
 executable Everythings
   hs-source-dirs:   .
   main-is:          Everythings.hs
   default-language: Haskell2010
-  build-depends:      base      >= 4.9.0.0 && < 4.20
+  build-depends:      base      >= 4.9.0.0 && < 4.22
                     , directory >= 1.0.0.0 && < 1.4
diff --git a/cubical.agda-lib b/cubical.agda-lib
index 064f900d4c..85499ce6c6 100644
--- a/cubical.agda-lib
+++ b/cubical.agda-lib
@@ -1,4 +1,4 @@
-name: cubical-0.7
+name: cubical-0.8
 include: .
 depend:
 flags: --cubical --no-import-sorts -WnoUnsupportedIndexedMatch
diff --git a/flake.lock b/flake.lock
index 6fa40f03e7..b66b947314 100644
--- a/flake.lock
+++ b/flake.lock
@@ -2,24 +2,22 @@
   "nodes": {
     "agda": {
       "inputs": {
-        "flake-utils": [
-          "flake-utils"
-        ],
+        "flake-parts": "flake-parts",
         "nixpkgs": [
           "nixpkgs"
         ]
       },
       "locked": {
-        "lastModified": 1701366566,
-        "narHash": "sha256-B8Jmjld0gGbkVO08GsovVqrUXCs8VfJ8UdM3sjHnzgM=",
+        "lastModified": 1726161230,
+        "narHash": "sha256-IupM/HJk1vpHTRWOakYDDliKn+RLzPjNzGlLTlF0CbY=",
         "owner": "agda",
         "repo": "agda",
-        "rev": "4293e0a94d15acac915ab9088b2ec028f78d14a9",
+        "rev": "a6fc20c27ae953149b53a8997ba4a1c8b17d628a",
         "type": "github"
       },
       "original": {
         "owner": "agda",
-        "ref": "v2.6.4.1",
+        "ref": "v2.7.0.1",
         "repo": "agda",
         "type": "github"
       }
@@ -27,11 +25,11 @@
     "flake-compat": {
       "flake": false,
       "locked": {
-        "lastModified": 1696426674,
-        "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=",
+        "lastModified": 1747046372,
+        "narHash": "sha256-CIVLLkVgvHYbgI2UpXvIIBJ12HWgX+fjA8Xf8PUmqCY=",
         "owner": "edolstra",
         "repo": "flake-compat",
-        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
+        "rev": "9100a0f413b0c601e0533d1d94ffd501ce2e7885",
         "type": "github"
       },
       "original": {
@@ -40,16 +38,34 @@
         "type": "github"
       }
     },
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1701473968,
+        "narHash": "sha256-YcVE5emp1qQ8ieHUnxt1wCZCC3ZfAS+SRRWZ2TMda7E=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "34fed993f1674c8d06d58b37ce1e0fe5eebcb9f5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
     "flake-utils": {
       "inputs": {
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1705309234,
-        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
@@ -60,11 +76,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1705883077,
-        "narHash": "sha256-ByzHHX3KxpU1+V0erFy8jpujTufimh6KaS/Iv3AciHk=",
+        "lastModified": 1747426788,
+        "narHash": "sha256-N4cp0asTsJCnRMFZ/k19V9akkxb7J/opG+K+jU57JGc=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "5f5210aa20e343b7e35f40c033000db0ef80d7b9",
+        "rev": "12a55407652e04dcf2309436eb06fef0d3713ef3",
         "type": "github"
       },
       "original": {
@@ -73,6 +89,24 @@
         "type": "indirect"
       }
     },
+    "nixpkgs-lib": {
+      "locked": {
+        "dir": "lib",
+        "lastModified": 1701253981,
+        "narHash": "sha256-ztaDIyZ7HrTAfEEUt9AtTDNoCYxUdSd6NrRHaYOIxtk=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e92039b55bcd58469325ded85d4f58dd5a4eaf58",
+        "type": "github"
+      },
+      "original": {
+        "dir": "lib",
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
         "agda": "agda",
diff --git a/flake.nix b/flake.nix
index 42f1b1beae..3db1690054 100644
--- a/flake.nix
+++ b/flake.nix
@@ -8,10 +8,9 @@
     flake = false;
   };
   inputs.agda = {
-    url = "github:agda/agda/v2.6.4.1";
+    url = "github:agda/agda/v2.7.0.1";
     inputs = {
       nixpkgs.follows = "nixpkgs";
-      flake-utils.follows = "flake-utils";
     };
   };
 
@@ -21,7 +20,7 @@
       overlay = final: prev: {
         cubical = final.agdaPackages.mkDerivation rec {
           pname = "cubical";
-          version = "0.7";
+          version = "0.8";
 
           src = cleanSourceWith {
             filter = name: type:
@@ -47,7 +46,7 @@
         };
         agdaWithCubical = final.agdaPackages.agda.withPackages [final.cubical];
       };
-      overlays = [ agda.overlay overlay ];
+      overlays = [ agda.overlays.default overlay ];
     in
     { overlays.default = overlay; } //
     flake-utils.lib.eachDefaultSystem (system: