Repository: UniMath/agda-unimath
Pull request #1388: Monotonic sequences in posets
Author: login: malarbol
Labels: name: order-theory
Created: 2025-03-28T17:51:23Z | Merged: 2025-04-22T16:42:52Z

This PR introduces a few definitions and results to work with sequences is preorders, posets or strictly preordered sets.
As an application, it introduces the concept of `subsequences` of a sequence `u`: the sequences `u ∘ f` for some strictly increasing map `f : ℕ → ℕ`.


Diff:
diff --git a/src/elementary-number-theory/strict-inequality-natural-numbers.lagda.md b/src/elementary-number-theory/strict-inequality-natural-numbers.lagda.md
index 623bc26c65e..027f13590a7 100644
--- a/src/elementary-number-theory/strict-inequality-natural-numbers.lagda.md
+++ b/src/elementary-number-theory/strict-inequality-natural-numbers.lagda.md
@@ -8,6 +8,7 @@ module elementary-number-theory.strict-inequality-natural-numbers where
 
 ```agda
 open import elementary-number-theory.addition-natural-numbers
+open import elementary-number-theory.equality-natural-numbers
 open import elementary-number-theory.inequality-natural-numbers
 open import elementary-number-theory.multiplication-natural-numbers
 open import elementary-number-theory.natural-numbers
@@ -29,6 +30,8 @@ open import foundation.propositions
 open import foundation.transport-along-identifications
 open import foundation.unit-type
 open import foundation.universe-levels
+
+open import order-theory.strictly-preordered-sets
 ```
 
 </details>
@@ -148,6 +151,15 @@ transitive-le-ℕ (succ-ℕ n) (succ-ℕ m) (succ-ℕ l) p q =
   transitive-le-ℕ n m l p q
 ```
 
+### The strictly preordered set of natural numbers orderd by strict inequality
+
+```agda
+strictly-preordered-set-ℕ : Strictly-Preordered-Set lzero lzero
+pr1 strictly-preordered-set-ℕ = ℕ-Set
+pr2 strictly-preordered-set-ℕ =
+  le-ℕ-Prop , anti-reflexive-le-ℕ , λ n m l I J → transitive-le-ℕ n m l J I
+```
+
 ### A sharper variant of transitivity
 
 ```agda
diff --git a/src/foundation.lagda.md b/src/foundation.lagda.md
index 429dd75e39d..d99f9fbe70a 100644
--- a/src/foundation.lagda.md
+++ b/src/foundation.lagda.md
@@ -405,6 +405,7 @@ open import foundation.structure public
 open import foundation.structure-identity-principle public
 open import foundation.structured-equality-duality public
 open import foundation.structured-type-duality public
+open import foundation.subsequences public
 open import foundation.subsingleton-induction public
 open import foundation.subterminal-types public
 open import foundation.subtype-duality public
diff --git a/src/foundation/strictly-right-unital-concatenation-identifications.lagda.md b/src/foundation/strictly-right-unital-concatenation-identifications.lagda.md
index 748f5c13d1b..ca593ec008d 100644
--- a/src/foundation/strictly-right-unital-concatenation-identifications.lagda.md
+++ b/src/foundation/strictly-right-unital-concatenation-identifications.lagda.md
@@ -64,7 +64,7 @@ module _
   right-strict-concat' x q p = p ∙ᵣ q
 ```
 
-### Translating between the stictly left and stricly right unital versions of concatenation
+### Translating between the strictly left and strictly right unital versions of concatenation
 
 ```agda
 module _
diff --git a/src/foundation/subsequences.lagda.md b/src/foundation/subsequences.lagda.md
new file mode 100644
index 00000000000..a9d95cf95bd
--- /dev/null
+++ b/src/foundation/subsequences.lagda.md
@@ -0,0 +1,128 @@
+# Subsequences
+
+```agda
+module foundation.subsequences where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+open import elementary-number-theory.strict-inequality-natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.identity-types
+open import foundation.propositional-truncations
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.strict-order-preserving-maps
+open import order-theory.strictly-increasing-sequences-strictly-preordered-sets
+```
+
+</details>
+
+## Idea
+
+A {{concept "subsequence" Agda=subsequence}} of a
+[sequence](foundation.sequences.md) `u : ℕ → A` is a sequence `u ∘ f` for some
+[strictly increasing](order-theory.strict-order-preserving-maps.md) sequence
+`f : ℕ → ℕ`.
+
+## Definitions
+
+### Subsequences of a sequence
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A)
+  where
+
+  subsequence : UU lzero
+  subsequence =
+    hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
+
+  extract-subsequence : subsequence → ℕ → ℕ
+  extract-subsequence =
+    map-hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
+
+  is-strictly-increasing-extract-subsequence :
+    (f : subsequence) →
+    preserves-strict-order-map-Strictly-Preordered-Set
+      ( strictly-preordered-set-ℕ)
+      ( strictly-preordered-set-ℕ)
+      ( extract-subsequence f)
+  is-strictly-increasing-extract-subsequence =
+    preserves-strict-order-hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
+
+  seq-subsequence : subsequence → sequence A
+  seq-subsequence f n = u (extract-subsequence f n)
+```
+
+## Properties
+
+### Any sequence is a subsequence of itself
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A)
+  where
+
+  refl-subsequence : subsequence u
+  refl-subsequence = id-hom-Strictly-Preordered-Set strictly-preordered-set-ℕ
+```
+
+### A subsequence of a subsequence is a subsequence of the original sequence
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A)
+  where
+
+  sub-subsequence :
+    (v : subsequence u) →
+    (w : subsequence (seq-subsequence u v)) →
+    subsequence u
+  sub-subsequence =
+    comp-hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
+```
+
+### The extraction sequence of a subsequence is superlinear
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A) (v : subsequence u)
+  where
+
+  abstract
+    is-superlinear-extract-subsequence :
+      (n : ℕ) → leq-ℕ n (extract-subsequence u v n)
+    is-superlinear-extract-subsequence zero-ℕ =
+      leq-zero-ℕ (extract-subsequence u v zero-ℕ)
+    is-superlinear-extract-subsequence (succ-ℕ n) =
+      leq-succ-le-ℕ
+        ( n)
+        ( extract-subsequence u v (succ-ℕ n))
+        ( concatenate-leq-le-ℕ
+          { n}
+          { extract-subsequence u v n}
+          { extract-subsequence u v (succ-ℕ n)}
+          ( is-superlinear-extract-subsequence n)
+          ( le-succ-is-strictly-increasing-sequence-Strictly-Preordered-Set
+            ( strictly-preordered-set-ℕ)
+            ( extract-subsequence u v)
+            ( is-strictly-increasing-extract-subsequence u v)
+            ( n)))
+```
diff --git a/src/order-theory.lagda.md b/src/order-theory.lagda.md
index 5d93468b213..111fb574313 100644
--- a/src/order-theory.lagda.md
+++ b/src/order-theory.lagda.md
@@ -52,6 +52,7 @@ open import order-theory.homomorphisms-meet-suplattices public
 open import order-theory.homomorphisms-suplattices public
 open import order-theory.ideals-preorders public
 open import order-theory.incidence-algebras public
+open import order-theory.increasing-sequences-posets public
 open import order-theory.inflationary-maps-posets public
 open import order-theory.inflationary-maps-preorders public
 open import order-theory.inflattices public
@@ -114,12 +115,16 @@ open import order-theory.reflective-galois-connections-large-posets public
 open import order-theory.resizing-posets public
 open import order-theory.resizing-preorders public
 open import order-theory.resizing-suplattices public
+open import order-theory.sequences-posets public
+open import order-theory.sequences-preorders public
+open import order-theory.sequences-strictly-preordered-sets public
 open import order-theory.similarity-of-elements-large-posets public
 open import order-theory.similarity-of-elements-large-preorders public
 open import order-theory.similarity-of-order-preserving-maps-large-posets public
 open import order-theory.similarity-of-order-preserving-maps-large-preorders public
 open import order-theory.strict-order-preserving-maps public
 open import order-theory.strict-preorders public
+open import order-theory.strictly-increasing-sequences-strictly-preordered-sets public
 open import order-theory.strictly-inflationary-maps-strict-preorders public
 open import order-theory.strictly-preordered-sets public
 open import order-theory.subposets public
