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/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/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/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 fac79698da..0422ce48bb 100644
--- a/Cubical/Data/Int/Order.agda
+++ b/Cubical/Data/Int/Order.agda
@@ -4,11 +4,12 @@ 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 ℤ
 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,59 @@ 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
+
+ℕ≥→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
+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..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
@@ -11,7 +12,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 +1506,42 @@ 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
+
+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/Mod.agda b/Cubical/Data/Nat/Mod.agda
index 8911504e25..1d53e66990 100644
--- a/Cubical/Data/Nat/Mod.agda
+++ b/Cubical/Data/Nat/Mod.agda
@@ -4,7 +4,8 @@ module Cubical.Data.Nat.Mod where
 open import Cubical.Foundations.Prelude
 open import Cubical.Data.Nat
 open import Cubical.Data.Nat.Order
-open import Cubical.Data.Empty
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
 
 -- Defining x mod 0 to be 0. This way all the theorems below are true
 -- for n : ℕ instead of n : ℕ₊₁.
@@ -36,6 +37,9 @@ mod< n =
               , cong (λ x → fst ind + suc x)
                      (modIndStep n x) ∙ snd ind
 
+<→mod : (n x : ℕ) → x < (suc n) → x mod (suc n) ≡ x
+<→mod = modIndBase
+
 mod-rUnit : (n x : ℕ) → x mod n ≡ ((x + n) mod n)
 mod-rUnit zero x = refl
 mod-rUnit (suc n) x =
@@ -153,6 +157,7 @@ mod-lCancel n x y =
   ∙∙ mod-rCancel n y x
   ∙∙ cong (_mod n) (+-comm y (x mod n))
 
+
 -- remainder and quotient after division by n
 -- Again, allowing for 0-division to get nicer syntax
 remainder_/_ : (x n : ℕ) → ℕ
@@ -192,3 +197,117 @@ private
 
   test₁ : ((11 + (10 mod 3)) mod 3) ≡ 0
   test₁ = refl
