diff --git a/Cubical/Algebra/CommMonoid/Properties.agda b/Cubical/Algebra/CommMonoid/Properties.agda
index 4926c3dc0b..c6e7ec1b9e 100644
--- a/Cubical/Algebra/CommMonoid/Properties.agda
+++ b/Cubical/Algebra/CommMonoid/Properties.agda
@@ -57,3 +57,19 @@ module CommMonoidTheory (M' : CommMonoid ℓ) where
  commAssocSwap : (x y z w : M) → (x · y) · (z · w) ≡ (x · z) · (y · w)
  commAssocSwap x y z w = ·Assoc (x · y) z w ∙∙ cong (_· w) (commAssocr x y z)
                                                ∙∙ sym (·Assoc (x · z) y w)
+
+ hasInverse : (x : M) → Type ℓ
+ hasInverse x = Σ[ -x ∈ M ] -x · x ≡ ε
+
+ isPropHasInverse : ∀ x → isProp (hasInverse x)
+ isPropHasInverse x yinv zinv
+   = Σ≡Prop (λ a → is-set (a · x) ε)
+    (PathPΣ (MonoidTheory.isPropHasInverse (CommMonoid→Monoid M') x
+                                           (hasInverseToMonoid x yinv)
+                                           (hasInverseToMonoid x zinv))
+                                               .fst)
+   where
+     hasInverseToMonoid : ∀ x
+                        → hasInverse x
+                        → MonoidTheory.hasInverse (CommMonoid→Monoid M') x
+     hasInverseToMonoid x (y , yinv) = y , yinv , ·Comm x y ∙ yinv
diff --git a/Cubical/Algebra/DistLattice/Downset.agda b/Cubical/Algebra/DistLattice/Downset.agda
index 907c419732..3c52245edf 100644
--- a/Cubical/Algebra/DistLattice/Downset.agda
+++ b/Cubical/Algebra/DistLattice/Downset.agda
@@ -16,6 +16,7 @@ open import Cubical.Algebra.Lattice
 open import Cubical.Algebra.DistLattice.Base
 
 open import Cubical.Relation.Binary.Order.Poset
+open import Cubical.Relation.Binary.Order.Poset.Subset
 
 open Iso
 
diff --git a/Cubical/Algebra/Monoid/Base.agda b/Cubical/Algebra/Monoid/Base.agda
index dbf68fb538..27491a8937 100644
--- a/Cubical/Algebra/Monoid/Base.agda
+++ b/Cubical/Algebra/Monoid/Base.agda
@@ -140,3 +140,13 @@ module MonoidTheory {ℓ} (M : Monoid ℓ) where
     (y · x) · z ≡⟨ congL _·_ left-inverse ⟩
     ε · z       ≡⟨ ·IdL z ⟩
     z ∎
+
+  -- Added for its use in division rings
+  hasInverse : (x : ⟨ M ⟩) → Type ℓ
+  hasInverse x = Σ[ -x ∈ ⟨ M ⟩ ] (-x · x ≡ ε) × (x · -x ≡ ε)
+
+  isPropHasInverse : ∀ x → isProp (hasInverse x)
+  isPropHasInverse x (y , invly , _) (z , _ , invrz)
+    = Σ≡Prop (λ a → isProp× (is-set (a · x) ε)
+                             (is-set (x · a) ε))
+              (inv-lemma x y z invly invrz)
diff --git a/Cubical/AlgebraicGeometry/ZariskiLattice/Properties.agda b/Cubical/AlgebraicGeometry/ZariskiLattice/Properties.agda
index f2dc3d1f52..5427849bf4 100644
--- a/Cubical/AlgebraicGeometry/ZariskiLattice/Properties.agda
+++ b/Cubical/AlgebraicGeometry/ZariskiLattice/Properties.agda
@@ -13,6 +13,7 @@ open import Cubical.Data.Nat using (ℕ)
 open import Cubical.Data.Sigma.Properties
 open import Cubical.Data.FinData
 open import Cubical.Relation.Binary.Order.Poset
+open import Cubical.Relation.Binary.Order.Poset.Subset
 
 open import Cubical.Algebra.CommRing
 open import Cubical.Algebra.CommRing.Localisation
diff --git a/Cubical/Categories/Constructions/SubObject.agda b/Cubical/Categories/Constructions/SubObject.agda
index 2a5040bd49..2e94416488 100644
--- a/Cubical/Categories/Constructions/SubObject.agda
+++ b/Cubical/Categories/Constructions/SubObject.agda
@@ -11,7 +11,7 @@ open import Cubical.Categories.Category
 open import Cubical.Categories.Functor
 open import Cubical.Categories.Morphism
 
-open import Cubical.Relation.Binary.Order.Preorder
+open import Cubical.Relation.Binary.Order.Proset
 
 open Category
 
@@ -83,9 +83,9 @@ SliceHom.S-comm
     ∎
 
 module _ (isSetCOb : isSet (C .ob)) where
-  subObjCatPreorderStr : PreorderStr _ (SubObjCat .ob)
-  PreorderStr._≲_ subObjCatPreorderStr x y = SubObjCat [ x , y ]
-  IsPreorder.is-set (PreorderStr.isPreorder subObjCatPreorderStr) = isSetΣ (isSetSliceOb isSetCOb) λ x → isProp→isSet (∈-isProp isSubObj x)
-  IsPreorder.is-prop-valued (PreorderStr.isPreorder subObjCatPreorderStr) = isPropSubObjMor
-  IsPreorder.is-refl (PreorderStr.isPreorder subObjCatPreorderStr) = isReflSubObjMor
-  IsPreorder.is-trans (PreorderStr.isPreorder subObjCatPreorderStr) = isTransSubObjMor
+  subObjCatPreorderStr : ProsetStr _ (SubObjCat .ob)
+  ProsetStr._≲_ subObjCatPreorderStr x y = SubObjCat [ x , y ]
+  IsProset.is-set (ProsetStr.isProset subObjCatPreorderStr) = isSetΣ (isSetSliceOb isSetCOb) λ x → isProp→isSet (∈-isProp isSubObj x)
+  IsProset.is-prop-valued (ProsetStr.isProset subObjCatPreorderStr) = isPropSubObjMor
+  IsProset.is-refl (ProsetStr.isProset subObjCatPreorderStr) = isReflSubObjMor
+  IsProset.is-trans (ProsetStr.isProset subObjCatPreorderStr) = isTransSubObjMor
diff --git a/Cubical/Data/Cardinal/Properties.agda b/Cubical/Data/Cardinal/Properties.agda
index 1c7371cf0c..d4041dafed 100644
--- a/Cubical/Data/Cardinal/Properties.agda
+++ b/Cubical/Data/Cardinal/Properties.agda
@@ -25,8 +25,7 @@ open import Cubical.Data.Sum as ⊎
 open import Cubical.Data.Unit
 open import Cubical.HITs.PropositionalTruncation as ∥₁
 open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Preorder.Base
-open import Cubical.Relation.Binary.Order.Properties
+open import Cubical.Relation.Binary.Order.Proset
 
 private
   variable
@@ -171,9 +170,9 @@ module _ where
              λ (A , _) (B , _) (C , _)
                → ∥₁.map2 λ A↪B B↪C → compEmbedding B↪C A↪B
 
-  isPreorder≲ : IsPreorder {ℓ-suc ℓ} _≲_
+  isPreorder≲ : IsProset {ℓ-suc ℓ} _≲_
   isPreorder≲
-    = ispreorder isSetCard isPropValued≲ isRefl≲ isTrans≲
+    = isproset isSetCard isPropValued≲ isRefl≲ isTrans≲
 
 isLeast𝟘 : ∀{ℓ} → isLeast isPreorder≲ (Card {ℓ} , id↪ (Card {ℓ})) (𝟘 {ℓ})
 isLeast𝟘 = ∥₂.elim (λ x → isProp→isSet (isPropValued≲ 𝟘 x))
diff --git a/Cubical/Data/Ordinal/Properties.agda b/Cubical/Data/Ordinal/Properties.agda
index 0cfbd9d98c..f4ea61dd03 100644
--- a/Cubical/Data/Ordinal/Properties.agda
+++ b/Cubical/Data/Ordinal/Properties.agda
@@ -60,7 +60,7 @@ propOrd {ℓ} P prop = P , (wosetstr _<_ (iswoset set prp well weak trans))
 𝟘 {ℓ} = propOrd (⊥* {ℓ}) (isProp⊥*)
 𝟙 {ℓ} = propOrd (Unit* {ℓ}) (isPropUnit*)
 
-isLeast𝟘 : ∀{ℓ} → isLeast (isPoset→isPreorder isPoset≼) ((Ord {ℓ}) , (id↪ (Ord {ℓ}))) (𝟘 {ℓ})
+isLeast𝟘 : ∀{ℓ} → isLeast (isPoset→isProset isPoset≼) ((Ord {ℓ}) , (id↪ (Ord {ℓ}))) (𝟘 {ℓ})
 isLeast𝟘 _ = ⊥.elim* , (⊥.elim* , ⊥.elim*)
 
 -- The successor of 𝟘 is 𝟙
@@ -144,8 +144,8 @@ suc≺ α = (inr tt*) , (eq , makeIsWosetEquiv eq eqsucα eqαsuc)
     eq = isoToEquiv rUnit*×Iso
 
     eqα𝟙 : _
-    eqα𝟙 (x , _) (y , _) (inl tt≺tt) = ⊥.rec (IsStrictPoset.is-irrefl
-                                                (isWoset→isStrictPoset
+    eqα𝟙 (x , _) (y , _) (inl tt≺tt) = ⊥.rec (IsQuoset.is-irrefl
+                                                (isWoset→isQuoset
                                                    (WosetStr.isWoset (str 𝟙)))
                                                tt* tt≺tt)
     eqα𝟙 (x , _) (y , _) (inr (_ , x≺y)) = x≺y
@@ -161,8 +161,8 @@ suc≺ α = (inr tt*) , (eq , makeIsWosetEquiv eq eqsucα eqαsuc)
 
     eq𝟙α : _
     eq𝟙α (_ , x) (_ , y) (inr (_ , tt≺tt)) = ⊥.rec
-                                               (IsStrictPoset.is-irrefl
-                                                (isWoset→isStrictPoset
+                                               (IsQuoset.is-irrefl
+                                                (isWoset→isQuoset
                                                   (WosetStr.isWoset (str 𝟙)))
                                                 tt* tt≺tt)
     eq𝟙α (_ , x) (_ , y) (inl x≺y) = x≺y
diff --git a/Cubical/Data/Rationals/Order.agda b/Cubical/Data/Rationals/Order.agda
index a18910dbec..0136e99319 100644
--- a/Cubical/Data/Rationals/Order.agda
+++ b/Cubical/Data/Rationals/Order.agda
@@ -216,8 +216,8 @@ module _ where
   isAsym< : isAsym _<_
   isAsym< = isIrrefl×isTrans→isAsym _<_ (isIrrefl< , isTrans<)
 
-  isStronglyConnected≤ : isStronglyConnected _≤_
-  isStronglyConnected≤ =
+  isTotal≤ : isTotal _≤_
+  isTotal≤ =
     elimProp2 {P = λ a b → (a ≤ b) ⊔′ (b ≤ a)}
               (λ _ _ → isPropPropTrunc)
                λ a b → ∣ lem a b ∣₁
@@ -230,12 +230,34 @@ module _ where
 
   isConnected< : isConnected _<_
   isConnected< =
-    elimProp2 {P = λ a b → ¬ a ≡ b → (a < b) ⊔′ (b < a)}
-              (λ _ _ → isProp→ isPropPropTrunc)
-               λ a b ¬a≡b → ∣ lem a b ¬a≡b ∣₁
+    elimProp2 {P = λ a b → (¬ a < b) × (¬ b < a) → a ≡ b}
+              (λ a b → isProp→ (isSetℚ a b))
+               lem
     where
-      -- Agda can't infer the relation involved, so the signature looks a bit weird here
-      lem : (a b : ℤ.ℤ × ℕ₊₁) → ¬ [_] {R = _∼_} a ≡ [ b ] → ([ a ] < [ b ]) ⊎ ([ b ] < [ a ])
+      lem : (a b : ℤ.ℤ × ℕ₊₁) → (¬ [ a ] < [ b ]) × (¬ [ b ] < [ a ]) → [ a ] ≡ [ b ]
+      lem (a , b) (c , d) (¬ad<cb , ¬cb<ad) with (a ℤ.· ℕ₊₁→ℤ d) ℤ.≟ (c ℤ.· ℕ₊₁→ℤ b)
+      ... | ℤ.lt ad<cb = ⊥.rec (¬ad<cb ad<cb)
+      ... | ℤ.eq ad≡cb = eq/ (a , b) (c , d) ad≡cb
+      ... | ℤ.gt cb<ad = ⊥.rec (¬cb<ad cb<ad)
+
+  isProp# : isPropValued _#_
+  isProp# x y = isProp⊎ (isProp< x y) (isProp< y x) (isAsym< x y)
+
+  isIrrefl# : isIrrefl _#_
+  isIrrefl# x (inl x<x) = isIrrefl< x x<x
+  isIrrefl# x (inr x<x) = isIrrefl< x x<x
+
+  isSym# : isSym _#_
+  isSym# _ _ (inl x<y) = inr x<y
+  isSym# _ _ (inr y<x) = inl y<x
+
+  inequalityImplies# : inequalityImplies _#_
+  inequalityImplies#
+    = elimProp2 {P = λ a b → ¬ a ≡ b → a # b}
+                (λ a b → isProp→ (isProp# a b))
+                 lem
+    where
+      lem : (a b : ℤ.ℤ × ℕ₊₁) → ¬ [_] {R = _∼_} a ≡ [ b ] → [ a ] # [ b ]
       lem (a , b) (c , d) ¬a≡b with (a ℤ.· ℕ₊₁→ℤ d) ℤ.≟ (c ℤ.· ℕ₊₁→ℤ b)
       ... | ℤ.lt ad<cb = inl ad<cb
       ... | ℤ.eq ad≡cb = ⊥.rec (¬a≡b (eq/ (a , b) (c , d) ad≡cb))
@@ -250,20 +272,9 @@ module _ where
       lem : (a b c : ℤ.ℤ × ℕ₊₁) → [ a ] < [ b ] → ([ a ] < [ c ]) ⊔′ ([ c ] < [ b ])
       lem a b c a<b with discreteℚ [ a ] [ c ]
       ... | yes a≡c = ∣ inr (subst (_< [ b ]) a≡c a<b) ∣₁
-      ... | no a≢c = ∥₁.map (⊎.map (λ a<c → a<c)
-                                    (λ c<a → isTrans< [ c ] [ a ] [ b ] c<a a<b))
-                             (isConnected< [ a ] [ c ] a≢c)
-
-  isProp# : isPropValued _#_
-  isProp# x y = isProp⊎ (isProp< x y) (isProp< y x) (isAsym< x y)
-
-  isIrrefl# : isIrrefl _#_
-  isIrrefl# x (inl x<x) = isIrrefl< x x<x
-  isIrrefl# x (inr x<x) = isIrrefl< x x<x
-
-  isSym# : isSym _#_
-  isSym# _ _ (inl x<y) = inr x<y
-  isSym# _ _ (inr y<x) = inl y<x
+      ... | no a≢c = ∣ ⊎.map (λ a<c → a<c)
+                             (λ c<a → isTrans< [ c ] [ a ] [ b ] c<a a<b)
+                             (inequalityImplies# [ a ] [ c ] a≢c) ∣₁
 
   isCotrans# : isCotrans _#_
   isCotrans#
@@ -274,10 +285,7 @@ module _ where
         lem : (a b c : ℤ.ℤ × ℕ₊₁) → [ a ] # [ b ] → ([ a ] # [ c ]) ⊔′ ([ b ] # [ c ])
         lem a b c a#b with discreteℚ [ b ] [ c ]
         ... | yes b≡c = ∣ inl (subst ([ a ] #_) b≡c a#b) ∣₁
-        ... | no  b≢c = ∥₁.map inr (isConnected< [ b ] [ c ] b≢c)
-
-  inequalityImplies# : inequalityImplies _#_
-  inequalityImplies# a b = ∥₁.rec (isProp# a b) (λ a#b → a#b) ∘ (isConnected< a b)
+        ... | no  b≢c = ∣ inr (inequalityImplies# [ b ] [ c ] b≢c) ∣₁
 
 ≤-+o : ∀ m n o → m ≤ n → m ℚ.+ o ≤ n ℚ.+ o
 ≤-+o =
@@ -614,7 +622,7 @@ m ≟ n with discreteℚ m n
 ... | yes m≡n = ≡Weaken≤ n m (sym m≡n)
 ... | no  m≢n = ∥₁.elim (λ _ → isProp≤ n m)
                         (⊎.rec (⊥.rec ∘ m≮n) (<Weaken≤ n m))
-                        (isConnected< m n m≢n)
+                         ∣ inequalityImplies# m n m≢n ∣₁
 
 0<+ : ∀ m n → 0 < m ℚ.+ n → (0 < m) ⊎ (0 < n)
 0<+ m n 0<m+n with <Dec 0 m | <Dec 0 n
diff --git a/Cubical/Foundations/Transport.agda b/Cubical/Foundations/Transport.agda
index 341dc68535..8d1051793f 100644
--- a/Cubical/Foundations/Transport.agda
+++ b/Cubical/Foundations/Transport.agda
@@ -74,6 +74,10 @@ substSubst⁻ {x = x} {y = y} B p v = transportTransport⁻ {A = B x} {B = B y}
 substEquiv : ∀ {ℓ ℓ'} {A : Type ℓ} {a a' : A} (P : A → Type ℓ') (p : a ≡ a') → P a ≃ P a'
 substEquiv P p = (subst P p , isEquivTransport (λ i → P (p i)))
 
+subst2Equiv : ∀ {ℓ ℓ' ℓ''} {A : Type ℓ} {B : Type ℓ'} {a a' : A} {b b' : B} (P : A → B → Type ℓ'')
+            (p : a ≡ a') (q : b ≡ b') → P a b ≃ P a' b'
+subst2Equiv P p q = (subst2 P p q , isEquivTransport (λ i → P (p i) (q i)))
+
 liftEquiv : ∀ {ℓ ℓ'} {A B : Type ℓ} (P : Type ℓ → Type ℓ') (e : A ≃ B) → P A ≃ P B
 liftEquiv P e = substEquiv P (ua e)
 
diff --git a/Cubical/Functions/Embedding.agda b/Cubical/Functions/Embedding.agda
index 3453a3fe57..e24518519f 100644
--- a/Cubical/Functions/Embedding.agda
+++ b/Cubical/Functions/Embedding.agda
@@ -15,7 +15,10 @@ open import Cubical.Foundations.Transport
 open import Cubical.Foundations.Univalence using (ua; univalence; pathToEquiv)
 open import Cubical.Functions.Fibration
 
+open import Cubical.HITs.PropositionalTruncation.Base
+
 open import Cubical.Data.Sigma
+open import Cubical.Data.Sum.Base
 open import Cubical.Functions.Fibration
 open import Cubical.Functions.FunExtEquiv
 open import Cubical.Relation.Nullary using (Discrete; yes; no)
@@ -24,11 +27,10 @@ open import Cubical.Structures.Axioms
 open import Cubical.Reflection.StrictEquiv
 
 open import Cubical.Data.Nat using (ℕ; zero; suc)
-open import Cubical.Data.Sigma
 
 private
   variable
-    ℓ ℓ' ℓ'' : Level
+    ℓ ℓ' ℓ'' ℓ''' : Level
     A B C : Type ℓ
     f h : A → B
     w x : A
@@ -430,6 +432,14 @@ _≃Emb_ = EmbeddingIdentityPrinciple.f≃g
 EmbeddingIP : {B : Type ℓ} (f g : Embedding B ℓ') → f ≃Emb g ≃ (f ≡ g)
 EmbeddingIP = EmbeddingIdentityPrinciple.EmbeddingIP
 
+-- Using the above, we can show that the collection of embeddings forms a set
+isSetEmbedding : {B : Type ℓ} {ℓ' : Level} → isSet (Embedding B ℓ')
+isSetEmbedding M N
+  = isOfHLevelRespectEquiv 1
+      (EmbeddingIP M N)
+      (isProp× (isPropΠ2 (λ b _ → isEmbedding→hasPropFibers (N .snd .snd) b))
+               (isPropΠ2  λ b _ → isEmbedding→hasPropFibers (M .snd .snd) b))
+
 -- Cantor's theorem for sets
 Set-Embedding-into-Powerset : {A : Type ℓ} → isSet A → A ↪ ℙ A
 Set-Embedding-into-Powerset {A = A} setA
@@ -462,3 +472,65 @@ Set-Embedding-into-Powerset {A = A} setA
 
 EmbeddingΣProp : {A : Type ℓ} → {B : A → Type ℓ'} → (∀ a → isProp (B a)) → Σ A B ↪ A
 EmbeddingΣProp f = fst , (λ _ _ → isEmbeddingFstΣProp f)
+
+-- Since embeddings are equivalent to subsets, we can create some notation around this
+_∈ₑ_ : {A : Type ℓ} → A → Embedding A ℓ' → Type (ℓ-max ℓ ℓ')
+x ∈ₑ (_ , (f , _)) = fiber f x
+
+isProp∈ₑ : {A : Type ℓ} (x : A) (S : Embedding A ℓ') → isProp (x ∈ₑ S)
+isProp∈ₑ x S = isEmbedding→hasPropFibers (S .snd .snd) x
+
+_⊆ₑ_ : {A : Type ℓ} → Embedding A ℓ' → Embedding A ℓ'' → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+X ⊆ₑ Y = ∀ x → x ∈ₑ X → x ∈ₑ Y
+
+isProp⊆ₑ : {A : Type ℓ} (X : Embedding A ℓ') (Y : Embedding A ℓ'')
+         → isProp (X ⊆ₑ Y)
+isProp⊆ₑ _ Y = isPropΠ2 λ x _ → isProp∈ₑ x Y
+
+isRefl⊆ₑ : {A : Type ℓ} → (S : Embedding A ℓ') → S ⊆ₑ S
+isRefl⊆ₑ S x x∈S = x∈S
+
+isAntisym⊆ₑ : {A : Type ℓ}
+             (X Y : Embedding A ℓ')
+            → X ⊆ₑ Y
+            → Y ⊆ₑ X
+            → X ≡ Y
+isAntisym⊆ₑ X Y X⊆Y Y⊆X = equivFun (EmbeddingIP X Y) (X⊆Y , Y⊆X)
+
+isTrans⊆ₑ : {A : Type ℓ}
+            (X : Embedding A ℓ')
+            (Y : Embedding A ℓ'')
+            (Z : Embedding A ℓ''')
+          → X ⊆ₑ Y
+          → Y ⊆ₑ Z
+          → X ⊆ₑ Z
+isTrans⊆ₑ X Y Z X⊆Y Y⊆Z x = (Y⊆Z x) ∘ (X⊆Y x)
+
+_∩ₑ_ : {A : Type ℓ}
+       (X : Embedding A ℓ')
+       (Y : Embedding A ℓ'')
+     → Embedding A (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+_∩ₑ_ {A = A} X Y = (Σ[ x ∈ A ] x ∈ₑ X × x ∈ₑ Y) ,
+                    EmbeddingΣProp λ x → isProp× (isProp∈ₑ x X)
+                                                 (isProp∈ₑ x Y)
+
+_∪ₑ_ : {A : Type ℓ}
+       (X : Embedding A ℓ')
+       (Y : Embedding A ℓ'')
+     → Embedding A (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+_∪ₑ_ {A = A} X Y = (Σ[ x ∈ A ] ∥ (x ∈ₑ X) ⊎ (x ∈ₑ Y) ∥₁) ,
+                    EmbeddingΣProp λ _ → squash₁
+
+⋂ₑ_ : {A : Type ℓ}
+      {I : Type ℓ'}
+      (P : I → Embedding A ℓ'')
+     → Embedding A (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+⋂ₑ_ {A = A} P = (Σ[ x ∈ A ] (∀ i → x ∈ₑ P i)) ,
+                EmbeddingΣProp λ x → isPropΠ λ i → isProp∈ₑ x (P i)
+
+⋃ₑ_ : {A : Type ℓ}
+      {I : Type ℓ'}
+      (P : I → Embedding A ℓ'')
+    → Embedding A (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+⋃ₑ_ {A = A} {I = I} P = (Σ[ x ∈ A ] (∃[ i ∈ I ] x ∈ₑ P i)) ,
+                        EmbeddingΣProp λ _ → squash₁
diff --git a/Cubical/Functions/Image.agda b/Cubical/Functions/Image.agda
index d975748b03..42cb61ebce 100644
--- a/Cubical/Functions/Image.agda
+++ b/Cubical/Functions/Image.agda
@@ -30,12 +30,7 @@ module _ (f : A → B) where
   Image = Σ[ y ∈ B ] isInImage y
 
   imageInclusion : Image ↪ B
-  imageInclusion = fst ,
-    hasPropFibers→isEmbedding {f = fst}
-      λ y → isOfHLevelRetractFromIso 1 (ϕ y) isPropPropTrunc
-      where
-        ϕ : (y : B) → Iso _ _
-        ϕ y = invIso (fiberProjIso B isInImage y)
+  imageInclusion = EmbeddingΣProp isPropIsInImage
 
   restrictToImage : A → Image
   restrictToImage x = (f x) , ∣ x , refl ∣₁
diff --git a/Cubical/Functions/Preimage.agda b/Cubical/Functions/Preimage.agda
new file mode 100644
index 0000000000..cdb81437af
--- /dev/null
+++ b/Cubical/Functions/Preimage.agda
@@ -0,0 +1,58 @@
+{-# OPTIONS --safe #-}
+module Cubical.Functions.Preimage where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Equiv.Fiberwise
+open import Cubical.Foundations.Powerset
+
+open import Cubical.Functions.Embedding
+open import Cubical.Functions.Image
+open import Cubical.Functions.Surjection
+
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+private
+  variable
+    ℓ ℓ' : Level
+    A B : Type ℓ
+
+module _ (f : A → B)
+         ((S , (g , emb)) : Embedding B ℓ')
+         where
+           isInPreimage : A → Type _
+           isInPreimage x = isInImage g (f x)
+
+           isPropIsInPreimage : ∀ x → isProp (isInPreimage x)
+           isPropIsInPreimage x = isPropIsInImage g (f x)
+
+           Preimage : Type _
+           Preimage = Σ[ x ∈ A ] isInPreimage x
+
+           preimageInclusion : Preimage ↪ A
+           preimageInclusion = EmbeddingΣProp isPropIsInPreimage
+
+           restrictToPreimage : Preimage → S
+           restrictToPreimage (x , im) = lemma (f x) im .fst
+             where lemma : ∀ y → isInImage g y
+                         → fiber g y
+                   lemma y = ∥₁.rec (isEmbedding→hasPropFibers emb y) λ fib → fib
+
+-- Some notation
+_⃖_ : (A → B) → (Embedding B ℓ') → Embedding A _
+f ⃖ S = Preimage f S , preimageInclusion f S
+
+PreimageOfImage : {A B : Type ℓ}
+                  (f : A → B)
+                → Preimage f (Image f , imageInclusion f) ≡ A
+PreimageOfImage {A = A} {B = B} f = isoToPath is
+  where is : Iso (Preimage f (Image f , imageInclusion f)) A
+        Iso.fun is = fst
+        Iso.inv is a = a , ∣ ((f a) , ∣ a , refl ∣₁) , refl ∣₁
+        Iso.rightInv is x = refl
+        Iso.leftInv is  x = Σ≡Prop (isPropIsInPreimage f (Image f , imageInclusion f)) refl
diff --git a/Cubical/Relation/Binary/Base.agda b/Cubical/Relation/Binary/Base.agda
index 07d31701af..b6e658f74b 100644
--- a/Cubical/Relation/Binary/Base.agda
+++ b/Cubical/Relation/Binary/Base.agda
@@ -77,19 +77,16 @@ module BinaryRelation {ℓ ℓ' : Level} {A : Type ℓ} (R : Rel A A ℓ') where
 
   -- Sum types don't play nicely with props, so we truncate
   isCotrans : Type (ℓ-max ℓ ℓ')
-  isCotrans = (a b c : A) → R a b → (R a c ⊔′ R b c)
+  isCotrans = (a b c : A) → R a b → R a c ⊔′ R b c
 
   isWeaklyLinear : Type (ℓ-max ℓ ℓ')
   isWeaklyLinear = (a b c : A) → R a b → R a c ⊔′ R c b
 
   isConnected : Type (ℓ-max ℓ ℓ')
-  isConnected = (a b : A) → ¬ (a ≡ b) → R a b ⊔′ R b a
+  isConnected = (a b : A) → (¬ R a b) × (¬ R b a) → a ≡ b
 
-  isStronglyConnected : Type (ℓ-max ℓ ℓ')
-  isStronglyConnected = (a b : A) → R a b ⊔′ R b a
-
-  isStronglyConnected→isConnected : isStronglyConnected → isConnected
-  isStronglyConnected→isConnected strong a b _ = strong a b
+  isTotal : Type (ℓ-max ℓ ℓ')
+  isTotal = (a b : A) → R a b ⊔′ R b a
 
   isIrrefl×isTrans→isAsym : isIrrefl × isTrans → isAsym
   isIrrefl×isTrans→isAsym (irrefl , trans) a₀ a₁ Ra₀a₁ Ra₁a₀
@@ -98,6 +95,9 @@ module BinaryRelation {ℓ ℓ' : Level} {A : Type ℓ} (R : Rel A A ℓ') where
   WellFounded→isIrrefl : WellFounded R → isIrrefl
   WellFounded→isIrrefl well = WFI.induction well λ a f Raa → f a Raa Raa
 
+  isAsym→isIrrefl : isAsym → isIrrefl
+  isAsym→isIrrefl asym a Raa = asym a a Raa Raa
+
   IrreflKernel : Rel A A (ℓ-max ℓ ℓ')
   IrreflKernel a b = R a b × (¬ a ≡ b)
 
@@ -116,6 +116,9 @@ module BinaryRelation {ℓ ℓ' : Level} {A : Type ℓ} (R : Rel A A ℓ') where
   NegationRel : Rel A A ℓ'
   NegationRel a b = ¬ (R a b)
 
+  Dual : Rel A A ℓ'
+  Dual a b = R b a
+
   module _
     {ℓ'' : Level}
     (P : Embedding A ℓ'')
@@ -154,10 +157,15 @@ module BinaryRelation {ℓ ℓ' : Level} {A : Type ℓ} (R : Rel A A ℓ') where
   isEffective =
     (a b : A) → isEquiv (eq/ {R = R} a b)
 
+  isDecidable : Type (ℓ-max ℓ ℓ')
+  isDecidable = (a b : A) → Dec (R a b)
 
   impliesIdentity : Type _
   impliesIdentity = {a a' : A} → (R a a') → (a ≡ a')
 
+  isTight : Type _
+  isTight = (a b : A) → ¬ R a b → a ≡ b
+
   inequalityImplies : Type _
   inequalityImplies = (a b : A) → ¬ a ≡ b → R a b
 
@@ -241,14 +249,6 @@ isIrreflIrreflKernel _ _ (_ , ¬a≡a) = ¬a≡a refl
 isReflReflClosure : ∀{ℓ ℓ'} {A : Type ℓ} (R : Rel A A ℓ') → isRefl (ReflClosure R)
 isReflReflClosure _ _ = inr refl
 
-isConnectedStronglyConnectedIrreflKernel : ∀{ℓ ℓ'} {A : Type ℓ} (R : Rel A A ℓ')
-                                         → isStronglyConnected R
-                                         → isConnected (IrreflKernel R)
-isConnectedStronglyConnectedIrreflKernel R strong a b ¬a≡b
-  = ∥₁.map (λ x → ⊎.rec (λ Rab → inl (Rab , ¬a≡b))
-                        (λ Rba → inr (Rba , (λ b≡a → ¬a≡b (sym b≡a)))) x)
-                        (strong a b)
-
 isSymSymKernel : ∀{ℓ ℓ'} {A : Type ℓ} (R : Rel A A ℓ') → isSym (SymKernel R)
 isSymSymKernel _ _ _ (Rab , Rba) = Rba , Rab
 
diff --git a/Cubical/Relation/Binary/Order.agda b/Cubical/Relation/Binary/Order.agda
index 9c15bb7931..7b777b96d8 100644
--- a/Cubical/Relation/Binary/Order.agda
+++ b/Cubical/Relation/Binary/Order.agda
@@ -2,9 +2,9 @@
 module Cubical.Relation.Binary.Order where
 
 open import Cubical.Relation.Binary.Order.Apartness public
-open import Cubical.Relation.Binary.Order.Preorder public
+open import Cubical.Relation.Binary.Order.Proset public
 open import Cubical.Relation.Binary.Order.Poset public
 open import Cubical.Relation.Binary.Order.Toset public
-open import Cubical.Relation.Binary.Order.StrictPoset public
+open import Cubical.Relation.Binary.Order.Quoset public
+open import Cubical.Relation.Binary.Order.StrictOrder public
 open import Cubical.Relation.Binary.Order.Loset public
-open import Cubical.Relation.Binary.Order.Properties public
diff --git a/Cubical/Relation/Binary/Order/Apartness/Base.agda b/Cubical/Relation/Binary/Order/Apartness/Base.agda
index 35dc95528f..5801016a17 100644
--- a/Cubical/Relation/Binary/Order/Apartness/Base.agda
+++ b/Cubical/Relation/Binary/Order/Apartness/Base.agda
@@ -66,8 +66,8 @@ record ApartnessStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc 
 Apartness : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
 Apartness ℓ ℓ' = TypeWithStr ℓ (ApartnessStr ℓ')
 
-apartness : (A : Type ℓ) (_#_ : A → A → Type ℓ') (h : IsApartness _#_) → Apartness ℓ ℓ'
-apartness A _#_ h = A , apartnessstr _#_ h
+apartness : (A : Type ℓ) → (_#_ : Rel A A ℓ') → IsApartness _#_ → Apartness ℓ ℓ'
+apartness A _#_ apart = A , (apartnessstr _#_ apart)
 
 record IsApartnessEquiv {A : Type ℓ₀} {B : Type ℓ₁}
   (M : ApartnessStr ℓ₀' A) (e : A ≃ B) (N : ApartnessStr ℓ₁' B)
diff --git a/Cubical/Relation/Binary/Order/Apartness/Properties.agda b/Cubical/Relation/Binary/Order/Apartness/Properties.agda
index 77f24ce04f..c82e5d77fc 100644
--- a/Cubical/Relation/Binary/Order/Apartness/Properties.agda
+++ b/Cubical/Relation/Binary/Order/Apartness/Properties.agda
@@ -1,6 +1,7 @@
 {-# OPTIONS --safe #-}
 module Cubical.Relation.Binary.Order.Apartness.Properties where
 
+open import Cubical.Foundations.Function
 open import Cubical.Foundations.Prelude
 
 open import Cubical.Functions.Embedding
@@ -51,3 +52,20 @@ module _
                   (λ a → IsApartness.is-irrefl apa (f a))
                   (λ a b c → IsApartness.is-cotrans apa (f a) (f b) (f c))
                   λ a b → IsApartness.is-sym apa (f a) (f b)
+
+  isApartnessDual : IsApartness R → IsApartness (Dual R)
+  isApartnessDual apa
+    = isapartness (IsApartness.is-set apa)
+                  (λ a b → IsApartness.is-prop-valued apa b a)
+                  (IsApartness.is-irrefl apa)
+                  (λ a b c Rba → ∥₁.map (⊎.rec (inl ∘ s c a)
+                                               (inr ∘ s c b))
+                                        (IsApartness.is-cotrans apa a b c (s a b Rba)))
+                   s
+    where s : isSym (Dual R)
+          s a b = IsApartness.is-sym apa b a
+
+DualApartness : Apartness ℓ ℓ' → Apartness ℓ ℓ'
+DualApartness (_ , apa)
+  = apartness _ (BinaryRelation.Dual (ApartnessStr._#_ apa))
+                (isApartnessDual (ApartnessStr.isApartness apa))
diff --git a/Cubical/Relation/Binary/Order/Loset/Base.agda b/Cubical/Relation/Binary/Order/Loset/Base.agda
index 0f2d3bd941..ee0fc5f99d 100644
--- a/Cubical/Relation/Binary/Order/Loset/Base.agda
+++ b/Cubical/Relation/Binary/Order/Loset/Base.agda
@@ -69,8 +69,8 @@ record LosetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')
 Loset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
 Loset ℓ ℓ' = TypeWithStr ℓ (LosetStr ℓ')
 
-loset : (A : Type ℓ) (_<_ : A → A → Type ℓ') (h : IsLoset _<_) → Loset ℓ ℓ'
-loset A _<_ h = A , losetstr _<_ h
+loset : (A : Type ℓ) → (_<_ : Rel A A ℓ') → IsLoset _<_ → Loset ℓ ℓ'
+loset A _<_ los = A , (losetstr _<_ los)
 
 record IsLosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
   (M : LosetStr ℓ₀' A) (e : A ≃ B) (N : LosetStr ℓ₁' B)
@@ -98,7 +98,7 @@ isPropIsLoset _<_ = isOfHLevelRetractFromIso 1 IsLosetIsoΣ
                                  (isPropΠ5 (λ _ _ _ _ _ → isPropValued< _ _))
                                  (isPropΠ3 (λ x y _ → isProp¬ (y < x)))
                                  (isPropΠ4 λ _ _ _ _ → squash₁)
-                                 (isPropΠ3 λ _ _ _ → squash₁))
+                                 (isPropΠ3 λ _ _ _ → isSetA _ _))
 
 𝒮ᴰ-Loset : DUARel (𝒮-Univ ℓ) (LosetStr ℓ') (ℓ-max ℓ ℓ')
 𝒮ᴰ-Loset =
diff --git a/Cubical/Relation/Binary/Order/Loset/Properties.agda b/Cubical/Relation/Binary/Order/Loset/Properties.agda
index 34e0e14e72..943f105a63 100644
--- a/Cubical/Relation/Binary/Order/Loset/Properties.agda
+++ b/Cubical/Relation/Binary/Order/Loset/Properties.agda
@@ -12,8 +12,9 @@ open import Cubical.HITs.PropositionalTruncation as ∥₁
 
 open import Cubical.Relation.Binary.Base
 open import Cubical.Relation.Binary.Order.Apartness.Base
-open import Cubical.Relation.Binary.Order.Toset.Base
-open import Cubical.Relation.Binary.Order.StrictPoset.Base
+open import Cubical.Relation.Binary.Order.Toset
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.StrictOrder.Base
 open import Cubical.Relation.Binary.Order.Loset.Base
 
 open import Cubical.Relation.Nullary
@@ -29,13 +30,14 @@ module _
 
   open BinaryRelation
 
-  isLoset→isStrictPoset : IsLoset R → IsStrictPoset R
-  isLoset→isStrictPoset loset = isstrictposet
-                                (IsLoset.is-set loset)
-                                (IsLoset.is-prop-valued loset)
-                                (IsLoset.is-irrefl loset)
-                                (IsLoset.is-trans loset)
-                                (IsLoset.is-asym loset)
+  isLoset→isStrictOrder : IsLoset R → IsStrictOrder R
+  isLoset→isStrictOrder loset = isstrictorder
+                          (IsLoset.is-set loset)
+                          (IsLoset.is-prop-valued loset)
+                          (IsLoset.is-irrefl loset)
+                          (IsLoset.is-trans loset)
+                          (IsLoset.is-asym loset)
+                          (IsLoset.is-weakly-linear loset)
 
   private
     transrefl : isTrans R → isTrans (ReflClosure R)
@@ -49,8 +51,8 @@ module _
     antisym irr trans a b (inl _) (inr b≡a) = sym b≡a
     antisym irr trans a b (inr a≡b) _ = a≡b
 
-  isLoset→isTosetReflClosure : Discrete A → IsLoset R → IsToset (ReflClosure R)
-  isLoset→isTosetReflClosure disc loset
+  isLoset→isTosetReflClosure : IsLoset R → isDecidable R → IsToset (ReflClosure R)
+  isLoset→isTosetReflClosure loset dec
     = istoset (IsLoset.is-set loset)
               (λ a b → isProp⊎ (IsLoset.is-prop-valued loset a b)
                                (IsLoset.is-set loset a b)
@@ -61,9 +63,33 @@ module _
               (transrefl (IsLoset.is-trans loset))
               (antisym (IsLoset.is-irrefl loset)
                        (IsLoset.is-trans loset))
-              λ a b → decRec (λ a≡b → ∣ inl (inr a≡b) ∣₁)
-                             (λ ¬a≡b → ∥₁.map (⊎.map (λ Rab → inl Rab) λ Rba → inl Rba)
-                             (IsLoset.is-connected loset a b ¬a≡b)) (disc a b)
+               λ a b → decRec (λ Rab → ∣ inl (inl Rab) ∣₁)
+                              (λ ¬Rab → decRec (λ Rba → ∣ inr (inl Rba) ∣₁)
+                                               (λ ¬Rba → ∣ inl (inr (IsLoset.is-connected loset a b
+                                                                    (¬Rab , ¬Rba))) ∣₁)
+                                        (dec b a))
+                       (dec a b)
+
+  isLosetDecidable→isTosetDecidable : IsLoset R → isDecidable R → isDecidable (ReflClosure R)
+  isLosetDecidable→isTosetDecidable los dec a b with dec a b
+  ... | yes Rab = yes (inl Rab)
+  ... | no ¬Rab with dec b a
+  ...       | yes Rba = no (⊎.rec ¬Rab λ a≡b → IsLoset.is-irrefl los b (subst (R b) a≡b Rba))
+  ...       | no ¬Rba = yes (inr (IsLoset.is-connected los a b (¬Rab , ¬Rba)))
+
+  isLosetDecidable→Discrete : IsLoset R → isDecidable R → Discrete A
+  isLosetDecidable→Discrete los dec = isTosetDecidable→Discrete
+                                     (isLoset→isTosetReflClosure los dec)
+                                     (isLosetDecidable→isTosetDecidable los dec)
+
+  isLoset→isPosetNegationRel : IsLoset R → IsPoset (NegationRel R)
+  isLoset→isPosetNegationRel loset
+    = isposet (IsLoset.is-set loset)
+              (λ a b → isProp¬ (R a b))
+              (IsLoset.is-irrefl loset)
+              (λ a b c ¬Rab ¬Rbc Rac → ∥₁.rec isProp⊥ (⊎.rec ¬Rab ¬Rbc)
+                                             (IsLoset.is-weakly-linear loset a c b Rac))
+               λ a b ¬Rab ¬Rba → IsLoset.is-connected loset a b (¬Rab , ¬Rba)
 
   isLosetInduced : IsLoset R → (B : Type ℓ'') → (f : B ↪ A)
                  → IsLoset (InducedRelation R (B , f))
@@ -74,18 +100,33 @@ module _
               (λ a b c → IsLoset.is-trans los (f a) (f b) (f c))
               (λ a b → IsLoset.is-asym los (f a) (f b))
               (λ a b c → IsLoset.is-weakly-linear los (f a) (f b) (f c))
-              λ a b ¬a≡b → IsLoset.is-connected los (f a) (f b)
-                λ fa≡fb → ¬a≡b (isEmbedding→Inj emb a b fa≡fb)
-
-Loset→StrictPoset : Loset ℓ ℓ' → StrictPoset ℓ ℓ'
-Loset→StrictPoset (_ , los)
-  = _ , strictposetstr (LosetStr._<_ los)
-                       (isLoset→isStrictPoset (LosetStr.isLoset los))
+               λ a b ineq → isEmbedding→Inj emb a b
+                           (IsLoset.is-connected los (f a) (f b) ineq)
+
+  isLosetDual : IsLoset R → IsLoset (Dual R)
+  isLosetDual los
+    = isloset (IsLoset.is-set los)
+              (λ a b → IsLoset.is-prop-valued los b a)
+              (IsLoset.is-irrefl los)
+              (λ a b c Rab Rbc → IsLoset.is-trans los c b a Rbc Rab)
+              (λ a b → IsLoset.is-asym los b a)
+              (λ a b c Rba → ∥₁.map (⊎.rec inr inl)
+                                    (IsLoset.is-weakly-linear los b a c Rba))
+               λ { a b (¬Rba , ¬Rab) → IsLoset.is-connected los a b (¬Rab , ¬Rba) }
+
+Loset→StrictOrder : Loset ℓ ℓ' → StrictOrder ℓ ℓ'
+Loset→StrictOrder (_ , los)
+  = strictorder _ (LosetStr._<_ los)
+                  (isLoset→isStrictOrder (LosetStr.isLoset los))
 
 Loset→Toset : (los : Loset ℓ ℓ')
-            → Discrete (fst los)
+            → BinaryRelation.isDecidable (LosetStr._<_ (snd los))
             → Toset ℓ (ℓ-max ℓ ℓ')
-Loset→Toset (_ , los) disc
-  = _ , tosetstr (BinaryRelation.ReflClosure (LosetStr._<_ los))
-                 (isLoset→isTosetReflClosure disc
-                                             (LosetStr.isLoset los))
+Loset→Toset (_ , los) dec
+  = toset _ (BinaryRelation.ReflClosure (LosetStr._<_ los))
+            (isLoset→isTosetReflClosure (LosetStr.isLoset los) dec)
+
+DualLoset : Loset ℓ ℓ' → Loset ℓ ℓ'
+DualLoset (_ , los)
+  = loset _ (BinaryRelation.Dual (LosetStr._<_ los))
+            (isLosetDual (LosetStr.isLoset los))
diff --git a/Cubical/Relation/Binary/Order/Poset/Base.agda b/Cubical/Relation/Binary/Order/Poset/Base.agda
index 8d6fddd9e4..35ae0fef5c 100644
--- a/Cubical/Relation/Binary/Order/Poset/Base.agda
+++ b/Cubical/Relation/Binary/Order/Poset/Base.agda
@@ -59,8 +59,8 @@ record PosetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')
 Poset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
 Poset ℓ ℓ' = TypeWithStr ℓ (PosetStr ℓ')
 
-poset : (A : Type ℓ) (_≤_ : A → A → Type ℓ') (h : IsPoset _≤_) → Poset ℓ ℓ'
-poset A _≤_ h = A , posetstr _≤_ h
+poset : (A : Type ℓ) → (_≤_ : Rel A A ℓ') → IsPoset _≤_ → Poset ℓ ℓ'
+poset A _≤_ pos = A , (posetstr _≤_ pos)
 
 record IsPosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
   (M : PosetStr ℓ₀' A) (e : A ≃ B) (N : PosetStr ℓ₁' B)
@@ -76,6 +76,12 @@ record IsPosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
   field
     pres≤ : (x y : A) → x M.≤ y ≃ equivFun e x N.≤ equivFun e y
 
+  -- This also holds in the other direction, which helps a lot in proofs
+  pres≤⁻ : (x y : B) → x N.≤ y ≃ invEq e x M.≤ invEq e y
+  pres≤⁻ x y = invEquiv (compEquiv (pres≤ (invEq e x) (invEq e y))
+                                    (subst2Equiv N._≤_ (secEq e x) (secEq e y)))
+
+unquoteDecl IsPosetEquivIsoΣ = declareRecordIsoΣ IsPosetEquivIsoΣ (quote IsPosetEquiv)
 
 PosetEquiv : (M : Poset ℓ₀ ℓ₀') (M : Poset ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
 PosetEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsPosetEquiv (M .snd) e (N .snd)
@@ -89,6 +95,16 @@ isPropIsPoset _≤_ = isOfHLevelRetractFromIso 1 IsPosetIsoΣ
                            (isPropΠ5 λ _ _ _ _ _ → isPropValued≤ _ _)
                              (isPropΠ4 λ _ _ _ _ → isSetA _ _))
 
+isPropIsPosetEquiv : {A : Type ℓ₀} {B : Type ℓ₁}
+                     (M : PosetStr ℓ₀' A)
+                     (e : A ≃ B)
+                     (N : PosetStr ℓ₁' B)
+                   → isProp (IsPosetEquiv M e N)
+isPropIsPosetEquiv M e N = isOfHLevelRetractFromIso 1 IsPosetEquivIsoΣ
+  (isPropΠ2 λ _ _ → isOfHLevel≃ 1
+                                (IsPoset.is-prop-valued (PosetStr.isPoset M) _ _)
+                                (IsPoset.is-prop-valued (PosetStr.isPoset N) _ _))
+
 𝒮ᴰ-Poset : DUARel (𝒮-Univ ℓ) (PosetStr ℓ') (ℓ-max ℓ ℓ')
 𝒮ᴰ-Poset =
   𝒮ᴰ-Record (𝒮-Univ _) IsPosetEquiv
diff --git a/Cubical/Relation/Binary/Order/Poset/Instances/Embedding.agda b/Cubical/Relation/Binary/Order/Poset/Instances/Embedding.agda
new file mode 100644
index 0000000000..648cc67fd4
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Poset/Instances/Embedding.agda
@@ -0,0 +1,145 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Poset.Instances.Embedding where
+
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Empty as ⊥
+
+open import Cubical.Functions.Embedding
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+open import Cubical.Relation.Binary.Order.Proset.Properties
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Poset.Properties
+
+private
+  variable
+    ℓ ℓ' : Level
+
+-- The collection of embeddings on a type happens to form a complete lattice
+
+-- First, we show that it's a poset
+isPoset⊆ₑ : {A : Type ℓ} → IsPoset {A = Embedding A ℓ'} _⊆ₑ_
+isPoset⊆ₑ = isposet isSetEmbedding
+                    isProp⊆ₑ
+                    isRefl⊆ₑ
+                    isTrans⊆ₑ
+                    isAntisym⊆ₑ
+
+EmbeddingPoset : (A : Type ℓ) (ℓ' : Level) → Poset _ _
+EmbeddingPoset A ℓ'
+  = poset (Embedding A ℓ') _⊆ₑ_ (isPoset⊆ₑ)
+
+-- Then we describe it as both a lattice and a complete lattice
+isMeet∩ₑ : {A : Type ℓ}
+           (X Y : Embedding A ℓ)
+         → isMeet (isPoset→isProset isPoset⊆ₑ) X Y (X ∩ₑ Y)
+isMeet∩ₑ X Y Z = propBiimpl→Equiv (isProp⊆ₑ Z (X ∩ₑ Y))
+                                  (isProp× (isProp⊆ₑ Z X)
+                                  (isProp⊆ₑ Z Y))
+                                  (λ Z⊆X∩Y →
+                                    (λ x x∈Z →
+                                       subst (_∈ₑ X)
+                                             (Z⊆X∩Y x x∈Z .snd)
+                                             (Z⊆X∩Y x x∈Z .fst .snd .fst)) ,
+                                    (λ x x∈Z →
+                                       subst (_∈ₑ Y)
+                                             (Z⊆X∩Y x x∈Z .snd)
+                                             (Z⊆X∩Y x x∈Z .fst .snd .snd)))
+                                   λ { (Z⊆X , Z⊆Y) x x∈Z →
+                                       (x , ((Z⊆X x x∈Z) ,
+                                             (Z⊆Y x x∈Z))) , refl }
+
+isMeetSemipseudolatticeEmbeddingPoset : {A : Type ℓ}
+                                      → isMeetSemipseudolattice (EmbeddingPoset A ℓ)
+isMeetSemipseudolatticeEmbeddingPoset X Y
+  = X ∩ₑ Y , isMeet∩ₑ X Y
+
+isGreatestEmbeddingPosetTotal : {A : Type ℓ}
+                              → isGreatest (isPoset→isProset isPoset⊆ₑ)
+                                           (Embedding A ℓ , id↪ (Embedding A ℓ))
+                                           (A , (id↪ A))
+isGreatestEmbeddingPosetTotal _ x _
+  = x , refl
+
+isMeetSemilatticeEmbeddingPoset : {A : Type ℓ}
+                                → isMeetSemilattice (EmbeddingPoset A ℓ)
+isMeetSemilatticeEmbeddingPoset {A = A}
+  = isMeetSemipseudolatticeEmbeddingPoset ,
+    (A , (id↪ A)) ,
+    isGreatestEmbeddingPosetTotal
+
+isJoin∪ₑ : {A : Type ℓ}
+           (X Y : Embedding A ℓ)
+         → isJoin (isPoset→isProset isPoset⊆ₑ) X Y (X ∪ₑ Y)
+isJoin∪ₑ X Y Z
+  = propBiimpl→Equiv (isProp⊆ₑ (X ∪ₑ Y) Z)
+                     (isProp× (isProp⊆ₑ X Z)
+                              (isProp⊆ₑ Y Z))
+                     (λ X∪Y⊆Z →
+                          (λ x x∈X → X∪Y⊆Z x ((x , ∣ inl x∈X ∣₁) , refl)) ,
+                          (λ x x∈Y → X∪Y⊆Z x ((x , ∣ inr x∈Y ∣₁) , refl)))
+                      λ { (X⊆Z , Y⊆Z) x x∈X∪Y →
+                          ∥₁.rec (isProp∈ₑ x Z)
+                                 (⊎.rec (λ a∈X → subst (_∈ₑ Z)
+                                                       (x∈X∪Y .snd)
+                                                       (X⊆Z _ a∈X))
+                                        (λ a∈Y → subst (_∈ₑ Z)
+                                                       (x∈X∪Y .snd)
+                                                       (Y⊆Z _ a∈Y)))
+                                 (x∈X∪Y .fst .snd) }
+
+isJoinSemipseudolatticeEmbeddingPoset : {A : Type ℓ}
+                                      → isJoinSemipseudolattice (EmbeddingPoset A ℓ)
+isJoinSemipseudolatticeEmbeddingPoset X Y
+  = X ∪ₑ Y , isJoin∪ₑ X Y
+
+isLeast∅ : {A : Type ℓ}
+         → isLeast (isPoset→isProset isPoset⊆ₑ) (Embedding A ℓ , id↪ (Embedding A ℓ)) ((Σ[ x ∈ A ] ⊥) , EmbeddingΣProp λ _ → isProp⊥)
+isLeast∅ _ _ ((_ , ()) , _)
+
+isJoinSemilatticeEmbeddingPoset : {A : Type ℓ}
+                                → isJoinSemilattice (EmbeddingPoset A ℓ)
+isJoinSemilatticeEmbeddingPoset {A = A}
+  = isJoinSemipseudolatticeEmbeddingPoset ,
+    ((Σ[ x ∈ A ] ⊥) , EmbeddingΣProp λ _ → isProp⊥) ,
+    isLeast∅
+
+isLatticeEmbeddingPoset : {A : Type ℓ}
+                        → isLattice (EmbeddingPoset A ℓ)
+isLatticeEmbeddingPoset = isMeetSemilatticeEmbeddingPoset ,
+                          isJoinSemilatticeEmbeddingPoset
+
+isInfimum⋂ₑ : {A : Type ℓ}
+               {I : Type ℓ}
+               (P : I → Embedding A ℓ)
+             → isInfimum (isPoset→isProset isPoset⊆ₑ) P (⋂ₑ P)
+fst (isInfimum⋂ₑ P) i y ((a , ∀i) , a≡y) = subst (_∈ₑ P i) a≡y (∀i i)
+snd (isInfimum⋂ₑ P) (X , lwr) y y∈X = (y , λ i → lwr i y y∈X) , refl
+
+isMeetCompleteSemipseudolatticeEmbeddingPoset : {A : Type ℓ}
+                                              → isMeetCompleteSemipseudolattice (EmbeddingPoset A ℓ)
+isMeetCompleteSemipseudolatticeEmbeddingPoset P
+  = (⋂ₑ P) , (isInfimum⋂ₑ P)
+
+isSupremum⋃ₑ : {A : Type ℓ}
+               {I : Type ℓ}
+               (P : I → Embedding A ℓ)
+              → isSupremum (isPoset→isProset isPoset⊆ₑ) P (⋃ₑ P)
+fst (isSupremum⋃ₑ P) i y y∈Pi = (y , ∣ i , y∈Pi ∣₁) , refl
+snd (isSupremum⋃ₑ P) (X , upr) y ((a , ∃i) , a≡y)
+  = ∥₁.rec (isProp∈ₑ y X) (λ (i , a∈Pi) → upr i y (subst (_∈ₑ P i) a≡y a∈Pi)) ∃i
+
+isJoinCompleteSemipseudolatticeEmbeddingPoset : {A : Type ℓ}
+                                              → isJoinCompleteSemipseudolattice (EmbeddingPoset A ℓ)
+isJoinCompleteSemipseudolatticeEmbeddingPoset P
+  = (⋃ₑ P) , (isSupremum⋃ₑ P)
+
+isCompleteLatticeEmbeddingPoset : {A : Type ℓ}
+                                → isCompleteLattice (EmbeddingPoset A ℓ)
+isCompleteLatticeEmbeddingPoset = isMeetCompleteSemipseudolatticeEmbeddingPoset ,
+                                  isJoinCompleteSemipseudolatticeEmbeddingPoset
diff --git a/Cubical/Relation/Binary/Order/Poset/Mappings.agda b/Cubical/Relation/Binary/Order/Poset/Mappings.agda
new file mode 100644
index 0000000000..161f366072
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Poset/Mappings.agda
@@ -0,0 +1,1228 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Poset.Mappings where
+
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Univalence
+
+open import Cubical.Algebra.Semigroup
+
+open import Cubical.Data.Sigma
+
+open import Cubical.Functions.Embedding
+open import Cubical.Functions.Image
+open import Cubical.Functions.Logic using (_⊔′_)
+open import Cubical.Functions.Preimage
+
+open import Cubical.Reflection.RecordEquiv
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+open import Cubical.HITs.SetQuotients
+
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Poset.Properties
+open import Cubical.Relation.Binary.Order.Poset.Subset
+open import Cubical.Relation.Binary.Order.Poset.Instances.Embedding
+open import Cubical.Relation.Binary.Order.Proset
+open import Cubical.Relation.Binary.Base
+
+
+private
+  variable
+    ℓ ℓ' ℓ'' ℓ''' ℓ₀ ℓ₀' ℓ₁ ℓ₁' ℓ₂ ℓ₂' : Level
+
+record IsIsotone {A : Type ℓ₀} {B : Type ℓ₁}
+  (M : PosetStr ℓ₀' A) (f : A → B) (N : PosetStr ℓ₁' B)
+  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
+  where
+  -- Shorter qualified names
+  private
+    module M = PosetStr M
+    module N = PosetStr N
+
+  field
+    pres≤ : (x y : A) → x M.≤ y → f x N.≤ f y
+
+unquoteDecl IsIsotoneIsoΣ = declareRecordIsoΣ IsIsotoneIsoΣ (quote IsIsotone)
+
+isPropIsIsotone : {A : Type ℓ₀} {B : Type ℓ₁}
+                  (M : PosetStr ℓ₀' A) (f : A → B) (N : PosetStr ℓ₁' B)
+                → isProp (IsIsotone M f N)
+isPropIsIsotone M f N = isOfHLevelRetractFromIso 1 IsIsotoneIsoΣ
+  (isPropΠ3 λ x y _ → IsPoset.is-prop-valued (PosetStr.isPoset N) (f x) (f y))
+
+IsIsotone-∘ : {A : Type ℓ₀} {B : Type ℓ₁} {C : Type ℓ₂}
+            → (M : PosetStr ℓ₀' A) (f : A → B)
+              (N : PosetStr ℓ₁' B) (g : B → C) (O : PosetStr ℓ₂' C)
+            → IsIsotone M f N
+            → IsIsotone N g O
+            → IsIsotone M (g ∘ f) O
+IsIsotone.pres≤ (IsIsotone-∘ M f N g O isf isg) x y x≤y
+  = IsIsotone.pres≤ isg (f x) (f y) (IsIsotone.pres≤ isf x y x≤y)
+
+record IsAntitone {A : Type ℓ₀} {B : Type ℓ₁}
+  (M : PosetStr ℓ₀' A) (f : A → B) (N : PosetStr ℓ₁' B)
+  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
+  where
+  constructor
+    isantitone
+  -- Shorter qualified names
+  private
+    module M = PosetStr M
+    module N = PosetStr N
+
+  field
+    inv≤ : (x y : A) → x M.≤ y → f y N.≤ f x
+
+unquoteDecl IsAntitoneIsoΣ = declareRecordIsoΣ IsAntitoneIsoΣ (quote IsAntitone)
+
+isPropIsAntitone : {A : Type ℓ₀} {B : Type ℓ₁}
+                   (M : PosetStr ℓ₀' A) (f : A → B) (N : PosetStr ℓ₁' B)
+                 → isProp (IsAntitone M f N)
+isPropIsAntitone M f N = isOfHLevelRetractFromIso 1 IsAntitoneIsoΣ
+  (isPropΠ3 λ x y _ → IsPoset.is-prop-valued (PosetStr.isPoset N) (f y) (f x))
+
+module _
+  (A : Poset ℓ₀ ℓ₀')
+  (B : Poset ℓ₁ ℓ₁')
+  (f : ⟨ A ⟩ → ⟨ B ⟩)
+  where
+
+    DualIsotone : IsIsotone (snd A) f (snd B)
+                → IsAntitone (snd (DualPoset A)) f (snd B)
+    IsAntitone.inv≤ (DualIsotone is) x y = IsIsotone.pres≤ is y x
+
+    DualIsotone' : IsIsotone (snd (DualPoset A)) f (snd B)
+                 → IsAntitone (snd A) f (snd B)
+    IsAntitone.inv≤ (DualIsotone' is) x y = IsIsotone.pres≤ is y x
+
+    IsotoneDual : IsIsotone (snd A) f (snd B)
+                → IsAntitone (snd A) f (snd (DualPoset B))
+    IsAntitone.inv≤ (IsotoneDual is) = IsIsotone.pres≤ is
+
+    IsotoneDual' : IsIsotone (snd A) f (snd (DualPoset B))
+                 → IsAntitone (snd A) f (snd B)
+    IsAntitone.inv≤ (IsotoneDual' is) = IsIsotone.pres≤ is
+
+    DualAntitone : IsAntitone (snd A) f (snd B)
+                 → IsIsotone (snd (DualPoset A)) f (snd B)
+    IsIsotone.pres≤ (DualAntitone is) x y = IsAntitone.inv≤ is y x
+
+    DualAntitone' : IsAntitone (snd (DualPoset A)) f (snd B)
+                  → IsIsotone (snd A) f (snd B)
+    IsIsotone.pres≤ (DualAntitone' is) x y = IsAntitone.inv≤ is y x
+
+    AntitoneDual : IsAntitone (snd A) f (snd B)
+                 → IsIsotone (snd A) f (snd (DualPoset B))
+    IsIsotone.pres≤ (AntitoneDual is) = IsAntitone.inv≤ is
+
+    AntitoneDual' : IsAntitone (snd A) f (snd (DualPoset B))
+                  → IsIsotone (snd A) f (snd B)
+    IsIsotone.pres≤ (AntitoneDual' is) = IsAntitone.inv≤ is
+
+    DualIsotoneDual : IsIsotone (snd A) f (snd B)
+                    → IsIsotone (snd (DualPoset A)) f (snd (DualPoset B))
+    IsIsotone.pres≤ (DualIsotoneDual is) x y = IsIsotone.pres≤ is y x
+
+    DualIsotoneDual' : IsIsotone (snd (DualPoset A)) f (snd (DualPoset B))
+                     → IsIsotone (snd A) f (snd B)
+    IsIsotone.pres≤ (DualIsotoneDual' is) x y = IsIsotone.pres≤ is y x
+
+    DualAntitoneDual : IsAntitone (snd A) f (snd B)
+                     → IsAntitone (snd (DualPoset A)) f (snd (DualPoset B))
+    IsAntitone.inv≤ (DualAntitoneDual is) x y = IsAntitone.inv≤ is y x
+
+    DualAntitoneDual' : IsAntitone (snd (DualPoset A)) f (snd (DualPoset B))
+                      → IsAntitone (snd A) f (snd B)
+    IsAntitone.inv≤ (DualAntitoneDual' is) x y = IsAntitone.inv≤ is y x
+
+IsPosetEquiv→IsIsotone : (P S : Poset ℓ ℓ')
+                         (e : ⟨ P ⟩ ≃ ⟨ S ⟩)
+                       → IsPosetEquiv (snd P) e (snd S)
+                       → IsIsotone (snd P) (equivFun e) (snd S)
+IsIsotone.pres≤ (IsPosetEquiv→IsIsotone P S e eq) x y = equivFun (IsPosetEquiv.pres≤ eq x y)
+
+-- Isotone maps are characterized by their actions on down-sets and up-sets
+module _
+  {P : Poset ℓ₀ ℓ₀'}
+  {S : Poset ℓ₁ ℓ₁'}
+  (f : ⟨ P ⟩ → ⟨ S ⟩)
+  where
+    private
+      isP = PosetStr.isPoset (snd P)
+      isS = PosetStr.isPoset (snd S)
+
+      _≤P_ = PosetStr._≤_ (snd P)
+      _≤S_ = PosetStr._≤_ (snd S)
+
+      propS = IsPoset.is-prop-valued isS
+      rflS = IsPoset.is-refl isS
+      transS = IsPoset.is-trans isS
+
+    IsIsotone→PreimagePrincipalDownsetIsDownset : IsIsotone (snd P) f (snd S)
+                                                → ∀ y → isDownset P (f ⃖ (principalDownset S y))
+    IsIsotone→PreimagePrincipalDownsetIsDownset is y (x , inPrex) z z≤x
+      = ∥₁.rec (isEmbedding→hasPropFibers (preimageInclusion f (principalDownset S y) .snd) z)
+               (λ { ((b , b≤y) , fibb) →
+                    (z , ∣ (f z , transS (f z) (f x) y
+                                         (IsIsotone.pres≤ is z x z≤x)
+                                         (subst (_≤S y) fibb b≤y)) ,
+                                          refl ∣₁) ,
+                     refl }) inPrex
+
+    IsIsotone→PreimagePrincipalUpsetIsUpset : IsIsotone (snd P) f (snd S)
+                                            → ∀ y → isUpset P (f ⃖ (principalUpset S y))
+    IsIsotone→PreimagePrincipalUpsetIsUpset is y (x , inPrex) z x≤z
+      = ∥₁.rec (isEmbedding→hasPropFibers (preimageInclusion f (principalUpset S y) .snd) z)
+               (λ { ((b , y≤b) , fibb) →
+                    (z , ∣ (f z , transS y (f x) (f z)
+                                        (subst (y ≤S_) fibb y≤b)
+                                        (IsIsotone.pres≤ is x z x≤z)) ,
+                                         refl ∣₁) ,
+                     refl }) inPrex
+
+    PreimagePrincipalDownsetIsDownset→IsIsotone : (∀ x → isDownset P (f ⃖ (principalDownset S x)))
+                                                → IsIsotone (snd P) f (snd S)
+    IsIsotone.pres≤ (PreimagePrincipalDownsetIsDownset→IsIsotone down) y x y≤x
+      = ∥₁.rec (propS _ _) (λ { ((b , b≤fx) , fibb) → subst (_≤S f x) (fibb ∙ cong f fiba) b≤fx }) pre
+        where fib = down (f x) (x , ∣ ((f x) , (rflS (f x))) , refl ∣₁) y y≤x
+
+              pre = fib .fst .snd
+              fiba = fib .snd
+
+    PreimagePrincipalUpsetIsUpset→IsIsotone : (∀ x → isUpset P (f ⃖ (principalUpset S x)))
+                                            → IsIsotone (snd P) f (snd S)
+    IsIsotone.pres≤ (PreimagePrincipalUpsetIsUpset→IsIsotone up) x y x≤y
+      = ∥₁.rec (propS _ _) (λ { ((b , fx≤b) , fibb) → subst (f x ≤S_) (fibb ∙ cong f fiba) fx≤b }) pre
+        where fib = up (f x) (x , ∣ ((f x) , (rflS (f x))) , refl ∣₁) y x≤y
+
+              pre = fib .fst .snd
+              fiba = fib .snd
+
+-- The next part requires our posets to operate over the same universes
+module _
+  (P S : Poset ℓ ℓ')
+  (f : ⟨ P ⟩ → ⟨ S ⟩)
+  where
+    private
+      isP = PosetStr.isPoset (snd P)
+      isS = PosetStr.isPoset (snd S)
+
+      _≤P_ = PosetStr._≤_ (snd P)
+      _≤S_ = PosetStr._≤_ (snd S)
+
+      propP = IsPoset.is-prop-valued isP
+      rflP = IsPoset.is-refl isP
+      antiP = IsPoset.is-antisym isP
+      transP = IsPoset.is-trans isP
+
+      propS = IsPoset.is-prop-valued isS
+      rflS = IsPoset.is-refl isS
+      antiS = IsPoset.is-antisym isS
+      transS = IsPoset.is-trans isS
+
+    -- We can now define the type of residuated maps
+    isResiduated : Type _
+    isResiduated = ∀ y → isPrincipalDownset P (f ⃖ (principalDownset S y))
+
+    hasResidual : Type (ℓ-max ℓ ℓ')
+    hasResidual = (IsIsotone (snd P) f (snd S)) ×
+                   (Σ[ g ∈ (⟨ S ⟩ → ⟨ P ⟩) ] (IsIsotone (snd S) g (snd P) ×
+                                             (∀ x → x ≤P (g ∘ f) x) ×
+                                             (∀ x → (f ∘ g) x ≤S x)))
+
+    isResiduated→hasResidual : isResiduated
+                             → hasResidual
+    isResiduated→hasResidual down = isotonef , g , isotoneg , g∘f , f∘g
+      where isotonef : IsIsotone (snd P) f (snd S)
+            isotonef = PreimagePrincipalDownsetIsDownset→IsIsotone f
+                       λ x → isPrincipalDownset→isDownset P (f ⃖ principalDownset S x) (down x)
+
+            isotonef⃖ : ∀ x y → x ≤S y → (f ⃖ (principalDownset S x)) ⊆ₑ (f ⃖ (principalDownset S y))
+            isotonef⃖ x y x≤y z ((a , pre) , fiba)
+              = ∥₁.rec (isProp∈ₑ z (f ⃖ principalDownset S y))
+                       (λ { ((b , b≤x) , fibb) → (a , ∣ (b , (transS b x y b≤x x≤y)) , fibb ∣₁) , fiba }) pre
+
+            g : ⟨ S ⟩ → ⟨ P ⟩
+            g x = down x .fst
+
+            isotoneg : IsIsotone (snd S) g (snd P)
+            IsIsotone.pres≤ isotoneg x y x≤y
+              = invEq
+                  (principalDownsetMembership P (g x) (g y))
+                  (subst
+                    (g x ∈ₑ_)
+                    (down y .snd)
+                    (isotonef⃖ x y x≤y (g x)
+                      (subst (g x ∈ₑ_)
+                        (sym (down x .snd))
+                        (equivFun (principalDownsetMembership P (g x) (g x)) (rflP (g x))))))
+
+            g∘f : ∀ x → x ≤P (g ∘ f) x
+            g∘f x = invEq (principalDownsetMembership P x (g (f x)))
+                          (subst (x ∈ₑ_) (down (f x) .snd)
+                                 ((x , ∣ ((f x) , (rflS (f x))) , refl ∣₁) , refl))
+
+            f∘g : ∀ y → (f ∘ g) y ≤S y
+            f∘g y = ∥₁.rec (propS _ _)
+                           (λ { ((a , a≤y) , fib) →
+                                subst (_≤S y) (fib ∙ cong f (gy∈pre .snd)) a≤y })
+                           (gy∈pre .fst .snd)
+              where gy∈pre : g y ∈ₑ (f ⃖ (principalDownset S y))
+                    gy∈pre = subst (g y ∈ₑ_) (sym (down y .snd))
+                                   (equivFun (principalDownsetMembership P (g y) (g y)) (rflP (g y)))
+
+    hasResidual→isResiduated : hasResidual
+                             → isResiduated
+    hasResidual→isResiduated (isf , g , isg , g∘f , f∘g) y
+      = (g y) , (equivFun (EmbeddingIP _ _)
+                ((λ x ((a , pre) , fiba) →
+                  ∥₁.rec (isProp∈ₑ x (principalDownset P (g y)))
+                                     (λ { ((b , b≤y) , fibb) →
+                                          equivFun (principalDownsetMembership P x (g y))
+                                                   (transP x (g (f x)) (g y) (g∘f x)
+                                                     (IsIsotone.pres≤ isg (f x) y
+                                                       (subst (_≤S y)
+                                                         (fibb ∙ cong f fiba) b≤y))) }) pre) ,
+                  λ x x∈g → (x , ∣ ((f x) ,
+                                   (transS (f x) (f (g y)) y
+                                     (IsIsotone.pres≤ isf x (g y)
+                                       (invEq (principalDownsetMembership P x (g y)) x∈g))
+                                     (f∘g y))) , refl ∣₁) , refl))
+
+    isPropIsResiduated : isProp isResiduated
+    isPropIsResiduated = isPropΠ λ _ → isPropIsPrincipalDownset P _
+
+    residualUnique : (p q : hasResidual)
+                   → p .snd .fst ≡ q .snd .fst
+    residualUnique (isf₀ , g  , isg  , g∘f  , f∘g)
+                   (isf₁ , g* , isg* , g*∘f , f∘g*)
+                   = funExt λ x → antiP (g x) (g* x) (g≤g* x) (g*≤g x)
+                   where g≤g* : ∀ x → g x ≤P g* x
+                         g≤g* x = transP (g x) ((g* ∘ f) (g x)) (g* x) (g*∘f (g x))
+                                          (IsIsotone.pres≤ isg* (f (g x)) x (f∘g x))
+
+                         g*≤g : ∀ x → g* x ≤P g x
+                         g*≤g x = transP (g* x) ((g ∘ f) (g* x)) (g x) (g∘f (g* x))
+                                         (IsIsotone.pres≤ isg (f (g* x)) x (f∘g* x))
+
+    isPropHasResidual : isProp hasResidual
+    isPropHasResidual p q = ≡-× (isPropIsIsotone _ f _ _ _)
+                                 (Σ≡Prop (λ g → isProp× (isPropIsIsotone _ g _)
+                                                (isProp× (isPropΠ (λ x → propP x (g (f x))))
+                                                         (isPropΠ λ x → propS (f (g x)) x)))
+                                          (residualUnique p q))
+
+    residual : hasResidual → ⟨ S ⟩ → ⟨ P ⟩
+    residual (_ , g , _) = g
+
+    AbsorbResidual : (res : hasResidual)
+                   → f ∘ (residual res) ∘ f ≡ f
+    AbsorbResidual (isf , f⁺ , _ , f⁺∘f , f∘f⁺)
+      = funExt λ x → antiS ((f ∘ f⁺ ∘ f) x) (f x)
+                           (f∘f⁺ (f x))
+                           (IsIsotone.pres≤ isf x (f⁺ (f x)) (f⁺∘f x))
+
+    ResidualAbsorb : (res : hasResidual)
+                   → (residual res) ∘ f ∘ (residual res) ≡ (residual res)
+    ResidualAbsorb (_ , f⁺ , isf⁺ , f⁺∘f , f∘f⁺)
+      = funExt λ x → antiP ((f⁺ ∘ f ∘ f⁺) x) (f⁺ x)
+                           (IsIsotone.pres≤ isf⁺ (f (f⁺ x)) x (f∘f⁺ x))
+                           (f⁺∘f (f⁺ x))
+
+isResidual : (P S : Poset ℓ ℓ')
+           → (f⁺ : ⟨ S ⟩ → ⟨ P ⟩)
+           → Type (ℓ-max ℓ ℓ')
+isResidual P S f⁺ = Σ[ f ∈ (⟨ P ⟩ → ⟨ S ⟩) ] (Σ[ res ∈ hasResidual P S f ] f⁺ ≡ residual P S f res)
+
+isResidualOfUnique : (P S : Poset ℓ ℓ')
+                   → (f⁺ : ⟨ S ⟩ → ⟨ P ⟩)
+                   → (p q : isResidual P S f⁺)
+                   → p .fst ≡ q .fst
+isResidualOfUnique P S h (f , (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺) , h≡f⁺)
+                         (g , (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺) , h≡g⁺)
+                   = funExt λ x → anti (f x) (g x)
+                                 (trans (f x) (f (f⁺ (g x))) (g x)
+                                        (IsIsotone.pres≤ isf x (f⁺ (g x))
+                                          (subst (x ≤_) (sym (p (g x))) (g⁺∘g x)))
+                                        (f∘f⁺ (g x)))
+                                  (trans (g x) (g (g⁺ (f x))) (f x)
+                                         (IsIsotone.pres≤ isg x (g⁺ (f x))
+                                           (subst (x ≤_) (p (f x)) (f⁺∘f x)))
+                                         (g∘g⁺ (f x)))
+                   where _≤_ = PosetStr._≤_ (snd P)
+                         anti = IsPoset.is-antisym (PosetStr.isPoset (snd S))
+                         trans = IsPoset.is-trans (PosetStr.isPoset (snd S))
+                         p = funExt⁻ ((sym h≡f⁺) ∙ h≡g⁺)
+
+isPropIsResidual : (P S : Poset ℓ ℓ')
+                 → (f⁺ : ⟨ S ⟩ → ⟨ P ⟩)
+                 → isProp (isResidual P S f⁺)
+isPropIsResidual P S f⁺ p q
+  = Σ≡Prop (λ f → isPropΣ (isPropHasResidual P S f)
+                            λ _ → isSet→ (IsPoset.is-set (PosetStr.isPoset (snd P))) _ _)
+                           (isResidualOfUnique P S f⁺ p q)
+
+hasResidual-∘ : (E F G : Poset ℓ ℓ')
+              → (f : ⟨ E ⟩ → ⟨ F ⟩)
+              → (g : ⟨ F ⟩ → ⟨ G ⟩)
+              → hasResidual E F f
+              → hasResidual F G g
+              → hasResidual E G (g ∘ f)
+hasResidual-∘ E F G f g (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺) (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺)
+  = is , f⁺ ∘ g⁺ , is⁺ , ⁺∘ , ∘⁺
+  where _≤E_ = PosetStr._≤_ (snd E)
+        _≤G_ = PosetStr._≤_ (snd G)
+
+        transE = IsPoset.is-trans (PosetStr.isPoset (snd E))
+        transG = IsPoset.is-trans (PosetStr.isPoset (snd G))
+
+        is : IsIsotone (snd E) (g ∘ f) (snd G)
+        is = IsIsotone-∘ (snd E) f (snd F) g (snd G) isf isg
+
+        is⁺ : IsIsotone (snd G) (f⁺ ∘ g⁺) (snd E)
+        is⁺ = IsIsotone-∘ (snd G) g⁺ (snd F) f⁺ (snd E) isg⁺ isf⁺
+
+        ⁺∘ : ∀ x → x ≤E ((f⁺ ∘ g⁺) ∘ (g ∘ f)) x
+        ⁺∘ x = transE x ((f⁺ ∘ f) x) (((f⁺ ∘ g⁺) ∘ g ∘ f) x)
+                      (f⁺∘f x)
+                      (IsIsotone.pres≤ isf⁺ (f x) (g⁺ (g (f x))) (g⁺∘g (f x)))
+
+        ∘⁺ : ∀ x → ((g ∘ f) ∘ (f⁺ ∘ g⁺)) x ≤G x
+        ∘⁺ x = transG (((g ∘ f) ∘ f⁺ ∘ g⁺) x) ((g ∘ g⁺) x) x
+                      (IsIsotone.pres≤ isg (f (f⁺ (g⁺ x))) (g⁺ x) (f∘f⁺ (g⁺ x)))
+                      (g∘g⁺ x)
+
+isResidual-∘ : (E F G : Poset ℓ ℓ')
+             → (f⁺ : ⟨ F ⟩ → ⟨ E ⟩)
+             → (g⁺ : ⟨ G ⟩ → ⟨ F ⟩)
+             → isResidual E F f⁺
+             → isResidual F G g⁺
+             → isResidual E G (f⁺ ∘ g⁺)
+isResidual-∘ E F G f⁺ g⁺ (f , resf , f⁺≡f*)
+                         (g , resg , g⁺≡g*)
+             = (g ∘ f) ,
+               (hasResidual-∘ E F G f g resf resg) ,
+               (funExt (λ x → cong f⁺ (funExt⁻ g⁺≡g* x) ∙ funExt⁻ f⁺≡f* _))
+
+EqualResidual→Involution : (P : Poset ℓ ℓ')
+                         → (f : ⟨ P ⟩ → ⟨ P ⟩)
+                         → (res : hasResidual P P f)
+                         → f ≡ (residual P P f res)
+                         → f ∘ f ≡ idfun ⟨ P ⟩
+EqualResidual→Involution P f (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺) f≡f⁺
+  = funExt λ x → anti (f (f x)) x
+                      (subst (λ g → (f ∘ g) x ≤ x) (sym f≡f⁺) (f∘f⁺ x))
+                      (subst (λ g → x ≤ (g ∘ f) x) (sym f≡f⁺) (f⁺∘f x))
+  where pos = PosetStr.isPoset (snd P)
+        _≤_ = PosetStr._≤_ (snd P)
+        anti = IsPoset.is-antisym pos
+
+Involution→EqualResidual : (P : Poset ℓ ℓ')
+                         → (f : ⟨ P ⟩ → ⟨ P ⟩)
+                         → (res : hasResidual P P f)
+                         → f ∘ f ≡ idfun ⟨ P ⟩
+                         → f ≡ (residual P P f res)
+Involution→EqualResidual P f res inv
+  = sym (cong₂ (λ g h → g ∘ f⁺ ∘ h) (sym inv) (sym inv) ∙
+         cong (λ g → f ∘ g ∘ f) (AbsorbResidual P P f res) ∙
+         cong (f ∘_) inv)
+  where f⁺ = res .snd .fst
+
+Res : Poset ℓ ℓ' → Semigroup (ℓ-max ℓ ℓ')
+fst (Res E) = Σ[ f ∈ (⟨ E ⟩ → ⟨ E ⟩) ] hasResidual E E f
+SemigroupStr._·_ (snd (Res E)) (f , resf) (g , resg)
+  = (g ∘ f) , (hasResidual-∘ E E E f g resf resg)
+IsSemigroup.is-set (SemigroupStr.isSemigroup (snd (Res E)))
+  = isSetΣ (isSet→ (IsPoset.is-set (PosetStr.isPoset (snd E))))
+      λ f → isProp→isSet (isPropHasResidual E E f)
+IsSemigroup.·Assoc (SemigroupStr.isSemigroup (snd (Res E))) (f , _) (g , _) (h , _)
+  = Σ≡Prop (λ f → isPropHasResidual E E f) refl
+
+Res⁺ : Poset ℓ ℓ' → Semigroup (ℓ-max ℓ ℓ')
+fst (Res⁺ E) = Σ[ f⁺ ∈ (⟨ E ⟩ → ⟨ E ⟩) ] isResidual E E f⁺
+SemigroupStr._·_ (snd (Res⁺ E)) (f⁺ , isresf⁺) (g⁺ , isresg⁺)
+  = (f⁺ ∘ g⁺) , isResidual-∘ E E E f⁺ g⁺ isresf⁺ isresg⁺
+IsSemigroup.is-set (SemigroupStr.isSemigroup (snd (Res⁺ E)))
+  = isSetΣ (isSet→ (IsPoset.is-set (PosetStr.isPoset (snd E))))
+      λ f⁺ → isProp→isSet (isPropIsResidual E E f⁺)
+IsSemigroup.·Assoc (SemigroupStr.isSemigroup (snd (Res⁺ E))) (f⁺ , _) (g⁺ , _) (h⁺ , _)
+  = Σ≡Prop (λ f⁺ → isPropIsResidual E E f⁺) refl
+
+isClosure : (E : Poset ℓ ℓ')
+            (f : ⟨ E ⟩ → ⟨ E ⟩)
+          → Type (ℓ-max ℓ ℓ')
+isClosure E f = IsIsotone (snd E) f (snd E) × (f ≡ f ∘ f) × (∀ x → x ≤ f x)
+  where _≤_ = PosetStr._≤_ (snd E)
+
+isDualClosure : (E : Poset ℓ ℓ')
+                (f : ⟨ E ⟩ → ⟨ E ⟩)
+              → Type (ℓ-max ℓ ℓ')
+isDualClosure E f = IsIsotone (snd E) f (snd E) × (f ≡ f ∘ f) × (∀ x → f x ≤ x)
+  where _≤_ = PosetStr._≤_ (snd E)
+
+-- This can be made more succinct
+isClosure' : (E : Poset ℓ ℓ')
+             (f : ⟨ E ⟩ → ⟨ E ⟩)
+           → Type (ℓ-max ℓ ℓ')
+isClosure' E f = ∀ x y → x ≤ f y ≃ f x ≤ f y
+  where _≤_ = PosetStr._≤_ (snd E)
+
+isDualClosure' : (E : Poset ℓ ℓ')
+                 (f : ⟨ E ⟩ → ⟨ E ⟩)
+               → Type (ℓ-max ℓ ℓ')
+isDualClosure' E f = ∀ x y → f x ≤ y ≃ f x ≤ f y
+  where _≤_ = PosetStr._≤_ (snd E)
+
+isClosure→isClosure' : (E : Poset ℓ ℓ')
+                     → ∀ f
+                     → isClosure E f
+                     → isClosure' E f
+isClosure→isClosure' E f (isf , f≡f∘f , x≤fx) x y
+  = propBiimpl→Equiv (prop _ _) (prop _ _)
+                     (λ x≤fy → subst (f x ≤_) (sym (funExt⁻ f≡f∘f y))
+                                     (IsIsotone.pres≤ isf x (f y) x≤fy))
+                     (trans x (f x) (f y) (x≤fx x))
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        prop = IsPoset.is-prop-valued is
+        trans = IsPoset.is-trans is
+
+isDualClosure→isDualClosure' : (E : Poset ℓ ℓ')
+                             → ∀ f
+                             → isDualClosure E f
+                             → isDualClosure' E f
+isDualClosure→isDualClosure' E f (isf , f≡f∘f , fx≤x) x y
+  = propBiimpl→Equiv (prop _ _) (prop _ _)
+                     (λ fx≤y → subst (_≤ f y) (sym (funExt⁻ f≡f∘f x))
+                                     (IsIsotone.pres≤ isf (f x) y fx≤y))
+                      λ fx≤fy → trans (f x) (f y) y fx≤fy (fx≤x y)
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        prop = IsPoset.is-prop-valued is
+        trans = IsPoset.is-trans is
+
+isClosure'→isClosure : (E : Poset ℓ ℓ')
+                     → ∀ f
+                     → isClosure' E f
+                     → isClosure E f
+isClosure'→isClosure E f eq
+  = isf ,
+   (funExt λ x → anti (f x) (f (f x))
+                      (IsIsotone.pres≤ isf x (f x) (x≤fx x))
+                      (equivFun (eq (f x) x) (rfl (f x)))) ,
+    x≤fx
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        rfl = IsPoset.is-refl is
+        anti = IsPoset.is-antisym is
+        trans = IsPoset.is-trans is
+
+        x≤fx : ∀ x → x ≤ f x
+        x≤fx x = invEq (eq x x) (rfl (f x))
+
+        isf : IsIsotone (snd E) f (snd E)
+        IsIsotone.pres≤ isf x y x≤y
+          = equivFun (eq x y)
+                     (trans x y (f y) x≤y (x≤fx y))
+
+isDualClosure'→isDualClosure : (E : Poset ℓ ℓ')
+                             → ∀ f
+                             → isDualClosure' E f
+                             → isDualClosure E f
+isDualClosure'→isDualClosure E f eq
+  = isf ,
+    (funExt (λ x → anti (f x) (f (f x))
+                        (equivFun (eq x (f x)) (rfl (f x)))
+                        (IsIsotone.pres≤ isf (f x) x (fx≤x x)))) ,
+    fx≤x
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        rfl = IsPoset.is-refl is
+        anti = IsPoset.is-antisym is
+        trans = IsPoset.is-trans is
+
+        fx≤x : ∀ x → f x ≤ x
+        fx≤x x = invEq (eq x x) (rfl (f x))
+
+        isf : IsIsotone (snd E) f (snd E)
+        IsIsotone.pres≤ isf x y x≤y
+          = equivFun (eq x y)
+                     (trans (f x) x y (fx≤x x) x≤y)
+
+isClosure→ComposedResidual : {E : Poset ℓ ℓ'}
+                             {f : ⟨ E ⟩ → ⟨ E ⟩}
+                           → isClosure E f
+                           → Σ[ F ∈ Poset ℓ ℓ' ] (Σ[ g ∈ (⟨ E ⟩ → ⟨ F ⟩) ] (Σ[ res ∈ hasResidual E F g ] f ≡ (residual E F g res) ∘ g))
+isClosure→ComposedResidual {ℓ} {ℓ'} {E = E} {f = f} (isf , f≡f∘f , x≤fx) = F , ♮ , (is♮ , ♮⁺ , is♮⁺ , x≤fx , ♮∘♮⁺) , refl
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+        set = IsPoset.is-set is
+        prop = IsPoset.is-prop-valued is
+        rfl = IsPoset.is-refl is
+        anti = IsPoset.is-antisym is
+        trans = IsPoset.is-trans is
+
+        kerf : Rel ⟨ E ⟩ ⟨ E ⟩ ℓ
+        kerf x y = f x ≡ f y
+
+        F' = ⟨ E ⟩ / kerf
+
+        _⊑'_ : F' → F' → hProp _
+        _⊑'_ = fun
+          where
+            fun₀ : ⟨ E ⟩ → F' → hProp _
+            fst (fun₀ x [ y ]) = f x ≤ f y
+            snd (fun₀ x [ y ]) = prop (f x) (f y)
+            fun₀ x (eq/ a b fa≡fb i) = record
+              { fst = cong (f x ≤_) fa≡fb i
+              ; snd = isProp→PathP (λ i → isPropIsProp {A = cong (f x ≤_) fa≡fb i})
+                                   (prop (f x) (f a)) (prop (f x) (f b)) i
+              }
+            fun₀ x (squash/ a b p q i j) = isSet→SquareP (λ _ _ → isSetHProp)
+              (λ _ → fun₀ x a)
+              (λ _ → fun₀ x b)
+              (λ i → fun₀ x (p i))
+              (λ i → fun₀ x (q i)) j i
+
+            toPath : ∀ a b (p : kerf a b) (y : F') → fun₀ a y ≡ fun₀ b y
+            toPath a b fa≡fb = elimProp (λ _ → isSetHProp _ _) λ c →
+              Σ≡Prop (λ _ → isPropIsProp) (cong (_≤ f c) fa≡fb)
+
+            fun : F' → F' → hProp _
+            fun [ a ] y = fun₀ a y
+            fun (eq/ a b fa≡fb i) y = toPath a b fa≡fb y i
+            fun (squash/ x y p q i j) z = isSet→SquareP (λ _ _ → isSetHProp)
+              (λ _ → fun x z) (λ _ → fun y z) (λ i → fun (p i) z) (λ i → fun (q i) z) j i
+
+        _⊑_ : Rel F' F' ℓ'
+        a ⊑ b = (a ⊑' b) .fst
+
+        open BinaryRelation _⊑_
+
+        isProp⊑ : isPropValued
+        isProp⊑ a b = (a ⊑' b) .snd
+
+        isRefl⊑ : isRefl
+        isRefl⊑ = elimProp (λ x → isProp⊑ x x)
+                           (rfl ∘ f)
+
+        isAntisym⊑ : isAntisym
+        isAntisym⊑ = elimProp2 (λ x y → isPropΠ2 λ _ _ → squash/ x y)
+                                λ a b fa≤fb fb≤fa → eq/ a b (anti (f a) (f b) fa≤fb fb≤fa)
+
+        isTrans⊑ : isTrans
+        isTrans⊑ = elimProp3 (λ x _ z → isPropΠ2 λ _ _ → isProp⊑ x z)
+                              λ a b c → trans (f a) (f b) (f c)
+
+        poset⊑ : IsPoset _⊑_
+        poset⊑ = isposet squash/ isProp⊑ isRefl⊑ isTrans⊑ isAntisym⊑
+
+        F : Poset ℓ ℓ'
+        F = F' , (posetstr _⊑_ poset⊑)
+
+        ♮ : ⟨ E ⟩ → ⟨ F ⟩
+        ♮ = [_]
+
+        is♮ : IsIsotone (snd E) ♮ (snd F)
+        IsIsotone.pres≤ is♮ x y x≤y = IsIsotone.pres≤ isf x y x≤y
+
+        ♮⁺ : ⟨ F ⟩ → ⟨ E ⟩
+        ♮⁺ [ x ] = f x
+        ♮⁺ (eq/ a b fa≡fb i) = fa≡fb i
+        ♮⁺ (squash/ x y p q i j) = isSet→SquareP (λ _ _ → set)
+          (λ _ → ♮⁺ x)
+          (λ _ → ♮⁺ y)
+          (λ i → ♮⁺ (p i))
+          (λ i → ♮⁺ (q i)) j i
+
+        is♮⁺ : IsIsotone (snd F) ♮⁺ (snd E)
+        IsIsotone.pres≤ is♮⁺ = elimProp2 (λ x y → isPropΠ λ _ → prop (♮⁺ x) (♮⁺ y))
+                                          λ x y fx≤fy → fx≤fy
+
+        ♮∘♮⁺ : ∀ x → (♮ ∘ ♮⁺) x ⊑ x
+        ♮∘♮⁺ = elimProp (λ x → isProp⊑ ((♮ ∘ ♮⁺) x) x)
+                        λ x → subst (_≤ f x) (funExt⁻ f≡f∘f x) (rfl (f x))
+
+isDualClosure→ComposedResidual : {E : Poset ℓ ℓ'}
+                                 {f : ⟨ E ⟩ → ⟨ E ⟩}
+                               → isDualClosure E f
+                               → Σ[ F ∈ Poset ℓ ℓ' ] (Σ[ g ∈ (⟨ F ⟩ → ⟨ E ⟩) ] (Σ[ res ∈ hasResidual F E g ] f ≡ g ∘ (residual F E g res)))
+isDualClosure→ComposedResidual {ℓ} {ℓ'} {E = E} {f = f} (isf , f≡f∘f , fx≤x) = F , ♮ , (is♮ , ♮⁺ , is♮⁺ , ♮⁺∘♮ , fx≤x) , refl
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+        set = IsPoset.is-set is
+        prop = IsPoset.is-prop-valued is
+        rfl = IsPoset.is-refl is
+        anti = IsPoset.is-antisym is
+        trans = IsPoset.is-trans is
+
+        kerf : Rel ⟨ E ⟩ ⟨ E ⟩ ℓ
+        kerf x y = f x ≡ f y
+
+        F' = ⟨ E ⟩ / kerf
+
+        _⊑'_ : F' → F' → hProp _
+        _⊑'_ = fun
+          where
+            fun₀ : ⟨ E ⟩ → F' → hProp _
+            fst (fun₀ x [ y ]) = f x ≤ f y
+            snd (fun₀ x [ y ]) = prop (f x) (f y)
+            fun₀ x (eq/ a b fa≡fb i) = record
+              { fst = cong (f x ≤_) fa≡fb i
+              ; snd = isProp→PathP (λ i → isPropIsProp {A = cong (f x ≤_) fa≡fb i})
+                                   (prop (f x) (f a)) (prop (f x) (f b)) i
+              }
+            fun₀ x (squash/ a b p q i j) = isSet→SquareP (λ _ _ → isSetHProp)
+              (λ _ → fun₀ x a)
+              (λ _ → fun₀ x b)
+              (λ i → fun₀ x (p i))
+              (λ i → fun₀ x (q i)) j i
+
+            toPath : ∀ a b (p : kerf a b) (y : F') → fun₀ a y ≡ fun₀ b y
+            toPath a b fa≡fb = elimProp (λ _ → isSetHProp _ _) λ c →
+              Σ≡Prop (λ _ → isPropIsProp) (cong (_≤ f c) fa≡fb)
+
+            fun : F' → F' → hProp _
+            fun [ a ] y = fun₀ a y
+            fun (eq/ a b fa≡fb i) y = toPath a b fa≡fb y i
+            fun (squash/ x y p q i j) z = isSet→SquareP (λ _ _ → isSetHProp)
+              (λ _ → fun x z) (λ _ → fun y z) (λ i → fun (p i) z) (λ i → fun (q i) z) j i
+
+        _⊑_ : Rel F' F' ℓ'
+        a ⊑ b = (a ⊑' b) .fst
+
+        open BinaryRelation _⊑_
+
+        isProp⊑ : isPropValued
+        isProp⊑ a b = (a ⊑' b) .snd
+
+        isRefl⊑ : isRefl
+        isRefl⊑ = elimProp (λ x → isProp⊑ x x)
+                           (rfl ∘ f)
+
+        isAntisym⊑ : isAntisym
+        isAntisym⊑ = elimProp2 (λ x y → isPropΠ2 λ _ _ → squash/ x y)
+                                λ a b fa≤fb fb≤fa → eq/ a b (anti (f a) (f b) fa≤fb fb≤fa)
+
+        isTrans⊑ : isTrans
+        isTrans⊑ = elimProp3 (λ x _ z → isPropΠ2 λ _ _ → isProp⊑ x z)
+                              λ a b c → trans (f a) (f b) (f c)
+
+        poset⊑ : IsPoset _⊑_
+        poset⊑ = isposet squash/ isProp⊑ isRefl⊑ isTrans⊑ isAntisym⊑
+
+        F : Poset ℓ ℓ'
+        F = F' , (posetstr _⊑_ poset⊑)
+
+        ♮⁺ : ⟨ E ⟩ → ⟨ F ⟩
+        ♮⁺ = [_]
+
+        is♮⁺ : IsIsotone (snd E) ♮⁺ (snd F)
+        IsIsotone.pres≤ is♮⁺ x y x≤y = IsIsotone.pres≤ isf x y x≤y
+
+        ♮ : ⟨ F ⟩ → ⟨ E ⟩
+        ♮ [ x ] = f x
+        ♮ (eq/ a b fa≡fb i) = fa≡fb i
+        ♮ (squash/ x y p q i j) = isSet→SquareP (λ _ _ → set)
+          (λ _ → ♮ x)
+          (λ _ → ♮ y)
+          (λ i → ♮ (p i))
+          (λ i → ♮ (q i)) j i
+
+        is♮ : IsIsotone (snd F) ♮ (snd E)
+        IsIsotone.pres≤ is♮ = elimProp2 (λ x y → isPropΠ λ _ → prop (♮ x) (♮ y))
+                                         λ x y fx≤fy → fx≤fy
+
+        ♮⁺∘♮ : ∀ x → x ⊑ (♮⁺ ∘ ♮) x
+        ♮⁺∘♮ = elimProp (λ x → isProp⊑ x ((♮⁺ ∘ ♮) x))
+                        λ x → subst (f x ≤_) (funExt⁻ f≡f∘f x) (rfl (f x))
+
+ComposedResidual→isClosure : {E : Poset ℓ ℓ'}
+                             {f : ⟨ E ⟩ → ⟨ E ⟩}
+                           → Σ[ F ∈ Poset ℓ ℓ' ] (Σ[ g ∈ (⟨ E ⟩ → ⟨ F ⟩) ] (Σ[ res ∈ hasResidual E F g ] f ≡ (residual E F g res) ∘ g))
+                           → isClosure E f
+ComposedResidual→isClosure {E = E} {f = f} (F , g , (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺) , f≡g⁺∘g)
+  = subst (λ x → IsIsotone (snd E) x (snd E)) (sym f≡g⁺∘g) (IsIsotone-∘ (snd E) g (snd F) g⁺ (snd E) isg isg⁺) ,
+    f≡g⁺∘g ∙
+    sym (cong (g⁺ ∘_)
+              (AbsorbResidual E F g (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺))) ∙
+    cong (_∘ g⁺ ∘ g) (sym f≡g⁺∘g) ∙
+    cong (f ∘_) (sym f≡g⁺∘g) ,
+    λ x → subst (x ≤_) (sym (funExt⁻ f≡g⁺∘g x)) (g⁺∘g x)
+    where _≤_ = PosetStr._≤_ (snd E)
+
+ComposedResidual→isDualClosure : {E : Poset ℓ ℓ'}
+                                 {f : ⟨ E ⟩ → ⟨ E ⟩}
+                               → Σ[ F ∈ Poset ℓ ℓ' ] (Σ[ g ∈ (⟨ F ⟩ → ⟨ E ⟩) ] (Σ[ res ∈ hasResidual F E g ] f ≡ g ∘ (residual F E g res)))
+                               → isDualClosure E f
+ComposedResidual→isDualClosure {E = E} {f = f} (F , g , (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺) , f≡g∘g⁺)
+  = subst (λ x → IsIsotone (snd E) x (snd E)) (sym f≡g∘g⁺) (IsIsotone-∘ (snd E) g⁺ (snd F) g (snd E) isg⁺ isg) ,
+  f≡g∘g⁺ ∙
+  sym (cong (g ∘_) (ResidualAbsorb F E g (isg , g⁺ , isg⁺ , g⁺∘g , g∘g⁺))) ∙
+  cong (_∘ g ∘ g⁺) (sym f≡g∘g⁺) ∙
+  cong (f ∘_) (sym f≡g∘g⁺) ,
+  λ x → subst (_≤ x) (sym (funExt⁻ f≡g∘g⁺ x)) (g∘g⁺ x)
+  where _≤_ = PosetStr._≤_ (snd E)
+
+isPropIsClosure : {E : Poset ℓ ℓ'}
+                  {f : ⟨ E ⟩ → ⟨ E ⟩}
+                → isProp (isClosure E f)
+isPropIsClosure {E = E} {f = f}
+  = isProp× (isPropIsIsotone (snd E) f (snd E))
+            (isProp× (isSet→ (IsPoset.is-set is) _ _)
+                     (isPropΠ λ x → IsPoset.is-prop-valued is x (f x)))
+  where is = PosetStr.isPoset (snd E)
+
+isPropIsClosure' : {E : Poset ℓ ℓ'}
+                   {f : ⟨ E ⟩ → ⟨ E ⟩}
+                 → isProp (isClosure' E f)
+isPropIsClosure' {E = E} {f = f}
+  = isPropΠ2 λ x y → isOfHLevel≃ 1 (prop x (f y)) (prop (f x) (f y))
+  where prop = IsPoset.is-prop-valued (PosetStr.isPoset (snd E))
+
+isPropIsDualClosure : {E : Poset ℓ ℓ'}
+                      {f : ⟨ E ⟩ → ⟨ E ⟩}
+                    → isProp (isDualClosure E f)
+isPropIsDualClosure {E = E} {f = f}
+  = isProp× (isPropIsIsotone (snd E) f (snd E))
+            (isProp× (isSet→ (IsPoset.is-set is) _ _)
+                     (isPropΠ λ x → IsPoset.is-prop-valued is (f x) x))
+  where is = PosetStr.isPoset (snd E)
+
+isPropIsDualClosure' : {E : Poset ℓ ℓ'}
+                       {f : ⟨ E ⟩ → ⟨ E ⟩}
+                     → isProp (isDualClosure' E f)
+isPropIsDualClosure' {E = E} {f = f}
+  = isPropΠ2 λ x y → isOfHLevel≃ 1 (prop (f x) y) (prop (f x) (f y))
+  where prop = IsPoset.is-prop-valued (PosetStr.isPoset (snd E))
+
+isClosureSubset : (E : Poset ℓ ℓ')
+                → (F : Embedding ⟨ E ⟩ ℓ)
+                → Type _
+isClosureSubset E F = Σ[ f ∈ (⟨ E ⟩ → ⟨ E ⟩) ] (isClosure E f × (F ≡ (Image f , imageInclusion f)))
+
+isDualClosureSubset : (E : Poset ℓ ℓ')
+                    → (F : Embedding ⟨ E ⟩ ℓ)
+                    → Type _
+isDualClosureSubset E F = Σ[ f ∈ (⟨ E ⟩ → ⟨ E ⟩) ] (isDualClosure E f × (F ≡ (Image f , imageInclusion f)))
+
+ClosureSubsetOperatorUnique : {E : Poset ℓ ℓ'}
+                              {F : Embedding ⟨ E ⟩ ℓ}
+                            → (f g : isClosureSubset E F)
+                            → f .fst ≡ g .fst
+ClosureSubsetOperatorUnique {E = E} {F = F}
+                            (f , (isf , f≡f∘f , x≤fx) , F≡Imf)
+                            (g , (isg , g≡g∘g , x≤gx) , F≡Img)
+  = funExt λ x → anti (f x) (g x) (fx≤gx x) (gx≤fx x)
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        prop = IsPoset.is-prop-valued is
+        anti = IsPoset.is-antisym is
+
+        Imf⊆Img : (Image f , imageInclusion f) ⊆ₑ (Image g , imageInclusion g)
+        Imf⊆Img x = subst (x ∈ₑ_) (sym F≡Imf ∙ F≡Img)
+
+        Img⊆Imf : (Image g , imageInclusion g) ⊆ₑ (Image f , imageInclusion f)
+        Img⊆Imf x = subst (x ∈ₑ_) (sym F≡Img ∙ F≡Imf)
+
+        fx≤gx : ∀ x → f x ≤ g x
+        fx≤gx x = ∥₁.rec (prop (f x) (g x))
+                          (λ { (a , fa≡gx) → subst (f x ≤_)
+                                               (sym (funExt⁻ f≡f∘f a) ∙
+                                                fa≡gx ∙
+                                                lemma .snd)
+                                               (IsIsotone.pres≤ isf x (f a)
+                                                (subst (x ≤_)
+                                                  (sym (fa≡gx ∙ lemma .snd))
+                                                    (x≤gx x))) })
+                          (lemma .fst .snd)
+              where lemma = Img⊆Imf (g x) (((g x) , ∣ x , refl ∣₁) , refl)
+
+        gx≤fx : ∀ x → g x ≤ f x
+        gx≤fx x = ∥₁.rec (prop (g x) (f x))
+                         (λ { (a , ga≡fx) → subst (g x ≤_)
+                                              (sym (funExt⁻ g≡g∘g a) ∙
+                                                    ga≡fx ∙
+                                                    lemma .snd)
+                                              (IsIsotone.pres≤ isg x (g a)
+                                               (subst (x ≤_)
+                                                 (sym (ga≡fx ∙ lemma .snd))
+                                                   (x≤fx x))) })
+                         (lemma .fst .snd)
+              where lemma = Imf⊆Img (f x) (((f x) , ∣ x , refl ∣₁) , refl)
+
+DualClosureSubsetOperatorUnique : {E : Poset ℓ ℓ'}
+                                  {F : Embedding ⟨ E ⟩ ℓ}
+                                → (f g : isDualClosureSubset E F)
+                                → f .fst ≡ g .fst
+DualClosureSubsetOperatorUnique {E = E} {F = F}
+                                (f , (isf , f≡f∘f , fx≤x) , F≡Imf)
+                                (g , (isg , g≡g∘g , gx≤x) , F≡Img)
+  = funExt λ x → anti (f x) (g x) (fx≤gx x) (gx≤fx x)
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        prop = IsPoset.is-prop-valued is
+        anti = IsPoset.is-antisym is
+
+        Imf⊆Img : (Image f , imageInclusion f) ⊆ₑ (Image g , imageInclusion g)
+        Imf⊆Img x = subst (x ∈ₑ_) (sym F≡Imf ∙ F≡Img)
+
+        Img⊆Imf : (Image g , imageInclusion g) ⊆ₑ (Image f , imageInclusion f)
+        Img⊆Imf x = subst (x ∈ₑ_) (sym F≡Img ∙ F≡Imf)
+
+        gx≤fx : ∀ x → g x ≤ f x
+        gx≤fx x = ∥₁.rec (prop (g x) (f x))
+                         (λ { (a , fa≡gx) → subst (_≤ f x) (sym (funExt⁻ f≡f∘f a) ∙
+                                                                  fa≡gx ∙
+                                                                  lemma .snd)
+                                                            (IsIsotone.pres≤ isf (f a) x
+                                                             (subst (_≤ x)
+                                                               (sym (fa≡gx ∙ lemma .snd))
+                                                                 (gx≤x x))) })
+                         (lemma .fst .snd)
+              where lemma = Img⊆Imf (g x) (((g x) , ∣ x , refl ∣₁) , refl)
+
+        fx≤gx : ∀ x → f x ≤ g x
+        fx≤gx x = ∥₁.rec (prop (f x) (g x))
+                         (λ { (a , ga≡fx) → subst (_≤ g x)
+                                              (sym (funExt⁻ g≡g∘g a) ∙
+                                                    ga≡fx ∙
+                                                    lemma .snd)
+                                              (IsIsotone.pres≤ isg (g a) x
+                                                (subst (_≤ x)
+                                                  (sym (ga≡fx ∙ lemma .snd))
+                                                    (fx≤x x))) })
+                         (lemma .fst .snd)
+              where lemma = Imf⊆Img (f x) (((f x) , ∣ x , refl ∣₁) , refl)
+
+isPropIsClosureSubset : {E : Poset ℓ ℓ'}
+                        {F : Embedding ⟨ E ⟩ ℓ}
+                      → isProp (isClosureSubset E F)
+isPropIsClosureSubset p q = Σ≡Prop (λ f → isProp× isPropIsClosure (isSetEmbedding _ _))
+                                    (ClosureSubsetOperatorUnique p q)
+
+isPropIsDualClosureSubset : {E : Poset ℓ ℓ'}
+                            {F : Embedding ⟨ E ⟩ ℓ}
+                          → isProp (isDualClosureSubset E F)
+isPropIsDualClosureSubset p q = Σ≡Prop (λ f → isProp× isPropIsDualClosure (isSetEmbedding _ _))
+                                        (DualClosureSubsetOperatorUnique p q)
+
+isClosureSubset→IntersectionBottom : (E : Poset ℓ ℓ')
+                                     (F : Embedding ⟨ E ⟩ ℓ)
+                                   → isClosureSubset E F
+                                   → ∀ x
+                                   → Least (isPoset→isProset (PosetStr.isPoset (snd E))) (principalUpset E x ∩ₑ F)
+isClosureSubset→IntersectionBottom E F (f , (isf , f≡f∘f , x≤fx) , F≡Imf) x
+  = (f x , fx∈x↑ , fx∈F ) , least
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        prop = IsPoset.is-prop-valued is
+
+        fx∈x↑ : f x ∈ₑ principalUpset E x
+        fx∈x↑ = equivFun (principalUpsetMembership E x (f x)) (x≤fx x)
+
+        fx∈F : f x ∈ₑ F
+        fx∈F = subst (f x ∈ₑ_) (sym F≡Imf) ((f x , ∣ x , refl ∣₁) , refl)
+
+        least : isLeast (isPoset→isProset is) (principalUpset E x ∩ₑ F) (f x , fx∈x↑ , fx∈F)
+        least (y , y∈x↑ , y∈F) = ∥₁.rec (prop _ _)
+                                        (λ { (a , fa≡fz)
+                                           → subst (f x ≤_)
+                                            (sym (funExt⁻ f≡f∘f a ∙
+                                                 cong f (fa≡fz ∙
+                                                         lemma .snd)) ∙
+                                                 fa≡fz ∙
+                                                 lemma .snd)
+                                            (IsIsotone.pres≤ isf x y
+                                              (invEq (principalUpsetMembership E x y) y∈x↑)) })
+                                         (lemma .fst .snd)
+          where lemma = subst (y ∈ₑ_) F≡Imf y∈F
+
+IntersectionBottom→isClosureSubset : (E : Poset ℓ ℓ)
+                                     (F : Embedding ⟨ E ⟩ ℓ)
+                                   → (∀ x → Least (isPoset→isProset (PosetStr.isPoset (snd E))) (principalUpset E x ∩ₑ F))
+                                   → isClosureSubset E F
+IntersectionBottom→isClosureSubset E F least
+  = f , (isf , f≡f∘f , x≤f) , F≡Imf
+    where _≤_ = PosetStr._≤_ (snd E)
+          is = PosetStr.isPoset (snd E)
+
+          rfl = IsPoset.is-refl is
+          anti = IsPoset.is-antisym is
+
+          f : ⟨ E ⟩ → ⟨ E ⟩
+          f x = least x .fst .fst
+
+          isf : IsIsotone (snd E) f (snd E)
+          IsIsotone.pres≤ isf x y x≤y = least x .snd (f y , y↑∩F⊆x↑∩F (f y) ((least y .fst) , refl) .fst .snd)
+            where x↑ = principalUpset E x
+                  y↑ = principalUpset E y
+
+                  y↑⊆x↑ = principalUpsetInclusion E x y x≤y
+                  y↑∩F⊆x↑∩F = isMeetIsotone
+                              (isPoset→isProset isPoset⊆ₑ) y↑ x↑ F F
+                              (y↑ ∩ₑ F)
+                              (x↑ ∩ₑ F)
+                              (isMeet∩ₑ y↑ F)
+                              (isMeet∩ₑ x↑ F)
+                               y↑⊆x↑
+                              (isRefl⊆ₑ F)
+
+          x≤f : ∀ x → x ≤ f x
+          x≤f x = invEq (principalUpsetMembership E x (f x)) (least x .fst .snd .fst)
+
+          F≡fF : ∀ y → y ∈ₑ F
+                      → y ≡ f y
+          F≡fF y y∈F = anti y (f y) (x≤f y)
+                       (least y .snd (y , equivFun (principalUpsetMembership E y y) (rfl y) , y∈F))
+
+          f≡f∘f : f ≡ (f ∘ f)
+          f≡f∘f = funExt λ x → F≡fF (f x) (least x .fst .snd .snd)
+
+          F⊆Imf : F ⊆ₑ (Image f , imageInclusion f)
+          F⊆Imf x x∈F = (x , ∣ x , (sym (F≡fF x x∈F)) ∣₁) , refl
+
+          Imf⊆F : (Image f , imageInclusion f) ⊆ₑ F
+          Imf⊆F x ((a , ima) , fib)
+            = ∥₁.rec (isProp∈ₑ x F)
+                     (λ { (b , fb≡a) →
+                           subst (_∈ₑ F)
+                                 (fb≡a ∙ fib)
+                                 (least b .fst .snd .snd) }) ima
+
+          F≡Imf : F ≡ (Image f , imageInclusion f)
+          F≡Imf = isAntisym⊆ₑ F (Image f , imageInclusion f) F⊆Imf Imf⊆F
+
+isBicomplete : (E : Poset ℓ ℓ')
+               (F : Embedding ⟨ E ⟩ ℓ)
+             → Type _
+isBicomplete E F = isClosureSubset E F × isClosureSubset (DualPoset E) F
+
+isBicompleteResiduatedClosureImage : (E : Poset ℓ ℓ')
+                                     (f : ⟨ E ⟩ → ⟨ E ⟩)
+                                   → hasResidual E E f
+                                   → isClosure E f
+                                   → isBicomplete E (Image f , imageInclusion f)
+isBicompleteResiduatedClosureImage E f (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺) (_ , f≡f∘f , x≤fx)
+  = (f , clsf , refl) , f⁺ , clsf⁺ , Imf≡Imf⁺
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+
+        anti = IsPoset.is-antisym is
+
+        resf = (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺)
+        clsf = (isf , f≡f∘f , x≤fx)
+
+        f≡f⁺∘f : f ≡ f⁺ ∘ f
+        f≡f⁺∘f = funExt λ x → anti (f x) ((f⁺ ∘ f) x) (f≤f⁺∘f x) (f⁺∘f≤f x)
+          where f≤f⁺∘f : ∀ x → f x ≤ (f⁺ ∘ f) x
+                f≤f⁺∘f x = subst (f x ≤_)
+                                 (cong f⁺ (sym (funExt⁻ f≡f∘f x))) (f⁺∘f (f x))
+
+                f⁺∘f≤f : ∀ x → (f⁺ ∘ f) x ≤ f x
+                f⁺∘f≤f x = subst ((f⁺ ∘ f) x ≤_)
+                                 (funExt⁻ (AbsorbResidual E E f resf) x)
+                                 (x≤fx ((f⁺ ∘ f) x))
+
+        f⁺≡f∘f⁺ : f⁺ ≡ f ∘ f⁺
+        f⁺≡f∘f⁺ = funExt λ x → sym (funExt⁻ (ResidualAbsorb E E f resf) x) ∙
+                               funExt⁻ (sym f≡f⁺∘f) (f⁺ x)
+
+        Imf⊆Imf⁺ : (Image f , imageInclusion f) ⊆ₑ (Image f⁺ , imageInclusion f⁺)
+        Imf⊆Imf⁺ x ((a , ima) , fib) = ∥₁.rec (isProp∈ₑ x (Image f⁺ , imageInclusion f⁺))
+                                              (λ { (b , fb≡a) → (x , ∣ x , (cong f⁺ (sym (fb≡a ∙ fib)) ∙
+                                                                            funExt⁻ (sym f≡f⁺∘f) b ∙
+                                                                            fb≡a ∙
+                                                                            fib) ∣₁) , refl })
+                                               ima
+
+        Imf⁺⊆Imf : (Image f⁺ , imageInclusion f⁺) ⊆ₑ (Image f , imageInclusion f)
+        Imf⁺⊆Imf x ((a , ima) , fib) = ∥₁.rec (isProp∈ₑ x (Image f , imageInclusion f))
+                                              (λ { (b , f⁺b≡a) → (x , ∣ x , (cong f (sym (f⁺b≡a ∙ fib)) ∙
+                                                                             funExt⁻ (sym f⁺≡f∘f⁺) b ∙
+                                                                             f⁺b≡a ∙
+                                                                             fib) ∣₁) , refl })
+                                               ima
+
+        Imf≡Imf⁺ : (Image f , imageInclusion f) ≡ (Image f⁺ , imageInclusion f⁺)
+        Imf≡Imf⁺ = isAntisym⊆ₑ _ _ Imf⊆Imf⁺ Imf⁺⊆Imf
+
+        clsf⁺ : isClosure (DualPoset E) f⁺
+        clsf⁺ = DualIsotoneDual E E f⁺ isf⁺ ,
+                f⁺≡f∘f⁺ ∙ cong (_∘ f⁺) f≡f⁺∘f ∙ cong (f⁺ ∘_) (sym f⁺≡f∘f⁺) ,
+                λ x → subst (_≤ x) (funExt⁻ (sym f⁺≡f∘f⁺) x) (f∘f⁺ x)
+
+isBicomplete→ClosureOperatorHasResidual : (E : Poset ℓ ℓ')
+                                          (F : Embedding ⟨ E ⟩ ℓ)
+                                        → (bi : isBicomplete E F)
+                                        → hasResidual E E (bi . fst .fst)
+isBicomplete→ClosureOperatorHasResidual E F ((f , (isf , f≡f∘f , x≤fx) , F≡Imf) ,
+                                              f⁺ , (isf⁺ , f⁺≡f⁺∘f⁺ , f⁺x≤x) , F≡Imf⁺)
+  = isf , f⁺ , DualIsotoneDual' E E f⁺ isf⁺ , f⁺∘f , f∘f⁺
+  where _≤_ = PosetStr._≤_ (snd E)
+        is = PosetStr.isPoset (snd E)
+        set = IsPoset.is-set is
+
+        Imf⁺⊆Imf : (Image f⁺ , imageInclusion f⁺) ⊆ₑ (Image f , imageInclusion f)
+        Imf⁺⊆Imf = subst (Imf⁺ ⊆ₑ_) ((sym F≡Imf⁺) ∙ F≡Imf) (isRefl⊆ₑ Imf⁺)
+          where Imf⁺ = (Image f⁺ , imageInclusion f⁺)
+
+        Imf⊆Imf⁺ : (Image f , imageInclusion f) ⊆ₑ (Image f⁺ , imageInclusion f⁺)
+        Imf⊆Imf⁺ = subst (Imf ⊆ₑ_) ((sym F≡Imf) ∙ F≡Imf⁺) (isRefl⊆ₑ Imf)
+          where Imf = (Image f , imageInclusion f)
+
+        f≡f⁺∘f : ∀ x → f x ≡ (f⁺ ∘ f) x
+        f≡f⁺∘f x = ∥₁.rec (set _ _) (λ { (b , f⁺b≡a) → (sym (f⁺b≡a ∙ fib) ∙ funExt⁻ f⁺≡f⁺∘f⁺ b) ∙ cong f⁺ (f⁺b≡a ∙ fib) }) ima
+          where lemma = Imf⊆Imf⁺ (f x) (((f x) , ∣ x , refl ∣₁) , refl)
+
+                ima = lemma .fst .snd
+                fib = lemma .snd
+
+        f⁺≡f∘f⁺ : ∀ x → f⁺ x ≡ (f ∘ f⁺) x
+        f⁺≡f∘f⁺ x = ∥₁.rec (set _ _) (λ { (b , fb≡a) → (sym (fb≡a ∙ fib) ∙ funExt⁻ f≡f∘f b) ∙ cong f (fb≡a ∙ fib) }) ima
+          where lemma = Imf⁺⊆Imf (f⁺ x) (((f⁺ x) , ∣ x , refl ∣₁) , refl)
+
+                ima = lemma .fst .snd
+                fib = lemma .snd
+
+        f⁺∘f : ∀ x → x ≤ (f⁺ ∘ f) x
+        f⁺∘f x = subst (x ≤_) (f≡f⁺∘f x) (x≤fx x)
+
+        f∘f⁺ : ∀ x → (f ∘ f⁺) x ≤ x
+        f∘f⁺ x = subst (_≤ x) (f⁺≡f∘f⁺ x) (f⁺x≤x x)
+
+IsPosetEquiv→isResiduatedBijection : (P S : Poset ℓ ℓ')
+                                     (e : ⟨ P ⟩ ≃ ⟨ S ⟩)
+                                   → IsPosetEquiv (snd P) e (snd S)
+                                   → hasResidual P S (equivFun e)
+IsPosetEquiv→isResiduatedBijection P S e eq
+  = IsPosetEquiv→IsIsotone P S e eq , invEq e , is⁻ ,
+   (λ x → subst (x ≤P_) (sym (retEq e x)) (rflP x)) ,
+    λ x → subst (_≤S x) (sym (secEq e x)) (rflS x)
+  where _≤P_ = PosetStr._≤_ (snd P)
+        _≤S_ = PosetStr._≤_ (snd S)
+
+        rflP = IsPoset.is-refl (PosetStr.isPoset (snd P))
+        rflS = IsPoset.is-refl (PosetStr.isPoset (snd S))
+
+        is⁻ : IsIsotone (snd S) (invEq e) (snd P)
+        IsIsotone.pres≤ is⁻ x y = equivFun (IsPosetEquiv.pres≤⁻ eq x y)
+
+isResiduatedBijection→IsPosetEquiv : (P S : Poset ℓ ℓ')
+                                     (e : ⟨ P ⟩ ≃ ⟨ S ⟩)
+                                   → hasResidual P S (equivFun e)
+                                   → IsPosetEquiv (snd P) e (snd S)
+IsPosetEquiv.pres≤ (isResiduatedBijection→IsPosetEquiv P S e
+                    (ise , e⁻ , ise⁻ , e⁻∘e , e∘e⁻)) x y
+  = propBiimpl→Equiv (propP _ _) (propS _ _) (IsIsotone.pres≤ ise x y) (subst2 _≤P_ (lemma x) (lemma y) ∘ IsIsotone.pres≤ ise⁻ _ _)
+  where _≤P_ = PosetStr._≤_ (snd P)
+        isP = PosetStr.isPoset (snd P)
+        propP = IsPoset.is-prop-valued isP
+        rflP = IsPoset.is-refl isP
+
+        _≤S_ = PosetStr._≤_ (snd S)
+        isS = PosetStr.isPoset (snd S)
+        propS = IsPoset.is-prop-valued isS
+        antiS = IsPoset.is-antisym isS
+
+        e∘e⁻x≡x : ∀ x → equivFun e (e⁻ x) ≡ x
+        e∘e⁻x≡x x = antiS _ x (e∘e⁻ x)
+                              (subst2 _≤S_ (secEq e x)
+                                           (cong (equivFun e ∘ e⁻) (secEq e x))
+                                           (IsIsotone.pres≤ ise _ _ (e⁻∘e (invEq e x))))
+
+        e⁻≡inv : ∀ x → e⁻ x ≡ invEq e x
+        e⁻≡inv x = sym (retEq e (e⁻ x)) ∙ cong (invEq e) (e∘e⁻x≡x x)
+
+        lemma : ∀ x → e⁻ (equivFun e x) ≡ x
+        lemma x = e⁻≡inv (equivFun e x) ∙ retEq e x
+
+-- We can weaken the equivalence of a poset equivalence to a surjection
+isOrderRecovering→isEmbedding : (P S : Poset ℓ ℓ')
+                                (f : ⟨ P ⟩ → ⟨ S ⟩)
+                              → (∀ x y → (PosetStr._≤_ (snd S) (f x) (f y))
+                                       → (PosetStr._≤_ (snd P) x y))
+                              → isEmbedding f
+isOrderRecovering→isEmbedding P S f is = emb
+  where _≤_ = PosetStr._≤_ (snd S)
+
+        isP = PosetStr.isPoset (snd P)
+        isS = PosetStr.isPoset (snd S)
+
+        setS = IsPoset.is-set isS
+
+        antiP = IsPoset.is-antisym isP
+        rflS = IsPoset.is-refl isS
+
+        emb : isEmbedding f
+        emb = injEmbedding setS λ {w} {x} fw≡fx
+            → antiP w x (is w x (subst (f w ≤_) fw≡fx (rflS (f w))))
+                        (is x w (subst (_≤ f w) fw≡fx (rflS (f w))))
+
+-- Galois connections work similarly to residuals, but are antitone
+module _
+  (E F : Poset ℓ ℓ')
+  (f : ⟨ E ⟩ → ⟨ F ⟩)
+  (g : ⟨ F ⟩ → ⟨ E ⟩)
+  where
+    private
+      _≤E_ = PosetStr._≤_ (snd E)
+      _≤F_ = PosetStr._≤_ (snd F)
+
+      propE = IsPoset.is-prop-valued (PosetStr.isPoset (snd E))
+      propF = IsPoset.is-prop-valued (PosetStr.isPoset (snd F))
+
+    isGaloisConnection : Type (ℓ-max ℓ ℓ')
+    isGaloisConnection = IsAntitone (snd E) f (snd F) ×
+                         IsAntitone (snd F) g (snd E) ×
+                        (∀ x → x ≤F (f ∘ g) x) ×
+                        (∀ x → x ≤E (g ∘ f) x)
+
+    isPropIsGaloisConnection : isProp isGaloisConnection
+    isPropIsGaloisConnection = isProp× (isPropIsAntitone _ _ _)
+                              (isProp× (isPropIsAntitone _ _ _)
+                              (isProp× (isPropΠ λ x → propF x _)
+                                       (isPropΠ λ x → propE x _)))
+
+    isGaloisConnection→hasResidualDual : isGaloisConnection
+                                       → hasResidual E (DualPoset F) f
+    isGaloisConnection→hasResidualDual (antif , antig , f∘g , g∘f)
+      = AntitoneDual E F f antif , g , DualAntitone F E g antig , g∘f , f∘g
+
+    AbsorbGaloisConnection : isGaloisConnection
+                           → f ∘ g ∘ f ≡ f
+    AbsorbGaloisConnection conn
+      = AbsorbResidual E (DualPoset F) f (isGaloisConnection→hasResidualDual conn)
+
+    GaloisConnectionAbsorb : isGaloisConnection
+                           → g ∘ f ∘ g ≡ g
+    GaloisConnectionAbsorb conn
+      = ResidualAbsorb E (DualPoset F) f (isGaloisConnection→hasResidualDual conn)
+
+    GaloisConnectionClosure : isGaloisConnection
+                            → isClosure E (g ∘ f)
+    GaloisConnectionClosure conn
+      = ComposedResidual→isClosure (DualPoset F , f , isGaloisConnection→hasResidualDual conn , refl)
+
+    GaloisConnectionDualClosure : isGaloisConnection
+                                → isDualClosure (DualPoset F) (f ∘ g)
+    GaloisConnectionDualClosure conn
+      = ComposedResidual→isDualClosure (E , f , isGaloisConnection→hasResidualDual conn , refl)
+
+hasResidual→isGaloisConnectionDual : (E F : Poset ℓ ℓ')
+                                     (f : ⟨ E ⟩ → ⟨ F ⟩)
+                                   → (res : hasResidual E F f)
+                                   → isGaloisConnection E (DualPoset F) f (residual E F f res)
+hasResidual→isGaloisConnectionDual E F f (isf , f⁺ , isf⁺ , f⁺∘f , f∘f⁺)
+  = (IsotoneDual E F f isf) , (DualIsotone F E f⁺ isf⁺) , f∘f⁺ , f⁺∘f
diff --git a/Cubical/Relation/Binary/Order/Poset/Properties.agda b/Cubical/Relation/Binary/Order/Poset/Properties.agda
index a3122fb1ca..323689256e 100644
--- a/Cubical/Relation/Binary/Order/Poset/Properties.agda
+++ b/Cubical/Relation/Binary/Order/Poset/Properties.agda
@@ -1,8 +1,14 @@
 {-# OPTIONS --safe #-}
 module Cubical.Relation.Binary.Order.Poset.Properties where
 
-open import Cubical.Foundations.Prelude
+open import Cubical.Data.Sigma
+open import Cubical.Data.Sum
+
+open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Transport
 
 open import Cubical.Functions.Embedding
 
@@ -12,14 +18,14 @@ open import Cubical.Data.Sigma
 
 open import Cubical.Relation.Binary.Base
 open import Cubical.Relation.Binary.Order.Poset.Base
-open import Cubical.Relation.Binary.Order.Preorder.Base
-open import Cubical.Relation.Binary.Order.StrictPoset.Base
+open import Cubical.Relation.Binary.Order.Proset
+open import Cubical.Relation.Binary.Order.Quoset.Base
 
 open import Cubical.Relation.Nullary
 
 private
   variable
-    ℓ ℓ' ℓ'' : Level
+    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
 
 module _
   {A : Type ℓ}
@@ -28,22 +34,30 @@ module _
 
   open BinaryRelation
 
-  isPoset→isPreorder : IsPoset R → IsPreorder R
-  isPoset→isPreorder poset = ispreorder
+  isPoset→isProset : IsPoset R → IsProset R
+  isPoset→isProset poset = isproset
                              (IsPoset.is-set poset)
                              (IsPoset.is-prop-valued poset)
                              (IsPoset.is-refl poset)
                              (IsPoset.is-trans poset)
 
+  isPosetDecidable→Discrete : IsPoset R → isDecidable R → Discrete A
+  isPosetDecidable→Discrete pos dec a b with dec a b
+  ... | no ¬Rab = no (λ a≡b → ¬Rab (subst (R a) a≡b (IsPoset.is-refl pos a)))
+  ... | yes Rab with dec b a
+  ...       | no ¬Rba = no (λ a≡b → ¬Rba (subst (λ x → R x a) a≡b
+                                         (IsPoset.is-refl pos a)))
+  ...       | yes Rba = yes (IsPoset.is-antisym pos a b Rab Rba)
+
   private
     transirrefl : isTrans R → isAntisym R → isTrans (IrreflKernel R)
     transirrefl trans anti a b c (Rab , ¬a≡b) (Rbc , ¬b≡c)
       = trans a b c Rab Rbc
       , λ a≡c → ¬a≡b (anti a b Rab (subst (R b) (sym a≡c) Rbc))
 
-  isPoset→isStrictPosetIrreflKernel : IsPoset R → IsStrictPoset (IrreflKernel R)
-  isPoset→isStrictPosetIrreflKernel poset
-    = isstrictposet (IsPoset.is-set poset)
+  isPoset→isQuosetIrreflKernel : IsPoset R → IsQuoset (IrreflKernel R)
+  isPoset→isQuosetIrreflKernel poset
+    = isquoset (IsPoset.is-set poset)
                     (λ a b → isProp× (IsPoset.is-prop-valued poset a b)
                                      (isProp¬ (a ≡ b)))
                     (isIrreflIrreflKernel R)
@@ -54,6 +68,13 @@ module _
                                              , transirrefl (IsPoset.is-trans poset)
                                                            (IsPoset.is-antisym poset)))
 
+  isPosetDecidable→isQuosetDecidable : IsPoset R → isDecidable R → isDecidable (IrreflKernel R)
+  isPosetDecidable→isQuosetDecidable pos dec a b with dec a b
+  ... | no ¬Rab = no λ { (Rab , _) → ¬Rab Rab }
+  ... | yes Rab with (isPosetDecidable→Discrete pos dec) a b
+  ...       | yes a≡b = no λ { (_ , ¬a≡b) → ¬a≡b a≡b }
+  ...       | no a≢b = yes (Rab , a≢b)
+
   isPosetInduced : IsPoset R → (B : Type ℓ'') → (f : B ↪ A) → IsPoset (InducedRelation R (B , f))
   isPosetInduced pos B (f , emb)
     = isposet (Embedding-into-isSet→isSet (f , emb) (IsPoset.is-set pos))
@@ -63,28 +84,532 @@ module _
               λ a b a≤b b≤a → isEmbedding→Inj emb a b
                 (IsPoset.is-antisym pos (f a) (f b) a≤b b≤a)
 
-Poset→Preorder : Poset ℓ ℓ' → Preorder ℓ ℓ'
-Poset→Preorder (_ , pos) = _ , preorderstr (PosetStr._≤_ pos)
-                                           (isPoset→isPreorder (PosetStr.isPoset pos))
+  isPosetDual : IsPoset R → IsPoset (Dual R)
+  isPosetDual pos
+    = isposet (IsPoset.is-set pos)
+              (λ a b → IsPoset.is-prop-valued pos b a)
+              (IsPoset.is-refl pos)
+              (λ a b c Rab Rbc → IsPoset.is-trans pos c b a Rbc Rab)
+              (λ a b Rab Rba → IsPoset.is-antisym pos a b Rba Rab)
+
+Poset→Proset : Poset ℓ ℓ' → Proset ℓ ℓ'
+Poset→Proset (_ , pos)
+  = proset _ (PosetStr._≤_ pos)
+             (isPoset→isProset (PosetStr.isPoset pos))
+
+Poset→Quoset : Poset ℓ ℓ' → Quoset ℓ (ℓ-max ℓ ℓ')
+Poset→Quoset (_ , pos)
+  = quoset _ (BinaryRelation.IrreflKernel (PosetStr._≤_ pos))
+             (isPoset→isQuosetIrreflKernel (PosetStr.isPoset pos))
+
+DualPoset : Poset ℓ ℓ' → Poset ℓ ℓ'
+DualPoset (_ , pos)
+  = poset _ (BinaryRelation.Dual (PosetStr._≤_ pos))
+            (isPosetDual (PosetStr.isPoset pos))
+
+module _
+  {A : Type ℓ}
+  {_≤_ : Rel A A ℓ'}
+  (pos : IsPoset _≤_)
+  where
+
+  private
+      pre = isPoset→isProset pos
+
+      set = IsPoset.is-set pos
+
+      prop = IsPoset.is-prop-valued pos
+
+      rfl = IsPoset.is-refl pos
+
+      anti = IsPoset.is-antisym pos
+
+      trans = IsPoset.is-trans pos
+
+  module _
+    {P : Embedding A ℓ''}
+    where
+
+    private
+      toA = fst (snd P)
+
+      emb = snd (snd P)
+
+    isLeast→ContrMinimal : ∀ n → isLeast pre P n  → ∀ m → isMinimal pre P m → n ≡ m
+    isLeast→ContrMinimal n isln m ismm
+      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isln m) (ismm n (isln m)))
+
+    isGreatest→ContrMaximal : ∀ n → isGreatest pre P n → ∀ m → isMaximal pre P m → n ≡ m
+    isGreatest→ContrMaximal n isgn m ismm
+      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (ismm n (isgn m)) (isgn m))
+
+    isLeastUnique : ∀ n m → isLeast pre P n → isLeast pre P m → n ≡ m
+    isLeastUnique n m isln islm
+      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isln m) (islm n))
+
+    isGreatestUnique : ∀ n m → isGreatest pre P n → isGreatest pre P m → n ≡ m
+    isGreatestUnique n m isgn isgm
+      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isgm n) (isgn m))
+
+    LeastUnique : (n m : Least pre P) → n ≡ m
+    LeastUnique (n , ln) (m , lm) = Σ≡Prop (λ _ → isPropIsLeast pre P _) (isLeastUnique n m ln lm)
+
+    GreatestUnique : (n m : Greatest pre P) → n ≡ m
+    GreatestUnique (n , gn) (m , gm) = Σ≡Prop (λ _ → isPropIsGreatest pre P _) (isGreatestUnique n m gn gm)
+
+  module _
+    {B : Type ℓ''}
+    {P : B → A}
+    where
+
+    isInfimum→ContrMaximalLowerBound : ∀ n → isInfimum pre P n
+                                     → ∀ m → isMaximalLowerBound pre P m
+                                     → n ≡ m
+    isInfimum→ContrMaximalLowerBound n (isln , isglbn) m (islm , ismlbm)
+      = anti n m (ismlbm (n , isln) (isglbn (m , islm))) (isglbn (m , islm))
+
+    isSupremum→ContrMinimalUpperBound : ∀ n → isSupremum pre P n
+                                      → ∀ m → isMinimalUpperBound pre P m
+                                      → n ≡ m
+    isSupremum→ContrMinimalUpperBound n (isun , islubn) m (isum , ismubm)
+      = anti n m (islubn (m , isum)) (ismubm (n , isun) (islubn (m , isum)))
+
+    isInfimumUnique : ∀ n m → isInfimum pre P n → isInfimum pre P m → n ≡ m
+    isInfimumUnique n m (isln , infn) (islm , infm)
+      = anti n m (infm (n , isln)) (infn (m , islm))
+
+    isSupremumUnique : ∀ n m → isSupremum pre P n → isSupremum pre P m → n ≡ m
+    isSupremumUnique n m (isun , supn) (isum , supm)
+      = anti n m (supn (m , isum)) (supm (n , isun))
+
+    InfimumUnique : (n m : Infimum pre P) → n ≡ m
+    InfimumUnique (n , infn) (m , infm) = Σ≡Prop (λ _ → isPropIsInfimum pre P _)
+                                                  (isInfimumUnique n m infn infm)
+
+    SupremumUnique : (n m : Supremum pre P) → n ≡ m
+    SupremumUnique (n , supn) (m , supm) = Σ≡Prop (λ _ → isPropIsSupremum pre P _)
+                                                   (isSupremumUnique n m supn supm)
+
+  isMeetUnique : ∀ a b x y → isMeet pre a b x → isMeet pre a b y → x ≡ y
+  isMeetUnique a b x y infx infy = anti x y x≤y y≤x
+    where x≤y : x ≤ y
+          x≤y = invEq (infy x) (infx x .fst (rfl x))
+
+          y≤x : y ≤ x
+          y≤x = invEq (infx y) (infy y .fst (rfl y))
+
+  isJoinUnique : ∀ a b x y → isJoin pre a b x → isJoin pre a b y → x ≡ y
+  isJoinUnique a b x y supx supy = anti x y x≤y y≤x
+          where x≤y : x ≤ y
+                x≤y = invEq (supx y) (supy y .fst (rfl y))
+
+                y≤x : y ≤ x
+                y≤x = invEq (supy x) (supx x .fst (rfl x))
+
+  MeetUnique : ∀ a b → (x y : Meet pre a b) → x ≡ y
+  MeetUnique a b (x , mx) (y , my) = Σ≡Prop (isPropIsMeet pre a b)
+                                            (isMeetUnique a b x y mx my)
+
+  JoinUnique : ∀ a b → (x y : Join pre a b) → x ≡ y
+  JoinUnique a b (x , jx) (y , jy) = Σ≡Prop (isPropIsJoin pre a b)
+                                            (isJoinUnique a b x y jx jy)
+
+  module _
+    (meet : ∀ a b → Meet pre a b)
+    where
+
+      meetIdemp : ∀ a → meet a a .fst ≡ a
+      meetIdemp a
+        = PathPΣ (MeetUnique a a (meet a a)
+                                 (a , (isReflIsMeet pre a))) .fst
+
+      meetComm : ∀ a b → meet a b .fst ≡ meet b a .fst
+      meetComm a b = sym (PathPΣ (MeetUnique b a (meet b a)
+                                           ((meet a b .fst) ,
+                                            (isMeetComm pre a b
+                                                       (meet a b .fst)
+                                                       (meet a b .snd)))) .fst)
+
+      meetAssoc : ∀ a b c
+                → meet a (meet b c .fst) .fst ≡ meet (meet a b .fst) c .fst
+      meetAssoc a b c
+        = sym (PathPΣ (MeetUnique
+                          (meet a b .fst) c
+                          (meet (meet a b .fst) c)
+                         ((meet a (meet b c .fst) .fst) ,
+                          (isMeetAssoc pre a b c
+                                      (meet a b .fst)
+                                      (meet b c .fst)
+                                      (meet a (meet b c .fst) .fst)
+                                      (meet a b .snd)
+                                      (meet b c .snd)
+                                      (meet a (meet b c .fst) .snd)))) .fst)
+
+  module _
+    (join : ∀ a b → Join pre a b)
+    where
+
+      joinIdem : ∀ a → join a a .fst ≡ a
+      joinIdem a
+        = PathPΣ (JoinUnique a a (join a a)
+                                 (a , (isReflIsJoin pre a))) .fst
+
+      joinComm : ∀ a b → join a b .fst ≡ join b a .fst
+      joinComm a b = sym (PathPΣ (JoinUnique b a (join b a)
+                                           ((join a b .fst) ,
+                                            (isJoinComm pre a b
+                                                       (join a b .fst)
+                                                       (join a b .snd)))) .fst)
+
+      joinAssoc : ∀ a b c
+                → join a (join b c .fst) .fst ≡ join (join a b .fst) c .fst
+      joinAssoc a b c
+        = sym (PathPΣ (JoinUnique
+                          (join a b .fst) c
+                          (join (join a b .fst) c)
+                         ((join a (join b c .fst) .fst) ,
+                          (isJoinAssoc pre a b c
+                                      (join a b .fst)
+                                      (join b c .fst)
+                                      (join a (join b c .fst) .fst)
+                                      (join a b .snd)
+                                      (join b c .snd)
+                                      (join a (join b c .fst) .snd)))) .fst)
+
+  order≃meet : ∀ a b a∧b
+             → isMeet pre a b a∧b
+             → (a ≤ b) ≃ (a ≡ a∧b)
+  order≃meet a b a∧b funa∧b
+    = propBiimpl→Equiv (prop a b)
+                       (set a a∧b)
+                       (λ a≤b → anti a a∧b (invEq (funa∧b a) (rfl a , a≤b))
+                                            (funa∧b a∧b .fst (rfl a∧b) .fst))
+                        λ a≡a∧b → subst (_≤ b) (sym a≡a∧b)
+                                         (funa∧b a∧b .fst (rfl a∧b) .snd)
+
+  order≃join : ∀ a b a∨b
+             → isJoin pre a b a∨b
+             → (a ≤ b) ≃ (b ≡ a∨b)
+  order≃join a b a∨b funa∨b
+    = propBiimpl→Equiv (prop a b)
+                       (set b a∨b)
+                       (λ a≤b → anti b a∨b (funa∨b a∨b .fst (rfl a∨b) .snd)
+                                            (invEq (funa∨b b) (a≤b , rfl b)))
+                        λ b≡a∨b → subst (a ≤_) (sym b≡a∨b)
+                                        (funa∨b a∨b .fst (rfl a∨b) .fst)
+
+-- Equivalences of posets respect meets and joins
+IsPosetEquivRespectsMeet : {P : Poset ℓ₀ ℓ₀'} {S : Poset ℓ₁ ℓ₁'} (e : PosetEquiv P S)
+                        → ∀ a b a∧b
+                        → isMeet (isPoset→isProset (PosetStr.isPoset (P .snd))) a b a∧b
+                        ≃ isMeet (isPoset→isProset (PosetStr.isPoset (S .snd)))
+                                 (equivFun (e .fst) a)
+                                 (equivFun (e .fst) b)
+                                 (equivFun (e .fst) a∧b)
+IsPosetEquivRespectsMeet {P = P} {S = S} (e , posEq) a b a∧b
+  = propBiimpl→Equiv (isPropIsMeet proP a b a∧b)
+                     (isPropIsMeet proS (equivFun e a) (equivFun e b) (equivFun e a∧b))
+                     (λ meet x
+                       → IsPosetEquiv.pres≤⁻ posEq x (equivFun e a∧b) ∙ₑ
+                         substEquiv (invEq e x ≤P_) (retEq e a∧b) ∙ₑ
+                         meet (invEq e x) ∙ₑ
+                         ≃-× (IsPosetEquiv.pres≤ posEq (invEq e x) a ∙ₑ
+                              substEquiv (_≤S equivFun e a) (secEq e x))
+                             (IsPosetEquiv.pres≤ posEq (invEq e x) b ∙ₑ
+                              substEquiv (_≤S equivFun e b) (secEq e x)))
+                      λ meet x
+                       → IsPosetEquiv.pres≤ posEq x a∧b ∙ₑ
+                         meet (equivFun e x) ∙ₑ
+                         ≃-× (IsPosetEquiv.pres≤⁻ posEq (equivFun e x) (equivFun e a) ∙ₑ
+                               subst2Equiv _≤P_ (retEq e x) (retEq e a))
+                             (IsPosetEquiv.pres≤⁻ posEq (equivFun e x) (equivFun e b) ∙ₑ
+                               subst2Equiv _≤P_ (retEq e x) (retEq e b))
+  where _≤P_ = PosetStr._≤_ (P .snd)
+        _≤S_ = PosetStr._≤_ (S .snd)
+
+        posP = PosetStr.isPoset (P .snd)
+        posS = PosetStr.isPoset (S .snd)
+
+        proP = isPoset→isProset posP
+        proS = isPoset→isProset posS
+
+IsPosetEquivRespectsJoin : {P : Poset ℓ₀ ℓ₀'} {S : Poset ℓ₁ ℓ₁'} (e : PosetEquiv P S)
+                        → ∀ a b a∨b
+                        → isJoin (isPoset→isProset (PosetStr.isPoset (P .snd))) a b a∨b
+                        ≃ isJoin (isPoset→isProset (PosetStr.isPoset (S .snd)))
+                                 (equivFun (e .fst) a)
+                                 (equivFun (e .fst) b)
+                                 (equivFun (e .fst) a∨b)
+
+IsPosetEquivRespectsJoin {P = P} {S = S} (e , posEq) a b a∨b
+  = propBiimpl→Equiv (isPropIsJoin proP a b a∨b)
+                     (isPropIsJoin proS (equivFun e a) (equivFun e b) (equivFun e a∨b))
+                     (λ join x
+                       → IsPosetEquiv.pres≤⁻ posEq (equivFun e a∨b) x ∙ₑ
+                         substEquiv (_≤P invEq e x) (retEq e a∨b) ∙ₑ
+                         join (invEq e x) ∙ₑ
+                         ≃-× (IsPosetEquiv.pres≤ posEq a (invEq e x) ∙ₑ
+                               substEquiv (equivFun e a ≤S_) (secEq e x))
+                              (IsPosetEquiv.pres≤ posEq b (invEq e x) ∙ₑ
+                               substEquiv (equivFun e b ≤S_) (secEq e x)))
+                      λ join x
+                       → IsPosetEquiv.pres≤ posEq a∨b x ∙ₑ
+                         join (equivFun e x) ∙ₑ
+                         ≃-× (IsPosetEquiv.pres≤⁻ posEq (equivFun e a) (equivFun e x) ∙ₑ
+                               subst2Equiv _≤P_ (retEq e a) (retEq e x))
+                              (IsPosetEquiv.pres≤⁻ posEq (equivFun e b) (equivFun e x) ∙ₑ
+                               subst2Equiv _≤P_ (retEq e b) (retEq e x))
+  where _≤P_ = PosetStr._≤_ (P .snd)
+        _≤S_ = PosetStr._≤_ (S .snd)
+
+        posP = PosetStr.isPoset (P .snd)
+        posS = PosetStr.isPoset (S .snd)
+
+        proP = isPoset→isProset posP
+        proS = isPoset→isProset posS
+
+module _
+  (pos : Poset ℓ ℓ')
+  where
+    private
+      pro = isPoset→isProset (PosetStr.isPoset (snd pos))
+
+      is = PosetStr.isPoset (snd pos)
+
+    isMeetSemipseudolattice : Type (ℓ-max ℓ ℓ')
+    isMeetSemipseudolattice = ∀ a b → Meet pro a b
+
+    isMeetCompleteSemipseudolattice : {ℓ'' : Level} → Type (ℓ-max (ℓ-max ℓ ℓ') (ℓ-suc ℓ''))
+    isMeetCompleteSemipseudolattice {ℓ'' = ℓ''} = {B : Type ℓ''}
+                                                → (P : B → ⟨ pos ⟩)
+                                                → Infimum pro P
+
+    isJoinSemipseudolattice : Type (ℓ-max ℓ ℓ')
+    isJoinSemipseudolattice = ∀ a b → Join pro a b
+
+    isJoinCompleteSemipseudolattice : {ℓ'' : Level} → Type (ℓ-max (ℓ-max ℓ ℓ') (ℓ-suc ℓ''))
+    isJoinCompleteSemipseudolattice {ℓ'' = ℓ''} = {B : Type ℓ''}
+                                                → (P : B → ⟨ pos ⟩)
+                                                → Supremum pro P
+
+    isMeetSemilattice : Type (ℓ-max ℓ ℓ')
+    isMeetSemilattice = isMeetSemipseudolattice × Greatest pro (⟨ pos ⟩ , (id↪ _))
+
+    isJoinSemilattice : Type (ℓ-max ℓ ℓ')
+    isJoinSemilattice = isJoinSemipseudolattice × Least pro (⟨ pos ⟩ , (id↪ _))
+
+    isPseudolattice : Type (ℓ-max ℓ ℓ')
+    isPseudolattice = isMeetSemipseudolattice × isJoinSemipseudolattice
+
+    isLattice : Type (ℓ-max ℓ ℓ')
+    isLattice = isMeetSemilattice × isJoinSemilattice
+
+    isCompleteLattice : {ℓ'' : Level} → Type (ℓ-max (ℓ-max ℓ ℓ') (ℓ-suc ℓ''))
+    isCompleteLattice {ℓ'' = ℓ''} = isMeetCompleteSemipseudolattice {ℓ''} × isJoinCompleteSemipseudolattice {ℓ''}
+
+    -- These are all propositonal statements
+    isPropIsMeetSemipseudolattice : isProp isMeetSemipseudolattice
+    isPropIsMeetSemipseudolattice
+      = isPropΠ2 λ a b → MeetUnique is a b
+
+    isPropIsMeetCompleteSemipseudolattice : {ℓ'' : Level} → isProp (isMeetCompleteSemipseudolattice {ℓ''})
+    isPropIsMeetCompleteSemipseudolattice
+      = isPropImplicitΠ λ _ → isPropΠ λ _ → InfimumUnique is
+
+    isPropIsJoinSemipseudolattice : isProp isJoinSemipseudolattice
+    isPropIsJoinSemipseudolattice
+      = isPropΠ2 λ a b → JoinUnique is a b
+
+    isPropIsJoinCompleteSemipseudolattice : {ℓ'' : Level} → isProp (isJoinCompleteSemipseudolattice {ℓ''})
+    isPropIsJoinCompleteSemipseudolattice
+      = isPropImplicitΠ λ _ → isPropΠ λ _ → SupremumUnique is
+
+    isPropIsMeetSemilattice : isProp isMeetSemilattice
+    isPropIsMeetSemilattice = isProp× isPropIsMeetSemipseudolattice
+                                     (GreatestUnique is {P = ⟨ pos ⟩ , (id↪ ⟨ pos ⟩)})
+
+    isPropIsJoinSemilattice : isProp isJoinSemilattice
+    isPropIsJoinSemilattice = isProp× isPropIsJoinSemipseudolattice
+                                     (LeastUnique is {P = ⟨ pos ⟩ , (id↪ ⟨ pos ⟩)})
+
+    isPropIsPseudolattice : isProp isPseudolattice
+    isPropIsPseudolattice = isProp× isPropIsMeetSemipseudolattice
+                                    isPropIsJoinSemipseudolattice
+
+    isPropIsLattice : isProp isLattice
+    isPropIsLattice = isProp× isPropIsMeetSemilattice
+                              isPropIsJoinSemilattice
+
+    isPropIsCompleteLattice : {ℓ'' : Level} → isProp (isCompleteLattice {ℓ''})
+    isPropIsCompleteLattice = isProp× isPropIsMeetCompleteSemipseudolattice
+                                      isPropIsJoinCompleteSemipseudolattice
+
+    -- Complete semipseudolattices are semipseudolattices
+    isMeetCompleteSemipseudolattice→isMeetSemipseudolattice : isMeetCompleteSemipseudolattice
+                                                            → isMeetSemipseudolattice
+    isMeetCompleteSemipseudolattice→isMeetSemipseudolattice meet
+      = (λ a b → (meet fst .fst) , invEq (isMeet≃isInfimum pro a b _)
+                                         (meet fst .snd))
+
+    isJoinCompleteSemipseudolattice→isJoinSemipseudolattice : isJoinCompleteSemipseudolattice
+                                                            → isJoinSemipseudolattice
+    isJoinCompleteSemipseudolattice→isJoinSemipseudolattice join
+      = (λ a b → (join fst .fst) , invEq (isJoin≃isSupremum pro a b _)
+                                         (join fst .snd))
+
+    -- They also imply each other, though we keep the two distinct for morphism reasons
+    isMeetCompleteSemipseudolattice≃isJoinCompleteSemipseudolattice : (isMeetCompleteSemipseudolattice {ℓ-max ℓ ℓ'})
+                                                                    ≃ (isJoinCompleteSemipseudolattice {ℓ-max ℓ ℓ'})
+    isMeetCompleteSemipseudolattice≃isJoinCompleteSemipseudolattice
+      = propBiimpl→Equiv isPropIsMeetCompleteSemipseudolattice
+                         isPropIsJoinCompleteSemipseudolattice to from
+      where to : isMeetCompleteSemipseudolattice
+               → isJoinCompleteSemipseudolattice {ℓ-max ℓ ℓ'}
+            to meet P = (fst lemma) ,
+                         isInfimumOfUpperBounds→isSupremum pro P (fst lemma)
+                                                                 (snd lemma)
+              where P↑ : Type _
+                    P↑ = UpperBound pro P
+
+                    lemma = meet {B = P↑} fst
+
+            from : isJoinCompleteSemipseudolattice
+                 → isMeetCompleteSemipseudolattice {ℓ-max ℓ ℓ'}
+            from join P = (fst lemma) ,
+                           isSupremumOfLowerBounds→isInfimum pro P (fst lemma)
+                                                                   (snd lemma)
+              where P↓ : Type _
+                    P↓ = LowerBound pro P
+
+                    lemma = join {B = P↓} fst
+
+    isCompleteLattice→isLattice : isCompleteLattice
+                                → isLattice
+    isCompleteLattice→isLattice (meet , join)
+      = ((isMeetCompleteSemipseudolattice→isMeetSemipseudolattice meet) ,
+         (join (λ x → x) .fst) ,
+          isUpperBoundOfSelf→isGreatestOfSelf pro (join (λ x → x) .snd .fst)) ,
+        ((isJoinCompleteSemipseudolattice→isJoinSemipseudolattice join) ,
+          meet (λ x → x) .fst ,
+          isLowerBoundOfSelf→isLeastOfSelf pro (meet (λ x → x) .snd .fst))
+
+    module _
+      (lat : isPseudolattice)
+      where
+        private
+          _∧l_ : ⟨ pos ⟩ → ⟨ pos ⟩ → ⟨ pos ⟩
+          a ∧l b = (lat .fst a b) .fst
+
+          _∨l_ : ⟨ pos ⟩ → ⟨ pos ⟩ → ⟨ pos ⟩
+          a ∨l b = (lat .snd a b) .fst
+
+          set = IsPoset.is-set is
+
+          rfl = IsPoset.is-refl is
+
+        MeetDistLJoin : Type ℓ
+        MeetDistLJoin = ∀ a b c → a ∧l (b ∨l c) ≡ (a ∧l b) ∨l (a ∧l c)
+
+        MeetDistRJoin : Type ℓ
+        MeetDistRJoin = ∀ a b c → (a ∨l b) ∧l c ≡ (a ∧l c) ∨l (b ∧l c)
+
+        JoinDistLMeet : Type ℓ
+        JoinDistLMeet = ∀ a b c → a ∨l (b ∧l c) ≡ (a ∨l b) ∧l (a ∨l c)
+
+        JoinDistRMeet : Type ℓ
+        JoinDistRMeet = ∀ a b c → (a ∧l b) ∨l c ≡ (a ∨l c) ∧l (b ∨l c)
+
+        MeetAbsorbLJoin : ∀ a b → a ∧l (a ∨l b) ≡ a
+        MeetAbsorbLJoin a b
+          = sym (equivFun
+                (order≃meet
+                   is a (a ∨l b) (a ∧l (a ∨l b))
+                  (lat .fst a (a ∨l b) .snd))
+                (equivFun (lat .snd a b .snd (a ∨l b))
+                          (rfl (a ∨l b)) .fst))
+
+        MeetAbsorbRJoin : ∀ a b → (a ∨l b) ∧l a ≡ a
+        MeetAbsorbRJoin a b
+          = meetComm is (lat .fst) (a ∨l b) a ∙
+            MeetAbsorbLJoin a b
+
+        JoinAbsorbLMeet : ∀ a b → a ∨l (a ∧l b) ≡ a
+        JoinAbsorbLMeet a b
+          = sym (equivFun
+                (order≃join
+                  is (a ∧l b) a (a ∨l (a ∧l b))
+                                (isJoinComm pro a (a ∧l b) (a ∨l (a ∧l b))
+                                           (lat .snd a (a ∧l b) .snd)))
+                (equivFun (lat .fst a b .snd (a ∧l b)) (rfl (a ∧l b)) .fst))
+
+        JoinAbsorbRMeet : ∀ a b → (a ∧l b) ∨l a ≡ a
+        JoinAbsorbRMeet a b
+          = joinComm is (lat .snd) (a ∧l b) a ∙
+            JoinAbsorbLMeet a b
+
+        isPropMeetDistLJoin : isProp MeetDistLJoin
+        isPropMeetDistLJoin = isPropΠ3 λ _ _ _ → set _ _
+
+        isPropMeetDistRJoin : isProp MeetDistRJoin
+        isPropMeetDistRJoin = isPropΠ3 λ _ _ _ → set _ _
+
+        isPropJoinDistLMeet : isProp JoinDistLMeet
+        isPropJoinDistLMeet = isPropΠ3 λ _ _ _ → set _ _
+
+        isPropJoinDistRMeet : isProp JoinDistRMeet
+        isPropJoinDistRMeet = isPropΠ3 λ _ _ _ → set _ _
+
+        MeetDistLJoin≃MeetDistRJoin : MeetDistLJoin ≃ MeetDistRJoin
+        MeetDistLJoin≃MeetDistRJoin
+          = propBiimpl→Equiv isPropMeetDistLJoin
+                             isPropMeetDistRJoin
+                            (λ distl a b c → meetComm is (lat .fst) (a ∨l b) c ∙
+                                             distl c a b ∙
+                                             cong₂ _∨l_ (meetComm is (lat .fst) c a)
+                                                        (meetComm is (lat .fst) c b))
+                             λ distr a b c → meetComm is (lat .fst) a (b ∨l c) ∙
+                                             distr b c a ∙
+                                             cong₂ _∨l_ (meetComm is (lat .fst) b a)
+                                                        (meetComm is (lat .fst) c a)
 
-Poset→StrictPoset : Poset ℓ ℓ' → StrictPoset ℓ (ℓ-max ℓ ℓ')
-Poset→StrictPoset (_ , pos)
-  = _ , strictposetstr (BinaryRelation.IrreflKernel (PosetStr._≤_ pos))
-                       (isPoset→isStrictPosetIrreflKernel (PosetStr.isPoset pos))
+        JoinDistLMeet≃JoinDistRMeet : JoinDistLMeet ≃ JoinDistRMeet
+        JoinDistLMeet≃JoinDistRMeet
+          = propBiimpl→Equiv isPropJoinDistLMeet
+                             isPropJoinDistRMeet
+                            (λ distl a b c → joinComm is (lat .snd) (a ∧l b) c ∙
+                                             distl c a b ∙
+                                             cong₂ _∧l_ (joinComm is (lat .snd) c a)
+                                                        (joinComm is (lat .snd) c b))
+                             λ distr a b c → joinComm is (lat .snd) a (b ∧l c) ∙
+                                             distr b c a ∙
+                                             cong₂ _∧l_ (joinComm is (lat .snd) b a)
+                                                        (joinComm is (lat .snd) c a)
 
+        MeetDistLJoin≃JoinDistLMeet : MeetDistLJoin ≃ JoinDistLMeet
+        MeetDistLJoin≃JoinDistLMeet
+          = propBiimpl→Equiv isPropMeetDistLJoin
+                             isPropJoinDistLMeet
+                             (λ dist a b c  → (a ∨l  (b  ∧l  c))                      ≡⟨ cong (_∨l (b ∧l c)) (sym (JoinAbsorbLMeet a c)) ⟩
+                                             ((a ∨l  (a  ∧l  c)) ∨l  (b ∧l c))        ≡⟨ sym (joinAssoc is (lat .snd) a (a ∧l c) (b ∧l c)) ⟩
+                                              (a ∨l ((a  ∧l  c)  ∨l  (b ∧l c)))       ≡⟨ cong (a ∨l_) (sym (equivFun MeetDistLJoin≃MeetDistRJoin dist a b c)) ⟩
+                                              (a ∨l ((a  ∨l  b)  ∧l   c))             ≡⟨ cong (_∨l ((a ∨l b) ∧l c)) (sym (MeetAbsorbRJoin a b)) ⟩
+                                            (((a ∨l   b) ∧l  a)  ∨l ((a ∨l b) ∧l c)) ≡⟨ sym (dist (a ∨l b) a c) ⟩
+                                             ((a ∨l   b) ∧l (a   ∨l   c))             ∎)
+                              λ dist' a b c → (a ∧l  (b  ∨l c))                      ≡⟨ cong (_∧l (b ∨l c)) (sym (MeetAbsorbLJoin a c)) ⟩
+                                             ((a ∧l  (a  ∨l c)) ∧l  (b ∨l c))        ≡⟨ sym (meetAssoc is (lat .fst) a (a ∨l c) (b ∨l c)) ⟩
+                                              (a ∧l ((a  ∨l c)  ∧l  (b ∨l c)))      ≡⟨ cong (a ∧l_) (sym (equivFun JoinDistLMeet≃JoinDistRMeet dist' a b c)) ⟩
+                                              (a ∧l ((a  ∧l b)  ∨l   c))             ≡⟨ cong (_∧l ((a ∧l b) ∨l c)) (sym (JoinAbsorbRMeet a b)) ⟩
+                                            (((a ∧l   b) ∨l a)  ∧l ((a ∧l b) ∨l c)) ≡⟨ sym (dist' (a ∧l b) a c) ⟩
+                                             ((a ∧l   b) ∨l (a  ∧l   c))             ∎
 
-module PosetDownset (P' : Poset ℓ ℓ') where
-  private P = fst P'
-  open PosetStr (snd P')
+        MeetDistRJoin≃JoinDistRMeet : MeetDistRJoin ≃ JoinDistRMeet
+        MeetDistRJoin≃JoinDistRMeet = invEquiv MeetDistLJoin≃MeetDistRJoin ∙ₑ
+                                      MeetDistLJoin≃JoinDistLMeet ∙ₑ
+                                      JoinDistLMeet≃JoinDistRMeet
 
-  ↓ : P → Type (ℓ-max ℓ ℓ')
-  ↓ u = Σ[ v ∈ P ] v ≤ u
+        -- Since all of those varieties of distributivity are equivalent, we say that MeetDistLJoin is our canonical version of distributivity
+        isDistributive : Type ℓ
+        isDistributive = MeetDistLJoin
 
-  ↓ᴾ : P → Poset (ℓ-max ℓ ℓ') ℓ'
-  fst (↓ᴾ u) = ↓ u
-  PosetStr._≤_ (snd (↓ᴾ u)) v w = v .fst ≤ w .fst
-  PosetStr.isPoset (snd (↓ᴾ u)) =
-    isPosetInduced
-      (PosetStr.isPoset (snd P'))
-      _
-      (EmbeddingΣProp (λ a → is-prop-valued _ _))
+        isPropIsDistributive : isProp isDistributive
+        isPropIsDistributive = isPropMeetDistLJoin
diff --git a/Cubical/Relation/Binary/Order/Poset/Subset.agda b/Cubical/Relation/Binary/Order/Poset/Subset.agda
new file mode 100644
index 0000000000..9153602a41
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Poset/Subset.agda
@@ -0,0 +1,249 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Poset.Subset where
+
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Transport
+
+open import Cubical.Data.Sigma
+open import Cubical.Data.Sum as ⊎
+
+open import Cubical.Functions.Embedding
+open import Cubical.Functions.Preimage
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Poset.Properties
+
+
+private
+  variable
+    ℓ ℓ' ℓ'' ℓ''' ℓ₀ ℓ₁ : Level
+
+module _
+  (P : Poset ℓ ℓ')
+  where
+    private
+      _≤_ = PosetStr._≤_ (snd P)
+
+      is = PosetStr.isPoset (snd P)
+      prop = IsPoset.is-prop-valued is
+
+      rfl = IsPoset.is-refl is
+      anti = IsPoset.is-antisym is
+      trans = IsPoset.is-trans is
+
+    module _
+      (S : Embedding ⟨ P ⟩ ℓ'')
+      where
+        private
+          f = S .snd .fst
+        isDownset : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+        isDownset = ∀ x → ∀ y → y ≤ f x → y ∈ₑ S
+
+        isPropIsDownset : isProp isDownset
+        isPropIsDownset = isPropΠ3 λ _ y _ → isProp∈ₑ y S
+
+        isUpset : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+        isUpset = ∀ x → ∀ y → f x ≤ y → y ∈ₑ S
+
+        isPropIsUpset : isProp isUpset
+        isPropIsUpset = isPropΠ3 λ _ y _ → isProp∈ₑ y S
+
+    module _
+      (A : Embedding ⟨ P ⟩ ℓ₀)
+      (B : Embedding ⟨ P ⟩ ℓ₁)
+      where
+        module _
+          (downA : isDownset A)
+          (downB : isDownset B)
+          where
+            isDownset∩ : isDownset (A ∩ₑ B)
+            isDownset∩ (x , (a , a≡x) , (b , b≡x)) y y≤x
+              = (y , (downA a y (subst (y ≤_) (sym a≡x) y≤x) ,
+                      downB b y (subst (y ≤_) (sym b≡x) y≤x))) , refl
+
+            isDownset∪ : isDownset (A ∪ₑ B)
+            isDownset∪ (x , A⊎B) y y≤x
+              = ∥₁.rec (isProp∈ₑ y (A ∪ₑ B))
+                       (⊎.rec (λ { (a , a≡x) →
+                              (y , ∣ inl (downA a y (subst (y ≤_)
+                                                           (sym a≡x) y≤x)) ∣₁) , refl })
+                              (λ { (b , b≡x) →
+                              (y , ∣ inr (downB b y (subst (y ≤_)
+                                                           (sym b≡x) y≤x)) ∣₁) , refl })) A⊎B
+
+        module _
+          (upA : isUpset A)
+          (upB : isUpset B)
+          where
+            isUpset∩ : isUpset (A ∩ₑ B)
+            isUpset∩ (x , (a , a≡x) , (b , b≡x)) y x≤y
+              = (y , (upA a y (subst (_≤ y) (sym a≡x) x≤y) ,
+                      upB b y (subst (_≤ y) (sym b≡x) x≤y))) , refl
+
+            isUpset∪ : isUpset (A ∪ₑ B)
+            isUpset∪ (x , A⊎B) y x≤y
+              = ∥₁.rec (isProp∈ₑ y (A ∪ₑ B))
+                       (⊎.rec (λ { (a , a≡x) →
+                              (y , ∣ inl (upA a y (subst (_≤ y)
+                                                         (sym a≡x) x≤y)) ∣₁) , refl })
+                              (λ { (b , b≡x) →
+                              (y , ∣ inr (upB b y (subst (_≤ y)
+                                                         (sym b≡x) x≤y)) ∣₁) , refl })) A⊎B
+
+    module _
+      {I : Type ℓ''}
+      (S : I → Embedding ⟨ P ⟩ ℓ''')
+      where
+        module _
+          (downS : ∀ i → isDownset (S i))
+          where
+            isDownset⋂ : isDownset (⋂ₑ S)
+            isDownset⋂ (x , ∀x) y y≤x
+              = (y , λ i → downS i (∀x i .fst) y (subst (y ≤_) (sym (∀x i .snd)) y≤x)) , refl
+
+            isDownset⋃ : isDownset (⋃ₑ S)
+            isDownset⋃ (x , ∃i) y y≤x
+              = (y , (∥₁.map (λ { (i , a , a≡x) → i , downS i a y (subst (y ≤_) (sym a≡x) y≤x) }) ∃i)) , refl
+
+        module _
+          (upS : ∀ i → isUpset (S i))
+          where
+            isUpset⋂ : isUpset (⋂ₑ S)
+            isUpset⋂ (x , ∀x) y x≤y
+              = (y , λ i → upS i (∀x i .fst) y (subst (_≤ y) (sym (∀x i .snd)) x≤y)) , refl
+
+            isUpset⋃ : isUpset (⋃ₑ S)
+            isUpset⋃ (x , ∃i) y x≤y
+              = (y , (∥₁.map (λ { (i , a , a≡x) → i , upS i a y (subst (_≤ y) (sym a≡x) x≤y)  }) ∃i)) , refl
+
+
+    module _
+      (x : ⟨ P ⟩)
+      where
+        principalDownset : Embedding ⟨ P ⟩ (ℓ-max ℓ ℓ')
+        principalDownset = (Σ[ y ∈ ⟨ P ⟩ ] y ≤ x) , EmbeddingΣProp λ _ → prop _ x
+
+        principalUpset : Embedding ⟨ P ⟩ (ℓ-max ℓ ℓ')
+        principalUpset = (Σ[ y ∈ ⟨ P ⟩ ] x ≤ y) , EmbeddingΣProp λ _ → prop x _
+
+    isDownsetPrincipalDownset : ∀ x → isDownset (principalDownset x)
+    isDownsetPrincipalDownset x (y , y≤x) z z≤y = (z , (trans z y x z≤y y≤x)) , refl
+
+    isUpsetPrincipalUpset : ∀ x → isUpset (principalUpset x)
+    isUpsetPrincipalUpset x (y , x≤y) z y≤z = (z , (trans x y z x≤y y≤z)) , refl
+
+    principalDownsetMembership : ∀ x y
+                               → x ≤ y
+                               ≃ x ∈ₑ principalDownset y
+    principalDownsetMembership x y
+      = propBiimpl→Equiv (prop x y)
+                         (isProp∈ₑ x (principalDownset y))
+                         (λ x≤y → (x , x≤y) , refl)
+                          λ { ((a , a≤y) , fib) → subst (_≤ y) fib a≤y}
+
+    principalUpsetMembership : ∀ x y
+                             → x ≤ y
+                             ≃ y ∈ₑ principalUpset x
+    principalUpsetMembership x y
+      = propBiimpl→Equiv (prop x y)
+                         (isProp∈ₑ y (principalUpset x))
+                         (λ x≤y → (y , x≤y) , refl)
+                          λ { ((a , x≤a) , fib) → subst (x ≤_) fib x≤a }
+
+    principalUpsetInclusion : ∀ x y
+                            → x ≤ y
+                            → principalUpset y ⊆ₑ principalUpset x
+    principalUpsetInclusion x y x≤y z z∈y↑
+      = equivFun (principalUpsetMembership x z)
+                 (trans x y z x≤y (invEq (principalUpsetMembership y z) z∈y↑))
+
+    principalDownsetInclusion : ∀ x y
+                              → x ≤ y
+                              → principalDownset x ⊆ₑ principalDownset y
+    principalDownsetInclusion x y x≤y z z∈x↓
+      = equivFun (principalDownsetMembership z y)
+                 (trans z x y (invEq (principalDownsetMembership z x) z∈x↓) x≤y)
+
+    module _
+      (S : Embedding ⟨ P ⟩ (ℓ-max ℓ ℓ'))
+      where
+        isPrincipalDownset : Type _
+        isPrincipalDownset = Σ[ x ∈ ⟨ P ⟩ ] S ≡ (principalDownset x)
+
+        isPropIsPrincipalDownset : isProp isPrincipalDownset
+        isPropIsPrincipalDownset (x , S≡x↓) (y , S≡y↓)
+          = Σ≡Prop (λ x → isSetEmbedding S (principalDownset x))
+                    (anti x y x≤y y≤x)
+          where x≤y : x ≤ y
+                x≤y = invEq (principalDownsetMembership x y)
+                            (subst (x ∈ₑ_)
+                                   (sym S≡x↓ ∙ S≡y↓)
+                                   (equivFun (principalDownsetMembership x x) (rfl x)))
+
+                y≤x : y ≤ x
+                y≤x = invEq (principalDownsetMembership y x)
+                            (subst (y ∈ₑ_)
+                                   (sym S≡y↓ ∙ S≡x↓)
+                                   (equivFun (principalDownsetMembership y y) (rfl y)))
+
+        isPrincipalUpset : Type _
+        isPrincipalUpset = Σ[ x ∈ ⟨ P ⟩ ] S ≡ (principalUpset x)
+
+        isPropIsPrincipalUpset : isProp isPrincipalUpset
+        isPropIsPrincipalUpset (x , S≡x↑) (y , S≡y↑)
+          = Σ≡Prop (λ x → isSetEmbedding S (principalUpset x))
+                    (anti x y x≤y y≤x)
+          where x≤y : x ≤ y
+                x≤y = invEq (principalUpsetMembership x y)
+                             (subst (y ∈ₑ_)
+                                    (sym S≡y↑ ∙ S≡x↑)
+                                    (equivFun (principalUpsetMembership y y) (rfl y)))
+
+                y≤x : y ≤ x
+                y≤x = invEq (principalUpsetMembership y x)
+                            (subst (x ∈ₑ_)
+                                   (sym S≡x↑ ∙ S≡y↑)
+                                   (equivFun (principalUpsetMembership x x) (rfl x)))
+
+        isPrincipalDownset→isDownset : isPrincipalDownset → (isDownset S)
+        isPrincipalDownset→isDownset (x , p) = transport⁻ (cong isDownset p) (isDownsetPrincipalDownset x)
+
+        isPrincipalUpset→isUpset : isPrincipalUpset → (isUpset S)
+        isPrincipalUpset→isUpset (x , p) = transport⁻ (cong isUpset p) (isUpsetPrincipalUpset x)
+
+module PosetDownset (P' : Poset ℓ ℓ') where
+  private P = ⟨ P' ⟩
+  open PosetStr (snd P')
+
+  ↓ : P → Type (ℓ-max ℓ ℓ')
+  ↓ u = principalDownset P' u .fst
+
+  ↓ᴾ : P → Poset (ℓ-max ℓ ℓ') ℓ'
+  fst (↓ᴾ u) = ↓ u
+  PosetStr._≤_ (snd (↓ᴾ u)) v w = v .fst ≤ w .fst
+  PosetStr.isPoset (snd (↓ᴾ u)) =
+    isPosetInduced
+      (PosetStr.isPoset (snd P'))
+       _
+      (principalDownset P' u .snd)
+
+module PosetUpset (P' : Poset ℓ ℓ') where
+  private P = ⟨ P' ⟩
+  open PosetStr (snd P')
+
+  ↑ : P → Type (ℓ-max ℓ ℓ')
+  ↑ u = principalUpset P' u .fst
+
+  ↑ᴾ : P → Poset (ℓ-max ℓ ℓ') ℓ'
+  fst (↑ᴾ u) = principalUpset P' u .fst
+  PosetStr._≤_ (snd (↑ᴾ u)) v w = v .fst ≤ w .fst
+  PosetStr.isPoset (snd (↑ᴾ u)) =
+    isPosetInduced
+      (PosetStr.isPoset (snd P'))
+       _
+      (principalUpset P' u .snd)
diff --git a/Cubical/Relation/Binary/Order/Preorder.agda b/Cubical/Relation/Binary/Order/Preorder.agda
deleted file mode 100644
index 6b9ce2af2f..0000000000
--- a/Cubical/Relation/Binary/Order/Preorder.agda
+++ /dev/null
@@ -1,5 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.Preorder where
-
-open import Cubical.Relation.Binary.Order.Preorder.Base public
-open import Cubical.Relation.Binary.Order.Preorder.Properties public
diff --git a/Cubical/Relation/Binary/Order/Preorder/Base.agda b/Cubical/Relation/Binary/Order/Preorder/Base.agda
deleted file mode 100644
index 5bf7dfd797..0000000000
--- a/Cubical/Relation/Binary/Order/Preorder/Base.agda
+++ /dev/null
@@ -1,135 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.Preorder.Base where
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.Equiv
-open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.Univalence
-open import Cubical.Foundations.Transport
-open import Cubical.Foundations.SIP
-
-open import Cubical.Data.Sigma
-
-open import Cubical.Reflection.RecordEquiv
-open import Cubical.Reflection.StrictEquiv
-
-open import Cubical.Displayed.Base
-open import Cubical.Displayed.Auto
-open import Cubical.Displayed.Record
-open import Cubical.Displayed.Universe
-
-open import Cubical.Relation.Binary.Base
-
-open Iso
-open BinaryRelation
-
-
-private
-  variable
-    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
-
-record IsPreorder {A : Type ℓ} (_≲_ : A → A → Type ℓ') : Type (ℓ-max ℓ ℓ') where
-  no-eta-equality
-  constructor ispreorder
-
-  field
-    is-set : isSet A
-    is-prop-valued : isPropValued _≲_
-    is-refl : isRefl _≲_
-    is-trans : isTrans _≲_
-
-unquoteDecl IsPreorderIsoΣ = declareRecordIsoΣ IsPreorderIsoΣ (quote IsPreorder)
-
-
-record PreorderStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')) where
-
-  constructor preorderstr
-
-  field
-    _≲_     : A → A → Type ℓ'
-    isPreorder : IsPreorder _≲_
-
-  infixl 7 _≲_
-
-  open IsPreorder isPreorder public
-
-Preorder : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
-Preorder ℓ ℓ' = TypeWithStr ℓ (PreorderStr ℓ')
-
-preorder : (A : Type ℓ) (_≲_ : A → A → Type ℓ') (h : IsPreorder _≲_) → Preorder ℓ ℓ'
-preorder A _≲_ h = A , preorderstr _≲_ h
-
-record IsPreorderEquiv {A : Type ℓ₀} {B : Type ℓ₁}
-  (M : PreorderStr ℓ₀' A) (e : A ≃ B) (N : PreorderStr ℓ₁' B)
-  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
-  where
-  constructor
-   ispreorderequiv
-  -- Shorter qualified names
-  private
-    module M = PreorderStr M
-    module N = PreorderStr N
-
-  field
-    pres≲ : (x y : A) → x M.≲ y ≃ equivFun e x N.≲ equivFun e y
-
-
-PreorderEquiv : (M : Preorder ℓ₀ ℓ₀') (M : Preorder ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
-PreorderEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsPreorderEquiv (M .snd) e (N .snd)
-
-isPropIsPreorder : {A : Type ℓ} (_≲_ : A → A → Type ℓ') → isProp (IsPreorder _≲_)
-isPropIsPreorder _≲_ = isOfHLevelRetractFromIso 1 IsPreorderIsoΣ
-  (isPropΣ isPropIsSet
-    λ isSetA → isPropΣ (isPropΠ2 (λ _ _ → isPropIsProp))
-      λ isPropValued≲ → isProp×
-                        (isPropΠ (λ _ → isPropValued≲ _ _))
-                        (isPropΠ4 λ _ _ _ _ → isPropΠ λ _ → isPropValued≲ _ _))
-
-𝒮ᴰ-Preorder : DUARel (𝒮-Univ ℓ) (PreorderStr ℓ') (ℓ-max ℓ ℓ')
-𝒮ᴰ-Preorder =
-  𝒮ᴰ-Record (𝒮-Univ _) IsPreorderEquiv
-    (fields:
-      data[ _≲_ ∣ autoDUARel _ _ ∣ pres≲ ]
-      prop[ isPreorder ∣ (λ _ _ → isPropIsPreorder _) ])
-    where
-    open PreorderStr
-    open IsPreorder
-    open IsPreorderEquiv
-
-PreorderPath : (M N : Preorder ℓ ℓ') → PreorderEquiv M N ≃ (M ≡ N)
-PreorderPath = ∫ 𝒮ᴰ-Preorder .UARel.ua
-
--- an easier way of establishing an equivalence of preorders
-module _ {P : Preorder ℓ₀ ℓ₀'} {S : Preorder ℓ₁ ℓ₁'} (e : ⟨ P ⟩ ≃ ⟨ S ⟩) where
-  private
-    module P = PreorderStr (P .snd)
-    module S = PreorderStr (S .snd)
-
-  module _ (isMon : ∀ x y → x P.≲ y → equivFun e x S.≲ equivFun e y)
-           (isMonInv : ∀ x y → x S.≲ y → invEq e x P.≲ invEq e y) where
-    open IsPreorderEquiv
-    open IsPreorder
-
-    makeIsPreorderEquiv : IsPreorderEquiv (P .snd) e (S .snd)
-    pres≲ makeIsPreorderEquiv x y = propBiimpl→Equiv (P.isPreorder .is-prop-valued _ _)
-                                                  (S.isPreorder .is-prop-valued _ _)
-                                                  (isMon _ _) (isMonInv' _ _)
-      where
-      isMonInv' : ∀ x y → equivFun e x S.≲ equivFun e y → x P.≲ y
-      isMonInv' x y ex≲ey = transport (λ i → retEq e x i P.≲ retEq e y i) (isMonInv _ _ ex≲ey)
-
-
-module PreorderReasoning (P' : Preorder ℓ ℓ') where
- private P = fst P'
- open PreorderStr (snd P')
- open IsPreorder
-
- _≲⟨_⟩_ : (x : P) {y z : P} → x ≲ y → y ≲ z → x ≲ z
- x ≲⟨ p ⟩ q = isPreorder .is-trans x _ _ p q
-
- _◾ : (x : P) → x ≲ x
- x ◾ = isPreorder .is-refl x
-
- infixr 0 _≲⟨_⟩_
- infix  1 _◾
diff --git a/Cubical/Relation/Binary/Order/Preorder/Properties.agda b/Cubical/Relation/Binary/Order/Preorder/Properties.agda
deleted file mode 100644
index deec933ddf..0000000000
--- a/Cubical/Relation/Binary/Order/Preorder/Properties.agda
+++ /dev/null
@@ -1,57 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.Preorder.Properties where
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.HLevels
-
-open import Cubical.Functions.Embedding
-
-open import Cubical.HITs.PropositionalTruncation as ∥₁
-
-open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Preorder.Base
-open import Cubical.Relation.Binary.Order.StrictPoset.Base
-
-open import Cubical.Relation.Nullary
-
-private
-  variable
-    ℓ ℓ' ℓ'' : Level
-
-module _
-  {A : Type ℓ}
-  {R : Rel A A ℓ'}
-  where
-
-  open BinaryRelation
-
-  isPreorder→isEquivRelSymKernel : IsPreorder R → isEquivRel (SymKernel R)
-  isPreorder→isEquivRelSymKernel preorder
-    = equivRel (λ a → (IsPreorder.is-refl preorder a)
-                    , (IsPreorder.is-refl preorder a))
-               (isSymSymKernel R)
-               (λ a b c (Rab , Rba) (Rbc , Rcb)
-                 → IsPreorder.is-trans preorder a b c Rab Rbc
-                 , IsPreorder.is-trans preorder c b a Rcb Rba)
-
-  isPreorder→isStrictPosetAsymKernel : IsPreorder R → IsStrictPoset (AsymKernel R)
-  isPreorder→isStrictPosetAsymKernel preorder
-    = isstrictposet (IsPreorder.is-set preorder)
-                    (λ a b → isProp× (IsPreorder.is-prop-valued preorder a b) (isProp¬ (R b a)))
-                    (λ a (Raa , ¬Raa) → ¬Raa (IsPreorder.is-refl preorder a))
-                    (λ a b c (Rab , ¬Rba) (Rbc , ¬Rcb)
-                      → IsPreorder.is-trans preorder a b c Rab Rbc
-                      , λ Rca → ¬Rcb (IsPreorder.is-trans preorder c a b Rca Rab))
-                    (isAsymAsymKernel R)
-
-  isPreorderInduced : IsPreorder R → (B : Type ℓ'') → (f : B ↪ A) → IsPreorder (InducedRelation R (B , f))
-  isPreorderInduced pre B (f , emb)
-    = ispreorder (Embedding-into-isSet→isSet (f , emb) (IsPreorder.is-set pre))
-                 (λ a b → IsPreorder.is-prop-valued pre (f a) (f b))
-                 (λ a → IsPreorder.is-refl pre (f a))
-                 λ a b c → IsPreorder.is-trans pre (f a) (f b) (f c)
-
-Preorder→StrictPoset : Preorder ℓ ℓ' → StrictPoset ℓ ℓ'
-Preorder→StrictPoset (_ , pre)
-  = _ , strictposetstr (BinaryRelation.AsymKernel (PreorderStr._≲_ pre))
-                       (isPreorder→isStrictPosetAsymKernel (PreorderStr.isPreorder pre))
diff --git a/Cubical/Relation/Binary/Order/Properties.agda b/Cubical/Relation/Binary/Order/Properties.agda
deleted file mode 100644
index 5f1eaaafdb..0000000000
--- a/Cubical/Relation/Binary/Order/Properties.agda
+++ /dev/null
@@ -1,302 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.Properties where
-
-open import Cubical.Data.Sigma
-open import Cubical.Data.Sum as ⊎
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.HLevels
-
-open import Cubical.Functions.Embedding
-
-open import Cubical.HITs.PropositionalTruncation as ∥₁
-
-open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Poset
-open import Cubical.Relation.Binary.Order.Toset
-open import Cubical.Relation.Binary.Order.Preorder.Base
-
-private
-  variable
-    ℓ ℓ' ℓ'' : Level
-
-module _
-  {A : Type ℓ}
-  {_≲_ : Rel A A ℓ'}
-  (pre : IsPreorder _≲_)
-  where
-
-  private
-      prop : ∀ a b → isProp (a ≲ b)
-      prop = IsPreorder.is-prop-valued pre
-
-  module _
-    (P : Embedding A ℓ'')
-    where
-
-    private
-      subtype : Type ℓ''
-      subtype = fst P
-
-      toA : subtype → A
-      toA = fst (snd P)
-
-    isMinimal : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
-    isMinimal n = (x : subtype) → toA x ≲ toA n → toA n ≲ toA x
-
-    isPropIsMinimal : ∀ n → isProp (isMinimal n)
-    isPropIsMinimal n = isPropΠ2 λ x _ → prop (toA n) (toA x)
-
-    Minimal : Type (ℓ-max ℓ' ℓ'')
-    Minimal = Σ[ n ∈ subtype ] isMinimal n
-
-    isMaximal : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
-    isMaximal n = (x : subtype) → toA n ≲ toA x → toA x ≲ toA n
-
-    isPropIsMaximal : ∀ n → isProp (isMaximal n)
-    isPropIsMaximal n = isPropΠ2 λ x _ → prop (toA x) (toA n)
-
-    Maximal : Type (ℓ-max ℓ' ℓ'')
-    Maximal = Σ[ n ∈ subtype ] isMaximal n
-
-    isLeast : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
-    isLeast n = (x : subtype) → toA n ≲ toA x
-
-    isPropIsLeast : ∀ n → isProp (isLeast n)
-    isPropIsLeast n = isPropΠ λ x → prop (toA n) (toA x)
-
-    Least : Type (ℓ-max ℓ' ℓ'')
-    Least = Σ[ n ∈ subtype ] isLeast n
-
-    isGreatest : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
-    isGreatest n = (x : subtype) → toA x ≲ toA n
-
-    isPropIsGreatest : ∀ n → isProp (isGreatest n)
-    isPropIsGreatest n = isPropΠ λ x → prop (toA x) (toA n)
-
-    Greatest : Type (ℓ-max ℓ' ℓ'')
-    Greatest = Σ[ n ∈ subtype ] isGreatest n
-
-  module _
-    {B : Type ℓ''}
-    (P : B → A)
-    where
-
-    isLowerBound : (n : A) → Type (ℓ-max ℓ' ℓ'')
-    isLowerBound n = (x : B) → n ≲ P x
-
-    isPropIsLowerBound : ∀ n → isProp (isLowerBound n)
-    isPropIsLowerBound n = isPropΠ λ x → prop n (P x)
-
-    LowerBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    LowerBound = Σ[ n ∈ A ] isLowerBound n
-
-    isUpperBound : (n : A) → Type (ℓ-max ℓ' ℓ'')
-    isUpperBound n = (x : B) → P x ≲ n
-
-    isPropIsUpperBound : ∀ n → isProp (isUpperBound n)
-    isPropIsUpperBound n = isPropΠ λ x → prop (P x) n
-
-    UpperBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    UpperBound = Σ[ n ∈ A ] isUpperBound n
-
-  module _
-    {B : Type ℓ''}
-    (P : B → A)
-    where
-
-    isMaximalLowerBound : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    isMaximalLowerBound n
-      = Σ[ islb ∈ isLowerBound P n ]
-        isMaximal (LowerBound P
-                  , (EmbeddingΣProp (isPropIsLowerBound P))) (n , islb)
-
-    isPropIsMaximalLowerBound : ∀ n → isProp (isMaximalLowerBound n)
-    isPropIsMaximalLowerBound n
-      = isPropΣ (isPropIsLowerBound P n)
-                λ islb → isPropIsMaximal (LowerBound P
-                       , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
-
-    MaximalLowerBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    MaximalLowerBound = Σ[ n ∈ A ] isMaximalLowerBound n
-
-    isMinimalUpperBound : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    isMinimalUpperBound n
-      = Σ[ isub ∈ isUpperBound P n ]
-        isMinimal (UpperBound P
-                  , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
-
-    isPropIsMinimalUpperBound : ∀ n → isProp (isMinimalUpperBound n)
-    isPropIsMinimalUpperBound n
-      = isPropΣ (isPropIsUpperBound P n)
-                λ isub → isPropIsMinimal (UpperBound P
-                       , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
-
-    MinimalUpperBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    MinimalUpperBound = Σ[ n ∈ A ] isMinimalUpperBound n
-
-    isInfimum : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    isInfimum n
-      = Σ[ islb ∈ isLowerBound P n ]
-        isGreatest (LowerBound P
-                   , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
-
-    isPropIsInfimum : ∀ n → isProp (isInfimum n)
-    isPropIsInfimum n
-      = isPropΣ (isPropIsLowerBound P n)
-                λ islb → isPropIsGreatest (LowerBound P
-                       , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
-
-    Infimum : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    Infimum = Σ[ n ∈ A ] isInfimum n
-
-    isSupremum : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    isSupremum n
-      = Σ[ isub ∈ isUpperBound P n ]
-        isLeast (UpperBound P
-                , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
-
-    isPropIsSupremum : ∀ n → isProp (isSupremum n)
-    isPropIsSupremum n
-      = isPropΣ (isPropIsUpperBound P n)
-                λ isub → isPropIsLeast (UpperBound P
-                       , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
-
-    Supremum : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
-    Supremum = Σ[ n ∈ A ] isSupremum n
-
-module _
-  {A : Type ℓ}
-  {_≲_ : Rel A A ℓ'}
-  (pre : IsPreorder _≲_)
-  where
-
-  module _
-    {P : Embedding A ℓ''}
-    where
-
-    private
-      toA : (fst P) → A
-      toA = fst (snd P)
-
-    isLeast→isMinimal : ∀ n → isLeast pre P n → isMinimal pre P n
-    isLeast→isMinimal _ isl x _ = isl x
-
-    isGreatest→isMaximal : ∀ n → isGreatest pre P n → isMaximal pre P n
-    isGreatest→isMaximal _ isg x _ = isg x
-
-    isLeast→isLowerBound : ∀ n → isLeast pre P n → isLowerBound pre toA (toA n)
-    isLeast→isLowerBound _ isl = isl
-
-    isGreatest→isUpperBound : ∀ n → isGreatest pre P n → isUpperBound pre toA (toA n)
-    isGreatest→isUpperBound _ isg = isg
-
-    isLeast→isInfimum : ∀ n → isLeast pre P n → isInfimum pre toA (toA n)
-    isLeast→isInfimum n isl = (isLeast→isLowerBound n isl) , (λ x → snd x n)
-
-    isGreatest→isSupremum : ∀ n → isGreatest pre P n → isSupremum pre toA (toA n)
-    isGreatest→isSupremum n isg = (isGreatest→isUpperBound n isg) , (λ x → snd x n)
-
-  module _
-    {B : Type ℓ''}
-    {P : B → A}
-    where
-
-    isInfimum→isLowerBound : ∀ n → isInfimum pre P n → isLowerBound pre P n
-    isInfimum→isLowerBound _ = fst
-
-    isSupremum→isUpperBound : ∀ n → isSupremum pre P n → isUpperBound pre P n
-    isSupremum→isUpperBound _ = fst
-
-module _
-  {A : Type ℓ}
-  {_≤_ : Rel A A ℓ'}
-  (pos : IsPoset _≤_)
-  where
-
-  private
-    pre : IsPreorder _≤_
-    pre = isPoset→isPreorder pos
-
-    anti : BinaryRelation.isAntisym _≤_
-    anti = IsPoset.is-antisym pos
-
-  module _
-    {P : Embedding A ℓ''}
-    where
-
-    private
-      toA : (fst P) → A
-      toA = fst (snd P)
-
-      emb : isEmbedding toA
-      emb = snd (snd P)
-
-    isLeast→ContrMinimal : ∀ n → isLeast pre P n  → ∀ m → isMinimal pre P m → n ≡ m
-    isLeast→ContrMinimal n isln m ismm
-      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isln m) (ismm n (isln m)))
-
-    isGreatest→ContrMaximal : ∀ n → isGreatest pre P n → ∀ m → isMaximal pre P m → n ≡ m
-    isGreatest→ContrMaximal n isgn m ismm
-      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (ismm n (isgn m)) (isgn m))
-
-    isLeastUnique : ∀ n m → isLeast pre P n → isLeast pre P m → n ≡ m
-    isLeastUnique n m isln islm
-      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isln m) (islm n))
-
-    isGreatestUnique : ∀ n m → isGreatest pre P n → isGreatest pre P m → n ≡ m
-    isGreatestUnique n m isgn isgm
-      = isEmbedding→Inj emb n m (anti (toA n) (toA m) (isgm n) (isgn m))
-
-  module _
-    {B : Type ℓ''}
-    {P : B → A}
-    where
-
-    isInfimum→ContrMaximalLowerBound : ∀ n → isInfimum pre P n
-                                     → ∀ m → isMaximalLowerBound pre P m
-                                     → n ≡ m
-    isInfimum→ContrMaximalLowerBound n (isln , isglbn) m (islm , ismlbm)
-      = anti n m (ismlbm (n , isln) (isglbn (m , islm))) (isglbn (m , islm))
-
-    isSupremum→ContrMinimalUpperBound : ∀ n → isSupremum pre P n
-                                      → ∀ m → isMinimalUpperBound pre P m
-                                      → n ≡ m
-    isSupremum→ContrMinimalUpperBound n (isun , islubn) m (isum , ismubm)
-      = anti n m (islubn (m , isum)) (ismubm (n , isun) (islubn (m , isum)))
-
-    isInfimumUnique : ∀ n m → isInfimum pre P n → isInfimum pre P m → n ≡ m
-    isInfimumUnique n m (isln , infn) (islm , infm)
-      = anti n m (infm (n , isln)) (infn (m , islm))
-
-    isSupremumUnique : ∀ n m → isSupremum pre P n → isSupremum pre P m → n ≡ m
-    isSupremumUnique n m (isun , supn) (isum , supm)
-      = anti n m (supn (m , isum)) (supm (n , isun))
-
-module _
-  {A : Type ℓ}
-  {P : Embedding A ℓ''}
-  {_≤_ : Rel A A ℓ'}
-  (tos : IsToset _≤_)
-  where
-
-  private
-    prop : ∀ a b → isProp (a ≤ b)
-    prop = IsToset.is-prop-valued tos
-
-    conn : BinaryRelation.isStronglyConnected _≤_
-    conn = IsToset.is-strongly-connected tos
-
-    pre : IsPreorder _≤_
-    pre = isPoset→isPreorder (isToset→isPoset tos)
-
-    toA : (fst P) → A
-    toA = fst (snd P)
-
-  isMinimal→isLeast : ∀ n → isMinimal pre P n → isLeast pre P n
-  isMinimal→isLeast n ism m
-    = ∥₁.rec (prop _ _) (⊎.rec (λ n≤m → n≤m) (λ m≤n → ism m m≤n)) (conn (toA n) (toA m))
-
-  isMaximal→isGreatest : ∀ n → isMaximal pre P n → isGreatest pre P n
-  isMaximal→isGreatest n ism m
-    = ∥₁.rec (prop _ _) (⊎.rec (λ n≤m → ism m n≤m) (λ m≤n → m≤n)) (conn (toA n) (toA m))
diff --git a/Cubical/Relation/Binary/Order/Proset.agda b/Cubical/Relation/Binary/Order/Proset.agda
new file mode 100644
index 0000000000..c96c4cc15c
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Proset.agda
@@ -0,0 +1,5 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Proset where
+
+open import Cubical.Relation.Binary.Order.Proset.Base public
+open import Cubical.Relation.Binary.Order.Proset.Properties public
diff --git a/Cubical/Relation/Binary/Order/Proset/Base.agda b/Cubical/Relation/Binary/Order/Proset/Base.agda
new file mode 100644
index 0000000000..dc80d72b29
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Proset/Base.agda
@@ -0,0 +1,138 @@
+{-# OPTIONS --safe #-}
+{-
+  Prosets are preordered sets; a set with a reflexive, transitive relation
+-}
+module Cubical.Relation.Binary.Order.Proset.Base where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.SIP
+
+open import Cubical.Data.Sigma
+
+open import Cubical.Reflection.RecordEquiv
+open import Cubical.Reflection.StrictEquiv
+
+open import Cubical.Displayed.Base
+open import Cubical.Displayed.Auto
+open import Cubical.Displayed.Record
+open import Cubical.Displayed.Universe
+
+open import Cubical.Relation.Binary.Base
+
+open Iso
+open BinaryRelation
+
+
+private
+  variable
+    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
+
+record IsProset {A : Type ℓ} (_≲_ : A → A → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+  no-eta-equality
+  constructor isproset
+
+  field
+    is-set : isSet A
+    is-prop-valued : isPropValued _≲_
+    is-refl : isRefl _≲_
+    is-trans : isTrans _≲_
+
+unquoteDecl IsProsetIsoΣ = declareRecordIsoΣ IsProsetIsoΣ (quote IsProset)
+
+
+record ProsetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')) where
+
+  constructor prosetstr
+
+  field
+    _≲_     : A → A → Type ℓ'
+    isProset : IsProset _≲_
+
+  infixl 7 _≲_
+
+  open IsProset isProset public
+
+Proset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
+Proset ℓ ℓ' = TypeWithStr ℓ (ProsetStr ℓ')
+
+proset : (A : Type ℓ) → (_≲_ : Rel A A ℓ') → IsProset _≲_ → Proset ℓ ℓ'
+proset A _≲_ pros = A , (prosetstr _≲_ pros)
+
+record IsProsetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
+  (M : ProsetStr ℓ₀' A) (e : A ≃ B) (N : ProsetStr ℓ₁' B)
+  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
+  where
+  constructor
+   isprosetequiv
+  -- Shorter qualified names
+  private
+    module M = ProsetStr M
+    module N = ProsetStr N
+
+  field
+    pres≲ : (x y : A) → x M.≲ y ≃ equivFun e x N.≲ equivFun e y
+
+
+ProsetEquiv : (M : Proset ℓ₀ ℓ₀') (M : Proset ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
+ProsetEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsProsetEquiv (M .snd) e (N .snd)
+
+isPropIsProset : {A : Type ℓ} (_≲_ : A → A → Type ℓ') → isProp (IsProset _≲_)
+isPropIsProset _≲_ = isOfHLevelRetractFromIso 1 IsProsetIsoΣ
+  (isPropΣ isPropIsSet
+    λ isSetA → isPropΣ (isPropΠ2 (λ _ _ → isPropIsProp))
+      λ isPropValued≲ → isProp×
+                        (isPropΠ (λ _ → isPropValued≲ _ _))
+                        (isPropΠ4 λ _ _ _ _ → isPropΠ λ _ → isPropValued≲ _ _))
+
+𝒮ᴰ-Proset : DUARel (𝒮-Univ ℓ) (ProsetStr ℓ') (ℓ-max ℓ ℓ')
+𝒮ᴰ-Proset =
+  𝒮ᴰ-Record (𝒮-Univ _) IsProsetEquiv
+    (fields:
+      data[ _≲_ ∣ autoDUARel _ _ ∣ pres≲ ]
+      prop[ isProset ∣ (λ _ _ → isPropIsProset _) ])
+    where
+    open ProsetStr
+    open IsProset
+    open IsProsetEquiv
+
+ProsetPath : (M N : Proset ℓ ℓ') → ProsetEquiv M N ≃ (M ≡ N)
+ProsetPath = ∫ 𝒮ᴰ-Proset .UARel.ua
+
+-- an easier way of establishing an equivalence of prosets
+module _ {P : Proset ℓ₀ ℓ₀'} {S : Proset ℓ₁ ℓ₁'} (e : ⟨ P ⟩ ≃ ⟨ S ⟩) where
+  private
+    module P = ProsetStr (P .snd)
+    module S = ProsetStr (S .snd)
+
+  module _ (isMon : ∀ x y → x P.≲ y → equivFun e x S.≲ equivFun e y)
+           (isMonInv : ∀ x y → x S.≲ y → invEq e x P.≲ invEq e y) where
+    open IsProsetEquiv
+    open IsProset
+
+    makeIsProsetEquiv : IsProsetEquiv (P .snd) e (S .snd)
+    pres≲ makeIsProsetEquiv x y = propBiimpl→Equiv (P.isProset .is-prop-valued _ _)
+                                                  (S.isProset .is-prop-valued _ _)
+                                                  (isMon _ _) (isMonInv' _ _)
+      where
+      isMonInv' : ∀ x y → equivFun e x S.≲ equivFun e y → x P.≲ y
+      isMonInv' x y ex≲ey = transport (λ i → retEq e x i P.≲ retEq e y i) (isMonInv _ _ ex≲ey)
+
+
+module ProsetReasoning (P' : Proset ℓ ℓ') where
+ private P = fst P'
+ open ProsetStr (snd P')
+ open IsProset
+
+ _≲⟨_⟩_ : (x : P) {y z : P} → x ≲ y → y ≲ z → x ≲ z
+ x ≲⟨ p ⟩ q = isProset .is-trans x _ _ p q
+
+ _◾ : (x : P) → x ≲ x
+ x ◾ = isProset .is-refl x
+
+ infixr 0 _≲⟨_⟩_
+ infix  1 _◾
diff --git a/Cubical/Relation/Binary/Order/Proset/Properties.agda b/Cubical/Relation/Binary/Order/Proset/Properties.agda
new file mode 100644
index 0000000000..61343c624a
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Proset/Properties.agda
@@ -0,0 +1,434 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Proset.Properties where
+
+open import Cubical.Data.Sigma
+open import Cubical.Data.Sum as ⊎
+
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Functions.Embedding
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Binary.Order.Proset.Base
+open import Cubical.Relation.Binary.Order.Quoset.Base
+
+open import Cubical.Relation.Nullary
+
+private
+  variable
+    ℓ ℓ' ℓ'' : Level
+
+module _
+  {A : Type ℓ}
+  {R : Rel A A ℓ'}
+  where
+
+  open BinaryRelation
+
+  isProset→isEquivRelSymKernel : IsProset R → isEquivRel (SymKernel R)
+  isProset→isEquivRelSymKernel proset
+    = equivRel (λ a → (IsProset.is-refl proset a)
+                    , (IsProset.is-refl proset a))
+               (isSymSymKernel R)
+               (λ a b c (Rab , Rba) (Rbc , Rcb)
+                 → IsProset.is-trans proset a b c Rab Rbc
+                 , IsProset.is-trans proset c b a Rcb Rba)
+
+  isProset→isQuosetAsymKernel : IsProset R → IsQuoset (AsymKernel R)
+  isProset→isQuosetAsymKernel proset
+    = isquoset (IsProset.is-set proset)
+                    (λ a b → isProp× (IsProset.is-prop-valued proset a b) (isProp¬ (R b a)))
+                    (λ a (Raa , ¬Raa) → ¬Raa (IsProset.is-refl proset a))
+                    (λ a b c (Rab , ¬Rba) (Rbc , ¬Rcb)
+                      → IsProset.is-trans proset a b c Rab Rbc
+                      , λ Rca → ¬Rcb (IsProset.is-trans proset c a b Rca Rab))
+                    (isAsymAsymKernel R)
+
+  isProsetInduced : IsProset R → (B : Type ℓ'') → (f : B ↪ A) → IsProset (InducedRelation R (B , f))
+  isProsetInduced pre B (f , emb)
+    = isproset (Embedding-into-isSet→isSet (f , emb) (IsProset.is-set pre))
+                 (λ a b → IsProset.is-prop-valued pre (f a) (f b))
+                 (λ a → IsProset.is-refl pre (f a))
+                 λ a b c → IsProset.is-trans pre (f a) (f b) (f c)
+
+  isProsetDual : IsProset R → IsProset (Dual R)
+  isProsetDual pre
+    = isproset (IsProset.is-set pre)
+               (λ a b → IsProset.is-prop-valued pre b a)
+               (IsProset.is-refl pre) (λ a b c Rab Rbc → IsProset.is-trans pre c b a Rbc Rab)
+
+Proset→Quoset : Proset ℓ ℓ' → Quoset ℓ ℓ'
+Proset→Quoset (_ , pre)
+  = quoset _ (BinaryRelation.AsymKernel (ProsetStr._≲_ pre))
+             (isProset→isQuosetAsymKernel (ProsetStr.isProset pre))
+
+DualProset : Proset ℓ ℓ' → Proset ℓ ℓ'
+DualProset (_ , pre)
+  = proset _ (BinaryRelation.Dual (ProsetStr._≲_ pre))
+             (isProsetDual (ProsetStr.isProset pre))
+
+module _
+  {A : Type ℓ}
+  {_≲_ : Rel A A ℓ'}
+  (pre : IsProset _≲_)
+  where
+
+  private
+      prop = IsProset.is-prop-valued pre
+
+      rfl = IsProset.is-refl pre
+
+      trans = IsProset.is-trans pre
+
+  module _
+    (P : Embedding A ℓ'')
+    where
+
+    private
+      subtype = fst P
+
+      toA = fst (snd P)
+
+    isMinimal : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
+    isMinimal n = (x : subtype) → toA x ≲ toA n → toA n ≲ toA x
+
+    isPropIsMinimal : ∀ n → isProp (isMinimal n)
+    isPropIsMinimal n = isPropΠ2 λ x _ → prop (toA n) (toA x)
+
+    Minimal : Type (ℓ-max ℓ' ℓ'')
+    Minimal = Σ[ n ∈ subtype ] isMinimal n
+
+    isMaximal : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
+    isMaximal n = (x : subtype) → toA n ≲ toA x → toA x ≲ toA n
+
+    isPropIsMaximal : ∀ n → isProp (isMaximal n)
+    isPropIsMaximal n = isPropΠ2 λ x _ → prop (toA x) (toA n)
+
+    Maximal : Type (ℓ-max ℓ' ℓ'')
+    Maximal = Σ[ n ∈ subtype ] isMaximal n
+
+    isLeast : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
+    isLeast n = (x : subtype) → toA n ≲ toA x
+
+    isPropIsLeast : ∀ n → isProp (isLeast n)
+    isPropIsLeast n = isPropΠ λ x → prop (toA n) (toA x)
+
+    Least : Type (ℓ-max ℓ' ℓ'')
+    Least = Σ[ n ∈ subtype ] isLeast n
+
+    isGreatest : (n : subtype) → Type (ℓ-max ℓ' ℓ'')
+    isGreatest n = (x : subtype) → toA x ≲ toA n
+
+    isPropIsGreatest : ∀ n → isProp (isGreatest n)
+    isPropIsGreatest n = isPropΠ λ x → prop (toA x) (toA n)
+
+    Greatest : Type (ℓ-max ℓ' ℓ'')
+    Greatest = Σ[ n ∈ subtype ] isGreatest n
+
+  module _
+    {B : Type ℓ''}
+    (P : B → A)
+    where
+
+    isLowerBound : (n : A) → Type (ℓ-max ℓ' ℓ'')
+    isLowerBound n = (x : B) → n ≲ P x
+
+    isPropIsLowerBound : ∀ n → isProp (isLowerBound n)
+    isPropIsLowerBound n = isPropΠ λ x → prop n (P x)
+
+    LowerBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    LowerBound = Σ[ n ∈ A ] isLowerBound n
+
+    isUpperBound : (n : A) → Type (ℓ-max ℓ' ℓ'')
+    isUpperBound n = (x : B) → P x ≲ n
+
+    isPropIsUpperBound : ∀ n → isProp (isUpperBound n)
+    isPropIsUpperBound n = isPropΠ λ x → prop (P x) n
+
+    UpperBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    UpperBound = Σ[ n ∈ A ] isUpperBound n
+
+  module _
+    {B : Type ℓ''}
+    (P : B → A)
+    where
+
+    isMaximalLowerBound : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    isMaximalLowerBound n
+      = Σ[ islb ∈ isLowerBound P n ]
+        isMaximal (LowerBound P
+                  , (EmbeddingΣProp (isPropIsLowerBound P))) (n , islb)
+
+    isPropIsMaximalLowerBound : ∀ n → isProp (isMaximalLowerBound n)
+    isPropIsMaximalLowerBound n
+      = isPropΣ (isPropIsLowerBound P n)
+                λ islb → isPropIsMaximal (LowerBound P
+                       , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
+
+    MaximalLowerBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    MaximalLowerBound = Σ[ n ∈ A ] isMaximalLowerBound n
+
+    isMinimalUpperBound : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    isMinimalUpperBound n
+      = Σ[ isub ∈ isUpperBound P n ]
+        isMinimal (UpperBound P
+                  , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
+
+    isPropIsMinimalUpperBound : ∀ n → isProp (isMinimalUpperBound n)
+    isPropIsMinimalUpperBound n
+      = isPropΣ (isPropIsUpperBound P n)
+                λ isub → isPropIsMinimal (UpperBound P
+                       , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
+
+    MinimalUpperBound : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    MinimalUpperBound = Σ[ n ∈ A ] isMinimalUpperBound n
+
+    isInfimum : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    isInfimum n
+      = Σ[ islb ∈ isLowerBound P n ]
+        isGreatest (LowerBound P
+                   , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
+
+    isPropIsInfimum : ∀ n → isProp (isInfimum n)
+    isPropIsInfimum n
+      = isPropΣ (isPropIsLowerBound P n)
+                λ islb → isPropIsGreatest (LowerBound P
+                       , EmbeddingΣProp (isPropIsLowerBound P)) (n , islb)
+
+    Infimum : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    Infimum = Σ[ n ∈ A ] isInfimum n
+
+    isSupremum : (n : A) → Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    isSupremum n
+      = Σ[ isub ∈ isUpperBound P n ]
+        isLeast (UpperBound P
+                , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
+
+    isPropIsSupremum : ∀ n → isProp (isSupremum n)
+    isPropIsSupremum n
+      = isPropΣ (isPropIsUpperBound P n)
+                λ isub → isPropIsLeast (UpperBound P
+                       , EmbeddingΣProp (isPropIsUpperBound P)) (n , isub)
+
+    Supremum : Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')
+    Supremum = Σ[ n ∈ A ] isSupremum n
+
+  isUpperBoundOfSelf→isGreatestOfSelf : ∀{n} → isUpperBound {B = A} (λ x → x) n
+                                      → isGreatest (A , (id↪ A)) n
+  isUpperBoundOfSelf→isGreatestOfSelf ub = ub
+
+  isLowerBoundOfSelf→isLeastOfSelf : ∀{n} → isLowerBound {B = A} (λ x → x) n
+                                   → isLeast (A , (id↪ A)) n
+  isLowerBoundOfSelf→isLeastOfSelf lb = lb
+
+  isInfimumOfUpperBounds→isUpperBound : {B : Type ℓ''}
+                                      → (P : B → A)
+                                      → ∀ n
+                                      → isInfimum {B = UpperBound P} fst n
+                                      → isUpperBound P n
+  isInfimumOfUpperBounds→isUpperBound P _ (_ , gt) x = gt ((P x) , λ { (_ , upy) → upy x })
+
+  isInfimumOfUpperBounds→isSupremum : {B : Type ℓ''}
+                                    → (P : B → A)
+                                    → ∀ n
+                                    → isInfimum {B = UpperBound P} fst n
+                                    → isSupremum P n
+  isInfimumOfUpperBounds→isSupremum P n (lt , gt)
+    = isInfimumOfUpperBounds→isUpperBound P n (lt , gt) , lt
+
+  isSupremumOfLowerBounds→isLowerBound : {B : Type ℓ''}
+                                       → (P : B → A)
+                                       → ∀ n
+                                       → isSupremum {B = LowerBound P} fst n
+                                       → isLowerBound P n
+  isSupremumOfLowerBounds→isLowerBound P _ (_ , ls) x = ls ((P x) , λ { (_ , lwy) → lwy x })
+
+  isSupremumOfLowerBounds→isInfimum : {B : Type ℓ''}
+                                    → (P : B → A)
+                                    → ∀ n
+                                    → isSupremum {B = LowerBound P} fst n
+                                    → isInfimum P n
+  isSupremumOfLowerBounds→isInfimum P n (gs , ls)
+    = isSupremumOfLowerBounds→isLowerBound P n (gs , ls) , gs
+
+  isMeet : A → A → A → Type (ℓ-max ℓ ℓ')
+  isMeet a b a∧b = ∀ x → x ≲ a∧b ≃ (x ≲ a × x ≲ b)
+
+  isJoin : A → A → A → Type (ℓ-max ℓ ℓ')
+  isJoin a b a∨b = ∀ x → a∨b ≲ x ≃ (a ≲ x × b ≲ x)
+
+  Meet : ∀ a b → Type (ℓ-max ℓ ℓ')
+  Meet a b = Σ[ a∧b ∈ A ] isMeet a b a∧b
+
+  Join : ∀ a b → Type (ℓ-max ℓ ℓ')
+  Join a b = Σ[ a∨b ∈ A ] isJoin a b a∨b
+
+  isPropIsMeet : ∀ a b a∧b → isProp (isMeet a b a∧b)
+  isPropIsMeet a b c = isPropΠ λ x → isOfHLevel≃ 1 (prop x c)
+                                                    (isProp× (prop x a)
+                                                             (prop x b))
+
+  isPropIsJoin : ∀ a b a∨b → isProp (isJoin a b a∨b)
+  isPropIsJoin a b c = isPropΠ λ x → isOfHLevel≃ 1 (prop c x)
+                                                    (isProp× (prop a x)
+                                                             (prop b x))
+
+  isReflIsMeet : ∀ a → isMeet a a a
+  isReflIsMeet a x = propBiimpl→Equiv (prop x a)
+                                      (isProp× (prop x a) (prop x a))
+                                      (λ a → a , a)
+                                       fst
+
+  isReflIsJoin : ∀ a → isJoin a a a
+  isReflIsJoin a x = propBiimpl→Equiv (prop a x)
+                                      (isProp× (prop a x) (prop a x))
+                                      (λ a → a , a)
+                                       fst
+
+  isMeet≃isInfimum : ∀ a b c
+                   → isMeet a b c
+                   ≃ isInfimum {B = Σ[ x ∈ A ] (x ≡ a) ⊎ (x ≡ b)} fst c
+  isMeet≃isInfimum a b a∧b
+    = propBiimpl→Equiv (isPropIsMeet a b a∧b) (isPropIsInfimum fst a∧b)
+                       (λ fun → ⊎.rec (λ x≡a → subst
+                                               (a∧b ≲_)
+                                               (sym x≡a)
+                                               (fun a∧b .fst (rfl a∧b) .fst))
+                                      (λ x≡b → subst
+                                               (a∧b ≲_)
+                                               (sym x≡b)
+                                               (fun a∧b .fst (rfl a∧b) .snd))
+                                ∘ snd ,
+                        λ { (c , uprc)
+                          → invEq (fun c) ((uprc (a , (inl refl))) ,
+                                           (uprc (b , (inr refl)))) })
+                        λ { (lb , gt) x
+                          → propBiimpl→Equiv
+                           (prop x a∧b)
+                           (isProp× (prop x a) (prop x b))
+                       (λ x≤a∧b → (trans x a∧b a x≤a∧b
+                                         (lb (a , inl refl))) ,
+                                   (trans x a∧b b x≤a∧b
+                                         (lb (b , inr refl))))
+                        λ { (x≤a , x≤b)
+                          → gt (x ,
+                               (⊎.rec (λ y≡a → subst
+                                               (x ≲_)
+                                               (sym y≡a)
+                                                x≤a)
+                                      (λ y≡b → subst
+                                               (x ≲_)
+                                               (sym y≡b)
+                                                x≤b)
+                                       ∘ snd)) } }
+
+  isJoin≃isSupremum : ∀ a b c
+                    → isJoin a b c
+                    ≃ isSupremum {B = Σ[ x ∈ A ] (x ≡ a) ⊎ (x ≡ b)} fst c
+  isJoin≃isSupremum a b a∨b
+    = propBiimpl→Equiv (isPropIsJoin a b a∨b) (isPropIsSupremum fst a∨b)
+                       (λ fun → ⊎.rec (λ x≡a → subst
+                                               (_≲ a∨b)
+                                               (sym x≡a)
+                                               (fun a∨b .fst (rfl a∨b) .fst))
+                                      (λ x≡b → subst
+                                               (_≲ a∨b)
+                                               (sym x≡b)
+                                               (fun a∨b .fst (rfl a∨b) .snd))
+                                ∘ snd ,
+                        λ { (c , lwrc)
+                          → invEq (fun c) ((lwrc (a , (inl refl))) ,
+                                           (lwrc (b , (inr refl)))) })
+                        λ { (ub , lt) x
+                          → propBiimpl→Equiv
+                           (prop a∨b x)
+                           (isProp× (prop a x) (prop b x))
+                       (λ a∨b≤x → trans a a∨b x
+                                        (ub (a , inl refl))
+                                         a∨b≤x ,
+                                   trans b a∨b x
+                                        (ub (b , inr refl))
+                                         a∨b≤x)
+                        λ { (a≤x , b≤x)
+                          → lt (x ,
+                               (⊎.rec (λ y≡a → subst
+                                               (_≲ x)
+                                               (sym y≡a)
+                                                a≤x)
+                                      (λ y≡b → subst
+                                               (_≲ x)
+                                               (sym y≡b)
+                                                b≤x)
+                                ∘ snd)) } }
+
+  isMeetComm : ∀ a b a∧b → isMeet a b a∧b → isMeet b a a∧b
+  isMeetComm _ _ _ fun x = compEquiv (fun x) Σ-swap-≃
+
+  isJoinComm : ∀ a b a∨b → isJoin a b a∨b → isJoin b a a∨b
+  isJoinComm _ _ _ fun x = compEquiv (fun x) Σ-swap-≃
+
+  isMeetAssoc : ∀ a b c a∧b b∧c a∧b∧c
+              → isMeet a b a∧b
+              → isMeet b c b∧c
+              → isMeet a b∧c a∧b∧c
+              → isMeet a∧b c a∧b∧c
+  isMeetAssoc a b c a∧b b∧c a∧b∧c funa∧b funb∧c funa∧b∧c x
+    = compEquiv (funa∧b∧c x)
+                (propBiimpl→Equiv (isProp× (prop x a) (prop x b∧c))
+                                  (isProp× (prop x a∧b) (prop x c))
+                                  (λ { (x≤a , x≤b∧c)
+                                     → invEq (funa∧b x)
+                                             (x≤a ,
+                                             (funb∧c x .fst x≤b∧c .fst)) ,
+                                              funb∧c x .fst x≤b∧c .snd })
+                                   λ { (x≤a∧b , x≤c)
+                                     → funa∧b x .fst x≤a∧b .fst ,
+                                       invEq (funb∧c x)
+                                            ((funa∧b x .fst x≤a∧b .snd) ,
+                                              x≤c) })
+
+  isJoinAssoc : ∀ a b c a∨b b∨c a∨b∨c
+              → isJoin a b a∨b
+              → isJoin b c b∨c
+              → isJoin a b∨c a∨b∨c
+              → isJoin a∨b c a∨b∨c
+  isJoinAssoc a b c a∨b b∨c a∨b∨c funa∨b funb∨c funa∨b∨c x
+    = compEquiv (funa∨b∨c x)
+                (propBiimpl→Equiv (isProp× (prop a x) (prop b∨c x))
+                                  (isProp× (prop a∨b x) (prop c x))
+                                  (λ { (a≤x , b∨c≤x)
+                                     → invEq (funa∨b x) (a≤x ,
+                                      (funb∨c x .fst b∨c≤x .fst)) ,
+                                       funb∨c x .fst b∨c≤x .snd })
+                                   λ { (a∨b≤x , c≤x)
+                                     → funa∨b x .fst a∨b≤x .fst ,
+                                       invEq (funb∨c x)
+                                     ((funa∨b x .fst a∨b≤x .snd) ,
+                                       c≤x) })
+
+  isMeetIsotone : ∀ a b c d a∧c b∧d
+                → isMeet a c a∧c
+                → isMeet b d b∧d
+                → a ≲ b
+                → c ≲ d
+                → a∧c ≲ b∧d
+  isMeetIsotone a b c d a∧c b∧d meeta∧c meetb∧d a≲b c≲d
+    = invEq (meetb∧d a∧c) (trans a∧c a b a∧c≲a a≲b , trans a∧c c d a∧c≲c c≲d)
+      where a∧c≲a = equivFun (meeta∧c a∧c) (rfl a∧c) .fst
+            a∧c≲c = equivFun (meeta∧c a∧c) (rfl a∧c) .snd
+
+  isJoinIsotone : ∀ a b c d a∨c b∨d
+                → isJoin a c a∨c
+                → isJoin b d b∨d
+                → a ≲ b
+                → c ≲ d
+                → a∨c ≲ b∨d
+  isJoinIsotone a b c d a∨c b∨d joina∨c joinb∨d a≲b c≲d
+    = invEq (joina∨c b∨d) (trans a b b∨d a≲b b≲b∨d , trans c d b∨d c≲d d≲b∨d)
+    where b≲b∨d = equivFun (joinb∨d b∨d) (rfl b∨d) .fst
+          d≲b∨d = equivFun (joinb∨d b∨d) (rfl b∨d) .snd
diff --git a/Cubical/Relation/Binary/Order/Quoset.agda b/Cubical/Relation/Binary/Order/Quoset.agda
new file mode 100644
index 0000000000..c40af09a6f
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Quoset.agda
@@ -0,0 +1,5 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Quoset where
+
+open import Cubical.Relation.Binary.Order.Quoset.Base public
+open import Cubical.Relation.Binary.Order.Quoset.Properties public
diff --git a/Cubical/Relation/Binary/Order/Quoset/Base.agda b/Cubical/Relation/Binary/Order/Quoset/Base.agda
new file mode 100644
index 0000000000..41e78ef8b9
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Quoset/Base.agda
@@ -0,0 +1,126 @@
+{-# OPTIONS --safe #-}
+{-
+  Quosets, or quasiordered sets, are posets where the relation is strict,
+  i.e. irreflexive rather than reflexive
+-}
+module Cubical.Relation.Binary.Order.Quoset.Base where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.SIP
+
+open import Cubical.Data.Sigma
+
+open import Cubical.Reflection.RecordEquiv
+open import Cubical.Reflection.StrictEquiv
+
+open import Cubical.Displayed.Base
+open import Cubical.Displayed.Auto
+open import Cubical.Displayed.Record
+open import Cubical.Displayed.Universe
+
+open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Nullary.Properties
+
+open Iso
+open BinaryRelation
+
+
+private
+  variable
+    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
+
+record IsQuoset {A : Type ℓ} (_<_ : A → A → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+  no-eta-equality
+  constructor isquoset
+
+  field
+    is-set : isSet A
+    is-prop-valued : isPropValued _<_
+    is-irrefl : isIrrefl _<_
+    is-trans : isTrans _<_
+    is-asym : isAsym _<_
+
+unquoteDecl IsQuosetIsoΣ = declareRecordIsoΣ IsQuosetIsoΣ (quote IsQuoset)
+
+
+record QuosetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')) where
+
+  constructor quosetstr
+
+  field
+    _<_     : A → A → Type ℓ'
+    isQuoset : IsQuoset _<_
+
+  infixl 7 _<_
+
+  open IsQuoset isQuoset public
+
+Quoset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
+Quoset ℓ ℓ' = TypeWithStr ℓ (QuosetStr ℓ')
+
+quoset : (A : Type ℓ) → (_<_ : Rel A A ℓ') → IsQuoset _<_ → Quoset ℓ ℓ'
+quoset A _<_ quo = A , (quosetstr _<_ quo)
+
+record IsQuosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
+  (M : QuosetStr ℓ₀' A) (e : A ≃ B) (N : QuosetStr ℓ₁' B)
+  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
+  where
+  constructor
+   isquosetequiv
+  -- Shorter qualified names
+  private
+    module M = QuosetStr M
+    module N = QuosetStr N
+
+  field
+    pres< : (x y : A) → x M.< y ≃ equivFun e x N.< equivFun e y
+
+
+QuosetEquiv : (M : Quoset ℓ₀ ℓ₀') (M : Quoset ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
+QuosetEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsQuosetEquiv (M .snd) e (N .snd)
+
+isPropIsQuoset : {A : Type ℓ} (_<_ : A → A → Type ℓ') → isProp (IsQuoset _<_)
+isPropIsQuoset _<_ = isOfHLevelRetractFromIso 1 IsQuosetIsoΣ
+  (isPropΣ isPropIsSet
+    λ isSetA → isPropΣ (isPropΠ2 (λ _ _ → isPropIsProp))
+      λ isPropValued< → isProp×2 (isPropΠ (λ x → isProp¬ (x < x)))
+                                 (isPropΠ5 (λ _ _ _ _ _ → isPropValued< _ _))
+                                 (isPropΠ3 λ x y _ → isProp¬ (y < x)))
+
+𝒮ᴰ-Quoset : DUARel (𝒮-Univ ℓ) (QuosetStr ℓ') (ℓ-max ℓ ℓ')
+𝒮ᴰ-Quoset =
+  𝒮ᴰ-Record (𝒮-Univ _) IsQuosetEquiv
+    (fields:
+      data[ _<_ ∣ autoDUARel _ _ ∣ pres< ]
+      prop[ isQuoset ∣ (λ _ _ → isPropIsQuoset _) ])
+    where
+    open QuosetStr
+    open IsQuoset
+    open IsQuosetEquiv
+
+QuosetPath : (M N : Quoset ℓ ℓ') → QuosetEquiv M N ≃ (M ≡ N)
+QuosetPath = ∫ 𝒮ᴰ-Quoset .UARel.ua
+
+-- an easier way of establishing an equivalence of strict posets
+module _ {P : Quoset ℓ₀ ℓ₀'} {S : Quoset ℓ₁ ℓ₁'} (e : ⟨ P ⟩ ≃ ⟨ S ⟩) where
+  private
+    module P = QuosetStr (P .snd)
+    module S = QuosetStr (S .snd)
+
+  module _ (isMon : ∀ x y → x P.< y → equivFun e x S.< equivFun e y)
+           (isMonInv : ∀ x y → x S.< y → invEq e x P.< invEq e y) where
+    open IsQuosetEquiv
+    open IsQuoset
+
+    makeIsQuosetEquiv : IsQuosetEquiv (P .snd) e (S .snd)
+    pres< makeIsQuosetEquiv x y = propBiimpl→Equiv (P.isQuoset .is-prop-valued _ _)
+                                                  (S.isQuoset .is-prop-valued _ _)
+                                                  (isMon _ _) (isMonInv' _ _)
+      where
+      isMonInv' : ∀ x y → equivFun e x S.< equivFun e y → x P.< y
+      isMonInv' x y ex<ey = transport (λ i → retEq e x i P.< retEq e y i) (isMonInv _ _ ex<ey)
diff --git a/Cubical/Relation/Binary/Order/Quoset/Properties.agda b/Cubical/Relation/Binary/Order/Quoset/Properties.agda
new file mode 100644
index 0000000000..12ddc6fe5a
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Quoset/Properties.agda
@@ -0,0 +1,80 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.Quoset.Properties where
+
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Empty as ⊥
+
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Functions.Embedding
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Binary.Order.Apartness.Base
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Quoset.Base
+
+private
+  variable
+    ℓ ℓ' ℓ'' : Level
+
+module _
+  {A : Type ℓ}
+  {R : Rel A A ℓ'}
+  where
+
+  open BinaryRelation
+
+  private
+    transrefl : isTrans R → isTrans (ReflClosure R)
+    transrefl trans a b c (inl Rab) (inl Rbc) = inl (trans a b c Rab Rbc)
+    transrefl trans a b c (inl Rab) (inr b≡c) = inl (subst (R a) b≡c Rab)
+    transrefl trans a b c (inr a≡b) (inl Rbc) = inl (subst (λ z → R z c) (sym a≡b) Rbc)
+    transrefl trans a b c (inr a≡b) (inr b≡c) = inr (a≡b ∙ b≡c)
+
+    antisym : isIrrefl R → isTrans R → isAntisym (ReflClosure R)
+    antisym irr trans a b (inl Rab) (inl Rba) = ⊥.rec (irr a (trans a b a Rab Rba))
+    antisym irr trans a b (inl _) (inr b≡a) = sym b≡a
+    antisym irr trans a b (inr a≡b) _ = a≡b
+
+  isQuoset→isPosetReflClosure : IsQuoset R → IsPoset (ReflClosure R)
+  isQuoset→isPosetReflClosure quoset
+    = isposet (IsQuoset.is-set quoset)
+              (λ a b → isProp⊎ (IsQuoset.is-prop-valued quoset a b)
+                               (IsQuoset.is-set quoset a b)
+                                 λ Rab a≡b
+                                   → IsQuoset.is-irrefl quoset a (subst (R a)
+                                                                           (sym a≡b) Rab))
+              (isReflReflClosure R)
+              (transrefl (IsQuoset.is-trans quoset))
+              (antisym (IsQuoset.is-irrefl quoset)
+                       (IsQuoset.is-trans quoset))
+
+  isQuosetInduced : IsQuoset R → (B : Type ℓ'') → (f : B ↪ A)
+                       → IsQuoset (InducedRelation R (B , f))
+  isQuosetInduced quo B (f , emb)
+    = isquoset (Embedding-into-isSet→isSet (f , emb)
+                                                (IsQuoset.is-set quo))
+                    (λ a b → IsQuoset.is-prop-valued quo (f a) (f b))
+                    (λ a → IsQuoset.is-irrefl quo (f a))
+                    (λ a b c → IsQuoset.is-trans quo (f a) (f b) (f c))
+                    λ a b → IsQuoset.is-asym quo (f a) (f b)
+
+  isQuosetDual : IsQuoset R → IsQuoset (Dual R)
+  isQuosetDual quo
+    = isquoset (IsQuoset.is-set quo)
+               (λ a b → IsQuoset.is-prop-valued quo b a)
+               (IsQuoset.is-irrefl quo)
+               (λ a b c Rab Rbc → IsQuoset.is-trans quo c b a Rbc Rab)
+                λ a b → IsQuoset.is-asym quo b a
+
+Quoset→Poset : Quoset ℓ ℓ' → Poset ℓ (ℓ-max ℓ ℓ')
+Quoset→Poset (_ , quo)
+  = poset _ (BinaryRelation.ReflClosure (QuosetStr._<_ quo))
+            (isQuoset→isPosetReflClosure (QuosetStr.isQuoset quo))
+
+DualQuoset : Quoset ℓ ℓ' → Quoset ℓ ℓ'
+DualQuoset (_ , quo)
+  = quoset _ (BinaryRelation.Dual (QuosetStr._<_ quo))
+             (isQuosetDual (QuosetStr.isQuoset quo))
diff --git a/Cubical/Relation/Binary/Order/StrictOrder.agda b/Cubical/Relation/Binary/Order/StrictOrder.agda
new file mode 100644
index 0000000000..81a6946c9d
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/StrictOrder.agda
@@ -0,0 +1,5 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.StrictOrder where
+
+open import Cubical.Relation.Binary.Order.StrictOrder.Base public
+open import Cubical.Relation.Binary.Order.StrictOrder.Properties public
diff --git a/Cubical/Relation/Binary/Order/StrictOrder/Base.agda b/Cubical/Relation/Binary/Order/StrictOrder/Base.agda
new file mode 100644
index 0000000000..f70a9ab16a
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/StrictOrder/Base.agda
@@ -0,0 +1,130 @@
+{-# OPTIONS --safe #-}
+{-
+  Strict orders are linear orders that aren't connected,
+  or a quasiorder with comparison
+-}
+module Cubical.Relation.Binary.Order.StrictOrder.Base where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.Transport
+open import Cubical.Foundations.SIP
+
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation
+
+open import Cubical.Reflection.RecordEquiv
+open import Cubical.Reflection.StrictEquiv
+
+open import Cubical.Displayed.Base
+open import Cubical.Displayed.Auto
+open import Cubical.Displayed.Record
+open import Cubical.Displayed.Universe
+
+open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Nullary.Properties
+
+open Iso
+open BinaryRelation
+
+
+private
+  variable
+    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
+
+record IsStrictOrder {A : Type ℓ} (_<_ : A → A → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+  no-eta-equality
+  constructor isstrictorder
+
+  field
+    is-set : isSet A
+    is-prop-valued : isPropValued _<_
+    is-irrefl : isIrrefl _<_
+    is-trans : isTrans _<_
+    is-asym : isAsym _<_
+    is-weakly-linear : isWeaklyLinear _<_
+
+unquoteDecl IsStrictOrderIsoΣ = declareRecordIsoΣ IsStrictOrderIsoΣ (quote IsStrictOrder)
+
+
+record StrictOrderStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')) where
+
+  constructor strictorderstr
+
+  field
+    _<_     : A → A → Type ℓ'
+    isStrictOrder : IsStrictOrder _<_
+
+  infixl 7 _<_
+
+  open IsStrictOrder isStrictOrder public
+
+StrictOrder : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
+StrictOrder ℓ ℓ' = TypeWithStr ℓ (StrictOrderStr ℓ')
+
+strictorder : (A : Type ℓ) → (_<_ : Rel A A ℓ') → IsStrictOrder _<_ → StrictOrder ℓ ℓ'
+strictorder A _<_ strict = A , (strictorderstr _<_ strict)
+
+record IsStrictOrderEquiv {A : Type ℓ₀} {B : Type ℓ₁}
+  (M : StrictOrderStr ℓ₀' A) (e : A ≃ B) (N : StrictOrderStr ℓ₁' B)
+  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
+  where
+  constructor
+   isstrictorderequiv
+  -- Shorter qualified names
+  private
+    module M = StrictOrderStr M
+    module N = StrictOrderStr N
+
+  field
+    pres< : (x y : A) → x M.< y ≃ equivFun e x N.< equivFun e y
+
+
+StrictOrderEquiv : (M : StrictOrder ℓ₀ ℓ₀') (M : StrictOrder ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
+StrictOrderEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsStrictOrderEquiv (M .snd) e (N .snd)
+
+isPropIsStrictOrder : {A : Type ℓ} (_<_ : A → A → Type ℓ') → isProp (IsStrictOrder _<_)
+isPropIsStrictOrder _<_ = isOfHLevelRetractFromIso 1 IsStrictOrderIsoΣ
+  (isPropΣ isPropIsSet
+    λ isSetA → isPropΣ (isPropΠ2 (λ _ _ → isPropIsProp))
+      λ isPropValued< → isProp×3 (isPropΠ (λ x → isProp¬ (x < x)))
+                                 (isPropΠ5 (λ _ _ _ _ _ → isPropValued< _ _))
+                                 (isPropΠ3 (λ x y _ → isProp¬ (y < x)))
+                                 (isPropΠ4 λ _ _ _ _ → squash₁))
+
+𝒮ᴰ-StrictOrder : DUARel (𝒮-Univ ℓ) (StrictOrderStr ℓ') (ℓ-max ℓ ℓ')
+𝒮ᴰ-StrictOrder =
+  𝒮ᴰ-Record (𝒮-Univ _) IsStrictOrderEquiv
+    (fields:
+      data[ _<_ ∣ autoDUARel _ _ ∣ pres< ]
+      prop[ isStrictOrder ∣ (λ _ _ → isPropIsStrictOrder _) ])
+    where
+    open StrictOrderStr
+    open IsStrictOrder
+    open IsStrictOrderEquiv
+
+StrictOrderPath : (M N : StrictOrder ℓ ℓ') → StrictOrderEquiv M N ≃ (M ≡ N)
+StrictOrderPath = ∫ 𝒮ᴰ-StrictOrder .UARel.ua
+
+-- an easier way of establishing an equivalence of strict orders
+module _ {P : StrictOrder ℓ₀ ℓ₀'} {S : StrictOrder ℓ₁ ℓ₁'} (e : ⟨ P ⟩ ≃ ⟨ S ⟩) where
+  private
+    module P = StrictOrderStr (P .snd)
+    module S = StrictOrderStr (S .snd)
+
+  module _ (isMon : ∀ x y → x P.< y → equivFun e x S.< equivFun e y)
+           (isMonInv : ∀ x y → x S.< y → invEq e x P.< invEq e y) where
+    open IsStrictOrderEquiv
+    open IsStrictOrder
+
+    makeIsStrictOrderEquiv : IsStrictOrderEquiv (P .snd) e (S .snd)
+    pres< makeIsStrictOrderEquiv x y = propBiimpl→Equiv (P.isStrictOrder .is-prop-valued _ _)
+                                                  (S.isStrictOrder .is-prop-valued _ _)
+                                                  (isMon _ _) (isMonInv' _ _)
+      where
+      isMonInv' : ∀ x y → equivFun e x S.< equivFun e y → x P.< y
+      isMonInv' x y ex<ey = transport (λ i → retEq e x i P.< retEq e y i) (isMonInv _ _ ex<ey)
diff --git a/Cubical/Relation/Binary/Order/StrictOrder/Properties.agda b/Cubical/Relation/Binary/Order/StrictOrder/Properties.agda
new file mode 100644
index 0000000000..b27118c823
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/StrictOrder/Properties.agda
@@ -0,0 +1,120 @@
+{-# OPTIONS --safe #-}
+module Cubical.Relation.Binary.Order.StrictOrder.Properties where
+
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Empty as ⊥
+
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Functions.Embedding
+
+open import Cubical.HITs.PropositionalTruncation as ∥₁
+
+open import Cubical.Relation.Binary.Base
+open import Cubical.Relation.Binary.Order.Apartness.Base
+open import Cubical.Relation.Binary.Order.Toset
+open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Proset.Base
+open import Cubical.Relation.Binary.Order.Quoset.Base
+open import Cubical.Relation.Binary.Order.StrictOrder.Base
+
+open import Cubical.Relation.Nullary
+
+private
+  variable
+    ℓ ℓ' ℓ'' : Level
+
+module _
+  {A : Type ℓ}
+  {R : Rel A A ℓ'}
+  where
+
+  open BinaryRelation
+
+  isStrictOrder→isStrictPoset : IsStrictOrder R → IsQuoset R
+  isStrictOrder→isStrictPoset strictorder = isquoset
+                                (IsStrictOrder.is-set strictorder)
+                                (IsStrictOrder.is-prop-valued strictorder)
+                                (IsStrictOrder.is-irrefl strictorder)
+                                (IsStrictOrder.is-trans strictorder)
+                                (IsStrictOrder.is-asym strictorder)
+
+  private
+    transrefl : isTrans R → isTrans (ReflClosure R)
+    transrefl trans a b c (inl Rab) (inl Rbc) = inl (trans a b c Rab Rbc)
+    transrefl trans a b c (inl Rab) (inr b≡c) = inl (subst (R a) b≡c Rab)
+    transrefl trans a b c (inr a≡b) (inl Rbc) = inl (subst (λ z → R z c) (sym a≡b) Rbc)
+    transrefl trans a b c (inr a≡b) (inr b≡c) = inr (a≡b ∙ b≡c)
+
+    antisym : isIrrefl R → isTrans R → isAntisym (ReflClosure R)
+    antisym irr trans a b (inl Rab) (inl Rba) = ⊥.rec (irr a (trans a b a Rab Rba))
+    antisym irr trans a b (inl _) (inr b≡a) = sym b≡a
+    antisym irr trans a b (inr a≡b) _ = a≡b
+
+  isStrictOrder→isApartnessSymClosure : IsStrictOrder R
+                                      → IsApartness (SymClosure R)
+  isStrictOrder→isApartnessSymClosure strict
+    = isapartness (IsStrictOrder.is-set strict)
+                  (λ a b → isProp⊎ (IsStrictOrder.is-prop-valued strict a b)
+                                   (IsStrictOrder.is-prop-valued strict b a)
+                                   (IsStrictOrder.is-asym strict a b))
+                  (λ a x → ⊎.rec (IsStrictOrder.is-irrefl strict a)
+                                 (IsStrictOrder.is-irrefl strict a) x)
+                  (λ a b c x → ⊎.rec (λ Rab → ∥₁.map (⊎.map (λ Rac → inl Rac)
+                                                             (λ Rcb → inr Rcb))
+                                                      (IsStrictOrder.is-weakly-linear strict a b c Rab))
+                                     (λ Rba → ∥₁.rec isPropPropTrunc
+                                                     (λ y → ∣ ⊎.rec (λ Rbc → inr (inl Rbc))
+                                                     (λ Rca → inl (inr Rca)) y ∣₁)
+                                                     (IsStrictOrder.is-weakly-linear strict b a c Rba)) x)
+                  (isSymSymClosure R)
+
+  isStrictOrder→isProsetNegationRel : IsStrictOrder R
+                                    → IsProset (NegationRel R)
+  isStrictOrder→isProsetNegationRel strict
+    = isproset (IsStrictOrder.is-set strict)
+               (λ _ _ → isProp¬ _)
+               (IsStrictOrder.is-irrefl strict)
+                λ a b c ¬Rab ¬Rbc Rac →
+                    ∥₁.rec isProp⊥ (⊎.rec ¬Rab ¬Rbc)
+                          (IsStrictOrder.is-weakly-linear strict a c b Rac)
+
+  isStrictOrderInduced : IsStrictOrder R → (B : Type ℓ'') → (f : B ↪ A)
+                 → IsStrictOrder (InducedRelation R (B , f))
+  isStrictOrderInduced strict B (f , emb)
+    = isstrictorder (Embedding-into-isSet→isSet (f , emb) (IsStrictOrder.is-set strict))
+              (λ a b → IsStrictOrder.is-prop-valued strict (f a) (f b))
+              (λ a → IsStrictOrder.is-irrefl strict (f a))
+              (λ a b c → IsStrictOrder.is-trans strict (f a) (f b) (f c))
+              (λ a b → IsStrictOrder.is-asym strict (f a) (f b))
+               λ a b c → IsStrictOrder.is-weakly-linear strict (f a) (f b) (f c)
+
+  isStrictOrderDual : IsStrictOrder R → IsStrictOrder (Dual R)
+  isStrictOrderDual strict
+    = isstrictorder (IsStrictOrder.is-set strict)
+                    (λ a b → IsStrictOrder.is-prop-valued strict b a)
+                    (IsStrictOrder.is-irrefl strict)
+                    (λ a b c Rab Rbc → IsStrictOrder.is-trans strict c b a Rbc Rab)
+                    (λ a b → IsStrictOrder.is-asym strict b a)
+                    (λ a b c Rba → ∥₁.map (⊎.rec inr inl)
+                                          (IsStrictOrder.is-weakly-linear strict b a c Rba))
+
+StrictOrder→Quoset : StrictOrder ℓ ℓ' → Quoset ℓ ℓ'
+StrictOrder→Quoset (_ , strict)
+  = quoset _ (StrictOrderStr._<_ strict)
+             (isStrictOrder→isStrictPoset (StrictOrderStr.isStrictOrder strict))
+
+StrictOrder→Apartness : StrictOrder ℓ ℓ' → Apartness ℓ ℓ'
+StrictOrder→Apartness (_ , strict)
+  = apartness _ (BinaryRelation.SymClosure (StrictOrderStr._<_ strict))
+                (isStrictOrder→isApartnessSymClosure (StrictOrderStr.isStrictOrder strict))
+
+StrictOrder→Proset : StrictOrder ℓ ℓ' → Proset ℓ ℓ'
+StrictOrder→Proset (_ , strict)
+  = proset _ (BinaryRelation.NegationRel (StrictOrderStr._<_ strict))
+             (isStrictOrder→isProsetNegationRel (StrictOrderStr.isStrictOrder strict))
+
+DualStrictOrder : StrictOrder ℓ ℓ' → StrictOrder ℓ ℓ'
+DualStrictOrder (_ , strict)
+  = strictorder _ (BinaryRelation.Dual (StrictOrderStr._<_ strict))
+                  (isStrictOrderDual (StrictOrderStr.isStrictOrder strict))
diff --git a/Cubical/Relation/Binary/Order/StrictPoset.agda b/Cubical/Relation/Binary/Order/StrictPoset.agda
deleted file mode 100644
index 40760b020a..0000000000
--- a/Cubical/Relation/Binary/Order/StrictPoset.agda
+++ /dev/null
@@ -1,5 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.StrictPoset where
-
-open import Cubical.Relation.Binary.Order.StrictPoset.Base public
-open import Cubical.Relation.Binary.Order.StrictPoset.Properties public
diff --git a/Cubical/Relation/Binary/Order/StrictPoset/Base.agda b/Cubical/Relation/Binary/Order/StrictPoset/Base.agda
deleted file mode 100644
index 750ddf9f4d..0000000000
--- a/Cubical/Relation/Binary/Order/StrictPoset/Base.agda
+++ /dev/null
@@ -1,126 +0,0 @@
-{-# OPTIONS --safe #-}
-{-
-  Strict posets are posets where the relation is strict,
-  i.e. irreflexive rather than reflexive
--}
-module Cubical.Relation.Binary.Order.StrictPoset.Base where
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.Equiv
-open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Isomorphism
-open import Cubical.Foundations.Univalence
-open import Cubical.Foundations.Transport
-open import Cubical.Foundations.SIP
-
-open import Cubical.Data.Sigma
-
-open import Cubical.Reflection.RecordEquiv
-open import Cubical.Reflection.StrictEquiv
-
-open import Cubical.Displayed.Base
-open import Cubical.Displayed.Auto
-open import Cubical.Displayed.Record
-open import Cubical.Displayed.Universe
-
-open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Nullary.Properties
-
-open Iso
-open BinaryRelation
-
-
-private
-  variable
-    ℓ ℓ' ℓ'' ℓ₀ ℓ₀' ℓ₁ ℓ₁' : Level
-
-record IsStrictPoset {A : Type ℓ} (_<_ : A → A → Type ℓ') : Type (ℓ-max ℓ ℓ') where
-  no-eta-equality
-  constructor isstrictposet
-
-  field
-    is-set : isSet A
-    is-prop-valued : isPropValued _<_
-    is-irrefl : isIrrefl _<_
-    is-trans : isTrans _<_
-    is-asym : isAsym _<_
-
-unquoteDecl IsStrictPosetIsoΣ = declareRecordIsoΣ IsStrictPosetIsoΣ (quote IsStrictPoset)
-
-
-record StrictPosetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')) where
-
-  constructor strictposetstr
-
-  field
-    _<_     : A → A → Type ℓ'
-    isStrictPoset : IsStrictPoset _<_
-
-  infixl 7 _<_
-
-  open IsStrictPoset isStrictPoset public
-
-StrictPoset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
-StrictPoset ℓ ℓ' = TypeWithStr ℓ (StrictPosetStr ℓ')
-
-strictposet : (A : Type ℓ) (_<_ : A → A → Type ℓ') (h : IsStrictPoset _<_) → StrictPoset ℓ ℓ'
-strictposet A _<_ h = A , strictposetstr _<_ h
-
-record IsStrictPosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
-  (M : StrictPosetStr ℓ₀' A) (e : A ≃ B) (N : StrictPosetStr ℓ₁' B)
-  : Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') ℓ₁')
-  where
-  constructor
-   isstrictposetequiv
-  -- Shorter qualified names
-  private
-    module M = StrictPosetStr M
-    module N = StrictPosetStr N
-
-  field
-    pres< : (x y : A) → x M.< y ≃ equivFun e x N.< equivFun e y
-
-
-StrictPosetEquiv : (M : StrictPoset ℓ₀ ℓ₀') (M : StrictPoset ℓ₁ ℓ₁') → Type (ℓ-max (ℓ-max ℓ₀ ℓ₀') (ℓ-max ℓ₁ ℓ₁'))
-StrictPosetEquiv M N = Σ[ e ∈ ⟨ M ⟩ ≃ ⟨ N ⟩ ] IsStrictPosetEquiv (M .snd) e (N .snd)
-
-isPropIsStrictPoset : {A : Type ℓ} (_<_ : A → A → Type ℓ') → isProp (IsStrictPoset _<_)
-isPropIsStrictPoset _<_ = isOfHLevelRetractFromIso 1 IsStrictPosetIsoΣ
-  (isPropΣ isPropIsSet
-    λ isSetA → isPropΣ (isPropΠ2 (λ _ _ → isPropIsProp))
-      λ isPropValued< → isProp×2 (isPropΠ (λ x → isProp¬ (x < x)))
-                                 (isPropΠ5 (λ _ _ _ _ _ → isPropValued< _ _))
-                                 (isPropΠ3 λ x y _ → isProp¬ (y < x)))
-
-𝒮ᴰ-StrictPoset : DUARel (𝒮-Univ ℓ) (StrictPosetStr ℓ') (ℓ-max ℓ ℓ')
-𝒮ᴰ-StrictPoset =
-  𝒮ᴰ-Record (𝒮-Univ _) IsStrictPosetEquiv
-    (fields:
-      data[ _<_ ∣ autoDUARel _ _ ∣ pres< ]
-      prop[ isStrictPoset ∣ (λ _ _ → isPropIsStrictPoset _) ])
-    where
-    open StrictPosetStr
-    open IsStrictPoset
-    open IsStrictPosetEquiv
-
-StrictPosetPath : (M N : StrictPoset ℓ ℓ') → StrictPosetEquiv M N ≃ (M ≡ N)
-StrictPosetPath = ∫ 𝒮ᴰ-StrictPoset .UARel.ua
-
--- an easier way of establishing an equivalence of strict posets
-module _ {P : StrictPoset ℓ₀ ℓ₀'} {S : StrictPoset ℓ₁ ℓ₁'} (e : ⟨ P ⟩ ≃ ⟨ S ⟩) where
-  private
-    module P = StrictPosetStr (P .snd)
-    module S = StrictPosetStr (S .snd)
-
-  module _ (isMon : ∀ x y → x P.< y → equivFun e x S.< equivFun e y)
-           (isMonInv : ∀ x y → x S.< y → invEq e x P.< invEq e y) where
-    open IsStrictPosetEquiv
-    open IsStrictPoset
-
-    makeIsStrictPosetEquiv : IsStrictPosetEquiv (P .snd) e (S .snd)
-    pres< makeIsStrictPosetEquiv x y = propBiimpl→Equiv (P.isStrictPoset .is-prop-valued _ _)
-                                                  (S.isStrictPoset .is-prop-valued _ _)
-                                                  (isMon _ _) (isMonInv' _ _)
-      where
-      isMonInv' : ∀ x y → equivFun e x S.< equivFun e y → x P.< y
-      isMonInv' x y ex<ey = transport (λ i → retEq e x i P.< retEq e y i) (isMonInv _ _ ex<ey)
diff --git a/Cubical/Relation/Binary/Order/StrictPoset/Properties.agda b/Cubical/Relation/Binary/Order/StrictPoset/Properties.agda
deleted file mode 100644
index b9a1098516..0000000000
--- a/Cubical/Relation/Binary/Order/StrictPoset/Properties.agda
+++ /dev/null
@@ -1,94 +0,0 @@
-{-# OPTIONS --safe #-}
-module Cubical.Relation.Binary.Order.StrictPoset.Properties where
-
-open import Cubical.Data.Sum as ⊎
-open import Cubical.Data.Empty as ⊥
-
-open import Cubical.Foundations.Prelude
-
-open import Cubical.Functions.Embedding
-
-open import Cubical.HITs.PropositionalTruncation as ∥₁
-
-open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Apartness.Base
-open import Cubical.Relation.Binary.Order.Poset.Base
-open import Cubical.Relation.Binary.Order.StrictPoset.Base
-
-private
-  variable
-    ℓ ℓ' ℓ'' : Level
-
-module _
-  {A : Type ℓ}
-  {R : Rel A A ℓ'}
-  where
-
-  open BinaryRelation
-
-  private
-    transrefl : isTrans R → isTrans (ReflClosure R)
-    transrefl trans a b c (inl Rab) (inl Rbc) = inl (trans a b c Rab Rbc)
-    transrefl trans a b c (inl Rab) (inr b≡c) = inl (subst (R a) b≡c Rab)
-    transrefl trans a b c (inr a≡b) (inl Rbc) = inl (subst (λ z → R z c) (sym a≡b) Rbc)
-    transrefl trans a b c (inr a≡b) (inr b≡c) = inr (a≡b ∙ b≡c)
-
-    antisym : isIrrefl R → isTrans R → isAntisym (ReflClosure R)
-    antisym irr trans a b (inl Rab) (inl Rba) = ⊥.rec (irr a (trans a b a Rab Rba))
-    antisym irr trans a b (inl _) (inr b≡a) = sym b≡a
-    antisym irr trans a b (inr a≡b) _ = a≡b
-
-  isStrictPoset→isPosetReflClosure : IsStrictPoset R → IsPoset (ReflClosure R)
-  isStrictPoset→isPosetReflClosure strictposet
-    = isposet (IsStrictPoset.is-set strictposet)
-              (λ a b → isProp⊎ (IsStrictPoset.is-prop-valued strictposet a b)
-                               (IsStrictPoset.is-set strictposet a b)
-                                 λ Rab a≡b
-                                   → IsStrictPoset.is-irrefl strictposet a (subst (R a)
-                                                                           (sym a≡b) Rab))
-              (isReflReflClosure R)
-              (transrefl (IsStrictPoset.is-trans strictposet))
-              (antisym (IsStrictPoset.is-irrefl strictposet)
-                       (IsStrictPoset.is-trans strictposet))
-
-  isStrictPoset→isApartnessSymClosure : IsStrictPoset R
-                                      → isWeaklyLinear R
-                                      → IsApartness (SymClosure R)
-  isStrictPoset→isApartnessSymClosure strictposet weak
-    = isapartness (IsStrictPoset.is-set strictposet)
-                  (λ a b → isProp⊎ (IsStrictPoset.is-prop-valued strictposet a b)
-                                   (IsStrictPoset.is-prop-valued strictposet b a)
-                                   (IsStrictPoset.is-asym strictposet a b))
-                  (λ a x → ⊎.rec (IsStrictPoset.is-irrefl strictposet a)
-                                 (IsStrictPoset.is-irrefl strictposet a) x)
-                  (λ a b c x → ⊎.rec (λ Rab → ∥₁.map (⊎.map (λ Rac → inl Rac)
-                                                             (λ Rcb → inr Rcb))
-                                                      (weak a b c Rab))
-                                     (λ Rba → ∥₁.rec isPropPropTrunc
-                                                     (λ y → ∣ ⊎.rec (λ Rbc → inr (inl Rbc))
-                                                     (λ Rca → inl (inr Rca)) y ∣₁)
-                                                     (weak b a c Rba)) x)
-                  (isSymSymClosure R)
-
-  isStrictPosetInduced : IsStrictPoset R → (B : Type ℓ'') → (f : B ↪ A)
-                       → IsStrictPoset (InducedRelation R (B , f))
-  isStrictPosetInduced strictpos B (f , emb)
-    = isstrictposet (Embedding-into-isSet→isSet (f , emb)
-                                                (IsStrictPoset.is-set strictpos))
-                    (λ a b → IsStrictPoset.is-prop-valued strictpos (f a) (f b))
-                    (λ a → IsStrictPoset.is-irrefl strictpos (f a))
-                    (λ a b c → IsStrictPoset.is-trans strictpos (f a) (f b) (f c))
-                    λ a b → IsStrictPoset.is-asym strictpos (f a) (f b)
-
-StrictPoset→Poset : StrictPoset ℓ ℓ' → Poset ℓ (ℓ-max ℓ ℓ')
-StrictPoset→Poset (_ , strictpos)
-  = _ , posetstr (BinaryRelation.ReflClosure (StrictPosetStr._<_ strictpos))
-                 (isStrictPoset→isPosetReflClosure (StrictPosetStr.isStrictPoset strictpos))
-
-StrictPoset→Apartness : (R : StrictPoset ℓ ℓ')
-                      → BinaryRelation.isWeaklyLinear (StrictPosetStr._<_ (snd R))
-                      → Apartness ℓ ℓ'
-StrictPoset→Apartness (_ , strictpos) weak
-  = _ , apartnessstr (BinaryRelation.SymClosure (StrictPosetStr._<_ strictpos))
-                     (isStrictPoset→isApartnessSymClosure
-                       (StrictPosetStr.isStrictPoset strictpos) weak)
diff --git a/Cubical/Relation/Binary/Order/Toset/Base.agda b/Cubical/Relation/Binary/Order/Toset/Base.agda
index d91fa08768..37d3b5cb30 100644
--- a/Cubical/Relation/Binary/Order/Toset/Base.agda
+++ b/Cubical/Relation/Binary/Order/Toset/Base.agda
@@ -46,7 +46,7 @@ record IsToset {A : Type ℓ} (_≤_ : A → A → Type ℓ') : Type (ℓ-max 
     is-refl : isRefl _≤_
     is-trans : isTrans _≤_
     is-antisym : isAntisym _≤_
-    is-strongly-connected : isStronglyConnected _≤_
+    is-total : isTotal _≤_
 
 unquoteDecl IsTosetIsoΣ = declareRecordIsoΣ IsTosetIsoΣ (quote IsToset)
 
@@ -66,8 +66,8 @@ record TosetStr (ℓ' : Level) (A : Type ℓ) : Type (ℓ-max ℓ (ℓ-suc ℓ')
 Toset : ∀ ℓ ℓ' → Type (ℓ-max (ℓ-suc ℓ) (ℓ-suc ℓ'))
 Toset ℓ ℓ' = TypeWithStr ℓ (TosetStr ℓ')
 
-toset : (A : Type ℓ) (_≤_ : A → A → Type ℓ') (h : IsToset _≤_) → Toset ℓ ℓ'
-toset A _≤_ h = A , tosetstr _≤_ h
+toset : (A : Type ℓ) → (_≤_ : Rel A A ℓ') → IsToset _≤_ → Toset ℓ ℓ'
+toset A _≤_ tos = A , (tosetstr _≤_ tos)
 
 record IsTosetEquiv {A : Type ℓ₀} {B : Type ℓ₁}
   (M : TosetStr ℓ₀' A) (e : A ≃ B) (N : TosetStr ℓ₁' B)
diff --git a/Cubical/Relation/Binary/Order/Toset/Properties.agda b/Cubical/Relation/Binary/Order/Toset/Properties.agda
index a7299ccc22..2bb17ea382 100644
--- a/Cubical/Relation/Binary/Order/Toset/Properties.agda
+++ b/Cubical/Relation/Binary/Order/Toset/Properties.agda
@@ -1,18 +1,23 @@
 {-# OPTIONS --safe #-}
 module Cubical.Relation.Binary.Order.Toset.Properties where
 
+open import Cubical.Data.Sigma
 open import Cubical.Data.Sum as ⊎
 open import Cubical.Data.Empty as ⊥
 
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.Prelude
 open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Structure
 
 open import Cubical.Functions.Embedding
 
 open import Cubical.HITs.PropositionalTruncation as ∥₁
 
 open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Poset.Base
+open import Cubical.Relation.Binary.Order.Proset.Properties
+open import Cubical.Relation.Binary.Order.Poset
 open import Cubical.Relation.Binary.Order.Toset.Base
 open import Cubical.Relation.Binary.Order.Loset.Base
 
@@ -36,14 +41,18 @@ module _
                           (IsToset.is-refl toset)
                           (IsToset.is-trans toset)
                           (IsToset.is-antisym toset)
+
+  isTosetDecidable→Discrete : IsToset R → isDecidable R → Discrete A
+  isTosetDecidable→Discrete = isPosetDecidable→Discrete ∘ isToset→isPoset
+
   private
     transirrefl : isTrans R → isAntisym R → isTrans (IrreflKernel R)
     transirrefl trans anti a b c (Rab , ¬a≡b) (Rbc , ¬b≡c)
       = trans a b c Rab Rbc
       , λ a≡c → ¬a≡b (anti a b Rab (subst (R b) (sym a≡c) Rbc))
 
-  isToset→isLosetIrreflKernel : Discrete A → IsToset R → IsLoset (IrreflKernel R)
-  isToset→isLosetIrreflKernel disc toset
+  isToset→isLosetIrreflKernel : IsToset R → isDecidable R → IsLoset (IrreflKernel R)
+  isToset→isLosetIrreflKernel toset dec
     = isloset (IsToset.is-set toset)
               (λ a b → isProp× (IsToset.is-prop-valued toset a b)
                                (isProp¬ (a ≡ b)))
@@ -59,15 +68,35 @@ module _
                          (λ Rbc → inr (Rbc , λ b≡c → ¬a≡c (a≡b ∙ b≡c)))
                                 λ Rcb → ⊥.rec (¬a≡c (IsToset.is-antisym toset a c Rac
                                               (subst (λ x → R c x) (sym a≡b) Rcb))))
-                                  (IsToset.is-strongly-connected toset b c))
+                                  (IsToset.is-total toset b c))
                          (λ ¬a≡b → ∥₁.map (⊎.map (λ Rab → Rab , ¬a≡b)
                                    (λ Rba → (IsToset.is-trans toset b a c Rba Rac)
                                    , λ b≡c → ¬a≡b (IsToset.is-antisym toset a b
                                        (subst (λ x → R a x) (sym b≡c) Rac) Rba)))
-                                 (IsToset.is-strongly-connected toset a b))
+                                 (IsToset.is-total toset a b))
                          (disc a b))
-              (isConnectedStronglyConnectedIrreflKernel R
-                (IsToset.is-strongly-connected toset))
+               λ { a b (¬¬Rab , ¬¬Rba) → IsToset.is-antisym toset a b
+                                         (decRec (λ Rab → Rab)
+                                           (λ ¬Rab → ⊥.rec (∥₁.rec isProp⊥
+                                             (⊎.rec ¬Rab λ Rba → ¬¬Rba (Rba ,
+                                               (λ b≡a → ¬Rab (subst (λ x → R x b) b≡a
+                                                 (IsToset.is-refl toset b)))))
+                                             (IsToset.is-total toset a b))) (dec a b))
+                                         (decRec (λ Rba → Rba)
+                                           (λ ¬Rba → ⊥.rec (∥₁.rec isProp⊥
+                                             (⊎.rec ¬Rba λ Rab → ¬¬Rab (Rab ,
+                                               (λ a≡b → ¬Rba (subst (λ x → R x a) a≡b
+                                                 (IsToset.is-refl toset a)))))
+                                             (IsToset.is-total toset b a))) (dec b a))}
+    where disc : Discrete A
+          disc = isTosetDecidable→Discrete toset dec
+
+  isTosetDecidable→isLosetDecidable : IsToset R → isDecidable R → isDecidable (IrreflKernel R)
+  isTosetDecidable→isLosetDecidable tos dec a b with dec a b
+  ... | no ¬Rab = no λ { (Rab , _) → ¬Rab Rab }
+  ... | yes Rab with (isTosetDecidable→Discrete tos dec) a b
+  ...       | yes a≡b = no λ { (_ , ¬a≡b) → ¬a≡b a≡b }
+  ...       | no  a≢b = yes (Rab , a≢b)
 
   isTosetInduced : IsToset R → (B : Type ℓ'') → (f : B ↪ A)
                  → IsToset (InducedRelation R (B , f))
@@ -78,14 +107,290 @@ module _
               (λ a b c → IsToset.is-trans tos (f a) (f b) (f c))
               (λ a b a≤b b≤a → isEmbedding→Inj emb a b
                 (IsToset.is-antisym tos (f a) (f b) a≤b b≤a))
-              λ a b → IsToset.is-strongly-connected tos (f a) (f b)
+              λ a b → IsToset.is-total tos (f a) (f b)
+
+  isTosetDual : IsToset R → IsToset (Dual R)
+  isTosetDual tos
+    = istoset (IsToset.is-set tos)
+              (λ a b → IsToset.is-prop-valued tos b a)
+              (IsToset.is-refl tos)
+              (λ a b c Rab Rbc → IsToset.is-trans tos c b a Rbc Rab)
+              (λ a b Rab Rba → IsToset.is-antisym tos a b Rba Rab)
+               λ a b → IsToset.is-total tos b a
 
 Toset→Poset : Toset ℓ ℓ' → Poset ℓ ℓ'
-Toset→Poset (_ , tos) = _ , posetstr (TosetStr._≤_ tos)
-                                     (isToset→isPoset (TosetStr.isToset tos))
-
-Toset→Loset : (tos : Toset ℓ ℓ') → Discrete (fst tos) → Loset ℓ (ℓ-max ℓ ℓ')
-Toset→Loset (_ , tos) disc
-  = _ , losetstr (BinaryRelation.IrreflKernel (TosetStr._≤_ tos))
-                       (isToset→isLosetIrreflKernel disc
-                                                    (TosetStr.isToset tos))
+Toset→Poset (_ , tos)
+  = poset _ (TosetStr._≤_ tos)
+            (isToset→isPoset (TosetStr.isToset tos))
+
+Toset→Loset : (tos : Toset ℓ ℓ')
+            → BinaryRelation.isDecidable (TosetStr._≤_ (snd tos))
+            → Loset ℓ (ℓ-max ℓ ℓ')
+Toset→Loset (_ , tos) dec
+  = loset _ (BinaryRelation.IrreflKernel (TosetStr._≤_ tos))
+            (isToset→isLosetIrreflKernel (TosetStr.isToset tos) dec)
+
+DualToset : Toset ℓ ℓ' → Toset ℓ ℓ'
+DualToset (_ , tos)
+  = toset _ (BinaryRelation.Dual (TosetStr._≤_ tos))
+            (isTosetDual (TosetStr.isToset tos))
+
+module _
+  {A : Type ℓ}
+  {_≤_ : Rel A A ℓ'}
+  (tos : IsToset _≤_)
+  where
+
+  private
+      pos = isToset→isPoset tos
+
+      pre = isPoset→isProset pos
+
+      prop = IsToset.is-prop-valued tos
+
+      rfl = IsToset.is-refl tos
+
+      anti = IsToset.is-antisym tos
+
+      trans = IsToset.is-trans tos
+
+      total = IsToset.is-total tos
+
+  module _
+    {P : Embedding A ℓ''}
+    where
+
+    private
+      toA = fst (snd P)
+
+    isMinimal→isLeast : ∀ n → isMinimal pre P n → isLeast pre P n
+    isMinimal→isLeast n ism m
+      = ∥₁.rec (prop _ _) (⊎.rec (λ n≤m → n≤m) (λ m≤n → ism m m≤n)) (total (toA n) (toA m))
+
+    isMaximal→isGreatest : ∀ n → isMaximal pre P n → isGreatest pre P n
+    isMaximal→isGreatest n ism m
+      = ∥₁.rec (prop _ _) (⊎.rec (λ n≤m → ism m n≤m) (λ m≤n → m≤n)) (total (toA n) (toA m))
+
+TosetIsPseudolattice : (tos : Toset ℓ ℓ')
+                     → isPseudolattice (Toset→Poset tos)
+TosetIsPseudolattice tos = meet , join
+  where
+    is = TosetStr.isToset (tos .snd)
+
+    posis = PosetStr.isPoset (Toset→Poset tos .snd)
+
+    prop = IsToset.is-prop-valued is
+
+    rfl = IsToset.is-refl is
+
+    trans = IsToset.is-trans is
+
+    total = IsToset.is-total is
+
+    meet : isMeetSemipseudolattice (Toset→Poset tos)
+    meet a b = ∥₁.rec (MeetUnique posis a b)
+                 (⊎.rec
+                   (λ a≤b → a ,
+                     λ x → propBiimpl→Equiv
+                             (prop _ _)
+                             (isProp× (prop _ _) (prop _ _))
+                             (λ x≤a → x≤a , (trans x a b x≤a a≤b))
+                              fst)
+                   (λ b≤a → b ,
+                     λ x → propBiimpl→Equiv
+                             (prop _ _)
+                             (isProp× (prop _ _) (prop _ _))
+                             (λ x≤b → trans x b a x≤b b≤a , x≤b)
+                              snd))
+                 (total a b)
+
+    join : isJoinSemipseudolattice (Toset→Poset tos)
+    join a b = ∥₁.rec (JoinUnique posis a b)
+                 (⊎.rec
+                   (λ a≤b → b ,
+                     λ x → propBiimpl→Equiv
+                             (prop _ _)
+                             (isProp× (prop _ _) (prop _ _))
+                             (λ b≤x → trans a b x a≤b b≤x , b≤x)
+                              snd)
+                   (λ b≤a → a ,
+                     λ x → propBiimpl→Equiv
+                             (prop _ _)
+                             (isProp× (prop _ _) (prop _ _))
+                             (λ a≤x → a≤x , trans b a x b≤a a≤x)
+                              fst))
+                 (total a b)
+
+-- We take the pseudolattice component in as an assumption because more likely than not,
+-- the goal is to prove some meet and join on a toset is distributive, not the
+-- meet and join that implicitly come with any toset
+TosetIsDistributivePseudolattice : (tos : Toset ℓ ℓ')
+                                 → (lat : isPseudolattice (Toset→Poset tos))
+                                 → MeetDistLJoin (Toset→Poset tos) lat
+TosetIsDistributivePseudolattice tos lat = dist
+  where
+    _≤_ = TosetStr._≤_ (tos .snd)
+    is = TosetStr.isToset (tos .snd)
+
+    pos = isToset→isPoset is
+
+    pro = isPoset→isProset pos
+
+    set = IsToset.is-set is
+
+    rfl = IsToset.is-refl is
+
+    trans = IsToset.is-trans is
+
+    anti = IsToset.is-antisym is
+
+    total = IsToset.is-total is
+
+    _∧l_ : ⟨ tos ⟩ → ⟨ tos ⟩ → ⟨ tos ⟩
+    a ∧l b = lat .fst a b .fst
+
+    meet : ∀ a b → isMeet pro a b (a ∧l b)
+    meet a b = lat .fst a b .snd
+
+    _∨l_ : ⟨ tos ⟩ → ⟨ tos ⟩ → ⟨ tos ⟩
+    a ∨l b = lat .snd a b .fst
+
+    join : ∀ a b → isJoin pro a b (a ∨l b)
+    join a b = lat .snd a b .snd
+
+    order→meet : ∀{a b} → a ≤ b → a ∧l b ≡ a
+    order→meet {a} {b} a≤b = sym (equivFun (order≃meet pos a b (a ∧l b) (meet a b)) a≤b)
+
+    order→join : ∀{a b} → a ≤ b → a ∨l b ≡ b
+    order→join {a} {b} a≤b = sym (equivFun (order≃join pos a b (a ∨l b) (join a b)) a≤b)
+
+    ∧Comm : ∀{a b} → a ∧l b ≡ b ∧l a
+    ∧Comm {a} {b} = meetComm pos (λ x y → (x ∧l y) , meet x y) a b
+
+    ∨Comm : ∀{ a b } → a ∨l b ≡ b ∨l a
+    ∨Comm {a} {b} = joinComm pos (λ x y → (x ∨l y) , join x y) a b
+
+    dist : ∀ a b c
+         → a ∧l (b ∨l c) ≡ (a ∧l b) ∨l (a ∧l c)
+    dist a b c = lem1+2+3+4+5+6+7+8
+      where
+        goal = a ∧l (b ∨l c) ≡ (a ∧l b) ∨l (a ∧l c)
+
+        lem1 : a ≤ b
+             → b ≤ c
+             → a ≤ c
+             → goal
+        lem1 a≤b b≤c a≤c = (cong (a ∧l_) (order→join b≤c) ∙
+                                   order→meet a≤c) ∙
+                             sym (cong₂ _∨l_ (order→meet a≤b)
+                                             (order→meet a≤c) ∙
+                                  order→join (rfl a))
+
+        lem2 : a ≤ b
+             → b ≤ c
+             → c ≤ a
+             → goal
+        lem2 a≤b b≤c c≤a = (cong (a ∧l_) (order→join b≤c) ∙
+                                   ∧Comm ∙
+                                   order→meet c≤a) ∙
+                             sym (cong₂ _∨l_ (order→meet a≤b)
+                                             (∧Comm ∙ order→meet c≤a) ∙
+                                  ∨Comm ∙
+                                  order→join c≤a ∙
+                                  anti a c (trans a b c a≤b b≤c) c≤a)
+
+        lem1+2 : a ≤ b
+               → b ≤ c
+               → goal
+        lem1+2 a≤b b≤c = ∥₁.rec (set _ _) (⊎.rec (lem1 a≤b b≤c) (lem2 a≤b b≤c)) (total a c)
+
+        lem3 : a ≤ b
+             → c ≤ b
+             → a ≤ c
+             → goal
+        lem3 a≤b c≤b a≤c = (cong (a ∧l_) (∨Comm ∙
+                                            order→join c≤b) ∙
+                                    order→meet a≤b) ∙
+                             sym (cong₂ _∨l_ (order→meet a≤b)
+                                             (order→meet a≤c) ∙
+                                  order→join (rfl a))
+
+        lem4 : a ≤ b
+             → c ≤ b
+             → c ≤ a
+             → goal
+        lem4 a≤b c≤b c≤a = (cong (a ∧l_) (∨Comm ∙
+                                            order→join c≤b) ∙
+                                    order→meet a≤b) ∙
+                             sym (cong₂ _∨l_ (order→meet a≤b)
+                                             (∧Comm ∙ order→meet c≤a) ∙
+                                  ∨Comm ∙
+                                  order→join c≤a)
+
+        lem3+4 : a ≤ b
+               → c ≤ b
+               → goal
+        lem3+4 a≤b c≤b = ∥₁.rec (set _ _ ) (⊎.rec (lem3 a≤b c≤b) (lem4 a≤b c≤b)) (total a c)
+
+        lem1+2+3+4 : a ≤ b
+                   → goal
+        lem1+2+3+4 a≤b = ∥₁.rec (set _ _) (⊎.rec (lem1+2 a≤b) (lem3+4 a≤b)) (total b c)
+
+        lem5 : b ≤ a
+             → b ≤ c
+             → a ≤ c
+             → goal
+        lem5 b≤a b≤c a≤c = (cong (a ∧l_) (order→join b≤c) ∙
+                                   order→meet a≤c) ∙
+                             sym (cong₂ _∨l_ (∧Comm ∙ order→meet b≤a) (order→meet a≤c) ∙
+                                  order→join b≤a)
+
+        lem6 : b ≤ a
+             → b ≤ c
+             → c ≤ a
+             → goal
+        lem6 b≤a b≤c c≤a = (cong (a ∧l_) (order→join b≤c) ∙
+                                   ∧Comm ∙
+                                   order→meet c≤a) ∙
+                             sym (cong₂ _∨l_ (∧Comm ∙ order→meet b≤a)
+                                             (∧Comm ∙ order→meet c≤a) ∙
+                                  order→join b≤c)
+
+        lem5+6 : b ≤ a
+               → b ≤ c
+               → goal
+        lem5+6 b≤a b≤c = ∥₁.rec (set _ _) (⊎.rec (lem5 b≤a b≤c) (lem6 b≤a b≤c)) (total a c)
+
+        lem7 : b ≤ a
+             → c ≤ b
+             → a ≤ c
+             → goal
+        lem7 b≤a c≤b a≤c = (cong (a ∧l_) (∨Comm ∙ order→join c≤b) ∙
+                                   ∧Comm ∙
+                                   order→meet b≤a) ∙
+                             sym (cong₂ _∨l_ (∧Comm ∙ order→meet b≤a)
+                                             (order→meet a≤c) ∙
+                                  order→join b≤a ∙ anti a b (trans a c b a≤c c≤b) b≤a)
+
+        lem8 : b ≤ a
+             → c ≤ b
+             → c ≤ a
+             → goal
+        lem8 b≤a c≤b c≤a = (cong (a ∧l_) (∨Comm ∙ order→join c≤b) ∙
+                                   ∧Comm ∙
+                                   order→meet b≤a) ∙
+                             sym (cong₂ _∨l_ (∧Comm ∙ order→meet b≤a)
+                                             (∧Comm ∙ order→meet c≤a) ∙
+                                  ∨Comm ∙ order→join c≤b)
+
+        lem7+8 : b ≤ a
+               → c ≤ b
+               → goal
+        lem7+8 b≤a c≤b = ∥₁.rec (set _ _) (⊎.rec (lem7 b≤a c≤b) (lem8 b≤a c≤b)) (total a c)
+
+        lem5+6+7+8 : b ≤ a
+                   → goal
+        lem5+6+7+8 b≤a = ∥₁.rec (set _ _) (⊎.rec (lem5+6 b≤a) (lem7+8 b≤a)) (total b c)
+
+        lem1+2+3+4+5+6+7+8 : goal
+        lem1+2+3+4+5+6+7+8 = ∥₁.rec (set _ _) (⊎.rec lem1+2+3+4 lem5+6+7+8) (total a b)
diff --git a/Cubical/Relation/Binary/Order/Woset/Properties.agda b/Cubical/Relation/Binary/Order/Woset/Properties.agda
index 9a2e0a52e3..6ab5edecdc 100644
--- a/Cubical/Relation/Binary/Order/Woset/Properties.agda
+++ b/Cubical/Relation/Binary/Order/Woset/Properties.agda
@@ -5,7 +5,7 @@ open import Cubical.Foundations.Prelude
 
 open import Cubical.Relation.Binary.Base
 open import Cubical.Relation.Binary.Order.Woset.Base
-open import Cubical.Relation.Binary.Order.StrictPoset.Base
+open import Cubical.Relation.Binary.Order.Quoset.Base
 
 open import Cubical.Induction.WellFounded
 
@@ -20,18 +20,18 @@ module _
 
   open BinaryRelation
 
-  isWoset→isStrictPoset : IsWoset R → IsStrictPoset R
-  isWoset→isStrictPoset wos = isstrictposet
-                              (IsWoset.is-set wos)
-                              (IsWoset.is-prop-valued wos)
-                              irrefl
-                              (IsWoset.is-trans wos)
-                              (isIrrefl×isTrans→isAsym R
-                                (irrefl , (IsWoset.is-trans wos)))
-                        where irrefl : isIrrefl R
-                              irrefl = WellFounded→isIrrefl R
-                                       (IsWoset.is-well-founded wos)
-
-Woset→StrictPoset : Woset ℓ ℓ' → StrictPoset ℓ ℓ'
-Woset→StrictPoset (_ , wos) = _ , strictposetstr (WosetStr._≺_ wos)
-                                  (isWoset→isStrictPoset (WosetStr.isWoset wos))
+  isWoset→isQuoset : IsWoset R → IsQuoset R
+  isWoset→isQuoset wos = isquoset
+                        (IsWoset.is-set wos)
+                        (IsWoset.is-prop-valued wos)
+                         irrefl
+                        (IsWoset.is-trans wos)
+                        (isIrrefl×isTrans→isAsym R
+                          (irrefl , (IsWoset.is-trans wos)))
+                   where irrefl : isIrrefl R
+                         irrefl = WellFounded→isIrrefl R
+                                 (IsWoset.is-well-founded wos)
+
+Woset→Quoset : Woset ℓ ℓ' → Quoset ℓ ℓ'
+Woset→Quoset (_ , wos) = _ , quosetstr (WosetStr._≺_ wos)
+                            (isWoset→isQuoset (WosetStr.isWoset wos))
diff --git a/Cubical/Relation/Binary/Order/Woset/Simulation.agda b/Cubical/Relation/Binary/Order/Woset/Simulation.agda
index 51b789b6e8..48235f4a3c 100644
--- a/Cubical/Relation/Binary/Order/Woset/Simulation.agda
+++ b/Cubical/Relation/Binary/Order/Woset/Simulation.agda
@@ -24,7 +24,7 @@ open import Cubical.Relation.Binary.Order.Woset.Base
 open import Cubical.Relation.Binary.Order.Poset
 open import Cubical.Relation.Binary.Base
 open import Cubical.Relation.Binary.Extensionality
-open import Cubical.Relation.Binary.Order.Properties
+open import Cubical.Relation.Binary.Order.Proset.Properties
 
 private
   variable