diff --git a/src/order-theory/increasing-sequences-posets.lagda.md b/src/order-theory/increasing-sequences-posets.lagda.md
new file mode 100644
index 00000000000..6184600d4a8
--- /dev/null
+++ b/src/order-theory/increasing-sequences-posets.lagda.md
@@ -0,0 +1,105 @@
+# Increasing sequences in partially ordered sets
+
+```agda
+module order-theory.increasing-sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.decidable-total-order-natural-numbers
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.order-preserving-maps-posets
+open import order-theory.posets
+open import order-theory.sequences-posets
+open import order-theory.subposets
+```
+
+</details>
+
+## Idea
+
+A [sequence in a partially ordered set](order-theory.sequences-posets.md) `u` is
+{{#concept "increasing" Disambiguation="sequence in a poset" Agda=is-increasing-sequence-Poset}}
+if it [preserves](order-theory.order-preserving-maps-posets.md) the
+[standard ordering on the natural numbers](elementary-number-theory.inequality-natural-numbers.md)
+or, equivalently, if `uₙ ≤ uₙ₊₁` for all `n : ℕ`.
+
+## Definitions
+
+### The predicate of being an increasing sequence in a partially ordered set
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u : type-sequence-Poset P)
+  where
+
+  is-increasing-prop-sequence-Poset : Prop l2
+  is-increasing-prop-sequence-Poset =
+    preserves-order-prop-Poset ℕ-Poset P u
+
+  is-increasing-sequence-Poset : UU l2
+  is-increasing-sequence-Poset =
+    type-Prop is-increasing-prop-sequence-Poset
+```
+
+### The poset of increasing sequences in a poset
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  increasing-sequence-Poset : Poset (l1 ⊔ l2) l2
+  increasing-sequence-Poset =
+    poset-Subposet
+      ( sequence-Poset P)
+      ( is-increasing-prop-sequence-Poset P)
+
+  type-increasing-sequence-Poset : UU (l1 ⊔ l2)
+  type-increasing-sequence-Poset =
+    type-Poset increasing-sequence-Poset
+
+  seq-increasing-sequence-Poset :
+    type-increasing-sequence-Poset →
+    type-sequence-Poset P
+  seq-increasing-sequence-Poset = pr1
+
+  is-increasing-seq-increasing-sequence-Poset :
+    (u : type-increasing-sequence-Poset) →
+    is-increasing-sequence-Poset
+      ( P)
+      ( seq-increasing-sequence-Poset u)
+  is-increasing-seq-increasing-sequence-Poset = pr2
+```
+
+## Properties
+
+### A sequence `u` in a poset is increasing if and only if `uₙ ≤ uₙ₊₁` for all `n : ℕ`
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u : type-sequence-Poset P)
+  where
+
+  is-increasing-leq-succ-sequence-Poset :
+    ((n : ℕ) → leq-Poset P (u n) (u (succ-ℕ n))) →
+    is-increasing-sequence-Poset P u
+  is-increasing-leq-succ-sequence-Poset =
+    preserves-order-ind-ℕ-Poset P u
+
+  leq-succ-is-increasing-sequence-Poset :
+    is-increasing-sequence-Poset P u →
+    ((n : ℕ) → leq-Poset P (u n) (u (succ-ℕ n)))
+  leq-succ-is-increasing-sequence-Poset H n =
+    H n (succ-ℕ n) (succ-leq-ℕ n)
+```
diff --git a/src/order-theory/order-preserving-maps-posets.lagda.md b/src/order-theory/order-preserving-maps-posets.lagda.md
index 163aee3f3f7..1638130acd9 100644
--- a/src/order-theory/order-preserving-maps-posets.lagda.md
+++ b/src/order-theory/order-preserving-maps-posets.lagda.md
@@ -25,7 +25,7 @@ open import order-theory.posets
 
 ## Idea
 
-A map `f : P → Q` between the underlying types of two posets is siad to be
+A map `f : P → Q` between the underlying types of two posets is said to be
 **order preserving** if `x ≤ y` in `P` implies `f x ≤ f y` in `Q`.
 
 ## Definition
diff --git a/src/order-theory/sequences-posets.lagda.md b/src/order-theory/sequences-posets.lagda.md
new file mode 100644
index 00000000000..8e6480b060e
--- /dev/null
+++ b/src/order-theory/sequences-posets.lagda.md
@@ -0,0 +1,101 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=type-sequence-Poset}}
+in a [poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in
+its underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  type-sequence-Poset : UU l1
+  type-sequence-Poset = type-sequence-Preorder (preorder-Poset P)
+```
+
+### Pointwise comparison on sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  leq-value-prop-sequence-Poset :
+    (u v : type-sequence-Poset P) → ℕ → Prop l2
+  leq-value-prop-sequence-Poset =
+    leq-value-prop-sequence-Preorder (preorder-Poset P)
+
+  leq-value-sequence-Poset :
+    (u v : type-sequence-Poset P) → ℕ → UU l2
+  leq-value-sequence-Poset =
+    leq-value-sequence-Preorder (preorder-Poset P)
+
+  leq-prop-sequence-Poset : (u v : type-sequence-Poset P) → Prop l2
+  leq-prop-sequence-Poset =
+    leq-prop-sequence-Preorder (preorder-Poset P)
+
+  leq-sequence-Poset : (u v : type-sequence-Poset P) → UU l2
+  leq-sequence-Poset =
+    leq-sequence-Preorder (preorder-Poset P)
+
+  is-prop-leq-sequence-Poset :
+    (u v : type-sequence-Poset P) →
+    is-prop (leq-sequence-Poset u v)
+  is-prop-leq-sequence-Poset =
+    is-prop-leq-sequence-Preorder (preorder-Poset P)
+```
+
+## Properties
+
+### The type of sequences in a poset is a poset ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  antisymmetric-leq-sequence-Poset : is-antisymmetric (leq-sequence-Poset P)
+  antisymmetric-leq-sequence-Poset u v I J =
+    eq-htpy (λ n → antisymmetric-leq-Poset P (u n) (v n) (I n) (J n))
+
+  sequence-Poset : Poset l1 l2
+  pr1 sequence-Poset = sequence-Preorder (preorder-Poset P)
+  pr2 sequence-Poset = antisymmetric-leq-sequence-Poset
+
+  refl-leq-sequence-Poset : is-reflexive (leq-sequence-Poset P)
+  refl-leq-sequence-Poset =
+    refl-leq-Poset sequence-Poset
+
+  transitive-leq-sequence-Poset : is-transitive (leq-sequence-Poset P)
+  transitive-leq-sequence-Poset =
+    transitive-leq-Poset sequence-Poset
+```
diff --git a/src/order-theory/sequences-preorders.lagda.md b/src/order-theory/sequences-preorders.lagda.md
new file mode 100644
index 00000000000..60422f55d1b
--- /dev/null
+++ b/src/order-theory/sequences-preorders.lagda.md
@@ -0,0 +1,89 @@
+# Sequences in preorders
+
+```agda
+module order-theory.sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.preorders
+```
+
+</details>
+
+## Idea
+
+A
+{{#concept "sequence" Disambiguation="in a preorder" Agda=type-sequence-Preorder}}
+in a [preorder](order-theory.preorders.md) is a
+[sequence](foundation.sequences.md) in its underlying type.
+
+## Definitions
+
+### Sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-sequence-Preorder : UU l1
+  type-sequence-Preorder = sequence (type-Preorder P)
+```
+
+### Pointwise comparison on sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2) (u v : type-sequence-Preorder P)
+  where
+
+  leq-value-prop-sequence-Preorder : ℕ → Prop l2
+  leq-value-prop-sequence-Preorder n = leq-prop-Preorder P (u n) (v n)
+
+  leq-value-sequence-Preorder : ℕ → UU l2
+  leq-value-sequence-Preorder = type-Prop ∘ leq-value-prop-sequence-Preorder
+
+  leq-prop-sequence-Preorder : Prop l2
+  leq-prop-sequence-Preorder = Π-Prop ℕ leq-value-prop-sequence-Preorder
+
+  leq-sequence-Preorder : UU l2
+  leq-sequence-Preorder = type-Prop leq-prop-sequence-Preorder
+
+  is-prop-leq-sequence-Preorder : is-prop leq-sequence-Preorder
+  is-prop-leq-sequence-Preorder = is-prop-type-Prop leq-prop-sequence-Preorder
+```
+
+## Properties
+
+### The type of sequences in a preorder is a preorder ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  refl-leq-sequence-Preorder : is-reflexive (leq-sequence-Preorder P)
+  refl-leq-sequence-Preorder u n = refl-leq-Preorder P (u n)
+
+  transitive-leq-sequence-Preorder : is-transitive (leq-sequence-Preorder P)
+  transitive-leq-sequence-Preorder u v w J I n =
+    transitive-leq-Preorder P (u n) (v n) (w n) (J n) (I n)
+
+  sequence-Preorder : Preorder l1 l2
+  pr1 sequence-Preorder = type-sequence-Preorder P
+  pr1 (pr2 sequence-Preorder) = leq-prop-sequence-Preorder P
+  pr1 (pr2 (pr2 sequence-Preorder)) = refl-leq-sequence-Preorder
+  pr2 (pr2 (pr2 sequence-Preorder)) = transitive-leq-sequence-Preorder
+```
diff --git a/src/order-theory/sequences-strictly-preordered-sets.lagda.md b/src/order-theory/sequences-strictly-preordered-sets.lagda.md
new file mode 100644
index 00000000000..379f538e28b
--- /dev/null
+++ b/src/order-theory/sequences-strictly-preordered-sets.lagda.md
@@ -0,0 +1,37 @@
+# Sequences in strictly preordered sets
+
+```agda
+module order-theory.sequences-strictly-preordered-sets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.strictly-preordered-sets
+```
+
+</details>
+
+## Idea
+
+A
+{{#concept "sequence" Disambiguation="in a strictly preordered set" Agda=type-sequence-Strictly-Preordered-Set}}
+in a [strictly preordered set](order-theory.strictly-preordered-sets.md) is a
+[sequence](foundation.sequences.md) in its underlying type.
+
+## Definition
+
+### Sequences in a strictly preordered set
+
+```agda
+module _
+  {l1 l2 : Level} (A : Strictly-Preordered-Set l1 l2)
+  where
+
+  type-sequence-Strictly-Preordered-Set : UU l1
+  type-sequence-Strictly-Preordered-Set =
+    sequence (type-Strictly-Preordered-Set A)
+```
diff --git a/src/order-theory/strict-order-preserving-maps.lagda.md b/src/order-theory/strict-order-preserving-maps.lagda.md
index 44b82253472..626b66a506d 100644
--- a/src/order-theory/strict-order-preserving-maps.lagda.md
+++ b/src/order-theory/strict-order-preserving-maps.lagda.md
@@ -9,6 +9,7 @@ module order-theory.strict-order-preserving-maps where
 ```agda
 open import foundation.binary-relations
 open import foundation.dependent-pair-types
+open import foundation.function-types
 open import foundation.propositions
 open import foundation.subtypes
 open import foundation.universe-levels
@@ -155,3 +156,80 @@ module _
   preserves-strict-order-hom-Strictly-Preordered-Set =
     pr2 f
 ```
+
+## Properties
+
+### The identity homomorphism of strictly preordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Strictly-Preordered-Set l1 l2)
+  where
+
+  id-hom-Strictly-Preordered-Set : hom-Strictly-Preordered-Set P P
+  id-hom-Strictly-Preordered-Set = (λ x → x) , (λ x y H → H)
+```
+
+### The composition of strict order preserving maps preserves the strict ordering
+
+```agda
+module _
+  {l1 l1' l2 l2' l3 l3' : Level}
+  (P : Strict-Preorder l1 l1')
+  (Q : Strict-Preorder l2 l2')
+  (R : Strict-Preorder l3 l3')
+  (g : type-Strict-Preorder Q → type-Strict-Preorder R)
+  (f : type-Strict-Preorder P → type-Strict-Preorder Q)
+  where
+
+  preserves-strict-order-comp-preserves-strict-order-map-Strict-Preorder :
+    preserves-strict-order-map-Strict-Preorder Q R g →
+    preserves-strict-order-map-Strict-Preorder P Q f →
+    preserves-strict-order-map-Strict-Preorder P R (g ∘ f)
+  preserves-strict-order-comp-preserves-strict-order-map-Strict-Preorder
+    G F x y = G (f x) (f y) ∘ (F x y)
+```
+
+### Strict order preserving composition of strict order preserving maps between strict preorders
+
+```agda
+module _
+  {l1 l1' l2 l2' l3 l3' : Level}
+  (P : Strict-Preorder l1 l1')
+  (Q : Strict-Preorder l2 l2')
+  (R : Strict-Preorder l3 l3')
+  (g : hom-Strict-Preorder Q R)
+  (f : hom-Strict-Preorder P Q)
+  where
+
+  comp-hom-Strict-Preorder : hom-Strict-Preorder P R
+  comp-hom-Strict-Preorder =
+    map-hom-Strict-Preorder Q R g ∘ map-hom-Strict-Preorder P Q f ,
+    preserves-strict-order-comp-preserves-strict-order-map-Strict-Preorder P Q R
+      ( map-hom-Strict-Preorder Q R g)
+      ( map-hom-Strict-Preorder P Q f)
+      ( preserves-strict-order-hom-Strict-Preorder Q R g)
+      ( preserves-strict-order-hom-Strict-Preorder P Q f)
+```
+
+### Strict order preserving composition of strict order preserving maps between strictly preordered sets
+
+```agda
+module _
+  {l1 l1' l2 l2' l3 l3' : Level}
+  (P : Strictly-Preordered-Set l1 l1')
+  (Q : Strictly-Preordered-Set l2 l2')
+  (R : Strictly-Preordered-Set l3 l3')
+  (g : hom-Strictly-Preordered-Set Q R)
+  (f : hom-Strictly-Preordered-Set P Q)
+  where
+
+  comp-hom-Strictly-Preordered-Set : hom-Strictly-Preordered-Set P R
+  comp-hom-Strictly-Preordered-Set =
+    comp-hom-Strict-Preorder
+      ( strict-preorder-Strictly-Preordered-Set P)
+      ( strict-preorder-Strictly-Preordered-Set Q)
+      ( strict-preorder-Strictly-Preordered-Set R)
+      ( g)
+      ( f)
+```
diff --git a/src/order-theory/strictly-increasing-sequences-strictly-preordered-sets.lagda.md b/src/order-theory/strictly-increasing-sequences-strictly-preordered-sets.lagda.md
new file mode 100644
index 00000000000..a0b31cef61f
--- /dev/null
+++ b/src/order-theory/strictly-increasing-sequences-strictly-preordered-sets.lagda.md
@@ -0,0 +1,114 @@
+# Strictly increasing sequences in strictly preordered sets
+
+```agda
+module order-theory.strictly-increasing-sequences-strictly-preordered-sets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.decidable-total-order-natural-numbers
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+open import elementary-number-theory.strict-inequality-natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.sequences-strictly-preordered-sets
+open import order-theory.strict-order-preserving-maps
+open import order-theory.strictly-preordered-sets
+```
+
+</details>
+
+## Idea
+
+A
+[sequence in a strictly preordered set](order-theory.sequences-strictly-preordered-sets.md)
+is called
+{{#concept "strictly increasing" Disambiguation="sequence in a strictly preordered set}}
+if it [preserves](order-theory.strict-order-preserving-maps.md) the
+[strict ordering on the natural numbers](elementary-number-theory.strict-inequality-natural-numbers.md).
+
+## Definitions
+
+### Strictly increasing sequences in strictly preordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (A : Strictly-Preordered-Set l1 l2)
+  (u : type-sequence-Strictly-Preordered-Set A)
+  where
+
+  is-strictly-increasing-prop-sequence-Strictly-Preordered-Set : Prop l2
+  is-strictly-increasing-prop-sequence-Strictly-Preordered-Set =
+    preserves-strict-order-prop-map-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      A
+      u
+
+  is-strictly-increasing-sequence-Strictly-Preordered-Set : UU l2
+  is-strictly-increasing-sequence-Strictly-Preordered-Set =
+    preserves-strict-order-map-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      A
+      u
+
+  is-prop-is-strictly-increasing-sequence-Strictly-Preordered-Set :
+    is-prop is-strictly-increasing-sequence-Strictly-Preordered-Set
+  is-prop-is-strictly-increasing-sequence-Strictly-Preordered-Set =
+    is-prop-preserves-strict-order-map-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      A
+      u
+```
+
+## Properties
+
+### A sequence `u` in a strictly preordered set is strictly increasing if and only if `uₙ < uₙ₊₁` for all `n : ℕ`
+
+```agda
+module _
+  {l1 l2 : Level} (A : Strictly-Preordered-Set l1 l2)
+  where
+
+  is-strictly-increasing-le-succ-sequence-Strictly-Preordered-Set :
+    (u : type-sequence-Strictly-Preordered-Set A) →
+    ((n : ℕ) → le-Strictly-Preordered-Set A (u n) (u (succ-ℕ n))) →
+    is-strictly-increasing-sequence-Strictly-Preordered-Set A u
+  is-strictly-increasing-le-succ-sequence-Strictly-Preordered-Set
+    u H zero-ℕ (succ-ℕ zero-ℕ) I = H zero-ℕ
+  is-strictly-increasing-le-succ-sequence-Strictly-Preordered-Set
+    u H zero-ℕ (succ-ℕ (succ-ℕ n)) I =
+      is-transitive-le-Strictly-Preordered-Set A
+        ( u zero-ℕ)
+        ( u (succ-ℕ n))
+        ( u (succ-ℕ (succ-ℕ n)))
+        ( H (succ-ℕ n))
+        ( is-strictly-increasing-le-succ-sequence-Strictly-Preordered-Set
+          ( u)
+          ( H)
+          ( zero-ℕ)
+          ( succ-ℕ n)
+          ( I))
+  is-strictly-increasing-le-succ-sequence-Strictly-Preordered-Set
+    u H (succ-ℕ m) (succ-ℕ n) I =
+      is-strictly-increasing-le-succ-sequence-Strictly-Preordered-Set
+        ( u ∘ succ-ℕ)
+        ( H ∘ succ-ℕ)
+        ( m)
+        ( n)
+        ( I)
+
+  le-succ-is-strictly-increasing-sequence-Strictly-Preordered-Set :
+    (u : type-sequence-Strictly-Preordered-Set A) →
+    is-strictly-increasing-sequence-Strictly-Preordered-Set A u →
+    ((n : ℕ) → le-Strictly-Preordered-Set A (u n) (u (succ-ℕ n)))
+  le-succ-is-strictly-increasing-sequence-Strictly-Preordered-Set
+    u H n = H n (succ-ℕ n) (succ-le-ℕ n)
+```


Reviews:
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-29T09:28:55Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-29T09:29:02Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-29T10:01:48Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-29T10:02:33Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-30T11:22:55Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T10:53:28Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T11:04:23Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T14:09:23Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T14:14:31Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T14:18:48Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T15:07:17Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T15:10:57Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T15:20:11Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T15:21:13Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T15:46:23Z
user: login: lowasser
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T16:02:42Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T16:28:32Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-01T17:13:11Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-06T12:16:14Z
user: login: lowasser
state: APPROVED
author_association: COLLABORATOR
submitted_at: 2025-04-08T22:52:08Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:18:26Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:27:26Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:27:40Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:28:18Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:29:13Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:30:47Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:32:14Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:34:26Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:36:25Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:37:21Z
user: login: fredrik-bakke
body: Very nice additions, thank you for these contributions!
state: APPROVED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:40:54Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T15:59:58Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T16:09:52Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T16:11:02Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T16:12:02Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T16:45:41Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T16:55:22Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T17:25:07Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T17:26:10Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T17:27:11Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T17:29:28Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T17:30:25Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T17:31:24Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T17:54:25Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T17:59:44Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:04:49Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:07:54Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:12:51Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:18:35Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:24:39Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:24:59Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:26:57Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:27:13Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:29:26Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:34:42Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:35:28Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-12T18:37:50Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-13T01:35:10Z
user: login: fredrik-bakke
body: Thank you!
state: APPROVED
author_association: COLLABORATOR
submitted_at: 2025-04-22T16:42:40Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-22T22:20:40Z
user: login: fredrik-bakke
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-22T22:27:27Z
user: login: malarbol
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-22T23:07:20Z

Review comments:
diff_hunk: @@ -0,0 +1,94 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=sequence-Poset}} in a
+[poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in its
+underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  sequence-Poset : UU l1
+  sequence-Poset = sequence (type-Poset P)
+```
+
+### Pointwise comparison on sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u v : sequence-Poset P)
+  where
+
+  leq-value-prop-sequence-Poset : ℕ → Prop l2
+  leq-value-prop-sequence-Poset n = leq-prop-Poset P (u n) (v n)
+
+  leq-value-sequence-Poset : ℕ → UU l2
+  leq-value-sequence-Poset = type-Prop ∘ leq-value-prop-sequence-Poset
+
+  leq-prop-sequence-Poset : Prop l2
+  leq-prop-sequence-Poset = Π-Prop ℕ leq-value-prop-sequence-Poset
+
+  leq-sequence-Poset : UU l2
+  leq-sequence-Poset = type-Prop leq-prop-sequence-Poset
+
+  is-prop-leq-sequence-Poset : is-prop leq-sequence-Poset
+  is-prop-leq-sequence-Poset = is-prop-type-Prop leq-prop-sequence-Poset
+```
+
+## Properties
+
+### The type of sequences in a poset is a poset ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  poset-sequence-Poset : Poset l1 l2
path: src/order-theory/sequences-posets.lagda.md
user: login: fredrik-bakke
body: ```suggestion
  sequence-Poset : Poset l1 l2
```
created_at: 2025-03-29T09:28:54Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,94 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=sequence-Poset}} in a
+[poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in its
+underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  sequence-Poset : UU l1
path: src/order-theory/sequences-posets.lagda.md
user: login: fredrik-bakke
body: ```suggestion
  type-sequence-Poset : UU l1
```
created_at: 2025-03-29T09:29:02Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,100 @@
+# Increasing sequences in partially ordered sets
+
+```agda
+module order-theory.increasing-sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.based-induction-natural-numbers
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.order-preserving-maps-posets
+open import order-theory.posets
+open import order-theory.sequences-posets
+```
+
+</details>
+
+## Idea
+
+A [sequence in a partially ordered set](order-theory.sequences-posets.md) `u` is
+{{#concept "increasing" Disambiguation="sequence in a poset" Agda=is-increasing-sequence-Poset}}
+if it [preserves](order-theory.order-preserving-maps-posets.md) the
+[standard ordering on the natural numbers](elementary-number-theory.inequality-natural-numbers.md)
+or, equivalently, if `uₙ ≤ uₙ₊₁` for all `n : ℕ`.
+
+## Definitions
+
+### The predicate of being an increasing sequence in a partially ordered set
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u : sequence-Poset P)
+  where
+
+  is-increasing-prop-sequence-Poset : Prop l2
+  is-increasing-prop-sequence-Poset =
+    preserves-order-prop-Poset ℕ-Poset P u
+
+  is-increasing-sequence-Poset : UU l2
+  is-increasing-sequence-Poset =
+    type-Prop is-increasing-prop-sequence-Poset
+```
+
+### The predicate of being an increasing value of a sequence in a partially ordered set
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u : sequence-Poset P) (n : ℕ)
+  where
+
+  is-increasing-value-prop-sequence-Poset : Prop l2
+  is-increasing-value-prop-sequence-Poset =
+    leq-prop-Poset P (u n) (u (succ-ℕ n))
+
+  is-increasing-value-sequence-Poset : UU l2
+  is-increasing-value-sequence-Poset =
+    type-Prop is-increasing-value-prop-sequence-Poset
+
+  is-prop-is-increasing-value-sequence-Poset :
+    is-prop is-increasing-value-sequence-Poset
+  is-prop-is-increasing-value-sequence-Poset =
+    is-prop-type-Prop is-increasing-value-prop-sequence-Poset
+```
+
+## Properties
+
+### A sequence in a partially ordered set is increasing if and only if all its values are increasing
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) {u : sequence-Poset P}
+  where
+
+  is-increasing-sequence-all-increasing-value-sequence-Poset :
+    ((n : ℕ) → is-increasing-value-sequence-Poset P u n) →
+    is-increasing-sequence-Poset P u
+  is-increasing-sequence-all-increasing-value-sequence-Poset H p =
+    based-ind-ℕ
+      ( p)
+      ( λ q → leq-Poset P (u p) (u q))
+      ( refl-leq-Poset P (u p))
+      ( λ q I →
+        transitive-leq-Poset P (u p) (u q) (u (succ-ℕ q)) (H q))
path: src/order-theory/increasing-sequences-posets.lagda.md
user: login: fredrik-bakke
body: This looks like an instantiation of `preserves-order-ind-ℕ-Poset`

```suggestion
  is-increasing-sequence-all-increasing-value-sequence-Poset :
    ((n : ℕ) → is-increasing-value-sequence-Poset P u n) →
    is-increasing-sequence-Poset P u
  is-increasing-sequence-all-increasing-value-sequence-Poset =
    preserves-order-ind-ℕ-Poset P u
```
created_at: 2025-03-29T10:01:47Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,100 @@
+# Increasing sequences in partially ordered sets
+
+```agda
+module order-theory.increasing-sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.based-induction-natural-numbers
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.order-preserving-maps-posets
+open import order-theory.posets
+open import order-theory.sequences-posets
+```
+
+</details>
+
+## Idea
+
+A [sequence in a partially ordered set](order-theory.sequences-posets.md) `u` is
+{{#concept "increasing" Disambiguation="sequence in a poset" Agda=is-increasing-sequence-Poset}}
+if it [preserves](order-theory.order-preserving-maps-posets.md) the
+[standard ordering on the natural numbers](elementary-number-theory.inequality-natural-numbers.md)
+or, equivalently, if `uₙ ≤ uₙ₊₁` for all `n : ℕ`.
+
+## Definitions
+
+### The predicate of being an increasing sequence in a partially ordered set
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u : sequence-Poset P)
+  where
+
+  is-increasing-prop-sequence-Poset : Prop l2
+  is-increasing-prop-sequence-Poset =
+    preserves-order-prop-Poset ℕ-Poset P u
+
+  is-increasing-sequence-Poset : UU l2
+  is-increasing-sequence-Poset =
+    type-Prop is-increasing-prop-sequence-Poset
+```
+
+### The predicate of being an increasing value of a sequence in a partially ordered set
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u : sequence-Poset P) (n : ℕ)
+  where
+
+  is-increasing-value-prop-sequence-Poset : Prop l2
+  is-increasing-value-prop-sequence-Poset =
+    leq-prop-Poset P (u n) (u (succ-ℕ n))
+
+  is-increasing-value-sequence-Poset : UU l2
+  is-increasing-value-sequence-Poset =
+    type-Prop is-increasing-value-prop-sequence-Poset
+
+  is-prop-is-increasing-value-sequence-Poset :
+    is-prop is-increasing-value-sequence-Poset
+  is-prop-is-increasing-value-sequence-Poset =
+    is-prop-type-Prop is-increasing-value-prop-sequence-Poset
+```
+
+## Properties
+
+### A sequence in a partially ordered set is increasing if and only if all its values are increasing
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) {u : sequence-Poset P}
+  where
+
+  is-increasing-sequence-all-increasing-value-sequence-Poset :
+    ((n : ℕ) → is-increasing-value-sequence-Poset P u n) →
+    is-increasing-sequence-Poset P u
+  is-increasing-sequence-all-increasing-value-sequence-Poset H p =
+    based-ind-ℕ
+      ( p)
+      ( λ q → leq-Poset P (u p) (u q))
+      ( refl-leq-Poset P (u p))
+      ( λ q I →
+        transitive-leq-Poset P (u p) (u q) (u (succ-ℕ q)) (H q))
path: src/order-theory/increasing-sequences-posets.lagda.md
user: login: fredrik-bakke
body: The definition is given in `elementary-number-theory.decidable-total-order-natural-numbers`
created_at: 2025-03-29T10:02:33Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,100 @@
+# Increasing sequences in partially ordered sets
+
+```agda
+module order-theory.increasing-sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.based-induction-natural-numbers
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.order-preserving-maps-posets
+open import order-theory.posets
+open import order-theory.sequences-posets
+```
+
+</details>
+
+## Idea
+
+A [sequence in a partially ordered set](order-theory.sequences-posets.md) `u` is
+{{#concept "increasing" Disambiguation="sequence in a poset" Agda=is-increasing-sequence-Poset}}
+if it [preserves](order-theory.order-preserving-maps-posets.md) the
+[standard ordering on the natural numbers](elementary-number-theory.inequality-natural-numbers.md)
+or, equivalently, if `uₙ ≤ uₙ₊₁` for all `n : ℕ`.
+
+## Definitions
+
+### The predicate of being an increasing sequence in a partially ordered set
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u : sequence-Poset P)
+  where
+
+  is-increasing-prop-sequence-Poset : Prop l2
+  is-increasing-prop-sequence-Poset =
+    preserves-order-prop-Poset ℕ-Poset P u
+
+  is-increasing-sequence-Poset : UU l2
+  is-increasing-sequence-Poset =
+    type-Prop is-increasing-prop-sequence-Poset
+```
+
+### The predicate of being an increasing value of a sequence in a partially ordered set
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u : sequence-Poset P) (n : ℕ)
+  where
+
+  is-increasing-value-prop-sequence-Poset : Prop l2
+  is-increasing-value-prop-sequence-Poset =
+    leq-prop-Poset P (u n) (u (succ-ℕ n))
path: src/order-theory/increasing-sequences-posets.lagda.md
user: login: fredrik-bakke
body: I find the terminology "increasing value" awkward. A value can't be increasing, but a sequence may be. Maybe we can do away with this definition?
created_at: 2025-03-30T11:22:55Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,94 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=type-sequence-Poset}}
+in a [poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in
+its underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  type-sequence-Poset : UU l1
+  type-sequence-Poset = sequence (type-Poset P)
+```
+
+### Pointwise comparison on sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u v : type-sequence-Poset P)
+  where
+
+  leq-value-prop-sequence-Poset : ℕ → Prop l2
+  leq-value-prop-sequence-Poset n = leq-prop-Poset P (u n) (v n)
+
+  leq-value-sequence-Poset : ℕ → UU l2
+  leq-value-sequence-Poset = type-Prop ∘ leq-value-prop-sequence-Poset
+
+  leq-prop-sequence-Poset : Prop l2
+  leq-prop-sequence-Poset = Π-Prop ℕ leq-value-prop-sequence-Poset
+
+  leq-sequence-Poset : UU l2
+  leq-sequence-Poset = type-Prop leq-prop-sequence-Poset
+
+  is-prop-leq-sequence-Poset : is-prop leq-sequence-Poset
+  is-prop-leq-sequence-Poset = is-prop-type-Prop leq-prop-sequence-Poset
+```
+
+## Properties
+
+### The type of sequences in a poset is a poset ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  sequence-Poset : Poset l1 l2
+  pr1 (pr1 sequence-Poset) = type-sequence-Poset P
+  pr1 (pr2 (pr1 sequence-Poset)) = leq-prop-sequence-Poset P
+  pr1 (pr2 (pr2 (pr1 sequence-Poset))) u n = refl-leq-Poset P (u n)
+  pr2 (pr2 (pr2 (pr1 sequence-Poset))) u v w J I n =
+    transitive-leq-Poset P (u n) (v n) (w n) (J n) (I n)
+  pr2 sequence-Poset u v I J =
+    eq-htpy (λ n → antisymmetric-leq-Poset P (u n) (v n) (I n) (J n))
+
+  refl-leq-sequence-Poset : is-reflexive (leq-sequence-Poset P)
+  refl-leq-sequence-Poset = refl-leq-Poset sequence-Poset
+
+  transitive-leq-sequence-Poset : is-transitive (leq-sequence-Poset P)
+  transitive-leq-sequence-Poset = transitive-leq-Poset sequence-Poset
+
+  antisymmetric-leq-sequence-Poset : is-antisymmetric (leq-sequence-Poset P)
+  antisymmetric-leq-sequence-Poset =
+    antisymmetric-leq-Poset sequence-Poset
+```
path: src/order-theory/sequences-posets.lagda.md
user: login: malarbol
body: Is this covered anywhere in the order-theory module? e.g. products of posets or anything?
created_at: 2025-04-01T10:53:28Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,94 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=type-sequence-Poset}}
+in a [poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in
+its underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  type-sequence-Poset : UU l1
+  type-sequence-Poset = sequence (type-Poset P)
+```
+
+### Pointwise comparison on sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u v : type-sequence-Poset P)
+  where
+
+  leq-value-prop-sequence-Poset : ℕ → Prop l2
+  leq-value-prop-sequence-Poset n = leq-prop-Poset P (u n) (v n)
+
+  leq-value-sequence-Poset : ℕ → UU l2
+  leq-value-sequence-Poset = type-Prop ∘ leq-value-prop-sequence-Poset
+
+  leq-prop-sequence-Poset : Prop l2
+  leq-prop-sequence-Poset = Π-Prop ℕ leq-value-prop-sequence-Poset
+
+  leq-sequence-Poset : UU l2
+  leq-sequence-Poset = type-Prop leq-prop-sequence-Poset
+
+  is-prop-leq-sequence-Poset : is-prop leq-sequence-Poset
+  is-prop-leq-sequence-Poset = is-prop-type-Prop leq-prop-sequence-Poset
+```
+
+## Properties
+
+### The type of sequences in a poset is a poset ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  sequence-Poset : Poset l1 l2
+  pr1 (pr1 sequence-Poset) = type-sequence-Poset P
+  pr1 (pr2 (pr1 sequence-Poset)) = leq-prop-sequence-Poset P
+  pr1 (pr2 (pr2 (pr1 sequence-Poset))) u n = refl-leq-Poset P (u n)
+  pr2 (pr2 (pr2 (pr1 sequence-Poset))) u v w J I n =
+    transitive-leq-Poset P (u n) (v n) (w n) (J n) (I n)
+  pr2 sequence-Poset u v I J =
+    eq-htpy (λ n → antisymmetric-leq-Poset P (u n) (v n) (I n) (J n))
+
+  refl-leq-sequence-Poset : is-reflexive (leq-sequence-Poset P)
+  refl-leq-sequence-Poset = refl-leq-Poset sequence-Poset
+
+  transitive-leq-sequence-Poset : is-transitive (leq-sequence-Poset P)
+  transitive-leq-sequence-Poset = transitive-leq-Poset sequence-Poset
+
+  antisymmetric-leq-sequence-Poset : is-antisymmetric (leq-sequence-Poset P)
+  antisymmetric-leq-sequence-Poset =
+    antisymmetric-leq-Poset sequence-Poset
+```
path: src/order-theory/sequences-posets.lagda.md
user: login: fredrik-bakke
body: We have `order-theory.dependent-products-large-posets`, so what you should do is copy its contents to a new file `order-theory.dependent-products-posets` and change it to apply to (small) posets. Note that if you want to eventually apply this theory of sequences in posets to real numbers, you should use the large variant instead.
created_at: 2025-04-01T11:04:23Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,94 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=type-sequence-Poset}}
+in a [poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in
+its underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  type-sequence-Poset : UU l1
+  type-sequence-Poset = sequence (type-Poset P)
+```
+
+### Pointwise comparison on sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u v : type-sequence-Poset P)
+  where
+
+  leq-value-prop-sequence-Poset : ℕ → Prop l2
+  leq-value-prop-sequence-Poset n = leq-prop-Poset P (u n) (v n)
+
+  leq-value-sequence-Poset : ℕ → UU l2
+  leq-value-sequence-Poset = type-Prop ∘ leq-value-prop-sequence-Poset
+
+  leq-prop-sequence-Poset : Prop l2
+  leq-prop-sequence-Poset = Π-Prop ℕ leq-value-prop-sequence-Poset
+
+  leq-sequence-Poset : UU l2
+  leq-sequence-Poset = type-Prop leq-prop-sequence-Poset
+
+  is-prop-leq-sequence-Poset : is-prop leq-sequence-Poset
+  is-prop-leq-sequence-Poset = is-prop-type-Prop leq-prop-sequence-Poset
+```
+
+## Properties
+
+### The type of sequences in a poset is a poset ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  sequence-Poset : Poset l1 l2
+  pr1 (pr1 sequence-Poset) = type-sequence-Poset P
+  pr1 (pr2 (pr1 sequence-Poset)) = leq-prop-sequence-Poset P
+  pr1 (pr2 (pr2 (pr1 sequence-Poset))) u n = refl-leq-Poset P (u n)
+  pr2 (pr2 (pr2 (pr1 sequence-Poset))) u v w J I n =
+    transitive-leq-Poset P (u n) (v n) (w n) (J n) (I n)
+  pr2 sequence-Poset u v I J =
+    eq-htpy (λ n → antisymmetric-leq-Poset P (u n) (v n) (I n) (J n))
+
+  refl-leq-sequence-Poset : is-reflexive (leq-sequence-Poset P)
+  refl-leq-sequence-Poset = refl-leq-Poset sequence-Poset
+
+  transitive-leq-sequence-Poset : is-transitive (leq-sequence-Poset P)
+  transitive-leq-sequence-Poset = transitive-leq-Poset sequence-Poset
+
+  antisymmetric-leq-sequence-Poset : is-antisymmetric (leq-sequence-Poset P)
+  antisymmetric-leq-sequence-Poset =
+    antisymmetric-leq-Poset sequence-Poset
+```
path: src/order-theory/sequences-posets.lagda.md
user: login: malarbol
body: ok. Since I'm mainly focused on sequences of natural numbers (to define subsequences) and rational numbers (to talk about monotonicity of arithmetic / geometric sequences in Q+) can we leave this for another PR? Then, when we work on monotonic sequences of real numbers we'll do sequences in Large Posets an maybe refactor this?
created_at: 2025-04-01T14:09:23Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,94 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=type-sequence-Poset}}
+in a [poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in
+its underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  type-sequence-Poset : UU l1
+  type-sequence-Poset = sequence (type-Poset P)
+```
+
+### Pointwise comparison on sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u v : type-sequence-Poset P)
+  where
+
+  leq-value-prop-sequence-Poset : ℕ → Prop l2
+  leq-value-prop-sequence-Poset n = leq-prop-Poset P (u n) (v n)
+
+  leq-value-sequence-Poset : ℕ → UU l2
+  leq-value-sequence-Poset = type-Prop ∘ leq-value-prop-sequence-Poset
+
+  leq-prop-sequence-Poset : Prop l2
+  leq-prop-sequence-Poset = Π-Prop ℕ leq-value-prop-sequence-Poset
+
+  leq-sequence-Poset : UU l2
+  leq-sequence-Poset = type-Prop leq-prop-sequence-Poset
+
+  is-prop-leq-sequence-Poset : is-prop leq-sequence-Poset
+  is-prop-leq-sequence-Poset = is-prop-type-Prop leq-prop-sequence-Poset
+```
+
+## Properties
+
+### The type of sequences in a poset is a poset ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  sequence-Poset : Poset l1 l2
+  pr1 (pr1 sequence-Poset) = type-sequence-Poset P
+  pr1 (pr2 (pr1 sequence-Poset)) = leq-prop-sequence-Poset P
+  pr1 (pr2 (pr2 (pr1 sequence-Poset))) u n = refl-leq-Poset P (u n)
+  pr2 (pr2 (pr2 (pr1 sequence-Poset))) u v w J I n =
+    transitive-leq-Poset P (u n) (v n) (w n) (J n) (I n)
+  pr2 sequence-Poset u v I J =
+    eq-htpy (λ n → antisymmetric-leq-Poset P (u n) (v n) (I n) (J n))
+
+  refl-leq-sequence-Poset : is-reflexive (leq-sequence-Poset P)
+  refl-leq-sequence-Poset = refl-leq-Poset sequence-Poset
+
+  transitive-leq-sequence-Poset : is-transitive (leq-sequence-Poset P)
+  transitive-leq-sequence-Poset = transitive-leq-Poset sequence-Poset
+
+  antisymmetric-leq-sequence-Poset : is-antisymmetric (leq-sequence-Poset P)
+  antisymmetric-leq-sequence-Poset =
+    antisymmetric-leq-Poset sequence-Poset
+```
path: src/order-theory/sequences-posets.lagda.md
user: login: malarbol
body: Are the "strictly preordered sets" of natural numbers and rational numbers defined anywhere? I'll need them to define strictly increasing sequences in term of "strict order preserving map".
created_at: 2025-04-01T14:14:30Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,94 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=type-sequence-Poset}}
+in a [poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in
+its underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  type-sequence-Poset : UU l1
+  type-sequence-Poset = sequence (type-Poset P)
+```
+
+### Pointwise comparison on sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u v : type-sequence-Poset P)
+  where
+
+  leq-value-prop-sequence-Poset : ℕ → Prop l2
+  leq-value-prop-sequence-Poset n = leq-prop-Poset P (u n) (v n)
+
+  leq-value-sequence-Poset : ℕ → UU l2
+  leq-value-sequence-Poset = type-Prop ∘ leq-value-prop-sequence-Poset
+
+  leq-prop-sequence-Poset : Prop l2
+  leq-prop-sequence-Poset = Π-Prop ℕ leq-value-prop-sequence-Poset
+
+  leq-sequence-Poset : UU l2
+  leq-sequence-Poset = type-Prop leq-prop-sequence-Poset
+
+  is-prop-leq-sequence-Poset : is-prop leq-sequence-Poset
+  is-prop-leq-sequence-Poset = is-prop-type-Prop leq-prop-sequence-Poset
+```
+
+## Properties
+
+### The type of sequences in a poset is a poset ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  sequence-Poset : Poset l1 l2
+  pr1 (pr1 sequence-Poset) = type-sequence-Poset P
+  pr1 (pr2 (pr1 sequence-Poset)) = leq-prop-sequence-Poset P
+  pr1 (pr2 (pr2 (pr1 sequence-Poset))) u n = refl-leq-Poset P (u n)
+  pr2 (pr2 (pr2 (pr1 sequence-Poset))) u v w J I n =
+    transitive-leq-Poset P (u n) (v n) (w n) (J n) (I n)
+  pr2 sequence-Poset u v I J =
+    eq-htpy (λ n → antisymmetric-leq-Poset P (u n) (v n) (I n) (J n))
+
+  refl-leq-sequence-Poset : is-reflexive (leq-sequence-Poset P)
+  refl-leq-sequence-Poset = refl-leq-Poset sequence-Poset
+
+  transitive-leq-sequence-Poset : is-transitive (leq-sequence-Poset P)
+  transitive-leq-sequence-Poset = transitive-leq-Poset sequence-Poset
+
+  antisymmetric-leq-sequence-Poset : is-antisymmetric (leq-sequence-Poset P)
+  antisymmetric-leq-sequence-Poset =
+    antisymmetric-leq-Poset sequence-Poset
+```
path: src/order-theory/sequences-posets.lagda.md
user: login: fredrik-bakke
body: The strict ordering is defined, but probably not that they are strictly ordered sets since the addition of strictly ordered sets is very new.
created_at: 2025-04-01T14:18:48Z
author_association: COLLABORATOR
diff_hunk: @@ -148,6 +151,15 @@ transitive-le-ℕ (succ-ℕ n) (succ-ℕ m) (succ-ℕ l) p q =
   transitive-le-ℕ n m l p q
 ```
 
+### The strictly preordered set of natural numbers orderd by strict inequality
+
+```agda
+ℕ-Strict-Preordered-Set : Strictly-Preordered-Set lzero lzero
+pr1 ℕ-Strict-Preordered-Set = ℕ-Set
+pr2 ℕ-Strict-Preordered-Set =
+  le-ℕ-Prop , anti-reflexive-le-ℕ , λ n m l I J → transitive-le-ℕ n m l J I
path: src/elementary-number-theory/strict-inequality-natural-numbers.lagda.md
user: login: malarbol
body: If I understood correctly `le-ℕ-Prop` should be renamed `le-prop-ℕ`. Do you want me to fix this now?

created_at: 2025-04-01T15:07:17Z
author_association: COLLABORATOR
diff_hunk: @@ -148,6 +151,15 @@ transitive-le-ℕ (succ-ℕ n) (succ-ℕ m) (succ-ℕ l) p q =
   transitive-le-ℕ n m l p q
 ```
 
+### The strictly preordered set of natural numbers orderd by strict inequality
+
+```agda
+ℕ-Strict-Preordered-Set : Strictly-Preordered-Set lzero lzero
+pr1 ℕ-Strict-Preordered-Set = ℕ-Set
+pr2 ℕ-Strict-Preordered-Set =
+  le-ℕ-Prop , anti-reflexive-le-ℕ , λ n m l I J → transitive-le-ℕ n m l J I
path: src/elementary-number-theory/strict-inequality-natural-numbers.lagda.md
user: login: malarbol
body: There's also a bit of inconsistency in the names, between `anti-reflexive` here and `irreflexive` in [order-theory.strictly-preordered-sets](https://unimath.github.io/agda-unimath/order-theory.strictly-preordered-sets.html). How do you want to handle this? (same for the order of arguments for transitivity).
created_at: 2025-04-01T15:10:56Z
author_association: COLLABORATOR
diff_hunk: @@ -148,6 +151,15 @@ transitive-le-ℕ (succ-ℕ n) (succ-ℕ m) (succ-ℕ l) p q =
   transitive-le-ℕ n m l p q
 ```
 
+### The strictly preordered set of natural numbers orderd by strict inequality
+
+```agda
+ℕ-Strict-Preordered-Set : Strictly-Preordered-Set lzero lzero
+pr1 ℕ-Strict-Preordered-Set = ℕ-Set
+pr2 ℕ-Strict-Preordered-Set =
+  le-ℕ-Prop , anti-reflexive-le-ℕ , λ n m l I J → transitive-le-ℕ n m l J I
path: src/elementary-number-theory/strict-inequality-natural-numbers.lagda.md
user: login: fredrik-bakke
body: It is best to refrain from that at the moment. Egbert is already undertaking a huge refactoring job on elementary number theory in #1211.
created_at: 2025-04-01T15:20:11Z
author_association: COLLABORATOR
diff_hunk: @@ -148,6 +151,15 @@ transitive-le-ℕ (succ-ℕ n) (succ-ℕ m) (succ-ℕ l) p q =
   transitive-le-ℕ n m l p q
 ```
 
+### The strictly preordered set of natural numbers orderd by strict inequality
+
+```agda
+ℕ-Strict-Preordered-Set : Strictly-Preordered-Set lzero lzero
+pr1 ℕ-Strict-Preordered-Set = ℕ-Set
+pr2 ℕ-Strict-Preordered-Set =
+  le-ℕ-Prop , anti-reflexive-le-ℕ , λ n m l I J → transitive-le-ℕ n m l J I
path: src/elementary-number-theory/strict-inequality-natural-numbers.lagda.md
user: login: fredrik-bakke
body: Presumably, Egbert intentionally introduced "anti-reflexive", so you can keep that if you want. There's nothing wrong with `irreflexive` though.
created_at: 2025-04-01T15:21:13Z
author_association: COLLABORATOR
diff_hunk: @@ -148,6 +151,15 @@ transitive-le-ℕ (succ-ℕ n) (succ-ℕ m) (succ-ℕ l) p q =
   transitive-le-ℕ n m l p q
 ```
 
+### The strictly preordered set of natural numbers orderd by strict inequality
+
+```agda
+ℕ-Strict-Preordered-Set : Strictly-Preordered-Set lzero lzero
+pr1 ℕ-Strict-Preordered-Set = ℕ-Set
+pr2 ℕ-Strict-Preordered-Set =
+  le-ℕ-Prop , anti-reflexive-le-ℕ , λ n m l I J → transitive-le-ℕ n m l J I
path: src/elementary-number-theory/strict-inequality-natural-numbers.lagda.md
user: login: malarbol
body: > Presumably, Egbert intentionally introduced "anti-reflexive", so you can keep that if you want. There's nothing wrong with `irreflexive` though.

Sure, I meant that `anti-reflexive-le-ℕ` could be renamed `irreflexive-le-ℕ` but, as for `le-prop-ℕ`, I'll leave it this way for now and you can decide later want you want to do with this.
created_at: 2025-04-01T15:46:22Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,94 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=type-sequence-Poset}}
+in a [poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in
+its underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  type-sequence-Poset : UU l1
+  type-sequence-Poset = sequence (type-Poset P)
+```
+
+### Pointwise comparison on sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u v : type-sequence-Poset P)
+  where
+
+  leq-value-prop-sequence-Poset : ℕ → Prop l2
+  leq-value-prop-sequence-Poset n = leq-prop-Poset P (u n) (v n)
+
+  leq-value-sequence-Poset : ℕ → UU l2
+  leq-value-sequence-Poset = type-Prop ∘ leq-value-prop-sequence-Poset
+
+  leq-prop-sequence-Poset : Prop l2
+  leq-prop-sequence-Poset = Π-Prop ℕ leq-value-prop-sequence-Poset
+
+  leq-sequence-Poset : UU l2
+  leq-sequence-Poset = type-Prop leq-prop-sequence-Poset
+
+  is-prop-leq-sequence-Poset : is-prop leq-sequence-Poset
+  is-prop-leq-sequence-Poset = is-prop-type-Prop leq-prop-sequence-Poset
+```
+
+## Properties
+
+### The type of sequences in a poset is a poset ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  sequence-Poset : Poset l1 l2
path: src/order-theory/sequences-posets.lagda.md
user: login: lowasser
body: I'd probably find this more readable with the order reversed: define refl, transitive, and antisymmetric individually, then define sequence-Poset in terms of those.
created_at: 2025-04-01T15:59:43Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,94 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=type-sequence-Poset}}
+in a [poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in
+its underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  type-sequence-Poset : UU l1
+  type-sequence-Poset = sequence (type-Poset P)
+```
+
+### Pointwise comparison on sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u v : type-sequence-Poset P)
+  where
+
+  leq-value-prop-sequence-Poset : ℕ → Prop l2
+  leq-value-prop-sequence-Poset n = leq-prop-Poset P (u n) (v n)
+
+  leq-value-sequence-Poset : ℕ → UU l2
+  leq-value-sequence-Poset = type-Prop ∘ leq-value-prop-sequence-Poset
+
+  leq-prop-sequence-Poset : Prop l2
+  leq-prop-sequence-Poset = Π-Prop ℕ leq-value-prop-sequence-Poset
+
+  leq-sequence-Poset : UU l2
+  leq-sequence-Poset = type-Prop leq-prop-sequence-Poset
+
+  is-prop-leq-sequence-Poset : is-prop leq-sequence-Poset
+  is-prop-leq-sequence-Poset = is-prop-type-Prop leq-prop-sequence-Poset
+```
+
+## Properties
+
+### The type of sequences in a poset is a poset ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  sequence-Poset : Poset l1 l2
path: src/order-theory/sequences-posets.lagda.md
user: login: malarbol
body: see https://github.com/UniMath/agda-unimath/pull/1388/commits/511889ab909cacbf6c0f27756bf14285c72a5c22
I guess we could do something like `sequence-Preorder` too but I'd rather keep this for a further re-factor if everyone is ok with it.
created_at: 2025-04-01T16:28:32Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,114 @@
+# Strictly increasing sequences in strictly preordered sets
+
+```agda
+module order-theory.strictly-increasing-sequences-strictly-preordered-sets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.decidable-total-order-natural-numbers
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+open import elementary-number-theory.strict-inequality-natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.sequences-strictly-preordered-sets
+open import order-theory.strict-order-preserving-maps
+open import order-theory.strictly-preordered-sets
+```
+
+</details>
+
+## Idea
+
+A
+[sequence in a strictly preordered set](order-theory.sequences-strictly-preordered-sets.md)
+is called
+{{#concept "strictly increasing" Disambiguation="sequence in a strictly preordered set}}
+if it [preserves](order-theory.strict-order-preserving-maps.md) the
+[strict ordering on the natural numbers](elementary-number-theory.strict-inequality-natural-numbers.md).
+
+## Definitions
+
+### Strictly increasing sequences in strictly preordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (A : Strictly-Preordered-Set l1 l2)
+  (u : type-sequence-Strictly-Preordered-Set A)
+  where
+
+  is-strictly-increasing-prop-sequence-Strictly-Preordered-Set : Prop l2
+  is-strictly-increasing-prop-sequence-Strictly-Preordered-Set =
+    preserves-strict-order-prop-map-Strictly-Preordered-Set
+      ℕ-Strict-Preordered-Set
+      A
+      u
+
+  is-strictly-increasing-sequence-Strictly-Preordered-Set : UU l2
+  is-strictly-increasing-sequence-Strictly-Preordered-Set =
+    preserves-strict-order-map-Strictly-Preordered-Set
+      ℕ-Strict-Preordered-Set
+      A
+      u
+
+  is-prop-is-strictly-increasing-sequence-Strictly-Preordered-Set :
+    is-prop is-strictly-increasing-sequence-Strictly-Preordered-Set
+  is-prop-is-strictly-increasing-sequence-Strictly-Preordered-Set =
+    is-prop-preserves-strict-order-map-Strictly-Preordered-Set
+      ℕ-Strict-Preordered-Set
+      A
+      u
+```
+
+## Properties
+
+### A sequence `u` in a strictly preordered set is strictly increasing if and only if `uₙ < uₙ₊₁` for all `n : ℕ`
+
+```agda
+module _
+  {l1 l2 : Level} (A : Strictly-Preordered-Set l1 l2)
+  where
+
+  is-strictly-increasing-is-everywhere-strictly-increasing-sequence-Strictly-Preordered-Set :
+    (u : type-sequence-Strictly-Preordered-Set A) →
+    ((n : ℕ) → le-Strictly-Preordered-Set A (u n) (u (succ-ℕ n))) →
+    is-strictly-increasing-sequence-Strictly-Preordered-Set A u
+  is-strictly-increasing-is-everywhere-strictly-increasing-sequence-Strictly-Preordered-Set
+    u H zero-ℕ (succ-ℕ zero-ℕ) I = H zero-ℕ
+  is-strictly-increasing-is-everywhere-strictly-increasing-sequence-Strictly-Preordered-Set
+    u H zero-ℕ (succ-ℕ (succ-ℕ n)) I =
+      is-transitive-le-Strictly-Preordered-Set A
+        ( u zero-ℕ)
+        ( u (succ-ℕ n))
+        ( u (succ-ℕ (succ-ℕ n)))
+        ( H (succ-ℕ n))
+        ( is-strictly-increasing-is-everywhere-strictly-increasing-sequence-Strictly-Preordered-Set
+          ( u)
+          ( H)
+          ( zero-ℕ)
+          ( succ-ℕ n)
+          ( I))
+  is-strictly-increasing-is-everywhere-strictly-increasing-sequence-Strictly-Preordered-Set
+    u H (succ-ℕ m) (succ-ℕ n) I =
+      is-strictly-increasing-is-everywhere-strictly-increasing-sequence-Strictly-Preordered-Set
+        ( u ∘ succ-ℕ)
+        ( H ∘ succ-ℕ)
+        ( m)
+        ( n)
+        ( I)
+
+  is-everywhere-strictly-increasing-is-strictly-increasing-sequence-Strictly-Preordered-Set :
+    (u : type-sequence-Strictly-Preordered-Set A) →
+    is-strictly-increasing-sequence-Strictly-Preordered-Set A u →
+    ((n : ℕ) → le-Strictly-Preordered-Set A (u n) (u (succ-ℕ n)))
+  is-everywhere-strictly-increasing-is-strictly-increasing-sequence-Strictly-Preordered-Set
+    u H n = H n (succ-ℕ n) (succ-le-ℕ n)
+```
path: src/order-theory/strictly-increasing-sequences-strictly-preordered-sets.lagda.md
user: login: malarbol
body: This is meant to address https://github.com/UniMath/agda-unimath/pull/1378#discussion_r2012480612
The name is a bit long but I'm open for suggestions.
created_at: 2025-04-01T17:13:11Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,94 @@
+# Sequences in partially ordered sets
+
+```agda
+module order-theory.sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.posets
+```
+
+</details>
+
+## Idea
+
+A {{#concept "sequence" Disambiguation="in a poset" Agda=type-sequence-Poset}}
+in a [poset](order-theory.posets.md) is a [sequence](foundation.sequences.md) in
+its underlying type.
+
+## Definitions
+
+### Sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  type-sequence-Poset : UU l1
+  type-sequence-Poset = sequence (type-Poset P)
+```
+
+### Pointwise comparison on sequences in partially ordered sets
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u v : type-sequence-Poset P)
+  where
+
+  leq-value-prop-sequence-Poset : ℕ → Prop l2
+  leq-value-prop-sequence-Poset n = leq-prop-Poset P (u n) (v n)
+
+  leq-value-sequence-Poset : ℕ → UU l2
+  leq-value-sequence-Poset = type-Prop ∘ leq-value-prop-sequence-Poset
+
+  leq-prop-sequence-Poset : Prop l2
+  leq-prop-sequence-Poset = Π-Prop ℕ leq-value-prop-sequence-Poset
+
+  leq-sequence-Poset : UU l2
+  leq-sequence-Poset = type-Prop leq-prop-sequence-Poset
+
+  is-prop-leq-sequence-Poset : is-prop leq-sequence-Poset
+  is-prop-leq-sequence-Poset = is-prop-type-Prop leq-prop-sequence-Poset
+```
+
+## Properties
+
+### The type of sequences in a poset is a poset ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2)
+  where
+
+  sequence-Poset : Poset l1 l2
path: src/order-theory/sequences-posets.lagda.md
user: login: malarbol
body: > see [511889a](https://github.com/UniMath/agda-unimath/commit/511889ab909cacbf6c0f27756bf14285c72a5c22) I guess we could do something like `sequence-Preorder` too but I'd rather keep this for a further re-factor if everyone is ok with it.

I think I'll go for it. Maybe I'll even try sequences in large preorders.
created_at: 2025-04-06T12:16:14Z
author_association: COLLABORATOR
diff_hunk: @@ -64,7 +64,7 @@ module _
   right-strict-concat' x q p = p ∙ᵣ q
 ```
 
-### Translating between the stictly left and stricly right unital versions of concatenation
+### Translating between the strictly left and strictly right unital versions of concatenation
path: src/foundation/strictly-right-unital-concatenation-identifications.lagda.md
user: login: fredrik-bakke
body: Wow, I managed to misspell it in two different ways in the same header 😅 thanks for fixing it!
created_at: 2025-04-12T15:18:26Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,136 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-limit-∞-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-limit-∞-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-limit-∞-sequence-Preorder : (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-limit-∞-sequence-Preorder m =
+    type-Prop (is-modulus-limit-∞-prop-sequence-Preorder m)
+
+  modulus-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-limit-∞-sequence-Preorder =
+    type-subtype is-modulus-limit-∞-prop-sequence-Preorder
+
+  modulus-modulus-limit-∞-sequence-Preorder :
+    modulus-limit-∞-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-limit-∞-sequence-Preorder = pr1
+
+  is-modulus-modulus-limit-∞-sequence-Preorder :
+    (m : modulus-limit-∞-sequence-Preorder) →
+    is-modulus-limit-∞-sequence-Preorder
+      (modulus-modulus-limit-∞-sequence-Preorder m)
+  is-modulus-modulus-limit-∞-sequence-Preorder = pr2
+
+  is-limit-∞-prop-sequence-Preorder : Prop (l1 ⊔ l2)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: Have you considered the perhaps more idiomatic `tends-to`? Then this could simply be read off as `tends-to-infinity`.
created_at: 2025-04-12T15:27:26Z
author_association: COLLABORATOR
diff_hunk: @@ -64,7 +64,7 @@ module _
   right-strict-concat' x q p = p ∙ᵣ q
 ```
 
-### Translating between the stictly left and stricly right unital versions of concatenation
+### Translating between the strictly left and strictly right unital versions of concatenation
path: src/foundation/strictly-right-unital-concatenation-identifications.lagda.md
user: login: malarbol
body: For some reason I misspell this word a lot too so this file just randomly popped up doing a `grep`. I was indeed surprised to see it pop up twice 🤣.
created_at: 2025-04-12T15:27:40Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,136 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-limit-∞-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-limit-∞-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-limit-∞-sequence-Preorder : (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-limit-∞-sequence-Preorder m =
+    type-Prop (is-modulus-limit-∞-prop-sequence-Preorder m)
+
+  modulus-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-limit-∞-sequence-Preorder =
+    type-subtype is-modulus-limit-∞-prop-sequence-Preorder
+
+  modulus-modulus-limit-∞-sequence-Preorder :
+    modulus-limit-∞-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-limit-∞-sequence-Preorder = pr1
+
+  is-modulus-modulus-limit-∞-sequence-Preorder :
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: We prefer the textual `infinity` to the unicode symbol `∞` inside of entry names.

https://unimath.github.io/agda-unimath/CODINGSTYLE.html#naming-conventions
created_at: 2025-04-12T15:28:18Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,136 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-limit-∞-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-limit-∞-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-limit-∞-sequence-Preorder : (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-limit-∞-sequence-Preorder m =
+    type-Prop (is-modulus-limit-∞-prop-sequence-Preorder m)
+
+  modulus-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-limit-∞-sequence-Preorder =
+    type-subtype is-modulus-limit-∞-prop-sequence-Preorder
+
+  modulus-modulus-limit-∞-sequence-Preorder :
+    modulus-limit-∞-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-limit-∞-sequence-Preorder = pr1
+
+  is-modulus-modulus-limit-∞-sequence-Preorder :
+    (m : modulus-limit-∞-sequence-Preorder) →
+    is-modulus-limit-∞-sequence-Preorder
+      (modulus-modulus-limit-∞-sequence-Preorder m)
+  is-modulus-modulus-limit-∞-sequence-Preorder = pr2
+
+  is-limit-∞-prop-sequence-Preorder : Prop (l1 ⊔ l2)
+  is-limit-∞-prop-sequence-Preorder =
+    is-inhabited-subtype-Prop is-modulus-limit-∞-prop-sequence-Preorder
+
+  is-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  is-limit-∞-sequence-Preorder = type-Prop is-limit-∞-prop-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: Potentially `sequence-tending-to-infinity-Preorder`
created_at: 2025-04-12T15:29:13Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,136 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-limit-∞-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-limit-∞-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-limit-∞-sequence-Preorder : (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-limit-∞-sequence-Preorder m =
+    type-Prop (is-modulus-limit-∞-prop-sequence-Preorder m)
+
+  modulus-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-limit-∞-sequence-Preorder =
+    type-subtype is-modulus-limit-∞-prop-sequence-Preorder
+
+  modulus-modulus-limit-∞-sequence-Preorder :
+    modulus-limit-∞-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-limit-∞-sequence-Preorder = pr1
+
+  is-modulus-modulus-limit-∞-sequence-Preorder :
+    (m : modulus-limit-∞-sequence-Preorder) →
+    is-modulus-limit-∞-sequence-Preorder
+      (modulus-modulus-limit-∞-sequence-Preorder m)
+  is-modulus-modulus-limit-∞-sequence-Preorder = pr2
+
+  is-limit-∞-prop-sequence-Preorder : Prop (l1 ⊔ l2)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: ok, I guess it will go better with https://github.com/UniMath/agda-unimath/pull/1388/#discussion_r2040678207 too. I'll fix that, and I guess zero-approximations of #1371 will be `tends-to-zero` instead.
created_at: 2025-04-12T15:30:47Z
author_association: COLLABORATOR
diff_hunk: @@ -64,7 +64,7 @@ module _
   right-strict-concat' x q p = p ∙ᵣ q
 ```
 
-### Translating between the stictly left and stricly right unital versions of concatenation
+### Translating between the strictly left and strictly right unital versions of concatenation
path: src/foundation/strictly-right-unital-concatenation-identifications.lagda.md
user: login: fredrik-bakke
body: You're not alone apparantly 🙂
created_at: 2025-04-12T15:32:14Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,74 @@
+# Increasing sequences in partially ordered sets
+
+```agda
+module order-theory.increasing-sequences-posets where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.decidable-total-order-natural-numbers
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.identity-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.order-preserving-maps-posets
+open import order-theory.posets
+open import order-theory.sequences-posets
+```
+
+</details>
+
+## Idea
+
+A [sequence in a partially ordered set](order-theory.sequences-posets.md) `u` is
+{{#concept "increasing" Disambiguation="sequence in a poset" Agda=is-increasing-sequence-Poset}}
+if it [preserves](order-theory.order-preserving-maps-posets.md) the
+[standard ordering on the natural numbers](elementary-number-theory.inequality-natural-numbers.md)
+or, equivalently, if `uₙ ≤ uₙ₊₁` for all `n : ℕ`.
+
+## Definitions
+
+### The predicate of being an increasing sequence in a partially ordered set
+
+```agda
+module _
+  {l1 l2 : Level} (P : Poset l1 l2) (u : type-sequence-Poset P)
+  where
+
+  is-increasing-prop-sequence-Poset : Prop l2
+  is-increasing-prop-sequence-Poset =
+    preserves-order-prop-Poset ℕ-Poset P u
+
+  is-increasing-sequence-Poset : UU l2
+  is-increasing-sequence-Poset =
+    type-Prop is-increasing-prop-sequence-Poset
+```
+
+## Properties
+
+### A sequence `u` in a poset is increasing if and only if `uₙ ≤ uₙ₊₁` for all n : ℕ
path: src/order-theory/increasing-sequences-posets.lagda.md
user: login: fredrik-bakke
body: ```suggestion
### A sequence `u` in a poset is increasing if and only if `uₙ ≤ uₙ₊₁` for all `n : ℕ`
```
created_at: 2025-04-12T15:34:26Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,156 @@
+# Subsequences
+
+```agda
+module foundation.subsequences where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+open import elementary-number-theory.strict-inequality-natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.identity-types
+open import foundation.propositional-truncations
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.infinite-limit-sequences-preorders
+open import order-theory.strict-order-preserving-maps
+open import order-theory.strictly-increasing-sequences-strictly-preordered-sets
+```
+
+</details>
+
+## Idea
+
+A {{concept "subsequence" Agda=subsequence}} of a
+[sequence](foundation.sequences.md) `u : ℕ → A` is a sequence `u ∘ f` for some
+[strictly increasing](order-theory.strict-order-preserving-maps.md) sequence
+`f : ℕ → ℕ`.
+
+## Definitions
+
+### Subsequences of a sequence
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A)
+  where
+
+  subsequence : UU lzero
+  subsequence =
+    hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
path: src/foundation/subsequences.lagda.md
user: login: fredrik-bakke
body: It seems like it could be useful to show that this is equivalent to unbounded (decidable?) subsets of the natural numbers. Just an idea
created_at: 2025-04-12T15:36:25Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,156 @@
+# Subsequences
+
+```agda
+module foundation.subsequences where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+open import elementary-number-theory.strict-inequality-natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.identity-types
+open import foundation.propositional-truncations
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.infinite-limit-sequences-preorders
+open import order-theory.strict-order-preserving-maps
+open import order-theory.strictly-increasing-sequences-strictly-preordered-sets
+```
+
+</details>
+
+## Idea
+
+A {{concept "subsequence" Agda=subsequence}} of a
+[sequence](foundation.sequences.md) `u : ℕ → A` is a sequence `u ∘ f` for some
+[strictly increasing](order-theory.strict-order-preserving-maps.md) sequence
+`f : ℕ → ℕ`.
+
+## Definitions
+
+### Subsequences of a sequence
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A)
+  where
+
+  subsequence : UU lzero
+  subsequence =
+    hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
+
+  extract-subsequence : subsequence → ℕ → ℕ
+  extract-subsequence =
+    map-hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
+
+  is-strictly-increasing-extract-subsequence :
+    (f : subsequence) →
+    preserves-strict-order-map-Strictly-Preordered-Set
+      ( strictly-preordered-set-ℕ)
+      ( strictly-preordered-set-ℕ)
+      ( extract-subsequence f)
+  is-strictly-increasing-extract-subsequence =
+    preserves-strict-order-hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
+
+  seq-subsequence : subsequence → sequence A
+  seq-subsequence f n = u (extract-subsequence f n)
+```
+
+## Properties
+
+### Any sequence is a subsequence of itself
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A)
+  where
+
+  refl-subsequence : subsequence u
+  refl-subsequence = id-hom-Strictly-Preordered-Set strictly-preordered-set-ℕ
+```
+
+### A subsequence of a subsequence is a subsequence of the original sequence
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A)
+  where
+
+  sub-subsequence :
+    (v : subsequence u) →
+    (w : subsequence (seq-subsequence u v)) →
+    subsequence u
+  sub-subsequence =
+    comp-hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
+```
+
+### The extraction sequence of a subsequence is superlinear
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A) (v : subsequence u)
+  where
+
+  abstract
+    is-superlinear-extract-subsequence :
+      (n : ℕ) → leq-ℕ n (extract-subsequence u v n)
+    is-superlinear-extract-subsequence zero-ℕ =
+      leq-zero-ℕ (extract-subsequence u v zero-ℕ)
+    is-superlinear-extract-subsequence (succ-ℕ n) =
+      leq-succ-le-ℕ
+        ( n)
+        ( extract-subsequence u v (succ-ℕ n))
+        ( concatenate-leq-le-ℕ
+          { n}
+          { extract-subsequence u v n}
+          { extract-subsequence u v (succ-ℕ n)}
+          ( is-superlinear-extract-subsequence n)
+          ( le-succ-is-strictly-increasing-sequence-Strictly-Preordered-Set
+            ( strictly-preordered-set-ℕ)
+            ( extract-subsequence u v)
+            ( is-strictly-increasing-extract-subsequence u v)
+            ( n)))
+```
+
+### The extraction sequence of a subsequence tends to infinity
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A) (v : subsequence u)
+  where
+
+  modulus-limit-∞-extract-subsequence :
+    modulus-limit-∞-sequence-Preorder ℕ-Preorder (extract-subsequence u v)
+  modulus-limit-∞-extract-subsequence =
+    modulus-leq-modulus-limit-∞-sequence-Preorder
+      ( ℕ-Preorder)
+      ( id)
+      ( extract-subsequence u v)
+      ( is-superlinear-extract-subsequence u v)
+      ( id , λ i j → id)
+
+  is-limit-∞-extract-subsequence :
+    is-limit-∞-sequence-Preorder ℕ-Preorder (extract-subsequence u v)
+  is-limit-∞-extract-subsequence =
+    unit-trunc-Prop modulus-limit-∞-extract-subsequence
+
+  limit-∞-extract-subsequence : limit-∞-sequence-Preorder ℕ-Preorder
+  limit-∞-extract-subsequence =
+    extract-subsequence u v , is-limit-∞-extract-subsequence
path: src/foundation/subsequences.lagda.md
user: login: fredrik-bakke
body: We parenthesize top-level pairs to be consistent with the mathematical notation. (this convention is currently undocumented, sorry)

```suggestion
    ( extract-subsequence u v , is-limit-∞-extract-subsequence)
```
created_at: 2025-04-12T15:37:21Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,136 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-limit-∞-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-limit-∞-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-limit-∞-sequence-Preorder : (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-limit-∞-sequence-Preorder m =
+    type-Prop (is-modulus-limit-∞-prop-sequence-Preorder m)
+
+  modulus-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-limit-∞-sequence-Preorder =
+    type-subtype is-modulus-limit-∞-prop-sequence-Preorder
+
+  modulus-modulus-limit-∞-sequence-Preorder :
+    modulus-limit-∞-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-limit-∞-sequence-Preorder = pr1
+
+  is-modulus-modulus-limit-∞-sequence-Preorder :
+    (m : modulus-limit-∞-sequence-Preorder) →
+    is-modulus-limit-∞-sequence-Preorder
+      (modulus-modulus-limit-∞-sequence-Preorder m)
+  is-modulus-modulus-limit-∞-sequence-Preorder = pr2
+
+  is-limit-∞-prop-sequence-Preorder : Prop (l1 ⊔ l2)
+  is-limit-∞-prop-sequence-Preorder =
+    is-inhabited-subtype-Prop is-modulus-limit-∞-prop-sequence-Preorder
+
+  is-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  is-limit-∞-sequence-Preorder = type-Prop is-limit-∞-prop-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: I went with `type-tends-to-infinity-sequence-Preorder`. Is it ok?
created_at: 2025-04-12T15:59:57Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,156 @@
+# Subsequences
+
+```agda
+module foundation.subsequences where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+open import elementary-number-theory.strict-inequality-natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.identity-types
+open import foundation.propositional-truncations
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.infinite-limit-sequences-preorders
+open import order-theory.strict-order-preserving-maps
+open import order-theory.strictly-increasing-sequences-strictly-preordered-sets
+```
+
+</details>
+
+## Idea
+
+A {{concept "subsequence" Agda=subsequence}} of a
+[sequence](foundation.sequences.md) `u : ℕ → A` is a sequence `u ∘ f` for some
+[strictly increasing](order-theory.strict-order-preserving-maps.md) sequence
+`f : ℕ → ℕ`.
+
+## Definitions
+
+### Subsequences of a sequence
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A)
+  where
+
+  subsequence : UU lzero
+  subsequence =
+    hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
path: src/foundation/subsequences.lagda.md
user: login: malarbol
body: I'll give it some thoughts, but I already have a lot of plans 😅 . Is there anything already on (un)bounded subsets of posets?
created_at: 2025-04-12T16:09:52Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,156 @@
+# Subsequences
+
+```agda
+module foundation.subsequences where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+open import elementary-number-theory.strict-inequality-natural-numbers
+
+open import foundation.dependent-pair-types
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.identity-types
+open import foundation.propositional-truncations
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.infinite-limit-sequences-preorders
+open import order-theory.strict-order-preserving-maps
+open import order-theory.strictly-increasing-sequences-strictly-preordered-sets
+```
+
+</details>
+
+## Idea
+
+A {{concept "subsequence" Agda=subsequence}} of a
+[sequence](foundation.sequences.md) `u : ℕ → A` is a sequence `u ∘ f` for some
+[strictly increasing](order-theory.strict-order-preserving-maps.md) sequence
+`f : ℕ → ℕ`.
+
+## Definitions
+
+### Subsequences of a sequence
+
+```agda
+module _
+  {l : Level} {A : UU l} (u : sequence A)
+  where
+
+  subsequence : UU lzero
+  subsequence =
+    hom-Strictly-Preordered-Set
+      strictly-preordered-set-ℕ
+      strictly-preordered-set-ℕ
path: src/foundation/subsequences.lagda.md
user: login: fredrik-bakke
body: don't think so
created_at: 2025-04-12T16:11:02Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,136 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-limit-∞-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-limit-∞-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-limit-∞-sequence-Preorder : (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-limit-∞-sequence-Preorder m =
+    type-Prop (is-modulus-limit-∞-prop-sequence-Preorder m)
+
+  modulus-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-limit-∞-sequence-Preorder =
+    type-subtype is-modulus-limit-∞-prop-sequence-Preorder
+
+  modulus-modulus-limit-∞-sequence-Preorder :
+    modulus-limit-∞-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-limit-∞-sequence-Preorder = pr1
+
+  is-modulus-modulus-limit-∞-sequence-Preorder :
+    (m : modulus-limit-∞-sequence-Preorder) →
+    is-modulus-limit-∞-sequence-Preorder
+      (modulus-modulus-limit-∞-sequence-Preorder m)
+  is-modulus-modulus-limit-∞-sequence-Preorder = pr2
+
+  is-limit-∞-prop-sequence-Preorder : Prop (l1 ⊔ l2)
+  is-limit-∞-prop-sequence-Preorder =
+    is-inhabited-subtype-Prop is-modulus-limit-∞-prop-sequence-Preorder
+
+  is-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  is-limit-∞-sequence-Preorder = type-Prop is-limit-∞-prop-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: How is that better?
created_at: 2025-04-12T16:12:02Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,89 @@
+# Sequences in preorders
+
+```agda
+module order-theory.sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.preorders
+```
+
+</details>
+
+## Idea
+
+A
+{{#concept "sequence" Disambiguation="in a preorder" Agda=type-sequence-Preorder}}
+in a [preorder](order-theory.preorders.md) is a
+[sequence](foundation.sequences.md) in its underlying type.
+
+## Definitions
+
+### Sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-sequence-Preorder : UU l1
+  type-sequence-Preorder = sequence (type-Preorder P)
+```
+
+### Pointwise comparison on sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2) (u v : type-sequence-Preorder P)
+  where
+
+  leq-value-prop-sequence-Preorder : ℕ → Prop l2
+  leq-value-prop-sequence-Preorder n = leq-prop-Preorder P (u n) (v n)
+
+  leq-value-sequence-Preorder : ℕ → UU l2
+  leq-value-sequence-Preorder = type-Prop ∘ leq-value-prop-sequence-Preorder
+
+  leq-prop-sequence-Preorder : Prop l2
+  leq-prop-sequence-Preorder = Π-Prop ℕ leq-value-prop-sequence-Preorder
+
+  leq-sequence-Preorder : UU l2
+  leq-sequence-Preorder = type-Prop leq-prop-sequence-Preorder
+
+  is-prop-leq-sequence-Preorder : is-prop leq-sequence-Preorder
+  is-prop-leq-sequence-Preorder = is-prop-type-Prop leq-prop-sequence-Preorder
+```
+
+## Properties
+
+### The type of sequences in a preorder is a preorder ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  refl-leq-sequence-Preorder : is-reflexive (leq-sequence-Preorder P)
+  refl-leq-sequence-Preorder u n = refl-leq-Preorder P (u n)
+
+  transitive-leq-sequence-Preorder : is-transitive (leq-sequence-Preorder P)
+  transitive-leq-sequence-Preorder u v w J I n =
+    transitive-leq-Preorder P (u n) (v n) (w n) (J n) (I n)
+
+  sequence-Preorder : Preorder l1 l2
path: src/order-theory/sequences-preorders.lagda.md
user: login: malarbol
body: Should this be `preorder-sequence-Preorder`, so we'd have 
```
type-Preorder (preorder-sequence-Preorder P) = type-sequence-Preorder
```
with like `Preorder preorder` cancelling out?
created_at: 2025-04-12T16:45:16Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,136 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-limit-∞-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-limit-∞-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-limit-∞-sequence-Preorder : (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-limit-∞-sequence-Preorder m =
+    type-Prop (is-modulus-limit-∞-prop-sequence-Preorder m)
+
+  modulus-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-limit-∞-sequence-Preorder =
+    type-subtype is-modulus-limit-∞-prop-sequence-Preorder
+
+  modulus-modulus-limit-∞-sequence-Preorder :
+    modulus-limit-∞-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-limit-∞-sequence-Preorder = pr1
+
+  is-modulus-modulus-limit-∞-sequence-Preorder :
+    (m : modulus-limit-∞-sequence-Preorder) →
+    is-modulus-limit-∞-sequence-Preorder
+      (modulus-modulus-limit-∞-sequence-Preorder m)
+  is-modulus-modulus-limit-∞-sequence-Preorder = pr2
+
+  is-limit-∞-prop-sequence-Preorder : Prop (l1 ⊔ l2)
+  is-limit-∞-prop-sequence-Preorder =
+    is-inhabited-subtype-Prop is-modulus-limit-∞-prop-sequence-Preorder
+
+  is-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  is-limit-∞-sequence-Preorder = type-Prop is-limit-∞-prop-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: Does the equation 
```
type-tends-to-infinity-sequence-Preorder =
    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
```
convince you? with `-subtype subtype-` cancelling out? 
Furthermore, let's say we rename `sequence-Preorder` to `preorder-sequence-Preorder` as I suggested [there](https://github.com/UniMath/agda-unimath/pull/1388#discussion_r2040694185) and we have something like https://github.com/UniMath/agda-unimath/pull/1371/commits/2cba40a80a2f96913ed1c0ad714a4269995b3524 (I could include here it if you'd like, it actually fits beer here than in #1371) we could write
```
preorder-tends-to-infinity-sequence-Preorder : Preorder _ _
preorder-tends-to-infinity-sequence-Preorder = 
  preorder-subtype-Preorder (preorder-sequence-Preorder P) (subptype-tends-to-infinity-sequence-Preorder P)
```
so
```
type-Preorder (preorder-tends-to-infinity-sequence-Preorder P) == type-tends-to-infinity-sequence-Preorder P
```
etc.
created_at: 2025-04-12T16:55:22Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,89 @@
+# Sequences in preorders
+
+```agda
+module order-theory.sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.preorders
+```
+
+</details>
+
+## Idea
+
+A
+{{#concept "sequence" Disambiguation="in a preorder" Agda=type-sequence-Preorder}}
+in a [preorder](order-theory.preorders.md) is a
+[sequence](foundation.sequences.md) in its underlying type.
+
+## Definitions
+
+### Sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-sequence-Preorder : UU l1
+  type-sequence-Preorder = sequence (type-Preorder P)
+```
+
+### Pointwise comparison on sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2) (u v : type-sequence-Preorder P)
+  where
+
+  leq-value-prop-sequence-Preorder : ℕ → Prop l2
+  leq-value-prop-sequence-Preorder n = leq-prop-Preorder P (u n) (v n)
+
+  leq-value-sequence-Preorder : ℕ → UU l2
+  leq-value-sequence-Preorder = type-Prop ∘ leq-value-prop-sequence-Preorder
+
+  leq-prop-sequence-Preorder : Prop l2
+  leq-prop-sequence-Preorder = Π-Prop ℕ leq-value-prop-sequence-Preorder
+
+  leq-sequence-Preorder : UU l2
+  leq-sequence-Preorder = type-Prop leq-prop-sequence-Preorder
+
+  is-prop-leq-sequence-Preorder : is-prop leq-sequence-Preorder
+  is-prop-leq-sequence-Preorder = is-prop-type-Prop leq-prop-sequence-Preorder
+```
+
+## Properties
+
+### The type of sequences in a preorder is a preorder ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  refl-leq-sequence-Preorder : is-reflexive (leq-sequence-Preorder P)
+  refl-leq-sequence-Preorder u n = refl-leq-Preorder P (u n)
+
+  transitive-leq-sequence-Preorder : is-transitive (leq-sequence-Preorder P)
+  transitive-leq-sequence-Preorder u v w J I n =
+    transitive-leq-Preorder P (u n) (v n) (w n) (J n) (I n)
+
+  sequence-Preorder : Preorder l1 l2
path: src/order-theory/sequences-preorders.lagda.md
user: login: fredrik-bakke
body: No, this should be `sequence-Preorder`
created_at: 2025-04-12T17:25:07Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,89 @@
+# Sequences in preorders
+
+```agda
+module order-theory.sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.preorders
+```
+
+</details>
+
+## Idea
+
+A
+{{#concept "sequence" Disambiguation="in a preorder" Agda=type-sequence-Preorder}}
+in a [preorder](order-theory.preorders.md) is a
+[sequence](foundation.sequences.md) in its underlying type.
+
+## Definitions
+
+### Sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-sequence-Preorder : UU l1
+  type-sequence-Preorder = sequence (type-Preorder P)
+```
+
+### Pointwise comparison on sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2) (u v : type-sequence-Preorder P)
+  where
+
+  leq-value-prop-sequence-Preorder : ℕ → Prop l2
+  leq-value-prop-sequence-Preorder n = leq-prop-Preorder P (u n) (v n)
+
+  leq-value-sequence-Preorder : ℕ → UU l2
+  leq-value-sequence-Preorder = type-Prop ∘ leq-value-prop-sequence-Preorder
+
+  leq-prop-sequence-Preorder : Prop l2
+  leq-prop-sequence-Preorder = Π-Prop ℕ leq-value-prop-sequence-Preorder
+
+  leq-sequence-Preorder : UU l2
+  leq-sequence-Preorder = type-Prop leq-prop-sequence-Preorder
+
+  is-prop-leq-sequence-Preorder : is-prop leq-sequence-Preorder
+  is-prop-leq-sequence-Preorder = is-prop-type-Prop leq-prop-sequence-Preorder
+```
+
+## Properties
+
+### The type of sequences in a preorder is a preorder ordered by pointwise comparison
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  refl-leq-sequence-Preorder : is-reflexive (leq-sequence-Preorder P)
+  refl-leq-sequence-Preorder u n = refl-leq-Preorder P (u n)
+
+  transitive-leq-sequence-Preorder : is-transitive (leq-sequence-Preorder P)
+  transitive-leq-sequence-Preorder u v w J I n =
+    transitive-leq-Preorder P (u n) (v n) (w n) (J n) (I n)
+
+  sequence-Preorder : Preorder l1 l2
path: src/order-theory/sequences-preorders.lagda.md
user: login: fredrik-bakke
body: The underlying type can be `type-sequence-Preorder`
created_at: 2025-04-12T17:26:10Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,136 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-limit-∞-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-limit-∞-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-limit-∞-sequence-Preorder : (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-limit-∞-sequence-Preorder m =
+    type-Prop (is-modulus-limit-∞-prop-sequence-Preorder m)
+
+  modulus-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-limit-∞-sequence-Preorder =
+    type-subtype is-modulus-limit-∞-prop-sequence-Preorder
+
+  modulus-modulus-limit-∞-sequence-Preorder :
+    modulus-limit-∞-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-limit-∞-sequence-Preorder = pr1
+
+  is-modulus-modulus-limit-∞-sequence-Preorder :
+    (m : modulus-limit-∞-sequence-Preorder) →
+    is-modulus-limit-∞-sequence-Preorder
+      (modulus-modulus-limit-∞-sequence-Preorder m)
+  is-modulus-modulus-limit-∞-sequence-Preorder = pr2
+
+  is-limit-∞-prop-sequence-Preorder : Prop (l1 ⊔ l2)
+  is-limit-∞-prop-sequence-Preorder =
+    is-inhabited-subtype-Prop is-modulus-limit-∞-prop-sequence-Preorder
+
+  is-limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
+  is-limit-∞-sequence-Preorder = type-Prop is-limit-∞-prop-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  limit-∞-sequence-Preorder : UU (l1 ⊔ l2)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: anyways, I just realizes https://github.com/UniMath/agda-unimath/commit/2cba40a80a2f96913ed1c0ad714a4269995b3524 is mostly `Subposets` and I got all the names wrong. I'll have another look.
created_at: 2025-04-12T17:27:11Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: Wait, this name doesn't make sense at all. It is the underlying type of the preorder of sequences that tend to infinity, so the proper name is probably `type-sequence-tending-to-infinity-Preorder`
created_at: 2025-04-12T17:29:28Z
author_association: COLLABORATOR
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: `sequences-tending-to-infinity-preorders.lagda.md`
created_at: 2025-04-12T17:30:25Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: It is not the underlying type of the preorder of witnesses that a given sequence in a preorder tends to infinity, as the name suggests.
created_at: 2025-04-12T17:31:24Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: What about `type-tending-to-infinity-sequence-Preorder`? it seems more coherent with names like `type-increasing-sequence-Preorder` etc., considering `tending-to-infinity` as a whole adjective-like term?
created_at: 2025-04-12T17:54:25Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: I have to say the phrasing "a tending-to-infinity-sequence" looks very odd. Have you ever heard anyone say that or seen it used in writing?
created_at: 2025-04-12T17:59:44Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: I agree it's very Yoda. But, from a library POV, it really feels that this should live in the namespace `type-XXX-sequence-Preorder`. I wish there was an adjective for "tending to infinity" but it's the best thing I have.
created_at: 2025-04-12T18:04:48Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: Maybe it's just I defect of the English language? For some reason, you can say "This sequence is increasing, it is an increasing sequence", but when I say, "This sequence is tending to infinity, it is a tending to infinity sequence", I sound lunatic 🤣 
created_at: 2025-04-12T18:07:54Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: what about `XXX-diverging`? like `infinitely-diverging`, or `upward-diverging`? or something better?
And rephrase the property as "diverges to infinity" which might be more appropriate until we have metric spaces that include some infinity to which the sequences will _converge_?
created_at: 2025-04-12T18:12:51Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: "Diverging" is different because a sequence can be bounded and still diverge. Infinitely diverging is not correct nomenclature. Upward diverging is also bad terminology, I believe, because the dual concept is convergence, not downward divergence.
created_at: 2025-04-12T18:18:35Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: You could maybe call it unbounded divergence, which consistently suggests "modulus of unbounded divergence", and then, the sequence would be called an "unbounded sequence"
created_at: 2025-04-12T18:24:39Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: Does that conflict with a different related concept?
created_at: 2025-04-12T18:24:59Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: > "Diverging" is different because a sequence can be bounded and still diverge. 

Sure, that's why it has to be `XXX-diverging` where `XXX` states its an diverging to infinity.

> Infinitely diverging is not correct nomenclature. Upward diverging is also bad terminology

ok.But it still seems that the phrasing "diverges to infinity" is more used that "converges to infinity", and avoid the conflict with convergence in metric spaces, where "converges to infinity" will have a totally different definition.

created_at: 2025-04-12T18:26:56Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: Note that this seems to me to be different to "tending to infinity", which should be akin to convergence to the point at infinity in the 1-point compactification.
created_at: 2025-04-12T18:27:13Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: E.g., the sequence `1,0,2,0,3,0,4,0,5,0,6,0,7,0,8...` does not tend to infinity, since we can establish a positive distance between infinity and "all elements above n". However, the sequence `1,2,3,4,5,6,7,8,...` does tend to infinity.
created_at: 2025-04-12T18:29:26Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: fredrik-bakke
body: I don't have more time to discuss this now. Please figure out the terminology, then I can give it a new review in about 10 days.
created_at: 2025-04-12T18:34:42Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: > You could maybe call it unbounded divergence, which consistently suggests "modulus of unbounded divergence", and then, the sequence would be called an "unbounded sequence"

unbounded sequences is yet another concept. a sequence can be unbounded and not diverge to infinity (e.g. ` n -> n*(-1)^n`)
created_at: 2025-04-12T18:35:27Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: > I don't have more time to discuss this now. Please figure out the terminology, then I can give it a new review in about 10 days.

ok. thanks a lot for your time.
created_at: 2025-04-12T18:37:50Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,143 @@
+# Sequences in preorders tending to infinity
+
+```agda
+module order-theory.infinite-limit-sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.inequality-natural-numbers
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.functoriality-dependent-pair-types
+open import foundation.inhabited-subtypes
+open import foundation.inhabited-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.subtypes
+open import foundation.universe-levels
+
+open import order-theory.preorders
+open import order-theory.sequences-preorders
+```
+
+</details>
+
+## Idea
+
+A [sequence](order-theory.sequences-preorders.md) `u` in a
+[preorder](order-theory.preorders.md) `P`
+{{#concept "tends to infinity" Disambiguation="sequence in a preorder" Agda=is-limit-∞-sequence-Preorder}}
+if there exists a map `m : P → ℕ` such that whenever `m x ≤ n` in `ℕ`, `x ≤ u n`
+in `P`. The map `m` is called a limit-modulus of `u` at infinity.
+
+## Definitions
+
+### The predicate of tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  (u : type-sequence-Preorder P)
+  where
+
+  is-modulus-tends-to-infinity-prop-sequence-Preorder :
+    (type-Preorder P → ℕ) → Prop (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-prop-sequence-Preorder m =
+    Π-Prop
+      ( type-Preorder P)
+      ( λ x →
+        Π-Prop
+          ( ℕ)
+          ( λ n →
+            leq-ℕ-Prop (m x) n ⇒
+            leq-prop-Preorder P x (u n)))
+
+  is-modulus-tends-to-infinity-sequence-Preorder :
+    (type-Preorder P → ℕ) → UU (l1 ⊔ l2)
+  is-modulus-tends-to-infinity-sequence-Preorder m =
+    type-Prop (is-modulus-tends-to-infinity-prop-sequence-Preorder m)
+
+  modulus-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  modulus-tends-to-infinity-sequence-Preorder =
+    type-subtype is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  modulus-modulus-tends-to-infinity-sequence-Preorder :
+    modulus-tends-to-infinity-sequence-Preorder → type-Preorder P → ℕ
+  modulus-modulus-tends-to-infinity-sequence-Preorder = pr1
+
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder :
+    ( m : modulus-tends-to-infinity-sequence-Preorder) →
+    ( is-modulus-tends-to-infinity-sequence-Preorder
+      ( modulus-modulus-tends-to-infinity-sequence-Preorder m))
+  is-modulus-modulus-tends-to-infinity-sequence-Preorder = pr2
+
+  subtype-tends-to-infinity-sequence-Preorder : Prop (l1 ⊔ l2)
+  subtype-tends-to-infinity-sequence-Preorder =
+    is-inhabited-subtype-Prop
+      is-modulus-tends-to-infinity-prop-sequence-Preorder
+
+  tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  tends-to-infinity-sequence-Preorder =
+    type-Prop subtype-tends-to-infinity-sequence-Preorder
+```
+
+### Sequences in preorders tending to infinity
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-tends-to-infinity-sequence-Preorder : UU (l1 ⊔ l2)
+  type-tends-to-infinity-sequence-Preorder =
+    type-subtype (subtype-tends-to-infinity-sequence-Preorder P)
path: src/order-theory/infinite-limit-sequences-preorders.lagda.md
user: login: malarbol
body: I removed all the `tending-to-infinity` stuff for now. I'll want it for things like "subsequences preserve limits" or "arithmetic sequences in Q+ diverge to infinity" but I'll give it more thoughts and put It in #1371 or another intermediate PR if needed. If the rest is ok for you, we can merge it.
created_at: 2025-04-13T01:35:10Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,89 @@
+# Sequences in preorders
+
+```agda
+module order-theory.sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.preorders
+```
+
+</details>
+
+## Idea
+
+A
+{{#concept "sequence" Disambiguation="in a preorder" Agda=type-sequence-Preorder}}
+in a [preorder](order-theory.preorders.md) is a
+[sequence](foundation.sequences.md) in its underlying type.
+
+## Definitions
+
+### Sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-sequence-Preorder : UU l1
+  type-sequence-Preorder = sequence (type-Preorder P)
path: src/order-theory/sequences-preorders.lagda.md
user: login: malarbol
body: Now that I see it, `sequence-type-Preorder` seems much better, and quite obvious. Let me now when/how you want to fix this.
created_at: 2025-04-22T22:20:40Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,89 @@
+# Sequences in preorders
+
+```agda
+module order-theory.sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.preorders
+```
+
+</details>
+
+## Idea
+
+A
+{{#concept "sequence" Disambiguation="in a preorder" Agda=type-sequence-Preorder}}
+in a [preorder](order-theory.preorders.md) is a
+[sequence](foundation.sequences.md) in its underlying type.
+
+## Definitions
+
+### Sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-sequence-Preorder : UU l1
+  type-sequence-Preorder = sequence (type-Preorder P)
path: src/order-theory/sequences-preorders.lagda.md
user: login: fredrik-bakke
body: If you want you can submit a pull request with just that naming change 
created_at: 2025-04-22T22:27:27Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,89 @@
+# Sequences in preorders
+
+```agda
+module order-theory.sequences-preorders where
+```
+
+<details><summary>Imports</summary>
+
+```agda
+open import elementary-number-theory.natural-numbers
+
+open import foundation.binary-relations
+open import foundation.dependent-pair-types
+open import foundation.function-extensionality
+open import foundation.function-types
+open import foundation.propositions
+open import foundation.sequences
+open import foundation.universe-levels
+
+open import order-theory.preorders
+```
+
+</details>
+
+## Idea
+
+A
+{{#concept "sequence" Disambiguation="in a preorder" Agda=type-sequence-Preorder}}
+in a [preorder](order-theory.preorders.md) is a
+[sequence](foundation.sequences.md) in its underlying type.
+
+## Definitions
+
+### Sequences in preorders
+
+```agda
+module _
+  {l1 l2 : Level} (P : Preorder l1 l2)
+  where
+
+  type-sequence-Preorder : UU l1
+  type-sequence-Preorder = sequence (type-Preorder P)
path: src/order-theory/sequences-preorders.lagda.md
user: login: malarbol
body: see #1407 
created_at: 2025-04-22T23:07:20Z
author_association: COLLABORATOR

PR comments:
user: login: malarbol
created_at: 2025-03-28T18:07:32Z
body: There's still a lot to do but if anyone sees anything they dislike, we can start talking about it.
For example, should I use `nondecreasing / increasing` instead of `increasing / strictly increasing` ?
author_association: COLLABORATOR
user: login: lowasser
created_at: 2025-04-08T22:51:58Z
body: It looks like many of my comments from #1371 apply to this subset.  I'm going to approve this, but please apply the changes asked for there to this PR.
author_association: COLLABORATOR
user: login: malarbol
created_at: 2025-04-08T23:13:47Z
body: > It looks like many of my comments from #1371 apply to this subset. I'm going to approve this, but please apply the changes asked for there to this PR.

I think I addressed all your comments from #1371 specific to this sub-PR. You can merge it or we can do it all in #1371 if you prefer.
author_association: COLLABORATOR
user: login: lowasser
created_at: 2025-04-08T23:16:14Z
body: I don't have merging permissions at this point, just review.
author_association: COLLABORATOR
user: login: malarbol
created_at: 2025-04-08T23:21:45Z
body: > I don't have merging permissions at this point, just review.

ok. we'll wait for @fredrik-bakke then. Thanks a lot for your help! See you on #1371, #1378, #1398 and, hopefully, more.
author_association: COLLABORATOR
user: login: malarbol
created_at: 2025-04-12T14:49:56Z
body: Is anyone interested in merging this separately from #1371? Otherwise I'll just close it and we can go directly to #1371.
author_association: COLLABORATOR
user: login: fredrik-bakke
created_at: 2025-04-12T15:42:29Z
body: Is it problematic to merge this PR without #1371? It is helpful to me to portion the review job out a bit (2700 lines is a lot for me)
author_association: COLLABORATOR
user: login: malarbol
created_at: 2025-04-12T16:04:03Z
body: > Is it problematic to merge this PR without #1371? It is helpful to me to portion the review job out a bit (2700 lines is a lot for me)

On the contrary! That's why I kept it separated from #1371. I think it's' self-contained enough to be merged on its own and it will make #1371 2/3 lighter, so easier to review later. I'm actually doing last-minute additions there too but it's ok to merge this now and I'll make the necessary changes in #1371 for a new review.
author_association: COLLABORATOR
user: login: malarbol
created_at: 2025-04-20T00:52:05Z
body: I added a few modules on bounded sequences. I still haven't find a good name for sequences tending to infinity so I'd rather leave this for later. Otherwise, I think it's good to go.
author_association: COLLABORATOR
user: login: fredrik-bakke
created_at: 2025-04-22T13:18:32Z
body: > I added a few modules on bounded sequences. I still haven't find a good name for sequences tending to infinity so I'd rather leave this for later. Otherwise, I think it's good to go.

Were these files suggested in the previous review?
If not, please pull them out to a second PR so this one can be merged.
author_association: COLLABORATOR
user: login: malarbol
created_at: 2025-04-22T16:35:30Z
body: > Were these files suggested in the previous review? If not, please pull them out to a second PR so this one can be merged.

Not really. At some point I wanted to use them to talk about unbounded sequences / sequences tending to infinity but I didn't went through. They're out now.
author_association: COLLABORATOR