+
+
+
+·mod : ∀ k n m → (k · n) mod (k · m)
+             ≡ k · (n mod m)
+·mod zero n m = refl
+·mod (suc k) n zero = cong ((n + k · n) mod_) (sym (0≡m·0 (suc k)))
+                  ∙ 0≡m·0 (suc k)
+·mod (suc k) n (suc m) = ·mod' n n ≤-refl (splitℕ-≤ (suc m) n)
+
+ where
+ ·mod' : ∀ N n → n ≤ N → ((suc m) ≤ n) ⊎ (n < suc m) →
+    ((suc k · n) mod (suc k · suc m)) ≡ suc k · (n mod suc m)
+ ·mod' _ zero x _ = cong (modInd (m + k · suc m)) (sym (0≡m·0 (suc k)))
+                  ∙ 0≡m·0 (suc k)
+ ·mod' zero (suc n) x _ = ⊥.rec (¬-<-zero x)
+ ·mod' (suc N) n@(suc n') x (inl (m' , p)) =
+  let z = ·mod' N m' (≤-trans (m
+               , +-comm m m' ∙ injSuc (sym (+-suc m' m) ∙ p))
+              (pred-≤-pred x)) (splitℕ-≤ _ _) ∙ cong ((suc k) ·_)
+            (sym (modIndStep m m') ∙
+             cong (_mod (suc m)) (+-comm (suc m) m' ∙ p))
+  in (cong (λ y → ((suc k · y) mod (suc k · suc m))) (sym p)
+       ∙ cong {x = (m' + suc m + k · (m' + suc m))}
+               {suc (m + k · suc m + (m' + k · m'))}
+            (modInd (m + k · suc m))
+              (cong (_+ k · (m' + suc m)) (+-suc m' m ∙ cong suc (+-comm m' m))
+                 ∙ cong suc
+                  (sym (+-assoc m m' _)
+                    ∙∙ cong (m +_)
+                       (((cong (m' +_) (sym (·-distribˡ k _ _)
+                         ∙ +-comm (k · m') _) ∙ +-assoc m' (k · suc m) (k · m'))
+                        ∙ cong (_+ k · m') (+-comm m' _))
+                        ∙ sym (+-assoc (k · suc m) m' (k · m')) )
+                    ∙∙ +-assoc m _ _))
+         ∙ modIndStep (m + k · suc m) (m' + k · m')) ∙ z
+ ·mod' (suc N) n x (inr x₁) =
+   modIndBase _ _ (
+     subst2 _<_ (·-comm n (suc k)) (·-comm _ (suc k))
+      (<-·sk {n} {suc m} {k = k} x₁) )
+    ∙ cong ((suc k) ·_) (sym (modIndBase _ _ x₁))
+
+2≤x→1<quotient[x/2] : ∀ n → 0 < quotient (2 + n) / 2
+2≤x→1<quotient[x/2] n =
+ let z : 0 < ((quotient (2 + n) / 2) · 2)
+     z = subst (0 <_) (·-comm 2 (quotient (2 + n) / 2))
+          (≤<-trans {m = n }
+             {n = 2 · (quotient (2 + n) / 2)} zero-≤
+            (<-k+-cancel (subst (_< 2 +
+             (2 · (quotient (2 + n) / 2)))
+           (≡remainder+quotient 2 (2 + n))
+             (<-+k {k = 2 · (quotient (2 + n) / 2)}
+              (mod< 1 (2 + n))))))
+ in <-·sk-cancel {0} {quotient (2 + n) / 2 } {k = 1} z
+
+
+
+2≤x→quotient[x/2]<x : ∀ n → quotient (2 + n) / 2 < (2 + n)
+2≤x→quotient[x/2]<x n =
+  subst ((quotient 2 + n / 2) <_)
+    (≡remainder+quotient 2 (2 + n))
+    (<≤-trans
+      ( subst ((quotient 2 + n / 2) <_)
+          ((cong ((quotient 2 + n / 2) +_)
+            (sym (+-zero (quotient 2 + n / 2)))))
+            (<-+k {k = (quotient 2 + n / 2)}
+             (2≤x→1<quotient[x/2] n)) )
+      (≤SumRight {_} {(remainder 2 + n / 2)}))
+
+
+-- -- TODO: shoulld be easy to generalise to other nuumbers than 2
+
+-- log2ℕ : ∀ n → Σ _ (Minimal.Least (λ k → n < 2 ^ k))
+-- log2ℕ n = w n n ≤-refl
+--  where
+
+--   w : ∀ N n → n ≤ N
+--           → Σ _ (Minimal.Least (λ k → n < 2 ^ k))
+--   w N zero x = 0 , (≤-refl , λ k' q → ⊥.rec (¬-<-zero q))
+--   w N (suc zero) x = 1 , (≤-refl ,
+--      λ { zero q → <-asym (suc-≤-suc ≤-refl)
+--       ; (suc k') q → ⊥.rec (¬-<-zero (pred-≤-pred q))})
+--   w zero (suc (suc n)) x = ⊥.rec (¬-<-zero x)
+--   w (suc N) (suc (suc n)) x =
+--    let (k , (X , Lst)) = w N
+--           (quotient 2 + n / 2)
+--           (≤-trans (pred-≤-pred (2≤x→quotient[x/2]<x n))
+--              (pred-≤-pred x))
+--        z = ≡remainder+quotient 2 (2 + n)
+--        zz = <-+-≤ X X
+--        zzz : suc (suc n) < (2 ^ suc k)
+--        zzz = subst2 (_<_)
+--            (+-comm ({!remainder 2 + n / 2!} +
+--                      (({!!})))
+--                       ({!!})
+--               ∙ sym (+-assoc _ _ _)
+--                ∙ cong ((remainder 2 + n / 2) +_)
+--              ((cong ((quotient 2 + n / 2) +_)
+--               (sym (+-zero (quotient 2 + n / 2)))))
+--              ∙ z)
+--            (cong ((2 ^ k) +_) (sym (+-zero (2 ^ k))))
+--            ((≤<-trans
+--              (≤-k+ {k = _}
+--                (≤-+k {k = {!!}} (pred-≤-pred (mod< 1 (2 + n))))) zz))
+--    in (suc k)
+--        , zzz
+--         , λ { zero 0'<sk 2+n<2^0' →
+--                 ⊥.rec (¬-<-zero (pred-≤-pred 2+n<2^0'))
+--             ; (suc k') k'<sk 2+n<2^k' →
+--                Lst k' (pred-≤-pred k'<sk)
+--                 (<-·sk-cancel {k = 1}
+--                     (subst2 _<_ (·-comm _ _) (·-comm _ _)
+--                       (≤<-trans (_ , z)
+--                          2+n<2^k' )))}
diff --git a/Cubical/Data/Nat/Order.agda b/Cubical/Data/Nat/Order.agda
index 87ffadf43f..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)
 
@@ -142,6 +145,15 @@ 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)
+
+≤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))
 
@@ -224,6 +236,20 @@ 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)
+<-·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 +506,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 +577,126 @@ 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⊥)
+
+<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/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 ce5e518567..d8509f682b 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 0136e99319..a92bb89da0 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⊎)
@@ -28,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
@@ -164,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
 
@@ -401,6 +418,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)
@@ -418,6 +436,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}
@@ -444,6 +463,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}
@@ -458,6 +496,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}
@@ -495,6 +539,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}
@@ -532,6 +588,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}
@@ -559,6 +618,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
@@ -581,6 +642,7 @@ min≤
 <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
@@ -588,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)
@@ -611,6 +689,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)
 
@@ -629,3 +709,292 @@ 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 : ∀ 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 =
+  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)
+
+≤≃≡⊎< : ∀ 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
new file mode 100644
index 0000000000..0b6a42dd42
--- /dev/null
+++ b/Cubical/Data/Rationals/Order/Properties.agda
@@ -0,0 +1,1756 @@
+{-# 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.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)
+
+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
+
+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 ]
+                   ≡ [ ℤ.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)))
+
+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 =
+ let ((fl , fr) , e , (e' , e'')) = floor-fracℚ₊ x
+
+ in decRec
+      (λ p → (fl , 0) ,
+        (+IdR _ ∙ sym e ∙ cong  ((fromNat fl) +_) (sym p) ∙ (+IdR _)) ,
+          (isRefl≤ 0 , decℚ<?))
+      (λ p → (suc fl , (1 ℚ.- fr)) ,
+          (cong₂ (_+_) (sym e) (ℚ.+Comm [ ℤ.pos 1 / 1+ 0 ] (- fr)) ∙
+            sym (ℚ.+Assoc _ _ _) ∙
+              cong  ((fromNat fl) +_)
+                (ℚ.+Assoc _ _ _
+                  ∙∙ cong (_+ 1) (+InvR _) ∙∙ +IdL 1)
+               ∙ ℚ.+Comm (fromNat fl) 1 ∙ ℕ+→ℚ+ _ _) ,
+               <Weaken≤ 0 _ (-< fr 1 e'') ,
+                 (<-o+ _ _ 1 (
+                   (⊎.rec (⊥.rec ∘ p) (minus-< 0 fr) (≤→≡⊎< 0 fr e')))))
+     (discreteℚ 0 fr)
+
+
+
+floor-frac : ∀ (x : ℚ) → Σ (ℤ × ℚ) λ (k , q) →
+                       ([ k , 1 ] + q ≡ x) × ((0 ≤ q)  × (q < 1))
+floor-frac x with 0 ≟ x
+... | lt x₁ =
+  let ((c , fr') , e ) = floor-fracℚ₊ (x , <→0< _ x₁)
+  in (ℤ.pos c , fr') , e
+
+... | eq x₁ = (0 , 0) , (x₁ , isRefl≤ 0 , decℚ<? )
+... | gt x₁ =
+  let ((c , fr') , e , e') = ceil-[1-frac]ℚ₊
+          (- x , <→0< (- x) (minus-< x 0 x₁))
+      fl = (ℤ.- ℤ.pos c)
+      p : [ fl , 1 ] + fr' ≡ x
+      p = (sym (-Invol _)
+             ∙ cong (-_) (-Distr _ _
+                 ∙ cong (_- fr')
+                    (cong [_/ 1 ] (ℤ.-Involutive _) )))
+              ∙ sym (cong -_ (+CancelL- _ _ _ e)) ∙ -Invol _
+  in (fl , fr') ,
+        p , e'
+
+
+ceilℚ₊ : (q : ℚ₊) → Σ[ k ∈ ℕ₊₁ ] (fst q) < fromNat (ℕ₊₁→ℕ k)
+ceilℚ₊ q = 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)))))
+
+
+
+
+
+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)
+
+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)
+  → (∀ 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)
+
+
+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 ∙∙
+                ℚ.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'))
+
+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
+  (ℚ.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))
+
+-≤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)
+
+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
+
+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
+ 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ℚ?)
+
+/4₊≡/2₊/2₊ : ∀ ε → fst (/4₊ ε) ≡ fst (/2₊ (/2₊ ε))
+/4₊≡/2₊/2₊ ε = cong (fst ε ·_) decℚ? ∙ ·Assoc _ _ _
+
+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))))
+
+
+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)))
+
+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)
+
+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
+
+
+
+ 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 _ _ _)))
+
+
+
+<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)
+clampDelta 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
+
+
+
+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 $ 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')
+       $ 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)
+
+
+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)
+clampDist L L' =
+ elimBy≤ (λ x y → subst2 _≤_ (absComm- (clamp L L' y) (clamp L L' x))
+    (absComm- y x)) (clampDist' L L')
+
+maxDist : ∀ M x y →
+    abs (max M y - max M x) ≤ abs (y - x)
+maxDist M x y =
+  subst2 {x = min (max M y) (max M (max x y))}
+          {(max M y)}
+    {z = min (max M x) (max M (max x y))} {(max M x)}
+    (λ a b → abs (a - b) ≤ abs (y - x))
+    (≤→min _ _ (subst (max M y ≤_)
+      (sym (maxAssoc _ _ _) ∙ cong (max M) (maxComm _ _))
+      (≤max _ _)))
+    (≤→min _ _
+      ((subst (max M x ≤_)
+      (sym (maxAssoc _ _ _))
+      (≤max _ _))))
+    (clampDist M (max M (max x y)) x y)
+
+
+≤→<⊎≡ : ∀ p q → p ≤ q → (p ≡ q) ⊎ (p < q)
+≤→<⊎≡ p q x with p ≟ q
+... | lt x₁ = inr x₁
+... | eq x₁ = inl x₁
+... | gt x₁ = ⊥.rec $ ≤→≯ p q x x₁
+
+
+getPosRatio : (L₁ L₂ : ℚ₊) → (fst ((invℚ₊ L₁) ℚ₊·  L₂) ≤ 1)
+                           ⊎ (fst ((invℚ₊ L₂) ℚ₊·  L₁) ≤ 1)
+getPosRatio L₁ L₂ =
+  elimBy≤ {A = λ (L₁ L₂ : ℚ) → (<L₁ : 0< L₁) → (<L₂ : 0< L₂)
+                      →  (((fst (invℚ₊ (L₁ , <L₁) ℚ₊·  (L₂ , <L₂))) ≤ 1)
+                           ⊎ ((fst ((invℚ₊ (L₂ , <L₂)) ℚ₊·
+                            (L₁ , <L₁))) ≤ 1))}
+    (λ x y x₁ <L₁ <L₂ →
+      Iso.fun (⊎.⊎-swap-Iso) (x₁ <L₂ <L₁) )
+     (λ L₁ L₂ x₁ <L₁ <L₂ →
+             inr (
+               subst (fst (invℚ₊ (L₂ , <L₂)) · L₁ ≤_)
+                  (invℚ₊[x]·x (L₂ , <L₂))
+                  (≤-o· L₁ L₂ (fst (invℚ₊ (L₂ , <L₂)))
+                    (0≤ℚ₊ (invℚ₊ (L₂ , <L₂))) x₁)))
+     (fst L₁) (fst L₂) (snd L₁) (snd L₂)
+
+
+·MaxDistrℚ : ∀ x y z → 0< z → (max x y) · z ≡ max (x · z) (y · z)
+·MaxDistrℚ = SQ.elimProp3 (λ _ _ _ → isPropΠ λ _ → isSetℚ _ _)
+  www
+
+ where
+ www : (a b c : ℤ.ℤ × ℕ₊₁) →
+         0< _//_.[ c ] →
+         max _//_.[ a ] _//_.[ b ] · _//_.[ c ] ≡
+         max (_//_.[ a ] · _//_.[ c ]) (_//_.[ b ] · _//_.[ c ])
+ www (a , a') (b , b') (c@(pos (suc n)) , c') x = eq/ _ _
+    wwww
+  where
+
+   wwww' : ∀ a b' →  a ℤ.· ℕ₊₁→ℤ b' ℤ.· pos (suc n) ℤ.· pos (ℕ₊₁→ℕ c')
+              ≡ ((a ℤ.· c) ℤ.· ℕ₊₁→ℤ (b' ·₊₁ c'))
+   wwww' a b' =
+      cong (ℤ._· pos (ℕ₊₁→ℕ c')) (sym (ℤ.·Assoc _ _ _) ∙
+            (cong (a ℤ.·_) (ℤ.·Comm _ _)) ∙ ℤ.·Assoc _ _ _) ∙
+         sym (ℤ.·Assoc _ _ _) ∙
+         cong ((a ℤ.· pos (suc n)) ℤ.·_) (sym (ℤ.pos·pos _ _))
+
+
+   wwww : ℤ.max (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a') ℤ.· c
+            ℤ.· ℕ₊₁→ℤ (a' ·₊₁ c' ·₊₁ (b' ·₊₁ c'))
+          ≡ ℤ.max ((a ℤ.· c) ℤ.· ℕ₊₁→ℤ (b' ·₊₁ c'))
+                    ((b ℤ.· c) ℤ.· ℕ₊₁→ℤ (a' ·₊₁ c'))  ℤ.·
+              ℕ₊₁→ℤ (a' ·₊₁ b' ·₊₁ c')
+   wwww =
+    cong (ℤ.max (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a') ℤ.· pos (suc n) ℤ.·_)
+      (cong (λ ac → ℕ₊₁→ℤ (ac ·₊₁ (b' ·₊₁ c'))) (·₊₁-comm a'  c')
+       ∙∙ cong ℕ₊₁→ℤ (sym (·₊₁-assoc  _ _ _)) ∙∙
+         ℤ.pos·pos _ _)
+      ∙∙ ℤ.·Assoc _ _ _ ∙∙
+    cong₂ (ℤ._·_)
+       (cong (ℤ._· (pos (ℕ₊₁→ℕ c')))
+         (ℤ.·DistPosLMax (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a') (suc n))
+         ∙ ℤ.·DistPosLMax
+              ((a ℤ.· ℕ₊₁→ℤ b') ℤ.· pos (suc n))
+              ((b ℤ.· ℕ₊₁→ℤ a') ℤ.· pos (suc n)) (ℕ₊₁→ℕ c')
+          ∙ cong₂ ℤ.max
+          (wwww' a b') (wwww' b a'))
+           (cong ℕ₊₁→ℤ (·₊₁-assoc a' b' c'))
+
+
+·MaxDistrℚ' : ∀ x y z → 0 ≤ z → (max x y) · z ≡ max (x · z) (y · z)
+·MaxDistrℚ' x y z =
+  ⊎.rec (λ p → cong ((max x y) ·_) (sym p) ∙
+        ·AnnihilR (max x y)  ∙ cong₂ max (sym (·AnnihilR x) ∙ cong (x ·_) p)
+            (sym (·AnnihilR y) ∙ cong (y ·_) p))
+    (·MaxDistrℚ x y z ∘ <→0< z) ∘ (≤→≡⊎< 0 z)
+
+≤Monotone·-onNonNeg : ∀ x x' y y' →
+  x ≤ x' →
+  y ≤ y' →
+  0 ≤ x →
+  0 ≤ y →
+   x · y ≤ x' · y'
+≤Monotone·-onNonNeg x x' y y' x≤x' y≤y' 0≤x 0≤y =
+  isTrans≤ _ _ _ (≤-·o x x' y 0≤y x≤x')
+   (≤-o· y y' x' (isTrans≤ 0 _ _ 0≤x x≤x') y≤y')
+
+<Monotone·-onPos : ∀ x x' y y' →
+  x < x' →
+  y < y' →
+  0 ≤ x →
+  0 ≤ y →
+   x · y < x' · y'
+<Monotone·-onPos x x' y y' x₁ x₂ x₃ x₄ =
+   let zz = 0<-m·n (x' - x) (y' - y) (-< x x' x₁) (-< y y' x₂)
+   in subst2 _<_ (+IdL _ ∙ +IdR _)
+          (lem--039 {x'} {x} {y'} {y})
+        (<≤Monotone+ 0 ((x' - x) · (y' - y)) (x · y + 0)
+             (x' · y + ((x · (y' - y)))) zz
+               (≤Monotone+ (x · y) (x' · y) 0  (x · (y' - y))
+                (≤-·o x x' y x₄ (<Weaken≤ x x' x₁))
+                (subst (_≤ x · (y' - y))
+                  (·AnnihilL _) $ ≤-·o 0 x (y' - y)
+                  (<Weaken≤ 0 (y' - y) (-< y y' x₂) ) x₃)))
+
+
+≤<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))
+
+invℚ₊≡invℚ : ∀ q p → invℚ (fst q) p ≡ fst (invℚ₊ q)
+invℚ₊≡invℚ q p = cong₂ _·_ (fst (<→sign (fst q)) (0<ℚ₊ q)
+    ) (cong (fst ∘ invℚ₊) (ℚ₊≡ (sym (abs'≡abs (fst q)) ∙
+     absPos (fst q) ((0<ℚ₊ q))))) ∙ ·IdL (fst (invℚ₊ q))
+
+fromNat-invℚ : ∀ n p → invℚ [ pos (suc n) / 1 ] p ≡ [ 1 / 1+ n ]
+fromNat-invℚ n p = invℚ₊≡invℚ _ _
+
+
+invℚ-pos : ∀ x y → 0 < x → 0 < invℚ x y
+invℚ-pos x y z =
+  subst (0 <_)
+    (sym (invℚ₊≡invℚ (x , <→0< _ z) y))
+      (0<ℚ₊ (invℚ₊ (x , <→0< _ z)))
+
+
+0#invℚ : ∀ q 0#q → 0 # (invℚ q 0#q)
+0#invℚ q 0#q = ·Monotone0# _ _  (fst (0#sign q) 0#q)
+  (inl (0<ℚ₊ (invℚ₊ (0#→ℚ₊ q 0#q))))
+
+
+
+
+·DistInvℚ : ∀ x y 0#x 0#y 0#xy →
+  (invℚ x 0#x) · (invℚ y 0#y) ≡ invℚ (x · y) 0#xy
+·DistInvℚ x y 0#x 0#y 0#xy =
+  (sym (·Assoc _ _ _) ∙
+    cong ((sign x) ·_)
+      (·Assoc _ _ _
+       ∙∙ cong (_· fst (invℚ₊ (0#→ℚ₊ y 0#y)))
+         (·Comm _ _) ∙∙
+       sym (·Assoc _ _ _))
+   ∙ (·Assoc _ _ _)) ∙
+   cong₂ _·_
+     (sign·sign x y)
+     (cong fst (invℚ₊Dist· (0#→ℚ₊ x 0#x) (0#→ℚ₊ y 0#y))
+       ∙ cong (fst ∘ invℚ₊) (ℚ₊≡ (abs'·abs' _ _)) )
+
+invℚ-sign : ∀ q 0#q → sign q ≡ (invℚ (sign q) 0#q)
+invℚ-sign q =
+  ⊎.rec (λ p → p ∙ cong (uncurry invℚ)
+    (Σ≡Prop  (λ _ → isProp# _ _)
+     {u = 1 , inl (𝟚.toWitness {Q = <Dec 0 1} _)} (sym p) ))
+     ((λ p → p ∙ cong (uncurry invℚ)
+    (Σ≡Prop  (λ _ → isProp# _ _)
+     {u = -1 , inr (𝟚.toWitness {Q = <Dec -1 0} _)} (sym p) )))
+ ∘ ⊎.map (fst (fst (<≃sign q)))
+   (fst (snd (snd (<≃sign q)))) ∘ invEq (0#sign q)
+
+
+invℚInvol : ∀ q 0#q 0#invQ → invℚ (invℚ q 0#q) 0#invQ ≡ q
+invℚInvol q 0#q 0#invQ =
+  sym (·DistInvℚ (sign q) _ (fst (0#sign q) 0#q)
+    (inl (0<ℚ₊ (invℚ₊ ((0#→ℚ₊ q 0#q)) )))
+    0#invQ )
+    ∙∙ cong₂ _·_ (sym (invℚ-sign _ _))
+     ((invℚ₊≡invℚ _ _ ∙ invℚ₊-invol (0#→ℚ₊ q 0#q)) ∙  sym (abs'≡abs q))  ∙∙
+     (·Comm _ _ ∙ (sign·abs q))
+
+
+_／ℚ[_,_] : ℚ → ∀ r → 0 # r  → ℚ
+q ／ℚ[ r , 0＃r ] = q · (invℚ r 0＃r)
+
+
+ℚ-y/y : ∀ r → (0＃r : 0 # r) → (r ／ℚ[ r , 0＃r ]) ≡ 1
+ℚ-y/y r y = cong (_· (invℚ r y)) (sym (sign·abs r))
+  ∙ sym (·Assoc _ _ _)
+  ∙ cong (abs r ·_) (·Assoc _ _ _ ∙∙
+    cong (_· fst (invℚ₊ (0#→ℚ₊ r y))) (signX·signX r y) ∙∙
+      ·IdL _)
+  ∙ cong (_· fst (invℚ₊ (0#→ℚ₊ r y))) (abs'≡abs _)
+   ∙ x·invℚ₊[x] (0#→ℚ₊ r y)
+
+ℚ-[x·y]/y : ∀ x r → (0＃r : 0 # r) → ((x · r) ／ℚ[ r , 0＃r ]) ≡ x
+ℚ-[x·y]/y x r 0#r = sym (·Assoc _ _ _) ∙∙
+  cong (x ·_) (ℚ-y/y r 0#r) ∙∙ ·IdR x
+
+ℚ-[x/y]·y : ∀ x r → (0＃r : 0 # r) → ((x ／ℚ[ r , 0＃r ]) · r) ≡ x
+ℚ-[x/y]·y x r 0#r = sym (·Assoc _ _ _) ∙∙
+  cong (x ·_) (·Comm _ _ ∙ ℚ-y/y r 0#r) ∙∙ ·IdR x
+
+
+ℚ-x·y≡z→x≡z/y : ∀ x q r → (0＃r : 0 # r)
+               → (x · r) ≡ q
+               → x ≡ q ／ℚ[ r , 0＃r ]
+ℚ-x·y≡z→x≡z/y x q r 0＃r p =
+    sym (ℚ-[x·y]/y x r 0＃r ) ∙ cong (_／ℚ[ r , 0＃r ]) p
+
+x≤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
+ℚ-x/y<z→x/z<y x q r 0<x 0<q 0<r p =
+ subst2 _<_ (sym (·Assoc _ _ _)
+   ∙  cong (x ·_) ((·Comm _ _) ∙
+     cong (_· invℚ r (inl 0<r)) (·Comm _ _) ∙
+      ℚ-[x·y]/y _ _ _ ) )
+   ((·Comm _ _) ∙ ℚ-[x/y]·y _ _ _)
+   (<-·o (x ／ℚ[ r , (inl 0<r) ]) q (r ／ℚ[ q , (inl 0<q) ])
+     (0<-m·n _ _ 0<r (invℚ-pos q (inl 0<q)  0<q)) p)
+
+invℚ≤invℚ : ∀ (p q : ℚ₊) → fst q ≤ fst p → fst (invℚ₊ p) ≤ fst (invℚ₊ q)
+invℚ≤invℚ p q x =
+ subst2 _≤_
+   (cong ((fst q) ·_) (·Comm _ _) ∙
+    (y·[x/y] q (fst (invℚ₊ p)))) (y·[x/y] p (fst (invℚ₊ q)))
+    (≤-·o _ _ (fst ((invℚ₊ p) ℚ₊· (invℚ₊ q)))
+     (0≤ℚ₊ ((invℚ₊ p) ℚ₊· (invℚ₊ q))) x)
+
+maxWithPos : ℚ₊ → ℚ → ℚ₊
+maxWithPos ε q .fst = max (fst ε) q
+maxWithPos ε q .snd = <→0< (max (fst ε) q)
+ (isTrans<≤ 0 (fst ε) _ (0<ℚ₊ ε) (≤max (fst ε) q))
+
+
+1/p+1/q : (p q : ℚ₊) → fst (invℚ₊ p) - fst (invℚ₊ q) ≡
+                       fst (invℚ₊ (p ℚ₊· q))
+                        · (fst q - fst p)
+1/p+1/q (p , p') (q , q') =
+  ElimProp2.go w p q p' q'
+ where
+  w : ElimProp2 λ p q → ∀ p' q'
+           → fst (invℚ₊ (p , p')) - fst (invℚ₊ (q , q')) ≡
+                       fst (invℚ₊ ((p , p') ℚ₊· (q , q')))
+                        · (q - p)
+  w .ElimProp2.isPropB _ _ = isPropΠ2 λ _ _ → isSetℚ _ _
+  w .ElimProp2.f (pos (suc x) , 1+ x') (pos (suc y) , 1+ y') p' q' =
+    eq/ _ _
+      (cong₂ ℤ._·_
+           (λ i → ((pos (suc x') ℤ.· ℕ₊₁→ℤ (·₊₁-identityˡ (1+ y) i))
+           ℤ.+ (ℤ.negsuc·pos y' ( (suc x)) i)))
+           (((λ i → ℤ.pos·pos
+            (ℕ₊₁→ℕ $ fst
+           (ℤ.0<→ℕ₊₁ (pos (suc x) ℤ.· pos (suc y))
+            (·0< _//_.[ pos (suc x) , (1+ x') ]
+             _//_.[ pos (suc y) , (1+ y') ] p' q')))
+             (ℕ₊₁→ℕ ((1+ y') ·₊₁ (·₊₁-identityˡ (1+ x') i))) i) ∙
+               λ i → snd
+               (ℤ.0<→ℕ₊₁ (pos (suc x) ℤ.· pos (suc y))
+                (·0< _//_.[ pos (suc x) , (1+ x') ]
+                _//_.[ pos (suc y) , (1+ y') ] p' q')) (~ i)
+                 ℤ.· (pos (ℕ₊₁→ℕ ((1+ y') ·₊₁ (1+ x'))))) ∙
+                  ℤ.·Comm _ _) ∙ ℤ.·Assoc _ _ _  ∙∙
+              cong (ℤ._· _) (cong₂ ℤ._·_
+                (cong₂ ℤ._+_ (ℤ.·Comm _ _) (cong ℤ.-_ (ℤ.·Comm _ _)))
+                (cong (pos ∘ ℕ₊₁→ℕ)
+                  (·₊₁-comm (1+ y') (1+ x')))
+                 ∙ ℤ.·Comm _ _) ∙ cong ((ℕ₊₁→ℤ
+               (fst (ℤ.0<→ℕ₊₁ (ℕ₊₁→ℤ ((1+ x') ·₊₁ (1+ y'))) tt))
+            ℤ.· ((pos (suc y) ℤ.· ℕ₊₁→ℤ ((1+ x')))
+                 ℤ.+ (ℤ.- (ℤ.pos (suc x) ℤ.· ℕ₊₁→ℤ (1+ y')))))
+          ℤ.·_) (sym (ℤ.pos·pos (suc x) _))
+               ∙∙ λ i → (ℕ₊₁→ℤ (fst (ℤ.0<→ℕ₊₁
+                (ℕ₊₁→ℤ ((1+ x') ·₊₁ (1+ y'))) tt))
+            ℤ.· ((pos (suc y) ℤ.· ℕ₊₁→ℤ (·₊₁-identityˡ (1+ x') (~ i)))
+                 ℤ.+ (ℤ.negsuc·pos x (suc y') (~ i))))
+          ℤ.· ℕ₊₁→ℤ ((1+ x) ·₊₁ (·₊₁-identityˡ (1+ y) (~ i))))
+
+invℚ₊≤invℚ₊ : ∀ x y
+      → fst y ≤ fst x
+      → fst (invℚ₊ x) ≤ fst (invℚ₊ y)
+invℚ₊≤invℚ₊ x y p =
+  subst2 _≤_
+    ((sym (·Assoc _ _ _) ∙∙
+     cong (fst (invℚ₊ x) ·_) (invℚ₊[x]·x y)
+     ∙∙ ·IdR (fst (invℚ₊ x))))
+    (sym (·Assoc _ _ _) ∙∙
+     cong (fst (invℚ₊ y) ·_) (invℚ₊[x]·x x)
+     ∙∙ ·IdR (fst (invℚ₊ y)))
+     (≤Monotone·-onNonNeg _ _ _ _
+        (≡Weaken≤ _ _ (·Comm (fst (invℚ₊ x)) (fst (invℚ₊ y)) ))
+        p
+        ((0≤ℚ₊ ((invℚ₊ x) ℚ₊· (invℚ₊ y))))
+        ((0≤ℚ₊ y)))
+
+
+
+
+_ℚ^ⁿ_ : ℚ → ℕ → ℚ
+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
+
+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 _ _ _)
+   ∙ 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 _ _))
+
+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 100921a315..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,76 +68,143 @@ open import Cubical.Data.Rationals.Base
    a ℤ.· (ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ c)  ≡⟨ cong (a ℤ.·_) (sym (pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ c))) ⟩
    a ℤ.· ℕ₊₁→ℤ (b ·₊₁ c) ∎)
 
--- useful functions for defining operations on ℚ
+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) )
 
-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 ∎
+-- useful functions for defining operations on ℚ
 
-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 ] })
+reduce : ℚ → ℚ
+reduce = [_] ∘ fst ∘  reduced
+
+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 +217,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 +255,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 +295,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 +436,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 +453,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 +492,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ℚ _ _)
@@ -456,12 +566,33 @@ _·_ = onCommonDenomSym
 ·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
 
+-Distr : ∀ x y → - (x + y) ≡ - x + - y
+-Distr = ·DistL+ -1
+
 negateEquiv : ℚ ≃ ℚ
 negateEquiv = isoToEquiv (iso -_ -_ -Invol -Invol)
 
@@ -474,6 +605,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 +628,66 @@ 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 → [ 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/Foundations/HLevels.agda b/Cubical/Foundations/HLevels.agda
index 18fe6927fb..3f5f7ae634 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)
@@ -797,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
@@ -863,3 +873,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/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/HITs/CauchyReals.agda b/Cubical/HITs/CauchyReals.agda
new file mode 100644
index 0000000000..200d8e2dd7
--- /dev/null
+++ b/Cubical/HITs/CauchyReals.agda
@@ -0,0 +1,12 @@
+{-# OPTIONS --safe #-}
+module Cubical.HITs.CauchyReals where
+
+open import Cubical.HITs.CauchyReals.Base public
+open import Cubical.HITs.CauchyReals.Closeness public
+open import Cubical.HITs.CauchyReals.Lipschitz public
+open import Cubical.HITs.CauchyReals.Order public
+open import Cubical.HITs.CauchyReals.Continuous public
+open import Cubical.HITs.CauchyReals.Multiplication public
+open import Cubical.HITs.CauchyReals.Inverse public
+open import Cubical.HITs.CauchyReals.Sequence public
+open import Cubical.HITs.CauchyReals.Derivative public
diff --git a/Cubical/HITs/CauchyReals/Base.agda b/Cubical/HITs/CauchyReals/Base.agda
new file mode 100644
index 0000000000..af62ea23da
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Base.agda
@@ -0,0 +1,312 @@
+{-# OPTIONS --safe #-}
+module Cubical.HITs.CauchyReals.Base where
+
+open import Cubical.Foundations.Prelude hiding (Path)
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+
+open import Cubical.Data.Int as ℤ
+open import Cubical.Data.Rationals as ℚ
+open import Cubical.Data.Rationals.Order as ℚ
+
+open import Cubical.Data.NatPlusOne
+
+private
+  variable
+    ℓ ℓ' : Level
+
+-- HoTT Definition 11.3.2.
+
+data ℝ : Type
+
+data _∼[_]_  : ℝ → ℚ₊ → ℝ → Type
+
+data ℝ where
+ rat : ℚ → ℝ
+ -- HoTT (11.3.3)
+ lim : (x : ℚ₊ → ℝ) →
+       (∀ ( δ ε : ℚ₊) → x δ ∼[ δ ℚ₊+ ε ] x ε) →  ℝ
+ -- HoTT (11.3.4)
+ eqℝ : ∀ x y → (∀ ε → x ∼[ ε ] y) → x ≡ y
+
+data _∼[_]_   where
+ rat-rat : ∀ q r ε
+   → (ℚ.- fst ε) ℚ.< (q ℚ.- r)
+   → (q ℚ.- r) ℚ.< fst ε → (rat q) ∼[ ε ] (rat r)
+ rat-lim : ∀ q y ε δ p v →
+        (rat q) ∼[ fst ε ℚ.- fst δ , v ] ( y δ )
+        → (rat q) ∼[ ε ] (lim y p )
+ lim-rat : ∀ x r ε δ p v →
+        (x δ) ∼[ fst ε ℚ.- fst δ , v ] ( rat r )
+        → (lim x p) ∼[ ε ] (rat r )
+ lim-lim : ∀ x y ε δ η p p' v →
+        (x δ) ∼[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v ] (y η )
+        → (lim x p) ∼[ ε ] (lim y p' )
+ isProp∼ : ∀ r q r' → isProp (r ∼[ q ] r')
+
+rat-rat-fromAbs : ∀ q r ε
+   → ℚ.abs (q ℚ.- r) ℚ.< fst ε → (rat q) ∼[ ε ] (rat r)
+rat-rat-fromAbs q r ε x =
+  rat-rat _ _ _
+      (isTrans<≤ (ℚ.- fst ε) (ℚ.- ℚ.abs (q ℚ.- r)) (q ℚ.- r)
+         (minus-< (ℚ.abs (q ℚ.- r)) (fst ε)  x)
+           (isTrans≤ (ℚ.- ℚ.abs (q ℚ.- r))
+             (ℚ.- (ℚ.- (q ℚ.- r))) (q ℚ.- r)
+             (minus-≤ (ℚ.- (q ℚ.- r)) (ℚ.abs (q ℚ.- r))
+               (isTrans≤ (ℚ.- (q ℚ.- r)) _ (ℚ.abs (q ℚ.- r))
+                  (ℚ.≤max (ℚ.- (q ℚ.- r)) (q ℚ.- r))
+                    (≡Weaken≤ (ℚ.max (ℚ.- (q ℚ.- r)) (q ℚ.- r))
+                     _
+                       (ℚ.maxComm (ℚ.- (q ℚ.- r)) (q ℚ.- r) ))))
+              (≡Weaken≤ (ℚ.- (ℚ.- (q ℚ.- r))) (((q ℚ.- r)))
+                 (ℚ.-Invol (q ℚ.- r)))))
+    ( isTrans≤< (q ℚ.- r) (ℚ.abs (q ℚ.- r)) (fst ε)
+      (ℚ.≤max (q ℚ.- r) (ℚ.- (q ℚ.- r)) ) x)
+
+
+_∼[_]ₚ_ : ℝ → ℚ₊ → ℝ → hProp ℓ-zero
+x ∼[ ε ]ₚ y = x ∼[ ε ] y , isProp∼ _ _ _
+
+
+instance
+  fromNatℝ : HasFromNat ℝ
+  fromNatℝ = record { Constraint = λ _ → Unit ; fromNat = λ n → rat [ pos n / 1 ] }
+
+instance
+  fromNegℝ : HasFromNeg ℝ
+  fromNegℝ = record { Constraint = λ _ → Unit ; fromNeg = λ n → rat [ neg n / 1 ] }
+
+
+record Elimℝ {ℓ} {ℓ'} (A : ℝ → Type ℓ)
+               (B : ∀ {x y : ℝ} →
+                  A x → A y →
+                ∀ ε → x ∼[ ε ] y → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+ field
+  ratA : ∀ x → A (rat x)
+  -- HoTT (11.3.5)
+  limA : ∀ x p → (a : ∀ q → A (x q)) →
+             (∀ δ ε → B {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'
+
+  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/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
new file mode 100644
index 0000000000..c2116e7a46
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Closeness.agda
@@ -0,0 +1,851 @@
+{-# OPTIONS --safe #-}
+module Cubical.HITs.CauchyReals.Closeness where
+
+open import Cubical.Foundations.Prelude hiding (Path)
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv hiding (_■)
+open import Cubical.Foundations.HLevels
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.Rationals as ℚ
+open import Cubical.Data.Rationals.Order as ℚ
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+
+
+
+-- HoTT Lemma (11.3.8)
+refl∼ : ∀ r ε → r ∼[ ε ] r
+refl∼ = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop _
+ w .Elimℝ-Prop.ratA x x₁ =
+   rat-rat x x x₁
+     (subst ((ℚ.- (fst x₁)) ℚ.<_) (sym (+InvR x))
+       (minus-< 0 (fst x₁) ((0<→< (fst x₁) (snd x₁)))))
+        --(minus-< 0 (fst x₁) (snd x₁)))
+        ((subst ( ℚ._< (fst x₁)) (sym (+InvR x)) ((0<→< (fst x₁) (snd x₁)))))
+ w .Elimℝ-Prop.limA x p _ ε =
+  let e1 = /2₊ (/2₊ ε)
+      zz = +CancelL- (fst (/2₊ ε)) (fst (/2₊ ε)) (fst ε)
+            (ε/2+ε/2≡ε (fst ε))
+          ∙ cong ( ℚ._-_ (fst ε)) (sym (ε/2+ε/2≡ε (fst (/2₊ ε))))
+  in lim-lim x x ε e1 e1 p p
+        (subst (0<_) zz (snd ((/2₊ ε))))
+       (subst (λ e → x e1 ∼[ e ] x e1)
+       (ℚ₊≡ (ε/2+ε/2≡ε (fst (/2₊ ε)) ∙
+          zz ))
+       (p e1 e1))
+ w .Elimℝ-Prop.isPropA _ = isPropΠ λ _ → isProp∼ _ _ _
+
+
+-- HoTT Lemma (11.3.12)
+sym∼ : ∀ r r' ε → r ∼[ ε ] r' → r' ∼[ ε ] r
+sym∼ r r' ε (rat-rat q r₁ .ε x x₁) =
+ rat-rat r₁ q ε (subst ((ℚ.- fst ε) ℚ.<_)
+  ((ℚ.-Distr' q r₁ ∙ ℚ.+Comm (ℚ.- q) r₁))
+    $ minus-< (q ℚ.- r₁) (fst ε) x₁)
+  (subst2 ℚ._<_ (ℚ.-Distr' q r₁ ∙ ℚ.+Comm (ℚ.- q) r₁)
+    (ℚ.-Invol (fst ε)) (minus-< (ℚ.- fst ε)  (q ℚ.- r₁) x))
+
+sym∼ r r' ε (rat-lim q y .ε δ p v x) =
+ lim-rat y q ε δ p v (sym∼ _ _ _ x)
+sym∼ r r' ε (lim-rat x r₁ .ε δ p v x₁) =
+  rat-lim r₁ x ε δ p v (sym∼ _ _ _ x₁)
+sym∼ r r' ε (lim-lim x y .ε δ η p p' v x₁) =
+ let z = ((sym∼ (x δ) (y η) _ x₁))
+     z' = subst (λ xx → Σ _ λ v → y η ∼[ (fst ε ℚ.- xx) , v ] x δ)
+            (ℚ.+Comm (fst δ) (fst η))
+             (v , z)
+ in lim-lim y x ε η δ  p' p (fst z') (snd z')
+sym∼ r r' ε (isProp∼ .r .ε .r' x x₁ i) =
+  isProp∼ r' ε r (sym∼ _ _ _ x) (sym∼ _ _ _ x₁) i
+
+-- HoTT Theorem (11.3.9)
+isSetℝ : isSet ℝ
+isSetℝ = lem722 (λ r r' → ∀ ε →  r ∼[ ε ] r')
+  (λ _ _ → isPropΠ λ _ → isProp∼ _ _ _)
+   eqℝ
+   refl∼
+
+∼≃≡ : ∀ r r' → (∀ ε → r ∼[ ε ] r') ≃  (r ≡ r')
+∼≃≡ r r' = propBiimpl→Equiv (isPropΠ λ _ → isProp∼ _ _ _) (isSetℝ _ _) (eqℝ _ _)
+  (J (λ r' _ → ∀ ε → r ∼[ ε ] r') (refl∼ _))
+
+≡→∼ : ∀ {ε r r'} → r ≡ r' → r ∼[ ε ] r'
+≡→∼ {ε} {r} {r'} p = invEq (∼≃≡ r r') p ε
+
+
+
+
+rat-rat' : ℚ → ℚ₊ → ℚ → hProp ℓ-zero
+rat-rat' q ε r .fst = ((ℚ.- fst ε) ℚ.< (q ℚ.- r)) × ((q ℚ.- r) ℚ.< fst ε)
+rat-rat' q ε r .snd = isProp× (ℚ.isProp< (ℚ.- fst ε) (q ℚ.- r))
+                        (ℚ.isProp< (q ℚ.- r) (fst ε))
+
+
+rat-rat'-sym : ∀ q ε r → ⟨ rat-rat' q ε r ⟩ → ⟨ rat-rat' r ε q ⟩
+rat-rat'-sym q ε r x .fst =
+  subst ((ℚ.- fst ε) ℚ.<_) (ℚ.-Distr' q r ∙ ℚ.+Comm (ℚ.- q) r)
+   (minus-< (q ℚ.- r) (fst ε) (snd x))
+rat-rat'-sym q ε r x .snd =
+  subst2 (ℚ._<_) (ℚ.-Distr' q r ∙ ℚ.+Comm (ℚ.- q) r) (ℚ.-Invol (fst ε))
+   (minus-<  (ℚ.- fst ε) (q ℚ.- r) (fst x))
+
+Σ< : (ℚ₊ → Type) → (ℚ → Type)
+Σ< P q = Σ _ (P ∘ (q ,_) )
+
+rat-lim' : ℚ₊ → (ℚ₊ → ℚ₊ → hProp ℓ-zero) → hProp ℓ-zero
+rat-lim' ε a =
+  (∃[ δ ∈ ℚ₊ ]
+      Σ< (fst ∘ a δ) (((fst ε) ℚ.- (fst δ)))  ) , squash₁
+
+lim-lim' : ℚ₊ → (ℚ₊ → ℚ₊ → ℚ₊ → hProp ℓ-zero) → hProp ℓ-zero
+lim-lim' ε a =
+  (∃[ (δ , η)  ∈ ℚ₊ × ℚ₊ ]
+      Σ< (fst ∘ a δ η) ((fst ε) ℚ.- (fst δ ℚ.+ fst η)) ) , squash₁
+
+
+w-prop' : (ℚ₊ → hProp ℓ-zero) → Type
+w-prop' = λ △ → ∀ ε → ⟨
+               ( △ ε ) L.⇔ (L.∃[ θ ∶ ℚ₊ ]
+                  (L.∃[ v ] (△ (((fst ε) ℚ.- (fst θ)) , v)))) ⟩
+
+
+substΣ< : (P : Σ (ℚ₊ → hProp ℓ-zero) w-prop') → ∀ {x y} → x ≡ y →
+             Σ< (fst ∘ (fst P)) x → Σ< (fst ∘ (fst P)) y
+substΣ< P = subst (Σ< (fst ∘ (fst P)))
+
+
+pre-w-rel' : Σ (ℚ₊ → hProp ℓ-zero) w-prop' →
+           Σ (ℚ₊ → hProp ℓ-zero) w-prop' → ℚ₊ → ℚ₊ → Type
+
+w-rel'  : Σ (ℚ₊ → hProp ℓ-zero) w-prop' →
+           Σ (ℚ₊ → hProp ℓ-zero) w-prop' → ℚ₊ → Type
+
+pre-w-rel' = λ (△ , _) (◻ , _) ε η
+       → (⟨ △ η ⟩ →  ⟨ ◻ (ε ℚ₊+ η) ⟩)
+
+
+w-rel' = λ △ ◻ ε →
+     ∀ η → pre-w-rel' △ ◻ ε η
+           × pre-w-rel' ◻ △  ε η
+
+w-rel'-sym : ∀ △ ◻ ε → w-rel' △ ◻ ε → w-rel' ◻ △  ε
+w-rel'-sym △ ◻ ε x η = fst Σ-swap-≃ (x η)
+
+w-rel'⇒ : ∀ x y → (∀ ε → w-rel' x y ε) → ∀ ε
+          → ⟨ fst x ε ⟩ → ⟨ fst y ε ⟩
+w-rel'⇒ x y x₁ ε x₂ =
+ let z = fst (snd x ε) x₂
+     z' = PT.map (λ (δ , xx) →
+              /2₊ δ , PT.map
+                  (λ (xxx , xxx') →
+                    substΣ< y
+                      (cong (λ zz → fst (/2₊ δ) ℚ.+ (fst ε ℚ.- zz))
+                        (sym (ε/2+ε/2≡ε (fst δ))) ∙
+                          lem--08 {fst (/2₊ δ)} {fst ε})
+                       (_ , (fst (x₁ (/2₊ δ) _) xxx')))
+                      xx) z
+ in snd (snd y ε)
+       z'
+
+w-rel'→≡ : ∀ x y → (∀ ε → w-rel' x y ε) → x ≡ y
+w-rel'→≡ x y p =
+  Σ≡Prop (λ x₁ → isPropΠ λ x →
+     (snd (x₁ x L.⇔
+     L.∃[∶]-syntax
+     (λ θ → L.∃[]-syntax (λ v₁ → x₁ ((fst x ℚ.- fst θ) , v₁))))))
+      (funExt λ ε →
+   L.⇔toPath (w-rel'⇒ x y p ε)
+     (w-rel'⇒ y x (λ ε₁ → w-rel'-sym x y ε₁ (p ε₁)) ε))
+
+
+
+r-r : ℚ → ℚ → Σ _ w-prop'
+r-r q r .fst ε = rat-rat' q ε r
+r-r q r .snd ε .fst x =
+ let z = getθ ε (q ℚ.- r) x
+ in ∣ fst z , ∣ fst (snd z)  , snd (snd z) ∣₁ ∣₁
+r-r q r .snd ε .snd =
+  PT.rec (snd (rat-rat' q ε r)) (uncurry λ q* →
+   PT.rec (snd (rat-rat' q ε r))
+     λ (x₁ , y) →
+       weak0<' (q ℚ.- r) ε q* (fst y) , weak0< (q ℚ.- r) ε q* (snd y) )
+
+
+
+r-l : (a : ℚ₊ → Σ _ w-prop')
+
+        → Σ _ w-prop'
+r-l a .fst ε = rat-lim' ε (fst ∘ a)
+r-l a .snd ε .fst =
+  PT.rec
+      squash₁
+       λ (q' , v , pp) →
+          let aa = fst ((snd (a q')) ((fst ε ℚ.- fst q') , v)) pp
+          in PT.map
+              (map-snd λ {a''} →
+               (PT.map
+                λ x₂ →
+                  strength-lem-01 ε q' a'' (fst x₂) ,
+                   ∣ q' ,
+                    subst {A = ℚ}
+                    (λ qq → Σ (0< qq)
+                        (λ x₃ → ⟨ a q' .fst (qq , x₃) ⟩))
+                    (sym (ℚ.+Assoc (fst ε) (ℚ.- (fst q')) (ℚ.- (fst a'')))
+                      ∙∙ cong (fst ε ℚ.+_)
+                            (ℚ.+Comm (ℚ.- (fst q')) (ℚ.- (fst a'')))
+                      ∙∙ (ℚ.+Assoc (fst ε) (ℚ.- (fst a'')) (ℚ.- (fst q')))) x₂ ∣₁))
+              aa
+
+r-l a .snd ε .snd =
+       PT.rec
+      squash₁
+        (uncurry λ q' →
+           PT.rec squash₁ (uncurry λ v →
+              PT.map λ (q'' , zz) →
+                let zzz = snd (snd (a q'') (fst ε ℚ.- fst q'' ,
+                     strength-lem-01 ε q' q'' (fst zz)))
+                            ∣ q' ,
+                              ∣ subst {A = ℚ}
+                       (λ qq → Σ (0< qq)
+                        (λ x₃ → ⟨ a q'' .fst (qq , x₃) ⟩))
+                         ((sym (ℚ.+Assoc (fst ε) (ℚ.- (fst q')) (ℚ.- (fst q'')))
+                      ∙∙ cong (fst ε ℚ.+_)
+                            (ℚ.+Comm (ℚ.- (fst q')) (ℚ.- (fst q'')))
+                      ∙∙ (ℚ.+Assoc (fst ε) (ℚ.- (fst q'')) (ℚ.- (fst q')))))
+                         zz ∣₁ ∣₁
+                in q'' , _ , zzz))
+
+
+l-l : (𝕒 : ℚ₊ → ℚ₊ → Σ _ w-prop')
+
+  → Σ (ℚ₊ → hProp ℓ-zero) w-prop'
+
+l-l 𝕒 .fst ε = lim-lim' ε (λ x x₁ → fst (𝕒 x x₁))
+l-l 𝕒 .snd ε .fst =
+ PT.rec squash₁
+ (λ ((δ , η) , (v , y)) →
+    PT.map (map-snd (λ {q'} → PT.map
+          (λ (x , x') → strength-lem-01 ε (δ ℚ₊+ η) q' x , ∣ (δ , η) ,
+            subst (Σ< (fst ∘ (fst (𝕒 δ η))))
+              (+AssocCommR (fst ε) (ℚ.- (fst δ ℚ.+ fst η))
+                (ℚ.- fst q'))
+                (x , x')
+            ∣₁ )))
+              (fst (snd (𝕒 δ η) _) y))
+l-l 𝕒 .snd ε .snd =
+  PT.rec squash₁
+     (uncurry λ q' →
+       PT.rec squash₁ (uncurry λ v →
+         PT.map (map-snd
+           λ {(δ , η)} (x , x') → strength-lem-01 ε q' (δ ℚ₊+ η) x ,
+            (snd (snd (𝕒 δ η) _) ∣ q' , ∣
+              subst (Σ< (fst ∘ (fst (𝕒 δ η))))
+               (sym ((+AssocCommR (fst ε) (ℚ.- (fst δ ℚ.+ fst η))
+                (ℚ.- fst q'))))
+               (x , x') ∣₁ ∣₁) )))
+
+rel-r-r : ∀ 𝕢 → (q r : ℚ) (ε : Σ ℚ 0<_) →
+     (ℚ.- fst ε) ℚ.< (q ℚ.- r) →
+     (q ℚ.- r) ℚ.< fst ε → w-rel' (r-r 𝕢 q) (r-r 𝕢 r) ε
+rel-r-r 𝕢 q r ε x x₁ η =
+ let z : (((q ℚ.- r) ℚ.+ (𝕢 ℚ.- q)) ≡ (𝕢 ℚ.- r))
+     z = lem--09 {q} {r} {𝕢}
+ in (λ (u , v) →
+      subst2 ℚ._<_
+           (sym $ ℚ.-Distr (fst ε) (fst η))
+           z
+            (ℚ.<Monotone+ (ℚ.- fst ε) (q ℚ.- r)
+               (ℚ.- fst η)  (𝕢 ℚ.- q) x u)
+
+               , subst (ℚ._< fst ε ℚ.+ fst η)
+                   z
+                 (ℚ.<Monotone+ (q ℚ.- r) (fst ε) (𝕢 ℚ.- q) (fst η)  x₁ v))
+  , (λ (u , v) →
+       let zz = ℚ.<Monotone+  (ℚ.- (fst ε)) (ℚ.- (q ℚ.- r))
+                       (ℚ.- fst η) (𝕢 ℚ.- r)
+                           (ℚ.minus-< (q ℚ.- r) (fst ε)   x₁) u
+
+       in subst2 ℚ._<_ (sym $ ℚ.-Distr (fst ε) (fst η) )
+                   (lem--010 {q} {r} {𝕢}) zz
+               ,
+           let zz = ℚ.<Monotone+
+                      (ℚ.- (q ℚ.- r)) (ℚ.- (ℚ.- (fst ε))) (𝕢 ℚ.- r)
+                       (fst η) (minus-< (ℚ.- (fst ε)) (q ℚ.- r) x) v
+           in subst2 {x = (ℚ.- (q ℚ.- r)) ℚ.+ (𝕢 ℚ.- r)} {𝕢 ℚ.- q}
+                {z = (ℚ.- (ℚ.- fst ε)) ℚ.+ fst η} {fst (ε ℚ₊+ η)}
+               ℚ._<_
+                (lem--010 {q} {r} {𝕢}) (lem--012 {fst ε} {fst η}) zz)
+
+rel-r-l : ∀ 𝕢 → (q : ℚ) (y : ℚ₊ → Σ (ℚ₊ → hProp ℓ-zero) w-prop')
+     (ε : ℚ₊) (p : (δ ε₁ : ℚ₊) → w-rel' (y δ) (y ε₁) (δ ℚ₊+ ε₁))
+     (δ : ℚ₊) (v₁ : 0< (fst ε ℚ.- fst δ)) →
+     w-rel' (r-r 𝕢 q) (y δ) ((fst ε ℚ.- fst δ) , v₁) →
+     w-rel' (r-r 𝕢 q) (r-l y) ε
+rel-r-l 𝕢 q y ε p δ v₁ x η .fst xx' =
+ let z = fst (x η) xx'
+ in ∣ δ , (subst {x = fst η ℚ.+ (fst ε ℚ.- fst δ)}
+               {y = (fst (ε ℚ₊+ η) ℚ.- fst δ)} 0<_
+               (lem--013 {fst η} {fst ε} {fst δ})
+               (+0< (fst η) (fst ε ℚ.- fst δ) (snd η) v₁) ,
+        subst (fst ∘ fst (y δ)) (ℚ₊≡ (lem--014 {fst ε} {fst δ} {fst η})) z ) ∣₁
+
+rel-r-l 𝕢 q y ε p δ v₁ x η .snd =
+   PT.rec (snd (rat-rat' 𝕢 (ε ℚ₊+ η) q))
+    λ (σ* , (xx , xx')) →
+      let z = fst (p _ _ _) xx'
+          z' = snd (x _) z
+      in subst
+              {x = (((fst ε ℚ.- fst δ) , v₁) ℚ₊+
+                 ((σ* ℚ₊+ δ) ℚ₊+ ((fst η ℚ.- fst σ*) , xx)))}
+                {(ε ℚ₊+ η)}
+             (λ xxx → ⟨ rat-rat' 𝕢 xxx q ⟩)
+               (ℚ₊≡ (lem--015 {fst ε} {fst δ} {fst σ*} {fst η})) z'
+
+rel-l-l' : (x y : ℚ₊ → Σ (ℚ₊ → hProp ℓ-zero) w-prop') (ε δ η : ℚ₊)
+     (p : (δ₁ ε₁ : ℚ₊) → w-rel' (x δ₁) (x ε₁) (δ₁ ℚ₊+ ε₁))
+     (p' : (δ₁ ε₁ : ℚ₊) → w-rel' (y δ₁) (y ε₁) (δ₁ ℚ₊+ ε₁))
+     (v₁ : 0< (fst ε ℚ.- (fst δ ℚ.+ fst η))) → ∀ η' →
+     (∀ η' →
+       pre-w-rel' (x δ) (y η) ((fst ε ℚ.- (fst δ ℚ.+ fst η)) , v₁) η') →
+     pre-w-rel' (r-l x) (r-l y) ε η'
+rel-l-l' x y ε δ η p p' v₁ η' x₁ =
+   PT.map (λ (a , (xx , xx')) →
+       let zz = fst (p a δ _) xx'
+           zz' = x₁ _ zz
+       in η ,
+            subst (ℚ.0<_)
+                (lem-02  (fst ε) (fst δ) (fst η) (fst η'))
+                  (+0< (fst ε ℚ.- (fst δ ℚ.+ fst η))
+                   (fst (δ ℚ₊+ η'))  v₁ (snd (δ ℚ₊+ η')))
+             , (subst (fst ∘ y η .fst)
+             (ℚ₊≡ (lem-01 (fst ε) (fst δ) (fst η) (fst η') (fst a))) zz'))
+
+
+
+rel-l-l : (x y : ℚ₊ → Σ (ℚ₊ → hProp ℓ-zero) w-prop') (ε δ η : ℚ₊)
+     (p : (δ₁ ε₁ : ℚ₊) → w-rel' (x δ₁) (x ε₁) (δ₁ ℚ₊+ ε₁))
+     (p' : (δ₁ ε₁ : ℚ₊) → w-rel' (y δ₁) (y ε₁) (δ₁ ℚ₊+ ε₁))
+     (v₁ : 0< (fst ε ℚ.- (fst δ ℚ.+ fst η))) →
+     w-rel' (x δ) (y η) ((fst ε ℚ.- (fst δ ℚ.+ fst η)) , v₁) →
+     w-rel' (r-l x) (r-l y) ε
+rel-l-l x y ε δ η p p' v₁ x₁ η₁ =
+  rel-l-l' x y ε δ η p p' v₁ η₁ (fst ∘ x₁)
+   , let zz : Σ (0< (fst ε ℚ.- (fst η ℚ.+ fst δ)))
+                  λ v →
+                    (η' : ℚ₊) →
+                pre-w-rel' (y η) (x δ)
+             ((fst ε ℚ.- (fst η ℚ.+ fst δ)) , v) η'
+         zz =
+               subst
+                  (λ xxx → Σ (0< (fst ε ℚ.- xxx))
+                  λ v →
+                    (η' : ℚ₊) →
+                pre-w-rel' (y η) (x δ)
+             ((fst ε ℚ.- xxx) , v) η')
+                  (ℚ.+Comm (fst δ) (fst η))
+                  (v₁ , snd ∘ x₁)
+     in rel-l-l' y x ε η δ  p' p (fst zz) η₁ (snd zz)
+
+w-prop : (ℚ₊ → ℝ → hProp ℓ-zero) → Type
+w-prop =
+ λ ♢ → (∀ u ε → ⟨ (♢ ε u)  L.⇔ (L.∃[ θ ∶ ℚ₊ ]
+                     L.∃[ v ] ♢ (((fst ε) ℚ.- (fst θ)) , v) u)
+                    ⟩ ) ×
+                      (∀ u v ε η →
+                         u ∼[ ε ] v →
+                           (⟨ ♢ η u ⟩ → ⟨ ♢ (ε ℚ₊+ η) v ⟩ ))
+
+
+substΣ<' : (P : Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop) → ∀ r → ∀ {x y} → x ≡ y →
+             Σ< (fst ∘ (flip (fst P) r)) x → Σ< (fst ∘ flip (fst P) r) y
+substΣ<' P r = subst (Σ< (fst ∘ (flip (fst P) r)))
+
+
+isProp-w-prop :  ∀ ♢ → isProp (w-prop ♢)
+isProp-w-prop ♢ =
+  isProp× (isPropΠ2 λ u ε →
+              snd (
+     ♢ ε u L.⇔
+     L.∃[∶]-syntax
+     (λ θ → L.∃[]-syntax (λ v₁ → ♢ ((fst ε ℚ.- fst θ) , v₁) u)))
+     )
+    (isPropΠ6 λ _ v ε η _ _ →
+        snd (♢ (ε ℚ₊+ η) v))
+
+w-rel : Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop →
+          Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop → ℚ₊ → Type
+w-rel = λ (♢ , _) (♥ , _) ε →
+         (∀ u η → (⟨ ♢ η u ⟩ →  ⟨ ♥ (ε ℚ₊+ η) u ⟩)
+                  × (⟨ ♥ η u ⟩ →  ⟨ ♢ (ε ℚ₊+ η) u ⟩))
+
+isSym-w-rel : ∀ a a' → (∀ ε → w-rel a a' ε) → (∀ ε → w-rel a' a ε)
+isSym-w-rel a a' w ε u η = fst Σ-swap-≃ (w ε u η)
+
+w-rel→⇒ : ∀ a a' → (∀ ε → w-rel a a' ε)
+             → ∀ ε u → ⟨ fst a ε u ⟩ → ⟨ fst a' ε u ⟩
+w-rel→⇒ a a' x ε u x₁ =
+  w-rel'⇒ ((flip (fst a) u) , (fst (snd a) u))
+    ((flip (fst a') u) , (fst (snd a') u))
+     (λ ε₁ → x ε₁ u)
+    ε x₁
+
+w-rel→≡ : ∀ a a' → (∀ ε → w-rel a a' ε) → a ≡ a'
+w-rel→≡ a a' w =
+  Σ≡Prop isProp-w-prop
+    (funExt₂ λ ε u →
+       L.⇔toPath (w-rel→⇒ a a' w ε u)
+         (w-rel→⇒ a' a (isSym-w-rel a a' w) ε u))
+
+rel-l-l-l : ∀ {𝕒 : ℚ₊ → Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop}
+
+              → (x y : ℚ₊ → ℝ) → ∀ ε δ η
+              (p : ∀ δ₁ ε₁ → x δ₁ ∼[ δ₁ ℚ₊+ ε₁ ] x ε₁)
+              (p' : ∀ δ₁ ε₁ → y δ₁ ∼[ δ₁ ℚ₊+ ε₁ ] y ε₁)
+              (v₁ : 0< (fst ε ℚ.- (fst δ ℚ.+ fst η)))
+              (r : x δ ∼[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v₁ ] y η)
+
+    →
+              w-rel'
+     (l-l
+      (λ q η₁ → (λ ε₁ → fst (𝕒 q) ε₁ (x η₁)) , fst (snd (𝕒 q)) (x η₁)))
+     (l-l
+      (λ q η₁ → (λ ε₁ → fst (𝕒 q) ε₁ (y η₁)) , fst (snd (𝕒 q)) (y η₁)))
+     ε
+rel-l-l-l {𝕒} x y ε δ η p p' v₁ r η₁ .fst =
+  PT.map
+    λ ((δ* , η*) , (xx , xx')) →
+     let z = snd (snd (𝕒 δ*)) (x η*) _ _ _ (p _ δ) xx'
+         z' = snd (snd (𝕒 δ*)) _ _ _ _ r z
+     in (δ* , η) , (+₃0<' (fst η₁ ℚ.- (fst δ* ℚ.+ fst η*))
+                   (fst ε ℚ.- (fst δ ℚ.+ fst η))
+                    (fst δ ℚ.+ fst η*)
+                   (fst (ε ℚ₊+ η₁) ℚ.- (fst δ* ℚ.+ fst η))
+                   xx v₁ (snd (δ ℚ₊+ η*))
+                     (lem--016 {fst η₁} {fst δ*} {fst η*} {fst ε} {fst δ}) ,
+            subst (λ xx → ⟨ 𝕒 δ* .fst xx (y η)⟩)
+              (ℚ₊≡ (lem-03 (fst ε) (fst η₁)
+                 (fst δ) (fst η) (fst δ*) (fst η*)))
+                 z')
+rel-l-l-l {𝕒}  x y ε δ η p p' v₁ r  η₁ .snd =
+  PT.map λ ((δ* , η*) , (xx , xx')) →
+     let z = snd (snd (𝕒 δ*)) (y η*) _ _ _ (p' _ η) xx'
+         z' = snd (snd (𝕒 δ*)) _ _ _ _ (sym∼ _ _ _ r) z
+
+     in (δ* , δ) , (
+            +₃0<' (fst η₁ ℚ.- (fst δ* ℚ.+ fst η*))
+                   (fst ε ℚ.- (fst δ ℚ.+ fst η))
+                    (fst η ℚ.+ fst η*)
+                   (fst (ε ℚ₊+ η₁) ℚ.- (fst δ* ℚ.+ fst δ))
+                   xx v₁ (snd (η ℚ₊+ η*))
+                    (lem--017 {fst η₁} {fst δ*} {fst η*} {fst ε} {fst δ})  ,
+            (
+            subst (λ xx → ⟨ 𝕒 δ* .fst xx (x δ)⟩)
+              (ℚ₊≡ (lem-04 (fst ε) (fst η₁)
+                 (fst δ) (fst η) (fst δ*) (fst η*)))
+                 z') )
+module ∼' where
+
+ w' : ℚ → Recℝ (Σ (ℚ₊ → hProp ℓ-zero) w-prop') w-rel'
+ w' 𝕢 .Recℝ.ratA 𝕢' = r-r 𝕢 𝕢'
+ w' 𝕢 .Recℝ.limA 𝕒 _ = r-l 𝕒
+ w' 𝕢 .Recℝ.eqA = w-rel'→≡
+ w' 𝕢 .Recℝ.rat-rat-B = rel-r-r 𝕢
+ w' 𝕢 .Recℝ.rat-lim-B = rel-r-l 𝕢
+ w' 𝕢 .Recℝ.lim-rat-B x r ε δ p v₁ x₁ =
+   w-rel'-sym (r-r 𝕢 r)  (r-l x)  ε
+     (rel-r-l 𝕢 r x ε p δ v₁
+      (w-rel'-sym (x δ) (r-r 𝕢 r) ((fst ε ℚ.- fst δ) , v₁) x₁))
+
+ w' 𝕢 .Recℝ.lim-lim-B = rel-l-l
+ w' 𝕢 .Recℝ.isPropB a a' ε =
+  isPropΠ λ x →
+     isProp× (isProp→ (snd (a' .fst (ε ℚ₊+ x))))
+             (isProp→ (snd (a .fst (ε ℚ₊+ x))))
+
+
+
+
+
+ w'' : (𝕒 : ℚ₊ → Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop)
+     → ((δ ε : ℚ₊) → w-rel (𝕒 δ) (𝕒 ε) (δ ℚ₊+ ε))
+     → Casesℝ (Σ (ℚ₊ → hProp ℓ-zero) w-prop') w-rel'
+ w'' 𝕒 𝕡 .Casesℝ.ratA 𝕢 = r-l
+    (λ q → (λ ε → fst (𝕒 q) ε (rat 𝕢)) ,
+          fst (snd (𝕒 q)) (rat 𝕢))
+
+
+ w'' 𝕒 𝕡 .Casesℝ.limA 𝕩 𝕔 =
+   l-l (λ q  η →
+       (λ ε → fst (𝕒 q) ε (𝕩 η))
+       , fst (snd (𝕒 q)) (𝕩 η) )
+
+
+ w'' 𝕒 𝕡 .Casesℝ.eqA = w-rel'→≡
+ w'' 𝕒 𝕡 .Casesℝ.rat-rat-B q r ε x x₁ η .fst =
+   PT.map
+     (uncurry λ q' →
+      λ (xx , xx') →
+       let z = snd (snd (𝕒 q')) _ _ _ _
+               (rat-rat q r ε x x₁) xx'
+       in q' , (substΣ<' (𝕒 q') _
+             (ℚ.+Assoc (fst ε) (fst η) (ℚ.- fst q')) (_ , z)))
+ w'' 𝕒 𝕡 .Casesℝ.rat-rat-B q r ε x x₁ η .snd =
+   PT.map
+     (uncurry λ q' →
+      λ (xx , xx') →
+       let z = snd (snd (𝕒 q')) _ _ _ _
+               (sym∼ _ _ ε (rat-rat q r ε x x₁)) xx'
+       in q' , (substΣ<' (𝕒 q') _ (ℚ.+Assoc (fst ε) (fst η) (ℚ.- fst q')) (_ , z)))
+
+ w'' 𝕒 𝕡 .Casesℝ.rat-lim-B q y ε δ p v₁ r v' u' x η .fst =
+   PT.map
+     λ ((δ* , η*) , (xx , xx')) →
+      let z = snd (snd (𝕒 _)) _ _ _ _ r xx'
+      in ((δ* , η*) , δ) , substΣ<' (𝕒 (δ* , η*)) _
+             (lem--018 {fst ε} {fst δ} {fst η} {δ*} ) (_ , z)
+ w'' 𝕒 𝕡 .Casesℝ.rat-lim-B q y ε δ p v₁ r v' u' x η .snd =
+   PT.map
+     λ ((δ* , η*) , (xx , xx')) →
+      let z = snd (snd (𝕒 _)) _ _ _ _ (p _ _) xx'
+          z' = snd (snd (𝕒 _)) _ _ _ _ (sym∼ _ _ _ r) z
+      in δ* , substΣ<' (𝕒 δ*) _
+             (lem--019 {fst ε} {fst δ} {fst η*}  {fst η} {fst δ*} ) (_ , z')
+ w'' 𝕒 𝕡 .Casesℝ.lim-rat-B x r ε δ p v₁ u v' u' x₁ η .fst =
+   PT.map λ ((δ* , η*) , (xx , xx')) →
+      let z = snd (snd (𝕒 _)) _ _ _ _ (p _ _)  xx'
+          z'  = snd (snd (𝕒 _)) _ _ _ _ u z
+      in δ* , substΣ<' (𝕒 δ*) _
+            (lem--020 {fst ε} {fst δ} {fst η*}  {fst η} {fst δ*}) (_ , z')
+ w'' 𝕒 𝕡 .Casesℝ.lim-rat-B x r ε δ p v₁ u v' u' x₁ η .snd =
+    PT.map
+     λ ((δ* , η*) , (xx , xx')) →
+      let z = snd (snd (𝕒 _)) _ _ _ _ (sym∼ _ _ _ u) xx'
+      in ((δ* , η*) , δ) , substΣ<' (𝕒 (δ* , η*)) _
+            ((lem--021 {fst ε} {fst δ} {fst η}  {δ*})) (_ , z)
+ w'' 𝕒 𝕡 .Casesℝ.lim-lim-B = rel-l-l-l {𝕒}
+ w'' 𝕒 𝕡 .Casesℝ.isPropB a a' ε =
+  isPropΠ λ x →
+     isProp× (isProp→ (snd (a' .fst (ε ℚ₊+ x))))
+             (isProp→ (snd (a .fst (ε ℚ₊+ x))))
+
+ isPropHlp : {P  Q  : ℝ → ℚ₊ →  Type} (P' Q' : ℝ → ℚ₊ →  hProp ℓ-zero) →
+         (x₂ : ℝ) → isProp ((η₂ : ℚ₊) →
+          ( P x₂ η₂  → ⟨ P' x₂ η₂ ⟩) × ( Q x₂ η₂  → ⟨ Q' x₂ η₂ ⟩))
+ isPropHlp P' Q' x =
+   isPropΠ λ η → isProp× (isProp→ (snd (P' x η))) (isProp→ (snd (Q' x η)))
+
+ w : Recℝ (Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop) w-rel
+ w .Recℝ.ratA 𝕢 =
+    (λ q 𝕣 → fst (Recℝ.go (w' 𝕢) 𝕣) q)
+   , (λ u ε → snd (Recℝ.go (w' 𝕢) u) ε)
+   , λ u v ε η x → fst (Recℝ.go~ (w' 𝕢)  x η)
+
+ w .Recℝ.limA 𝕒 𝕡 =
+     (λ q 𝕣 → fst (Casesℝ.go (w'' 𝕒 𝕡) 𝕣) q)
+   , (λ u ε → snd (Casesℝ.go (w'' 𝕒 𝕡) u) ε)
+   , λ u v ε η x → fst (Casesℝ.go~ (w'' 𝕒 𝕡)  x η) --
+
+ w .Recℝ.eqA = w-rel→≡
+
+ w .Recℝ.rat-rat-B q r ε u v = Elimℝ-Prop.go www
+  where
+  www : Elimℝ-Prop _
+  www .Elimℝ-Prop.ratA x η =
+
+    rat-rat'-sym x (ε ℚ₊+ η) r
+      ∘S (fst (rel-r-r x q r ε u v η))
+      ∘S rat-rat'-sym q η x ,
+     rat-rat'-sym x (ε ℚ₊+ η) q ∘S (snd (rel-r-r  x q r ε u v η)) ∘S
+      rat-rat'-sym r η x
+  www .Elimℝ-Prop.limA x p x₁ η =
+       PT.map (λ (δ* , (xx , xx'))
+         → δ* , substΣ< (Elimℝ.go (Recℝ.d (w' r)) (x δ*))
+                   (ℚ.+Assoc (fst ε) (fst η) (ℚ.- fst δ*))
+                    (_ , fst (x₁ _ _) xx'))
+     , PT.map (λ (δ* , (xx , xx'))
+         → δ* , substΣ< (Recℝ.go (w' q) (x δ*))
+             ((ℚ.+Assoc (fst ε) (fst η) (ℚ.- fst δ*)))
+              (_ , snd (x₁ _ _) xx'  ))
+  www .Elimℝ-Prop.isPropA = isPropHlp
+      (λ x η → fst (Recℝ.go (w' r) x) (ε ℚ₊+ η))
+      λ x η → fst (Recℝ.go (w' q) x) (ε ℚ₊+ η)
+
+
+ w .Recℝ.rat-lim-B q y ε p δ v₁ x = Elimℝ-Prop.go www
+  where
+  www : Elimℝ-Prop _
+  www .Elimℝ-Prop.ratA x* η .fst xx =
+   let zz = fst (x (rat x*)  η) xx
+   in ∣ δ ,  substΣ<' (y δ) _ (lem--022 {fst ε} {fst δ} {fst η}) (_ , zz) ∣₁
+
+  www .Elimℝ-Prop.ratA x* η .snd =
+    PT.rec (snd (fst (Recℝ.go (w' q) (rat x*)) (ε ℚ₊+ η)))
+      λ (δ* , (xx , xx')) →
+       let zz = snd (p δ _ (rat x*) _) xx'
+           zz' = snd (x (rat x*)  _) zz
+       in subst {x = (((fst ε ℚ.- fst δ) , v₁) ℚ₊+
+             ((δ ℚ₊+ δ*) ℚ₊+ ((fst η ℚ.- fst δ*) , xx)))}
+            {y = (ε ℚ₊+ η)} (fst ∘ fst (Recℝ.go (w' q) (rat x*)))
+             (ℚ₊≡ (lem--023 {fst ε} {fst δ} {fst δ*} {fst η})) zz'
+
+  www .Elimℝ-Prop.limA x* p* x₁* η* .fst =
+    PT.map λ (δ* , (xx , xx')) →
+       let z = fst (x (x* δ*) (_ , xx)) xx'
+
+       in (δ , δ*) , substΣ<' (y δ) _
+              (lem--024 {fst ε} {fst δ} {fst η*} {fst δ*}) (_ , z)
+  www .Elimℝ-Prop.limA x'' pp'' x₁'' η'' .snd =
+     PT.map λ ((δ* , η*) , (xx , xx')) →
+      let z = fst (p _ _ _ _) xx'
+          z' = snd (x (x'' η*) _) z
+      in η* , substΣ< (Elimℝ.go (Recℝ.d (w' q)) (x'' η*))
+                   (lem--025 {fst ε} {fst δ} {fst δ*} {fst η''}) (_ , z')
+
+  www .Elimℝ-Prop.isPropA = isPropHlp
+      (λ x η → fst (Casesℝ.go (w'' y p) x) (ε ℚ₊+ η))
+      λ x η → fst (Recℝ.go (w' q) x) (ε ℚ₊+ η)
+
+ w .Recℝ.lim-rat-B x r ε δ p v₁ x₁  = Elimℝ-Prop.go www
+  where
+  www : Elimℝ-Prop _
+  www .Elimℝ-Prop.ratA x' η' .fst =
+    PT.rec (snd (fst (Recℝ.go (w' r) (rat x')) (ε ℚ₊+ η')))
+      λ (δ* , (xx , xx')) →
+       let zz = snd (p δ _ (rat x') _) xx'
+           zz' = fst (x₁ (rat x') _) zz
+       in subst
+            {x = (((fst ε ℚ.- fst δ) , v₁) ℚ₊+
+             ((δ ℚ₊+ δ*) ℚ₊+ ((fst η' ℚ.- fst δ*) , xx)))}
+             {(ε ℚ₊+ η')}
+             (fst ∘ (fst (Recℝ.go (w' r) (rat x'))))
+            (ℚ₊≡ $ lem--026 {fst ε} {fst δ} {fst δ*} {fst η'}) zz'
+  www .Elimℝ-Prop.ratA x' η' .snd xx =
+   let zz = snd (x₁ (rat x')  η') xx
+   in ∣ δ , substΣ<' (x δ) _ (lem--027 {fst ε} {fst δ} {fst η'}) (_ , zz) ∣₁
+
+  www .Elimℝ-Prop.limA x' p' x₁' η' .fst =
+    PT.map λ ((δ* , η*) , (xx , xx')) →
+      let z = fst (p _ _ _ _) xx'
+          z' = fst (x₁ (x' η*) _) z
+      in η* , substΣ< (Recℝ.go (w' r) (x' η*))
+                ((lem--028 {fst ε} {fst δ}  {fst δ*} {fst η'}  {fst η*})) (_ , z')
+  www .Elimℝ-Prop.limA x' p' x₁' η' .snd =
+    PT.map λ (δ* , (xx , xx')) →
+      let z = snd (x₁ (x' δ*) ((fst η' ℚ.- fst δ*) , xx)) xx'
+
+      in (δ , δ*) , substΣ<' (x δ) _
+          (lem--029 {fst ε} {fst δ} {fst η'} {fst δ*}) (_ , z)
+  www .Elimℝ-Prop.isPropA = isPropHlp
+      (λ x η → fst (Recℝ.go (w' r) x) (ε ℚ₊+ η))
+      λ x₂ η → fst (Casesℝ.go (w'' x p) x₂) (ε ℚ₊+ η)
+
+ w .Recℝ.lim-lim-B x y ε δ η p p' v₁ x₁ = Elimℝ-Prop.go www
+  where
+  www : Elimℝ-Prop _
+  www .Elimℝ-Prop.ratA x* η' .fst =
+    PT.map λ ((δ* , η*) , (xx , xx')) →
+     let z = fst ((p _ _) _ _) xx'
+         z' = fst (x₁ _ _) z
+     in η , substΣ<' (y η) _
+           (lem--030 {fst ε} {fst δ} {fst η} {δ*}  {fst η'}) (_ , z')
+  www .Elimℝ-Prop.ratA x* η' .snd =
+    PT.map λ ((δ* , η*) , (xx , xx')) →
+     let z = fst ((p' _ _) _ _) xx'
+         z' = snd (x₁ _ _) z
+     in δ , substΣ<' (x δ) _
+         (lem--031 {fst ε} {fst δ} {fst η} {δ*}  {fst η'} ) (_ , z')
+  www .Elimℝ-Prop.limA x* p* x₁' η₁ .fst =
+   PT.map λ ((δ* , η*) , (xx , xx')) →
+   let z = (fst (p δ* δ (x* η*) _)) xx'
+       z' : fst
+              (y η .fst
+               (((fst ε ℚ.- (fst δ ℚ.+ fst η)) , v₁) ℚ₊+
+                ((δ* ℚ₊+ δ) ℚ₊+ ((fst η₁ ℚ.- (fst δ* ℚ.+ fst η*)) , xx)))
+               (x* η*))
+       z' = fst (x₁ _ _) z
+   in (η , η*) ,
+          substΣ<' (y η) _
+        (lem--032 {fst ε} {fst δ} {fst η} {fst δ*}  {fst η₁} {fst η*})
+           (_ , z')
+  www .Elimℝ-Prop.limA x* p x₁' η₁ .snd =
+   PT.map λ ((δ* , η*) , (xx , xx')) →
+    let z = (fst (p' _ _ _ _)) xx'
+        z' = snd (x₁ _ _) z
+    in (δ , η*) , substΣ<' (x δ) _
+          (lem--033  {fst ε} {fst δ} {fst η} {fst δ*}  {fst η₁} {fst η*}) (_ , z')
+
+  www .Elimℝ-Prop.isPropA = isPropHlp
+      (λ x₂ η₂ → fst (Casesℝ.go (w'' y p') x₂) (ε ℚ₊+ η₂))
+      λ x₂ η₂ → fst (Casesℝ.go (w'' x p) x₂) (ε ℚ₊+ η₂)
+
+ w .Recℝ.isPropB a a' ε = isPropΠ2 λ u x →
+     isProp× (isProp→ (snd (a' .fst (ε ℚ₊+ x) u)))
+             (isProp→ (snd (a .fst (ε ℚ₊+ x) u)))
+
+
+ -- pre-~' : ℝ → Σ (ℚ₊ → ℝ → (hProp ℓ-zero)) _
+ -- pre-~' = Recℝ.go w
+
+
+-- HoTT Theorem (11.3.16)
+
+_∼'[_]_ : ℝ → ℚ₊ → ℝ → Type
+x ∼'[ ε ] y = ⟨ fst (Recℝ.go ∼'.w x) ε y ⟩
+
+_∼'[_]ₚ_ : ℝ → ℚ₊ → ℝ → hProp ℓ-zero
+x ∼'[ ε ]ₚ y = fst (Recℝ.go ∼'.w x) ε y
+
+
+-- (11.3.17)
+_ : ∀ r r' ε → (rat r) ∼'[ ε ] (rat r') ≡
+              ((ℚ.- fst ε) ℚ.< (r ℚ.- r'))
+               × ((r ℚ.- r') ℚ.< fst ε)
+_ = λ r r' ε → refl
+
+-- (11.3.18)
+_ : ∀ r x y ε → (rat r) ∼'[ ε ] (lim x y) ≡
+              (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ] ((rat r) ∼'[ (fst ε ℚ.- fst δ) , v ] x δ))
+_ = λ r x y ε → refl
+
+-- (11.3.19)
+_ : ∀ r x y ε → (lim x y) ∼'[ ε ] (rat r) ≡
+              (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ]
+                ((x δ) ∼'[ (fst ε ℚ.- fst δ) , v ] rat r ))
+_ = λ r x y ε → refl
+
+-- (11.3.20)
+_ : ∀ x y x' y' ε → (lim x y) ∼'[ ε ] (lim x' y') ≡
+               (∃[ (δ , η) ∈ (ℚ₊ × ℚ₊) ] Σ[ v ∈ _ ]
+                ((x δ) ∼'[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v ] (x' η) ))
+_ = λ x y x' y' ε → refl
+
+-- (11.3.23)
+triangle∼' : ∀ u v w ε η
+      → u ∼[ ε ] v
+      → v ∼'[ η ] w
+      → u ∼'[ ε ℚ₊+ η ] w
+triangle∼' u v w ε η x =
+  snd ((Recℝ.go~ ∼'.w {x = u} {v} {ε} x w η ))
+
+
+-- (11.3.21)
+rounded∼' : ∀ u v ε →
+             ⟨ (u ∼'[ ε ]ₚ v) L.⇔
+              (L.∃[ δ ]
+                L.∃[ _ ] u ∼'[ (fst ε ℚ.- fst δ) , _ ]ₚ v) ⟩
+rounded∼' u v ε = fst (snd (Recℝ.go ∼'.w u)) v ε
+
+
+∼→∼' : ∀ x y ε → x ∼[ ε ] y → x ∼'[ ε ] y
+∼→∼' x y ε (rat-rat q r .ε x₁ x₂) = x₁ , x₂
+∼→∼' x y ε (rat-lim q y₁ .ε δ p v₁ x₁) =
+ ∣ δ , v₁ , ∼→∼' (rat q) (y₁ δ) _ x₁ ∣₁
+∼→∼' x y ε (lim-rat x₁ r .ε δ p v₁ x₂) =
+ ∣ δ , v₁ , ∼→∼' (x₁ δ) (rat r)  _ x₂ ∣₁
+∼→∼' x y ε (lim-lim x₁ y₁ .ε δ η p p' v₁ x₂) =
+  ∣ (δ , η) , (v₁ , (∼→∼' _ _ _ x₂)) ∣₁
+∼→∼' x y ε (isProp∼ .x .ε .y x₁ x₂ i) =
+  snd (x ∼'[ ε ]ₚ y) (∼→∼' x y ε x₁) (∼→∼' x y ε x₂) i
+
+∼'→∼ : ∀ x y ε → x ∼'[ ε ] y → x ∼[ ε ] y
+∼'→∼ = Elimℝ-Prop2.go w
+ where
+ w : Elimℝ-Prop2 _
+ w .Elimℝ-Prop2.rat-ratA r q ε =
+   uncurry $ rat-rat r q ε
+ w .Elimℝ-Prop2.rat-limA r x y x₁ ε =
+    PT.rec (isProp∼ _ _ _)
+      λ (δ , (xx , xx')) → rat-lim r x ε δ y  xx (x₁ _ _ xx')
+
+ w .Elimℝ-Prop2.lim-ratA x y r x₁ ε =
+    PT.rec (isProp∼ _ _ _)
+      λ (δ , (xx , xx')) → lim-rat x r ε δ y  xx (x₁ _ _ xx')
+ w .Elimℝ-Prop2.lim-limA x y x' y' x₁ ε =
+    PT.rec (isProp∼ _ _ _)
+      λ ((δ , η) , (xx , xx')) →
+        lim-lim x x' ε δ η y y' xx (x₁ _ _ _ xx')
+ w .Elimℝ-Prop2.isPropA _ _ = isPropΠ2 λ _ _ → isProp∼ _ _ _
+
+
+sym∼' : ∀ r r' ε → r ∼'[ ε ] r' → r' ∼'[ ε ] r
+sym∼' r r' ε =
+  ∼→∼' r' r ε ∘S sym∼ r r' ε ∘S ∼'→∼ r r' ε
+
+
+
+-- (11.3.22)
+triangle∼'' : ∀ u v w ε η
+      → u ∼'[ ε ] v
+      → v ∼[ η ] w
+      → u ∼'[ ε ℚ₊+ η ] w
+triangle∼'' u v w ε η x y =
+  subst (u ∼'[_] w) (ℚ₊≡ (ℚ.+Comm (fst η) (fst ε)))
+   (sym∼' w u _ (triangle∼' w v u η ε (sym∼ v w η y) (sym∼' u v ε x)))
+
+-- HoTT Theorem (11.3.32)
+∼'⇔∼ : ∀ x y ε → ⟨ x ∼'[ ε ]ₚ y L.⇔ x ∼[ ε ]ₚ y ⟩
+∼'⇔∼ x y z = ∼'→∼ x y z , ∼→∼' x y z
+
+
+infixr 6 _∙⇔_
+
+_∙⇔_ : ∀ {ℓ} {A B C : Type ℓ}
+         → ((A → B) × (B → A))
+         → ((B → C) × (C → B))
+         → ((A → C) × (C → A))
+_∙⇔_ (x , _) (y , _) .fst = y ∘ x
+_∙⇔_ (_ , x) (_ , y) .snd = x ∘ y
+
+sym⇔ : ∀ {ℓ} {A B : Type ℓ}
+    → ((A → B) × (B → A))
+    → ((B → A) × (A → B))
+sym⇔ (x , y) = y , x
+
+
+-- HoTT (11.3.33)
+rounded∼ : ∀ u v ε →
+             ⟨ (u ∼[ ε ]ₚ v) L.⇔
+              (L.∃[ δ ]
+                L.∃[ p ] u ∼[ (fst ε ℚ.- fst δ) , p ]ₚ v) ⟩
+rounded∼ u v ε = sym⇔
+      (∼'⇔∼ u v ε) ∙⇔ rounded∼' u v ε ∙⇔
+     (PT.map (map-snd (PT.map (map-snd (fst (∼'⇔∼ u v _)))))
+   ,  PT.map (map-snd (PT.map (map-snd (snd (∼'⇔∼ u v _))))))
+
+-- HoTT (11.3.36)
+
+triangle∼ : ∀ {u v w ε η}
+      → u ∼[ ε ] v
+      → v ∼[ η ] w
+      → u ∼[ ε ℚ₊+ η ] w
+triangle∼ {u} {v} {w} {ε} {η} x  =
+  ∼'→∼ u w (ε ℚ₊+ η) ∘ triangle∼' u v w ε η x ∘ ∼→∼' v w _
+
+
+
+_ : ∀ r x y ε → (rat r) ∼'[ ε ] (lim x y) ≡
+              (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ] ((rat r) ∼'[ (fst ε ℚ.- fst δ) , v ] x δ))
+_ = λ r x y ε → refl
+
+_ : ∀ r x y ε → (lim x y) ∼'[ ε ] (rat r) ≡
+              (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ]
+                ((x δ) ∼'[ (fst ε ℚ.- fst δ) , v ] rat r ))
+_ = λ r x y ε → refl
+
+
+_ : ∀ x y x' y' ε → (lim x y) ∼'[ ε ] (lim x' y') ≡
+               (∃[ (δ , η) ∈ (ℚ₊ × ℚ₊) ] Σ[ v ∈ _ ]
+                ((x δ) ∼'[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v ] (x' η) ))
+_ = λ x y x' y' ε → refl
+
diff --git a/Cubical/HITs/CauchyReals/Continuous.agda b/Cubical/HITs/CauchyReals/Continuous.agda
new file mode 100644
index 0000000000..c8aa25b7b4
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Continuous.agda
@@ -0,0 +1,1528 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Continuous where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.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 _//_)
+
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊)
+
+open import Cubical.Data.NatPlusOne
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+open import Cubical.HITs.CauchyReals.Order
+
+
+
+open ℚ.HLP
+
+ -- HoTT Lemma (11.3.41)
+
+
+-- -- 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
+
+ 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 =
+  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 = 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'')))))
+            (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
+
+
+
+
+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 invEq (<ᵣ-impl _ _) ∣ (_ , 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'')) ∣₁ ))
+      (fst (<ᵣ-impl _ _) 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
+ 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  ε →
+  (absᵣ (u +ᵣ (-ᵣ  v)) <ᵣ rat (fst ε)) → (u ∼[ ε ] v)
+
+∼≃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
+  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∼ _ _ _) (isProp<ᵣ _ _)
+
+   ((λ 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 _ ) ∙ sym (absᵣ-rat' _))
+      ∘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₁
+
+
+
+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
+
+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ℝ _ _
+
+
+
+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₁
+
+
+<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) ]
+
+
+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 ])
+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))
+
+-- opaque
+--  unfolding absᵣ _<ᵣ_
+IsContinuousAbsᵣ : IsContinuous absᵣ
+IsContinuousAbsᵣ = Lipschitz→IsContinuous _ _ absᵣ-lip
+
+
+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 _ _ _ ε) ∣₁
+
+IsContinuousClamp : ∀ a b → IsContinuous (clampᵣ a b)
+IsContinuousClamp a b =
+ IsContinuous∘ _ _
+   (IsContinuousMinR _)
+   (IsContinuousMaxL _)
+
+IsContinuous-ᵣ : IsContinuous (-ᵣ_)
+IsContinuous-ᵣ = Lipschitz→IsContinuous _ _ -ᵣ-lip
+
+
+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∈)
+
+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₂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
+
+
+
+
+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
+
+
+
+IsContinuousId : IsContinuous (λ x → x)
+IsContinuousId u ε = ∣ ε , (λ _ x → x) ∣₁
+
+IsContinuousConst : ∀ x → IsContinuous (λ _ → x)
+IsContinuousConst x u ε = ∣ ε , (λ _ _ → refl∼ _ _ ) ∣₁
+
+
+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
+
+ 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 _ _
+
+
+ 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))
+
+
+
+
+ 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
+
+
+ ∩-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)
+
+
+
+
+
+ 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
+ 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
new file mode 100644
index 0000000000..57575afd94
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -0,0 +1,926 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+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 ⊎
+open import Cubical.Data.Int as ℤ using (pos)
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.Data.NatPlusOne
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊;x/2<x;invℚ)
+
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+open import Cubical.HITs.CauchyReals.Order
+open import Cubical.HITs.CauchyReals.Continuous
+open import Cubical.HITs.CauchyReals.Multiplication
+open import Cubical.HITs.CauchyReals.Inverse
+open import Cubical.HITs.CauchyReals.Sequence
+
+
+
+
+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 =
+  ∀ (ε : ℝ₊) → ∃[ δ ∈ ℝ₊ ]
+   (∀ r → absᵣ (x -ᵣ r) <ᵣ fst δ → absᵣ (L -ᵣ f r) <ᵣ fst ε)
+
+inclLimit→Limit : ∀ f x L → at x inclLimitOf f is L
+                          → at x limitOf (λ r _ → f r)  is L
+inclLimit→Limit f x L = PT.map (map-snd (const ∘_)) ∘_
+
+substLim : ∀ {x f f' L}
+  → (∀ r x＃r → f r x＃r ≡ f' r x＃r)
+  → at x limitOf f is L → at x limitOf f' is L
+substLim {x} {L = L} p =  subst (at x limitOf_is L) (funExt₂ p)
+
+IsContinuousInclLim : ∀ f x → IsContinuous f →
+                    at x inclLimitOf f is (f x)
+IsContinuousInclLim f x cx = uncurry
+  λ ε → (PT.rec squash₁
+   λ (q , 0<q , q<ε) →
+     PT.map (λ (δ , X) →
+       (ℚ₊→ℝ₊ δ) ,
+         λ r x₁ → isTrans<ᵣ _ _ _
+           (fst (∼≃abs<ε _ _ _) (X r (invEq (∼≃abs<ε _ _ _) x₁)))
+            q<ε  )
+       (cx x (q , ℚ.<→0< q (<ᵣ→<ℚ 0 q 0<q)))) ∘ denseℚinℝ 0 ε
+
+IsContinuousLim : ∀ f x → IsContinuous f →
+                    at x limitOf (λ r _ → f r) is (f x)
+IsContinuousLim f x cx = inclLimit→Limit _ _ _ (IsContinuousInclLim f x cx)
+
+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
+IsContinuousInclLim→IsContinuous f xc x (ε , 0<ε) =
+  PT.rec squash₁ w z
+
+ where
+  z = xc x (rat ε , <ℚ→<ᵣ 0 ε (ℚ.0<→< _ 0<ε) )
+  w : Σ ℝ₊
+        (λ δ →
+           (r : ℝ) →
+           absᵣ (x -ᵣ r) <ᵣ fst δ → absᵣ (f x -ᵣ f r) <ᵣ rat ε) →
+        ∃-syntax ℚ₊ (λ δ → (v₁ : ℝ) → x ∼[ δ ] v₁ → f x ∼[ ε , 0<ε ] f v₁)
+  w ((δ , 0<δ) , X) =
+      PT.map (λ (q , 0<q , q<δ) →
+        ((q , ℚ.<→0< q (<ᵣ→<ℚ 0 q 0<q))) ,
+          λ r x∼r → invEq (∼≃abs<ε _ _ _) (X r
+            (isTrans<ᵣ _ _ _ (fst (∼≃abs<ε _ _ _) x∼r) q<δ)))
+       (denseℚinℝ 0 δ 0<δ)
+
+IsContinuousInclLim≃IsContinuous : ∀ f  →
+                    (∀ x → at x inclLimitOf f is (f x))
+                    ≃ (IsContinuous f)
+IsContinuousInclLim≃IsContinuous f =
+  propBiimpl→Equiv (isPropΠ2 λ _ _ → squash₁) (isPropIsContinuous f)
+    (IsContinuousInclLim→IsContinuous f)
+     λ fc x → IsContinuousInclLim f x fc
+
+IsContinuousLimΔ : ∀ f x → IsContinuous f →
+                    at 0 limitOf (λ Δx _ → f (x +ᵣ Δx)) is (f x)
+IsContinuousLimΔ f x cx =
+  subst (at rat [ pos 0 / 1+ 0 ] limitOf (λ Δx _ → f (x +ᵣ Δx)) is_)
+   (cong f (+IdR x))
+  (IsContinuousLim (λ Δx → f (x +ᵣ Δx)) 0
+    (IsContinuous∘ _ _ cx (IsContinuous+ᵣL x)))
+
+
+
+const-lim : ∀ C x → at x limitOf (λ _ _ → C) is C
+const-lim C x ε = ∣ (1 , decℚ<ᵣ?) ,
+  (λ r x＃r x₁ → subst (_<ᵣ fst ε) (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 )  ∣₁
+
+_$[_]$_ : (ℝ → ℝ)
+        → (ℝ → ℝ → ℝ)
+        → (ℝ → ℝ)
+        → (ℝ → ℝ)
+f $[ _op_ ]$ g = λ r → (f r) op (g r)
+
+_#[_]$_ : {x : ℝ}
+        → (∀ r → x ＃ r → ℝ)
+        → (ℝ → ℝ → ℝ)
+        → (∀ r → x ＃ r → ℝ)
+        → (∀ r → x ＃ r → ℝ)
+f #[ _op_ ]$ g = λ r x → (f r x) op (g r x)
+
++-lim : ∀ x f g F G
+        → at x limitOf f is F
+        → at x limitOf g is G
+        → at x limitOf (f #[ _+ᵣ_ ]$ g) is (F +ᵣ G)
++-lim x f g F G fL gL ε =
+  PT.map2 (λ (δ , p) (δ' , p') →
+       (minᵣ₊ δ δ') ,
+        λ r x＃r x₁ →
+         let u = p r x＃r (isTrans<≤ᵣ _ _ _ x₁ (min≤ᵣ _ _))
+             u' = p' r x＃r (isTrans<≤ᵣ _ _ _ x₁ (min≤ᵣ' _ _))
+         in subst2 _<ᵣ_
+                (cong absᵣ (sym L𝐑.lem--041))
+                (x·rat[α]+x·rat[β]=x (fst ε))
+               (isTrans≤<ᵣ _ _ _
+                 (absᵣ-triangle _ _)
+                 (<ᵣMonotone+ᵣ _ _ _ _ u u')))
+    (fL (ε ₊·ᵣ (rat [ 1 / 2 ] , decℚ<ᵣ?)))
+     (gL (ε ₊·ᵣ (rat [ 1 / 2 ] , decℚ<ᵣ?)))
+
+
+·-lim : ∀ x f g F G
+        → at x limitOf f is F
+        → at x limitOf g is G
+        → at x limitOf (f #[ _·ᵣ_ ]$ g) is (F ·ᵣ G)
+·-lim x f g F G fL gL ε = PT.map3 w (fL (ε'f)) (gL (ε'g)) (gL 1)
+
+ where
+
+  ε'f : ℝ₊
+  ε'f = (ε ₊／ᵣ₊ 2) ₊／ᵣ₊ (1 +ᵣ absᵣ G ,
+           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ᵣ 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_)
+
+
+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)
+   (funExt₂ λ r 0＃r → sym (𝐑'.0LeftAnnihilates (invℝ r 0＃r)) ∙
+     cong (_·ᵣ (invℝ r 0＃r)) (sym (+-ᵣ _)))
+   (const-lim 0 0)
+
+idDerivative : ∀ x → derivativeOf (idfun ℝ) at x is 1
+idDerivative x =  subst (at 0 limitOf_is 1)
+   (funExt₂ λ r 0＃r → sym (x·invℝ[x] r 0＃r) ∙
+    cong (_·ᵣ (invℝ r 0＃r)) (sym (L𝐑.lem--063)))
+   (const-lim 1 0)
+
++Derivative : ∀ x f f'x g g'x
+        → derivativeOf f at x is f'x
+        → derivativeOf g at x is g'x
+        → derivativeOf (f $[ _+ᵣ_ ]$ g) at x is (f'x +ᵣ g'x)
++Derivative x f f'x g g'x F G =
+ subst {x = (differenceAt f x) #[ _+ᵣ_ ]$ (differenceAt g x)}
+            {y = (differenceAt (f $[ _+ᵣ_ ]$ g) x)}
+      (at 0 limitOf_is (f'x +ᵣ g'x))
+       (funExt₂ λ h 0＃h →
+         sym (·DistR+ _ _ _) ∙
+          cong (_·ᵣ (invℝ h 0＃h))
+           (sym L𝐑.lem--041)) (+-lim _ _ _ _ _ F G)
+
++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)
+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)
+
+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'
+substDer = subst (derivativeOf_at _ is _) ∘ funExt
+
+substDer₂ : ∀ {x f' g' f g} →
+        (∀ r → f r ≡ g r) → f' ≡ g'
+     → derivativeOf f at x is f'
+     → derivativeOf g at x is g'
+substDer₂ p q = subst2 (derivativeOf_at _ is_) (funExt p) q
+
+
+C·Derivative' : ∀ C x f f'x
+        → derivativeOf f at x is f'x
+        → derivativeOf ((_·ᵣ C) ∘S f) at x is (f'x ·ᵣ C)
+C·Derivative' C x f f'x F =
+  substDer₂ (λ _ → ·ᵣComm _ _) (·ᵣComm _ _)
+    (C·Derivative C x f f'x F)
+
+·Derivative : ∀ x f f'x g g'x
+        → IsContinuous g
+        → derivativeOf f at x is f'x
+        → derivativeOf g at x is g'x
+        → derivativeOf (f $[ _·ᵣ_ ]$ g) at x is
+           (f'x ·ᵣ (g x) +ᵣ (f x) ·ᵣ g'x)
+·Derivative x f f'x g g'x gC F G =
+  substLim w
+    (+-lim _ _ _ _ _
+      (·-lim _ _ _ _ _
+        F (IsContinuousLimΔ g x gC))
+      (·-lim _ _ _ _ _
+         (const-lim _ _) G))
+
+ where
+ w : (r : ℝ) (x＃r : 0 ＃ r) → _
+       ≡ differenceAt (f $[ _·ᵣ_ ]$ g) x r x＃r
+ w h 0＃h =
+    cong₂ _+ᵣ_ (sym (·ᵣAssoc _ _ _) ∙
+       cong ((f (x +ᵣ h) -ᵣ f x) ·ᵣ_) (·ᵣComm _ _)
+         ∙ (·ᵣAssoc _ _ _) )
+      (·ᵣAssoc _ (g (x +ᵣ h) -ᵣ g x) (invℝ h 0＃h))
+      ∙ sym (·DistR+ _ _ _) ∙
+       cong (_·ᵣ (invℝ h 0＃h))
+         (cong₂ _+ᵣ_ (·DistR+ _ _ _ ∙
+            cong (f (x +ᵣ h) ·ᵣ g (x +ᵣ h) +ᵣ_) (-ᵣ· _ _))
+           (·DistL+ _ _ _ ∙
+             cong (f x ·ᵣ g (x +ᵣ h) +ᵣ_) (·-ᵣ _ _))
+           ∙ L𝐑.lem--060)
+
+-- LimEverywhere→LimIncl : ∀ f → (∀ x → at x limitOf (λ x _ → f x) is (f x))
+--                            → (∀ x → at x inclLimitOf f is (f x))
+-- LimEverywhere→LimIncl = {!!}
+
+
+-- hasDer→isCont : ∀ f (f' : ℝ → ℝ) →
+--   (∀ x → derivativeOf f at x is f' x )
+--   → IsContinuous f
+-- hasDer→isCont f f' df ε = {!df!}
+
+derivative-^ⁿ : ∀ n x →
+   derivativeOf (_^ⁿ (suc n)) at x
+            is (fromNat (suc n) ·ᵣ (x ^ⁿ n))
+derivative-^ⁿ zero x =
+ substDer₂
+   (λ _ → sym (·IdL _))
+   (sym (·IdL _))
+   (idDerivative x)
+derivative-^ⁿ (suc n) x =
+  substDer₂ (λ _ → refl)
+    (+ᵣComm _ _ ∙ cong₂ _+ᵣ_
+       (·ᵣComm _ _) (sym (·ᵣAssoc _ _ _)) ∙
+       sym (·DistR+ _ _ _) ∙
+        cong (_·ᵣ ((x ^ⁿ n) ·ᵣ idfun ℝ x))
+         (+ᵣ-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
new file mode 100644
index 0000000000..1459a90281
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Inverse.agda
@@ -0,0 +1,1977 @@
+{-# OPTIONS --lossy-unification --safe #-}
+
+module Cubical.HITs.CauchyReals.Inverse where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.Powerset
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Unit
+open import Cubical.Data.Int as ℤ using (pos)
+open import Cubical.Data.Sigma
+open import Cubical.Data.NatPlusOne
+
+
+import Cubical.Algebra.CommRing as CR
+import Cubical.Algebra.Ring as RP
+
+
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊;x/2<x;invℚ)
+
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+open import Cubical.HITs.CauchyReals.Order
+open import Cubical.HITs.CauchyReals.Continuous
+open import Cubical.HITs.CauchyReals.Multiplication
+
+
+Rℝ = (CR.CommRing→Ring (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ))
+module CRℝ = RP.RingStr (snd Rℝ)
+
+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)
+
+
+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)
+          × ((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
+
+
+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)
+ℚ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 → -ᵣ 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 → -ᵣ y <ᵣ -ᵣ x →  x <ᵣ y
+<ᵣ-ᵣ x y = subst2 _<ᵣ_ (-ᵣInvol x) (-ᵣInvol y) ∘ -ᵣ<ᵣ (-ᵣ y) (-ᵣ x)
+
+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...
+
+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
+
+ <ᵣ-+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) = isTrans≡<ᵣ _ _ _ (sym (+ᵣ-rat  _ _)) (<ᵣMonotone+ᵣ 0 m 0 n <m <n)
+
+
+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 (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 (isProp<ᵣ _ _ 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 <ᵣ_) (+ᵣ-rat _ _ ∙ 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)
+
+
+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< : ?
+
+isSym＃ : BinaryRelation.isSym _＃_
+isSym＃ _ _ = fst ⊎-swap-≃
+
+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)
+
+
+ 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)
+
+
+
+ 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)))
+
+
+ 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)
+
+
+ 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)
+
+
+
+invℝ'' : Σ (∀ r → ∃[ σ ∈ ℚ₊ ] (rat (fst σ) <ᵣ r) → ℝ)
+      λ _ → Σ (∀ r → 0 <ᵣ r → ℝ) (IsContinuousWithPred (λ r → _ , isProp<ᵣ _ _))
+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 _ _ ∙ cong (_·ᵣ rat [ 1 / 2 ]) (sym (-ᵣ-rat₂ _ _)))
+                  (≤ℚ→≤ᵣ (fst φ*)
+                    (fst (/2₊
+                             (ℚ.<→ℚ₊ (fst σ⊔) q (<ᵣ→<ℚ _ _ σ⊔<q))
+                          )) zz)
+
+
+           limRestr' : rat (fst φ* ℚ.+ fst φ*)
+               ≤ᵣ (lim x y +ᵣ (-ᵣ rat (fst σ⊔)))
+           limRestr' =
+             let zz : ((rat q +ᵣ (-ᵣ rat (fst σ⊔)))) ≤ᵣ
+                        ((lim x y +ᵣ (-ᵣ rat (fst σ⊔))) )
+                 zz = ≤ᵣ-+o (rat q) (lim x y) (-ᵣ rat (fst σ⊔))
+                          (<ᵣWeaken≤ᵣ _ _ q<limX)
+             in  subst2 _≤ᵣ_
+                  (sym (rat·ᵣrat _ _) ∙
+                   cong rat (distℚ! (fst φ*) ·[ ge[ 2 ]  ≡ ge1 +ge ge1 ]))
+                    (sym (·ᵣAssoc _ _ _) ∙∙
+                      cong ((lim x y +ᵣ (-ᵣ rat (fst σ⊔))) ·ᵣ_)
+                       (sym (rat·ᵣrat _ _)
+                         ∙ (cong rat (𝟚.toWitness {Q = ℚ.discreteℚ
+                           ([ 1 / 2 ] ℚ.· 2) 1} tt))) ∙∙
+                      ·IdR _ )
+                   (≤ᵣ-·o _ _ 2 (ℚ.decℚ≤? {0} {2}) (isTrans≤ᵣ _ _ _
+                   limRestr'' (≤ᵣ-·o _ _ [ 1 / 2 ] (ℚ.decℚ≤? {0} {[ 1 / 2 ]})
+                         zz)))
+
+
+           limRestr : rat (fst σ⊔)
+               ≤ᵣ ((lim x y +ᵣ (-ᵣ rat (fst φ* ℚ.+ fst φ*))))
+           limRestr = subst2 _≤ᵣ_
+             (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+ _ _
+               (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 → _ , isProp<ᵣ _ _))
+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))))
+
+
+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)
+
+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)
+
+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))
+
+
+
+-ᵣ≡[-1·ᵣ] : ∀ x → -ᵣ x ≡ (-1) ·ᵣ x
+-ᵣ≡[-1·ᵣ] = ≡Continuous _ _
+   IsContinuous-ᵣ
+   (IsContinuous·ᵣL -1)
+   λ r → -ᵣ-rat _ ∙ rat·ᵣrat _ _
+
+
+openPred< : ∀ x → ⟨ openPred (λ y → (x <ᵣ y) , isProp<ᵣ _ _)  ⟩
+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) , isProp<ᵣ _ _)  ⟩
+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
+
+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 _ _))
+
+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)
+
+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)
+
+
+ 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))
+
+ 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 = q ·ᵣ fst (invℝ₊ 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 →
+               (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 =
+      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
+               → (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 ·ᵣ_) (+ᵣ-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
new file mode 100644
index 0000000000..ed7bdf3798
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Lems.agda
@@ -0,0 +1,376 @@
+{-# OPTIONS --safe #-}
+module Cubical.HITs.CauchyReals.Lems where
+
+open import Cubical.Foundations.Prelude
+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 →
+       (ε - (δ + η)) +
+       ((a + δ) + (η' - a))
+      ≡ (ε + η') - η
+ lem-01 ε δ η η' a = solve! R
+
+ lem-02 : ∀ ε δ η η' → (ε - (δ + η)) + (δ + η')
+           ≡ ((ε + η') - η)
+ lem-02 ε δ η η' = solve! R
+
+ lem-03 : ∀ ε η₁ δ η δ* η* →
+            (ε - (δ +  η)) +
+       ((η* + δ) + (η₁ - (δ* +  η*)))
+        ≡ (ε + η₁) - (δ* + η)
+ lem-03 ε η₁ δ η δ* η* = solve! R
+
+ lem-04 : ∀ ε η₁ δ η δ* η* →
+            (ε - (δ +  η)) +
+       ((η* + η) + (η₁ - (δ* +  η*)))
+        ≡ (ε + η₁) - (δ* + δ)
+ lem-04 ε η₁ δ η δ* η* = solve! R
+
+ lem-05 : ∀ x y → x + (y - (x + x)) ≡ y - x
+ lem-05 x y = solve! R
+
+ +AssocCommR : ∀ x y z → (x + y) + z ≡ (x + z) + y
+ +AssocCommR x y z = solve! R
+
+ private
+  variable
+   ε δ q q' a'' 𝕢 r η σ* δ* η₁ η* η'' η' x y x' y' a a' b b' c c' θ L : fst R
+
+ lem--00 : (ε - δ) + δ ≡ ε
+ lem--00 = solve! R
+
+ lem--01 : (- (ε - δ)) + (- δ) ≡ (- ε)
+ lem--01 = solve! R
+
+ lem--02 : ε + q + (ε - q) ≡ ε + ε
+ lem--02 = solve! R
+
+ lem--03 : (- ε) + δ ≡ (- (ε - δ))
+ lem--03 = solve! R
+
+ lem--04 : (- ε) + (ε + q) ≡ q
+ lem--04 = solve! R
+
+ lem--05 : δ + (q - δ) ≡ q
+ lem--05 = solve! R
+
+ lem--06 : (ε - q) + (q - δ) ≡ (ε - δ)
+ lem--06 = solve! R
+
+ lem--07 : ε + (- q') + (- a'') + q' ≡ (ε - a'')
+ lem--07 = solve! R
+
+ lem--08 : δ + (ε - (δ + δ)) ≡ (ε - δ)
+ lem--08 = solve! R
+
+ lem--09 : (q - r) + (𝕢 - q) ≡ (𝕢 - r)
+ lem--09 = solve! R
+
+ lem--010 : (- (q - r)) + (𝕢 - r) ≡ (𝕢 - q)
+ lem--010 = solve! R
+
+ lem--012 : (- (- ε)) + η ≡ ε + η
+ lem--012 = solve! R
+
+ lem--013 : η + (ε - δ) ≡ (ε + η) - δ
+ lem--013 = solve! R
+
+ lem--014 : ((ε - δ) + η) ≡ (ε + η) - δ
+ lem--014 = solve! R
+
+ lem--015 : (ε - δ) + ((σ* + δ) + ((η - σ*) )) ≡ ε + η
+ lem--015 = solve! R
+
+ lem--016 : (η₁ - (δ* + η*)) + (ε - (δ + η)) + (δ + η*) ≡ (ε + η₁) - (δ* + η)
+ lem--016 = solve! R
+
+ lem--017 : (η₁ - (δ* + η*)) + (ε - (δ + η)) + (η + η*) ≡ (ε + η₁) - (δ* + δ)
+ lem--017 = solve! R
+
+ lem--018 : (ε - δ) + (η - δ*) ≡ (ε + η) - (δ* + δ)
+ lem--018 = solve! R
+
+ lem--019 : (ε - δ) + ((η* + δ) + (η - (δ* + η*))) ≡ (ε + η) - δ*
+ lem--019 = solve! R
+
+ lem--020 : (ε - δ) + ((η* + δ) + (η - (δ* + η*))) ≡ (ε + η) - δ*
+ lem--020 = solve! R
+
+ lem--021 : (ε - δ) + (η - δ*) ≡ (ε + η) - (δ* + δ)
+ lem--021 = solve! R
+
+ lem--022 : (ε - δ) + η ≡ (ε + η) - δ
+ lem--022 = solve! R
+
+ lem--023 : (((ε - δ)) + ((δ + δ*) + ((η - δ*)))) ≡ (ε + η)
+ lem--023 = solve! R
+
+ lem--024 : (ε - δ) + (η* - δ*) ≡ (ε + η*) - (δ + δ*)
+ lem--024 = solve! R
+
+ lem--025 : (ε - δ) + ((δ* + δ) + ((η'' - (δ* + η*)))) ≡ (ε + η'') - η*
+ lem--025 = solve! R
+
+ lem--026 : (((ε - δ)) + ((δ + δ*) + ((η' - δ*)))) ≡ (ε + η')
+ lem--026 = solve! R
+
+ lem--027 : (ε - δ) + η' ≡ (ε + η') - δ
+ lem--027 = solve! R
+
+ lem--028 : (ε - δ) + ((δ* + δ) + (η' - (δ* + η*))) ≡ (ε + η') - η*
+ lem--028 = solve! R
+
+ lem--029 : (ε - δ) + (η' - δ*) ≡ (ε + η') - (δ + δ*)
+ lem--029 = solve! R
+
+ lem--030 : (ε - (δ + η)) + ((δ* + δ) + (η' - δ*)) ≡ (ε + η') - η
+ lem--030 = solve! R
+
+ lem--031 : (ε - (δ + η)) + ((δ*  + η) + (η' - δ*)) ≡ (ε + η') - δ
+ lem--031 = solve! R
+
+ lem--032 : (ε - (δ + η)) + ((δ* + δ) + ((η₁ - (δ* + η*)))) ≡ (ε + η₁) - (η + η*)
+ lem--032 = solve! R
+
+ lem--033 : (ε - (δ + η₁)) + ((δ* + η₁) + ((η - (δ* + η*)))) ≡ (ε + η) - (δ + η*)
+ lem--033 = solve! R
+
+ lem--034 : ε ≡ ((ε + δ) - δ)
+ lem--034 = solve! R
+
+ lem--035 : ε ≡ ((ε - δ) + δ)
+ lem--035 = solve! R
+
+ lem--036 : (ε - η) ≡
+             ((ε + δ) - (η +  δ))
+ lem--036 = solve! R
+
+ lem--037 : (ε - η) ≡
+             ((δ + ε) - (δ + η))
+ lem--037 = solve! R
+
+ lem--038 : (ε - η) · (ε + η) ≡
+             (ε · ε) - (η · η)
+ lem--038 = solve! R
+
+ lem--039 : (x' - x) · (y' - y) + (x' · y + x · (y' - y))
+            ≡ x' · y'
+ lem--039 = solve! R
+
+ lem--040 : (x' + x) · (x' - x)
+            ≡ x' · x' - x · x
+ lem--040 = solve! R
+
+ lem--041 : (x' + x) - (y' + y)
+            ≡ (x' - y') + (x - y)
+ lem--041 = solve! R
+
+ lem--042 : (a ·  b' ·  c' + c · ( a' ·  b')) ·  c' ≡
+           (a ·  c' + c ·  a') · ( b' ·  c')
+ lem--042 = solve! R
+
+ lem--043 : (b ·  a' ·  c' + c · ( a' ·  b')) ·  c' ≡
+            (b ·  c' + c ·  b') · ( a' ·  c')
+ lem--043 = solve! R
+
+ lem--044 : (θ +  θ) + ( θ) +
+      ( ε - ( ( θ +  θ) +  ( θ +  θ)))
+      ≡ ( (ε + δ) - ( ( θ) +  δ))
+ lem--044 = solve! R
+
+ lem--045 : (x' + x) + (y' + y)
+            ≡ (x' + y') + (x + y)
+ lem--045 = solve! R
+
+ lem--046 : L · (ε + (- δ)) ≡
+    L · ε + (- (L · δ))
+ lem--046 = solve! R
+
+ lem--047 : L · (ε - (δ + η)) ≡
+    ((L · ε) - ((L · δ) + (L · η)))
+ lem--047 = solve! R
+
+ lem--048 : ((x + (y - x) · a) + (y - x) · a) + (y - x) · a ≡ x + (a + a + a) · (y - x)
+ lem--048 = solve! R
+
+ lem--049 : ((ε · x) · y) + ((η · x) · y) ≡ (((ε + η) · x) · y)
+ lem--049 = solve! R
+
+ lem--050 : (- ε) ≡ (x - (x + ε))
+ lem--050 = solve! R
+
+ lem--051 :  y + ((- y) - ε) ≡ (- ((x + ε) - x))
+ lem--051 = solve! R
+
+ lem--052 : ε + x + (- y - ε) ≡ x - y
+ lem--052 = solve! R
+
+ lem--053 : y + (- (- ε)) - y  ≡ (x + ε) - x
+ lem--053 = solve! R
+
+ lem--054 : (((ε - θ) - η) + (θ + η)) ≡ ε
+ lem--054 = solve! R
+
+ lem--055 : θ + (ε - (θ + θ + θ)) ≡ (ε - (θ + θ))
+ lem--055 = solve! R
+
+ lem--056 : (ε - θ) ≡ (ε - (θ + θ)) + θ
+ lem--056 = solve! R
+
+ lem--057 : (x · y) + ((x · y) + (x · y)) ≡  (x + (x + x)) · y
+ lem--057 = solve! R
+
+ lem--058 : (r · q) + (r · q) ≡
+      ((r + q) · (r + q) + - (r · r + q · q))
+ lem--058 = solve! R
+
+ lem--059 : (x' - q) + (y' + q)
+            ≡ x' + y'
+ lem--059 = solve! R
+
+ lem--060 : (x' - q) + (q - y')
+            ≡ x' - y'
+ lem--060 = solve! R
+
+ lem--061 : (q - y) + (x - q) ≡ (x - y)
+ lem--061 = solve! R
+
+ lem--062 : (q - x) - (q - y) ≡ y - x
+ lem--062 = solve! R
+
+ lem--063 : (ε + δ) - ε ≡ δ
+ lem--063 = solve! R
+
+ lem--064 : (x · (ε · x')) + (y · (ε · y'))
+               ≡ ((x · x') + (y · y')) · ε
+ lem--064 = solve! R
+
+ lem--065 : (x' · y') - (x · y)
+              ≡ y · (x' - x) + x' · (y' - y)
+ lem--065 = solve! R
+
+ 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 ℚ
+
+
+
+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..9b1cb3dc98
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Lipschitz.agda
@@ -0,0 +1,673 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Lipschitz where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Int as ℤ
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊ ; /4₊+/4₊≡/2₊ ; ε/2+ε/2≡ε)
+
+open import Cubical.Data.NatPlusOne
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+
+sΣℚ< : ∀ {u v ε ε'} → fst ε ≡ ε' → (u ∼[ ε ] v) →
+         Σ (0< ε') (λ z → u ∼[ ε' , z ] v)
+sΣℚ< {u} {v} {ε} p x =
+   subst (λ ε' → Σ (0< ε') (λ z → u ∼[ ε' , z ] v)) p (snd ε , x)
+
+sΣℚ<' : ∀ {u v ε ε'} → fst ε ≡ ε' → (u ∼'[ ε ] v) →
+         Σ (0< ε') (λ z → u ∼'[ ε' , z ] v)
+sΣℚ<' {u} {v} {ε} p x =
+   subst (λ ε' → Σ (0< ε') (λ z → u ∼'[ ε' , z ] v)) p (snd ε , x)
+
+
+-- 11.3.36
+𝕣-lim : ∀ r y ε δ p →
+          r ∼[ ε ] ( y δ )
+        → r ∼[ ε ℚ₊+ δ  ] (lim y p )
+𝕣-lim = Elimℝ-Prop.go w
+
+ where
+ w : Elimℝ-Prop _
+ w .Elimℝ-Prop.ratA x y ε δ p x₁ =
+   rat-lim x y (ε ℚ₊+ δ) δ p (subst 0<_ ((lem--034 {fst ε} {fst δ})) (snd ε))
+    (subst∼ (lem--034 {fst ε} {fst δ}) x₁)
+ w .Elimℝ-Prop.limA x p R y ε δ p₁ = PT.rec (isProp∼ _ _ _)
+     (uncurry λ θ → PT.rec (isProp∼ _ _ _) (uncurry $ λ vv →
+        uncurry (lim-lim _ _ _ (/4₊ θ) δ _ _) ∘
+                  (sΣℚ< ((λ i → (fst (/4₊+/4₊≡/2₊ θ (~ i)) ℚ.+ fst (/4₊ θ))
+                             ℚ.+ (fst ε ℚ.-
+                                (sym (ε/2+ε/2≡ε (fst θ))
+                                      ∙ cong₂ ℚ._+_ (cong fst $
+                                          sym (/4₊+/4₊≡/2₊ θ))
+                                         (cong fst $ sym (/4₊+/4₊≡/2₊ θ))) i ))
+                         ∙ lem--044 {fst (/4₊ θ)} {fst ε} {fst δ}) ∘
+                    (triangle∼ (R (/4₊ θ) x (/2₊ θ)
+                      (/4₊ θ) p (refl∼ _ _)))))) ∘ fst (rounded∼ _ _ _)
+
+
+ w .Elimℝ-Prop.isPropA _ = isPropΠ5 λ _ _ _ _ _ → isProp∼ _ _ _
+
+
+-- 11.3.37
+𝕣-lim-self : ∀ x y δ ε → x δ ∼[ δ ℚ₊+ ε ] lim x y
+𝕣-lim-self x y δ ε =
+ subst∼ (sym (ℚ.+Assoc _ _ _) ∙ cong (fst δ ℚ.+_) (ε/2+ε/2≡ε (fst ε))) $ 𝕣-lim (x δ) x (δ ℚ₊+ /2₊ ε) ((/2₊ ε)) y
+  (y δ _)
+
+-- 11.3.36
+𝕣-lim' : ∀ r y ε δ p v →
+          r ∼[ fst ε ℚ.- fst δ , v ] ( y δ )
+        → r ∼[ ε ] (lim y p )
+𝕣-lim' r y ε δ p v₁ x =
+   subst∼ (sym (lem--035 {fst ε} {fst δ}))
+     $ 𝕣-lim r y (fst ε ℚ.- fst δ , v₁) δ p x
+
+-- 𝕣-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) )
+lim-surj = PT.map (map-snd (eqℝ _ _)) ∘ (Elimℝ-Prop.go w)
+ where
+ w : Elimℝ-Prop _
+ w .Elimℝ-Prop.ratA x = ∣ ((λ _ → rat x) , (λ _ _ → refl∼ _ _)) ,
+   (λ ε → rat-lim x (λ v → rat x) ε
+    (/2₊ ε) (λ v v₁ → refl∼ (rat x) (v ℚ₊+ v₁))
+     (subst 0<_ (lem--034 {fst (/2₊ ε)} {fst (/2₊ ε)} ∙ cong (λ e → e ℚ.- fst (/2₊ ε)) (ε/2+ε/2≡ε (fst ε)) ) (snd (/2₊ ε)))
+
+    (refl∼ (rat x) _)) ∣₁
+
+
+ w .Elimℝ-Prop.limA x p _ = ∣ (x , p) , refl∼ _ ∣₁
+ w .Elimℝ-Prop.isPropA _ = squash₁
+
+
+-- TODO : (Lemma 11.3.11)
+
+-- HoTT-11-3-11 : ∀ {ℓ} (A : Type ℓ) (isSetA : isSet A) →
+--        (f : (Σ[ x ∈  (ℚ₊ → ℝ) ] (∀ ( δ ε : ℚ₊) → x δ ∼[ δ ℚ₊+ ε ] x ε))
+--          → A) →
+--       (∀ u v → uncurry lim u ≡ uncurry lim v → f u ≡ f v)
+--       → ∃![ g ∈ (ℝ → A) ] f ≡ g ∘ uncurry lim
+-- HoTT-11-3-11 A isSetA f p =
+--
+
+Lipschitz-ℚ→ℚ : ℚ₊ → (ℚ → ℚ) → Type
+Lipschitz-ℚ→ℚ L f =
+  (∀ q r → (ε : ℚ₊) →
+    ℚ.abs (q ℚ.- r) ℚ.< (fst ε) → ℚ.abs (f q ℚ.- f r) ℚ.< fst (L ℚ₊· ε  ))
+
+
+Lipschitz-ℚ→ℚ' : ℚ₊ → (ℚ → ℚ) → Type
+Lipschitz-ℚ→ℚ' L f =
+  ∀ q r →
+    ℚ.abs (f q ℚ.- f r) ℚ.≤ fst L ℚ.· ℚ.abs (q ℚ.- r)
+
+Lipschitz-ℚ→ℚ'→Lipschitz-ℚ→ℚ : ∀ L f →
+ Lipschitz-ℚ→ℚ' L f → Lipschitz-ℚ→ℚ L f
+Lipschitz-ℚ→ℚ'→Lipschitz-ℚ→ℚ L f P q r ε <ε =
+  ℚ.isTrans≤< _ _ _ (P q r)
+    (ℚ.<-o· (ℚ.abs (q ℚ.- r)) (fst ε) _ (ℚ.0<ℚ₊ L) <ε)
+
+Lipschitz-ℚ→ℚ-restr : ℚ₊ → ℚ₊ → (ℚ → ℚ) → Type
+Lipschitz-ℚ→ℚ-restr Δ L f =
+  (∀ q r → ℚ.abs q ℚ.< fst Δ → ℚ.abs r ℚ.< fst Δ → (ε : ℚ₊) →
+    ℚ.abs (q ℚ.- r) ℚ.< (fst ε) → ℚ.abs (f q ℚ.- f r) ℚ.< fst (L ℚ₊· ε  ))
+
+Lipschitz-ℚ→ℚ-restr' : ℚ₊ → ℚ₊ → (ℚ → ℚ) → Type
+Lipschitz-ℚ→ℚ-restr' Δ L f =
+  (∀ q r → fst Δ ℚ.< ℚ.abs q → fst Δ  ℚ.< ℚ.abs r → (ε : ℚ₊) →
+    ℚ.abs (q ℚ.- r) ℚ.< (fst ε) → ℚ.abs (f q ℚ.- f r) ℚ.< fst (L ℚ₊· ε  ))
+
+
+Lipschitz-ℚ→ℚ-extend : ∀ Δ L f (δ : ℚ₊) → fst δ ℚ.< fst Δ
+ → Lipschitz-ℚ→ℚ-restr Δ L f
+ → Lipschitz-ℚ→ℚ L (f ∘ ℚ.clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ))
+Lipschitz-ℚ→ℚ-extend Δ L f δ δ<Δ x q r ε v =
+ let z : ∀ u → ℚ.abs (ℚ.clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) u)
+                  ℚ.< fst Δ
+     z u = ℚ.absFrom<×< (fst Δ)
+              (ℚ.clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) u)
+               (ℚ.isTrans<≤ (ℚ.- (fst Δ)) (ℚ.- (fst Δ ℚ.- fst δ)) _
+                 (subst2 (ℚ._<_)
+                     (ℚ.+IdR _) (ℚ.+Comm _ _
+                      ∙ (sym $ ℚ.-[x-y]≡y-x (fst Δ) (fst δ)))
+                     ((ℚ.<-o+ 0 (fst δ) (ℚ.- (fst Δ)) (ℚ.0<ℚ₊ δ))))
+                 ((ℚ.≤clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) u
+                    (( ℚ.pos[-x≤x] (ℚ.<→ℚ₊ (fst δ) (fst Δ) δ<Δ))))) )
+               (ℚ.isTrans≤< _ _ _ (ℚ.clamp≤ _ _ _)
+                (ℚ.<-ℚ₊' (fst Δ) (fst Δ) δ (ℚ.isRefl≤ (fst Δ)) ))
+
+ in x (ℚ.clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) q)
+            (ℚ.clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) r)
+            (z q) (z r) ε
+             (ℚ.isTrans≤< _ _ _
+               (ℚ.clampDist (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) r q)
+               v)
+
+
+-- HoTT Definition (11.3.14)
+Lipschitz-ℚ→ℝ : ℚ₊ → (ℚ → ℝ) → Type
+Lipschitz-ℚ→ℝ L f =
+  (∀ q r → (ε : ℚ₊) →
+    (ℚ.- (fst ε)) ℚ.< (q ℚ.- r)
+     → q ℚ.- r ℚ.< (fst ε) → f q ∼[ L ℚ₊· ε  ] f r)
+
+Lipschitz-rat∘ : ∀ l f → Lipschitz-ℚ→ℚ l f → Lipschitz-ℚ→ℝ l (rat ∘ f)
+Lipschitz-rat∘ l f x =
+  λ q r ε x₁ x₂ →
+    rat-rat-fromAbs _ _ _
+       $ x q r ε (ℚ.absFrom<×< (fst ε) (q ℚ.- r) x₁ x₂)
+
+Lipschitz-ℝ→ℝ : ℚ₊ → (ℝ → ℝ) → Type
+Lipschitz-ℝ→ℝ L f =
+  (∀ u v → (ε : ℚ₊) →
+    u ∼[ ε  ] v → f u ∼[ L ℚ₊· ε  ] f v)
+
+
+isPropLipschitz-ℝ→ℝ : ∀ q f → isProp (Lipschitz-ℝ→ℝ q f)
+isPropLipschitz-ℝ→ℝ q f = isPropΠ4 λ _ _ _ _ → isProp∼ _ _ _
+
+·- : ∀ x y → x ℚ.· (ℚ.- y) ≡ ℚ.- (x ℚ.· y)
+·- x y = ℚ.·Assoc x (-1) y
+         ∙∙ cong (ℚ._· y) (ℚ.·Comm x (-1))
+         ∙∙ sym (ℚ.·Assoc (-1) x y)
+
+
+-- HoTT Lemma (11.3.15)
+fromLipschitz : ∀ L → Σ _ (Lipschitz-ℚ→ℝ L) → Σ _ (Lipschitz-ℝ→ℝ L)
+fromLipschitz L (f , fL) = f' ,
+  λ u v ε x → Elimℝ.go∼ w x
+ where
+
+ rl : _
+ rl q y ε δ p v r v' u' z =
+  𝕣-lim' (f q) (v' ∘ (invℚ₊ L) ℚ₊·_)
+            (L ℚ₊· ε) (L ℚ₊· δ)
+          (λ δ₁ ε₁ →
+          subst (λ q₁ → v' (invℚ₊ L ℚ₊· δ₁) ∼[ q₁ ] v' (invℚ₊ L ℚ₊· ε₁))
+          (ℚ.ℚ₊≡
+           ((λ i →
+               fst L ℚ.· ℚ.·DistL+ (fst (invℚ₊ L)) (fst δ₁) (fst ε₁) (~ i))
+            ∙∙ ℚ.·Assoc (fst L) (fst (invℚ₊ L)) (fst δ₁ ℚ.+ fst ε₁) ∙∙
+            ((λ i → ℚ.x·invℚ₊[x] L i ℚ.· fst (δ₁ ℚ₊+ ε₁)) ∙
+             ℚ.·IdL (fst (δ₁ ℚ₊+ ε₁)))))
+          (u' (invℚ₊ L ℚ₊· δ₁) (invℚ₊ L ℚ₊· ε₁)))
+          (subst {x = fst L ℚ.· (fst ε ℚ.+ (ℚ.- fst δ))}
+                 {fst L ℚ.· fst ε ℚ.+ (ℚ.- fst (L ℚ₊· δ))}
+                0<_ ( lem--046 )
+            (ℚ.·0< (fst L) (fst ε ℚ.- fst δ) (snd L) v) )
+              (subst2 (f q ∼[_]_) (ℚ₊≡ lem--046)
+                 (cong v' (ℚ₊≡ (sym $ ℚ.[y·x]/y L (fst δ)))) z)
+
+ w : Elimℝ (λ _ → ℝ) λ u v ε _ → u ∼[ L ℚ₊· ε  ] v
+ w .Elimℝ.ratA = f
+ w .Elimℝ.limA x p a v = lim (a ∘ (invℚ₊ L) ℚ₊·_)
+   λ δ ε →
+    let v' = v ((invℚ₊ L ℚ₊· δ)) ((invℚ₊ L ℚ₊· ε))
+    in subst (λ q → a (invℚ₊ L ℚ₊· δ) ∼[ q ] a (invℚ₊ L ℚ₊· ε))
+        (ℚ₊≡ (cong ((fst L) ℚ.·_)
+                (sym (ℚ.·DistL+ (fst (invℚ₊ L)) (fst δ) (fst ε)))
+                 ∙∙ ℚ.·Assoc (fst L) (fst (invℚ₊ L))
+                      ((fst δ) ℚ.+ (fst ε)) ∙∙
+                       (cong (ℚ._· fst (δ ℚ₊+ ε))
+                        (ℚ.x·invℚ₊[x] L) ∙ ℚ.·IdL (fst (δ ℚ₊+ ε)))))
+
+          v'
+ w .Elimℝ.eqA p a a' x y =
+   eqℝ a a' λ ε →
+     subst (λ q → a ∼[ q ] a')
+        (ℚ₊≡ $
+          ℚ.·Assoc (fst L) (fst (invℚ₊ L)) (fst ε) ∙
+            (cong (ℚ._· fst (ε))
+                        (ℚ.x·invℚ₊[x] L) ∙ ℚ.·IdL (fst (ε))))
+                        (y (invℚ₊ L ℚ₊· ε))
+ w .Elimℝ.rat-rat-B q r ε x x₁ = fL q r ε x x₁
+ w .Elimℝ.rat-lim-B = rl
+ w .Elimℝ.lim-rat-B x r ε δ p v₁ u v' u' x₁ = sym∼ _ _ _ $
+  rl r x ε δ p v₁ (sym∼ _ _ _ u) v' u' (sym∼ _ _ _ x₁)
+ w .Elimℝ.lim-lim-B x y ε δ η p p' v₁ r v' u' v'' u'' x₁ =
+  let e = lem--047
+  in lim-lim _ _ _ (L ℚ₊· δ) (L ℚ₊· η) _ _
+       (subst (0<_) e
+         $ ℚ.·0< (fst L) (fst ε ℚ.- (fst δ ℚ.+ fst η))
+              (snd L) v₁)
+
+        ((cong v' (ℚ₊≡ $ sym (ℚ.[y·x]/y L (fst δ)))
+          subst∼[ ℚ₊≡ e ]
+           cong v'' (ℚ₊≡ $ sym (ℚ.[y·x]/y L (fst η)))) x₁)
+ w .Elimℝ.isPropB _ _ _ _ = isProp∼ _ _ _
+
+
+
+ f' : ℝ → ℝ
+ f' = Elimℝ.go w
+
+
+
+∼-monotone< : ∀ {u v ε ε'} → fst ε ℚ.< fst ε' → u ∼[ ε ] v → u ∼[ ε' ] v
+∼-monotone< {u} {v} {ε} {ε'} x x₁ =
+  subst∼ (lem--05 {fst ε} {fst ε'})
+   (triangle∼ x₁ (refl∼ v (ℚ.<→ℚ₊ (fst ε) (fst ε') x)))
+
+∼-monotone≤ : ∀ {u v ε ε'} → fst ε ℚ.≤ fst ε' → u ∼[ ε ] v → u ∼[ ε' ] v
+∼-monotone≤ {u} {v} {ε} {ε'} x x₁ =
+   ⊎.rec (flip subst∼ x₁ )
+         (flip ∼-monotone< x₁ )
+     $ ℚ.≤→<⊎≡ (fst ε) (fst ε') x
+
+
+lipschConstIrrel : ∀ L₁ L₂ (x : ℚ₊ → ℝ) → ∀  p₁ p₂ →
+         lim (λ q → x (L₁ ℚ₊· q)) p₁
+       ≡ lim (λ q → x (L₂ ℚ₊· q)) p₂
+lipschConstIrrel L₁ L₂ =
+   ⊎.rec (w L₁ L₂) (λ x x₁ p₁ p₂ →
+     sym (w L₂ L₁ x x₁ p₂ p₁)) (ℚ.getPosRatio L₁ L₂)
+
+
+ where
+ w : ∀ L₁ L₂ → (fst ((invℚ₊ L₁) ℚ₊·  L₂)) ℚ.≤ [ pos 1 / 1+ 0 ] →
+      (x : ℚ₊ → ℝ)
+      (p₁ : (δ ε : ℚ₊) → x (L₁ ℚ₊· δ) ∼[ δ ℚ₊+ ε ] x (L₁ ℚ₊· ε))
+      (p₂ : (δ ε : ℚ₊) → x (L₂ ℚ₊· δ) ∼[ δ ℚ₊+ ε ] x (L₂ ℚ₊· ε)) →
+      lim (λ q → x (L₁ ℚ₊· q)) p₁ ≡ lim (λ q → x (L₂ ℚ₊· q)) p₂
+ w L₁ L₂ L₂/L₁≤1 x p₁ p₂ = eqℝ _ _ $ λ ε →
+
+    (
+      (uncurry (lim-lim _ _ ε (/4₊ ε) (/4₊ ε) p₁ p₂)
+         (sΣℚ< ((((cong (fst (/4₊ ε) ℚ.+_) (ℚ.·IdL _)) ∙
+                  cong fst (/4₊+/4₊≡/2₊ ε)  ) ∙ lem--034 ∙
+               cong₂ (ℚ._-_)
+                  (ε/2+ε/2≡ε (fst ε)) (cong fst $ sym (/4₊+/4₊≡/2₊ ε) ))) (( refl subst∼[ refl ] cong x
+               (ℚ₊≡ (ℚ.·Assoc _ _ _ ∙
+                cong (ℚ._· (fst (/4₊ ε)))
+                  (ℚ.·Assoc _ _ _ ∙
+                   cong (ℚ._· (fst L₂))
+                     (ℚ.x·invℚ₊[x] L₁) ∙ ℚ.·IdL (fst (L₂))) ))) $
+            (∼-monotone≤ {ε' = (/4₊ ε) ℚ₊+ (1 ℚ₊· (/4₊ ε))}
+               (ℚ.≤-o+ _ (1 ℚ.· (fst (/4₊ ε))) (fst (/4₊ ε))
+                 (ℚ.≤-·o (fst (invℚ₊ L₁ ℚ₊· L₂)) 1 (fst (/4₊ ε))
+                  (ℚ.0≤ℚ₊ (/4₊ ε)) L₂/L₁≤1)
+                   ) $ p₁ (/4₊ ε) ((invℚ₊ L₁ ℚ₊· L₂) ℚ₊· /4₊ ε))))
+                   ) )
+
+
+NonExpandingℚₚ : (ℚ → ℚ) → hProp ℓ-zero
+fst (NonExpandingℚₚ f) = ∀ q r → ℚ.abs (f q ℚ.- f r) ℚ.≤ ℚ.abs (q ℚ.- r)
+snd (NonExpandingℚₚ f) = isPropΠ2 λ _ _ → ℚ.isProp≤ _ _
+
+NonExpandingₚ : (ℝ → ℝ) → hProp ℓ-zero
+fst (NonExpandingₚ f) = ∀ u v ε →  u ∼[ ε ] v → f u ∼[ ε ] f v
+snd (NonExpandingₚ f) = isPropΠ4 λ _ _ _ _ → isProp∼ _ _ _
+
+NonExpandingₚ∘ : ∀ f g → ⟨ NonExpandingₚ f ⟩ → ⟨ NonExpandingₚ g ⟩ →
+                    ⟨ NonExpandingₚ (f ∘ g) ⟩
+NonExpandingₚ∘ _ _ x y _ _ _ = x _ _ _ ∘ (y _ _ _)
+
+
+congLim : ∀ x y x' y' → (∀ q → x q ≡ x' q) → lim x y ≡ lim x' y'
+congLim x y x' y' p =
+  congS (uncurry lim)
+          (Σ≡Prop (λ _ → isPropΠ2 λ _ _ → isProp∼ _ _ _)
+           (funExt p))
+
+
+open ℚ.HLP
+
+congLim' : ∀ x y x' → (p : ∀ q → x q ≡ x' q) →
+ lim x y ≡ lim x' (subst (λ x' → (δ ε : ℚ₊) → x' δ ∼[ δ ℚ₊+ ε ] x' ε)
+                      (funExt p) y)
+congLim' x y x' p =
+   congLim x y x' _ p
+
+-- HoTT Lemma (11.3.40)
+record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
+ no-eta-equality
+ field
+
+  cL : ∀ q r s →
+       ℚ.abs (g q s ℚ.- g r s) ℚ.≤ ℚ.abs (q ℚ.- r)
+
+  cR : ∀ q r s →
+      (ℚ.abs (g q r ℚ.- g q s) ℚ.≤ ℚ.abs (r ℚ.- s))
+
+
+
+
+ zz : (q : ℚ) → Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ (1 , tt))
+ zz q = fromLipschitz (1 , tt) (rat ∘ g q ,
+    λ q₁ r₁ ε x₀ x →
+      let zz : ℚ.abs (g q q₁ ℚ.- g q r₁) ℚ.≤ ℚ.abs (q₁ ℚ.- r₁)
+          zz = cR q q₁ r₁
+      in rat-rat-fromAbs _ _ _
+           (ℚ.isTrans≤<
+             (ℚ.abs (g q q₁ ℚ.- g q r₁)) (ℚ.abs (q₁ ℚ.- r₁))
+             _ zz
+               (subst (ℚ.abs (q₁ ℚ.- r₁) ℚ.<_) (sym (ℚ.·IdL (fst ε)))
+                 (ℚ.absFrom<×< (fst ε) (q₁ ℚ.- r₁) x₀ x)))
+
+      )
+
+
+ w : Elimℝ
+       _ λ h h' ε v → ∀ u → (fst h u) ∼[ ε ] fst h' u
+ w .Elimℝ.ratA x .fst = fst (zz x)
+
+ w .Elimℝ.ratA x .snd = λ ε u v →
+    subst (fst (zz x) u ∼[_] fst (zz x) v)
+     (ℚ₊≡ $ ℚ.·IdL (fst ε)) ∘S snd (zz x) u v ε
+ w .Elimℝ.limA x p a x₁ .fst u =
+   lim (λ q → fst (a q) u) λ δ ε → x₁ δ ε u
+ w .Elimℝ.limA x p a x₁ .snd ε u v =
+   PT.rec (isProp∼ _ _ _)
+     (uncurry λ q → PT.rec (isProp∼ _ _ _)
+       λ (xx , xx') →
+        let q/2 = /2₊ q
+            z = snd (a q/2) _ _ _ xx'
+        in lim-lim _ _ _ q/2 q/2 _ _
+             (subst 0<_ ((cong (λ d → fst ε ℚ.- d) (sym $ ε/2+ε/2≡ε (fst q)) ))
+                xx)
+             (subst∼ (cong (λ d → fst ε ℚ.- d) (sym $ ε/2+ε/2≡ε (fst q)) ) z))
+     ∘S fst (rounded∼ _ _ _)
+
+ w .Elimℝ.eqA p a a' x x₁ = Σ≡Prop
+   (λ _ → isPropΠ4 λ _ _ _ _ → isProp∼ _ _ _)
+   (funExt λ rr →
+     eqℝ _ _ λ ε → x₁ ε rr)
+ w .Elimℝ.rat-rat-B q r ε x x₁ u =
+    Elimℝ-Prop.go rr u ε x x₁
+
+  where
+  rr :  Elimℝ-Prop λ u → (ε : ℚ₊) (x : (ℚ.- fst ε) ℚ.< (q ℚ.- r))
+         (x₁ : (q ℚ.- r) ℚ.< fst ε) →
+               fst (zz q) u ∼[ ε ] fst (zz r) u
+  rr .Elimℝ-Prop.ratA qq ε x₁ x₂ =
+    rat-rat-fromAbs _ _ _
+      (ℚ.isTrans≤<
+        (ℚ.abs (g q qq ℚ.- g r qq))
+        (ℚ.abs (q ℚ.- r))
+        _
+        (cL q r qq) (ℚ.absFrom<×< (fst ε) (q ℚ.- r) x₁ x₂))
+
+  rr .Elimℝ-Prop.limA x p x₁ ε x₂ x₃ =
+    let ((θ , θ<) , (x₂' , x₃'))  = ℚ.getθ ε ((q ℚ.- r)) (x₂ , x₃)
+        θ/2 = /2₊ (θ , θ<)
+        zzz : fst (zz q) (x θ/2) ∼[ (fst ε ℚ.- θ) , x₂' ]
+               fst (zz r) (x θ/2)
+        zzz = x₁ θ/2  ((fst ε ℚ.- θ) , x₂') (fst x₃') (snd x₃')
+    in lim-lim _ _ _ θ/2 θ/2
+                _ _ (subst 0<_ (cong (λ θ → fst ε ℚ.- θ)
+                              (sym (ε/2+ε/2≡ε θ))) x₂') (
+                 (subst2 (λ xx yy → fst (zz q) (x xx) ∼[ yy ]
+                     fst (zz r) (x xx))
+                       (ℚ₊≡ $ sym (ℚ.·IdL (fst θ/2)))
+                       (ℚ₊≡ (cong (λ θ → fst ε ℚ.- θ)
+                              (sym (ε/2+ε/2≡ε θ)))) zzz))
+  rr .Elimℝ-Prop.isPropA _ = isPropΠ3 λ _ _ _ → isProp∼ _ _ _
+
+ w .Elimℝ.rat-lim-B _ _ ε δ _ _ _ _ _ x _ =
+       subst∼ (sym $ lem--035 {fst ε} {fst δ}) $ 𝕣-lim _ _ _ _ _ (x _)
+ w .Elimℝ.lim-rat-B _ _ ε δ _ _ _ _ _ x₁ _ =
+   subst∼ (sym $ lem--035 {fst ε} {fst δ})
+    $ sym∼ _ _ _ (𝕣-lim _ _ _ _ _ (sym∼ _ _ _ $ x₁ _))
+ w .Elimℝ.lim-lim-B _ _ _ _ _ _ _ _ _ _ _ _ _ x₁ _ =
+   lim-lim _ _ _ _ _ _ _ _ (x₁ _)
+ w .Elimℝ.isPropB a a' ε _ = isPropΠ λ _ → isProp∼ _ _ _
+
+ preF : ℝ → Σ (ℝ → ℝ) λ h → ∀ ε u v → u ∼[ ε ] v → h u ∼[ ε ] h v
+ preF = Elimℝ.go w
+
+
+ go : ℝ → ℝ → ℝ
+ go x = fst (preF x)
+
+ go∼R : ∀ x u v ε → u ∼[ ε ] v → go x u ∼[ ε ] go x v
+ go∼R x u v ε = snd (preF x) ε u v
+
+ go∼L : ∀ x u v ε → u ∼[ ε ] v → go u x ∼[ ε ] go v x
+ go∼L x u v ε y = Elimℝ.go∼ w {u} {v} {ε} y x
+
+
+ go∼₂ : ∀ δ η {u v u' v'} → u ∼[ δ  ] v → u' ∼[ η ] v'
+             → go u u' ∼[ δ ℚ₊+ η ] go v v'
+ go∼₂ δ η {u} {v} {u'} {v'} x x' =
+   (triangle∼ (go∼L u' u v _ x) (go∼R v u' v' _ x'))
+
+
+ β-rat-lim : ∀ r x y y' → go (rat r) (lim x y) ≡
+                         lim (λ q → go (rat r) (x q))
+                          y'
+ β-rat-lim r x y y' = congLim _ _ _ _
+   λ q → cong (go (rat r) ∘ x)
+     (ℚ₊≡ (ℚ.·IdL (fst q)))
+
+
+ β-rat-lim' : ∀ r x y → Σ _
+            λ y' → (go (rat r) (lim x y) ≡
+                         lim (λ q → go (rat r) (x q)) y')
+ β-rat-lim' r x y = _ , congLim' _ _ _
+   λ q → cong (go (rat r) ∘ x)
+     (ℚ₊≡ (ℚ.·IdL (fst q)))
+
+
+ β-lim-lim/2 : ∀ x y x' y' → Σ _ (λ yy' → go (lim x y) (lim x' y') ≡
+                         lim (λ q → go (x (/2₊ q)) (x' (/2₊ q)))
+                          yy')
+ β-lim-lim/2 x y x' y' =
+   let
+       zz : lim (λ q → fst (Elimℝ.go w (x q)) (lim x' y'))
+              (λ δ ε → Elimℝ.go∼ w (y δ ε) (lim x' y')) ≡
+            lim (λ q → fst (Elimℝ.go w (x (/2₊ q))) (x' (/2₊ q)))
+                   λ δ ε →
+                     subst∼ (lem--045 ∙ cong₂ ℚ._+_ (ε/2+ε/2≡ε (fst δ))
+                              (ε/2+ε/2≡ε (fst ε))) $
+                       triangle∼
+                        (go∼R (x (/2₊ δ))  (x' (/2₊ δ)) (x' (/2₊ ε))
+                         (/2₊ δ ℚ₊+ /2₊ ε)
+                          (y' _ _))
+                         (go∼L (x' (/2₊ ε))
+                          (x (/2₊ δ)) (x (/2₊ ε)) _ (y _ _))
+       zz = eqℝ _ _ (λ ε →
+               let ε/4 = /4₊ ε
+                   v = subst {x = fst ε ℚ.· ℚ.[ 3 / 8 ]} (0 ℚ.<_)
+                       (distℚ! (fst ε)
+                        ·[ ge[ ℚ.[ 3 / 8 ] ] ≡
+                          (ge1 +ge
+                        (neg-ge
+                        ((ge[ ℚ.[ pos 1 / 1+ 3 ] ]
+                          ·ge ge[ ℚ.[ pos 1 / 1+ 1 ] ])
+                           +ge ge[ ℚ.[ pos 1 / 1+ 3 ] ])))
+                           +ge
+                        (neg-ge ((ge[ ℚ.[ pos 1 / 4 ] ]
+                          ·ge ge[ ℚ.[ pos 1 / 2 ] ])
+                               +ge
+                               (ge[ ℚ.[ pos 1 / 4 ] ]
+                          ·ge ge[ ℚ.[ pos 1 / 2 ] ]))) ])
+                        (ℚ.0<ℚ₊ (ε ℚ₊· (ℚ.[ 3 / 8 ] , _)))
+               in (lim-lim _ (λ q' → go (x (/2₊ q')) (x' (/2₊ q'))) ε
+                        (/2₊ ε/4) ε/4 _ _) (subst
+                         {y = fst ε ℚ.- (fst (/2₊ ε/4) ℚ.+ (fst ε/4))} (ℚ.0<_)
+                                   distℚ! (fst ε) ·[ ge[ ℚ.[ pos 5 / 8 ] ]
+                                     ≡ (ge1 +ge
+                        (neg-ge
+                        ((ge[ ℚ.[ pos 1 / 4 ] ]
+                          ·ge ge[ ℚ.[ pos 1 / 2 ] ])
+                           +ge ge[ ℚ.[ pos 1 / 4 ] ]))) ]
+                                    ((snd (ε ℚ₊· (ℚ.[ 5 / 8 ] , _)))))
+                        ((go∼R ( x (/2₊ ε/4)) (lim x' y')
+                          (x' (/2₊ ε/4)) _
+                          ((∼-monotone< {ε = /2₊ ε/4 ℚ₊+ /2₊ ε/4}
+                               {(fst ε ℚ.- ((((fst ε) ℚ.· [ 1 / 4 ])
+                                  ℚ.· ℚ.[ 1 / 2 ]) ℚ.+ fst ε/4))
+                                , _} (((ℚ.-<⁻¹ _ _ v)))
+                                   $ sym∼ _ _ _ (𝕣-lim-self x' y'
+                             (/2₊ ε/4) (/2₊ ε/4)))))))
+   in _ , zz
+
+
+NonExpanding₂-flip : ∀ g → NonExpanding₂ g → NonExpanding₂ (flip g)
+NonExpanding₂-flip g ne .NonExpanding₂.cL q r s =
+   NonExpanding₂.cR ne s q r
+NonExpanding₂-flip g ne .NonExpanding₂.cR q r s =
+   NonExpanding₂.cL ne r s q
+
+
+
+isPropNonExpanding₂ : ∀ g → isProp (NonExpanding₂ g)
+isPropNonExpanding₂ g x y i .NonExpanding₂.cL =
+  isPropΠ3 (λ q r s →
+   ℚ.isProp≤ (ℚ.abs (g q s ℚ.- g r s)) (ℚ.abs (q ℚ.- r)))
+     (λ q r s → x .NonExpanding₂.cL q r s)
+    (λ q r s → y .NonExpanding₂.cL q r s) i
+isPropNonExpanding₂ g x y i .NonExpanding₂.cR =
+   isPropΠ3 (λ q r s →
+   ℚ.isProp≤ (ℚ.abs (g q r ℚ.- g q s)) (ℚ.abs (r ℚ.- s)))
+     (λ q r s → x .NonExpanding₂.cR q r s)
+    (λ q r s → y .NonExpanding₂.cR q r s) i
+
+nonExpanding₂Ext : (g g' : _)
+   → (ne : NonExpanding₂ g) (ne' : NonExpanding₂ g')
+   → (∀ x y → g x y ≡ g' x y)
+   → ∀ x y → NonExpanding₂.go ne x y  ≡ NonExpanding₂.go ne' x y
+nonExpanding₂Ext g g' ne ne' p x y =
+  congS (λ x₁ → NonExpanding₂.go (snd x₁) x y)
+   (Σ≡Prop isPropNonExpanding₂ {_ , ne} {_ , ne'}
+    λ i x₁ x₂ → p x₁ x₂ i)
+
+
+NonExpanding₂-flip-go : ∀ g → (ne : NonExpanding₂ g)
+                              (flip-ne : NonExpanding₂ (flip g)) → ∀ x y →
+     (NonExpanding₂.go {g = flip g} flip-ne x y)
+   ≡ (NonExpanding₂.go {g = g} ne y x)
+NonExpanding₂-flip-go g ne flip-ne = Elimℝ-Prop2.go w
+ where
+ w : Elimℝ-Prop2
+          λ z z₁ → NonExpanding₂.go flip-ne z z₁ ≡ NonExpanding₂.go ne z₁ z
+
+ w .Elimℝ-Prop2.rat-ratA _ _ = refl
+ w .Elimℝ-Prop2.rat-limA r x y x₁ =
+   congLim _ _ _ _
+     λ q → congS (NonExpanding₂.go flip-ne (rat r) ∘S x)
+       ((ℚ₊≡ $ (ℚ.·IdL (fst q)) )) ∙ x₁ q
+
+ w .Elimℝ-Prop2.lim-ratA x y r x₁ =
+    congLim _ _ _ _
+     λ q → x₁ q ∙ congS (NonExpanding₂.go ne (rat r) ∘S x)
+      (ℚ₊≡ $ sym (ℚ.·IdL (fst q)) )
+
+ w .Elimℝ-Prop2.lim-limA x y x' y' x₁ =
+      snd (NonExpanding₂.β-lim-lim/2 flip-ne
+        x y x' y') ∙∙
+         cong (uncurry lim)
+          (Σ≡Prop (λ _ → isPropΠ2 λ _ _ → isProp∼ _ _ _)
+           (funExt λ q → x₁ (/2₊ q) (/2₊ q)))
+         ∙∙
+       sym (snd (NonExpanding₂.β-lim-lim/2 ne
+        x' y' x y))
+ w .Elimℝ-Prop2.isPropA _ _ = isSetℝ _ _
+
+module NonExpanding₂-Lemmas
+        (g : ℚ → ℚ → ℚ)
+        (ne : NonExpanding₂ g) where
+
+ module NE = NonExpanding₂ ne
+
+ module _ (gComm : ∀ x y → NE.go x y ≡ NE.go y x)
+          (gAssoc : ∀ p q r → g p (g q r) ≡ g (g p q) r)  where
+  pp : ∀ ε → fst (/2₊ ε) ≡ (fst ε ℚ.- (fst (/4₊ ε) ℚ.+ fst (/4₊ ε)))
+  pp ε = (distℚ! (fst ε) ·[ ge[ ℚ.[ 1 / 2 ] ]
+            ≡ ge1 +ge (neg-ge (ge[ ℚ.[ 1 / 4 ] ]
+               +ge ge[ ℚ.[ 1 / 4 ] ]))  ])
+
+  gAssoc∼ : ∀ x y z → ∀ ε → NE.go x (NE.go y z) ∼[ ε ] NE.go (NE.go x y) z
+  gAssoc∼ = Elimℝ-Prop.go w
+    where
+    w : Elimℝ-Prop _
+    w .Elimℝ-Prop.ratA q y z ε =
+       subst2 (_∼[ ε ]_)
+         (gComm (NE.go y z) (rat q))
+         (λ i → NE.go (gComm y (rat q) i) z)
+         (hh y z ε)
+     where
+     hh : (y z : ℝ) (ε : ℚ₊) →
+            NE.go (NE.go y z) (rat q) ∼[ ε ] NE.go (NE.go y (rat q)) z
+     hh = Elimℝ-Prop.go w'
+       where
+       w' : Elimℝ-Prop _
+       w' .Elimℝ-Prop.ratA p = Elimℝ-Prop.go w''
+         where
+         w'' : Elimℝ-Prop _
+         w'' .Elimℝ-Prop.ratA r ε = ≡→∼ (
+          gComm _ _ ∙∙ cong rat (gAssoc q p r)
+           ∙∙ λ i → NE.go (gComm (rat q) (rat p) i) (rat r))
+         w'' .Elimℝ-Prop.limA x x' R ε =
+           subst2 (_∼[ ε ]_)
+             (λ i → NE.go (gComm (lim x x')  (rat p)  i) (rat q))
+             (sym (gComm (NE.go (rat p) (rat q)) (lim x x')))
+            (hhh ε)
+          where
+          hhh : ∀ ε → NE.go (NE.go (lim x x') (rat p)) (rat q) ∼[ ε ]
+                 NE.go (lim x x') (NE.go (rat p) (rat q))
+          hhh ε =
+           let zzz = R (/4₊ ε) (/2₊ ε)
+           in uncurry (lim-lim _ _ ε (/4₊ ε)
+               (/4₊ ε) _ _)
+                (sΣℚ< (pp ε)
+                  ( (λ i → NE.go (gComm (rat p) (x (/4₊ ε)) i) (rat q))
+                      subst∼[ refl ] gComm (NE.go (rat p) (rat q))
+                                          (x (/4₊ ε))
+                     $ zzz  ))
+
+         w'' .Elimℝ-Prop.isPropA _ = isPropΠ λ _ → isProp∼ _ _ _
+       w' .Elimℝ-Prop.limA x x' R z ε =
+        uncurry (lim-lim _ _ ε (/4₊ ε)
+        (/4₊ ε) _ _)
+         (sΣℚ< (pp ε) (R (/4₊ ε) z (/2₊ ε) ))
+       w' .Elimℝ-Prop.isPropA _ = isPropΠ2 λ _ _ → isProp∼ _ _ _
+
+    w .Elimℝ-Prop.limA x x' R y z ε =
+     uncurry (lim-lim _ _ ε (/4₊ ε)
+        (/4₊ ε) _ _)
+         (sΣℚ< (pp ε)
+          (R (/4₊ ε) y z (/2₊ ε)))
+    w .Elimℝ-Prop.isPropA _ = isPropΠ3 λ _ _ _ → isProp∼ _ _ _
+
+
+fromLipshitzNEβ : ∀ f (fl : Lipschitz-ℚ→ℝ 1 f) x y →
+  fst (fromLipschitz 1 (f , fl)) (lim x y) ≡
+    lim (λ x₁ → Elimℝ.go _ (x x₁))
+     _
+fromLipshitzNEβ f fl x y = congLim' _ _ _
+ λ q → cong (Elimℝ.go _ ∘ x) (ℚ₊≡ $ ℚ.·IdL _)
+
+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
new file mode 100644
index 0000000000..cc67d449fb
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Multiplication.agda
@@ -0,0 +1,908 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Multiplication where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.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
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
+
+open import Cubical.Data.NatPlusOne
+
+import Cubical.Algebra.CommRing as CR
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊)
+
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+open import Cubical.HITs.CauchyReals.Order
+open import Cubical.HITs.CauchyReals.Continuous
+
+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)
+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
+
+  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⊓ 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))}))))))))
+                    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 ])
+
+     c : ℚ
+     c = (fst (fromNat (suc (suc (getClampsOnQ x' .fst .ℕ₊₁.n))))
+         ℚ.- _//_.[ 1 , 4 ])
+
+
+     c' : ℚ
+     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
+
+
+ IsContinuous/2ᵣ : IsContinuous /2ᵣ
+ IsContinuous/2ᵣ = Lipschitz→IsContinuous _ /2ᵣ (snd /2ᵣ-L)
+
+
+ IsContinuousSqᵣ : IsContinuous sqᵣ
+ IsContinuousSqᵣ = snd sqᵣ'
+
+
+
+
+
+
+ _·ᵣ_ : ℝ → ℝ → ℝ
+ 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)))
+
+
+ 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
+  (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) )
+
+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
+ isSetℝ
+  +ᵣ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)
+·ᵣ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₊ ε)
+
+
+
+
+
+
+
+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)
+·-ᵣ 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' → 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))
+·DistL- x y z = ·DistL+ x y (-ᵣ z) ∙ cong ((x ·ᵣ y) +ᵣ_) (·-ᵣ _ _)
+
+
+-ᵣ· : ∀ x y →  ((-ᵣ x) ·ᵣ y) ≡  -ᵣ (x ·ᵣ y)
+-ᵣ· x y = ·ᵣComm _ _ ∙∙ ·-ᵣ y x ∙∙ cong -ᵣ_ (·ᵣComm _ _)
+
+-ᵣ·-ᵣ : ∀ x y →  ((-ᵣ x) ·ᵣ (-ᵣ y)) ≡  (x ·ᵣ y)
+-ᵣ·-ᵣ x y = -ᵣ· x (-ᵣ y) ∙ cong (-ᵣ_) (·-ᵣ x y) ∙ -ᵣInvol _
+
+
+_^ⁿ_ : ℝ → ℕ → ℝ
+x ^ⁿ zero = 1
+x ^ⁿ suc n = (x ^ⁿ n) ·ᵣ 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
new file mode 100644
index 0000000000..3bc6bea7fa
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Order.agda
@@ -0,0 +1,779 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Order where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Powerset
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Int as ℤ
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Sigma
+open import Cubical.Relation.Nullary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
+
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊)
+
+open import Cubical.Data.NatPlusOne
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+
+
+
+sumR : NonExpanding₂ ℚ._+_
+sumR .NonExpanding₂.cL q r s =
+ ℚ.≡Weaken≤  (ℚ.abs ((q ℚ.+ s) ℚ.- (r ℚ.+ s))) (ℚ.abs (q ℚ.- r))
+  (sym $ cong ℚ.abs (lem--036 {q} {r} {s}))
+sumR .NonExpanding₂.cR q r s =
+   ℚ.≡Weaken≤ (ℚ.abs ((q ℚ.+ r) ℚ.- (q ℚ.+ s))) (ℚ.abs (r ℚ.- s))
+   (sym $ cong ℚ.abs (lem--037 {r} {s} {q}))
+
+infix  8 -ᵣ_
+infixl 6 _+ᵣ_ _-ᵣ_
+
+
+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)
+
+
+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
+
+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 ⟩
+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 )
+
+
+
+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 _ _)
+
+
+
+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'))
+
+
+
+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ℝ _ _
+
+infix 4 _≤ᵣ_ _<ᵣ_
+
+open ℚ.HLP
+
+opaque
+
+ _≤ᵣ_ : ℝ → ℝ → Type
+ u ≤ᵣ v = maxᵣ u v ≡ v
+
+ ≤ᵣ→≡ : ∀ {u v} → u ≤ᵣ v → maxᵣ u v ≡ v
+ ≤ᵣ→≡ p = p
+
+ ≡→≤ᵣ : ∀ {u v} → maxᵣ u v ≡ v → u ≤ᵣ v
+ ≡→≤ᵣ p = p
+
+ ≤ℚ→≤ᵣ : ∀ 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)
+
+
+ ≤ᵣ-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)
+
+
+ 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)
+
+ 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
+
+ <ᵣ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)
+
+decℚ≡ᵣ? : ∀ {x y} → {𝟚.True (ℚ.discreteℚ x y)} →  (rat x ≡ rat y)
+decℚ≡ᵣ? {x} {y} {p} = cong rat (ℚ.decℚ? {x} {y} {p})
+
+decℚ<ᵣ? : ∀ {x y} → {𝟚.True (ℚ.<Dec x y)} →  (rat x <ᵣ rat y)
+decℚ<ᵣ? {x} {y} {p} = <ℚ→<ᵣ x y (ℚ.decℚ<? {x} {y} {p})
+
+decℚ≤ᵣ? : ∀ {x y} → {𝟚.True (ℚ.≤Dec x y)} →  (rat x ≤ᵣ rat y)
+decℚ≤ᵣ? {x} {y} {p} = ≤ℚ→≤ᵣ x y (ℚ.decℚ≤? {x} {y} {p})
+
+instance
+  fromNatℝ₊ : HasFromNat ℝ₊
+  fromNatℝ₊ = record {
+     Constraint = λ { zero → ⊥ ; _ → Unit }
+   ; fromNat = λ { zero {{()}}  ; (suc n) →
+     (rat [ pos (suc n) / 1 ]) , <ℚ→<ᵣ _ _
+       (ℚ.<ℤ→<ℚ _ _ (ℤ.suc-≤-suc ℤ.zero-≤pos)) }}
+
+
+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
new file mode 100644
index 0000000000..73840e0540
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -0,0 +1,1471 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Sequence where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+open import Cubical.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 (_·_;_+_)
+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
+
+
+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∈ ))
+
+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∈)) )))
+
+ where
+ 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 ] , _)
+  (_ , Lipschitz-rat∘ ([ 1 / n ] , _) (ℚ._· [ 1 / n ])
+   λ q r ε x →
+     subst (ℚ._< ([ 1 / n ]) ℚ.· (fst ε))
+      (sym (ℚ.pos·abs [ 1 / n ] (q ℚ.- r)
+       (ℚ.<Weaken≤ 0 [ 1 / n ]
+           ( (ℚ.0<→< [ 1 / n ] _))))
+       ∙ cong ℚ.abs (ℚ.·Comm _ _ ∙ ℚ.·DistR+ q (ℚ.- r) [ 1 / n ]
+        ∙ cong ((q ℚ.· [ 1 / n ]) ℚ.+_)
+            (sym (ℚ.·Assoc -1 r [ 1 / n ]))))
+      (ℚ.<-o· (ℚ.abs (q ℚ.- r)) (fst ε) [ 1 / n ]
+       ((ℚ.0<→< [ 1 / n ] _))
+       x)))
+
+/nᵣ : ℕ₊₁ → ℝ → ℝ
+/nᵣ = fst ∘ /nᵣ-L
+
+/nᵣ-／ᵣ : ∀ n x (p : 0 ＃ fromNat (ℕ₊₁→ℕ n))
+            → /nᵣ n x ≡ (x ／ᵣ[ fromNat (ℕ₊₁→ℕ n) , p ] )
+/nᵣ-／ᵣ n x p = ≡Continuous _ _
+  (Lipschitz→IsContinuous _ (fst (/nᵣ-L n)) (snd (/nᵣ-L n)))
+   (IsContinuous·ᵣR _)
+  (λ r → cong rat (cong (r ℚ.·_) (cong [ 1 /_] (sym (·₊₁-identityˡ _))))
+    ∙ rat·ᵣrat _ _ ∙
+      cong (rat r ·ᵣ_) (sym (invℝ-rat _ _ (fst (rat＃ _ _) p)) )) x
+
+/nᵣ-pos : ∀ n x → 0 <ᵣ x → 0 <ᵣ /nᵣ n x
+/nᵣ-pos n x 0<x = subst (0 <ᵣ_) (sym (/nᵣ-／ᵣ _ _ _))
+                     (ℝ₊· (_ , 0<x) (_ , invℝ-pos _
+                         (<ℚ→<ᵣ _ _ (ℚ.0<→< _ tt))))
+
+seqSumUpTo : (ℕ → ℝ) → ℕ →  ℝ
+seqSumUpTo s zero = 0
+seqSumUpTo s (suc n) = s zero +ᵣ seqSumUpTo (s ∘ suc) n
+
+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' : (ℕ → ℝ) → ℕ →  ℝ
+seqSumUpTo' s zero = 0
+seqSumUpTo' s (suc n) = seqSumUpTo' s n +ᵣ s n
+
+seqΣ : Seq → Seq
+seqΣ = seqSumUpTo'
+
+seqΣ' : Seq → Seq
+seqΣ' = seqSumUpTo
+
+
+seqSumUpTo-suc : ∀ f n → seqSumUpTo f n +ᵣ f n ≡
+      f zero +ᵣ seqSumUpTo (λ x → f (suc x)) n
+seqSumUpTo-suc f zero = +ᵣComm _ _
+seqSumUpTo-suc f (suc n) =
+  sym (+ᵣAssoc _ _ _) ∙
+    cong ((f zero) +ᵣ_ ) (seqSumUpTo-suc _ _)
+
+seqSumUpTo≡seqSumUpTo' : ∀ f n → seqSumUpTo' f n ≡ seqSumUpTo f n
+seqSumUpTo≡seqSumUpTo' f zero = refl
+seqSumUpTo≡seqSumUpTo' f (suc n) =
+ cong (_+ᵣ (f n)) (seqSumUpTo≡seqSumUpTo' (f) n) ∙
+   seqSumUpTo-suc f n
+
+<-·sk-cancel : ∀ {m n k} → m ℕ.· suc k ℕ.< n ℕ.· suc k → m ℕ.< n
+<-·sk-cancel {n = zero} x = ⊥.rec (ℕ.¬-<-zero x)
+<-·sk-cancel {zero} {n = suc n} x = ℕ.suc-≤-suc (ℕ.zero-≤ {n})
+<-·sk-cancel {suc m} {n = suc n} {k} x =
+  ℕ.suc-≤-suc {suc m} {n}
+    (<-·sk-cancel {m} {n} {k}
+     (ℕ.≤-k+-cancel (subst (ℕ._≤ (k ℕ.+ n ℕ.· suc k))
+       (sym (ℕ.+-suc _ _)) (ℕ.pred-≤-pred x))))
+
+2≤x→1<quotient[x/2] : ∀ n → 0 ℕ.< (ℕ.quotient (2 ℕ.+ n) / 2)
+2≤x→1<quotient[x/2] n =
+ let z : 0 ℕ.<
+             ((ℕ.quotient (2 ℕ.+ n) / 2) ℕ.· 2)
+     z = subst (0 ℕ.<_) (ℕ.·-comm _ _)
+          (ℕ.≤<-trans ℕ.zero-≤ (ℕ.<-k+-cancel (subst (ℕ._< 2 ℕ.+
+             (2 ℕ.· (ℕ.quotient (2 ℕ.+ n) / 2)))
+           (ℕ.≡remainder+quotient 2 (2 ℕ.+ n))
+             (ℕ.<-+k {k = 2 ℕ.· (ℕ.quotient (2 ℕ.+ n) / 2)}
+              (ℕ.mod< 1 (2 ℕ.+ n))))))
+ in <-·sk-cancel {0} {ℕ.quotient (2 ℕ.+ n) / 2 } {k = 1}
+     z
+
+
+
+open ℕ.Minimal
+
+-- invFacℕ : ∀ n → Σ _ (Least (λ k → n ℕ.< 2 !))
+-- invFacℕ = {!!}
+
+log2ℕ : ∀ n → Σ _ (Least (λ k → n ℕ.< 2 ^ k))
+log2ℕ n = w n n ℕ.≤-refl
+ where
+
+  w : ∀ N n → n ℕ.≤ N
+          → Σ _ (Least (λ k → n ℕ.< 2 ^ k))
+  w N zero x = 0 , (ℕ.≤-refl , λ k' q → ⊥.rec (ℕ.¬-<-zero q))
+  w N (suc zero) x = 1 , (ℕ.≤-refl ,
+     λ { zero q → ℕ.<-asym (ℕ.suc-≤-suc ℕ.≤-refl)
+      ; (suc k') q → ⊥.rec (ℕ.¬-<-zero (ℕ.pred-≤-pred q))})
+  w zero (suc (suc n)) x = ⊥.rec (ℕ.¬-<-zero x)
+  w (suc N) (suc (suc n)) x =
+   let (k , (X , Lst)) = w N
+          (ℕ.quotient 2 ℕ.+ n / 2)
+          (ℕ.≤-trans (ℕ.pred-≤-pred (ℕ.2≤x→quotient[x/2]<x n))
+             (ℕ.pred-≤-pred x))
+       z = ℕ.≡remainder+quotient 2 (2 ℕ.+ n)
+       zz = ℕ.<-+-≤ X X
+       zzz : suc (suc n) ℕ.< (2 ^ suc k)
+       zzz = subst2 (ℕ._<_)
+           (ℕ.+-comm _ _
+              ∙ sym (ℕ.+-assoc ((ℕ.remainder 2 ℕ.+ n / 2)) _ _)
+               ∙ cong ((ℕ.remainder 2 ℕ.+ n / 2) ℕ.+_)
+             ((cong ((ℕ.quotient 2 ℕ.+ n / 2) ℕ.+_)
+              (sym (ℕ.+-zero (ℕ.quotient 2 ℕ.+ n / 2)))))
+             ∙ z)
+           (cong ((2 ^ k) ℕ.+_) (sym (ℕ.+-zero (2 ^ k))))
+           (ℕ.≤<-trans
+             (ℕ.≤-k+ (ℕ.≤-+k (ℕ.pred-≤-pred (ℕ.mod< 1 (2 ℕ.+ n))))) zz)
+   in (suc k)
+       , zzz
+        , λ { zero 0'<sk 2+n<2^0' →
+                ⊥.rec (ℕ.¬-<-zero (ℕ.pred-≤-pred 2+n<2^0'))
+            ; (suc k') k'<sk 2+n<2^k' →
+               Lst k' (ℕ.pred-≤-pred k'<sk)
+                (<-·sk-cancel {k = 1}
+                    (subst2 ℕ._<_ (ℕ.·-comm _ _) (ℕ.·-comm _ _)
+                      (ℕ.≤<-trans (_ , z)
+                         2+n<2^k' )))}
+
+
+
+
+
+0<x^ⁿ : ∀ x n → 0 <ᵣ x → 0 <ᵣ (x ^ⁿ n)
+0<x^ⁿ x zero x₁ = 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
+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' _ _ (-ᵣ-rat 0)))) ))
+          (≡ᵣWeaken≤ᵣ _ _ (·IdL _ ) )))
+
+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) →
+   ∀ 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≤→Σ≤-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
+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) =
+  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)) ≡
+     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)
+
+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 ε)
+
+
+IsCauchySequence' : Seq → Type
+IsCauchySequence' s =
+  ∀ (ε : ℚ₊) → Σ[ N ∈ ℕ ] (∀ m n → N ℕ.< n → N ℕ.< m →
+    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 =
+    ∀ (ε : ℝ₊) →
+     Σ[ N ∈ ℕ ] ∀ n m →
+       absᵣ (seqΣ (s ∘ (ℕ._+ (n ℕ.+ (suc N)))) m) <ᵣ fst ε
+
+IsConvSeries' : Seq → Type
+IsConvSeries' s =
+    ∀ (ε : ℚ₊) →
+     Σ[ N ∈ ℕ ] ∀ n m →
+       absᵣ (seqΣ (s ∘ (ℕ._+ (n ℕ.+ (suc N)))) m) <ᵣ rat (fst ε)
+
+
+IsoIsConvSeriesIsCauchySequenceSum : (s : Seq) →
+  Iso (IsConvSeries s) (IsCauchySequence (seqΣ s))
+IsoIsConvSeriesIsCauchySequenceSum s =
+   codomainIsoDep λ ε →
+     Σ-cong-iso-snd λ N →
+        isProp→Iso (isPropΠ2 λ _ _ → isProp<ᵣ _ _)
+         (isPropΠ4 λ _ _ _ _ → isProp<ᵣ _ _ )
+         (λ f → ℕ.elimBy≤
+           (λ n n' X <n <n' → subst (_<ᵣ fst ε)
+             (minusComm-absᵣ _ _) (X <n' <n))
+           λ n n' n≤n' N<n' N<n →
+              subst ((_<ᵣ fst ε) ∘ absᵣ)
+                 (cong (λ x → seqΣ (s ∘ (ℕ._+ x)) (n' ∸ n))
+                    (ℕ.[n-m]+m (suc N) n N<n)
+                   ∙∙ sym (seriesDiff s n (n' ∸ n)) ∙∙
+                   cong (_+ᵣ (-ᵣ seqΣ s n))
+                     (cong (seqΣ s)
+                       (ℕ.[n-m]+m n n' n≤n')))
+                 (f (n ∸ (suc N)) (n' ∸ n)))
+         λ f n m →
+           subst ((_<ᵣ fst ε) ∘ absᵣ)
+             (seriesDiff s (n ℕ.+ suc N) m)
+               (f (n ℕ.+ (suc N)) (m ℕ.+ (n ℕ.+ suc N))
+               (subst (N ℕ.<_) (sym (ℕ.+-assoc _ _ _))
+                 (ℕ.≤SumRight {suc N} {m ℕ.+ n}))
+               (ℕ.≤SumRight {suc N} {n}))
+
+
+IsConvSeries≃IsCauchySequenceSum : (s : Seq) →
+  IsConvSeries s ≃ IsCauchySequence (seqΣ s)
+IsConvSeries≃IsCauchySequenceSum s =
+  isoToEquiv (IsoIsConvSeriesIsCauchySequenceSum s)
+
+IsoIsConvSeries'IsCauchySequenceSum' : (s : Seq) →
+  Iso (IsConvSeries' s) (IsCauchySequence' (seqΣ s))
+IsoIsConvSeries'IsCauchySequenceSum' s =
+ codomainIsoDep λ ε →
+     Σ-cong-iso-snd λ N →
+        isProp→Iso (isPropΠ2 λ _ _ → isProp<ᵣ _ _)
+         (isPropΠ4 λ _ _ _ _ → isProp<ᵣ _ _)
+
+         (λ f → ℕ.elimBy≤
+           (λ n n' X <n <n' → subst (_<ᵣ rat (fst ε))
+             (minusComm-absᵣ _ _) (X <n' <n))
+           λ n n' n≤n' N<n' N<n →
+              subst ((_<ᵣ rat (fst ε)) ∘ absᵣ)
+                 (cong (λ x → seqΣ (s ∘ (ℕ._+ x)) (n' ∸ n))
+                    (ℕ.[n-m]+m (suc N) n N<n)
+                   ∙∙ sym (seriesDiff s n (n' ∸ n)) ∙∙
+                   cong (_+ᵣ (-ᵣ seqΣ s n))
+                     (cong (seqΣ s)
+                       (ℕ.[n-m]+m n n' n≤n')))
+                 (f (n ∸ (suc N)) (n' ∸ n)))
+         λ f n m →
+           subst ((_<ᵣ rat (fst ε)) ∘ absᵣ)
+             (seriesDiff s (n ℕ.+ suc N) m)
+               (f (n ℕ.+ (suc N)) (m ℕ.+ (n ℕ.+ suc N))
+               (subst (N ℕ.<_) (sym (ℕ.+-assoc _ _ _))
+                 (ℕ.≤SumRight {suc N} {m ℕ.+ n}))
+               (ℕ.≤SumRight {suc N} {n}))
+
+
+IsConvSeries'≃IsCauchySequence'Sum : (s : Seq) →
+  IsConvSeries' s ≃ IsCauchySequence' (seqΣ s)
+IsConvSeries'≃IsCauchySequence'Sum s =
+  isoToEquiv (IsoIsConvSeries'IsCauchySequenceSum' s)
+
+isCauchyAprox : (ℚ₊ → ℝ) → Type
+isCauchyAprox f = (δ ε : ℚ₊) →
+  (absᵣ (f δ +ᵣ (-ᵣ  f ε)) <ᵣ rat (fst (δ ℚ₊+ ε)))
+
+lim' : ∀ x → isCauchyAprox x → ℝ
+lim' x y = lim x λ δ ε  → (invEq (∼≃abs<ε _ _ _)) (y δ ε)
+
+-- HoTT 11.3.49
+
+fromCauchySequence : ∀ s → IsCauchySequence s → ℝ
+fromCauchySequence s ics =
+  lim x y
+
+ where
+ x : ℚ₊ → ℝ
+ x q = s (suc (fst (ics (ℚ₊→ℝ₊ q))))
+
+ y : (δ ε : ℚ₊) → x δ ∼[ δ ℚ₊+ ε ] x ε
+ y δ ε = invEq (∼≃abs<ε _ _ _)
+    (ww (ℕ.Dichotomyℕ δₙ εₙ) )
+  where
+  δₙ = fst (ics (ℚ₊→ℝ₊ δ))
+  εₙ = fst (ics (ℚ₊→ℝ₊ ε))
+
+  ww : _ ⊎ _ → absᵣ (x δ +ᵣ (-ᵣ x ε)) <ᵣ rat (fst (δ ℚ₊+ ε))
+  ww (inl δₙ≤εₙ) =
+   let z = snd (ics (ℚ₊→ℝ₊ δ)) (suc εₙ) (suc δₙ)
+              ℕ.≤-refl  (ℕ.suc-≤-suc δₙ≤εₙ )
+   in isTrans<ᵣ (absᵣ (x δ +ᵣ (-ᵣ x ε)))
+           (rat (fst (δ))) (rat (fst (δ ℚ₊+ ε)))
+           z (<ℚ→<ᵣ _ _ (ℚ.<+ℚ₊' (fst δ) (fst δ) ε (ℚ.isRefl≤ (fst δ))))
+  ww (inr εₙ<δₙ) =
+    let z = snd (ics (ℚ₊→ℝ₊ ε)) (suc εₙ) (suc δₙ)
+               (ℕ.≤-suc εₙ<δₙ) ℕ.≤-refl
+    in isTrans<ᵣ (absᵣ (x δ +ᵣ (-ᵣ x ε)))
+           (rat (fst (ε))) (rat (fst (δ ℚ₊+ ε)))
+           z ((<ℚ→<ᵣ _ _
+               (subst ((fst ε) ℚ.<_) (ℚ.+Comm _ _)
+               (ℚ.<+ℚ₊' (fst ε) (fst ε) δ (ℚ.isRefl≤ (fst ε))))))
+
+
+-- TODO HoTT 11.3.50.
+
+
+fromCauchySequence'-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 ε)
+
+  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 ε))))))
+
+
+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 ∈ ℕ ]
+    (∀ 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 ε)))
+
+
+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 ,
+         subst (fst ε ℚ.<_) (sym (ℚ.fromNat-^ _ _))
+          (ℚ.isTrans< _ _ (fromNat (2 ^ n))
+                  ((snd (ℚ.ceilℚ₊ ε)))
+                   (ℚ.<ℤ→<ℚ (ℤ.pos (ℕ₊₁→ℕ (fst (ℚ.ceilℚ₊ ε))))
+                     _ (ℤ.ℕ≤→pos-≤-pos  _ _
+                    (fst (snd (log2ℕ (ℕ₊₁→ℕ (fst (ℚ.ceilℚ₊ ε)))))))))
+
+
+1/2ⁿ<ε : (ε : ℚ₊) → Σ[ n ∈ ℕ ] [ 1 / 2 ] ℚ^ⁿ n ℚ.< fst ε
+1/2ⁿ<ε ε =
+ let (n , 1/ε<n) = ε<2ⁿ (invℚ₊ ε)
+ in n , invEq (ℚ.invℚ₊-<-invℚ₊ (([ 1 / 2 ] , _) ℚ₊^ⁿ n) ε)
+         (subst (fst (invℚ₊ ε) ℚ.<_)
+           (sym (ℚ.invℚ₊-ℚ^ⁿ ([ 1 / 2 ] , _) n)) 1/ε<n)
+
+
+
+
+ratio→seqLimit : ∀ (s : Seq) → (∀ n → Σ[ r ∈ ℚ ] (s n ≡ rat r))
+  → (sPos : ∀ n → rat 0 <ᵣ (s n))
+  → lim'ₙ→∞ (λ n →  s (suc n) ／ᵣ[ s n , inl ((sPos n)) ]) is 0
+  → lim'ₙ→∞ s is 0
+ratio→seqLimit s sRat sPos l (ε , 0<ε) =
+ (uncurry w)
+    (l ([ 1 / 2 ] , _))
+
+ where
+ 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
+ratioTest₊ : ∀ (s : Seq) → (sPos : ∀ n → rat 0 <ᵣ (s n))
+     → lim'ₙ→∞ s is 0
+     → (lim'ₙ→∞ (λ n →  s (suc n) ／ᵣ[ s n , inl ((sPos n)) ]) is 0)
+     → IsConvSeries' s
+ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) =
+  N , ww
+
+ where
+ ½ᵣ = (ℚ₊→ℝ₊ ([ 1 / 2 ] , _))
+ N½ = l ([ 1 / 2 ] , _)
+ ε/2 : ℚ₊
+ ε/2 = /2₊ ε₊
+
+ Nε = (l' ε/2)
+
+ N : ℕ
+ N = suc (ℕ.max (suc (fst N½)) (fst Nε))
+
+ ww : ∀ m n → absᵣ (seqΣ (λ x → s (x ℕ.+ (m ℕ.+ suc N))) n) <ᵣ (rat ε)
+ ww m n = isTrans≤<ᵣ _ _ _
+   (≡ᵣWeaken≤ᵣ _ _
+     (absᵣNonNeg (seqΣ (λ x → s (x ℕ.+ (m ℕ.+ suc N))) n)
+     (0≤seqΣ _ (λ n → <ᵣWeaken≤ᵣ _ _ (sPos (n ℕ.+ (m ℕ.+ suc N)))) _))) pp
+
+  where
+  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
+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' ∙ +ᵣ-rat _ _
+
+expSeqPos : ∀ x → 0 <ᵣ x → ∀ n → 0 <ᵣ expSeq x n
+expSeqPos x 0<x zero = decℚ<ᵣ?
+expSeqPos x 0<x (suc n) =
+ /nᵣ-pos (1+ n) _ (ℝ₊· (_ , expSeqPos x 0<x n) (_ , 0<x))
+
+limₙ→∞[expSeqRatio]=0 : ∀ x → ∀ (0<x : 0 ℚ.< x)  → lim'ₙ→∞
+      (λ n →
+         expSeq (rat x) (suc n) ／ᵣ[ expSeq (rat x) n ,
+         inl (expSeqPos (rat x) (<ℚ→<ᵣ 0 x 0<x) n) ])
+      is 0
+limₙ→∞[expSeqRatio]=0 x 0<x =
+  subst (lim'ₙ→∞_is 0)
+    (funExt (w (rat x) (<ℚ→<ᵣ 0 x 0<x)))
+    w'
+
+ where
+ 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
+limₙ→∞[expSeq]=0 x 0<x =
+  ratio→seqLimit _ (expSeq-rat x)
+      (expSeqPos (rat x) _) (limₙ→∞[expSeqRatio]=0 x 0<x)
+
+
+expSeriesConvergesAtℚ₊ : ∀ x → 0 ℚ.< x → IsConvSeries' (expSeq (rat x))
+expSeriesConvergesAtℚ₊ x 0<x =
+ ratioTest₊ (expSeq (rat x)) (expSeqPos (rat x) (<ℚ→<ᵣ _ _ 0<x))
+      (limₙ→∞[expSeq]=0 x  0<x)
+      (limₙ→∞[expSeqRatio]=0 x 0<x)
+
+expℚ₊ : ℚ₊ → ℝ
+expℚ₊ q = fromCauchySequence' _
+  (fst (IsConvSeries'≃IsCauchySequence'Sum (expSeq (rat (fst q))))
+    (expSeriesConvergesAtℚ₊ (fst q) (ℚ.0<ℚ₊ q)))
+
+
+expSeriesVal : ℕ → ℚ
+expSeriesVal n = fst (expSeries-rat 1 n)
+
+𝑒 : ℝ
+𝑒 = expℚ₊ 1
diff --git a/Cubical/HITs/PropositionalTruncation/Properties.agda b/Cubical/HITs/PropositionalTruncation/Properties.agda
index 7f143a450c..90337bddcd 100644
--- a/Cubical/HITs/PropositionalTruncation/Properties.agda
+++ b/Cubical/HITs/PropositionalTruncation/Properties.agda
@@ -25,7 +25,7 @@ open import Cubical.HITs.PropositionalTruncation.Base
 private
   variable
     ℓ ℓ' : Level
-    A B C : Type ℓ
+    A B C D : Type ℓ
     A′ : Type ℓ'
 
 ∥∥-isPropDep : (P : A → Type ℓ) → isOfHLevelDep 1 (λ x → ∥ P x ∥₁)
@@ -167,6 +167,9 @@ map f = rec squash₁ (∣_∣₁ ∘ f)
 map2 : (A → B → C) → (∥ A ∥₁ → ∥ B ∥₁ → ∥ C ∥₁)
 map2 f = rec (isPropΠ λ _ → squash₁) (map ∘ f)
 
+map3 : (A → B → C → D) → (∥ A ∥₁ → ∥ B ∥₁ → ∥ C ∥₁ → ∥ D ∥₁)
+map3 f = rec (isPropΠ2 λ _ _ → squash₁) (map2 ∘ f)
+
 -- The propositional truncation can be eliminated into non-propositional
 -- types as long as the function used in the eliminator is 'coherently
 -- constant.' The details of this can be found in the following paper:
diff --git a/Cubical/HITs/SetQuotients/Properties.agda b/Cubical/HITs/SetQuotients/Properties.agda
index f2327a424d..abee1c3f3c 100644
--- a/Cubical/HITs/SetQuotients/Properties.agda
+++ b/Cubical/HITs/SetQuotients/Properties.agda
@@ -351,3 +351,123 @@ descendMapPath f g isSetM path i x =
                         g x   ∎ })
     ([]surjective x)
     i
+
+
+
+record Rec {A : Type ℓ} {R : A → A → Type ℓ'} (B : Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isSetB : isSet B
+  f : A → B
+  f∼ : ∀ a a' → R a a' → f a ≡ f a'
+
+
+ go : _ / R → B
+ go [ a ] = f a
+ go (eq/ a a' r i) = f∼ a a' r i
+ go (squash/ x y p q i i₁) =
+   isSetB (go x) (go y) (cong go p) (cong go q) i i₁
+
+
+record Elim {A : Type ℓ} {R : A → A → Type ℓ'} (B : A / R →  Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isSetB : ∀ x → isSet (B x)
+  f : ∀ x → B [ x ]
+  f∼ : ∀ a a' → (r : R a a') → PathP (λ i → B (eq/ a a' r i)) (f a) (f a')
+
+
+ go : ∀ x → B x
+ go [ a ] = f a
+ go (eq/ a a' r i) = f∼ a a' r i
+ go (squash/ x y p q i i₁) =
+   isSet→SquareP
+     (λ i i₁ → (isSetB (squash/ x y p q i i₁)))
+     (cong go p) (cong go q) (λ _ → go x) (λ _ → go y)  i i₁
+
+record ElimProp {A : Type ℓ} {R : A → A → Type ℓ'} (B : A / R →  Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isPropB : ∀ x → isProp (B x)
+  f : ∀ x → B [ x ]
+
+ go : ∀ x → B x
+ go = Elim.go w
+  where
+  w : Elim B
+  w .Elim.isSetB = isProp→isSet ∘ isPropB
+  w .Elim.f = f
+  w .Elim.f∼ a a' r =
+    isProp→PathP (λ i → isPropB (eq/ a a' r i) ) _ _
+
+
+record Rec2 {A : Type ℓ} {R : A → A → Type ℓ'} (B : Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isSetB : isSet B
+  f : A → A → B
+  f∼ : ∀ x (a a' : A) → R a a' → f x a ≡ f x a'
+  ∼f : ∀ (a a' : A) x → R a a' → f a x ≡ f a' x
+
+
+
+ go : _ / R  → _ / R → B
+ go = Rec.go w
+  where
+  w : Rec {A = A} {R} (_ / R → B)
+  w .Rec.isSetB = isSet→ isSetB
+  w .Rec.f x = Rec.go w'
+     where
+      w' : Rec _
+      w' .Rec.isSetB = isSetB
+      w' .Rec.f x' = f x x'
+      w' .Rec.f∼ = f∼ x
+  w .Rec.f∼ a a' r = funExt
+    (ElimProp.go w')
+   where
+   w' : ElimProp _
+   w' .ElimProp.isPropB _ = isSetB _ _
+   w' .ElimProp.f x = ∼f a a' x r
+
+
+record ElimProp2 {A : Type ℓ} {R : A → A → Type ℓ'} (B : A / R → A / R →  Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isPropB : ∀ x y → isProp (B x y)
+  f : ∀ x y → B [ x ] [ y ]
+
+ go : ∀ x y → B x y
+ go = ElimProp.go w
+  where
+  w : ElimProp (λ z → (y : A / R) → B z y)
+  w .ElimProp.isPropB _ = isPropΠ λ _ → isPropB _ _
+  w .ElimProp.f x = ElimProp.go w'
+   where
+   w' : ElimProp (λ z → B [ x ] z)
+   w' .ElimProp.isPropB _ = isPropB _ _
+   w' .ElimProp.f = f x
+
+
+record ElimProp3 {A : Type ℓ} {R : A → A → Type ℓ'}
+        (B : A / R → A / R → A / R →  Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isPropB : ∀ x y z → isProp (B x y z)
+  f : ∀ x y z → B [ x ] [ y ] [ z ]
+
+ go : ∀ x y z → B x y z
+ go = ElimProp2.go w
+  where
+  w : ElimProp2 (λ z z₁ → (z₂ : A / R) → B z z₁ z₂)
+  w .ElimProp2.isPropB _ _ = isPropΠ λ _ → isPropB _ _ _
+  w .ElimProp2.f x y = ElimProp.go w'
+   where
+   w' : ElimProp (λ z → B [ x ] [ y ] z)
+   w' .ElimProp.isPropB _ = isPropB _ _ _
+   w' .ElimProp.f = f x y