diff --git a/.github/haskell-ci.patch b/.github/haskell-ci.patch
index cffc543501..c451df30df 100644
--- a/.github/haskell-ci.patch
+++ b/.github/haskell-ci.patch
@@ -8,7 +8,7 @@
 +      - .github/workflows/haskell-ci.yml
 +      - agda-stdlib-utils.cabal
 +      - cabal.haskell-ci
-+      - *.hs
++      - "*.hs"
    pull_request:
      branches:
        - master
@@ -17,7 +17,7 @@
 +      - .github/workflows/haskell-ci.yml
 +      - agda-stdlib-utils.cabal
 +      - cabal.haskell-ci
-+      - *.hs
++      - "*.hs"
  jobs:
    linux:
      name: Haskell-CI - Linux - ${{ matrix.compiler }}
diff --git a/.github/tooling/agda-logo.svg b/.github/tooling/agda-logo.svg
new file mode 100644
index 0000000000..0fe434e8ed
--- /dev/null
+++ b/.github/tooling/agda-logo.svg
@@ -0,0 +1,16 @@
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="-43.48 -43.48 1286.97 1086.97">
+    <title>logotype</title>
+    <desc>Created with Sketch.</desc>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+      <g id="logo">
+        <circle id="left-eye" fill="#000000" cx="240" cy="270" r="27"/>
+        <circle id="right-eye" fill="#000000" cx="340" cy="270" r="27"/>
+        <path d="M1000,0 L600,400" id="wing" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"/>
+        <path d="M1200,100 L1000,300" id="tail-middle" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"/>
+        <path d="M1200,0 L1000,200" id="tail-top" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"/>
+        <path d="M500,0 L300,200" id="head-middle" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"/>
+        <path d="M600,0 L400,200" id="head-right" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"/>
+        <path d="M400,-2.84217094e-13 L0,400 L200,400 L200,600 C200,820 380,1000 600,1000 C820,1000 1000,820 1000,600 L1000,400 L1200,200" id="body" stroke="#000000" stroke-width="36" stroke-linecap="round" stroke-linejoin="round"/>
+      </g>
+    </g>
+</svg>
\ No newline at end of file
diff --git a/travis/index.agda b/.github/tooling/index.agda
similarity index 100%
rename from travis/index.agda
rename to .github/tooling/index.agda
diff --git a/travis/index.sh b/.github/tooling/index.sh
similarity index 100%
rename from travis/index.sh
rename to .github/tooling/index.sh
diff --git a/.github/tooling/landing-bottom.html b/.github/tooling/landing-bottom.html
new file mode 100644
index 0000000000..9cd52d7c69
--- /dev/null
+++ b/.github/tooling/landing-bottom.html
@@ -0,0 +1,4 @@
+      </ul>
+    </div>
+  </body>
+</html>
diff --git a/.github/tooling/landing-top.html b/.github/tooling/landing-top.html
new file mode 100644
index 0000000000..81b03304b9
--- /dev/null
+++ b/.github/tooling/landing-top.html
@@ -0,0 +1,24 @@
+<html>
+
+  <head>
+    <title>Documention for the Agda standard library</title>
+  </head>
+
+  <body>
+
+    <div id="container" style="width:50%;min-width:500px;margin:auto">
+      <img src="agda-logo.svg" style="width:80px;float:right" />
+      <h1>Documention for the Agda standard library</h1>
+
+      <hr />
+
+      <h2>Development versions</h2>
+
+      <ul>
+        <li><a href="master">master</a></li>
+        <li><a href="experimental">experimental</a></li>
+      </ul>
+
+      <h2>Released versions</h2>
+
+      <ul>
diff --git a/.github/tooling/landing.sh b/.github/tooling/landing.sh
new file mode 100755
index 0000000000..fcc042da46
--- /dev/null
+++ b/.github/tooling/landing.sh
@@ -0,0 +1,18 @@
+set -eu
+set -o pipefail
+
+rm html/index.html
+
+cat landing-top.html >> landing.html
+
+find html/ -name "index.html" \
+  | grep -v "master\|experimental" \
+  | sed 's|html/\([^\/]*\)/index.html|\1|g' \
+  | sort -r \
+  | sed 's|^\(.*\)$|        <li><a href="\1">\1</a></li>|g' \
+  >> landing.html
+
+cat landing-bottom.html >> landing.html
+
+mv landing.html html/index.html
+mv agda-logo.svg html/
diff --git a/.github/workflows/ci-ubuntu.yml b/.github/workflows/ci-ubuntu.yml
index 2b08c7d6e6..dbcdb2b247 100644
--- a/.github/workflows/ci-ubuntu.yml
+++ b/.github/workflows/ci-ubuntu.yml
@@ -8,6 +8,7 @@ on:
     branches:
       - master
       - experimental
+  merge_group:
 
 ########################################################################
 ## CONFIGURATION
@@ -46,11 +47,11 @@ on:
 ########################################################################
 
 env:
-  GHC_VERSION: 8.10.7
-  CABAL_VERSION: 3.6.2.0
+  GHC_VERSION: 9.8.2
+  CABAL_VERSION: 3.10.3.0
   CABAL_INSTALL: cabal v1-install --ghc-options='-O1 +RTS -M6G -RTS'
   # CABAL_INSTALL: cabal install --overwrite-policy=always --ghc-options='-O1 +RTS -M6G -RTS'
-  AGDA: agda -Werror +RTS -M3.5G -H3.5G -A128M -RTS -i. -i src/
+  AGDA: agda -Werror +RTS -M5G -H3.5G -A128M -RTS -i. -isrc -idoc
 
 jobs:
   test-stdlib:
@@ -71,21 +72,20 @@ jobs:
 
       - name: Initialise variables
         run: |
-          if [[ '${{ github.ref }}' == 'refs/heads/master' \
-             || '${{ github.base_ref }}' == 'master' ]]; then
-            # Pick Agda version for master
-            echo "AGDA_COMMIT=tags/v2.6.2" >> $GITHUB_ENV;
-            echo "AGDA_HTML_DIR=html" >> $GITHUB_ENV
-          elif [[ '${{ github.ref }}' == 'refs/heads/experimental' \
-               || '${{ github.base_ref }}' == 'experimental' ]]; then
+          if [[ '${{ github.ref }}' == 'refs/heads/experimental' \
+             || '${{ github.base_ref }}' == 'experimental' ]]; then
             # Pick Agda version for experimental
-            echo "AGDA_COMMIT=4d36cb37f8bfb765339b808b13356d760aa6f0ec" >> $GITHUB_ENV;
-            echo "AGDA_HTML_DIR=html/experimental" >> $GITHUB_ENV
+            echo "AGDA_COMMIT=f25a71a1c1d22c8702514df22e4f206982c15f40" >> "${GITHUB_ENV}";
+            echo "AGDA_HTML_DIR=html/experimental" >> "${GITHUB_ENV}"
+          else
+            # Pick Agda version for master
+            echo "AGDA_COMMIT=tags/v2.6.4.3" >> "${GITHUB_ENV}";
+            echo "AGDA_HTML_DIR=html/master" >> "${GITHUB_ENV}"
           fi
 
           if [[ '${{ github.ref }}' == 'refs/heads/master' \
              || '${{ github.ref }}' == 'refs/heads/experimental' ]]; then
-             echo "AGDA_DEPLOY=true" >> $GITHUB_ENV
+             echo "AGDA_DEPLOY=true" >> "${GITHUB_ENV}"
           fi
 
 ########################################################################
@@ -98,7 +98,7 @@ jobs:
       # i.e. if we change either the version of Agda, ghc, or cabal that we want
       # to use for the build.
       - name: Cache ~/.cabal directories
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         id: cache-cabal
         with:
           path: |
@@ -113,18 +113,17 @@ jobs:
 ########################################################################
 
       - name: Install ghc & cabal
-        uses: haskell/actions/setup@v1
+        uses: haskell-actions/setup@v2
         with:
           ghc-version: ${{ env.GHC_VERSION }}
           cabal-version: ${{ env.CABAL_VERSION }}
+          cabal-update: true
 
       - name: Put cabal programs in PATH
-        run: echo "~/.cabal/bin" >> $GITHUB_PATH
-
-      - name: Cabal update
-        run: cabal update
+        run: echo "~/.cabal/bin" >> "${GITHUB_PATH}"
 
       - name: Install alex & happy
+        if: steps.cache-cabal.outputs.cache-hit != 'true'
         run: |
           ${{ env.CABAL_INSTALL }} alex
           ${{ env.CABAL_INSTALL }} happy
@@ -146,14 +145,23 @@ jobs:
 
       # By default github actions do not pull the repo
       - name: Checkout stdlib
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Test stdlib
         run: |
+          # Including deprecated modules purely for testing
+          cabal run GenerateEverything -- --include-deprecated
+          ${{ env.AGDA }} -WnoUserWarning --safe EverythingSafe.agda
+          ${{ env.AGDA }} -WnoUserWarning Everything.agda
+
+      - name: Prepare HTML index
+        run: |
+          # Regenerating the Everything files without the deprecated modules
           cabal run GenerateEverything
-          cp travis/* .
+          cp .github/tooling/* .
           ./index.sh
           ${{ env.AGDA }} --safe EverythingSafe.agda
+          ${{ env.AGDA }} Everything.agda
           ${{ env.AGDA }} index.agda
 
       - name: Golden testing
@@ -176,10 +184,12 @@ jobs:
           rm -f '${{ env.AGDA_HTML_DIR }}'/*.html
           rm -f '${{ env.AGDA_HTML_DIR }}'/*.css
           ${{ env.AGDA }} --html --html-dir ${{ env.AGDA_HTML_DIR }} index.agda
+          cp .github/tooling/* .
+          ./landing.sh
 
       - name: Deploy HTML
         uses: JamesIves/github-pages-deploy-action@4.1.3
-        if: ${{ success() && env.AGDA_DEPLOY }}
+        if: success() && env.AGDA_DEPLOY
 
         with:
           branch: gh-pages
diff --git a/.github/workflows/haskell-ci.yml b/.github/workflows/haskell-ci.yml
index 2fd1064fae..391a975ad6 100644
--- a/.github/workflows/haskell-ci.yml
+++ b/.github/workflows/haskell-ci.yml
@@ -8,9 +8,9 @@
 #
 # For more information, see https://github.com/haskell-CI/haskell-ci
 #
-# version: 0.15.20230217
+# version: 0.19.20240514
 #
-# REGENDATA ("0.15.20230217",["github","--no-cabal-check","agda-stdlib-utils.cabal"])
+# REGENDATA ("0.19.20240514",["github","--no-cabal-check","agda-stdlib-utils.cabal"])
 #
 name: Haskell-CI
 on:
@@ -18,10 +18,21 @@ on:
     branches:
       - master
       - experimental
+    paths:
+      - .github/workflows/haskell-ci.yml
+      - agda-stdlib-utils.cabal
+      - cabal.haskell-ci
+      - "*.hs"
   pull_request:
     branches:
       - master
       - experimental
+    paths:
+      - .github/workflows/haskell-ci.yml
+      - agda-stdlib-utils.cabal
+      - cabal.haskell-ci
+      - "*.hs"
+  merge_group:
 jobs:
   linux:
     name: Haskell-CI - Linux - ${{ matrix.compiler }}
@@ -29,19 +40,34 @@ jobs:
     timeout-minutes:
       60
     container:
-      image: buildpack-deps:bionic
+      image: buildpack-deps:jammy
     continue-on-error: ${{ matrix.allow-failure }}
     strategy:
       matrix:
         include:
-          - compiler: ghc-9.4.4
+          - compiler: ghc-9.10.1
             compilerKind: ghc
-            compilerVersion: 9.4.4
+            compilerVersion: 9.10.1
             setup-method: ghcup
             allow-failure: false
-          - compiler: ghc-9.2.6
+          - compiler: ghc-9.8.2
             compilerKind: ghc
-            compilerVersion: 9.2.6
+            compilerVersion: 9.8.2
+            setup-method: ghcup
+            allow-failure: false
+          - compiler: ghc-9.6.5
+            compilerKind: ghc
+            compilerVersion: 9.6.5
+            setup-method: ghcup
+            allow-failure: false
+          - compiler: ghc-9.4.8
+            compilerKind: ghc
+            compilerVersion: 9.4.8
+            setup-method: ghcup
+            allow-failure: false
+          - compiler: ghc-9.2.8
+            compilerKind: ghc
+            compilerVersion: 9.2.8
             setup-method: ghcup
             allow-failure: false
           - compiler: ghc-9.0.2
@@ -57,12 +83,12 @@ jobs:
           - compiler: ghc-8.8.4
             compilerKind: ghc
             compilerVersion: 8.8.4
-            setup-method: hvr-ppa
+            setup-method: ghcup
             allow-failure: false
           - compiler: ghc-8.6.5
             compilerKind: ghc
             compilerVersion: 8.6.5
-            setup-method: hvr-ppa
+            setup-method: ghcup
             allow-failure: false
       fail-fast: false
     steps:
@@ -70,23 +96,11 @@ jobs:
         run: |
           apt-get update
           apt-get install -y --no-install-recommends gnupg ca-certificates dirmngr curl git software-properties-common libtinfo5
-          if [ "${{ matrix.setup-method }}" = ghcup ]; then
-            mkdir -p "$HOME/.ghcup/bin"
-            curl -sL https://downloads.haskell.org/ghcup/0.1.18.0/x86_64-linux-ghcup-0.1.18.0 > "$HOME/.ghcup/bin/ghcup"
-            chmod a+x "$HOME/.ghcup/bin/ghcup"
-            "$HOME/.ghcup/bin/ghcup" config add-release-channel https://raw.githubusercontent.com/haskell/ghcup-metadata/master/ghcup-prereleases-0.0.7.yaml;
-            "$HOME/.ghcup/bin/ghcup" install ghc "$HCVER" || (cat "$HOME"/.ghcup/logs/*.* && false)
-            "$HOME/.ghcup/bin/ghcup" install cabal 3.9.0.0 || (cat "$HOME"/.ghcup/logs/*.* && false)
-          else
-            apt-add-repository -y 'ppa:hvr/ghc'
-            apt-get update
-            apt-get install -y "$HCNAME"
-            mkdir -p "$HOME/.ghcup/bin"
-            curl -sL https://downloads.haskell.org/ghcup/0.1.18.0/x86_64-linux-ghcup-0.1.18.0 > "$HOME/.ghcup/bin/ghcup"
-            chmod a+x "$HOME/.ghcup/bin/ghcup"
-            "$HOME/.ghcup/bin/ghcup" config add-release-channel https://raw.githubusercontent.com/haskell/ghcup-metadata/master/ghcup-prereleases-0.0.7.yaml;
-            "$HOME/.ghcup/bin/ghcup" install cabal 3.9.0.0 || (cat "$HOME"/.ghcup/logs/*.* && false)
-          fi
+          mkdir -p "$HOME/.ghcup/bin"
+          curl -sL https://downloads.haskell.org/ghcup/0.1.20.0/x86_64-linux-ghcup-0.1.20.0 > "$HOME/.ghcup/bin/ghcup"
+          chmod a+x "$HOME/.ghcup/bin/ghcup"
+          "$HOME/.ghcup/bin/ghcup" install ghc "$HCVER" || (cat "$HOME"/.ghcup/logs/*.* && false)
+          "$HOME/.ghcup/bin/ghcup" install cabal 3.10.2.0 || (cat "$HOME"/.ghcup/logs/*.* && false)
         env:
           HCKIND: ${{ matrix.compilerKind }}
           HCNAME: ${{ matrix.compiler }}
@@ -98,20 +112,13 @@ jobs:
           echo "CABAL_DIR=$HOME/.cabal" >> "$GITHUB_ENV"
           echo "CABAL_CONFIG=$HOME/.cabal/config" >> "$GITHUB_ENV"
           HCDIR=/opt/$HCKIND/$HCVER
-          if [ "${{ matrix.setup-method }}" = ghcup ]; then
-            HC=$HOME/.ghcup/bin/$HCKIND-$HCVER
-            echo "HC=$HC" >> "$GITHUB_ENV"
-            echo "HCPKG=$HOME/.ghcup/bin/$HCKIND-pkg-$HCVER" >> "$GITHUB_ENV"
-            echo "HADDOCK=$HOME/.ghcup/bin/haddock-$HCVER" >> "$GITHUB_ENV"
-            echo "CABAL=$HOME/.ghcup/bin/cabal-3.9.0.0 -vnormal+nowrap" >> "$GITHUB_ENV"
-          else
-            HC=$HCDIR/bin/$HCKIND
-            echo "HC=$HC" >> "$GITHUB_ENV"
-            echo "HCPKG=$HCDIR/bin/$HCKIND-pkg" >> "$GITHUB_ENV"
-            echo "HADDOCK=$HCDIR/bin/haddock" >> "$GITHUB_ENV"
-            echo "CABAL=$HOME/.ghcup/bin/cabal-3.9.0.0 -vnormal+nowrap" >> "$GITHUB_ENV"
-          fi
-
+          HC=$("$HOME/.ghcup/bin/ghcup" whereis ghc "$HCVER")
+          HCPKG=$(echo "$HC" | sed 's#ghc$#ghc-pkg#')
+          HADDOCK=$(echo "$HC" | sed 's#ghc$#haddock#')
+          echo "HC=$HC" >> "$GITHUB_ENV"
+          echo "HCPKG=$HCPKG" >> "$GITHUB_ENV"
+          echo "HADDOCK=$HADDOCK" >> "$GITHUB_ENV"
+          echo "CABAL=$HOME/.ghcup/bin/cabal-3.10.2.0 -vnormal+nowrap" >> "$GITHUB_ENV"
           HCNUMVER=$(${HC} --numeric-version|perl -ne '/^(\d+)\.(\d+)\.(\d+)(\.(\d+))?$/; print(10000 * $1 + 100 * $2 + ($3 == 0 ? $5 != 1 : $3))')
           echo "HCNUMVER=$HCNUMVER" >> "$GITHUB_ENV"
           echo "ARG_TESTS=--enable-tests" >> "$GITHUB_ENV"
@@ -161,14 +168,14 @@ jobs:
       - name: install cabal-plan
         run: |
           mkdir -p $HOME/.cabal/bin
-          curl -sL https://github.com/haskell-hvr/cabal-plan/releases/download/v0.6.2.0/cabal-plan-0.6.2.0-x86_64-linux.xz > cabal-plan.xz
-          echo 'de73600b1836d3f55e32d80385acc055fd97f60eaa0ab68a755302685f5d81bc  cabal-plan.xz' | sha256sum -c -
+          curl -sL https://github.com/haskell-hvr/cabal-plan/releases/download/v0.7.3.0/cabal-plan-0.7.3.0-x86_64-linux.xz > cabal-plan.xz
+          echo 'f62ccb2971567a5f638f2005ad3173dba14693a45154c1508645c52289714cb2  cabal-plan.xz' | sha256sum -c -
           xz -d < cabal-plan.xz > $HOME/.cabal/bin/cabal-plan
           rm -f cabal-plan.xz
           chmod a+x $HOME/.cabal/bin/cabal-plan
           cabal-plan --version
       - name: checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           path: source
       - name: initial cabal.project for sdist
@@ -196,7 +203,7 @@ jobs:
           echo "    ghc-options: -Werror=missing-methods" >> cabal.project
           cat >> cabal.project <<EOF
           EOF
-          $HCPKG list --simple-output --names-only | perl -ne 'for (split /\s+/) { print "constraints: $_ installed\n" unless /^(agda-stdlib-utils)$/; }' >> cabal.project.local
+          $HCPKG list --simple-output --names-only | perl -ne 'for (split /\s+/) { print "constraints: any.$_ installed\n" unless /^(agda-stdlib-utils)$/; }' >> cabal.project.local
           cat cabal.project
           cat cabal.project.local
       - name: dump install plan
@@ -204,7 +211,7 @@ jobs:
           $CABAL v2-build $ARG_COMPILER $ARG_TESTS $ARG_BENCH --dry-run all
           cabal-plan
       - name: restore cache
-        uses: actions/cache/restore@v3
+        uses: actions/cache/restore@v4
         with:
           key: ${{ runner.os }}-${{ matrix.compiler }}-${{ github.sha }}
           path: ~/.cabal/store
@@ -227,7 +234,7 @@ jobs:
           rm -f cabal.project.local
           $CABAL v2-build $ARG_COMPILER --disable-tests --disable-benchmarks all
       - name: save cache
-        uses: actions/cache/save@v3
+        uses: actions/cache/save@v4
         if: always()
         with:
           key: ${{ runner.os }}-${{ matrix.compiler }}-${{ github.sha }}
diff --git a/.github/workflows/whitespace.yml b/.github/workflows/whitespace.yml
new file mode 100644
index 0000000000..9e98c51ba4
--- /dev/null
+++ b/.github/workflows/whitespace.yml
@@ -0,0 +1,20 @@
+name: Check whitespace
+on:
+  push:
+    branches:
+      - master
+      - experimental
+  pull_request:
+    branches:
+      - master
+      - experimental
+  merge_group:
+
+jobs:
+  check-whitespace:
+    runs-on: ubuntu-latest
+    steps:
+
+    - uses: actions/checkout@v4
+
+    - uses: andreasabel/fix-whitespace-action@v1
diff --git a/.gitignore b/.gitignore
index 99f960e19f..1724ffd72e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,7 +13,7 @@
 .*.swp
 .#*
 \#*
-./_build/*
+_build
 .DS_Store
 .vscode/*
 dist
diff --git a/AllNonAsciiChars.hs b/AllNonAsciiChars.hs
index fa9ac746d1..bc474296c4 100644
--- a/AllNonAsciiChars.hs
+++ b/AllNonAsciiChars.hs
@@ -4,7 +4,8 @@
 
 module Main where
 
-import qualified Data.List as L (sortBy, group, sort)
+import qualified Data.List as List (sortBy, sort)
+import qualified Data.List.NonEmpty as List1 (group, head)
 import Data.Char (isAscii, ord)
 import Data.Function (on)
 import Numeric (showHex)
@@ -27,9 +28,9 @@ main = do
   nonAsciiChars <-
     filter (not . isAscii) . T.unpack . T.concat <$> mapM readUTF8File agdaFiles
   let table :: [(Char, Int)]
-      table = L.sortBy (flip compare `on` snd) $
-              map (\cs -> (head cs, length cs)) $
-              L.group $ L.sort $ nonAsciiChars
+      table = List.sortBy (flip compare `on` snd) $
+              map (\cs -> (List1.head cs, length cs)) $
+              List1.group $ List.sort $ nonAsciiChars
 
   let codePoint :: Char -> T.Text
       codePoint c = T.pack $ showHex (ord c) ""
diff --git a/CHANGELOG.md b/CHANGELOG.md
index edb69c4b8f..bb6e91c887 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3024 +1,836 @@
-Version 2.0-dev
+Version 2.1-dev
 ===============
 
-The library has been tested using Agda 2.6.2.
+The library has been tested using Agda 2.6.4.3.
 
 Highlights
 ----------
 
-* A golden testing library in `Test.Golden`. This allows you to run a set
-  of tests and make sure their output matches an expected `golden` value.
-  The test runner has many options: filtering tests by name, dumping the
-  list of failures to a file, timing the runs, coloured output, etc.
-  Cf. the comments in `Test.Golden` and the standard library's own tests
-  in `tests/` for documentation on how to use the library.
+* The size of the dependency graph for many modules has been
+  reduced. This may lead to speed ups for first-time loading of some
+  modules.
 
-* A new tactic `cong!` available from `Tactic.Cong` which automatically
-  infers the argument to `cong` for you via anti-unification.
+* Added bindings for file handles in `IO.Handle`.
 
-* Improved the `solve` tactic in `Tactic.RingSolver` to work in a much
-  wider range of situations.
-
-* Added `⌊log₂_⌋` and `⌈log₂_⌉` on Natural Numbers.
-
-* A massive refactoring of the unindexed Functor/Applicative/Monad hierarchy
-  and the MonadReader / MonadState type classes. These are now usable with
-  instance arguments as demonstrated in the tests/monad examples.
+* Added bindings for random number generation in `System.Random`
 
+* Added support for 8-bit words and bytestrings in `Data.Word8` and `Data.ByteString`.
 
 Bug-fixes
 ---------
 
-* In `System.Exit`, the `ExitFailure` constructor is now carrying an integer
-  rather than a natural. The previous binding was incorrectly assuming that
-  all exit codes where non-negative.
-
-* In `/-monoˡ-≤` in `Data.Nat.DivMod` the parameter `o` was implicit but not inferrable.
-  It has been changed to be explicit.
-
-* In `+-distrib-/-∣ʳ` in `Data.Nat.DivMod` the parameter `m` was implicit but not inferrable,
-  while `n` is explicit but inferrable.  They have been changed.
-
-* In `Function.Definitions` the definitions of `Surjection`, `Inverseˡ`,
-  `Inverseʳ` were not being re-exported correctly and therefore had an unsolved
-  meta-variable whenever this module was explicitly parameterised. This has
-  been fixed.
-
-* Add module `Algebra.Module` that re-exports the contents of
-  `Algebra.Module.(Definitions/Structures/Bundles)`
-
-* Various module-like bundles in `Algebra.Module.Bundles` were missing a fixity
-  declaration for `_*ᵣ_`. This has been fixed.
+* Fixed type of `toList-replicate` in `Data.Vec.Properties`, where `replicate`
+  was mistakenly applied to the level of the type `A` instead of the
+  variable `x` of type `A`.
 
-* In `Algebra.Definitions.RawSemiring` the record `prime` add `p∤1 : p ∤ 1#` to the field.
+* Module `Data.List.Relation.Ternary.Appending.Setoid.Properties` no longer
+  incorrectly publicly exports the `Setoid` module under the alias `S`.
 
-* In `Data.List.Relation.Ternary.Appending.Setoid` we re-export specialised versions of
-  the constructors using the setoid's carrier set. Prior to that, the constructor were
-  re-exported in their full generality which would lead to unsolved meta variables at
-  their use sites.
-
-* In `Data.Container.FreeMonad`, we give a direct definition of `_⋆_` as an inductive
-  type rather than encoding it as an instance of `μ`. This ensures Agda notices that
-  `C ⋆ X` is strictly positive in `X` which in turn allows us to use the free monad
-  when defining auxiliary (co)inductive types (cf. the `Tap` example in
-  `README.Data.Container.FreeMonad`).
-
-* In `Data.Maybe.Base` the fixity declaration of `_<∣>_` was missing. This has been fixed.
+* Removed unbound parameter from `length-alignWith`,
+  `alignWith-map` and `map-alignWith` in `Data.List.Properties`.
 
 Non-backwards compatible changes
 --------------------------------
 
-#### Removed deprecated names
-
-* All modules and names that were deprecated in v1.2 and before have been removed.
-
-#### Moved `Codata` modules to `Codata.Sized`
-
-* Due to the change in Agda 2.6.2 where sized types are no longer compatible
-  with the `--safe` flag, it has become clear that a third variant of codata
-  will be needed using coinductive records. Therefore all existing modules in
-  `Codata` which used sized types have been moved inside a new folder named
-  `Sized`, e.g. `Codata.Stream` has become `Codata.Sized.Stream`.
-
-#### Moved `Category` modules to `Effect`
-
-* As observed by Wen Kokke in Issue #1636, it no longer really makes sense
-  to group the modules which correspond to the variety of concepts of
-  (effectful) type constructor arising in functional programming (esp. in haskell)
-  such as `Monad`, `Applicative`, `Functor`, etc, under `Category.*`, as this
-  obstructs the importing of the `agda-categories` development into the Standard Library,
-  and moreover needlessly restricts the applicability of categorical concepts to this
-  (highly specific) mode of use. Correspondingly, modules grouped under `*.Categorical.*`
-  which exploited these structures for effectful programming have been renamed `*.Effectful`.
-
-### Improvements to pretty printing and regexes
-
-* In `Text.Pretty`, `Doc` is now a record rather than a type alias. This
-  helps Agda reconstruct the `width` parameter when the module is opened
-  without it being applied. In particular this allows users to write
-  width-generic pretty printers and only pick a width when calling the
-  renderer by using this import style:
+* The recently added modules and (therefore their contents) in:
+  ```agda
+  Algebra.Module.Morphism.Structures
+  Algebra.Module.Morphism.Construct.Composition
+  Algebra.Module.Morphism.Construct.Identity
   ```
-  open import Text.Pretty using (Doc; render)
-  --                      ^-- no width parameter for Doc & render
-  open module Pretty {w} = Text.Pretty w hiding (Doc; render)
-  --                 ^-- implicit width parameter for the combinators
-
-  pretty : Doc w
-  pretty = ? -- you can use the combinators here and there won't be any
-             -- issues related to the fact that `w` cannot be reconstructed
-             -- anymore
+  have been changed so they are now parametrized by _raw_ bundles rather
+  than lawful bundles.
+  This is in line with other modules that define morphisms.
+  As a result many of the `Composition` lemmas now take a proof of
+  transitivity and the `Identity` lemmas now take a proof of reflexivity.
 
-  main = do
-    -- you can now use the same pretty with different widths:
-    putStrLn $ render 40 pretty
-    putStrLn $ render 80 pretty
-  ```
-
-* In `Text.Regex.Search` the `searchND` function finding infix matches has
-  been tweaked to make sure the returned solution is a local maximum in terms
-  of length. It used to be that we would make the match start as late as
-  possible and finish as early as possible. It's now the reverse.
-
-  So `[a-zA-Z]+.agdai?` run on "the path _build/Main.agdai corresponds to"
-  will return "Main.agdai" when it used to be happy to just return "n.agda".
-
-### Refactoring of algebraic lattice hierarchy
-
-* In order to improve modularity and consistency with `Relation.Binary.Lattice`,
-  the structures & bundles for `Semilattice`, `Lattice`, `DistributiveLattice`
-  & `BooleanAlgebra` have been moved out of the `Algebra` modules and into their
-  own hierarchy in `Algebra.Lattice`.
-
-* All submodules, (e.g. `Algebra.Properties.Semilattice` or `Algebra.Morphism.Lattice`)
-  have been moved to the corresponding place under `Algebra.Lattice` (e.g.
-  `Algebra.Lattice.Properties.Semilattice` or `Algebra.Lattice.Morphism.Lattice`). See
-  the `Deprecated modules` section below for full details.
-
-* Changed definition of `IsDistributiveLattice` and `IsBooleanAlgebra` so that they are
-  no longer right-biased which hinders compositionality. More concretely, `IsDistributiveLattice`
-  now has fields:
-  ```agda
-  ∨-distrib-∧ : ∨ DistributesOver ∧
-  ∧-distrib-∨ : ∧ DistributesOver ∨
-  ```
-  instead of
-  ```agda
-  ∨-distribʳ-∧ : ∨ DistributesOverʳ ∧
-  ```
-  and `IsBooleanAlgebra` now has fields:
-  ```
-  ∨-complement : Inverse ⊤ ¬ ∨
-  ∧-complement : Inverse ⊥ ¬ ∧
-  ```
-  instead of:
-  ```agda
-  ∨-complementʳ : RightInverse ⊤ ¬ ∨
-  ∧-complementʳ : RightInverse ⊥ ¬ ∧
-  ```
-
-* To allow construction of these structures via their old form, smart constructors
-  have been added to a new module `Algebra.Lattice.Structures.Biased`, which are by
-  re-exported automatically by `Algebra.Lattice`. For example, if before you wrote:
-  ```agda
-  ∧-∨-isDistributiveLattice = record
-    { isLattice    = ∧-∨-isLattice
-    ; ∨-distribʳ-∧ = ∨-distribʳ-∧
-    }
-  ```
-  you can use the smart constructor `isDistributiveLatticeʳʲᵐ` to write:
-  ```agda
-  ∧-∨-isDistributiveLattice = isDistributiveLatticeʳʲᵐ (record
-    { isLattice    = ∧-∨-isLattice
-    ; ∨-distribʳ-∧ = ∨-distribʳ-∧
-    })
-  ```
-  without having to prove full distributivity.
-
-* Added new `IsBoundedSemilattice`/`BoundedSemilattice` records.
-
-* Added new aliases `Is(Meet/Join)(Bounded)Semilattice` for `Is(Bounded)Semilattice`
-  which can be used to indicate meet/join-ness of the original structures.
-
-#### Function hierarchy
-
-* The switch to the new function hierarchy is complete and the following definitions
-  now use the new definitions instead of the old ones:
-  * `Algebra.Lattice.Properties.BooleanAlgebra`
-  * `Algebra.Properties.CommutativeMonoid.Sum`
-  * `Algebra.Properties.Lattice`
-    * `replace-equality`
-  * `Data.Fin.Properties`
-    * `∀-cons-⇔`
-    * `⊎⇔∃`
-  * `Data.Fin.Subset.Properties`
-    * `out⊆-⇔`
-    * `in⊆in-⇔`
-    * `out⊂in-⇔`
-    * `out⊂out-⇔`
-    * `in⊂in-⇔`
-    * `x∈⁅y⁆⇔x≡y`
-    * `∩⇔×`
-    * `∪⇔⊎`
-    * `∃-Subset-[]-⇔`
-    * `∃-Subset-∷-⇔`
-  * `Data.List.Countdown`
-    * `empty`
-  * `Data.List.Fresh.Relation.Unary.Any`
-    * `⊎⇔Any`
-  * `Data.List.NonEmpty`
-  * `Data.List.Relation.Binary.Lex`
-    * `[]<[]-⇔`
-    * `∷<∷-⇔`
-  * `Data.List.Relation.Binary.Sublist.Heterogeneous.Properties`
-    * `∷⁻¹`
-    * `∷ʳ⁻¹`
-    * `Sublist-[x]-bijection`
-  * `Data.List.Relation.Binary.Sublist.Setoid.Properties`
-    * `∷⁻¹`
-    * `∷ʳ⁻¹`
-    * `[x]⊆xs⤖x∈xs`
-  * `Data.List.Relation.Unary.Grouped.Properties`
-  * `Data.Maybe.Relation.Binary.Connected`
-    * `just-equivalence`
-  * `Data.Maybe.Relation.Binary.Pointwise`
-    * `just-equivalence`
-  * `Data.Maybe.Relation.Unary.All`
-    * `just-equivalence`
-  * `Data.Maybe.Relation.Unary.Any`
-    * `just-equivalence`
-  * `Data.Nat.Divisibility`
-    * `m%n≡0⇔n∣m`
-  * `Data.Nat.Properties`
-    * `eq?`
-  * `Data.Vec.N-ary`
-    * `uncurry-∀ⁿ`
-    * `uncurry-∃ⁿ`
-  * `Data.Vec.Relation.Binary.Lex.Core`
-    * `P⇔[]<[]`
-    * `∷<∷-⇔`
-  * `Data.Vec.Relation.Binary.Pointwise.Extensional`
-    * `equivalent`
-    * `Pointwise-≡↔≡`
-  * `Data.Vec.Relation.Binary.Pointwise.Inductive`
-    * `Pointwise-≡↔≡`
-  * `Effect.Monad.Partiality`
-    * `correct`
-  * `Relation.Binary.Construct.Closure.Reflexive.Properties`
-    * `⊎⇔Refl`
-  * `Relation.Binary.Construct.Closure.Transitive`
-    * `equivalent`
-  * `Relation.Binary.Reflection`
-    * `solve₁`
-  * `Relation.Nullary.Decidable`
-    * `map`
-
-* The names of the fields in the records of the new hierarchy have been
-  changed from `f`, `g`, `cong₁`, `cong₂` to `to`, `from`, `to-cong`, `from-cong`.
-
-#### Proofs of non-zeroness/positivity/negativity as instance arguments
-
-* Many numeric operations in the library require their arguments to be non-zero,
-  and various proofs require their arguments to be non-zero/positive/negative etc.
-  As discussed on the [mailing list](https://lists.chalmers.se/pipermail/agda/2021/012693.html),
-  the previous way of constructing and passing round these proofs was extremely clunky and lead
-  to messy and difficult to read code. We have therefore changed every occurrence where we need
-  a proof of non-zeroness/positivity/etc. to take it as an irrelevant
-  [instance argument](https://agda.readthedocs.io/en/latest/language/instance-arguments.html).
-  See the mailing list for a fuller explanation of the motivation and implementation.
-
-* For example, whereas the type signature of division used to be:
-  ```
-  _/_ : (dividend divisor : ℕ) {≢0 : False (divisor ≟ 0)} → ℕ
-  ```
-  it is now:
-  ```
-  _/_ : (dividend divisor : ℕ) .{{_ : NonZero divisor}} → ℕ
-  ```
-  which means that as long as an instance of `NonZero n` is in scope then you can write
-  `m / n` without having to explicitly provide a proof, as instance search will fill it in
-  for you. The full list of such operations changed is as follows:
-    - In `Data.Nat.DivMod`: `_/_`, `_%_`, `_div_`, `_mod_`
-	- In `Data.Nat.Pseudorandom.LCG`: `Generator`
-	- In `Data.Integer.DivMod`: `_divℕ_`, `_div_`, `_modℕ_`, `_mod_`
-	- In `Data.Rational`: `mkℚ+`, `normalize`, `_/_`, `1/_`
-	- In `Data.Rational.Unnormalised`: `_/_`, `1/_`, `_÷_`
-
-* At the moment, there are 4 different ways such instance arguments can be provided,
-  listed in order of convenience and clarity:
-    1. *Automatic basic instances* - the standard library provides instances based on the constructors of each
-	   numeric type in `Data.X.Base`. For example, `Data.Nat.Base` constains an instance of `NonZero (suc n)` for any `n`
-	   and `Data.Integer.Base` contains an instance of `NonNegative (+ n)` for any `n`. Consequently,
-	   if the argument is of the required form, these instances will always be filled in by instance search
-	   automatically, e.g.
-	   ```
-	   0/n≡0 : 0 / suc n ≡ 0
-	   ```
-	2. *Take the instance as an argument* - You can provide the instance argument as a parameter to your function
-	   and Agda's instance search will automatically use it in the correct place without you having to
-	   explicitly pass it, e.g.
-	   ```
-	   0/n≡0 : .{{_ : NonZero n}} → 0 / n ≡ 0
-	   ```
-	3. *Define the instance locally* - You can define an instance argument in scope (e.g. in a `where` clause)
-	   and Agda's instance search will again find it automatically, e.g.
-	   ```
-	   instance
-	     n≢0 : NonZero n
-	     n≢0 = ...
-
-	   0/n≡0 : 0 / n ≡ 0
-	   ```
-	4. *Pass the instance argument explicitly* - Finally, if all else fails you can pass the
-	   instance argument explicitly into the function using `{{ }}`, e.g.
-	   ```
-	   0/n≡0 : ∀ n (n≢0 : NonZero n) → ((0 / n) {{n≢0}}) ≡ 0
-	   ```
-	   Suitable constructors for `NonZero`/`Positive` etc. can be found in `Data.X.Base`.
-
-* A full list of proofs that have changed to use instance arguments is available at the end of this file.
-  Notable changes to proofs are now discussed below.
-
-* Previously one of the hacks used in proofs was to explicitly refer to everything in the correct form,
-  e.g. if the argument `n` had to be non-zero then you would refer to the argument as `suc n` everywhere
-  instead of `n`, e.g.
-  ```
-  n/n≡1 : ∀ n → suc n / suc n ≡ 1
-  ```
-  This made the proofs extremely difficult to use if your term wasn't in the right form.
-  After being updated to use instance arguments instead, the proof above becomes:
-  ```
-  n/n≡1 : ∀ n {{_ : NonZero n}} → n / n ≡ 1
-  ```
-  However, note that this means that if you passed in the value `x` to these proofs before, then you
-  will now have to pass in `suc x`. The proofs for which the arguments have changed form in this way
-  are highlighted in the list at the bottom of the file.
-
-* Finally, the definition of `_≢0` has been removed from `Data.Rational.Unnormalised.Base`
-  and the following proofs about it have been removed from `Data.Rational.Unnormalised.Properties`:
-  ```
-  p≄0⇒∣↥p∣≢0 : ∀ p → p ≠ 0ℚᵘ → ℤ.∣ (↥ p) ∣ ≢0
-  ∣↥p∣≢0⇒p≄0 : ∀ p → ℤ.∣ (↥ p) ∣ ≢0 → p ≠ 0ℚᵘ
-  ```
-
-### Change in reduction behaviour of rationals
-
-* Currently arithmetic expressions involving rationals (both normalised and
-  unnormalised) undergo disastrous exponential normalisation. For example,
-  `p + q` would often be normalised by Agda to
-  `(↥ p ℤ.* ↧ q ℤ.+ ↥ q ℤ.* ↧ p) / (↧ₙ p ℕ.* ↧ₙ q)`. While the normalised form
-  of `p + q + r + s + t + u + v` would be ~700 lines long. This behaviour
-  often chokes both type-checking and the display of the expressions in the IDE.
-
-* To avoid this expansion and make non-trivial reasoning about rationals actually feasible:
-  1. the records `ℚᵘ` and `ℚ` have both had the `no-eta-equality` flag enabled
-  2. definition of arithmetic operations have trivial pattern matching added to
-     prevent them reducing, e.g.
-     ```agda
-     p + q = (↥ p ℤ.* ↧ q ℤ.+ ↥ q ℤ.* ↧ p) / (↧ₙ p ℕ.* ↧ₙ q)
-     ```
-     has been changed to
-     ```
-     p@record{} + q@record{} = (↥ p ℤ.* ↧ q ℤ.+ ↥ q ℤ.* ↧ p) / (↧ₙ p ℕ.* ↧ₙ q)
-     ```
-
-* As a consequence of this, some proofs that relied on this reduction behaviour
-  or on eta-equality may no longer go through. There are several ways to fix this:
-  1. The principled way is to not rely on this reduction behaviour in the first place.
-	 The `Properties` files for rational numbers have been greatly expanded in `v1.7`
-	 and `v2.0`, and we believe most proofs should be able to be built up from existing
-	 proofs contained within these files.
-  2. Alternatively, annotating any rational arguments to a proof with either
-	 `@record{}` or `@(mkℚ _ _ _)` should restore the old reduction behaviour for any
-	 terms involving those parameters.
-  3. Finally, if the above approaches are not viable then you may be forced to explicitly
-	 use `cong` combined with a lemma that proves the old reduction behaviour.
-
-### Change to the definition of `LeftCancellative` and `RightCancellative`
-
-* The definitions of the types for cancellativity in `Algebra.Definitions` previously
-  made some of their arguments implicit. This was under the assumption that the operators were
-  defined by pattern matching on the left argument so that Agda could always infer the
-  argument on the RHS.
-
-* Although many of the operators defined in the library follow this convention, this is not
-  always true and cannot be assumed in user's code.
-
-* Therefore the definitions have been changed as follows to make all their arguments explicit:
-  - `LeftCancellative _•_`
-	- From: `∀ x {y z} → (x • y) ≈ (x • z) → y ≈ z`
-	- To: `∀ x y z → (x • y) ≈ (x • z) → y ≈ z`
-
-  - `RightCancellative _•_`
-    - From: `∀ {x} y z → (y • x) ≈ (z • x) → y ≈ z`
-	- To: `∀ x y z → (y • x) ≈ (z • x) → y ≈ z`
-
-  - `AlmostLeftCancellative e _•_`
-    - From: `∀ {x} y z → ¬ x ≈ e → (x • y) ≈ (x • z) → y ≈ z`
-	- To: `∀ x y z → ¬ x ≈ e → (x • y) ≈ (x • z) → y ≈ z`
-
-  - `AlmostRightCancellative e _•_`
-	- From: `∀ {x} y z → ¬ x ≈ e → (y • x) ≈ (z • x) → y ≈ z`
-	- To: `∀ x y z → ¬ x ≈ e → (y • x) ≈ (z • x) → y ≈ z`
-
-* Correspondingly some proofs of the above types will need additional arguments passed explicitly.
-  Instances can easily be fixed by adding additional underscores, e.g.
-  - `∙-cancelˡ x` to `∙-cancelˡ x _ _`
-  - `∙-cancelʳ y z` to `∙-cancelʳ _ y z`
-
-### Change in the definition of `Prime`
-
-* The definition of `Prime` in `Data.Nat.Primality` was:
-  ```agda
-  Prime 0             = ⊥
-  Prime 1             = ⊥
-  Prime (suc (suc n)) = (i : Fin n) → 2 + toℕ i ∤ 2 + n
-  ```
-  which was very hard to reason about as not only did it involve conversion
-  to and from the `Fin` type, it also required that the divisor was of the form
-  `2 + toℕ i`, which has exactly the same problem as the `suc n` hack described
-  above used for non-zeroness.
-
-* To make it easier to use, reason about and read, the definition has been
-  changed to:
-  ```agda
-  Prime 0 = ⊥
-  Prime 1 = ⊥
-  Prime n = ∀ {d} → 2 ≤ d → d < n → d ∤ n
-  ```
-
-### Renaming of `Reflection` modules
-
-* Under the `Reflection` module, there were various impending name clashes
-  between the core AST as exposed by Agda and the annotated AST defined in
-  the library.
-
-* While the content of the modules remain the same, the modules themselves
-  have therefore been renamed as follows:
-  ```
-  Reflection.Annotated              ↦ Reflection.AnnotatedAST
-  Reflection.Annotated.Free         ↦ Reflection.AnnotatedAST.Free
-
-  Reflection.Abstraction            ↦ Reflection.AST.Abstraction
-  Reflection.Argument               ↦ Reflection.AST.Argument
-  Reflection.Argument.Information   ↦ Reflection.AST.Argument.Information
-  Reflection.Argument.Quantity      ↦ Reflection.AST.Argument.Quantity
-  Reflection.Argument.Relevance     ↦ Reflection.AST.Argument.Relevance
-  Reflection.Argument.Modality      ↦ Reflection.AST.Argument.Modality
-  Reflection.Argument.Visibility    ↦ Reflection.AST.Argument.Visibility
-  Reflection.DeBruijn               ↦ Reflection.AST.DeBruijn
-  Reflection.Definition             ↦ Reflection.AST.Definition
-  Reflection.Instances              ↦ Reflection.AST.Instances
-  Reflection.Literal                ↦ Reflection.AST.Literal
-  Reflection.Meta                   ↦ Reflection.AST.Meta
-  Reflection.Name                   ↦ Reflection.AST.Name
-  Reflection.Pattern                ↦ Reflection.AST.Pattern
-  Reflection.Show                   ↦ Reflection.AST.Show
-  Reflection.Traversal              ↦ Reflection.AST.Traversal
-  Reflection.Universe               ↦ Reflection.AST.Universe
-
-  Reflection.TypeChecking.Monad             ↦ Reflection.TCM
-  Reflection.TypeChecking.Monad.Categorical ↦ Reflection.TCM.Categorical
-  Reflection.TypeChecking.Monad.Format      ↦ Reflection.TCM.Format
-  Reflection.TypeChecking.Monad.Syntax      ↦ Reflection.TCM.Instances
-  Reflection.TypeChecking.Monad.Instances   ↦ Reflection.TCM.Syntax
-  ```
-
-* A new module `Reflection.AST` that re-exports the contents of the
-  submodules has been addeed.
-
-### Implementation of division and modulus for `ℤ`
-
-* The previous implementations of `_divℕ_`, `_div_`, `_modℕ_`, `_mod_`
-  in `Data.Integer.DivMod` internally converted to the unary `Fin` datatype
-  resulting in poor performance. The implementation has been updated to
-  use the corresponding operations from `Data.Nat.DivMod` which are
-  efficiently implemented using the Haskell backend.
-
-### Strict functions
-
-* The module `Strict` has been deprecated in favour of `Function.Strict`
-  and the definitions of strict application, `_$!_` and `_$!′_`, have been
-  moved from `Function.Base` to `Function.Strict`.
-
-* The contents of `Function.Strict` is now re-exported by `Function`.
-
-### Changes to ring structures
-
-* Several ring-like structures now have the multiplicative structure defined by
-  its laws rather than as a substructure, to avoid repeated proofs that the
-  underlying relation is an equivalence. These are:
-  * `IsNearSemiring`
-  * `IsSemiringWithoutOne`
-  * `IsSemiringWithoutAnnihilatingZero`
-  * `IsRing`
-* To aid with migration, structures matching the old style ones have been added
-  to `Algebra.Structures.Biased`, with conversionFunctions:
-  * `IsNearSemiring*` and `isNearSemiring*`
-  * `IsSemiringWithoutOne*` and `isSemiringWithoutOne*`
-  * `IsSemiringWithoutAnnihilatingZero*` and `isSemiringWithoutAnnihilatingZero*`
-  * `IsRing*` and `isRing*`
-
-### Proof-irrelevant empty type
-
-* The definition of ⊥ has been changed to
-  ```agda
-  private
-    data Empty : Set where
-
-  ⊥ : Set
-  ⊥ = Irrelevant Empty
-  ```
-  in order to make ⊥ proof irrelevant. Any two proofs of `⊥` or of a negated
-  statements are now *judgementally* equal to each other.
-
-* Consequently we have modified the following definitions:
-  + In `Relation.Nullary.Decidable.Core`, the type of `dec-no` has changed
-    ```agda
-    dec-no : (p? : Dec P) → ¬ P → ∃ λ ¬p′ → p? ≡ no ¬p′
-      ↦ dec-no : (p? : Dec P) (¬p : ¬ P) → p? ≡ no ¬p
-    ```
-  + In `Relation.Binary.PropositionalEquality`, the type of `≢-≟-identity` has changed
-    ```agda
-    ≢-≟-identity : x ≢ y → ∃ λ ¬eq → x ≟ y ≡ no ¬eq
-      ↦ ≢-≟-identity : (x≢y : x ≢ y) → x ≟ y ≡ no x≢y
-    ```
-
-### Reorganisation of the `Relation.Nullary` hierarchy
-
-* It was very difficult to use the `Relation.Nullary` modules, as `Relation.Nullary`
-  contained the basic definitions of negation, decidability etc., and the operations and
-  proofs were smeared over `Relation.Nullary.(Negation/Product/Sum/Implication etc.)`.
-  
-* In order to fix this:
-  - the definition of `Dec` and `recompute` have been moved to `Relation.Nullary.Decidable.Core`
-  - the definition of `Reflects` has been moved to `Relation.Nullary.Reflects`
-  - the definition of `¬_` has been moved to `Relation.Nullary.Negation.Core`
-
-* Backwards compatibility has been maintained, as `Relation.Nullary` still re-exports these publicly.
-
-* The modules:
-  ```
-  Relation.Nullary.Product
-  Relation.Nullary.Sum
-  Relation.Nullary.Implication
-  ```
-  have been deprecated and their contents moved to `Relation.Nullary.(Negation/Reflects/Decidable)`
-  however all their contents is re-exported by `Relation.Nullary` which is the easiest way to access
-  it now.
-  
-* In order to facilitate this reorganisation the following breaking moves have occured:
-  - `¬?` has been moved from `Relation.Nullary.Negation.Core` to `Relation.Nullary.Decidable.Core`
-  - `¬-reflects` has been moved from `Relation.Nullary.Negation.Core` to `Relation.Nullary.Reflects`.
-  - `decidable-stable`, `excluded-middle` and `¬-drop-Dec` have been moved from `Relation.Nullary.Negation` 
-	to `Relation.Nullary.Decidable`.
-  - `fromDec` and `toDec` have been mvoed from `Data.Sum.Base` to `Data.Sum`.
-
-### Refactoring of the unindexed Functor/Applicative/Monad hiearchy
-
-* The unindexed versions are not defined in terms of the named versions anymore
-
-* The `RawApplicative` and `RawMonad` type classes have been relaxed so that the underlying
-  functors do not need their domain and codomain to live at the same Set level.
-  This is needed for level-increasing functors like `IO : Set l → Set (suc l)`.
-
-* `RawApplicative` is now `RawFunctor + pure + _<*>_` and `RawMonad` is now
-  `RawApplicative` + `_>>=_` and so `return` is not used anywhere anymore.
-  This fixes the conflict with `case_return_of` (#356)
-  This reorganisation means in particular that the functor/applicative of a monad
-  are not computed using `_>>=_`. This may break proofs.
-
-* We now have `RawEmpty` and `RawChoice` respectively packing `empty : M A` and
-  `(<|>) : M A → M A → M A`. `RawApplicativeZero`, `RawAlternative`, `RawMonadZero`,
-  `RawMonadPlus` are all defined in terms of these.
-
-* `MonadT T` now returns a `MonadTd` record that packs both a proof that the
-  `Monad M` transformed by `T` is a monad and that we can `lift` a computation
-  `M A` to a trasnformed computation `T M A`.
-
-* The monad transformer are not mere aliases anymore, they are record-wrapped
-  which allows constraints such as `MonadIO (StateT S (ReaderT R IO))` to be
-  discharged by instance arguments.
-
-* The mtl-style type classes (`MonadState`, `MonadReader`) do not contain a proof
-  that the underlying functor is a `Monad` anymore. This ensures we do not have
-  conflicting `Monad M` instances from a pair of `MonadState S M` & `MonadReader R M`
-  constraints.
-
-* `MonadState S M` is now defined in terms of
-  ```agda
-  gets : (S → A) → M A
-  modify : (S → S) → M ⊤
-  ```
-  with `get` and `put` defined as derived notions.
-  This is needed because `MonadState S M` does not pack a `Monad M` instance anymore
-  and so we cannot define `modify f` as `get >>= λ s → put (f s)`.
-
-* `MonadWriter 𝕎 M` is defined similarly:
-   ```agda
-   writer : W × A → M A
-   listen : M A → M (W × A)
-   pass   : M ((W → W) × A) → M A
-   ```
-   with `tell` defined as a derived notion.
-   Note that `𝕎` is a `RawMonoid`, not a `Set` and `W` is the carrier of the monoid.
-
-* New modules:
-  ```
-  Algebra.Construct.Initial
-  Algebra.Construct.Terminal
-  Data.List.Effectful.Transformer
-  Data.List.NonEmpty.Effectful.Transformer
-  Data.Maybe.Effectful.Transformer
-  Data.Sum.Effectful.Left.Transformer
-  Data.Sum.Effectful.Right.Transformer
-  Data.Vec.Effectful.Transformer
-  Effect.Empty
-  Effect.Choice
-  Effect.Monad.Error.Transformer
-  Effect.Monad.Identity
-  Effect.Monad.IO
-  Effect.Monad.IO.Instances
-  Effect.Monad.Reader.Indexed
-  Effect.Monad.Reader.Instances
-  Effect.Monad.Reader.Transformer
-  Effect.Monad.Reader.Transformer.Base
-  Effect.Monad.State.Indexed
-  Effect.Monad.State.Instances
-  Effect.Monad.State.Transformer
-  Effect.Monad.State.Transformer.Base
-  Effect.Monad.Writer
-  Effect.Monad.Writer.Indexed
-  Effect.Monad.Writer.Instances
-  Effect.Monad.Writer.Transformer
-  Effect.Monad.Writer.Transformer.Base
-  IO.Effectful
-  IO.Instances
-  ```
-
-### Other
-
-* In accordance with changes to the flags in Agda 2.6.3, all modules that previously used
-  the `--without-K` flag now use the `--cubical-compatible` flag instead.
-
-* The first two arguments of `m≡n⇒m-n≡0` (now `i≡j⇒i-j≡0`) in `Data.Integer.Base`
-  have been made implicit.
-
-* The relations `_≤_` `_≥_` `_<_` `_>_` in `Data.Fin.Base` have been
-  generalised so they can now relate `Fin` terms with different indices.
-  Should be mostly backwards compatible, but very occasionally when proving
-  properties about the orderings themselves the second index must be provided
-  explicitly.
-
-* The operation `SymClosure` on relations in
-  `Relation.Binary.Construct.Closure.Symmetric` has been reimplemented
-  as a data type `SymClosure _⟶_ a b` that is parameterized by the
-  input relation `_⟶_` (as well as the elements `a` and `b` of the
-  domain) so that `_⟶_` can be inferred, which it could not from the
-  previous implementation using the sum type `a ⟶ b ⊎ b ⟶ a`.
-
-* In `Algebra.Morphism.Structures`, `IsNearSemiringHomomorphism`,
-  `IsSemiringHomomorphism`, and `IsRingHomomorphism` have been redeisgned to
-  build up from `IsMonoidHomomorphism`, `IsNearSemiringHomomorphism`, and
-  `IsSemiringHomomorphism` respectively, adding a single property at each step.
-  This means that they no longer need to have two separate proofs of
-  `IsRelHomomorphism`. Similarly, `IsLatticeHomomorphism` is now built as
-  `IsRelHomomorphism` along with proofs that `_∧_` and `_∨_` are homorphic.
-
-  Also, `⁻¹-homo` in `IsRingHomomorphism` has been renamed to `-‿homo`.
-
-* Moved definition of `_>>=_` under `Data.Vec.Base` to its submodule `CartesianBind`
-  in order to keep another new definition of `_>>=_`, located in `DiagonalBind`
-  which is also a submodule of `Data.Vec.Base`.
-
-* The functions `split`, `flatten` and `flatten-split` have been removed from
-  `Data.List.NonEmpty`. In their place `groupSeqs` and `ungroupSeqs`
-  have been added to `Data.List.NonEmpty.Base` which morally perform the same
-  operations but without computing the accompanying proofs. The proofs can be
-  found in `Data.List.NonEmpty.Properties` under the names `groupSeqs-groups`
-  and `ungroupSeqs` and `groupSeqs`.
-
-* The constructors `+0` and `+[1+_]` from `Data.Integer.Base` are no longer
-  exported by `Data.Rational.Base`. You will have to open `Data.Integer(.Base)`
-  directly to use them.
-
-* The names of the (in)equational reasoning combinators defined in the internal
-  modules `Data.Rational(.Unnormalised).Properties.≤-Reasoning` have been renamed
-  (issue #1437) to conform with the defined setoid equality `_≃_` on `Rational`s:
-  ```agda
-  step-≈  ↦  step-≃
-  step-≃˘ ↦  step-≃˘
-  ```
-  with corresponding associated syntax:
-  ```agda
-  _≈⟨_⟩_  ↦  _≃⟨_⟩_
-  _≈˘⟨_⟩_ ↦  _≃˘⟨_⟩_
-  ```
-  NB. It is not possible to rename or deprecate `syntax` declarations, so Agda will
-  only issue a "Could not parse the application `begin ...` when scope checking"
-  warning if the old combinators are used. 
-
-* The types of the proofs `pos⇒1/pos`/`1/pos⇒pos` and `neg⇒1/neg`/`1/neg⇒neg` in
-  `Data.Rational(.Unnormalised).Properties` have been switched, as the previous
-  naming scheme didn't correctly generalise to e.g. `pos+pos⇒pos`. For example
-  the types of `pos⇒1/pos`/`1/pos⇒pos` were:
-  ```
-  pos⇒1/pos : ∀ p .{{_ : NonZero p}} .{{Positive (1/ p)}} → Positive p
-  1/pos⇒pos : ∀ p .{{_ : Positive p}} → Positive (1/ p)
-  ```
-  but are now:
-  ```
-  pos⇒1/pos : ∀ p .{{_ : Positive p}} → Positive (1/ p)
-  1/pos⇒pos : ∀ p .{{_ : NonZero p}} .{{Positive (1/ p)}} → Positive p
-  ```
-* `Opₗ` and `Opᵣ` have moved from `Algebra.Core` to `Algebra.Module.Core`.
-
-* In `Data.Nat.GeneralisedArithmetic`, the `s` and `z` arguments to the following
-  functions have been made explicit:
-  * `fold-+`
-  * `fold-k`
-  * `fold-*`
-  * `fold-pull`
+* The module `IO.Primitive` was moved to `IO.Primitive.Core`.
 
-* In `Data.Fin.Properties`:
-  + the `i` argument to `opposite-suc` has been made explicit;
-  + `pigeonhole` has been strengthened: wlog, we return a proof that
-    `i < j` rather than a mere `i ≢ j`.
-
-* In `Data.Sum.Base` the definitions `fromDec` and `toDec` have been moved to `Data.Sum`.
-
-* In `Codata.Guarded.Stream` the following functions have been modified to have simpler definitions:
-  * `cycle`
-  * `interleave⁺`
-  * `cantor`
-  Furthermore, the direction of interleaving of `cantor` has changed. Precisely, suppose `pair` is the cantor pairing function, then `lookup (pair i j) (cantor xss)` according to the old definition corresponds to `lookup (pair j i) (cantor xss)` according to the new definition. For a concrete example see the one included at the end of the module.
-
-* Removed `m/n/o≡m/[n*o]` from `Data.Nat.Divisibility` and added a more general
-  `m/n/o≡m/[n*o]` to `Data.Nat.DivMod` that doesn't require `n * o ∣ m`.
-
-* Updated `lookup` functions (and variants) to match the conventions adopted in the
-  `List` module i.e. `lookup` takes its container first and the index (whose type may
-  depend on the container value) second.
-  This affects modules:
-    ```
-    Codata.Guarded.Stream
-    Codata.Guarded.Stream.Relation.Binary.Pointwise
-    Codata.Musical.Colist.Base
-    Codata.Musical.Colist.Relation.Unary.Any.Properties
-    Codata.Musical.Covec
-    Codata.Musical.Stream
-    Codata.Sized.Colist
-    Codata.Sized.Covec
-    Codata.Sized.Stream
-    Data.Vec.Relation.Unary.All
-    Data.Star.Environment
-    Data.Star.Pointer
-    Data.Star.Vec
-    Data.Trie
-    Data.Trie.NonEmpty
-    Data.Tree.AVL
-    Data.Tree.AVL.Indexed
-    Data.Tree.AVL.Map
-    Data.Tree.AVL.NonEmpty
-    Data.Vec.Recursive
-    Tactic.RingSolver
-    Tactic.RingSolver.Core.NatSet
-    ```
-  * Moved & renamed from `Data.Vec.Relation.Unary.All`
-    to `Data.Vec.Relation.Unary.All.Properties`:
-    ```
-    lookup ↦ lookup⁺
-    tabulate ↦ lookup⁻
-    ```
-  * Renamed in `Data.Vec.Relation.Unary.Linked.Properties`
-    and `Codata.Guarded.Stream.Relation.Binary.Pointwise`:
-    ```
-    lookup ↦ lookup⁺
-    ```
-  * Added the following new definitions to `Data.Vec.Relation.Unary.All`:
-    ```
-    lookupAny : All P xs → (i : Any Q xs) → (P ∩ Q) (Any.lookup i)
-    lookupWith : ∀[ P ⇒ Q ⇒ R ] → All P xs → (i : Any Q xs) → R (Any.lookup i)
-    lookup : All P xs → (∀ {x} → x ∈ₚ xs → P x)
-    lookupₛ : P Respects _≈_ → All P xs → (∀ {x} → x ∈ xs → P x)
-    ```
-
-
-Major improvements
+Minor improvements
 ------------------
 
-### Improvements to ring solver tactic
-
-* The ring solver tactic has been greatly improved. In particular:
-  1. When the solver is used for concrete ring types, e.g. ℤ, the equality can now use
-	 all the ring operations defined natively for that type, rather than having
-	 to use the operations defined in `AlmostCommutativeRing`. For example
-	 previously you could not use `Data.Integer.Base._*_` but instead had to
-	 use `AlmostCommutativeRing._*_`.
-  2. The solver now supports use of the subtraction operator `_-_` whenever
-     it is defined immediately in terms of `_+_` and `-_`. This is the case for
-	 `Data.Integer` and `Data.Rational`.
-
-### Moved `_%_` and `_/_` operators to `Data.Nat.Base`
-
-* Previously the division and modulus operators were defined in `Data.Nat.DivMod`
-  which in turn meant that using them required importing `Data.Nat.Properties`
-  which is a very heavy dependency.
-
-* To fix this, these operators have been moved to `Data.Nat.Base`. The properties
-  for them still live in `Data.Nat.DivMod` (which also publicly re-exports them
-  to provide backwards compatability).
-
-* Beneficieries of this change include `Data.Rational.Unnormalised.Base` whose
-  dependencies are now significantly smaller.
-
-### Moved raw bundles from Data.X.Properties to Data.X.Base
-
-* As mentioned by MatthewDaggitt in Issue #1755, Raw bundles defined in Data.X.Properties
-  should be defined in Data.X.Base as they don't require any properties.
-  * Moved raw bundles From `Data.Nat.Properties` to `Data.Nat.Base`
-  * Moved raw bundles From `Data.Nat.Binary.Properties` to `Data.Nat.Binary.Base`
-  * Moved raw bundles From `Data.Rational.Properties` to `Data.Rational.Base`
-  * Moved raw bundles From `Data.Rational.Unnormalised.Properties` to `Data.Rational.Unnormalised.Base`
-
-### Moved the definition of RawX from `Algebra.X.Bundles` to `Algebra.X.Bundles.Raw`
-
-* A new module `Algebra.Bundles.Raw` containing the definitions of the raw bundles
-  can be imported at much lower cost from `Data.X.Base`.
-  The following definitions have been moved:
-  * `RawMagma`
-  * `RawMonoid`
-  * `RawGroup`
-  * `RawNearSemiring`
-  * `RawSemiring`
-  * `RawRingWithoutOne`
-  * `RawRing`
-  * `RawQuasigroup`
-  * `RawLoop`
-* A new module `Algebra.Lattice.Bundles.Raw` is also introduced.
-  * `RawLattice` has been moved from `Algebra.Lattice.Bundles` to this new module.
+* The definition of the `Pointwise` relational combinator in
+  `Data.Product.Relation.Binary.Pointwise.NonDependent.Pointwise`
+  has been generalised to take heterogeneous arguments in `REL`.
+
+* The structures `IsSemilattice` and `IsBoundedSemilattice` in
+  `Algebra.Lattice.Structures` have been redefined as aliases of
+  `IsCommutativeBand` and `IsIdempotentMonoid` in `Algebra.Structures`.
 
 Deprecated modules
 ------------------
 
-### Deprecation of old function hierarchy
+* All modules in the `Data.Word` hierarchy have been deprecated in favour
+  of their newly introduced counterparts in `Data.Word64`.
 
-* The module `Function.Related` has been deprecated in favour of `Function.Related.Propositional`
-  whose code uses the new function hierarchy. This also opens up the possibility of a more
-  general `Function.Related.Setoid` at a later date. Several of the names have been changed
-  in this process to bring them into line with the camelcase naming convention used
-  in the rest of the library:
-  ```agda
-  reverse-implication ↦ reverseImplication
-  reverse-injection   ↦ reverseInjection
-  left-inverse        ↦ leftInverse
+* The module `Data.List.Relation.Binary.Sublist.Propositional.Disjoint`
+  has been deprecated in favour of `Data.List.Relation.Binary.Sublist.Propositional.Slice`.
 
-  Symmetric-kind      ↦ SymmetricKind
-  Forward-kind        ↦ ForwardKind
-  Backward-kind       ↦ BackwardKind
-  Equivalence-kind    ↦ EquivalenceKind
+* The modules
   ```
-
-### Moving `Algebra.Lattice` files
-
-* As discussed above the following files have been moved:
-  ```agda
-  Algebra.Properties.Semilattice               ↦ Algebra.Lattice.Properties.Semilattice
-  Algebra.Properties.Lattice                   ↦ Algebra.Lattice.Properties.Lattice
-  Algebra.Properties.DistributiveLattice       ↦ Algebra.Lattice.Properties.DistributiveLattice
-  Algebra.Properties.BooleanAlgebra            ↦ Algebra.Lattice.Properties.BooleanAlgebra
-  Algebra.Properties.BooleanAlgebra.Expression ↦ Algebra.Lattice.Properties.BooleanAlgebra.Expression
-  Algebra.Morphism.LatticeMonomorphism         ↦ Algebra.Lattice.Morphism.LatticeMonomorphism
+  Function.Endomorphism.Propositional
+  Function.Endomorphism.Setoid
   ```
-
-### Moving `Relation.Binary.Properties.XLattice` files
-
-* The following files have been moved:
-  ```agda
-  Relation.Binary.Properties.BoundedJoinSemilattice.agda  ↦ Relation.Binary.Lattice.Properties.BoundedJoinSemilattice.agda
-  Relation.Binary.Properties.BoundedLattice.agda          ↦ Relation.Binary.Lattice.Properties.BoundedLattice.agda
-  Relation.Binary.Properties.BoundedMeetSemilattice.agda  ↦ Relation.Binary.Lattice.Properties.BoundedMeetSemilattice.agda
-  Relation.Binary.Properties.DistributiveLattice.agda     ↦ Relation.Binary.Lattice.Properties.DistributiveLattice.agda
-  Relation.Binary.Properties.JoinSemilattice.agda         ↦ Relation.Binary.Lattice.Properties.JoinSemilattice.agda
-  Relation.Binary.Properties.Lattice.agda                 ↦ Relation.Binary.Lattice.Properties.Lattice.agda
-  Relation.Binary.Properties.MeetSemilattice.agda         ↦ Relation.Binary.Lattice.Properties.MeetSemilattice.agda
+  that used the old `Function` hierarchy have been deprecated in favour of:
+  ```
+  Function.Endo.Propositional
+  Function.Endo.Setoid
   ```
-
-### Deprecation of `Data.Nat.Properties.Core`
-
-* The module `Data.Nat.Properties.Core` has been deprecated, and its one entry moved to `Data.Nat.Properties`
 
 Deprecated names
 ----------------
 
-* In `Algebra.Construct.Zero`:
-  ```agda
-  rawMagma   ↦  Algebra.Construct.Terminal.rawMagma
-  magma      ↦  Algebra.Construct.Terminal.magma
-  semigroup  ↦  Algebra.Construct.Terminal.semigroup
-  band       ↦  Algebra.Construct.Terminal.band
-  ```
-
-* In `Codata.Guarded.Stream.Properties`:
+* In `Algebra.Properties.Semiring.Mult`:
   ```agda
-  map-identity  ↦  map-id
-  map-fusion    ↦  map-∘
+  1×-identityʳ  ↦  ×-homo-1
   ```
 
-* In `Codata.Sized.Colist.Properties`:
+* In `Algebra.Structures.IsGroup`:
   ```agda
-  map-identity   ↦  map-id
-  map-map-fusion  ↦  map-∘
+  _-_  ↦  _//_
   ```
 
-* In `Codata.Sized.Covec.Properties`:
+* In `Algebra.Structures.Biased`:
   ```agda
-  map-identity   ↦  map-id
-  map-map-fusion  ↦  map-∘
+  IsRing*  ↦  Algebra.Structures.IsRing
+  isRing*  ↦  Algebra.Structures.isRing
   ```
 
-* In `Codata.Sized.Delay.Properties`:
+* In `Data.Float.Base`:
   ```agda
-  map-identity      ↦  map-id
-  map-map-fusion    ↦  map-∘
-  map-unfold-fusion  ↦  map-unfold
+  toWord ↦ toWord64
   ```
 
-* In `Codata.Sized.M.Properties`:
+* In `Data.Float.Properties`:
   ```agda
-  map-compose  ↦  map-∘
+  toWord-injective ↦ toWord64-injective
   ```
 
-* In `Codata.Sized.Stream.Properties`:
+* In `Data.List.Base`:
   ```agda
-  map-identity   ↦  map-id
-  map-map-fusion  ↦  map-∘
+  scanr  ↦  Data.List.Scans.Base.scanr
+  scanl  ↦  Data.List.Scans.Base.scanl
   ```
 
-* In `Data.Fin.Base`: two new, hopefully more memorable, names `↑ˡ` `↑ʳ`
-  for the 'left', resp. 'right' injection of a Fin m into a 'larger' type,
-  `Fin (m + n)`, resp. `Fin (n + m)`, with argument order to reflect the
-  position of the `Fin m` argument.
-  ```
-  inject+  ↦  flip _↑ˡ_
-  raise    ↦  _↑ʳ_
-  ```
-
-  Issue #1726: the relation `_≺_` and its single constructor `_≻toℕ_`
-  have been deprecated in favour of their extensional equivalent `_<_`
-  but omitting the inversion principle which pattern matching on `_≻toℕ_`
-  would achieve; this instead is proxied by the property `Data.Fin.Properties.toℕ<`.
-
-* In `Data.Fin.Induction`:
-  ```
-  ≺-Rec 
-  ≺-wellFounded
-  ≺-recBuilder
-  ≺-rec
-  ```
-
-  As with Issue #1726 above: the deprecation of relation `_≺_` means that these definitions
-  associated with wf-recursion are deprecated in favour of their `_<_` counterparts.
-  But it's not quite sensible to say that these definiton should be *renamed* to *anything*,
-  least of all those counterparts... the type confusion would be intolerable. 
-
-* In `Data.Fin.Properties`:
-  ```
-  toℕ-raise        ↦ toℕ-↑ʳ
-  toℕ-inject+      ↦ toℕ-↑ˡ
-  splitAt-inject+  ↦ splitAt-↑ˡ m i n
-  splitAt-raise    ↦ splitAt-↑ʳ
-  Fin0↔⊥           ↦ 0↔⊥
-  eq?              ↦ inj⇒≟
-  ```
-
-  Likewise under issue #1726: the properties `≺⇒<′` and `<′⇒≺` have been deprecated
-  in favour of their proxy counterparts `<⇒<′` and `<′⇒<`.
-
-* In `Data.Fin.Permutation.Components`:
-  ```
-  reverse            ↦ Data.Fin.Base.opposite
-  reverse-prop       ↦ Data.Fin.Properties.opposite-prop
-  reverse-involutive ↦ Data.Fin.Properties.opposite-involutive
-  reverse-suc        ↦ Data.Fin.Properties.opposite-suc
-  ```
-
-* In `Data.Integer.DivMod` the operator names have been renamed to
-  be consistent with those in `Data.Nat.DivMod`:
-  ```
-  _divℕ_  ↦ _/ℕ_
-  _div_   ↦ _/_
-  _modℕ_  ↦ _%ℕ_
-  _mod_   ↦ _%_
-  ```
-
-* In `Data.Integer.Properties` references to variables in names have
-  been made consistent so that `m`, `n` always refer to naturals and
-  `i` and `j` always refer to integers:
-  ```
-  ≤-steps        ↦  i≤j⇒i≤k+j
-  ≤-step         ↦  i≤j⇒i≤1+j
-
-  ≤-steps-neg    ↦  i≤j⇒i-k≤j
-  ≤-step-neg     ↦  i≤j⇒pred[i]≤j
-
-  n≮n            ↦  i≮i
-  ∣n∣≡0⇒n≡0       ↦  ∣i∣≡0⇒i≡0
-  ∣-n∣≡∣n∣         ↦  ∣-i∣≡∣i∣
-  0≤n⇒+∣n∣≡n      ↦  0≤i⇒+∣i∣≡i
-  +∣n∣≡n⇒0≤n      ↦  +∣i∣≡i⇒0≤i
-  +∣n∣≡n⊎+∣n∣≡-n   ↦  +∣i∣≡i⊎+∣i∣≡-i
-  ∣m+n∣≤∣m∣+∣n∣     ↦  ∣i+j∣≤∣i∣+∣j∣
-  ∣m-n∣≤∣m∣+∣n∣     ↦  ∣i-j∣≤∣i∣+∣j∣
-  signₙ◃∣n∣≡n     ↦  signᵢ◃∣i∣≡i
-  ◃-≡            ↦  ◃-cong
-  ∣m-n∣≡∣n-m∣      ↦  ∣i-j∣≡∣j-i∣
-  m≡n⇒m-n≡0      ↦  i≡j⇒i-j≡0
-  m-n≡0⇒m≡n      ↦  i-j≡0⇒i≡j
-  m≤n⇒m-n≤0      ↦  i≤j⇒i-j≤0
-  m-n≤0⇒m≤n      ↦  i-j≤0⇒i≤j
-  m≤n⇒0≤n-m      ↦  i≤j⇒0≤j-i
-  0≤n-m⇒m≤n      ↦  0≤i-j⇒j≤i
-  n≤1+n          ↦  i≤suc[i]
-  n≢1+n          ↦  i≢suc[i]
-  m≤pred[n]⇒m<n  ↦  i≤pred[j]⇒i<j
-  m<n⇒m≤pred[n]  ↦  i<j⇒i≤pred[j]
-  -1*n≡-n        ↦  -1*i≡-i
-  m*n≡0⇒m≡0∨n≡0  ↦  i*j≡0⇒i≡0∨j≡0
-  ∣m*n∣≡∣m∣*∣n∣     ↦  ∣i*j∣≡∣i∣*∣j∣
-  m≤m+n          ↦  i≤i+j
-  n≤m+n          ↦  i≤j+i
-  m-n≤m          ↦  i≤i-j
-
-  +-pos-monoʳ-≤    ↦  +-monoʳ-≤
-  +-neg-monoʳ-≤    ↦  +-monoʳ-≤
-  *-monoʳ-≤-pos    ↦  *-monoʳ-≤-nonNeg
-  *-monoˡ-≤-pos    ↦  *-monoˡ-≤-nonNeg
-  *-monoʳ-≤-neg    ↦  *-monoʳ-≤-nonPos
-  *-monoˡ-≤-neg    ↦  *-monoˡ-≤-nonPos
-  *-cancelˡ-<-neg  ↦  *-cancelˡ-<-nonPos
-  *-cancelʳ-<-neg  ↦  *-cancelʳ-<-nonPos
-
-  ^-semigroup-morphism ↦ ^-isMagmaHomomorphism
-  ^-monoid-morphism    ↦ ^-isMonoidHomomorphism
-  
-  pos-distrib-* ↦ pos-*
-  pos-+-commute ↦ pos-+
-  abs-*-commute ↦ abs-*
-  
-  +-isAbelianGroup ↦ +-0-isAbelianGroup
-  ```
-  
 * In `Data.List.Properties`:
   ```agda
-  map-id₂         ↦  map-id-local
-  map-cong₂       ↦  map-cong-local
-  map-compose     ↦  map-∘
-
-  map-++-commute       ↦  map-++
-  sum-++-commute       ↦  sum-++
-  reverse-map-commute  ↦  reverse-map
-  reverse-++-commute   ↦  reverse-++
-
-  zipWith-identityˡ  ↦  zipWith-zeroˡ
-  zipWith-identityʳ  ↦  zipWith-zeroʳ
-  ```
-
-* In `Data.List.NonEmpty.Properties`:
-  ```agda
-  map-compose     ↦  map-∘
-
-  map-++⁺-commute ↦  map-++⁺
+  scanr-defn  ↦  Data.List.Scans.Properties.scanr-defn
+  scanl-defn  ↦  Data.List.Scans.Properties.scanl-defn
   ```
 
 * In `Data.List.Relation.Unary.All.Properties`:
   ```agda
-  updateAt-id-relative      ↦  updateAt-id-local
-  updateAt-compose-relative ↦  updateAt-∘-local
-  updateAt-compose          ↦  updateAt-∘
-  updateAt-cong-relative    ↦  updateAt-cong-local
+  map-compose  ↦  map-∘
   ```
 
-* In `Data.List.Zipper.Properties`:
+* In `Data.Maybe.Base`:
   ```agda
-  toList-reverse-commute ↦  toList-reverse
-  toList-ˡ++-commute     ↦  toList-ˡ++
-  toList-++ʳ-commute     ↦  toList-++ʳ
-  toList-map-commute    ↦  toList-map
-  toList-foldr-commute  ↦  toList-foldr
+  decToMaybe  ↦  Relation.Nullary.Decidable.Core.dec⇒maybe
   ```
 
-* In `Data.Maybe.Properties`:
+* In `Data.Nat.Base`: the following pattern synonyms and definitions are all
+  deprecated in favour of direct pattern matching on `Algebra.Definitions.RawMagma._∣ˡ_._,_`
   ```agda
-  map-id₂     ↦  map-id-local
-  map-cong₂   ↦  map-cong-local
-
-  map-compose    ↦  map-∘
-
-  map-<∣>-commute ↦  map-<∣>
-
-* In `Data.List.Relation.Binary.Subset.Propositional.Properties`:
-  ```
-  map-with-∈⁺  ↦  mapWith∈⁺
-  ```
-
-* In `Data.List.Relation.Unary.Any.Properties`:
-  ```
-  map-with-∈⁺  ↦  mapWith∈⁺
-  map-with-∈⁻  ↦  mapWith∈⁻
-  map-with-∈↔  ↦  mapWith∈↔
-  ```
-
-* In `Data.Nat.Properties`:
-  ```
-  suc[pred[n]]≡n  ↦  suc-pred
-  ≤-step          ↦  m≤n⇒m≤1+n
-  ≤-stepsˡ        ↦  m≤n⇒m≤o+n
-  ≤-stepsʳ        ↦  m≤n⇒m≤n+o
-  <-step          ↦  m<n⇒m<1+n
-  ```
-
-* In `Data.Rational.Unnormalised.Properties`:
-  ```
-  ↥[p/q]≡p         ↦  ↥[n/d]≡n
-  ↧[p/q]≡q         ↦  ↧[n/d]≡d
-  *-monoˡ-≤-pos    ↦  *-monoˡ-≤-nonNeg
-  *-monoʳ-≤-pos    ↦  *-monoʳ-≤-nonNeg
-  ≤-steps          ↦  p≤q⇒p≤r+q
-  *-monoˡ-≤-neg    ↦  *-monoˡ-≤-nonPos
-  *-monoʳ-≤-neg    ↦  *-monoʳ-≤-nonPos
-  *-cancelˡ-<-pos  ↦  *-cancelˡ-<-nonNeg
-  *-cancelʳ-<-pos  ↦  *-cancelʳ-<-nonNeg
-
-  positive⇒nonNegative  ↦ pos⇒nonNeg
-  negative⇒nonPositive  ↦ neg⇒nonPos
-  negative<positive     ↦ neg<pos
-  ```
-
-* In `Data.Rational.Base`:
-  ```
-  +-rawMonoid ↦ +-0-rawMonoid
-  *-rawMonoid ↦ *-1-rawMonoid
-  ```
-
-* In `Data.Rational.Properties`:
+  pattern less-than-or-equal {k} eq = k , eq
+  pattern ≤″-offset k = k , refl
+  pattern <″-offset k = k , refl
+  s≤″s⁻¹
   ```
-  *-monoʳ-≤-neg    ↦  *-monoʳ-≤-nonPos
-  *-monoˡ-≤-neg    ↦  *-monoˡ-≤-nonPos
-  *-monoʳ-≤-pos    ↦  *-monoʳ-≤-nonNeg
-  *-monoˡ-≤-pos    ↦  *-monoˡ-≤-nonNeg
-  *-cancelˡ-<-pos  ↦  *-cancelˡ-<-nonNeg
-  *-cancelʳ-<-pos  ↦  *-cancelʳ-<-nonNeg
-  *-cancelˡ-<-neg  ↦  *-cancelˡ-<-nonPos
-  *-cancelʳ-<-neg  ↦  *-cancelʳ-<-nonPos
 
-  negative<positive     ↦ neg<pos
-  ```
-
-* In `Data.Rational.Unnormalised.Base`:
-  ```
-  +-rawMonoid ↦ +-0-rawMonoid
-  *-rawMonoid ↦ *-1-rawMonoid
-  ```
-
-* In `Data.Sum.Properties`:
+* In `Data.Nat.Divisibility.Core`:
   ```agda
-  [,]-∘-distr      ↦  [,]-∘
-  [,]-map-commute  ↦  [,]-map
-  map-commute      ↦  map-map
-  map₁₂-commute    ↦  map₁₂-map₂₁
+  *-pres-∣  ↦  Data.Nat.Divisibility.*-pres-∣
   ```
 
-* In `Data.Tree.AVL`:
-  ```
-  _∈?_ ↦ member
-  ```
-
-* In `Data.Tree.AVL.IndexedMap`:
-  ```
-  _∈?_ ↦ member
-  ```
-
-* In `Data.Tree.AVL.Map`:
-  ```
-  _∈?_ ↦ member
-  ```
-
-* In `Data.Tree.AVL.Sets`:
-  ```
-  _∈?_ ↦ member
-  ```
-
-* In `Data.Tree.Binary.Zipper.Properties`:
-  ```
-  toTree-#nodes-commute   ↦  toTree-#nodes
-  toTree-#leaves-commute  ↦  toTree-#leaves
-  toTree-map-commute      ↦  toTree-map
-  toTree-foldr-commute    ↦  toTree-foldr
-  toTree-⟪⟫ˡ-commute      ↦  toTree--⟪⟫ˡ
-  toTree-⟪⟫ʳ-commute      ↦  toTree-⟪⟫ʳ
-  ```
-
-* In `Data.Tree.Rose.Properties`:
+* In `Data.Sum`:
   ```agda
-  map-compose     ↦  map-∘
-  ```
-
-* In `Data.Vec.Properties`:
-  ```
-  updateAt-id-relative      ↦  updateAt-id-local
-  updateAt-compose-relative ↦  updateAt-∘-local
-  updateAt-compose          ↦  updateAt-∘
-  updateAt-cong-relative    ↦  updateAt-cong-local
-
-  []%=-compose    ↦  []%=-∘
-
-  []≔-++-inject+  ↦ []≔-++-↑ˡ
-  []≔-++-raise    ↦ []≔-++-↑ʳ
-  idIsFold        ↦ id-is-foldr
-  sum-++-commute  ↦ sum-++
-  ```
-  and the type of the proof `zipWith-comm` has been generalised from:
-  ```
-  zipWith-comm : ∀ {f : A → A → B} (comm : ∀ x y → f x y ≡ f y x) (xs ys : Vec A n) → zipWith f xs ys ≡ zipWith f ys xs
-  ```
-  to
-  ```
-  zipWith-comm : ∀ {f : A → B → C} {g : B → A → C}  (comm : ∀ x y → f x y ≡ g y x) (xs : Vec A n) ys → zipWith f xs ys ≡ zipWith g ys xs
-  ```
-
-* In `Data.Vec.Functional.Properties`:
-  ```
-  updateAt-id-relative      ↦  updateAt-id-local
-  updateAt-compose-relative ↦  updateAt-∘-local
-  updateAt-compose          ↦  updateAt-∘
-  updateAt-cong-relative    ↦  updateAt-cong-local
-
-  map-updateAt              ↦  map-updateAt-local
-  ```
-  NB. This last one is complicated by the *addition* of a 'global' property `map-updateAt`
-
-* In `Data.Vec.Recursive.Properties`:
-  ```
-  append-cons-commute  ↦  append-cons
+  fromDec  ↦  Relation.Nullary.Decidable.Core.toSum
+  toDec    ↦  Relation.Nullary.Decidable.Core.fromSum
   ```
 
-* In `Data.Vec.Relation.Binary.Equality.Setoid`:
+* In `IO.Base`:
   ```agda
-  map-++-commute ↦  map-++
-  ```
-
-* In `Function.Construct.Composition`:
-  ```
-  _∘-⟶_   ↦   _⟶-∘_
-  _∘-↣_   ↦   _↣-∘_
-  _∘-↠_   ↦   _↠-∘_
-  _∘-⤖_  ↦   _⤖-∘_
-  _∘-⇔_   ↦   _⇔-∘_
-  _∘-↩_   ↦   _↩-∘_
-  _∘-↪_   ↦   _↪-∘_
-  _∘-↔_   ↦   _↔-∘_
-  ```
-
-  * In `Function.Construct.Identity`:
-  ```
-  id-⟶   ↦   ⟶-id
-  id-↣   ↦   ↣-id
-  id-↠   ↦   ↠-id
-  id-⤖  ↦   ⤖-id
-  id-⇔   ↦   ⇔-id
-  id-↩   ↦   ↩-id
-  id-↪   ↦   ↪-id
-  id-↔   ↦   ↔-id
-  ```
-
-* In `Function.Construct.Symmetry`:
-  ```
-  sym-⤖   ↦   ⤖-sym
-  sym-⇔   ↦   ⇔-sym
-  sym-↩   ↦   ↩-sym
-  sym-↪   ↦   ↪-sym
-  sym-↔   ↦   ↔-sym
-  ```
-
-* In `Foreign.Haskell.Either` and `Foreign.Haskell.Pair`:
-  ```
-  toForeign   ↦ Foreign.Haskell.Coerce.coerce
-  fromForeign ↦ Foreign.Haskell.Coerce.coerce
+  untilRight  ↦  untilInj₂
   ```
 
-* In `Relation.Binary.Properties.Preorder`:
-  ```
-  invIsPreorder ↦ converse-isPreorder
-  invPreorder   ↦ converse-preorder
-  ```
-
-### Renamed Data.Erased to Data.Irrelevant
-
-* This fixes the fact we had picked the wrong name originally. The erased modality
-  corresponds to @0 whereas the irrelevance one corresponds to `.`.
-
 New modules
 -----------
 
-* Algebraic structures when freely adding an identity element:
-  ```
-  Algebra.Construct.Add.Identity
-  ```
-
-* Operations for module-like algebraic structures:
-  ```
-  Algebra.Module.Core
-  ```
-
-* Constructive algebraic structures with apartness relations:
-  ```
-  Algebra.Apartness
-  Algebra.Apartness.Bundles
-  Algebra.Apartness.Structures
-  Algebra.Apartness.Properties.CommutativeHeytingAlgebra
-  Relation.Binary.Properties.ApartnessRelation
-  ```
-
-* Algebraic structures obtained by flipping their binary operations:
-  ```
-  Algebra.Construct.Flip.Op
-  ```
-
-* Morphisms between module-like algebraic structures:
-  ```
-  Algebra.Module.Morphism.Construct.Composition
-  Algebra.Module.Morphism.Construct.Identity
-  Algebra.Module.Morphism.Definitions
-  Algebra.Module.Morphism.Structures
-  Algebra.Module.Properties
-  ```
-
-* Identity morphisms and composition of morphisms between algebraic structures:
-  ```
-  Algebra.Morphism.Construct.Composition
-  Algebra.Morphism.Construct.Identity
-  ```
-
-* Ordered algebraic structures (pomonoids, posemigroups, etc.)
-  ```
-  Algebra.Ordered
-  Algebra.Ordered.Bundles
-  Algebra.Ordered.Structures
-  ```
-
-* 'Optimised' tail-recursive exponentiation properties:
-  ```
-  Algebra.Properties.Semiring.Exp.TailRecursiveOptimised
-  ```
-
-* A definition of infinite streams using coinductive records:
-  ```
-  Codata.Guarded.Stream
-  Codata.Guarded.Stream.Properties
-  Codata.Guarded.Stream.Relation.Binary.Pointwise
-  Codata.Guarded.Stream.Relation.Unary.All
-  Codata.Guarded.Stream.Relation.Unary.Any
-  ```
-
-* A small library for function arguments with default values:
-  ```
-  Data.Default
-  ```
-
-* A small library for a non-empty fresh list:
-  ```
-  Data.List.Fresh.NonEmpty
-  ```
-
-* A small library defining a structurally inductive view of lists:
+* Pointwise lifting of algebraic structures `IsX` and bundles `X` from
+  carrier set `C` to function space `A → C`:
   ```
-  Data.List.Relation.Unary.Sufficient
+  Algebra.Construct.Pointwise
   ```
 
-* Combinations and permutations for ℕ.
+* Raw bundles for module-like algebraic structures:
   ```
-  Data.Nat.Combinatorics
-  Data.Nat.Combinatorics.Base
-  Data.Nat.Combinatorics.Spec
+  Algebra.Module.Bundles.Raw
   ```
 
-* A small library defining parity and its algebra:
-  ```
-  Data.Parity
-  Data.Parity.Base
-  Data.Parity.Instances
-  Data.Parity.Properties
-  ```
-
-* New base module for `Data.Product` containing only the basic definitions.
-  ```
-  Data.Product.Base
-  ```
-
-* Reflection utilities for some specific types:
-  ```
-  Data.List.Reflection
-  Data.Vec.Reflection
-  ```
-
-* The `All` predicate over non-empty lists:
-  ```
-  Data.List.NonEmpty.Relation.Unary.All
-  ```
-
-* A small library for heterogenous equational reasoning on vectors:
-  ```
-  Data.Vec.Properties.Heterogeneous
-  ```
-
-* Show module for unnormalised rationals:
-  ```
-  Data.Rational.Unnormalised.Show
+* Nagata's construction of the "idealization of a module":
+  ```agda
+  Algebra.Module.Construct.Idealization
   ```
 
-* Membership relations for maps and sets
-  ```
-  Data.Tree.AVL.Map.Membership.Propositional
-  Data.Tree.AVL.Map.Membership.Propositional.Properties
-  Data.Tree.AVL.Sets.Membership
-  Data.Tree.AVL.Sets.Membership.Properties
+* The unique morphism from the initial, resp. terminal, algebra:
+  ```agda
+  Algebra.Morphism.Construct.Initial
+  Algebra.Morphism.Construct.Terminal
   ```
 
-* Properties of bijections:
-  ```
-  Function.Consequences
-  Function.Properties.Bijection
-  Function.Properties.RightInverse
-  Function.Properties.Surjection
+* Bytestrings and builders:
+  ```agda
+  Data.Bytestring.Base
+  Data.Bytestring.Builder.Base
+  Data.Bytestring.Builder.Primitive
+  Data.Bytestring.IO
+  Data.Bytestring.IO.Primitive
+  Data.Bytestring.Primitive
   ```
 
-* In order to improve modularity, the contents of `Relation.Binary.Lattice` has been
-  split out into the standard:
-  ```
-  Relation.Binary.Lattice.Definitions
-  Relation.Binary.Lattice.Structures
-  Relation.Binary.Lattice.Bundles
+* Pointwise and equality relations over indexed containers:
+  ```agda
+  Data.Container.Indexed.Relation.Binary.Pointwise
+  Data.Container.Indexed.Relation.Binary.Pointwise.Properties
+  Data.Container.Indexed.Relation.Binary.Equality.Setoid
   ```
-  All contents is re-exported by `Relation.Binary.Lattice` as before.
 
-* Algebraic properties of `_∩_` and `_∪_` for predicates
+* Refactoring of `Data.List.Base.{scanr|scanl}` and their properties:
   ```
-  Relation.Unary.Algebra
+  Data.List.Scans.Base
+  Data.List.Scans.Properties
   ```
 
-* Both versions of equality on predications are equivalences
-  ```
-  Relation.Unary.Relation.Binary.Equality
+* Various show modules for lists and vector types:
+  ```agda
+  Data.List.Show
+  Data.Vec.Show
+  Data.Vec.Bounded.Show
   ```
 
-* The subset relations on predicates define an order
+* Properties of `List` modulo `Setoid` equality (currently only the ([],++) monoid):
   ```
-  Relation.Unary.Relation.Binary.Subset
+  Data.List.Relation.Binary.Equality.Setoid.Properties
   ```
 
-* Polymorphic versions of some unary relations and their properties
-  ```
-  Relation.Unary.Polymorphic
-  Relation.Unary.Polymorphic.Properties
+* Decidability for the subset relation on lists:
+  ```agda
+  Data.List.Relation.Binary.Subset.DecSetoid (_⊆?_)
+  Data.List.Relation.Binary.Subset.DecPropositional
   ```
 
-* Alpha equality over reflected terms
-  ```
-  Reflection.AST.AlphaEquality
+* Decidability for the disjoint relation on lists:
+  ```agda
+  Data.List.Relation.Binary.Disjoint.DecSetoid (disjoint?)
+  Data.List.Relation.Binary.Disjoint.DecPropositional
   ```
 
-* `cong!` tactic for deriving arguments to `cong`
-  ```
-  Tactic.Cong
+* Prime factorisation of natural numbers.
+  ```agda
+  Data.Nat.Primality.Factorisation
   ```
 
-* Various system types and primitives:
-  ```
-  System.Clock.Primitive
-  System.Clock
-  System.Console.ANSI
-  System.Directory.Primitive
-  System.Directory
-  System.FilePath.Posix.Primitive
-  System.FilePath.Posix
-  System.Process.Primitive
-  System.Process
+* Permutations of vectors as functions:
+  ```agda
+  Data.Vec.Functional.Relation.Binary.Permutation
+  Data.Vec.Functional.Relation.Binary.Permutation.Properties
   ```
 
-* A golden testing library with test pools, an options parser, a runner:
-  ```
-  Test.Golden
+* A type of bytes:
+  ```agda
+  Data.Word8.Primitive
+  Data.Word8.Base
+  Data.Word8.Literals
+  Data.Word8.Show
   ```
 
-* New interfaces for using Haskell datatypes:
-  ```
-  Foreign.Haskell.List.NonEmpty
-  ```
-* Added new module `Algebra.Properties.RingWithoutOne`:
-  ```
-  -‿distribˡ-* : ∀ x y → - (x * y) ≈ - x * y
-  -‿distribʳ-* : ∀ x y → - (x * y) ≈ x * - y
-  ```
-* An implementation of M-types with `--guardedness` flag:
-  ```
-  Codata.Guarded.M
+* Word64 literals and bit-based functions:
+  ```agda
+  Data.Word64.Literals
+  Data.Word64.Unsafe
+  Data.Word64.Show
   ```
 
-* Port of `Linked` to `Vec`:
-  ```
-  Data.Vec.Relation.Unary.Linked
-  Data.Vec.Relation.Unary.Linked.Properties
-  ```
-* Added Logarithm base 2 on Natural Numbers:
-  ```
-  Data.Nat.Logarithm.Core
-  Data.Nat.Logarithm
-  ```
 
-* Proofs of some axioms of linearity:
-  ```
-  Algebra.Module.Morphism.ModuleHomomorphism
-  Algebra.Module.Properties
+* Pointwise equality over functions
   ```
-* Properties of MoufangLoop
-  ```
-  Algebra.Properties.MoufangLoop
+  Function.Relation.Binary.Equality`
   ```
 
-* Properties of Quasigroup
-  ```
-  Algebra.Properties.Quasigroup
-  ```
-  
-* Properties of MiddleBolLoop
-  ```
-  Algebra.Properties.MiddleBolLoop
+* Consequences of 'infinite descent' for (accessible elements of) well-founded relations:
+  ```agda
+  Induction.InfiniteDescent
   ```
 
-* Properties of Loop
-  ```
-  Algebra.Properties.Loop
+* New IO primitives to handle buffering
+  ```agda
+  IO.Primitive.Handle
+  IO.Handle
   ```
 
-* Some n-ary functions manipulating lists
+* Symmetric interior of a binary relation
   ```
-  Data.List.Nary.NonDependent
+  Relation.Binary.Construct.Interior.Symmetric
   ```
 
-* Properties of KleeneAlgebra
+* Properties of `Setoid`s with decidable equality relation:
   ```
-  Algebra.Properties.KleeneAlgebra
+  Relation.Binary.Properties.DecSetoid
   ```
-Other minor changes
--------------------
 
-* Added new proof to `Data.Maybe.Properties`
+* Collection of results about recomputability in
   ```agda
-    <∣>-idem : Idempotent _<∣>_
+  Relation.Nullary.Recomputable
   ```
+  with the main definition `Recomputable` exported publicly from `Relation.Nullary`.
 
-* The module `Algebra` now publicly re-exports the contents of
-  `Algebra.Structures.Biased`.
-
-* Added new definitions to `Algebra.Bundles`:
+* New bindings to random numbers:
   ```agda
-  record UnitalMagma c ℓ : Set (suc (c ⊔ ℓ))
-  record InvertibleMagma c ℓ : Set (suc (c ⊔ ℓ))
-  record InvertibleUnitalMagma c ℓ : Set (suc (c ⊔ ℓ))
-  record RawQuasiGroup c ℓ : Set (suc (c ⊔ ℓ))
-  record Quasigroup c ℓ : Set (suc (c ⊔ ℓ))
-  record RawLoop  c ℓ : Set (suc (c ⊔ ℓ))
-  record Loop  c ℓ : Set (suc (c ⊔ ℓ))
-  record RingWithoutOne c ℓ : Set (suc (c ⊔ ℓ))
-  record IdempotentSemiring c ℓ : Set (suc (c ⊔ ℓ))
-  record KleeneAlgebra c ℓ : Set (suc (c ⊔ ℓ))
-  record RawRingWithoutOne c ℓ : Set (suc (c ⊔ ℓ))
-  record Quasiring c ℓ : Set (suc (c ⊔ ℓ)) where
-  record Nearring c ℓ : Set (suc (c ⊔ ℓ)) where
-  record IdempotentMagma c ℓ : Set (suc (c ⊔ ℓ))
-  record AlternateMagma c ℓ : Set (suc (c ⊔ ℓ))
-  record FlexibleMagma c ℓ : Set (suc (c ⊔ ℓ))
-  record MedialMagma c ℓ : Set (suc (c ⊔ ℓ))
-  record SemimedialMagma c ℓ : Set (suc (c ⊔ ℓ))
-  record LeftBolLoop c ℓ : Set (suc (c ⊔ ℓ))
-  record RightBolLoop c ℓ : Set (suc (c ⊔ ℓ))
-  record MoufangLoop c ℓ : Set (suc (c ⊔ ℓ))
-  record NonAssociativeRing c ℓ : Set (suc (c ⊔ ℓ))
-  record MiddleBolLoop c ℓ : Set (suc (c ⊔ ℓ))
-  ```
-  and the existing record `Lattice` now provides
-  ```agda
-  ∨-commutativeSemigroup : CommutativeSemigroup c ℓ
-  ∧-commutativeSemigroup : CommutativeSemigroup c ℓ
-  ```
-  and their corresponding algebraic subbundles.
-
-* Added new proofs to `Algebra.Consequences.Base`:
-  ```agda
-  reflexive+selfInverse⇒involutive : Reflexive _≈_ →
-                                     SelfInverse _≈_ f →
-                                     Involutive _≈_ f
-  ```
-
-* Added new proofs to `Algebra.Consequences.Setoid`:
-  ```agda
-  involutive⇒surjective  : Involutive f  → Surjective f
-  selfInverse⇒involutive : SelfInverse f → Involutive f
-  selfInverse⇒congruent  : SelfInverse f → Congruent f
-  selfInverse⇒inverseᵇ   : SelfInverse f → Inverseᵇ f f
-  selfInverse⇒surjective : SelfInverse f → Surjective f
-  selfInverse⇒injective  : SelfInverse f → Injective f
-  selfInverse⇒bijective  : SelfInverse f → Bijective f
-
-  comm+idˡ⇒id              : Commutative _•_ → LeftIdentity  e _•_ → Identity e _•_
-  comm+idʳ⇒id              : Commutative _•_ → RightIdentity e _•_ → Identity e _•_
-  comm+zeˡ⇒ze              : Commutative _•_ → LeftZero      e _•_ → Zero     e _•_
-  comm+zeʳ⇒ze              : Commutative _•_ → RightZero     e _•_ → Zero     e _•_
-  comm+invˡ⇒inv            : Commutative _•_ → LeftInverse  e _⁻¹ _•_ → Inverse e _⁻¹ _•_
-  comm+invʳ⇒inv            : Commutative _•_ → RightInverse e _⁻¹ _•_ → Inverse e _⁻¹ _•_
-  comm+distrˡ⇒distr        : Commutative _•_ → _•_ DistributesOverˡ _◦_ → _•_ DistributesOver _◦_
-  comm+distrʳ⇒distr        : Commutative _•_ → _•_ DistributesOverʳ _◦_ → _•_ DistributesOver _◦_
-  distrib+absorbs⇒distribˡ : Associative _•_ → Commutative _◦_ → _•_ Absorbs _◦_ → _◦_ Absorbs _•_ → _◦_ DistributesOver _•_ → _•_ DistributesOverˡ _◦_
-  ```
-
-* Added new functions to `Algebra.Construct.DirectProduct`:
-  ```agda
-  rawSemiring : RawSemiring a ℓ₁ → RawSemiring b ℓ₂ → RawSemiring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  rawRing : RawRing a ℓ₁ → RawRing b ℓ₂ → RawRing (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  semiringWithoutAnnihilatingZero : SemiringWithoutAnnihilatingZero a ℓ₁ →
-                                    SemiringWithoutAnnihilatingZero b ℓ₂ →
-                                    SemiringWithoutAnnihilatingZero (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  semiring : Semiring a ℓ₁ → Semiring b ℓ₂ → Semiring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  commutativeSemiring : CommutativeSemiring a ℓ₁ → CommutativeSemiring b ℓ₂ →
-                        CommutativeSemiring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  ring : Ring a ℓ₁ → Ring b ℓ₂ → Ring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  commutativeRing : CommutativeRing a ℓ₁ → CommutativeRing b ℓ₂ →
-                    CommutativeRing (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  rawQuasigroup : RawQuasigroup a ℓ₁ → RawQuasigroup b ℓ₂ →
-                  RawQuasigroup (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  rawLoop : RawLoop a ℓ₁ → RawLoop b ℓ₂ → RawLoop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  unitalMagma : UnitalMagma a ℓ₁ → UnitalMagma b ℓ₂ →
-                UnitalMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  invertibleMagma : InvertibleMagma a ℓ₁ → InvertibleMagma b ℓ₂ →
-                    InvertibleMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  invertibleUnitalMagma : InvertibleUnitalMagma a ℓ₁ → InvertibleUnitalMagma b ℓ₂ →
-                          InvertibleUnitalMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  quasigroup : Quasigroup a ℓ₁ → Quasigroup b ℓ₂ → Quasigroup (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  loop : Loop a ℓ₁ → Loop b ℓ₂ → Loop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  idempotentSemiring : IdempotentSemiring a ℓ₁ → IdempotentSemiring b ℓ₂ →
-                       IdempotentSemiring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  idempotentMagma : IdempotentMagma a ℓ₁ → IdempotentMagma b ℓ₂ →
-                    IdempotentMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  alternativeMagma : AlternativeMagma a ℓ₁ → AlternativeMagma b ℓ₂ →
-                     AlternativeMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  flexibleMagma : FlexibleMagma a ℓ₁ → FlexibleMagma b ℓ₂ →
-                  FlexibleMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  medialMagma : MedialMagma a ℓ₁ → MedialMagma b ℓ₂ → MedialMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  semimedialMagma : SemimedialMagma a ℓ₁ → SemimedialMagma b ℓ₂ →
-                    SemimedialMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  kleeneAlgebra : KleeneAlgebra a ℓ₁ → KleeneAlgebra b ℓ₂ → KleeneAlgebra (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  leftBolLoop : LeftBolLoop a ℓ₁ → LeftBolLoop b ℓ₂ → LeftBolLoop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  rightBolLoop : RightBolLoop a ℓ₁ → RightBolLoop b ℓ₂ → RightBolLoop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  middleBolLoop : MiddleBolLoop a ℓ₁ → MiddleBolLoop b ℓ₂ → MiddleBolLoop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
-  moufangLoop : MoufangLoop a ℓ₁ → MoufangLoop b ℓ₂ → MoufangLoop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
- ```
-
-* Added new functions and proofs to `Algebra.Construct.Flip.Op`:
-  ```agda
-  zero : Zero ≈ ε ∙ → Zero ≈ ε (flip ∙)
-  distributes : (≈ DistributesOver ∙) + → (≈ DistributesOver (flip ∙)) +
-  isSemiringWithoutAnnihilatingZero : IsSemiringWithoutAnnihilatingZero + * 0# 1# →
-                                      IsSemiringWithoutAnnihilatingZero + (flip *) 0# 1#
-  isSemiring : IsSemiring + * 0# 1# → IsSemiring + (flip *) 0# 1#
-  isCommutativeSemiring : IsCommutativeSemiring + * 0# 1# →
-                          IsCommutativeSemiring + (flip *) 0# 1#
-  isCancellativeCommutativeSemiring : IsCancellativeCommutativeSemiring + * 0# 1# →
-                                      IsCancellativeCommutativeSemiring + (flip *) 0# 1#
-  isIdempotentSemiring : IsIdempotentSemiring + * 0# 1# →
-                         IsIdempotentSemiring + (flip *) 0# 1#
-  isQuasiring : IsQuasiring + * 0# 1# → IsQuasiring + (flip *) 0# 1#
-  isRingWithoutOne : IsRingWithoutOne + * - 0# → IsRingWithoutOne + (flip *) - 0#
-  isNonAssociativeRing : IsNonAssociativeRing + * - 0# 1# →
-                         IsNonAssociativeRing + (flip *) - 0# 1#
-  isRing : IsRing ≈ + * - 0# 1# → IsRing ≈ + (flip *) - 0# 1#
-  isNearring : IsNearring + * 0# 1# - → IsNearring + (flip *) 0# 1# -
-  isCommutativeRing : IsCommutativeRing + * - 0# 1# →
-                      IsCommutativeRing + (flip *) - 0# 1#
-  semiringWithoutAnnihilatingZero : SemiringWithoutAnnihilatingZero a ℓ →
-                                    SemiringWithoutAnnihilatingZero a ℓ
-  commutativeSemiring : CommutativeSemiring a ℓ → CommutativeSemiring a ℓ
-  cancellativeCommutativeSemiring : CancellativeCommutativeSemiring a ℓ →
-                                  CancellativeCommutativeSemiring a ℓ
-  idempotentSemiring : IdempotentSemiring a ℓ → IdempotentSemiring a ℓ
-  quasiring : Quasiring a ℓ → Quasiring a ℓ
-  ringWithoutOne : RingWithoutOne a ℓ → RingWithoutOne a ℓ
-  nonAssociativeRing : NonAssociativeRing a ℓ → NonAssociativeRing a ℓ
-  nearring : Nearring a ℓ → Nearring a ℓ
-  ring : Ring a ℓ → Ring a ℓ
-  commutativeRing : CommutativeRing a ℓ → CommutativeRing a ℓ
-  ```
-
-* Added new definition to `Algebra.Definitions`:
-  ```agda
-  SelfInverse : Op₁ A → Set _
-  
-  LeftDividesˡ  : Op₂ A → Op₂ A → Set _
-  LeftDividesʳ  : Op₂ A → Op₂ A → Set _
-  RightDividesˡ : Op₂ A → Op₂ A → Set _
-  RightDividesʳ : Op₂ A → Op₂ A → Set _
-  LeftDivides   : Op₂ A → Op₂ A → Set _
-  RightDivides  : Op₂ A → Op₂ A → Set _
-
-  LeftInvertible  e _∙_ x = ∃[ x⁻¹ ] (x⁻¹ ∙ x) ≈ e
-  RightInvertible e _∙_ x = ∃[ x⁻¹ ] (x ∙ x⁻¹) ≈ e
-  Invertible      e _∙_ x = ∃[ x⁻¹ ] ((x⁻¹ ∙ x) ≈ e) × ((x ∙ x⁻¹) ≈ e)
-  StarRightExpansive e _+_ _∙_ _⁻* = ∀ x → (e + (x ∙ (x ⁻*))) ≈ (x ⁻*)
-  StarLeftExpansive e _+_ _∙_ _⁻* = ∀ x →  (e + ((x ⁻*) ∙ x)) ≈ (x ⁻*)
-  StarExpansive e _+_ _∙_ _* = (StarLeftExpansive e _+_ _∙_ _*) × (StarRightExpansive e _+_ _∙_ _*)
-  StarLeftDestructive _+_ _∙_ _* = ∀ a b x → (b + (a ∙ x)) ≈ x → ((a *) ∙ b) ≈ x
-  StarRightDestructive _+_ _∙_ _* = ∀ a b x → (b + (x ∙ a)) ≈ x → (b ∙ (a *)) ≈ x
-  StarDestructive _+_ _∙_ _* = (StarLeftDestructive _+_ _∙_ _*) × (StarRightDestructive _+_ _∙_ _*)
-  LeftAlternative _∙_ = ∀ x y  →  ((x ∙ x) ∙ y) ≈ (x ∙ (y ∙ y))
-  RightAlternative _∙_ = ∀ x y → (x ∙ (y ∙ y)) ≈ ((x ∙ y) ∙ y)
-  Alternative _∙_ = (LeftAlternative _∙_ ) × (RightAlternative _∙_)
-  Flexible _∙_ = ∀ x y → ((x ∙ y) ∙ x) ≈ (x ∙ (y ∙ x))
-  Medial _∙_ = ∀ x y u z → ((x ∙ y) ∙ (u ∙ z)) ≈ ((x ∙ u) ∙ (y ∙ z))
-  LeftSemimedial _∙_ = ∀ x y z → ((x ∙ x) ∙ (y ∙ z)) ≈ ((x ∙ y) ∙ (x ∙ z))
-  RightSemimedial _∙_ = ∀ x y z → ((y ∙ z) ∙ (x ∙ x)) ≈ ((y ∙ x) ∙ (z ∙ x))
-  Semimedial _∙_ = (LeftSemimedial _∙_) × (RightSemimedial _∙_)
-  LeftBol _∙_ = ∀ x y z → (x ∙ (y ∙ (x ∙ z))) ≈ ((x ∙ (y ∙ z)) ∙ z )
-  RightBol _∙_ = ∀ x y z → (((z ∙ x) ∙ y) ∙ x) ≈ (z ∙ ((x ∙ y) ∙ x))
-  MiddleBol _∙_ _\\_ _//_ = ∀ x y z → (x ∙ ((y ∙ z) \\ x)) ≈ ((x // z) ∙ (y \\ x))
-  ```
-
-* Added new functions to `Algebra.Definitions.RawSemiring`:
-  ```agda
-  _^[_]*_ : A → ℕ → A → A
-  _^ᵗ_     : A → ℕ → A
-  ```
-
-* `Algebra.Properties.Magma.Divisibility` now re-exports operations 
-  `_∣ˡ_`, `_∤ˡ_`, `_∣ʳ_`, `_∤ʳ_` from `Algebra.Definitions.Magma`.
-
-* Added new proofs to `Algebra.Properties.CommutativeSemigroup`:
-  ```agda
-  interchange : Interchangable _∙_ _∙_
-  xy∙xx≈x∙yxx : ∀ x y → (x ∙ y) ∙ (x ∙ x) ≈ x ∙ (y ∙ (x ∙ x))
-  leftSemimedial : LeftSemimedial _∙_
-  rightSemimedial : RightSemimedial _∙_
-  middleSemimedial : ∀ x y z → (x ∙ y) ∙ (z ∙ x) ≈ (x ∙ z) ∙ (y ∙ x)
-  semimedial : Semimedial _∙_
-  ```
-* Added new proof to `Algebra.Properties.Monoid.Mult`:
-  ```agda
-  ×-congˡ : ∀ {x} → (_× x) Preserves _≡_ ⟶ _≈_
-  ```
-
-* Added new proof to `Algebra.Properties.Monoid.Sum`:
-  ```agda
-  sum-init-last : ∀ {n} (t : Vector _ (suc n)) → sum t ≈ sum (init t) + last t
+  System.Random.Primitive
+  System.Random
   ```
 
-* Added new proofs to `Algebra.Properties.Semigroup`:
-  ```agda
-  leftAlternative : LeftAlternative _∙_
-  rightAlternative : RightAlternative _∙_
-  alternative : Alternative _∙_
-  flexible : Flexible _∙_
-  ```
+Additions to existing modules
+-----------------------------
 
-* Added new proofs to `Algebra.Properties.Semiring.Exp`:
+* Added new definitions in `Algebra.Bundles`:
   ```agda
-  ^-congʳ               : (x ^_) Preserves _≡_ ⟶ _≈_
-  y*x^m*y^n≈x^m*y^[n+1] : (x * y ≈ y * x) → y * (x ^ m * y ^ n) ≈ x ^ m * y ^ suc n
+  record SuccessorSet c ℓ : Set (suc (c ⊔ ℓ))
+  record CommutativeBand c ℓ : Set (suc (c ⊔ ℓ))
+  record IdempotentMonoid c ℓ : Set (suc (c ⊔ ℓ))
   ```
-
-* Added new proofs to `Algebra.Properties.Semiring.Mult`:
+  and additional manifest fields for sub-bundles arising from these in:
   ```agda
-  1×-identityʳ : 1 × x ≈ x
-  ×-comm-*    : x * (n × y) ≈ n × (x * y)
-  ×-assoc-*   : (n × x) * y ≈ n × (x * y)
+  IdempotentCommutativeMonoid
+  IdempotentSemiring
   ```
 
-* Added new proofs to `Algebra.Properties.Ring`:
+* Added new definition in `Algebra.Bundles.Raw`
   ```agda
-  -1*x≈-x : ∀ x → - 1# * x ≈ - x
-  x+x≈x⇒x≈0 : ∀ x → x + x ≈ x → x ≈ 0#
-  x[y-z]≈xy-xz : ∀ x y z → x * (y - z) ≈ x * y - x * z
-  [y-z]x≈yx-zx : ∀ x y z → (y - z) * x ≈ (y * x) - (z * x)
+  record RawSuccessorSet c ℓ : Set (suc (c ⊔ ℓ))
   ```
 
-* Added new definitions to `Algebra.Structures`:
+* Added new proofs in `Algebra.Construct.Terminal`:
   ```agda
-  record IsUnitalMagma (_∙_ : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
-  record IsInvertibleMagma (_∙_ : Op₂ A) (ε : A) (_⁻¹ : Op₁ A) : Set (a ⊔ ℓ)
-  record IsInvertibleUnitalMagma (_∙_ : Op₂ A) (ε : A) (⁻¹ : Op₁ A) : Set (a ⊔ ℓ)
-  record IsQuasigroup (∙ \\ // : Op₂ A) : Set (a ⊔ ℓ)
-  record IsLoop (∙ \\ // : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
-  record IsRingWithoutOne (+ * : Op₂ A) (-_ : Op₁ A) (0# : A) : Set (a ⊔ ℓ)
-  record IsIdempotentSemiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ)
-  record IsKleeneAlgebra (+ * : Op₂ A) (⋆ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ)
-  record IsQuasiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ) where
-  record IsNearring (+ * : Op₂ A) (0# 1# : A) (_⁻¹ : Op₁ A) : Set (a ⊔ ℓ) where
-  record IsIdempotentMagma (∙ : Op₂ A) : Set (a ⊔ ℓ)
-  record IsAlternativeMagma (∙ : Op₂ A) : Set (a ⊔ ℓ)
-  record IsFlexibleMagma (∙ : Op₂ A) : Set (a ⊔ ℓ)
-  record IsMedialMagma (∙ : Op₂ A) : Set (a ⊔ ℓ)
-  record IsSemimedialMagma (∙ : Op₂ A) : Set (a ⊔ ℓ)
-  record IsLeftBolLoop (∙ \\ // : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
-  record IsRightBolLoop (∙ \\ // : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
-  record IsMoufangLoop (∙ \\ // : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
-  record IsNonAssociativeRing (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ)
-  record IsMiddleBolLoop (∙ \\ // : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
-  ```
-  and the existing record `IsLattice` now provides
+  rawNearSemiring : RawNearSemiring c ℓ
+  nearSemiring    : NearSemiring c ℓ
   ```
-  ∨-isCommutativeSemigroup : IsCommutativeSemigroup ∨
-  ∧-isCommutativeSemigroup : IsCommutativeSemigroup ∧
-  ```
-  and their corresponding algebraic substructures.
 
-* Added new records to `Algebra.Morphism.Structures`:
-  ```agda
-  record IsQuasigroupHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
-  record IsQuasigroupMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
-  record IsQuasigroupIsomorphism  (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)
-  record IsLoopHomomorphism       (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
-  record IsLoopMonomorphism       (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
-  record IsLoopIsomorphism        (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)
-  record IsRingWithoutOneHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
-  record IsRingWithoutOneMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
-  record IsRingWithoutOneIsoMorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)
-  ```
+* In `Algebra.Module.Bundles`, raw bundles are now re-exported and bundles
+  consistently expose their raw counterparts.
 
-* Added new proofs in `Data.Bool.Properties`:
+* Added proofs in `Algebra.Module.Construct.DirectProduct`:
   ```agda
-  <-wellFounded : WellFounded _<_
+  rawLeftSemimodule  : RawLeftSemimodule R m ℓm → RawLeftSemimodule m′ ℓm′ → RawLeftSemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+  rawLeftModule      : RawLeftModule R m ℓm → RawLeftModule m′ ℓm′ → RawLeftModule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+  rawRightSemimodule : RawRightSemimodule R m ℓm → RawRightSemimodule m′ ℓm′ → RawRightSemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+  rawRightModule     : RawRightModule R m ℓm → RawRightModule m′ ℓm′ → RawRightModule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+  rawBisemimodule    : RawBisemimodule R m ℓm → RawBisemimodule m′ ℓm′ → RawBisemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+  rawBimodule        : RawBimodule R m ℓm → RawBimodule m′ ℓm′ → RawBimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+  rawSemimodule      : RawSemimodule R m ℓm → RawSemimodule m′ ℓm′ → RawSemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+  rawModule          : RawModule R m ℓm → RawModule m′ ℓm′ → RawModule R (m ⊔ m′) (ℓm ⊔ ℓm′)
   ```
 
-* Added new functions in `Data.Fin.Base`:
-  ```
-  finToFun  : Fin (m ^ n) → (Fin n → Fin m)
-  funToFin  : (Fin m → Fin n) → Fin (n ^ m)
-  quotient  : Fin (m * n) → Fin m
-  remainder : Fin (m * n) → Fin n
-  ```
-
-* Added new proofs in `Data.Fin.Induction`:
-  every (strict) partial order is well-founded and Noetherian.
-
+* Added proofs in `Algebra.Module.Construct.TensorUnit`:
   ```agda
-  spo-wellFounded : ∀ {r} {_⊏_ : Rel (Fin n) r} → IsStrictPartialOrder _≈_ _⊏_ → WellFounded _⊏_
-  spo-noetherian  : ∀ {r} {_⊏_ : Rel (Fin n) r} → IsStrictPartialOrder _≈_ _⊏_ → WellFounded (flip _⊏_)
+  rawLeftSemimodule  : RawLeftSemimodule _ c ℓ
+  rawLeftModule      : RawLeftModule _ c ℓ
+  rawRightSemimodule : RawRightSemimodule _ c ℓ
+  rawRightModule     : RawRightModule _ c ℓ
+  rawBisemimodule    : RawBisemimodule _ _ c ℓ
+  rawBimodule        : RawBimodule _ _ c ℓ
+  rawSemimodule      : RawSemimodule _ c ℓ
+  rawModule          : RawModule _ c ℓ
   ```
 
-* Added new definitions and proofs in `Data.Fin.Permutation`:
+* Added proofs in `Algebra.Module.Construct.Zero`:
   ```agda
-  insert         : Fin (suc m) → Fin (suc n) → Permutation m n → Permutation (suc m) (suc n)
-  insert-punchIn : insert i j π ⟨$⟩ʳ punchIn i k ≡ punchIn j (π ⟨$⟩ʳ k)
-  insert-remove  : insert i (π ⟨$⟩ʳ i) (remove i π) ≈ π
-  remove-insert  : remove i (insert i j π) ≈ π
+  rawLeftSemimodule  : RawLeftSemimodule R c ℓ
+  rawLeftModule      : RawLeftModule R c ℓ
+  rawRightSemimodule : RawRightSemimodule R c ℓ
+  rawRightModule     : RawRightModule R c ℓ
+  rawBisemimodule    : RawBisemimodule R c ℓ
+  rawBimodule        : RawBimodule R c ℓ
+  rawSemimodule      : RawSemimodule R c ℓ
+  rawModule          : RawModule R c ℓ
   ```
 
-* In `Data.Fin.Properties`:
-  the proof that an injection from a type `A` into `Fin n` induces a
-  decision procedure for `_≡_` on `A` has been generalized to other
-  equivalences over `A` (i.e. to arbitrary setoids), and renamed from
-  `eq?` to the more descriptive `inj⇒≟` and `inj⇒decSetoid`.
+* Added definitions in `Algebra.Morphism.Structures`:
+  ```agda
+  record IsSuccessorSetHomomorphism (⟦_⟧ : N₁.Carrier → N₂.Carrier) : Set _
+  record IsSuccessorSetMonomorphism (⟦_⟧ : N₁.Carrier → N₂.Carrier) : Set _
+  record IsSuccessorSetIsomorphism  (⟦_⟧ : N₁.Carrier →  N₂.Carrier) : Set _
 
-* Added new proofs in `Data.Fin.Properties`:
+  IsSemigroupHomomorphism : (A → B) → Set _
+  IsSemigroupMonomorphism : (A → B) → Set _
+  IsSemigroupIsomorphism : (A → B) → Set _
   ```
-  1↔⊤                : Fin 1 ↔ ⊤
-
-  0≢1+n              : zero ≢ suc i
-
-  ↑ˡ-injective       : i ↑ˡ n ≡ j ↑ˡ n → i ≡ j
-  ↑ʳ-injective       : n ↑ʳ i ≡ n ↑ʳ j → i ≡ j
-  finTofun-funToFin  : funToFin ∘ finToFun ≗ id
-  funTofin-funToFun  : finToFun (funToFin f) ≗ f
-  ^↔→                : Extensionality _ _ → Fin (m ^ n) ↔ (Fin n → Fin m)
-
-  toℕ-mono-<         : i < j → toℕ i ℕ.< toℕ j
-  toℕ-mono-≤         : i ≤ j → toℕ i ℕ.≤ toℕ j
-  toℕ-cancel-≤       : toℕ i ℕ.≤ toℕ j → i ≤ j
-  toℕ-cancel-<       : toℕ i ℕ.< toℕ j → i < j
-
-  toℕ-combine        : toℕ (combine i j) ≡ k ℕ.* toℕ i ℕ.+ toℕ j
-  combine-injectiveˡ : combine i j ≡ combine k l → i ≡ k
-  combine-injectiveʳ : combine i j ≡ combine k l → j ≡ l
-  combine-injective  : combine i j ≡ combine k l → i ≡ k × j ≡ l
-  combine-surjective : ∀ i → ∃₂ λ j k → combine j k ≡ i
-  combine-monoˡ-<    : i < j → combine i k < combine j l
-
-  ℕ-ℕ≡toℕ‿ℕ-         : n ℕ-ℕ i ≡ toℕ (n ℕ- i)
 
-  punchIn-mono-≤     : ∀ i (j k : Fin n) → j ≤ k → punchIn i j ≤ punchIn i k
-  punchIn-cancel-≤   : ∀ i (j k : Fin n) → punchIn i j ≤ punchIn i k → j ≤ k
-  punchOut-mono-≤    : (i≢j : i ≢ j) (i≢k : i ≢ k) → j ≤ k → punchOut i≢j ≤ punchOut i≢k
-  punchOut-cancel-≤  : (i≢j : i ≢ j) (i≢k : i ≢ k) → punchOut i≢j ≤ punchOut i≢k → j ≤ k
-
-  lower₁-injective   : lower₁ i n≢i ≡ lower₁ j n≢j → i ≡ j
-  pinch-injective    : suc i ≢ j → suc i ≢ k → pinch i j ≡ pinch i k → j ≡ k
-
-  i<1+i              : i < suc i
-
-  injective⇒≤               : ∀ {f : Fin m → Fin n} → Injective f → m ℕ.≤ n
-  <⇒notInjective            : ∀ {f : Fin m → Fin n} → n ℕ.< m → ¬ (Injective f)
-  ℕ→Fin-notInjective        : ∀ (f : ℕ → Fin n) → ¬ (Injective f)
-  cantor-schröder-bernstein : ∀ {f : Fin m → Fin n} {g : Fin n → Fin m} → Injective f → Injective g → m ≡ n
-
-  cast-is-id    : cast eq k ≡ k
-  subst-is-cast : subst Fin eq k ≡ cast eq k
-  cast-trans    : cast eq₂ (cast eq₁ k) ≡ cast (trans eq₁ eq₂) k
+* Added proof in `Algebra.Properties.AbelianGroup`:
   ```
-
-* Added new functions in `Data.Integer.Base`:
+  ⁻¹-anti-homo‿- : (x - y) ⁻¹ ≈ y - x
   ```
-  _^_ : ℤ → ℕ → ℤ
- 
-  +-0-rawGroup  : Rawgroup 0ℓ 0ℓ
-
-  *-rawMagma    : RawMagma 0ℓ 0ℓ
-  *-1-rawMonoid : RawMonoid 0ℓ 0ℓ
- ```
 
-* Added new proofs in `Data.Integer.Properties`:
+* Added proofs in `Algebra.Properties.Group`:
   ```agda
-  sign-cong′ : s₁ ◃ n₁ ≡ s₂ ◃ n₂ → s₁ ≡ s₂ ⊎ (n₁ ≡ 0 × n₂ ≡ 0)
-  ≤-⊖        : m ℕ.≤ n → n ⊖ m ≡ + (n ∸ m)
-  ∣⊖∣-≤      : m ℕ.≤ n → ∣ m ⊖ n ∣ ≡ n ∸ m
-  ∣-∣-≤      : i ≤ j → + ∣ i - j ∣ ≡ j - i
+  isQuasigroup    : IsQuasigroup _∙_ _\\_ _//_
+  quasigroup      : Quasigroup _ _
+  isLoop          : IsLoop _∙_ _\\_ _//_ ε
+  loop            : Loop _ _
 
-  i^n≡0⇒i≡0      : i ^ n ≡ 0ℤ → i ≡ 0ℤ
-  ^-identityʳ    : i ^ 1 ≡ i
-  ^-zeroˡ        : 1 ^ n ≡ 1
-  ^-*-assoc      : (i ^ m) ^ n ≡ i ^ (m ℕ.* n)
-  ^-distribˡ-+-* : i ^ (m ℕ.+ n) ≡ i ^ m * i ^ n
+  \\-leftDividesˡ  : LeftDividesˡ _∙_ _\\_
+  \\-leftDividesʳ  : LeftDividesʳ _∙_ _\\_
+  \\-leftDivides   : LeftDivides _∙_ _\\_
+  //-rightDividesˡ : RightDividesˡ _∙_ _//_
+  //-rightDividesʳ : RightDividesʳ _∙_ _//_
+  //-rightDivides  : RightDivides _∙_ _//_
 
-  ^-isMagmaHomomorphism  : IsMagmaHomomorphism  ℕ.+-rawMagma    *-rawMagma    (i ^_)
-  ^-isMonoidHomomorphism : IsMonoidHomomorphism ℕ.+-0-rawMonoid *-1-rawMonoid (i ^_)
+  ⁻¹-selfInverse  : SelfInverse _⁻¹
+  x∙y⁻¹≈ε⇒x≈y     : ∀ x y → (x ∙ y ⁻¹) ≈ ε → x ≈ y
+  x≈y⇒x∙y⁻¹≈ε     : ∀ {x y} → x ≈ y → (x ∙ y ⁻¹) ≈ ε
+  \\≗flip-//⇒comm : (∀ x y → x \\ y ≈ y // x) → Commutative _∙_
+  comm⇒\\≗flip-// : Commutative _∙_ → ∀ x y → x \\ y ≈ y // x
+  ⁻¹-anti-homo-// : (x // y) ⁻¹ ≈ y // x
+  ⁻¹-anti-homo-\\ : (x \\ y) ⁻¹ ≈ y \\ x
   ```
 
-* Added new proofs in `Data.Integer.GCD`:
+* Added new proofs in `Algebra.Properties.Loop`:
   ```agda
-  gcd-assoc : Associative gcd
-  gcd-zeroˡ : LeftZero 1ℤ gcd
-  gcd-zeroʳ : RightZero 1ℤ gcd
-  gcd-zero  : Zero 1ℤ gcd
+  identityˡ-unique : x ∙ y ≈ y → x ≈ ε
+  identityʳ-unique : x ∙ y ≈ x → y ≈ ε
+  identity-unique  : Identity x _∙_ → x ≈ ε
   ```
 
-* Added new functions in `Data.List`:
+* Added new proofs in `Algebra.Properties.Monoid.Mult`:
   ```agda
-  takeWhileᵇ   : (A → Bool) → List A → List A
-  dropWhileᵇ   : (A → Bool) → List A → List A
-  filterᵇ      : (A → Bool) → List A → List A
-  partitionᵇ   : (A → Bool) → List A → List A × List A
-  spanᵇ        : (A → Bool) → List A → List A × List A
-  breakᵇ       : (A → Bool) → List A → List A × List A
-  linesByᵇ     : (A → Bool) → List A → List (List A)
-  wordsByᵇ     : (A → Bool) → List A → List (List A)
-  derunᵇ       : (A → A → Bool) → List A → List A
-  deduplicateᵇ : (A → A → Bool) → List A → List A
+  ×-homo-0 : 0 × x ≈ 0#
+  ×-homo-1 : 1 × x ≈ x
   ```
 
-* Added new functions and definitions to `Data.List.Base`:
+* Added new proofs in `Algebra.Properties.Semiring.Mult`:
   ```agda
-  catMaybes : List (Maybe A) → List A
-  ap : List (A → B) → List A → List B
-  ++-rawMagma : Set a → RawMagma a _
-  ++-[]-rawMonoid : Set a → RawMonoid a _
+  ×-homo-0#     : 0 × x ≈ 0# * x
+  ×-homo-1#     : 1 × x ≈ 1# * x
+  idem-×-homo-* : (_*_ IdempotentOn x) → (m × x) * (n × x) ≈ (m ℕ.* n) × x
   ```
 
-* Added new proofs in `Data.List.Relation.Binary.Lex.Strict`:
+* Added new definitions to `Algebra.Structures`:
   ```agda
-  xs≮[] : ¬ xs < []
+  record IsSuccessorSet (suc# : Op₁ A) (zero# : A) : Set _
+  record IsCommutativeBand (∙ : Op₂ A) : Set _
+  record IsIdempotentMonoid (∙ : Op₂ A) (ε : A) : Set _
   ```
 
-* Added new proofs to `Data.List.Relation.Binary.Permutation.Propositional.Properties`:
+* Added new definitions in `IsGroup` record in `Algebra.Structures`:
   ```agda
-  Any-resp-[σ⁻¹∘σ] : (σ : xs ↭ ys) → (ix : Any P xs) → Any-resp-↭ (trans σ (↭-sym σ)) ix ≡ ix
-  ∈-resp-[σ⁻¹∘σ]   : (σ : xs ↭ ys) → (ix : x ∈ xs)   → ∈-resp-↭   (trans σ (↭-sym σ)) ix ≡ ix
-  ```
-
-* Added new functions in `Data.List.Relation.Unary.All`:
-  ```
-  decide :  Π[ P ∪ Q ] → Π[ All P ∪ Any Q ]
-  ```
-
-* Added new functions in `Data.List.Fresh.Relation.Unary.All`:
-  ```
-  decide :  Π[ P ∪ Q ] → Π[ All {R = R} P ∪ Any Q ]
+  x // y = x ∙ (y ⁻¹)
+  x \\ y = (x ⁻¹) ∙ y
   ```
 
-* Added new proofs to `Data.List.Membership.Propositional.Properties`:
+* In `Algebra.Structures` added new proof to `IsCancellativeCommutativeSemiring` record:
   ```agda
-  mapWith∈-id  : mapWith∈ xs (λ {x} _ → x) ≡ xs
-  map-mapWith∈ : map g (mapWith∈ xs f) ≡ mapWith∈ xs (g ∘′ f)
+  *-cancelʳ-nonZero : AlmostRightCancellative 0# *
   ```
 
-* Added new proofs to `Data.List.Membership.Setoid.Properties`:
+* In `Data.Bool.Show`:
   ```agda
-  mapWith∈-id  : mapWith∈ xs (λ {x} _ → x) ≡ xs
-  map-mapWith∈ : map g (mapWith∈ xs f) ≡ mapWith∈ xs (g ∘′ f)
+  showBit : Bool → Char
   ```
 
-* Add new proofs in `Data.List.Properties`:
+* In `Data.Container.Indexed.Core`:
   ```agda
-  ∈⇒∣product : n ∈ ns → n ∣ product ns
-  ∷ʳ-++ : xs ∷ʳ a ++ ys ≡ xs ++ a ∷ ys
-
-  concatMap-cong : f ≗ g → concatMap f ≗ concatMap g
-  concatMap-pure : concatMap [_] ≗ id
-  concatMap-map  : concatMap g (map f xs) ≡ concatMap (g ∘′ f) xs
-  map-concatMap  : map f ∘′ concatMap g ≗ concatMap (map f ∘′ g)
-
-  length-isMagmaHomomorphism : (A : Set a) → IsMagmaHomomorphism (++-rawMagma A) +-rawMagma length
-  length-isMonoidHomomorphism : (A : Set a) → IsMonoidHomomorphism (++-[]-rawMonoid A) +-0-rawMonoid length
+  Subtrees o c = (r : Response c) → X (next c r)
   ```
 
-* Added new patterns and definitions to `Data.Nat.Base`:
+* In `Data.Empty`:
   ```agda
-  pattern z<s {n}         = s≤s (z≤n {n})
-  pattern s<s {m} {n} m<n = s≤s {m} {n} m<n
-
-  pattern <′-base          = ≤′-refl
-  pattern <′-step {n} m<′n = ≤′-step {n} m<′n
-
-  _⊔′_ : ℕ → ℕ → ℕ
-  _⊓′_ : ℕ → ℕ → ℕ
-  ∣_-_∣′ : ℕ → ℕ → ℕ
-  _! : ℕ → ℕ
-
-  parity : ℕ → Parity
-  
-  +-rawMagma          : RawMagma 0ℓ 0ℓ
-  +-0-rawMonoid       : RawMonoid 0ℓ 0ℓ
-  *-rawMagma          : RawMagma 0ℓ 0ℓ
-  *-1-rawMonoid       : RawMonoid 0ℓ 0ℓ
-  +-*-rawNearSemiring : RawNearSemiring 0ℓ 0ℓ
-  +-*-rawSemiring     : RawSemiring 0ℓ 0ℓ
+  ⊥-elim-irr  : .⊥ → Whatever
   ```
 
-
-* Added new definitions and proofs to `Data.Nat.Primality`:
+* In `Data.Fin.Properties`:
   ```agda
-  Composite        : ℕ → Set
-  composite?       : Decidable composite
-  composite⇒¬prime : Composite n → ¬ Prime n
-  ¬composite⇒prime : 2 ≤ n → ¬ Composite n → Prime n
-  prime⇒¬composite : Prime n → ¬ Composite n
-  ¬prime⇒composite : 2 ≤ n → ¬ Prime n → Composite n
-  euclidsLemma     : Prime p → p ∣ m * n → p ∣ m ⊎ p ∣ n
+  nonZeroIndex : Fin n → ℕ.NonZero n
   ```
 
-* Added new proofs in `Data.Nat.Properties`:
+* In `Data.Float.Base`:
   ```agda
-  nonZero?  : Decidable NonZero
-  n≮0       : n ≮ 0
-  n+1+m≢m   : n + suc m ≢ m
-  m*n≡0⇒m≡0 : .{{_ : NonZero n}} → m * n ≡ 0 → m ≡ 0
-  n>0⇒n≢0   : n > 0 → n ≢ 0
-  m^n≢0     : .{{_ : NonZero m}} → NonZero (m ^ n)
-  m*n≢0     : .{{_ : NonZero m}} .{{_ : NonZero n}} → NonZero (m * n)
-  m≤n⇒n∸m≤n : m ≤ n → n ∸ m ≤ n
-
-  ≤-pred        : suc m ≤ suc n → m ≤ n
-  s<s-injective : ∀ {p q : m < n} → s<s p ≡ s<s q → p ≡ q
-  <-pred        : suc m < suc n → m < n
-  <-step        : m < n → m < 1 + n
-  m<1+n⇒m<n∨m≡n : m < suc n → m < n ⊎ m ≡ n
-
-  z<′s : zero <′ suc n
-  s<′s : m <′ n → suc m <′ suc n
-  <⇒<′ : m < n → m <′ n
-  <′⇒< : m <′ n → m < n
-
-  1≤n!    : 1 ≤ n !
-  _!≢0    : NonZero (n !)
-  _!*_!≢0 : NonZero (m ! * n !)
-
-  anyUpTo? : ∀ (P? : U.Decidable P) (v : ℕ) → Dec (∃ λ n → n < v × P n)
-  allUpTo? : ∀ (P? : U.Decidable P) (v : ℕ) → Dec (∀ {n} → n < v → P n)
-
-  n≤1⇒n≡0∨n≡1 : n ≤ 1 → n ≡ 0 ⊎ n ≡ 1
-
-  2^n>0 : 2 ^ n > 0
-
-  n≡⌊n+n/2⌋ : n ≡ ⌊ n + n /2⌋
-  n≡⌈n+n/2⌉ : n ≡ ⌈ n + n /2⌉
-
-  m<n⇒m<n*o : .{{_ : NonZero o}} → m < n → m < n * o
-  m<n⇒m<o*n : .{{_ : NonZero o}} → m < n → m < o * n
-  ∸-monoˡ-< : m < o → n ≤ m → m ∸ n < o ∸ n
-
-  m≤n⇒∣m-n∣≡n∸m : m ≤ n → ∣ m - n ∣ ≡ n ∸ m
-
-  ⊔≡⊔′ : m ⊔ n ≡ m ⊔′ n
-  ⊓≡⊓′ : m ⊓ n ≡ m ⊓′ n
-  ∣-∣≡∣-∣′ : ∣ m - n ∣ ≡ ∣ m - n ∣′
+  _≤_ : Rel Float _
   ```
 
-* Re-exported additional functions from `Data.Nat`:
+* In `Data.Integer.Divisibility` introduced `divides` as an explicit pattern synonym
   ```agda
-  nonZero? : Decidable NonZero
-  eq? : A ↣ ℕ → DecidableEquality A
-  ≤-<-connex : Connex _≤_ _<_
-  ≥->-connex : Connex _≥_ _>_
-  <-≤-connex : Connex _<_ _≤_
-  >-≥-connex : Connex _>_ _≥_
-  <-cmp : Trichotomous _≡_ _<_
-  anyUpTo? : (P? : Decidable P) → ∀ v → Dec (∃ λ n → n < v × P n)
-  allUpTo? : (P? : Decidable P) → ∀ v → Dec (∀ {n} → n < v → P n)
+  pattern divides k eq = Data.Nat.Divisibility.divides k eq
   ```
 
-* Added new proofs in `Data.Nat.DivMod`:
+* In `Data.Integer.Properties`:
   ```agda
-  m%n≤n           : .{{_ : NonZero n}} → m % n ≤ n
-  m*n/m!≡n/[m∸1]! : .{{_ : NonZero m}} → m * n / m ! ≡ n / (pred m) !
-
-  %-congˡ             : .⦃ _ : NonZero o ⦄ → m ≡ n → m % o ≡ n % o
-  %-congʳ             : .⦃ _ : NonZero m ⦄ .⦃ _ : NonZero n ⦄ → m ≡ n → o % m ≡ o % n
-  m≤n⇒[n∸m]%m≡n%m     : .⦃ _ : NonZero m ⦄ → m ≤ n → (n ∸ m) % m ≡ n % m
-  m*n≤o⇒[o∸m*n]%n≡o%n : .⦃ _ : NonZero n ⦄ → m * n ≤ o → (o ∸ m * n) % n ≡ o % n
-  m∣n⇒o%n%m≡o%m       : .⦃ _ : NonZero m ⦄ .⦃ _ : NonZero n ⦄ → m ∣ n → o % n % m ≡ o % m
-  m<n⇒m%n≡m           : .⦃ _ : NonZero n ⦄ → m < n → m % n ≡ m
-  m*n/o*n≡m/o         : .⦃ _ : NonZero o ⦄ ⦃ _ : NonZero (o * n) ⦄ → m * n / (o * n) ≡ m / o
-  m<n*o⇒m/o<n         : .⦃ _ : NonZero o ⦄ → m < n * o → m / o < n
-  [m∸n]/n≡m/n∸1       : .⦃ _ : NonZero n ⦄ → (m ∸ n) / n ≡ pred (m / n)
-  [m∸n*o]/o≡m/o∸n     : .⦃ _ : NonZero o ⦄ → (m ∸ n * o) / o ≡ m / o ∸ n
-  m/n/o≡m/[n*o]       : .⦃ _ : NonZero n ⦄ .⦃ _ : NonZero o ⦄ .⦃ _ : NonZero (n * o) ⦄ → m / n / o ≡ m / (n * o)
-  m%[n*o]/o≡m/o%n     : .⦃ _ : NonZero n ⦄ .⦃ _ : NonZero o ⦄ ⦃ _ : NonZero (n * o) ⦄ → m % (n * o) / o ≡ m / o % n
-  m%n*o≡m*o%[n*o]     : .⦃ _ : NonZero n ⦄ ⦃ _ : NonZero (n * o) ⦄ → m % n * o ≡ m * o % (n * o)
-
-  [m*n+o]%[p*n]≡[m*n]%[p*n]+o : ⦃ _ : NonZero (p * n) ⦄ → o < n → (m * n + o) % (p * n) ≡ (m * n) % (p * n) + o
+  ◃-nonZero : .{{_ : ℕ.NonZero n}} → NonZero (s ◃ n)
+  sign-*    : .{{NonZero (i * j)}} → sign (i * j) ≡ sign i Sign.* sign j
+  i*j≢0     : .{{_ : NonZero i}} .{{_ : NonZero j}} → NonZero (i * j)
   ```
 
-* Added new proofs in `Data.Nat.Divisibility`:
+* In `Data.List.Base` added two new functions:
   ```agda
-  n∣m*n*o       : n ∣ m * n * o
-  m*n∣⇒m∣       : m * n ∣ i → m ∣ i
-  m*n∣⇒n∣       : m * n ∣ i → n ∣ i
-  m≤n⇒m!∣n!     : m ≤ n → m ! ∣ n !
-  m/n/o≡m/[n*o] : .{{NonZero n}} .{{NonZero o}} → n * o ∣ m → (m / n) / o ≡ m / (n * o)
+  Inits.tail : List A → List (List A)
+  Tails.tail : List A → List (List A)
   ```
+  and redefined `inits` and `tails` in terms of them.
 
-* Added new proofs in `Data.Nat.GCD`:
+* In `Data.List.Membership.Propositional.Properties.Core`:
   ```agda
-  gcd-assoc     : Associative gcd
-  gcd-identityˡ : LeftIdentity 0 gcd
-  gcd-identityʳ : RightIdentity 0 gcd
-  gcd-identity  : Identity 0 gcd
-  gcd-zeroˡ     : LeftZero 1 gcd
-  gcd-zeroʳ     : RightZero 1 gcd
-  gcd-zero      : Zero 1 gcd
+  find∘∃∈-Any : (p : ∃ λ x → x ∈ xs × P x) → find (∃∈-Any p) ≡ p
+  ∃∈-Any∘find : (p : Any P xs) → ∃∈-Any (find p) ≡ p
   ```
 
-* Added new patterns in `Data.Nat.Reflection`:
+* In `Data.List.Membership.Setoid.Properties`:
   ```agda
-  pattern `ℕ     = def (quote ℕ) []
-  pattern `zero  = con (quote ℕ.zero) []
-  pattern `suc x = con (quote ℕ.suc) (x ⟨∷⟩ [])
+  reverse⁺ : x ∈ xs → x ∈ reverse xs
+  reverse⁻ : x ∈ reverse xs → x ∈ xs
   ```
 
-* Added new proofs in `Data.Parity.Properties`:
+* In `Data.List.Properties`:
   ```agda
-  suc-homo-⁻¹ : (parity (suc n)) ⁻¹ ≡ parity n
-  +-homo-+    : parity (m ℕ.+ n) ≡ parity m ℙ.+ parity n
-  *-homo-*    : parity (m ℕ.* n) ≡ parity m ℙ.* parity n
-  parity-isMagmaHomomorphism : IsMagmaHomomorphism ℕ.+-rawMagma ℙ.+-rawMagma parity
-  parity-isMonoidHomomorphism : IsMonoidHomomorphism ℕ.+-0-rawMonoid ℙ.+-0-rawMonoid parity
-  parity-isNearSemiringHomomorphism : IsNearSemiringHomomorphism ℕ.+-*-rawNearSemiring ℙ.+-*-rawNearSemiring parity
-  parity-isSemiringHomomorphism : IsSemiringHomomorphism ℕ.+-*-rawSemiring ℙ.+-*-rawSemiring parity
+  length-catMaybes       : length (catMaybes xs) ≤ length xs
+  applyUpTo-∷ʳ           : applyUpTo f n ∷ʳ f n ≡ applyUpTo f (suc n)
+  applyDownFrom-∷ʳ       : applyDownFrom (f ∘ suc) n ∷ʳ f 0 ≡ applyDownFrom f (suc n)
+  upTo-∷ʳ                : upTo n ∷ʳ n ≡ upTo (suc n)
+  downFrom-∷ʳ            : applyDownFrom suc n ∷ʳ 0 ≡ downFrom (suc n)
+  reverse-selfInverse    : SelfInverse {A = List A} _≡_ reverse
+  reverse-applyUpTo      : reverse (applyUpTo f n) ≡ applyDownFrom f n
+  reverse-upTo           : reverse (upTo n) ≡ downFrom n
+  reverse-applyDownFrom  : reverse (applyDownFrom f n) ≡ applyUpTo f n
+  reverse-downFrom       : reverse (downFrom n) ≡ upTo n
+  mapMaybe-map           : mapMaybe f ∘ map g ≗ mapMaybe (f ∘ g)
+  map-mapMaybe           : map g ∘ mapMaybe f ≗ mapMaybe (Maybe.map g ∘ f)
+  align-map              : align (map f xs) (map g ys) ≡ map (map f g) (align xs ys)
+  zip-map                : zip (map f xs) (map g ys) ≡ map (map f g) (zip xs ys)
+  unzipWith-map          : unzipWith f ∘ map g ≗ unzipWith (f ∘ g)
+  map-unzipWith          : map (map g) (map h) ∘ unzipWith f ≗ unzipWith (map g h ∘ f)
+  unzip-map              : unzip ∘ map (map f g) ≗ map (map f) (map g) ∘ unzip
+  splitAt-map            : splitAt n ∘ map f ≗ map (map f) (map f) ∘ splitAt n
+  uncons-map             : uncons ∘ map f ≗ map (map f (map f)) ∘ uncons
+  last-map               : last ∘ map f ≗ map f ∘ last
+  tail-map               : tail ∘ map f ≗ map (map f) ∘ tail
+  mapMaybe-cong          : f ≗ g → mapMaybe f ≗ mapMaybe g
+  zipWith-cong           : (∀ a b → f a b ≡ g a b) → ∀ as → zipWith f as ≗ zipWith g as
+  unzipWith-cong         : f ≗ g → unzipWith f ≗ unzipWith g
+  foldl-cong             : (∀ x y → f x y ≡ g x y) → ∀ x → foldl f x ≗ foldl g x
+  alignWith-flip         : alignWith f xs ys ≡ alignWith (f ∘ swap) ys xs
+  alignWith-comm         : f ∘ swap ≗ f → alignWith f xs ys ≡ alignWith f ys xs
+  align-flip             : align xs ys ≡ map swap (align ys xs)
+  zip-flip               : zip xs ys ≡ map swap (zip ys xs)
+  unzipWith-swap         : unzipWith (swap ∘ f) ≗ swap ∘ unzipWith f
+  unzip-swap             : unzip ∘ map swap ≗ swap ∘ unzip
+  take-take              : take n (take m xs) ≡ take (n ⊓ m) xs
+  take-drop              : take n (drop m xs) ≡ drop m (take (m + n) xs)
+  zip-unzip              : uncurry′ zip ∘ unzip ≗ id
+  unzipWith-zipWith      : f ∘ uncurry′ g ≗ id →
+                           length xs ≡ length ys →
+                           unzipWith f (zipWith g xs ys) ≡ (xs , ys)
+  unzip-zip              : length xs ≡ length ys → unzip (zip xs ys) ≡ (xs , ys)
+  mapMaybe-++            : mapMaybe f (xs ++ ys) ≡ mapMaybe f xs ++ mapMaybe f ys
+  unzipWith-++           : unzipWith f (xs ++ ys) ≡
+                           zip _++_ _++_ (unzipWith f xs) (unzipWith f ys)
+  catMaybes-concatMap    : catMaybes ≗ concatMap fromMaybe
+  catMaybes-++           : catMaybes (xs ++ ys) ≡ catMaybes xs ++ catMaybes ys
+  map-catMaybes          : map f ∘ catMaybes ≗ catMaybes ∘ map (Maybe.map f)
+  Any-catMaybes⁺         : Any (M.Any P) xs → Any P (catMaybes xs)
+  mapMaybeIsInj₁∘mapInj₁ : mapMaybe isInj₁ (map inj₁ xs) ≡ xs
+  mapMaybeIsInj₁∘mapInj₂ : mapMaybe isInj₁ (map inj₂ xs) ≡ []
+  mapMaybeIsInj₂∘mapInj₂ : mapMaybe isInj₂ (map inj₂ xs) ≡ xs
+  mapMaybeIsInj₂∘mapInj₁ : mapMaybe isInj₂ (map inj₁ xs) ≡ []
+  ```
+
+* In `Data.List.Relation.Binary.Pointwise.Base`:
+  ```agda
+  unzip : Pointwise (R ; S) ⇒ (Pointwise R ; Pointwise S)
+  ```
+
+* In `Data.List.Relation.Binary.Sublist.Setoid`:
+  ```agda
+  ⊆-upper-bound : ∀ {xs ys zs} (τ : xs ⊆ zs) (σ : ys ⊆ zs) → UpperBound τ σ
+  ```
+
+* In `Data.List.Relation.Binary.Sublist.Setoid.Properties`:
+  ```agda
+  ⊆-trans-idˡ   : (trans-reflˡ : ∀ {x y} (p : x ≈ y) → trans ≈-refl p ≡ p) →
+                  (pxs : xs ⊆ ys) → ⊆-trans ⊆-refl pxs ≡ pxs
+  ⊆-trans-idʳ   : (trans-reflʳ : ∀ {x y} (p : x ≈ y) → trans p ≈-refl ≡ p) →
+                  (pxs : xs ⊆ ys) → ⊆-trans pxs ⊆-refl ≡ pxs
+  ⊆-trans-assoc : (≈-assoc : ∀ {w x y z} (p : w ≈ x) (q : x ≈ y) (r : y ≈ z) →
+                             trans p (trans q r) ≡ trans (trans p q) r) →
+                  (ps : as ⊆ bs) (qs : bs ⊆ cs) (rs : cs ⊆ ds) →
+                  ⊆-trans ps (⊆-trans qs rs) ≡ ⊆-trans (⊆-trans ps qs) rs
+  ```
+
+* In `Data.List.Relation.Unary.All`:
+  ```agda
+  universal-U : Universal (All U)
   ```
 
-* Added new rounding functions in `Data.Rational.Base`:
+* In `Data.List.Relation.Unary.All.Properties`:
   ```agda
-  floor ceiling truncate round ⌊_⌋ ⌈_⌉ [_] : ℚ → ℤ
-  fracPart : ℚ → ℚ
+  All-catMaybes⁺ : All (Maybe.All P) xs → All P (catMaybes xs)
+  Any-catMaybes⁺ : All (Maybe.Any P) xs → All P (catMaybes xs)
   ```
 
-* Added new definitions and proofs in `Data.Rational.Properties`:
+* In `Data.List.Relation.Unary.AllPairs.Properties`:
   ```agda
-  ↥ᵘ-toℚᵘ : ↥ᵘ (toℚᵘ p) ≡ ↥ p
-  ↧ᵘ-toℚᵘ : ↧ᵘ (toℚᵘ p) ≡ ↧ p
-
-  _≥?_ : Decidable _≥_
-  _>?_ : Decidable _>_
-
-  +-*-rawNearSemiring                 : RawNearSemiring 0ℓ 0ℓ
-  +-*-rawSemiring                     : RawSemiring 0ℓ 0ℓ
-  toℚᵘ-isNearSemiringHomomorphism-+-* : IsNearSemiringHomomorphism +-*-rawNearSemiring ℚᵘ.+-*-rawNearSemiring toℚᵘ
-  toℚᵘ-isNearSemiringMonomorphism-+-* : IsNearSemiringMonomorphism +-*-rawNearSemiring ℚᵘ.+-*-rawNearSemiring toℚᵘ
-  toℚᵘ-isSemiringHomomorphism-+-*     : IsSemiringHomomorphism     +-*-rawSemiring     ℚᵘ.+-*-rawSemiring     toℚᵘ
-  toℚᵘ-isSemiringMonomorphism-+-*     : IsSemiringMonomorphism     +-*-rawSemiring     ℚᵘ.+-*-rawSemiring     toℚᵘ
-
-  pos⇒nonZero       : .{{Positive p}} → NonZero p
-  neg⇒nonZero       : .{{Negative p}} → NonZero p
-  nonZero⇒1/nonZero : .{{_ : NonZero p}} → NonZero (1/ p)
+  catMaybes⁺ : AllPairs (Pointwise R) xs → AllPairs R (catMaybes xs)
+  tabulate⁺-< : (i < j → R (f i) (f j)) → AllPairs R (tabulate f)
   ```
 
-* Added new rounding functions in `Data.Rational.Unnormalised.Base`:
+* In `Data.List.Relation.Unary.Any.Properties`:
   ```agda
-  floor ceiling truncate round ⌊_⌋ ⌈_⌉ [_] : ℚᵘ → ℤ
-  fracPart : ℚᵘ → ℚᵘ
+  map-cong : (f g : P ⋐ Q) → (∀ {x} (p : P x) → f p ≡ g p) →
+             (p : Any P xs) → Any.map f p ≡ Any.map g p
   ```
 
-* Added new definitions in `Data.Rational.Unnormalised.Properties`:
+* Added new proofs to `Data.List.Relation.Binary.Permutation.Propositional.Properties`:
   ```agda
-  +-*-rawNearSemiring : RawNearSemiring 0ℓ 0ℓ
-  +-*-rawSemiring     : RawSemiring 0ℓ 0ℓ
-
-  ≰⇒≥ : _≰_ ⇒ _≥_
-
-  _≥?_ : Decidable _≥_
-  _>?_ : Decidable _>_
-
-  *-mono-≤-nonNeg   : .{{_ : NonNegative p}} .{{_ : NonNegative r}} → p ≤ q → r ≤ s → p * r ≤ q * s
-  *-mono-<-nonNeg   : .{{_ : NonNegative p}} .{{_ : NonNegative r}} → p < q → r < s → p * r < q * s
-  1/-antimono-≤-pos : .{{_ : Positive p}}    .{{_ : Positive q}}    → p ≤ q → 1/ q ≤ 1/ p
-  ⊓-mono-<          : _⊓_ Preserves₂ _<_ ⟶ _<_ ⟶ _<_
-  ⊔-mono-<          : _⊔_ Preserves₂ _<_ ⟶ _<_ ⟶ _<_
-
-  pos⇒nonZero          : .{{_ : Positive p}} → NonZero p
-  neg⇒nonZero          : .{{_ : Negative p}} → NonZero p
-  pos+pos⇒pos          : .{{_ : Positive p}}    .{{_ : Positive q}}    → Positive (p + q)
-  nonNeg+nonNeg⇒nonNeg : .{{_ : NonNegative p}} .{{_ : NonNegative q}} → NonNegative (p + q)
-  pos*pos⇒pos          : .{{_ : Positive p}}    .{{_ : Positive q}}    → Positive (p * q)
-  nonNeg*nonNeg⇒nonNeg : .{{_ : NonNegative p}} .{{_ : NonNegative q}} → NonNegative (p * q)
-  pos⊓pos⇒pos          : .{{_ : Positive p}}    .{{_ : Positive q}}    → Positive (p ⊓ q)
-  pos⊔pos⇒pos          : .{{_ : Positive p}}    .{{_ : Positive q}}    → Positive (p ⊔ q)
-  1/nonZero⇒nonZero    : .{{_ : NonZero p}} → NonZero (1/ p)
+  product-↭   : product Preserves _↭_ ⟶ _≡_
+  catMaybes-↭ : xs ↭ ys → catMaybes xs ↭ catMaybes ys
+  mapMaybe-↭  : xs ↭ ys → mapMaybe f xs ↭ mapMaybe f ys
   ```
 
-* Added new functions to `Data.Product.Nary.NonDependent`:
+* Added new proofs to `Data.List.Relation.Binary.Permutation.Setoid.Properties.Maybe`:
   ```agda
-  zipWith : (∀ k → Projₙ as k → Projₙ bs k → Projₙ cs k) →
-            Product n as → Product n bs → Product n cs
+  catMaybes-↭ : xs ↭ ys → catMaybes xs ↭ catMaybes ys
+  mapMaybe-↭  : xs ↭ ys → mapMaybe f xs ↭ mapMaybe f ys
   ```
 
-* Added new proof to `Data.Product.Properties`:
+* In `Data.List.Relation.Binary.Subset.Setoid.Properties`:
   ```agda
-  map-cong : f ≗ g → h ≗ i → map f h ≗ map g i
-  ```
+  map⁺ : f Preserves _≈_ ⟶ _≈′_ → as ⊆ bs → map f as ⊆′ map f bs
 
-* Added new definitions to `Data.Product.Properties` and
-  `Function.Related.TypeIsomorphisms` for convenience:
-  ```
-  Σ-≡,≡→≡ : (∃ λ (p : proj₁ p₁ ≡ proj₁ p₂) → subst B p (proj₂ p₁) ≡ proj₂ p₂) → p₁ ≡ p₂
-  Σ-≡,≡←≡ : p₁ ≡ p₂ → (∃ λ (p : proj₁ p₁ ≡ proj₁ p₂) → subst B p (proj₂ p₁) ≡ proj₂ p₂)
-  ×-≡,≡→≡ : (proj₁ p₁ ≡ proj₁ p₂ × proj₂ p₁ ≡ proj₂ p₂) → p₁ ≡ p₂
-  ×-≡,≡←≡ : p₁ ≡ p₂ → (proj₁ p₁ ≡ proj₁ p₂ × proj₂ p₁ ≡ proj₂ p₂)
+  reverse-selfAdjoint : as ⊆ reverse bs → reverse as ⊆ bs
+  reverse⁺            : as ⊆ bs → reverse as ⊆ reverse bs
+  reverse⁻            : reverse as ⊆ reverse bs → as ⊆ bs
   ```
 
-* Added new proof to `Data.Product.Relation.Binary.Lex.Strict`
+* Added new proofs to `Data.List.Relation.Binary.Sublist.Propositional.Slice`:
   ```agda
-  ×-respectsʳ : Transitive _≈₁_ →
-                _<₁_ Respectsʳ _≈₁_ → _<₂_ Respectsʳ _≈₂_ → _<ₗₑₓ_ Respectsʳ _≋_ 
-  ×-respectsˡ : Symmetric _≈₁_ → Transitive _≈₁_ →
-                 _<₁_ Respectsˡ _≈₁_ → _<₂_ Respectsˡ _≈₂_ → _<ₗₑₓ_ Respectsˡ _≋_ 
-  ×-wellFounded' : Symmetric  _≈₁_ → Transitive _≈₁_ → _<₁_ Respectsʳ _≈₁_ → 
-                   WellFounded _<₁_ → WellFounded _<₂_ → WellFounded _<ₗₑₓ_
+  ⊆-upper-bound-is-cospan : (τ₁ : xs ⊆ zs) (τ₂ : ys ⊆ zs) → IsCospan (⊆-upper-bound τ₁ τ₂)
+  ⊆-upper-bound-cospan    : (τ₁ : xs ⊆ zs) (τ₂ : ys ⊆ zs) → Cospan τ₁ τ₂
   ```
 
-* Added new definitions to `Data.Sign.Base`:
+* In `Data.List.Relation.Ternary.Appending.Setoid.Properties`:
   ```agda
-  *-rawMagma : RawMagma 0ℓ 0ℓ
-  *-1-rawMonoid : RawMonoid 0ℓ 0ℓ
-  *-1-rawGroup : RawGroup 0ℓ 0ℓ
+  through→ : ∃[ xs ] Pointwise _≈_ as xs × Appending xs bs cs →
+             ∃[ ys ] Appending as bs ys × Pointwise _≈_ ys cs
+  through← : ∃[ ys ] Appending as bs ys × Pointwise _≈_ ys cs →
+             ∃[ xs ] Pointwise _≈_ as xs × Appending xs bs cs
+  assoc→   : ∃[ xs ] Appending as bs xs × Appending xs cs ds →
+             ∃[ ys ] Appending bs cs ys × Appending as ys ds
   ```
 
-* Added new proofs to `Data.Sign.Properties`:
+* In `Data.List.Relation.Ternary.Appending.Properties`:
   ```agda
-  *-inverse : Inverse + id _*_
-  *-isCommutativeSemigroup : IsCommutativeSemigroup _*_
-  *-isCommutativeMonoid : IsCommutativeMonoid _*_ +
-  *-isGroup : IsGroup _*_ + id
-  *-isAbelianGroup : IsAbelianGroup _*_ + id
-  *-commutativeSemigroup : CommutativeSemigroup 0ℓ 0ℓ
-  *-commutativeMonoid : CommutativeMonoid 0ℓ 0ℓ
-  *-group : Group 0ℓ 0ℓ
-  *-abelianGroup : AbelianGroup 0ℓ 0ℓ
-  ≡-isDecEquivalence : IsDecEquivalence _≡_
+  through→ : (R ⇒ (S ; T)) → ((U ; V) ⇒ (W ; T)) →
+                 ∃[ xs ] Pointwise U as xs × Appending V R xs bs cs →
+                         ∃[ ys ] Appending W S as bs ys × Pointwise T ys cs
+  through← : ((R ; S) ⇒ T) → ((U ; S) ⇒ (V ; W)) →
+                 ∃[ ys ] Appending U R as bs ys × Pointwise S ys cs →
+                         ∃[ xs ] Pointwise V as xs × Appending W T xs bs cs
+  assoc→ :   (R ⇒ (S ; T)) → ((U ; V) ⇒ (W ; T)) → ((Y ; V) ⇒ X) →
+                     ∃[ xs ] Appending Y U as bs xs × Appending V R xs cs ds →
+                         ∃[ ys ] Appending W S bs cs ys × Appending X T as ys ds
+  assoc← :   ((S ; T) ⇒ R) → ((W ; T) ⇒ (U ; V)) → (X ⇒ (Y ; V)) →
+             ∃[ ys ] Appending W S bs cs ys × Appending X T as ys ds →
+                         ∃[ xs ] Appending Y U as bs xs × Appending V R xs cs ds
   ```
 
-* Added new functions in `Data.String.Base`:
+* In `Data.List.NonEmpty.Base`:
   ```agda
-  wordsByᵇ : (Char → Bool) → String → List String
-  linesByᵇ : (Char → Bool) → String → List String
-  ```
-
-* Added new proofs in `Data.String.Properties`:
-  ```
-  ≤-isDecTotalOrder-≈ : IsDecTotalOrder _≈_ _≤_
-  ≤-decTotalOrder-≈   :  DecTotalOrder _ _ _
-  ```
-* Added new definitions in `Data.Sum.Properties`:
-  ```
-  swap-↔ : (A ⊎ B) ↔ (B ⊎ A)
+  inits : List A → List⁺ (List A)
+  tails : List A → List⁺ (List A)
   ```
 
-* Added new proofs in `Data.Sum.Properties`:
-  ```
-  map-assocˡ : (f : A → C) (g : B → D) (h : C → F) →
-    map (map f g) h ∘ assocˡ ≗ assocˡ ∘ map f (map g h)
-  map-assocʳ : (f : A → C) (g : B → D) (h : C → F) →
-    map f (map g h) ∘ assocʳ ≗ assocʳ ∘ map (map f g) h
-  ```
-
-* Adden new proof in `Data.Sum.Relation.Binary.LeftOrder` :
-  ```
-  ⊎-<-wellFounded : WellFounded ∼₁ → WellFounded ∼₂ → WellFounded (∼₁ ⊎-< ∼₂)
-  ```
-* Adden new proof in `Data.Sum.Relation.Binary.Pointwise` :
-  ```
-  ⊎-wellFounded : WellFounded ∼₁ → WellFounded ∼₂ → WellFounded (Pointwise ∼₁ ∼₂)
-  ```
-
-* Made `Map` public in `Data.Tree.AVL.IndexedMap`
-
-* Added new definitions in `Data.Vec.Base`:
+* In `Data.List.NonEmpty.Properties`:
   ```agda
-  truncate : m ≤ n → Vec A n → Vec A m
-  pad      : m ≤ n → A → Vec A m → Vec A n
-
-  FoldrOp A B = ∀ {n} → A → B n → B (suc n)
-  FoldlOp A B = ∀ {n} → B n → A → B (suc n)
-
-  foldr′ : (A → B → B) → B → Vec A n → B
-  foldl′ : (B → A → B) → B → Vec A n → B
-  countᵇ : (A → Bool) → Vec A n → ℕ
-
-  iterate : (A → A) → A → Vec A n
-
-  diagonal           : Vec (Vec A n) n → Vec A n
-  DiagonalBind._>>=_ : Vec A n → (A → Vec B n) → Vec B n
-  join               : Vec (Vec A n) n → Vec A n
-
-  _ʳ++_              : Vec A m → Vec A n → Vec A (m + n)
-
-  cast : .(eq : m ≡ n) → Vec A m → Vec A n
+  toList-inits : toList ∘ List⁺.inits ≗ List.inits
+  toList-tails : toList ∘ List⁺.tails ≗ List.tails
   ```
 
-* Added new instance in `Data.Vec.Categorical`:
+* In `Data.Maybe.Relation.Binary.Pointwise`:
   ```agda
-  monad : RawMonad (λ (A : Set a) → Vec A n)
+  pointwise⊆any : Pointwise R (just x) ⊆ Any (R x)
   ```
 
-* Added new proofs in `Data.Vec.Properties`:
+* In `Data.Nat.Divisibility`:
   ```agda
-  padRight-refl      : padRight ≤-refl a xs ≡ xs
-  padRight-replicate : replicate a ≡ padRight le a (replicate a)
-  padRight-trans     : padRight (≤-trans m≤n n≤p) a xs ≡ padRight n≤p a (padRight m≤n a xs)
-
-  truncate-refl     : truncate ≤-refl xs ≡ xs
-  truncate-trans    : truncate (≤-trans m≤n n≤p) xs ≡ truncate m≤n (truncate n≤p xs)
-  truncate-padRight : truncate m≤n (padRight m≤n a xs) ≡ xs
-
-  map-const    : map (const x) xs ≡ replicate x
-  map-⊛        : map f xs ⊛ map g xs ≡ map (f ˢ g) xs
-  map-++       : map f (xs ++ ys) ≡ map f xs ++ map f ys
-  map-is-foldr : map f ≗ foldr (Vec B) (λ x ys → f x ∷ ys) []
-  map-∷ʳ       : map f (xs ∷ʳ x) ≡ (map f xs) ∷ʳ (f x)
-  map-reverse  : map f (reverse xs) ≡ reverse (map f xs)
-  map-ʳ++      : map f (xs ʳ++ ys) ≡ map f xs ʳ++ map f ys
-
-  lookup-concat : lookup (concat xss) (combine i j) ≡ lookup (lookup xss i) j
-
-  ⊛-is->>=    : fs ⊛ xs ≡ fs >>= flip map xs
-  lookup-⊛*   : lookup (fs ⊛* xs) (combine i j) ≡ (lookup fs i $ lookup xs j)
-  ++-is-foldr : xs ++ ys ≡ foldr ((Vec A) ∘ (_+ n)) _∷_ ys xs
-  []≔-++-↑ʳ   : (xs ++ ys) [ m ↑ʳ i ]≔ y ≡ xs ++ (ys [ i ]≔ y)
-  unfold-ʳ++  : xs ʳ++ ys ≡ reverse xs ++ ys
-
-  foldl-universal : ∀ (h : ∀ {c} (C : ℕ → Set c) (g : FoldlOp A C) (e : C zero) → ∀ {n} → Vec A n → C n) →
-                    (∀ ... → h C g e [] ≡ e) →
-                    (∀ ... → h C g e ∘ (x ∷_) ≗ h (C ∘ suc) g (g e x)) →
-                    h B f e ≗ foldl B f e
-  foldl-fusion  : h d ≡ e → (∀ ... → h (f b x) ≡ g (h b) x) → h ∘ foldl B f d ≗ foldl C g e
-  foldl-∷ʳ      : foldl B f e (ys ∷ʳ y) ≡ f (foldl B f e ys) y
-  foldl-[]      : foldl B f e [] ≡ e
-  foldl-reverse : foldl B {n} f e ∘ reverse ≗ foldr B (flip f) e
+  quotient≢0       : m ∣ n → .{{NonZero n}} → NonZero quotient
 
-  foldr-[]      : foldr B f e [] ≡ e
-  foldr-++      : foldr B f e (xs ++ ys) ≡ foldr (B ∘ (_+ n)) f (foldr B f e ys) xs
-  foldr-∷ʳ      : foldr B f e (ys ∷ʳ y) ≡ foldr (B ∘ suc) f (f y e) ys
-  foldr-ʳ++     : foldr B f e (xs ʳ++ ys) ≡ foldl (B ∘ (_+ n)) (flip f) (foldr B f e ys) xs
-  foldr-reverse : foldr B f e ∘ reverse ≗ foldl B (flip f) e
+  m∣n⇒n≡quotient*m : m ∣ n → n ≡ quotient * m
+  m∣n⇒n≡m*quotient : m ∣ n → n ≡ m * quotient
+  quotient-∣       : m ∣ n → quotient ∣ n
+  quotient>1       : m ∣ n → m < n → 1 < quotient
+  quotient-<       : m ∣ n → .{{NonTrivial m}} → .{{NonZero n}} → quotient < n
+  n/m≡quotient     : m ∣ n → .{{_ : NonZero m}} → n / m ≡ quotient
 
-  ∷ʳ-injective  : xs ∷ʳ x ≡ ys ∷ʳ y → xs ≡ ys × x ≡ y
-  ∷ʳ-injectiveˡ : xs ∷ʳ x ≡ ys ∷ʳ y → xs ≡ ys
-  ∷ʳ-injectiveʳ : xs ∷ʳ x ≡ ys ∷ʳ y → x ≡ y
+  m/n≡0⇒m<n    : .{{_ : NonZero n}} → m / n ≡ 0 → m < n
+  m/n≢0⇒n≤m    : .{{_ : NonZero n}} → m / n ≢ 0 → n ≤ m
 
-  reverse-∷          : reverse (x ∷ xs) ≡ reverse xs ∷ʳ x
-  reverse-involutive : Involutive _≡_ reverse
-  reverse-reverse    : reverse xs ≡ ys → reverse ys ≡ xs
-  reverse-injective  : reverse xs ≡ reverse ys → xs ≡ ys
-
-  transpose-replicate : transpose (replicate xs) ≡ map replicate xs
-
-  toList-cast   : toList (cast eq xs) ≡ toList xs
-  cast-is-id    : cast eq xs ≡ xs
-  subst-is-cast : subst (Vec A) eq xs ≡ cast eq xs
-  cast-trans    : cast eq₂ (cast eq₁ xs) ≡ cast (trans eq₁ eq₂) xs
-  map-cast      : map f (cast eq xs) ≡ cast eq (map f xs)
-  lookup-cast   : lookup (cast eq xs) (Fin.cast eq i) ≡ lookup xs i
-  lookup-cast₁  : lookup (cast eq xs) i ≡ lookup xs (Fin.cast (sym eq) i)
-  lookup-cast₂  : lookup xs (Fin.cast eq i) ≡ lookup (cast (sym eq) xs) i
+  nonZeroDivisor : DivMod dividend divisor → NonZero divisor
   ```
 
-* Added new proofs in `Data.Vec.Functional.Properties`:
-  ```
-  map-updateAt : f ∘ g ≗ h ∘ f → map f (updateAt i g xs) ≗ updateAt i h (map f xs)
-  ```
-
-* Added new proofs in `Data.Vec.Relation.Binary.Lex.Strict`:
+* Added new proofs to `Data.Nat.Primality`:
   ```agda
-  xs≮[] : ∀ {n} (xs : Vec A n) → ¬ xs < []
-  <-respectsˡ : IsPartialEquivalence _≈_ → _≺_ Respectsˡ _≈_ →
-                ∀ {m n} → _Respectsˡ_ (_<_ {m} {n}) _≋_
-  <-respectsʳ : IsPartialEquivalence _≈_ → _≺_ Respectsʳ _≈_ →
-                ∀ {m n} → _Respectsʳ_ (_<_ {m} {n}) _≋_
-  <-wellFounded : Symmetric _≈_ →  Transitive _≈_ → _≺_ Respectsʳ _≈_ → WellFounded _≺_ → 
-                  ∀ {n} → WellFounded (_<_ {n})
-```
-
-* Added new functions in `Data.Vec.Relation.Unary.Any`:
-  ```
-  lookup : Any P xs → A
-  ```
-
-* Added new functions in `Data.Vec.Relation.Unary.All`:
-  ```
-  decide :  Π[ P ∪ Q ] → Π[ All P ∪ Any Q ]
-  ```
-
-* Added vector associativity proof to  `Data.Vec.Relation.Binary.Equality.Setoid`:
-  ```
-  ++-assoc : (xs ++ ys) ++ zs ≋ xs ++ (ys ++ zs)
+  rough∧square>⇒prime : .{{NonTrivial n}} → m Rough n → m * m > n → Prime n
+  productOfPrimes≢0 : All Prime as → NonZero (product as)
+  productOfPrimes≥1 : All Prime as → product as ≥ 1
   ```
 
-* Added new functions in `Effect.Monad.State`:
-  ```
-  runState  : State s a → s → a × s
-  evalState : State s a → s → a
-  execState : State s a → s → s
-  ```
-
-* Added new proofs in `Function.Construct.Symmetry`:
-  ```
-  bijective     : Bijective ≈₁ ≈₂ f → Symmetric ≈₂ → Transitive ≈₂ → Congruent ≈₁ ≈₂ f → Bijective ≈₂ ≈₁ f⁻¹
-  isBijection   : IsBijection ≈₁ ≈₂ f → Congruent ≈₂ ≈₁ f⁻¹ → IsBijection ≈₂ ≈₁ f⁻¹
-  isBijection-≡ : IsBijection ≈₁ _≡_ f → IsBijection _≡_ ≈₁ f⁻¹
-  bijection     : Bijection R S → Congruent IB.Eq₂._≈_ IB.Eq₁._≈_ f⁻¹ → Bijection S R
-  bijection-≡   : Bijection R (setoid B) → Bijection (setoid B) R
-  sym-⤖        : A ⤖ B → B ⤖ A
-  ```
-
-* Added new operations in `Function.Strict`:
-  ```
-  _!|>_  : (a : A) → (∀ a → B a) → B a
-  _!|>′_ : A → (A → B) → B
-  ```
-
-* Added new definition to the `Surjection` module in `Function.Related.Surjection`:
-  ```
-  f⁻ = proj₁ ∘ surjective
-  ```
-
-* Added new operations in `IO`:
-  ```
-  Colist.forM  : Colist A → (A → IO B) → IO (Colist B)
-  Colist.forM′ : Colist A → (A → IO B) → IO ⊤
-
-  List.forM  : List A → (A → IO B) → IO (List B)
-  List.forM′ : List A → (A → IO B) → IO ⊤
-  ```
-
-* Added new operations in `IO.Base`:
-  ```
-  lift! : IO A → IO (Lift b A)
-  _<$_  : B → IO A → IO B
-  _=<<_ : (A → IO B) → IO A → IO B
-  _<<_  : IO B → IO A → IO B
-  lift′ : Prim.IO ⊤ → IO {a} ⊤
-
-  when   : Bool → IO ⊤ → IO ⊤
-  unless : Bool → IO ⊤ → IO ⊤
-
-  whenJust  : Maybe A → (A → IO ⊤) → IO ⊤
-  untilJust : IO (Maybe A) → IO A
-  untilRight : (A → IO (A ⊎ B)) → A → IO B
-  ```
-
-* Added new functions in `Reflection.AST.Term`:
-  ```
-  stripPis     : Term → List (String × Arg Type) × Term
-  prependLams  : List (String × Visibility) → Term → Term
-  prependHLams : List String → Term → Term
-  prependVLams : List String → Term → Term
-  ```
-
-* Added new operations in `Relation.Binary.Construct.Closure.Equivalence`:
-  ```
-  fold   : IsEquivalence _∼_ → _⟶_ ⇒ _∼_ → EqClosure _⟶_ ⇒ _∼_
-  gfold  : IsEquivalence _∼_ → _⟶_ =[ f ]⇒ _∼_ → EqClosure _⟶_ =[ f ]⇒ _∼_
-  return : _⟶_ ⇒ EqClosure _⟶_
-  join   : EqClosure (EqClosure _⟶_) ⇒ EqClosure _⟶_
-  _⋆     : _⟶₁_ ⇒ EqClosure _⟶₂_ → EqClosure _⟶₁_ ⇒ EqClosure _⟶₂_
-  ```
-
-* Added new operations in `Relation.Binary.Construct.Closure.Symmetric`:
-  ```
-  fold   : Symmetric _∼_ → _⟶_ ⇒ _∼_ → SymClosure _⟶_ ⇒ _∼_
-  gfold  : Symmetric _∼_ → _⟶_ =[ f ]⇒ _∼_ → SymClosure _⟶_ =[ f ]⇒ _∼_
-  return : _⟶_ ⇒ SymClosure _⟶_
-  join   : SymClosure (SymClosure _⟶_) ⇒ SymClosure _⟶_
-  _⋆     : _⟶₁_ ⇒ SymClosure _⟶₂_ → SymClosure _⟶₁_ ⇒ SymClosure _⟶₂_
-  ```
-
-* Added new proofs to `Relation.Binary.Lattice.Properties.{Join,Meet}Semilattice`:
-  ```agda
-  isPosemigroup : IsPosemigroup _≈_ _≤_ _∨_
-  posemigroup : Posemigroup c ℓ₁ ℓ₂
-  ≈-dec⇒≤-dec : Decidable _≈_ → Decidable _≤_
-  ≈-dec⇒isDecPartialOrder : Decidable _≈_ → IsDecPartialOrder _≈_ _≤_
-  ```
-
-* Added new proofs to `Relation.Binary.Lattice.Properties.Bounded{Join,Meet}Semilattice`:
+* Added new proofs in `Data.Nat.Properties`:
   ```agda
-  isCommutativePomonoid : IsCommutativePomonoid _≈_ _≤_ _∨_ ⊥
-  commutativePomonoid : CommutativePomonoid c ℓ₁ ℓ₂
-  ```
+  m≤n+o⇒m∸n≤o    : m ≤ n + o → m ∸ n ≤ o
+  m<n+o⇒m∸n<o    : .{{NonZero o}} → m < n + o → m ∸ n < o
+  pred-cancel-≤  : pred m ≤ pred n → (m ≡ 1 × n ≡ 0) ⊎ m ≤ n
+  pred-cancel-<  : pred m < pred n → m < n
+  pred-injective : .{{NonZero m}} → .{{NonZero n}} → pred m ≡ pred n → m ≡ n
+  pred-cancel-≡  : pred m ≡ pred n → ((m ≡ 0 × n ≡ 1) ⊎ (m ≡ 1 × n ≡ 0)) ⊎ m ≡ n
 
-* Added new proofs to `Relation.Binary.Properties.Poset`:
-  ```agda
-  ≤-dec⇒≈-dec : Decidable _≤_ → Decidable _≈_
-  ≤-dec⇒isDecPartialOrder : Decidable _≤_ → IsDecPartialOrder _≈_ _≤_
+  <⇒<″          : _<_ ⇒ _<″_
+  m≤n⇒∃[o]m+o≡n : .(m ≤ n) → ∃ λ k → m + k ≡ n
+  guarded-∸≗∸   : .(m≤n : m ≤ n) → let k , _ = m≤n⇒∃[o]m+o≡n m≤n in k ≡ n ∸ m
   ```
 
-* Added new proofs in `Relation.Binary.Properties.StrictPartialOrder`:
+* Added some very-dependent map and zipWith to `Data.Product`.
   ```agda
-  >-strictPartialOrder : StrictPartialOrder s₁ s₂ s₃
-  ```
+  map-Σ : {B : A → Set b} {P : A → Set p} {Q : {x : A} → P x → B x → Set q} →
+   (f : (x : A) → B x) → (∀ {x} → (y : P x) → Q y (f x)) →
+   ((x , y) : Σ A P) → Σ (B x) (Q y)
 
-* Added new proofs in `Relation.Binary.PropositionalEquality.Properties`:
-  ```
-  subst-application′ : subst Q eq (f x p) ≡ f y (subst P eq p)
-  sym-cong : sym (cong f p) ≡ cong f (sym p)
-  ```
+  map-Σ′ : {B : A → Set b} {P : Set p} {Q : P → Set q} →
+    (f : (x : A) → B x) → ((x : P) → Q x) → ((x , y) : A × P) → B x × Q y
 
-* Added new proofs in `Relation.Binary.HeterogeneousEquality`:
-  ```
-  subst₂-removable : subst₂ _∼_ eq₁ eq₂ p ≅ p
+  zipWith : {P : A → Set p} {Q : B → Set q} {R : C → Set r} {S : (x : C) → R x → Set s}
+    (_∙_ : A → B → C) → (_∘_ : ∀ {x y} → P x → Q y → R (x ∙ y)) →
+    (_*_ : (x : C) → (y : R x) → S x y) →
+    ((a , p) : Σ A P) → ((b , q) : Σ B Q) →
+        S (a ∙ b) (p ∘ q)
   ```
 
-* Added new definitions in `Relation.Unary`:
-  ```
-  _≐_  : Pred A ℓ₁ → Pred A ℓ₂ → Set _
-  _≐′_ : Pred A ℓ₁ → Pred A ℓ₂ → Set _
-  _∖_  : Pred A ℓ₁ → Pred A ℓ₂ → Pred A _
-  ```
-
-* Added new proofs in `Relation.Unary.Properties`:
-  ```
-  ⊆-reflexive : _≐_ ⇒ _⊆_
-  ⊆-antisym : Antisymmetric _≐_ _⊆_
-  ⊆-min : Min _⊆_ ∅
-  ⊆-max : Max _⊆_ U
-  ⊂⇒⊆ : _⊂_ ⇒ _⊆_
-  ⊂-trans : Trans _⊂_ _⊂_ _⊂_
-  ⊂-⊆-trans : Trans _⊂_ _⊆_ _⊂_
-  ⊆-⊂-trans : Trans _⊆_ _⊂_ _⊂_
-  ⊂-respʳ-≐ : _⊂_ Respectsʳ _≐_
-  ⊂-respˡ-≐ : _⊂_ Respectsˡ _≐_
-  ⊂-resp-≐ : _⊂_ Respects₂ _≐_
-  ⊂-irrefl : Irreflexive _≐_ _⊂_
-  ⊂-antisym : Antisymmetric _≐_ _⊂_
-  ∅-⊆′ : (P : Pred A ℓ) → ∅ ⊆′ P
-  ⊆′-U : (P : Pred A ℓ) → P ⊆′ U
-  ⊆′-refl : Reflexive {A = Pred A ℓ} _⊆′_
-  ⊆′-reflexive : _≐′_ ⇒ _⊆′_
-  ⊆′-trans : Trans _⊆′_ _⊆′_ _⊆′_
-  ⊆′-antisym : Antisymmetric _≐′_ _⊆′_
-  ⊆′-min : Min _⊆′_ ∅
-  ⊆′-max : Max _⊆′_ U
-  ⊂′⇒⊆′ : _⊂′_ ⇒ _⊆′_
-  ⊂′-trans : Trans _⊂′_ _⊂′_ _⊂′_
-  ⊂′-⊆′-trans : Trans _⊂′_ _⊆′_ _⊂′_
-  ⊆′-⊂′-trans : Trans _⊆′_ _⊂′_ _⊂′_
-  ⊂′-respʳ-≐′ : _⊂′_ Respectsʳ _≐′_
-  ⊂′-respˡ-≐′ : _⊂′_ Respectsˡ _≐′_
-  ⊂′-resp-≐′ : _⊂′_ Respects₂ _≐′_
-  ⊂′-irrefl : Irreflexive _≐′_ _⊂′_
-  ⊂′-antisym : Antisymmetric _≐′_ _⊂′_
-  ⊆⇒⊆′ : _⊆_ ⇒ _⊆′_
-  ⊆′⇒⊆ : _⊆′_ ⇒ _⊆_
-  ⊂⇒⊂′ : _⊂_ ⇒ _⊂′_
-  ⊂′⇒⊂ : _⊂′_ ⇒ _⊂_
-  ≐-refl : Reflexive _≐_
-  ≐-sym : Sym _≐_ _≐_
-  ≐-trans : Trans _≐_ _≐_ _≐_
-  ≐′-refl : Reflexive _≐′_
-  ≐′-sym : Sym _≐′_ _≐′_
-  ≐′-trans : Trans _≐′_ _≐′_ _≐′_
-  ≐⇒≐′ : _≐_ ⇒ _≐′_
-  ≐′⇒≐ : _≐′_ ⇒ _≐_
-
-  U-irrelevant : Irrelevant {A = A} U
-  ∁-irrelevant : (P : Pred A ℓ) → Irrelevant (∁ P)
-  ```
-
-* Generalised proofs in `Relation.Unary.Properties`:
-  ```
-  ⊆-trans : Trans _⊆_ _⊆_ _⊆_
-  ```
-
-* Added new proofs in `Relation.Binary.Properties.Setoid`:
-  ```
-  ≈-isPreorder     : IsPreorder _≈_ _≈_
-  ≈-isPartialOrder : IsPartialOrder _≈_ _≈_
-
-  ≈-preorder : Preorder a ℓ ℓ
-  ≈-poset    : Poset a ℓ ℓ
-  ```
-
-* Added new definitions in `Relation.Binary.Definitions`:
-  ```
-  Cotransitive _#_ = ∀ {x y} → x # y → ∀ z → (x # z) ⊎ (z # y)
-  Tight    _≈_ _#_ = ∀ x y → (¬ x # y → x ≈ y) × (x ≈ y → ¬ x # y)
-
-  Monotonic₁         _≤_ _⊑_ f     = f Preserves _≤_ ⟶ _⊑_
-  Antitonic₁         _≤_ _⊑_ f     = f Preserves (flip _≤_) ⟶ _⊑_
-  Monotonic₂         _≤_ _⊑_ _≼_ ∙ = ∙ Preserves₂ _≤_ ⟶ _⊑_ ⟶ _≼_
-  MonotonicAntitonic _≤_ _⊑_ _≼_ ∙ = ∙ Preserves₂ _≤_ ⟶ (flip _⊑_) ⟶ _≼_
-  AntitonicMonotonic _≤_ _⊑_ _≼_ ∙ = ∙ Preserves₂ (flip _≤_) ⟶ _⊑_ ⟶ _≼_
-  Antitonic₂         _≤_ _⊑_ _≼_ ∙ = ∙ Preserves₂ (flip _≤_) ⟶ (flip _⊑_) ⟶ _≼_
-  Adjoint            _≤_ _⊑_ f g   = ∀ {x y} → (f x ⊑ y → x ≤ g y) × (x ≤ g y → f x ⊑ y)
-  ```
-
-* Added new definitions in `Relation.Binary.Bundles`:
-  ```
-  record ApartnessRelation c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  ```
-
-* Added new definitions in `Relation.Binary.Structures`:
-  ```
-  record IsApartnessRelation (_#_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
-  ```
-
-* Added new proofs to `Relation.Binary.Consequences`:
-  ```
-  sym⇒¬-sym       : Symmetric _∼_ → Symmetric _≁_
-  cotrans⇒¬-trans : Cotransitive _∼_ → Transitive _≁_
-  irrefl⇒¬-refl   : Reflexive _≈_ → Irreflexive _≈_ _∼_ →  Reflexive _≁_
-  mono₂⇒cong₂     : Symmetric ≈₁ → ≈₁ ⇒ ≤₁ → Antisymmetric ≈₂ ≤₂ → ∀ {f} →
-                    f Preserves₂ ≤₁ ⟶ ≤₁ ⟶ ≤₂ →
-                    f Preserves₂ ≈₁ ⟶ ≈₁ ⟶ ≈₂
-  ```
-
-* Added new operations in `Relation.Binary.PropositionalEquality.Properties`:
-  ```
-  J       : (B : (y : A) → x ≡ y → Set b) (p : x ≡ y) → B x refl → B y p
-  dcong   : (p : x ≡ y) → subst B p (f x) ≡ f y
-  dcong₂  : (p : x₁ ≡ x₂) → subst B p y₁ ≡ y₂ → f x₁ y₁ ≡ f x₂ y₂
-  dsubst₂ : (p : x₁ ≡ x₂) → subst B p y₁ ≡ y₂ → C x₁ y₁ → C x₂ y₂
-  ddcong₂ : (p : x₁ ≡ x₂) (q : subst B p y₁ ≡ y₂) → dsubst₂ C p q (f x₁ y₁) ≡ f x₂ y₂
-
-  isPartialOrder : IsPartialOrder _≡_ _≡_
-  poset          : Set a → Poset _ _ _
-  ```
-
-* Added new operations in `System.Exit`:
-  ```
-  isSuccess : ExitCode → Bool
-  isFailure : ExitCode → Bool
-  ```
-
-* Added new functions in `Codata.Guarded.Stream`:
-  ```
-  transpose : List (Stream A) → Stream (List A)
-  transpose⁺ : List⁺ (Stream A) → Stream (List⁺ A)
-  concat : Stream (List⁺ A) → Stream A
-  ```
+* In `Data.Rational.Properties`:
+  ```agda
+  1≢0 : 1ℚ ≢ 0ℚ
 
-* Added new proofs in `Codata.Guarded.Stream.Properties`:
-  ```
-  cong-concat : {ass bss : Stream (List⁺.List⁺ A)} → ass ≈ bss → concat ass ≈ concat bss
-  map-concat : ∀ (f : A → B) ass → map f (concat ass) ≈ concat (map (List⁺.map f) ass)
-  lookup-transpose : ∀ n (ass : List (Stream A)) → lookup n (transpose ass) ≡ List.map (lookup n) ass
-  lookup-transpose⁺ : ∀ n (ass : List⁺ (Stream A)) → lookup n (transpose⁺ ass) ≡ List⁺.map (lookup n) ass
-  ```
+  #⇒invertible : p ≢ q → Invertible 1ℚ _*_ (p - q)
+  invertible⇒# : Invertible 1ℚ _*_ (p - q) → p ≢ q
 
-* Added new corollaries in `Data.List.Membership.Setoid.Properties`:
-  ```
-  ∈-++⁺∘++⁻ : ∀ {v} xs {ys} (p : v ∈ xs ++ ys) → [ ∈-++⁺ˡ , ∈-++⁺ʳ xs ]′ (∈-++⁻ xs p) ≡ p
-  ∈-++⁻∘++⁺ : ∀ {v} xs {ys} (p : v ∈ xs ⊎ v ∈ ys) → ∈-++⁻ xs ([ ∈-++⁺ˡ , ∈-++⁺ʳ xs ]′ p) ≡ p
-  ∈-++↔ : ∀ {v xs ys} → (v ∈ xs ⊎ v ∈ ys) ↔ v ∈ xs ++ ys
-  ∈-++-comm : ∀ {v} xs ys → v ∈ xs ++ ys → v ∈ ys ++ xs
-  ∈-++-comm∘++-comm : ∀ {v} xs {ys} (p : v ∈ xs ++ ys) → ∈-++-comm ys xs (∈-++-comm xs ys p) ≡ p
-  ∈-++↔++ : ∀ {v} xs ys → v ∈ xs ++ ys ↔ v ∈ ys ++ xs
+  isHeytingCommutativeRing : IsHeytingCommutativeRing _≡_ _≢_ _+_ _*_ -_ 0ℚ 1ℚ
+  isHeytingField           : IsHeytingField _≡_ _≢_ _+_ _*_ -_ 0ℚ 1ℚ
+  heytingCommutativeRing   : HeytingCommutativeRing 0ℓ 0ℓ 0ℓ
+  heytingField             : HeytingField 0ℓ 0ℓ 0ℓ
   ```
 
-* Exposed container combinator conversion functions from `Data.Container.Combinator.Properties` separate from their correctness proofs in `Data.Container.Combinator`:
-  ```
-  to-id      : F.id A → ⟦ id ⟧ A
-  from-id    : ⟦ id ⟧ A → F.id A
-  to-const   : (A : Set s) → A → ⟦ const A ⟧ B
-  from-const : (A : Set s) → ⟦ const A ⟧ B → A
-  to-∘       : (C₁ : Container s₁ p₁) (C₂ : Container s₂ p₂) → ⟦ C₁ ⟧ (⟦ C₂ ⟧ A) → ⟦ C₁ ∘ C₂ ⟧ A
-  from-∘     : (C₁ : Container s₁ p₁) (C₂ : Container s₂ p₂) → ⟦ C₁ ∘ C₂ ⟧ A → ⟦ C₁ ⟧ (⟦ C₂ ⟧ A)
-  to-×       : (C₁ : Container s₁ p₁) (C₂ : Container s₂ p₂) → ⟦ C₁ ⟧ A P.× ⟦ C₂ ⟧ A → ⟦ C₁ × C₂ ⟧ A
-  from-×     : (C₁ : Container s₁ p₁) (C₂ : Container s₂ p₂) → ⟦ C₁ × C₂ ⟧ A → ⟦ C₁ ⟧ A P.× ⟦ C₂ ⟧ A
-  to-Π       : (I : Set i) (Cᵢ : I → Container s p) → (∀ i → ⟦ Cᵢ i ⟧ A) → ⟦ Π I Cᵢ ⟧ A
-  from-Π     : (I : Set i) (Cᵢ : I → Container s p) → ⟦ Π I Cᵢ ⟧ A → ∀ i → ⟦ Cᵢ i ⟧ A
-  to-⊎       : (C₁ : Container s₁ p) (C₂ : Container s₂ p) → ⟦ C₁ ⟧ A S.⊎ ⟦ C₂ ⟧ A → ⟦ C₁ ⊎ C₂ ⟧ A
-  from-⊎     : (C₁ : Container s₁ p) (C₂ : Container s₂ p) → ⟦ C₁ ⊎ C₂ ⟧ A → ⟦ C₁ ⟧ A S.⊎ ⟦ C₂ ⟧ A
-  to-Σ       : (I : Set i) (C : I → Container s p) → (∃ λ i → ⟦ C i ⟧ A) → ⟦ Σ I C ⟧ A
-  from-Σ     : (I : Set i) (C : I → Container s p) → ⟦ Σ I C ⟧ A → ∃ λ i → ⟦ C i ⟧ A
-  ```
-
-* Added a non-dependent version of `Function.Base.flip` due to an issue noted in
-  Pull Request #1812:
+* Added new functions in `Data.String.Base`:
   ```agda
-  flip′ : (A → B → C) → (B → A → C)
+  map     : (Char → Char) → String → String
+  between : String → String → String → String
   ```
 
-* Added new proofs to `Data.List.Properties`
+* Added new functions in `Data.Vec.Bounded.Base`:
   ```agda
-  cartesianProductWith-zeroˡ       : cartesianProductWith f [] ys ≡ []
-  cartesianProductWith-zeroʳ       : cartesianProductWith f xs [] ≡ []
-  cartesianProductWith-distribʳ-++ : cartesianProductWith f (xs ++ ys) zs ≡
-                                     cartesianProductWith f xs zs ++ cartesianProductWith f ys zs
-  foldr-map : foldr f x (map g xs) ≡ foldr (g -⟨ f ∣) x xs
-  foldl-map : foldl f x (map g xs) ≡ foldl (∣ f ⟩- g) x xs
-  ```
-
-NonZero/Positive/Negative changes
----------------------------------
-
-This is a full list of proofs that have changed form to use irrelevant instance arguments:
-
-* In `Data.Nat.Base`:
-  ```
-  ≢-nonZero⁻¹ : ∀ {n} → .(NonZero n) → n ≢ 0
-  >-nonZero⁻¹ : ∀ {n} → .(NonZero n) → n > 0
-  ```
-
-* In `Data.Nat.Properties`:
-  ```
-  *-cancelʳ-≡ : ∀ m n {o} → m * suc o ≡ n * suc o → m ≡ n
-  *-cancelˡ-≡ : ∀ {m n} o → suc o * m ≡ suc o * n → m ≡ n
-  *-cancelʳ-≤ : ∀ m n o → m * suc o ≤ n * suc o → m ≤ n
-  *-cancelˡ-≤ : ∀ {m n} o → suc o * m ≤ suc o * n → m ≤ n
-  *-monoˡ-<   : ∀ n → (_* suc n) Preserves _<_ ⟶ _<_
-  *-monoʳ-<   : ∀ n → (suc n *_) Preserves _<_ ⟶ _<_
-
-  m≤m*n          : ∀ m {n} → 0 < n → m ≤ m * n
-  m≤n*m          : ∀ m {n} → 0 < n → m ≤ n * m
-  m<m*n          : ∀ {m n} → 0 < m → 1 < n → m < m * n
-  suc[pred[n]]≡n : ∀ {n} → n ≢ 0 → suc (pred n) ≡ n
+  isBounded : (as : Vec≤ A n) → Vec≤.length as ≤ n
+  toVec     : (as : Vec≤ A n) → Vec A (Vec≤.length as)
   ```
 
-* In `Data.Nat.Coprimality`:
-  ```
-  Bézout-coprime : ∀ {i j d} → Bézout.Identity (suc d) (i * suc d) (j * suc d) → Coprime i j
-  ```
-
-* In `Data.Nat.Divisibility`
+* In `Data.Word64.Base`:
   ```agda
-  m%n≡0⇒n∣m : ∀ m n → m % suc n ≡ 0 → suc n ∣ m
-  n∣m⇒m%n≡0 : ∀ m n → suc n ∣ m → m % suc n ≡ 0
-  m%n≡0⇔n∣m : ∀ m n → m % suc n ≡ 0 ⇔ suc n ∣ m
-  ∣⇒≤       : ∀ {m n} → m ∣ suc n → m ≤ suc n
-  >⇒∤        : ∀ {m n} → m > suc n → m ∤ suc n
-  *-cancelˡ-∣ : ∀ {i j} k → suc k * i ∣ suc k * j → i ∣ j
+  _≤_ : Rel Word64 zero
+  show : Word64 → String
   ```
 
-* In `Data.Nat.DivMod`:
-  ```
-  m≡m%n+[m/n]*n : ∀ m n → m ≡ m % suc n + (m / suc n) * suc n
-  m%n≡m∸m/n*n   : ∀ m n → m % suc n ≡ m ∸ (m / suc n) * suc n
-  n%n≡0         : ∀ n → suc n % suc n ≡ 0
-  m%n%n≡m%n     : ∀ m n → m % suc n % suc n ≡ m % suc n
-  [m+n]%n≡m%n   : ∀ m n → (m + suc n) % suc n ≡ m % suc n
-  [m+kn]%n≡m%n  : ∀ m k n → (m + k * (suc n)) % suc n ≡ m % suc n
-  m*n%n≡0       : ∀ m n → (m * suc n) % suc n ≡ 0
-  m%n<n         : ∀ m n → m % suc n < suc n
-  m%n≤m         : ∀ m n → m % suc n ≤ m
-  m≤n⇒m%n≡m     : ∀ {m n} → m ≤ n → m % suc n ≡ m
+* In `Function.Bundles`, added `_⟶ₛ_` as a synonym for `Func` that can
+  be used infix.
 
-  m/n<m         : ∀ m n {≢0} → m ≥ 1 → n ≥ 2 → (m / n) {≢0} < m
-  ```
-
-* In `Data.Nat.GCD`
-  ```
-  GCD-* : ∀ {m n d c} → GCD (m * suc c) (n * suc c) (d * suc c) → GCD m n d
-  gcd[m,n]≤n : ∀ m n → gcd m (suc n) ≤ suc n
-  ```
-
-* In `Data.Integer.Properties`:
-  ```
-  positive⁻¹        : ∀ {i} → Positive i → i > 0ℤ
-  negative⁻¹        : ∀ {i} → Negative i → i < 0ℤ
-  nonPositive⁻¹     : ∀ {i} → NonPositive i → i ≤ 0ℤ
-  nonNegative⁻¹     : ∀ {i} → NonNegative i → i ≥ 0ℤ
-  negative<positive : ∀ {i j} → Negative i → Positive j → i < j
-
-  sign-◃    : ∀ s n → sign (s ◃ suc n) ≡ s
-  sign-cong : ∀ {s₁ s₂ n₁ n₂} → s₁ ◃ suc n₁ ≡ s₂ ◃ suc n₂ → s₁ ≡ s₂
-  -◃<+◃     : ∀ m n → Sign.- ◃ (suc m) < Sign.+ ◃ n
-  m⊖1+n<m   : ∀ m n → m ⊖ suc n < + m
-
-  *-cancelʳ-≡     : ∀ i j k → k ≢ + 0 → i * k ≡ j * k → i ≡ j
-  *-cancelˡ-≡     : ∀ i j k → i ≢ + 0 → i * j ≡ i * k → j ≡ k
-  *-cancelʳ-≤-pos : ∀ m n o → m * + suc o ≤ n * + suc o → m ≤ n
-
-  ≤-steps     : ∀ n → i ≤ j → i ≤ + n + j
-  ≤-steps-neg : ∀ n → i ≤ j → i - + n ≤ j
-  n≤m+n       : ∀ n → i ≤ + n + i
-  m≤m+n       : ∀ n → i ≤ i + + n
-  m-n≤m       : ∀ i n → i - + n ≤ i
-
-  *-cancelʳ-≤-pos    : ∀ m n o → m * + suc o ≤ n * + suc o → m ≤ n
-  *-cancelˡ-≤-pos    : ∀ m j k → + suc m * j ≤ + suc m * k → j ≤ k
-  *-cancelˡ-≤-neg    : ∀ m {j k} → -[1+ m ] * j ≤ -[1+ m ] * k → j ≥ k
-  *-cancelʳ-≤-neg    : ∀ {n o} m → n * -[1+ m ] ≤ o * -[1+ m ] → n ≥ o
-  *-cancelˡ-<-nonNeg : ∀ n → + n * i < + n * j → i < j
-  *-cancelʳ-<-nonNeg : ∀ n → i * + n < j * + n → i < j
-  *-monoʳ-≤-nonNeg   : ∀ n → (_* + n) Preserves _≤_ ⟶ _≤_
-  *-monoˡ-≤-nonNeg   : ∀ n → (+ n *_) Preserves _≤_ ⟶ _≤_
-  *-monoˡ-≤-nonPos   : ∀ i → NonPositive i → (i *_) Preserves _≤_ ⟶ _≥_
-  *-monoʳ-≤-nonPos   : ∀ i → NonPositive i → (_* i) Preserves _≤_ ⟶ _≥_
-  *-monoˡ-<-pos      : ∀ n → (+[1+ n ] *_) Preserves _<_ ⟶ _<_
-  *-monoʳ-<-pos      : ∀ n → (_* +[1+ n ]) Preserves _<_ ⟶ _<_
-  *-monoˡ-<-neg      : ∀ n → (-[1+ n ] *_) Preserves _<_ ⟶ _>_
-  *-monoʳ-<-neg      : ∀ n → (_* -[1+ n ]) Preserves _<_ ⟶ _>_
-  *-cancelˡ-<-nonPos : ∀ n → NonPositive n → n * i < n * j → i > j
-  *-cancelʳ-<-nonPos : ∀ n → NonPositive n → i * n < j * n → i > j
-
-  *-distribˡ-⊓-nonNeg : ∀ m j k → + m * (j ⊓ k) ≡ (+ m * j) ⊓ (+ m * k)
-  *-distribʳ-⊓-nonNeg : ∀ m j k → (j ⊓ k) * + m ≡ (j * + m) ⊓ (k * + m)
-  *-distribˡ-⊓-nonPos : ∀ i → NonPositive i → ∀ j k → i * (j ⊓ k) ≡ (i * j) ⊔ (i * k)
-  *-distribʳ-⊓-nonPos : ∀ i → NonPositive i → ∀ j k → (j ⊓ k) * i ≡ (j * i) ⊔ (k * i)
-  *-distribˡ-⊔-nonNeg : ∀ m j k → + m * (j ⊔ k) ≡ (+ m * j) ⊔ (+ m * k)
-  *-distribʳ-⊔-nonNeg : ∀ m j k → (j ⊔ k) * + m ≡ (j * + m) ⊔ (k * + m)
-  *-distribˡ-⊔-nonPos : ∀ i → NonPositive i → ∀ j k → i * (j ⊔ k) ≡ (i * j) ⊓ (i * k)
-  *-distribʳ-⊔-nonPos : ∀ i → NonPositive i → ∀ j k → (j ⊔ k) * i ≡ (j * i) ⊓ (k * i)
-  ```
-
-* In `Data.Integer.Divisibility`:
-  ```
-  *-cancelˡ-∣ : ∀ k {i j} → k ≢ + 0 → k * i ∣ k * j → i ∣ j
-  *-cancelʳ-∣ : ∀ k {i j} → k ≢ + 0 → i * k ∣ j * k → i ∣ j
-  ```
-
-* In `Data.Integer.Divisibility.Signed`:
-  ```
-  *-cancelˡ-∣ : ∀ k {i j} → k ≢ + 0 → k * i ∣ k * j → i ∣ j
-  *-cancelʳ-∣ : ∀ k {i j} → k ≢ + 0 → i * k ∣ j * k → i ∣ j
-  ```
-
-* In `Data.Rational.Unnormalised.Properties`:
-  ```agda
-  positive⁻¹           : ∀ {q} → .(Positive q) → q > 0ℚᵘ
-  nonNegative⁻¹        : ∀ {q} → .(NonNegative q) → q ≥ 0ℚᵘ
-  negative⁻¹           : ∀ {q} → .(Negative q) → q < 0ℚᵘ
-  nonPositive⁻¹        : ∀ {q} → .(NonPositive q) → q ≤ 0ℚᵘ
-  positive⇒nonNegative : ∀ {p} → Positive p → NonNegative p
-  negative⇒nonPositive : ∀ {p} → Negative p → NonPositive p
-  negative<positive    : ∀ {p q} → .(Negative p) → .(Positive q) → p < q
-  nonNeg∧nonPos⇒0      : ∀ {p} → .(NonNegative p) → .(NonPositive p) → p ≃ 0ℚᵘ
-
-  ≤-steps : ∀ {p q r} → NonNegative r → p ≤ q → p ≤ r + q
-  p≤p+q   : ∀ {p q} → NonNegative q → p ≤ p + q
-  p≤q+p   : ∀ {p} → NonNegative p → ∀ {q} → q ≤ p + q
-
-  *-cancelʳ-≤-pos    : ∀ {r} → Positive r → ∀ {p q} → p * r ≤ q * r → p ≤ q
-  *-cancelˡ-≤-pos    : ∀ {r} → Positive r → ∀ {p q} → r * p ≤ r * q → p ≤ q
-  *-cancelʳ-≤-neg    : ∀ r → Negative r → ∀ {p q} → p * r ≤ q * r → q ≤ p
-  *-cancelˡ-≤-neg    : ∀ r → Negative r → ∀ {p q} → r * p ≤ r * q → q ≤ p
-  *-cancelˡ-<-nonNeg : ∀ {r} → NonNegative r → ∀ {p q} → r * p < r * q → p < q
-  *-cancelʳ-<-nonNeg : ∀ {r} → NonNegative r → ∀ {p q} → p * r < q * r → p < q
-  *-cancelˡ-<-nonPos : ∀ r → NonPositive r → ∀ {p q} → r * p < r * q → q < p
-  *-cancelʳ-<-nonPos : ∀ r → NonPositive r → ∀ {p q} → p * r < q * r → q < p
-  *-monoˡ-≤-nonNeg   : ∀ {r} → NonNegative r → (_* r) Preserves _≤_ ⟶ _≤_
-  *-monoʳ-≤-nonNeg   : ∀ {r} → NonNegative r → (r *_) Preserves _≤_ ⟶ _≤_
-  *-monoˡ-≤-nonPos   : ∀ r → NonPositive r → (_* r) Preserves _≤_ ⟶ _≥_
-  *-monoʳ-≤-nonPos   : ∀ r → NonPositive r → (r *_) Preserves _≤_ ⟶ _≥_
-  *-monoˡ-<-pos      : ∀ {r} → Positive r → (_* r) Preserves _<_ ⟶ _<_
-  *-monoʳ-<-pos      : ∀ {r} → Positive r → (r *_) Preserves _<_ ⟶ _<_
-  *-monoˡ-<-neg      : ∀ r → Negative r → (_* r) Preserves _<_ ⟶ _>_
-  *-monoʳ-<-neg      : ∀ r → Negative r → (r *_) Preserves _<_ ⟶ _>_
-
-  pos⇒1/pos : ∀ p (p>0 : Positive p) → Positive ((1/ p) {{pos⇒≢0 p p>0}})
-  neg⇒1/neg : ∀ p (p<0 : Negative p) → Negative ((1/ p) {{neg⇒≢0 p p<0}})
-
-  *-distribʳ-⊓-nonNeg : ∀ p → NonNegative p → ∀ q r → (q ⊓ r) * p ≃ (q * p) ⊓ (r * p)
-  *-distribˡ-⊓-nonNeg : ∀ p → NonNegative p → ∀ q r → p * (q ⊓ r) ≃ (p * q) ⊓ (p * r)
-  *-distribˡ-⊔-nonNeg : ∀ p → NonNegative p → ∀ q r → p * (q ⊔ r) ≃ (p * q) ⊔ (p * r)
-  *-distribʳ-⊔-nonNeg : ∀ p → NonNegative p → ∀ q r → (q ⊔ r) * p ≃ (q * p) ⊔ (r * p)
-  *-distribˡ-⊔-nonPos : ∀ p → NonPositive p → ∀ q r → p * (q ⊔ r) ≃ (p * q) ⊓ (p * r)
-  *-distribʳ-⊔-nonPos : ∀ p → NonPositive p → ∀ q r → (q ⊔ r) * p ≃ (q * p) ⊓ (r * p)
-  *-distribˡ-⊓-nonPos : ∀ p → NonPositive p → ∀ q r → p * (q ⊓ r) ≃ (p * q) ⊔ (p * r)
-  *-distribʳ-⊓-nonPos : ∀ p → NonPositive p → ∀ q r → (q ⊓ r) * p ≃ (q * p) ⊔ (r * p)
-  ```
-
-* In `Data.Rational.Properties`:
-  ```
-  positive⁻¹ : Positive p → p > 0ℚ
-  nonNegative⁻¹ : NonNegative p → p ≥ 0ℚ
-  negative⁻¹ : Negative p → p < 0ℚ
-  nonPositive⁻¹ : NonPositive p → p ≤ 0ℚ
-  negative<positive : Negative p → Positive q → p < q
-  nonNeg≢neg : ∀ p q → NonNegative p → Negative q → p ≢ q
-  pos⇒nonNeg : ∀ p → Positive p → NonNegative p
-  neg⇒nonPos : ∀ p → Negative p → NonPositive p
-  nonNeg∧nonZero⇒pos : ∀ p → NonNegative p → NonZero p → Positive p
-
-  *-cancelʳ-≤-pos    : ∀ r → Positive r → ∀ {p q} → p * r ≤ q * r → p ≤ q
-  *-cancelˡ-≤-pos    : ∀ r → Positive r → ∀ {p q} → r * p ≤ r * q → p ≤ q
-  *-cancelʳ-≤-neg    : ∀ r → Negative r → ∀ {p q} → p * r ≤ q * r → p ≥ q
-  *-cancelˡ-≤-neg    : ∀ r → Negative r → ∀ {p q} → r * p ≤ r * q → p ≥ q
-  *-cancelˡ-<-nonNeg : ∀ r → NonNegative r → ∀ {p q} → r * p < r * q → p < q
-  *-cancelʳ-<-nonNeg : ∀ r → NonNegative r → ∀ {p q} → p * r < q * r → p < q
-  *-cancelˡ-<-nonPos : ∀ r → NonPositive r → ∀ {p q} → r * p < r * q → p > q
-  *-cancelʳ-<-nonPos : ∀ r → NonPositive r → ∀ {p q} → p * r < q * r → p > q
-  *-monoʳ-≤-nonNeg   : ∀ r → NonNegative r → (_* r) Preserves _≤_ ⟶ _≤_
-  *-monoˡ-≤-nonNeg   : ∀ r → NonNegative r → (r *_) Preserves _≤_ ⟶ _≤_
-  *-monoʳ-≤-nonPos   : ∀ r → NonPositive r → (_* r) Preserves _≤_ ⟶ _≥_
-  *-monoˡ-≤-nonPos   : ∀ r → NonPositive r → (r *_) Preserves _≤_ ⟶ _≥_
-  *-monoˡ-<-pos      : ∀ r → Positive r → (_* r) Preserves _<_ ⟶ _<_
-  *-monoʳ-<-pos      : ∀ r → Positive r → (r *_) Preserves _<_ ⟶ _<_
-  *-monoˡ-<-neg      : ∀ r → Negative r → (_* r) Preserves _<_ ⟶ _>_
-  *-monoʳ-<-neg      : ∀ r → Negative r → (r *_) Preserves _<_ ⟶ _>_
-
-  *-distribˡ-⊓-nonNeg : ∀ p → NonNegative p → ∀ q r → p * (q ⊓ r) ≡ (p * q) ⊓ (p * r)
-  *-distribʳ-⊓-nonNeg : ∀ p → NonNegative p → ∀ q r → (q ⊓ r) * p ≡ (q * p) ⊓ (r * p)
-  *-distribˡ-⊔-nonNeg : ∀ p → NonNegative p → ∀ q r → p * (q ⊔ r) ≡ (p * q) ⊔ (p * r)
-  *-distribʳ-⊔-nonNeg : ∀ p → NonNegative p → ∀ q r → (q ⊔ r) * p ≡ (q * p) ⊔ (r * p)
-  *-distribˡ-⊔-nonPos : ∀ p → NonPositive p → ∀ q r → p * (q ⊔ r) ≡ (p * q) ⊓ (p * r)
-  *-distribʳ-⊔-nonPos : ∀ p → NonPositive p → ∀ q r → (q ⊔ r) * p ≡ (q * p) ⊓ (r * p)
-  *-distribˡ-⊓-nonPos : ∀ p → NonPositive p → ∀ q r → p * (q ⊓ r) ≡ (p * q) ⊔ (p * r)
-  *-distribʳ-⊓-nonPos : ∀ p → NonPositive p → ∀ q r → (q ⊓ r) * p ≡ (q * p) ⊔ (r * p)
-
-  pos⇒1/pos : ∀ p (p>0 : Positive p) → Positive ((1/ p) {{pos⇒≢0 p p>0}})
-  neg⇒1/neg : ∀ p (p<0 : Negative p) → Negative ((1/ p) {{neg⇒≢0 p p<0}})
-  1/pos⇒pos : ∀ p .{{_ : NonZero p}} → (1/p : Positive (1/ p)) → Positive p
-  1/neg⇒neg : ∀ p .{{_ : NonZero p}} → (1/p : Negative (1/ p)) → Negative p
+* Re-exported new types and functions in `IO`:
+  ```agda
+  BufferMode : Set
+  noBuffering : BufferMode
+  lineBuffering : BufferMode
+  blockBuffering : Maybe ℕ → BufferMode
+  Handle : Set
+  stdin : Handle
+  stdout : Handle
+  stderr : Handle
+  hSetBuffering : Handle → BufferMode → IO ⊤
+  hGetBuffering : Handle → IO BufferMode
+  hFlush : Handle → IO ⊤
   ```
 
-* In `Data.List.NonEmpty.Base`:
+* Added new functions in `IO.Base`:
   ```agda
-  drop+ : ℕ → List⁺ A → List⁺ A
+  whenInj₂ : E ⊎ A → (A → IO ⊤) → IO ⊤
+  forever : IO ⊤ → IO ⊤
   ```
-  When drop+ping more than the size of the length of the list, the last element remains.
 
-* Added new proofs in `Data.List.NonEmpty.Properties`:
+* In `IO.Primitive.Core`:
   ```agda
-  length-++⁺ : length (xs ++⁺ ys) ≡ length xs + length ys
-  length-++⁺-tail : length (xs ++⁺ ys) ≡ suc (length xs + length (tail ys))
-  ++-++⁺ : (xs ++ ys) ++⁺ zs ≡ xs ++⁺ ys ++⁺ zs
-  ++⁺-cancelˡ′ : xs ++⁺ zs ≡ ys ++⁺ zs′ → List.length xs ≡ List.length ys → zs ≡ zs′
-  ++⁺-cancelˡ : xs ++⁺ ys ≡ xs ++⁺ zs → ys ≡ zs
-  drop+-++⁺ : drop+ (length xs) (xs ++⁺ ys) ≡ ys
-  map-++⁺-commute : map f (xs ++⁺ ys) ≡ map f xs ++⁺ map f ys
-  length-map : length (map f xs) ≡ length xs
-  map-cong : f ≗ g → map f ≗ map g
-  map-compose : map (g ∘ f) ≗ map g ∘ map f
+  _>>_ : IO A → IO B → IO B
   ```
 
-* Added new functions and proofs in `Data.Nat.GeneralisedArithmetic`:
+* Added new definition in `Relation.Binary.Construct.Closure.Transitive`
   ```agda
-  iterate : (A → A) → A → ℕ → A
-  iterate-is-fold : ∀ (z : A) s m → fold z s m ≡ iterate s z m
+  transitive⁻ : Transitive _∼_ → TransClosure _∼_ ⇒ _∼_
   ```
 
-* Added new proofs to `Function.Properties.Inverse`:
+* Added new proofs in `Relation.Binary.Construct.Composition`:
   ```agda
-  Inverse⇒Injection : Inverse S T → Injection S T
-  ↔⇒↣ : A ↔ B → A ↣ B
+  transitive⇒≈;≈⊆≈ : Transitive ≈ → (≈ ; ≈) ⇒ ≈
   ```
 
-* Added a new isomorphism to `Data.Fin.Properties`:
+* Added new definitions in `Relation.Binary.Definitions`
   ```agda
-  2↔Bool : Fin 2 ↔ Bool
+  Stable _∼_ = ∀ x y → Nullary.Stable (x ∼ y)
+  Empty  _∼_ = ∀ {x y} → ¬ (x ∼ y)
   ```
 
-* Added new isomorphisms to `Data.Unit.Polymorphic.Properties`:
+* Added new proofs in `Relation.Binary.Properties.Setoid`:
   ```agda
-  ⊤↔⊤* : ⊤ {ℓ} ↔ ⊤*
+  ≉-irrefl : Irreflexive _≈_ _≉_
+  ≈;≈⇒≈ : _≈_ ; _≈_ ⇒ _≈_
+  ≈⇒≈;≈ : _≈_ ⇒ _≈_ ; _≈_
   ```
 
-* Added new isomorphisms to `Data.Vec.N-ary`:
+* Added new definitions in `Relation.Nullary`
   ```agda
-  Vec↔N-ary : ∀ n → (Vec A n → B) ↔ N-ary n A B
+  Recomputable    : Set _
+  WeaklyDecidable : Set _
   ```
 
-* Added new isomorphisms to `Data.Vec.Recursive`:
+* Added new proof in `Relation.Nullary.Decidable`:
   ```agda
-  lift↔ : ∀ n → A ↔ B → A ^ n ↔ B ^ n
-  Fin[m^n]↔Fin[m]^n : ∀ m n → Fin (m ^ n) ↔ Fin m Vec.^ n
+  ⌊⌋-map′ : (a? : Dec A) → ⌊ map′ t f a? ⌋ ≡ ⌊ a? ⌋
   ```
 
-* Added new functions to `Function.Properties.Inverse`:
+* Added new definitions and proofs in `Relation.Nullary.Decidable.Core`:
   ```agda
-  ↔-refl  : Reflexive _↔_
-  ↔-sym   : Symmetric _↔_
-  ↔-trans : Transitive _↔_
+  dec⇒maybe          : Dec A → Maybe A
+  recompute-constant : (a? : Dec A) (p q : A) → recompute a? p ≡ recompute a? q
+  toSum              : Dec A → A ⊎ ¬ A
+  fromSum            : A ⊎ ¬ A → Dec A
   ```
 
-* Added new isomorphisms to `Function.Properties.Inverse`:
+* Added new definitions in `Relation.Nullary.Negation.Core`:
   ```agda
-  ↔-fun : A ↔ B → C ↔ D → (A → C) ↔ (B → D)
+  contradiction-irr : .A → ¬ A → Whatever
   ```
 
-* Added new function to `Data.Fin.Properties`
+* Added new definitions in `Relation.Nullary.Reflects`:
   ```agda
-  i≤inject₁[j]⇒i≤1+j : i ≤ inject₁ j → i ≤ suc j
+  recompute          : Reflects A b → Recomputable A
+  recompute-constant : (r : Reflects A b) (p q : A) → recompute r p ≡ recompute r q
   ```
 
-* Added new function to `Data.Fin.Induction`
+* Added new definitions in `Relation.Unary`:
   ```agda
-  <-weakInduction-startingFrom : P i →  (∀ j → P (inject₁ j) → P (suc j)) → ∀ {j} → j ≥ i → P j
+  Stable          : Pred A ℓ → Set _
+  WeaklyDecidable : Pred A ℓ → Set _
   ```
+
+* Enhancements to `Tactic.Cong` - see `README.Tactic.Cong` for details.
+  - Provide a marker function, `⌞_⌟`, for user-guided anti-unification.
+  - Improved support for equalities between terms with instance arguments,
+    such as terms that contain `_/_` or `_%_`.
diff --git a/CHANGELOG/v1.7.3.md b/CHANGELOG/v1.7.3.md
new file mode 100644
index 0000000000..7226a01e8a
--- /dev/null
+++ b/CHANGELOG/v1.7.3.md
@@ -0,0 +1,18 @@
+Version 1.7.3
+=============
+
+The library has been tested using Agda 2.6.3 & 2.6.4.
+
+* To avoid _large indices_ that are by default no longer allowed in Agda 2.6.4,
+  universe levels have been increased in the following definitions:
+  - `Data.Star.Decoration.DecoratedWith`
+  - `Data.Star.Pointer.Pointer`
+  - `Reflection.AnnotatedAST.Typeₐ`
+  - `Reflection.AnnotatedAST.AnnotationFun`
+
+* The following aliases have been added:
+  - `IO.Primitive.pure` as alias for `IO.Primitive.return`
+  - modules `Effect.*` as aliases for modules `Category.*`
+
+  These allow to address said objects with the new name they will have in v2.0 of the library,
+  to ease the transition from v1.7.3 to v2.0.
diff --git a/CHANGELOG/v2.0.md b/CHANGELOG/v2.0.md
new file mode 100644
index 0000000000..ce3c85e979
--- /dev/null
+++ b/CHANGELOG/v2.0.md
@@ -0,0 +1,3911 @@
+Version 2.0
+===========
+
+The library has been tested using Agda 2.6.4 and 2.6.4.1.
+
+NOTE: Version `2.0` contains various breaking changes and is not backwards
+compatible with code written with version `1.X` of the library.
+
+Highlights
+----------
+
+* A new tactic `cong!` available from `Tactic.Cong` which automatically
+  infers the argument to `cong` for you via anti-unification.
+
+* Improved the `solve` tactic in `Tactic.RingSolver` to work in a much
+  wider range of situations.
+
+* A massive refactoring of the unindexed `Functor`/`Applicative`/`Monad` hierarchy
+  and the `MonadReader` / `MonadState` type classes. These are now usable with
+  instance arguments as demonstrated in the tests/monad examples.
+
+* Significant tightening of `import` statements internally in the library,
+  drastically decreasing the dependencies and hence load time of many key
+  modules.
+
+* A golden testing library in `Test.Golden`. This allows you to run a set
+  of tests and make sure their output matches an expected `golden` value.
+  The test runner has many options: filtering tests by name, dumping the
+  list of failures to a file, timing the runs, coloured output, etc.
+  Cf. the comments in `Test.Golden` and the standard library's own tests
+  in `tests/` for documentation on how to use the library.
+
+Bug-fixes
+---------
+
+* In `Algebra.Structures` the records `IsRing` and `IsRingWithoutOne` contained an unnecessary field
+  `zero : RightZero 0# *`, which could be derived from the other ring axioms.
+  Consequently this field has been removed from the record, and the record
+  `IsRingWithoutAnnihilatingZero` in `Algebra.Structures.Biased` has been
+  deprecated as it is now identical to is `IsRing`.
+
+* In `Algebra.Definitions.RawSemiring` the record `Prime` did not
+  enforce that the number was not divisible by `1#`. To fix this
+  `p∤1 : p ∤ 1#` has been added as a field.
+
+* In `Data.Container.FreeMonad`, we give a direct definition of `_⋆_` as an inductive
+  type rather than encoding it as an instance of `μ`. This ensures Agda notices that
+  `C ⋆ X` is strictly positive in `X` which in turn allows us to use the free monad
+  when defining auxiliary (co)inductive types (cf. the `Tap` example in
+  `README.Data.Container.FreeMonad`).
+
+* In `Data.Fin.Properties` the `i` argument to `opposite-suc` was implicit
+  but could not be inferred in general. It has been made explicit.
+
+* In `Data.List.Membership.Setoid` the operations `_∷=_` and `_─_`
+  had an extraneous `{A : Set a}` parameter. This has been removed.
+
+* In `Data.List.Relation.Ternary.Appending.Setoid` the constructors
+  were re-exported in their full generality which lead to unsolved meta
+  variables at their use sites. Now versions of the constructors specialised
+  to use the setoid's carrier set are re-exported.
+
+* In `Data.Nat.DivMod` the parameter `o` in the proof `/-monoˡ-≤` was
+  implicit but not inferrable. It has been changed to be explicit.
+
+* In `Data.Nat.DivMod` the parameter `m` in the proof `+-distrib-/-∣ʳ` was
+  implicit but not inferrable, while `n` is explicit but inferrable.
+  They have been to explicit and implicit respectively.
+
+* In `Data.Nat.GeneralisedArithmetic` the `s` and `z` arguments to the
+  following functions were implicit but not inferrable:
+  `fold-+`, `fold-k`, `fold-*`, `fold-pull`. They have been made explicit.
+
+* In `Data.Rational(.Unnormalised).Properties` the module `≤-Reasoning`
+  exported equality combinators using the generic setoid symbol `_≈_`. They
+  have been renamed to use the same `_≃_` symbol used for non-propositional
+  equality over `Rational`s, i.e.
+  ```agda
+  step-≈  ↦  step-≃
+  step-≈˘ ↦  step-≃˘
+  ```
+  with corresponding associated syntax:
+  ```agda
+  _≈⟨_⟩_ ↦ _≃⟨_⟩_
+  _≈⟨_⟨_ ↦ _≃⟨_⟨_
+  ```
+
+* In `Function.Construct.Composition` the combinators
+  `_⟶-∘_`, `_↣-∘_`, `_↠-∘_`, `_⤖-∘_`, `_⇔-∘_`, `_↩-∘_`, `_↪-∘_`, `_↔-∘_`
+  had their arguments in the wrong order. They have been flipped so they can
+  actually be  used as a composition operator.
+
+* In `Function.Definitions` the definitions of `Surjection`, `Inverseˡ`,
+  `Inverseʳ` were not being re-exported correctly and therefore had an unsolved
+  meta-variable whenever this module was explicitly parameterised. This has
+  been fixed.
+
+* In `System.Exit` the `ExitFailure` constructor is now carrying an integer
+  rather than a natural. The previous binding was incorrectly assuming that
+  all exit codes where non-negative.
+
+Non-backwards compatible changes
+--------------------------------
+
+### Removed deprecated names
+
+* All modules and names that were deprecated in `v1.2` and before have
+  been removed.
+
+### Changes to `LeftCancellative` and `RightCancellative` in `Algebra.Definitions`
+
+* The definitions of the types for cancellativity in `Algebra.Definitions` previously
+  made some of their arguments implicit. This was under the assumption that the operators were
+  defined by pattern matching on the left argument so that Agda could always infer the
+  argument on the RHS.
+
+* Although many of the operators defined in the library follow this convention, this is not
+  always true and cannot be assumed in user's code.
+
+* Therefore the definitions have been changed as follows to make all their arguments explicit:
+  - `LeftCancellative _∙_`
+    - From: `∀ x {y z} → (x ∙ y) ≈ (x ∙ z) → y ≈ z`
+    - To: `∀ x y z → (x ∙ y) ≈ (x ∙ z) → y ≈ z`
+
+  - `RightCancellative _∙_`
+    - From: `∀ {x} y z → (y ∙ x) ≈ (z ∙ x) → y ≈ z`
+    - To: `∀ x y z → (y ∙ x) ≈ (z ∙ x) → y ≈ z`
+
+  - `AlmostLeftCancellative e _∙_`
+    - From: `∀ {x} y z → ¬ x ≈ e → (x ∙ y) ≈ (x ∙ z) → y ≈ z`
+    - To: `∀ x y z → ¬ x ≈ e → (x ∙ y) ≈ (x ∙ z) → y ≈ z`
+
+  - `AlmostRightCancellative e _∙_`
+    - From: `∀ {x} y z → ¬ x ≈ e → (y ∙ x) ≈ (z ∙ x) → y ≈ z`
+    - To: `∀ x y z → ¬ x ≈ e → (y ∙ x) ≈ (z ∙ x) → y ≈ z`
+
+* Correspondingly some proofs of the above types will need additional arguments passed explicitly.
+  Instances can easily be fixed by adding additional underscores, e.g.
+  - `∙-cancelˡ x` to `∙-cancelˡ x _ _`
+  - `∙-cancelʳ y z` to `∙-cancelʳ _ y z`
+
+### Changes to ring structures in `Algebra`
+
+* Several ring-like structures now have the multiplicative structure defined by
+  its laws rather than as a substructure, to avoid repeated proofs that the
+  underlying relation is an equivalence. These are:
+  * `IsNearSemiring`
+  * `IsSemiringWithoutOne`
+  * `IsSemiringWithoutAnnihilatingZero`
+  * `IsRing`
+
+* To aid with migration, structures matching the old style ones have been added
+  to `Algebra.Structures.Biased`, with conversion functions:
+  * `IsNearSemiring*` and `isNearSemiring*`
+  * `IsSemiringWithoutOne*` and `isSemiringWithoutOne*`
+  * `IsSemiringWithoutAnnihilatingZero*` and `isSemiringWithoutAnnihilatingZero*`
+  * `IsRing*` and `isRing*`
+
+### Refactoring of lattices in `Algebra.Structures/Bundles` hierarchy
+
+* In order to improve modularity and consistency with `Relation.Binary.Lattice`,
+  the structures & bundles for `Semilattice`, `Lattice`, `DistributiveLattice`
+  & `BooleanAlgebra` have been moved out of the `Algebra` modules and into their
+  own hierarchy in `Algebra.Lattice`.
+
+* All submodules, (e.g. `Algebra.Properties.Semilattice` or `Algebra.Morphism.Lattice`)
+  have been moved to the corresponding place under `Algebra.Lattice` (e.g.
+  `Algebra.Lattice.Properties.Semilattice` or `Algebra.Lattice.Morphism.Lattice`). See
+  the `Deprecated modules` section below for full details.
+
+* The definition of `IsDistributiveLattice` and `IsBooleanAlgebra` have changed so
+  that they are no longer right-biased which hindered compositionality.
+  More concretely, `IsDistributiveLattice` now has fields:
+  ```agda
+  ∨-distrib-∧ : ∨ DistributesOver ∧
+  ∧-distrib-∨ : ∧ DistributesOver ∨
+  ```
+  instead of
+  ```agda
+  ∨-distribʳ-∧ : ∨ DistributesOverʳ ∧
+  ```
+  and `IsBooleanAlgebra` now has fields:
+  ```agda
+  ∨-complement : Inverse ⊤ ¬ ∨
+  ∧-complement : Inverse ⊥ ¬ ∧
+  ```
+  instead of:
+  ```agda
+  ∨-complementʳ : RightInverse ⊤ ¬ ∨
+  ∧-complementʳ : RightInverse ⊥ ¬ ∧
+  ```
+
+* To allow construction of these structures via their old form, smart constructors
+  have been added to a new module `Algebra.Lattice.Structures.Biased`, which are by
+  re-exported automatically by `Algebra.Lattice`. For example, if before you wrote:
+  ```agda
+  ∧-∨-isDistributiveLattice = record
+    { isLattice    = ∧-∨-isLattice
+    ; ∨-distribʳ-∧ = ∨-distribʳ-∧
+    }
+  ```
+  you can use the smart constructor `isDistributiveLatticeʳʲᵐ` to write:
+  ```agda
+  ∧-∨-isDistributiveLattice = isDistributiveLatticeʳʲᵐ (record
+    { isLattice    = ∧-∨-isLattice
+    ; ∨-distribʳ-∧ = ∨-distribʳ-∧
+    })
+  ```
+  without having to prove full distributivity.
+
+* Added new `IsBoundedSemilattice`/`BoundedSemilattice` records.
+
+* Added new aliases `Is(Meet/Join)(Bounded)Semilattice` for `Is(Bounded)Semilattice`
+  which can be used to indicate meet/join-ness of the original structures, and
+  the field names in `IsSemilattice` and `Semilattice` have been renamed from
+  `∧-cong` to `∙-cong`to indicate their undirected nature.
+
+* Finally, the following auxiliary files have been moved:
+  ```agda
+  Algebra.Properties.Semilattice               ↦ Algebra.Lattice.Properties.Semilattice
+  Algebra.Properties.Lattice                   ↦ Algebra.Lattice.Properties.Lattice
+  Algebra.Properties.DistributiveLattice       ↦ Algebra.Lattice.Properties.DistributiveLattice
+  Algebra.Properties.BooleanAlgebra            ↦ Algebra.Lattice.Properties.BooleanAlgebra
+  Algebra.Properties.BooleanAlgebra.Expression ↦ Algebra.Lattice.Properties.BooleanAlgebra.Expression
+  Algebra.Morphism.LatticeMonomorphism         ↦ Algebra.Lattice.Morphism.LatticeMonomorphism
+  ```
+
+#### Changes to `Algebra.Morphism.Structures`
+
+* Previously the record definitions:
+  ```
+  IsNearSemiringHomomorphism
+  IsSemiringHomomorphism
+  IsRingHomomorphism
+  ```
+  all had two separate proofs of `IsRelHomomorphism` within them.
+
+* To fix this they have all been redefined to build up from `IsMonoidHomomorphism`,
+  `IsNearSemiringHomomorphism`, and `IsSemiringHomomorphism` respectively,
+  adding a single property at each step.
+
+* Similarly, `IsLatticeHomomorphism` is now built as
+  `IsRelHomomorphism` along with proofs that `_∧_` and `_∨_` are homomorphic.
+
+* Finally `⁻¹-homo` in `IsRingHomomorphism` has been renamed to `-‿homo`.
+
+#### Renamed `Category` modules to `Effect`
+
+* As observed by Wen Kokke in issue #1636, it no longer really makes sense
+  to group the modules which correspond to the variety of concepts of
+  (effectful) type constructor arising in functional programming (esp. in Haskell)
+  such as `Monad`, `Applicative`, `Functor`, etc, under `Category.*`,
+  as this obstructs the importing of the `agda-categories` development into
+  the Standard Library, and moreover needlessly restricts the applicability of
+  categorical concepts to this (highly specific) mode of use.
+
+* Correspondingly, client modules grouped under  `*.Categorical.*` which
+  exploit such structure  for effectful programming have been  renamed
+  `*.Effectful`, with the originals being deprecated.
+
+* Full list of moved modules:
+  ```agda
+  Codata.Sized.Colist.Categorical            ↦ Codata.Sized.Colist.Effectful
+  Codata.Sized.Covec.Categorical             ↦ Codata.Sized.Covec.Effectful
+  Codata.Sized.Delay.Categorical             ↦ Codata.Sized.Delay.Effectful
+  Codata.Sized.Stream.Categorical            ↦ Codata.Sized.Stream.Effectful
+  Data.List.Categorical                      ↦ Data.List.Effectful
+  Data.List.Categorical.Transformer          ↦ Data.List.Effectful.Transformer
+  Data.List.NonEmpty.Categorical             ↦ Data.List.NonEmpty.Effectful
+  Data.List.NonEmpty.Categorical.Transformer ↦ Data.List.NonEmpty.Effectful.Transformer
+  Data.Maybe.Categorical                     ↦ Data.Maybe.Effectful
+  Data.Maybe.Categorical.Transformer         ↦ Data.Maybe.Effectful.Transformer
+  Data.Product.Categorical.Examples          ↦ Data.Product.Effectful.Examples
+  Data.Product.Categorical.Left              ↦ Data.Product.Effectful.Left
+  Data.Product.Categorical.Left.Base         ↦ Data.Product.Effectful.Left.Base
+  Data.Product.Categorical.Right             ↦ Data.Product.Effectful.Right
+  Data.Product.Categorical.Right.Base        ↦ Data.Product.Effectful.Right.Base
+  Data.Sum.Categorical.Examples              ↦ Data.Sum.Effectful.Examples
+  Data.Sum.Categorical.Left                  ↦ Data.Sum.Effectful.Left
+  Data.Sum.Categorical.Left.Transformer      ↦ Data.Sum.Effectful.Left.Transformer
+  Data.Sum.Categorical.Right                 ↦ Data.Sum.Effectful.Right
+  Data.Sum.Categorical.Right.Transformer     ↦ Data.Sum.Effectful.Right.Transformer
+  Data.These.Categorical.Examples            ↦ Data.These.Effectful.Examples
+  Data.These.Categorical.Left                ↦ Data.These.Effectful.Left
+  Data.These.Categorical.Left.Base           ↦ Data.These.Effectful.Left.Base
+  Data.These.Categorical.Right               ↦ Data.These.Effectful.Right
+  Data.These.Categorical.Right.Base          ↦ Data.These.Effectful.Right.Base
+  Data.Vec.Categorical                       ↦ Data.Vec.Effectful
+  Data.Vec.Categorical.Transformer           ↦ Data.Vec.Effectful.Transformer
+  Data.Vec.Recursive.Categorical             ↦ Data.Vec.Recursive.Effectful
+  Function.Identity.Categorical              ↦ Function.Identity.Effectful
+  IO.Categorical                             ↦ IO.Effectful
+  Reflection.TCM.Categorical                 ↦ Reflection.TCM.Effectful
+  ```
+
+* Full list of new modules:
+  ```
+  Algebra.Construct.Initial
+  Algebra.Construct.Terminal
+  Data.List.Effectful.Transformer
+  Data.List.NonEmpty.Effectful.Transformer
+  Data.Maybe.Effectful.Transformer
+  Data.Sum.Effectful.Left.Transformer
+  Data.Sum.Effectful.Right.Transformer
+  Data.Vec.Effectful.Transformer
+  Effect.Empty
+  Effect.Choice
+  Effect.Monad.Error.Transformer
+  Effect.Monad.Identity
+  Effect.Monad.IO
+  Effect.Monad.IO.Instances
+  Effect.Monad.Reader.Indexed
+  Effect.Monad.Reader.Instances
+  Effect.Monad.Reader.Transformer
+  Effect.Monad.Reader.Transformer.Base
+  Effect.Monad.State.Indexed
+  Effect.Monad.State.Instances
+  Effect.Monad.State.Transformer
+  Effect.Monad.State.Transformer.Base
+  Effect.Monad.Writer
+  Effect.Monad.Writer.Indexed
+  Effect.Monad.Writer.Instances
+  Effect.Monad.Writer.Transformer
+  Effect.Monad.Writer.Transformer.Base
+  IO.Effectful
+  IO.Instances
+  ```
+
+### Refactoring of the unindexed Functor/Applicative/Monad hierarchy in `Effect`
+
+* The unindexed versions are not defined in terms of the named versions anymore.
+
+* The `RawApplicative` and `RawMonad` type classes have been relaxed so that the underlying
+  functors do not need their domain and codomain to live at the same Set level.
+  This is needed for level-increasing functors like `IO : Set l → Set (suc l)`.
+
+* `RawApplicative` is now `RawFunctor + pure + _<*>_` and `RawMonad` is now
+  `RawApplicative` + `_>>=_`.
+  This reorganisation means in particular that the functor/applicative of a monad
+  are not computed using `_>>=_`. This may break proofs.
+
+* When `F : Set f → Set f` we moreover have a definable join/μ operator
+  `join : (M : RawMonad F) → F (F A) → F A`.
+
+* We now have `RawEmpty` and `RawChoice` respectively packing `empty : M A` and
+  `(<|>) : M A → M A → M A`. `RawApplicativeZero`, `RawAlternative`, `RawMonadZero`,
+  `RawMonadPlus` are all defined in terms of these.
+
+* `MonadT T` now returns a `MonadTd` record that packs both a proof that the
+  `Monad M` transformed by `T` is a monad and that we can `lift` a computation
+  `M A` to a transformed computation `T M A`.
+
+* The monad transformer are not mere aliases anymore, they are record-wrapped
+  which allows constraints such as `MonadIO (StateT S (ReaderT R IO))` to be
+  discharged by instance arguments.
+
+* The mtl-style type classes (`MonadState`, `MonadReader`) do not contain a proof
+  that the underlying functor is a `Monad` anymore. This ensures we do not have
+  conflicting `Monad M` instances from a pair of `MonadState S M` & `MonadReader R M`
+  constraints.
+
+* `MonadState S M` is now defined in terms of
+  ```agda
+  gets : (S → A) → M A
+  modify : (S → S) → M ⊤
+  ```
+  with `get` and `put` defined as derived notions.
+  This is needed because `MonadState S M` does not pack a `Monad M` instance anymore
+  and so we cannot define `modify f` as `get >>= λ s → put (f s)`.
+
+* `MonadWriter 𝕎 M` is defined similarly:
+   ```agda
+   writer : W × A → M A
+   listen : M A → M (W × A)
+   pass   : M ((W → W) × A) → M A
+   ```
+   with `tell` defined as a derived notion.
+   Note that `𝕎` is a `RawMonoid`, not a `Set` and `W` is the carrier of the monoid.
+
+
+#### Moved `Codata` modules to `Codata.Sized`
+
+* Due to the change in Agda 2.6.2 where sized types are no longer compatible
+  with the `--safe` flag, it has become clear that a third variant of codata
+  will be needed using coinductive records.
+
+* Therefore all existing modules in `Codata` which used sized types have been
+  moved inside a new folder named `Codata.Sized`,  e.g. `Codata.Stream`
+  has become `Codata.Sized.Stream`.
+
+### New proof-irrelevant for empty type in `Data.Empty`
+
+* The definition of `⊥` has been changed to
+  ```agda
+  private
+    data Empty : Set where
+
+  ⊥ : Set
+  ⊥ = Irrelevant Empty
+  ```
+  in order to make ⊥ proof irrelevant. Any two proofs of `⊥` or of a negated
+  statements are now *judgmentally* equal to each other.
+
+* Consequently the following two definitions have been modified:
+
+  + In `Relation.Nullary.Decidable.Core`, the type of `dec-no` has changed
+    ```agda
+    dec-no : (p? : Dec P) → ¬ P → ∃ λ ¬p′ → p? ≡ no ¬p′
+      ↦
+    dec-no : (p? : Dec P) (¬p : ¬ P) → p? ≡ no ¬p
+    ```
+
+  + In `Relation.Binary.PropositionalEquality`, the type of `≢-≟-identity` has changed
+    ```agda
+    ≢-≟-identity : x ≢ y → ∃ λ ¬eq → x ≟ y ≡ no ¬eq
+      ↦
+    ≢-≟-identity : (x≢y : x ≢ y) → x ≟ y ≡ no x≢y
+    ```
+
+### Deprecation of `_≺_` in `Data.Fin.Base`
+
+* In `Data.Fin.Base` the relation `_≺_` and its single constructor `_≻toℕ_`
+  have been deprecated in favour of their extensional equivalent `_<_`
+  but omitting the inversion principle which pattern matching on `_≻toℕ_`
+  would achieve; this instead is proxied by the property `Data.Fin.Properties.toℕ<`.
+
+* Consequently in `Data.Fin.Induction`:
+  ```
+  ≺-Rec
+  ≺-wellFounded
+  ≺-recBuilder
+  ≺-rec
+  ```
+  these functions are also deprecated.
+
+* Likewise in `Data.Fin.Properties` the proofs `≺⇒<′` and `<′⇒≺` have been deprecated
+  in favour of their proxy counterparts `<⇒<′` and `<′⇒<`.
+
+### Standardisation of `insertAt`/`updateAt`/`removeAt` in `Data.List`/`Data.Vec`
+
+* Previously, the names and argument order of index-based insertion, update and removal functions for
+  various types of lists and vectors were inconsistent.
+
+* To fix this the names have all been standardised to `insertAt`/`updateAt`/`removeAt`.
+
+* Correspondingly the following changes have occurred:
+
+* In `Data.List.Base` the following have been added:
+  ```agda
+  insertAt : (xs : List A) → Fin (suc (length xs)) → A → List A
+  updateAt : (xs : List A) → Fin (length xs) → (A → A) → List A
+  removeAt : (xs : List A) → Fin (length xs) → List A
+  ```
+  and the following has been deprecated
+  ```
+  _─_ ↦ removeAt
+  ```
+
+* In `Data.Vec.Base`:
+  ```agda
+  insert ↦ insertAt
+  remove ↦ removeAt
+
+  updateAt : Fin n → (A → A) → Vec A n → Vec A n
+    ↦
+  updateAt : Vec A n → Fin n → (A → A) → Vec A n
+  ```
+
+* In `Data.Vec.Functional`:
+  ```agda
+  remove : Fin (suc n) → Vector A (suc n) → Vector A n
+    ↦
+  removeAt : Vector A (suc n) → Fin (suc n) → Vector A n
+
+  updateAt : Fin n → (A → A) → Vector A n → Vector A n
+    ↦
+  updateAt : Vector A n → Fin n → (A → A) → Vector A n
+  ```
+
+* The old names (and the names of all proofs about these functions) have been deprecated appropriately.
+
+#### Standardisation of `lookup` in `Data.(List/Vec/...)`
+
+* All the types of `lookup` functions (and variants) in the following modules
+  have been changed to match the argument convention adopted in the `List` module (i.e.
+  `lookup` takes its container first and the index, whose type may depend on the
+  container value, second):
+  ```
+  Codata.Guarded.Stream
+  Codata.Guarded.Stream.Relation.Binary.Pointwise
+  Codata.Musical.Colist.Base
+  Codata.Musical.Colist.Relation.Unary.Any.Properties
+  Codata.Musical.Covec
+  Codata.Musical.Stream
+  Codata.Sized.Colist
+  Codata.Sized.Covec
+  Codata.Sized.Stream
+  Data.Vec.Relation.Unary.All
+  Data.Star.Environment
+  Data.Star.Pointer
+  Data.Star.Vec
+  Data.Trie
+  Data.Trie.NonEmpty
+  Data.Tree.AVL
+  Data.Tree.AVL.Indexed
+  Data.Tree.AVL.Map
+  Data.Tree.AVL.NonEmpty
+  Data.Vec.Recursive
+  ```
+
+* To accommodate this in in `Data.Vec.Relation.Unary.Linked.Properties`
+  and `Codata.Guarded.Stream.Relation.Binary.Pointwise`, the proofs
+  called `lookup` have been renamed `lookup⁺`.
+
+#### Changes to `Data.(Nat/Integer/Rational)` proofs of `NonZero`/`Positive`/`Negative` to use instance arguments
+
+* Many numeric operations in the library require their arguments to be non-zero,
+  and various proofs require their arguments to be non-zero/positive/negative etc.
+  As discussed on the [mailing list](https://lists.chalmers.se/pipermail/agda/2021/012693.html),
+  the previous way of constructing and passing round these proofs was extremely
+  clunky and lead to messy and difficult to read code.
+
+* We have therefore changed every occurrence where we need a proof of
+  non-zeroness/positivity/etc. to take it as an irrelevant
+  [instance argument](https://agda.readthedocs.io/en/latest/language/instance-arguments.html).
+  See the mailing list discussion for a fuller explanation of the motivation and implementation.
+
+* For example, whereas the type of division over `ℕ` used to be:
+  ```agda
+  _/_ : (dividend divisor : ℕ) {≢0 : False (divisor ≟ 0)} → ℕ
+  ```
+  it is now:
+  ```agda
+  _/_ : (dividend divisor : ℕ) .{{_ : NonZero divisor}} → ℕ
+  ```
+
+* This means that as long as an instance of `NonZero n` is in scope then you can write
+  `m / n` without having to explicitly provide a proof, as instance search will fill it in
+  for you. The full list of such operations changed is as follows:
+    - In `Data.Nat.DivMod`: `_/_`, `_%_`, `_div_`, `_mod_`
+    - In `Data.Nat.Pseudorandom.LCG`: `Generator`
+    - In `Data.Integer.DivMod`: `_divℕ_`, `_div_`, `_modℕ_`, `_mod_`
+    - In `Data.Rational`: `mkℚ+`, `normalize`, `_/_`, `1/_`
+    - In `Data.Rational.Unnormalised`: `_/_`, `1/_`, `_÷_`
+
+* At the moment, there are 4 different ways such instance arguments can be provided,
+  listed in order of convenience and clarity:
+
+  1. *Automatic basic instances* - the standard library provides instances based on
+         the constructors of each numeric type in `Data.X.Base`. For example,
+         `Data.Nat.Base` constrains an instance of `NonZero (suc n)` for any `n`
+         and `Data.Integer.Base` contains an instance of `NonNegative (+ n)` for any `n`.
+         Consequently, if the argument is of the required form, these instances will always
+         be filled in by instance search automatically, e.g.
+        ```agda
+        0/n≡0 : 0 / suc n ≡ 0
+        ```
+
+  2. *Add an instance argument parameter* - You can provide the instance argument as
+         a parameter to your function and Agda's instance search will automatically use it
+         in the correct place without you having to explicitly pass it, e.g.
+    ```agda
+    0/n≡0 : .{{_ : NonZero n}} → 0 / n ≡ 0
+    ```
+
+  3. *Define the instance locally* - You can define an instance argument in scope
+         (e.g. in a `where` clause) and Agda's instance search will again find it automatically,
+         e.g.
+        ```agda
+        instance
+          n≢0 : NonZero n
+          n≢0 = ...
+
+        0/n≡0 : 0 / n ≡ 0
+        ```
+
+  4. *Pass the instance argument explicitly* - Finally, if all else fails you can pass the
+         instance argument explicitly into the function using `{{ }}`, e.g.
+         ```
+         0/n≡0 : ∀ n (n≢0 : NonZero n) → ((0 / n) {{n≢0}}) ≡ 0
+         ```
+
+* Suitable constructors for `NonZero`/`Positive` etc. can be found in `Data.X.Base`.
+
+* A full list of proofs that have changed to use instance arguments is available
+  at the end of this file. Notable changes to proofs are now discussed below.
+
+* Previously one of the hacks used in proofs was to explicitly refer to everything
+  in the correct form, e.g. if the argument `n` had to be non-zero then you would
+  refer to the argument as `suc n` everywhere instead of `n`, e.g.
+  ```
+  n/n≡1 : ∀ n → suc n / suc n ≡ 1
+  ```
+  This made the proofs extremely difficult to use if your term wasn't in the form `suc n`.
+  After being updated to use instance arguments instead, the proof above becomes:
+  ```
+  n/n≡1 : ∀ n {{_ : NonZero n}} → n / n ≡ 1
+  ```
+  However, note that this means that if you passed in the value `x` to these proofs
+  before, then you will now have to pass in `suc x`. The proofs for which the
+  arguments have changed form in this way are highlighted in the list at the bottom
+  of the file.
+
+* Finally, in `Data.Rational.Unnormalised.Base` the definition of `_≢0` is now
+  redundant and so has been removed. Additionally the following proofs about it have
+  also been removed from `Data.Rational.Unnormalised.Properties`:
+  ```
+  p≄0⇒∣↥p∣≢0 : ∀ p → p ≠ 0ℚᵘ → ℤ.∣ (↥ p) ∣ ≢0
+  ∣↥p∣≢0⇒p≄0 : ∀ p → ℤ.∣ (↥ p) ∣ ≢0 → p ≠ 0ℚᵘ
+  ```
+
+### Changes to the definition of `_≤″_` in `Data.Nat.Base` (issue #1919)
+
+* The definition of `_≤″_` was previously:
+  ```agda
+  record _≤″_ (m n : ℕ) : Set where
+    constructor less-than-or-equal
+    field
+      {k}   : ℕ
+      proof : m + k ≡ n
+  ```
+  which introduced a spurious additional definition, when this is in fact, modulo
+  field names and implicit/explicit qualifiers, equivalent to the definition of left-
+  divisibility, `_∣ˡ_` for the `RawMagma` structure of `_+_`.
+
+* Since the addition of raw bundles to `Data.X.Base`, this definition can now be
+  made directly. Accordingly, the definition has been changed to:
+  ```agda
+  _≤″_ : (m n : ℕ)  → Set
+  _≤″_ = _∣ˡ_ +-rawMagma
+
+  pattern less-than-or-equal {k} prf = k , prf
+  ```
+
+* Knock-on consequences include the need to retain the old constructor
+  name, now introduced as a pattern synonym, and introduction of (a function
+  equivalent to) the former field name/projection function `proof` as
+  `≤″-proof` in `Data.Nat.Properties`.
+
+### Changes to definition of `Prime` in `Data.Nat.Primality`
+
+* The definition of `Prime` was:
+  ```agda
+  Prime 0             = ⊥
+  Prime 1             = ⊥
+  Prime (suc (suc n)) = (i : Fin n) → 2 + toℕ i ∤ 2 + n
+  ```
+  which was very hard to reason about as, not only did it involve conversion
+  to and from the `Fin` type, it also required that the divisor was of the form
+  `2 + toℕ i`, which has exactly the same problem as the `suc n` hack described
+  above used for non-zeroness.
+
+* To make it easier to use, reason about and read, the definition has been
+  changed to:
+  ```agda
+  record Prime (p : ℕ) : Set where
+    constructor prime
+    field
+      .{{nontrivial}} : NonTrivial p
+      notComposite    : ¬ Composite p
+  ```
+  where `Composite` is now defined as the diagonal of the new relation
+  `_HasNonTrivialDivisorLessThan_` in `Data.Nat.Divisibility.Core`.
+
+### Changes to operation reduction behaviour in `Data.Rational(.Unnormalised)`
+
+* Currently arithmetic expressions involving rationals (both normalised and
+  unnormalised) undergo disastrous exponential normalisation. For example,
+  `p + q` would often be normalised by Agda to
+  `(↥ p ℤ.* ↧ q ℤ.+ ↥ q ℤ.* ↧ p) / (↧ₙ p ℕ.* ↧ₙ q)`. While the normalised form
+  of `p + q + r + s + t + u + v` would be ~700 lines long. This behaviour
+  often chokes both type-checking and the display of the expressions in the IDE.
+
+* To avoid this expansion and make non-trivial reasoning about rationals actually feasible:
+  1. the records `ℚᵘ` and `ℚ` have both had the `no-eta-equality` flag enabled
+  2. definition of arithmetic operations have trivial pattern matching added to
+     prevent them reducing, e.g.
+     ```agda
+     p + q = (↥ p ℤ.* ↧ q ℤ.+ ↥ q ℤ.* ↧ p) / (↧ₙ p ℕ.* ↧ₙ q)
+     ```
+     has been changed to
+     ```
+     p@record{} + q@record{} = (↥ p ℤ.* ↧ q ℤ.+ ↥ q ℤ.* ↧ p) / (↧ₙ p ℕ.* ↧ₙ q)
+     ```
+
+* As a consequence of this, some proofs that relied either on this reduction behaviour
+  or on eta-equality may no longer type-check.
+
+* There are several ways to fix this:
+
+  1. The principled way is to not rely on this reduction behaviour in the first place.
+     The `Properties` files for rational numbers have been greatly expanded in `v1.7`
+     and `v2.0`, and we believe most proofs should be able to be built up from existing
+     proofs contained within these files.
+
+  2. Alternatively, annotating any rational arguments to a proof with either
+     `@record{}` or `@(mkℚ _ _ _)` should restore the old reduction behaviour for any
+     terms involving those parameters.
+
+  3. Finally, if the above approaches are not viable then you may be forced to explicitly
+     use `cong` combined with a lemma that proves the old reduction behaviour.
+
+* Similarly, in order to prevent reduction, the equality `_≃_` in `Data.Rational.Base`
+  has been made into a data type with the single constructor `*≡*`. The destructor
+  `drop-*≡*` has been added to `Data.Rational.Properties`.
+
+#### Deprecation of old `Function` hierarchy
+
+* The new `Function` hierarchy was introduced in `v1.2` which follows
+  the same `Core`/`Definitions`/`Bundles`/`Structures` as all the other
+  hierarchies in the library.
+
+* At the time the old function hierarchy in:
+  ```
+  Function.Equality
+  Function.Injection
+  Function.Surjection
+  Function.Bijection
+  Function.LeftInverse
+  Function.Inverse
+  Function.HalfAdjointEquivalence
+  Function.Related
+  ```
+  was unofficially deprecated, but could not be officially deprecated because
+  of it's widespread use in the rest of the library.
+
+* Now, the old hierarchy modules have all been officially deprecated. All
+  uses of them in the rest of the library have been switched to use the
+  new hierarchy.
+
+* The latter is unfortunately a relatively big breaking change, but was judged
+  to be unavoidable given how widely used the old hierarchy was.
+
+#### Changes to the new `Function` hierarchy
+
+* In `Function.Bundles` the names of the fields in the records have been
+  changed from `f`, `g`, `cong₁` and `cong₂` to `to`, `from`, `to-cong`, `from-cong`.
+
+* In `Function.Definitions`, the module no longer has two equalities as
+  module arguments, as they did not interact as intended with the re-exports
+  from `Function.Definitions.(Core1/Core2)`. The latter two modules have
+  been removed and their definitions folded into `Function.Definitions`.
+
+* In `Function.Definitions` the following definitions have been changed from:
+  ```
+  Surjective f = ∀ y → ∃ λ x → f x ≈₂ y
+  Inverseˡ f g = ∀ y → f (g y) ≈₂ y
+  Inverseʳ f g = ∀ x → g (f x) ≈₁ x
+  ```
+  to:
+  ```
+  Surjective f = ∀ y → ∃ λ x → ∀ {z} → z ≈₁ x → f z ≈₂ y
+  Inverseˡ f g = ∀ {x y} → y ≈₁ g x → f y ≈₂ x
+  Inverseʳ f g = ∀ {x y} → y ≈₂ f x → g y ≈₁ x
+  ```
+  This is for several reasons:
+          i) the new definitions compose much more easily,
+          ii) Agda can better infer the equalities used.
+
+* To ease backwards compatibility:
+   - the old definitions have been moved to the new names  `StrictlySurjective`,
+         `StrictlyInverseˡ` and `StrictlyInverseʳ`.
+   - The records in  `Function.Structures` and `Function.Bundles` export proofs
+         of these under the names `strictlySurjective`, `strictlyInverseˡ` and
+         `strictlyInverseʳ`,
+   - Conversion functions for the definitions have been added in both directions
+                 to `Function.Consequences(.Propositional/Setoid)`.
+   - Conversion functions for structures have been added in
+                 `Function.Structures.Biased`.
+
+### New `Function.Strict`
+
+* The module `Strict` has been deprecated in favour of `Function.Strict`
+  and the definitions of strict application, `_$!_` and `_$!′_`, have been
+  moved from `Function.Base` to `Function.Strict`.
+
+* The contents of `Function.Strict` is now re-exported by `Function`.
+
+### Change to the definition of `WfRec` in `Induction.WellFounded` (issue #2083)
+
+* Previously, the definition of `WfRec` was:
+  ```agda
+  WfRec : Rel A r → ∀ {ℓ} → RecStruct A ℓ _
+  WfRec _<_ P x = ∀ y → y < x → P y
+  ```
+  which meant that all arguments involving accessibility and wellfoundedness proofs
+  were polluted by almost-always-inferrable explicit arguments for the `y` position.
+
+* The definition has now been changed to make that argument *implicit*, as
+  ```agda
+  WfRec : Rel A r → ∀ {ℓ} → RecStruct A ℓ _
+  WfRec _<_ P x = ∀ {y} → y < x → P y
+  ```
+
+### Reorganisation of `Reflection` modules
+
+* Under the `Reflection` module, there were various impending name clashes
+  between the core AST as exposed by Agda and the annotated AST defined in
+  the library.
+
+* While the content of the modules remain the same, the modules themselves
+  have therefore been renamed as follows:
+  ```
+  Reflection.Annotated              ↦ Reflection.AnnotatedAST
+  Reflection.Annotated.Free         ↦ Reflection.AnnotatedAST.Free
+
+  Reflection.Abstraction            ↦ Reflection.AST.Abstraction
+  Reflection.Argument               ↦ Reflection.AST.Argument
+  Reflection.Argument.Information   ↦ Reflection.AST.Argument.Information
+  Reflection.Argument.Quantity      ↦ Reflection.AST.Argument.Quantity
+  Reflection.Argument.Relevance     ↦ Reflection.AST.Argument.Relevance
+  Reflection.Argument.Modality      ↦ Reflection.AST.Argument.Modality
+  Reflection.Argument.Visibility    ↦ Reflection.AST.Argument.Visibility
+  Reflection.DeBruijn               ↦ Reflection.AST.DeBruijn
+  Reflection.Definition             ↦ Reflection.AST.Definition
+  Reflection.Instances              ↦ Reflection.AST.Instances
+  Reflection.Literal                ↦ Reflection.AST.Literal
+  Reflection.Meta                   ↦ Reflection.AST.Meta
+  Reflection.Name                   ↦ Reflection.AST.Name
+  Reflection.Pattern                ↦ Reflection.AST.Pattern
+  Reflection.Show                   ↦ Reflection.AST.Show
+  Reflection.Traversal              ↦ Reflection.AST.Traversal
+  Reflection.Universe               ↦ Reflection.AST.Universe
+
+  Reflection.TypeChecking.Monad             ↦ Reflection.TCM
+  Reflection.TypeChecking.Monad.Categorical ↦ Reflection.TCM.Categorical
+  Reflection.TypeChecking.Monad.Format      ↦ Reflection.TCM.Format
+  Reflection.TypeChecking.Monad.Syntax      ↦ Reflection.TCM.Instances
+  Reflection.TypeChecking.Monad.Instances   ↦ Reflection.TCM.Syntax
+  ```
+
+* A new module `Reflection.AST` that re-exports the contents of the
+  submodules has been added.
+
+
+### Reorganisation of the `Relation.Nullary` hierarchy
+
+* It was very difficult to use the `Relation.Nullary` modules, as
+  `Relation.Nullary` contained the basic definitions of negation, decidability etc.,
+  and the operations and proofs about these definitions were spread over
+  `Relation.Nullary.(Negation/Product/Sum/Implication etc.)`.
+
+* To fix this all the contents of the latter is now exported by `Relation.Nullary`.
+
+* In order to achieve this the following backwards compatible changes have been made:
+
+  1. the definition of `Dec` and `recompute` have been moved to `Relation.Nullary.Decidable.Core`
+
+  2. the definition of `Reflects` has been moved to `Relation.Nullary.Reflects`
+
+  3. the definition of `¬_` has been moved to `Relation.Nullary.Negation.Core`
+
+  4. The modules `Relation.Nullary.(Product/Sum/Implication)` have been deprecated
+         and their contents moved to `Relation.Nullary.(Negation/Reflects/Decidable)`.
+
+  5. The proof `T?` has been moved from `Data.Bool.Properties` to `Relation.Nullary.Decidable.Core`
+         (but is still re-exported by the former).
+
+  as well as the following breaking changes:
+
+  1. `¬?` has been moved from `Relation.Nullary.Negation.Core` to
+         `Relation.Nullary.Decidable.Core`
+
+  2. `¬-reflects` has been moved from `Relation.Nullary.Negation.Core` to
+         `Relation.Nullary.Reflects`.
+
+  3. `decidable-stable`, `excluded-middle` and `¬-drop-Dec` have been moved
+         from `Relation.Nullary.Negation` to `Relation.Nullary.Decidable`.
+
+  4. `fromDec` and `toDec` have been moved from `Data.Sum.Base` to `Data.Sum`.
+
+
+### (Issue #2096) Introduction of flipped and negated relation symbols to bundles in `Relation.Binary.Bundles`
+
+* Previously, bundles such as `Preorder`, `Poset`, `TotalOrder` etc. did not have the flipped
+  and negated versions of the operators exposed. In some cases they could obtained by opening the
+  relevant `Relation.Binary.Properties.X` file but usually they had to be redefined every time.
+
+* To fix this, these bundles now all export all 4 versions of the operator: normal, converse, negated,
+  converse-negated. Accordingly they are no longer exported from the corresponding `Properties` file.
+
+* To make this work for `Preorder`, it was necessary to change the name of the relation symbol.
+  Previously, the symbol was `_∼_`  which is (notationally) symmetric, so that its
+  converse relation could only be discussed *semantically* in terms of `flip _∼_`.
+
+* Now, the `Preorder` record field `_∼_` has been renamed to `_≲_`, with `_≳_`
+  introduced as a definition in `Relation.Binary.Bundles.Preorder`.
+  Partial backwards compatible has been achieved by redeclaring a deprecated version
+  of the old symbol in the record. Therefore, only _declarations_ of `PartialOrder` records will
+  need their field names updating.
+
+
+### Changes to definition of `IsStrictTotalOrder` in `Relation.Binary.Structures`
+
+* The previous definition of the record `IsStrictTotalOrder` did not
+  build upon `IsStrictPartialOrder` as would be expected.
+  Instead it omitted several fields like irreflexivity as they were derivable from the
+  proof of trichotomy. However, this led to problems further up the hierarchy where
+  bundles such as `StrictTotalOrder` which contained multiple distinct proofs of
+  `IsStrictPartialOrder`.
+
+* To remedy this the definition of `IsStrictTotalOrder` has been changed to so
+  that it builds upon `IsStrictPartialOrder` as would be expected.
+
+* To aid migration, the old record definition has been moved to
+  `Relation.Binary.Structures.Biased` which contains the `isStrictTotalOrderᶜ`
+  smart constructor (which is re-exported by `Relation.Binary`) . Therefore the old code:
+  ```agda
+  <-isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_
+  <-isStrictTotalOrder = record
+        { isEquivalence = isEquivalence
+        ; trans         = <-trans
+        ; compare       = <-cmp
+        }
+  ```
+  can be migrated either by updating to the new record fields if you have a proof of `IsStrictPartialOrder`
+  available:
+  ```agda
+  <-isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_
+  <-isStrictTotalOrder = record
+        { isStrictPartialOrder = <-isStrictPartialOrder
+        ; compare              = <-cmp
+        }
+  ```
+  or simply applying the smart constructor to the record definition as follows:
+  ```agda
+  <-isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_
+  <-isStrictTotalOrder = isStrictTotalOrderᶜ record
+        { isEquivalence = isEquivalence
+        ; trans         = <-trans
+        ; compare       = <-cmp
+        }
+  ```
+
+### Changes to the interface of `Relation.Binary.Reasoning.Triple`
+
+* The module `Relation.Binary.Reasoning.Base.Triple` now takes an extra proof
+  that the strict relation is irreflexive.
+
+* This allows the addition of the following new proof combinator:
+  ```agda
+  begin-contradiction : (r : x IsRelatedTo x) → {s : True (IsStrict? r)} → A
+  ```
+  that takes a proof that a value is strictly less than itself and then applies the
+  principle of explosion to derive anything.
+
+* Specialised versions of this combinator are available in the `Reasoning` modules
+  exported by the following modules:
+  ```
+  Data.Nat.Properties
+  Data.Nat.Binary.Properties
+  Data.Integer.Properties
+  Data.Rational.Unnormalised.Properties
+  Data.Rational.Properties
+  Data.Vec.Relation.Binary.Lex.Strict
+  Data.Vec.Relation.Binary.Lex.NonStrict
+  Relation.Binary.Reasoning.StrictPartialOrder
+  Relation.Binary.Reasoning.PartialOrder
+  ```
+
+### A more modular design for `Relation.Binary.Reasoning`
+
+* Previously, every `Reasoning` module in the library tended to roll it's own set
+  of syntax for the combinators. This hindered consistency and maintainability.
+
+* To improve the situation, a new module `Relation.Binary.Reasoning.Syntax`
+  has been introduced which exports a wide range of sub-modules containing
+  pre-existing reasoning combinator syntax.
+
+* This makes it possible to add new or rename existing reasoning combinators to a
+  pre-existing `Reasoning` module in just a couple of lines
+  (e.g. see `∣-Reasoning` in `Data.Nat.Divisibility`)
+
+* One pre-requisite for that is that `≡-Reasoning` has been moved from
+  `Relation.Binary.PropositionalEquality.Core` (which shouldn't be
+  imported anyway as it's a `Core` module) to
+  `Relation.Binary.PropositionalEquality.Properties`.
+  It is still exported by `Relation.Binary.PropositionalEquality`.
+
+### Renaming of symmetric combinators in `Reasoning` modules
+
+* We've had various complaints about the symmetric version of reasoning combinators
+  that use the syntax `_R˘⟨_⟩_` for some relation `R`, (e.g. `_≡˘⟨_⟩_` and `_≃˘⟨_⟩_`)
+  introduced in `v1.0`. In particular:
+  1. The symbol `˘` is hard to type.
+  2. The symbol `˘` doesn't convey the direction of the equality
+  3. The left brackets aren't vertically aligned with the left brackets of the non-symmetric version.
+
+* To address these problems we have renamed all the symmetric versions of the
+  combinators from `_R˘⟨_⟩_` to `_R⟨_⟨_` (the direction of the last bracket is flipped
+  to indicate the quality goes from right to left).
+
+* The old combinators still exist but have been deprecated. However due to
+  [Agda issue #5617](https://github.com/agda/agda/issues/5617), the deprecation warnings
+  don't fire correctly. We will not remove the old combinators before the above issue is
+  addressed. However, we still encourage migrating to the new combinators!
+
+* On a Linux-based system, the following command was used to globally migrate all uses of the
+  old combinators to the new ones in the standard library itself.
+  It *may* be useful when trying to migrate your own code:
+  ```bash
+  find . -type f -name "*.agda" -print0 | xargs -0 sed -i -e 's/˘⟨\(.*\)⟩/⟨\1⟨/g'
+  ```
+  USUAL CAVEATS: It has not been widely tested and the standard library developers are not
+  responsible for the results of this command. It is strongly recommended you back up your
+  work before you attempt to run it.
+
+* NOTE: this refactoring may require some extra bracketing around the operator `_⟨_⟩_` from
+  `Function.Base` if the `_⟨_⟩_` operator is used within the reasoning proof. The symptom
+  for this is a `Don't know how to parse` error.
+
+### Improvements to `Text.Pretty` and `Text.Regex`
+
+* In `Text.Pretty`, `Doc` is now a record rather than a type alias. This
+  helps Agda reconstruct the `width` parameter when the module is opened
+  without it being applied. In particular this allows users to write
+  width-generic pretty printers and only pick a width when calling the
+  renderer by using this import style:
+  ```
+  open import Text.Pretty using (Doc; render)
+  --                      ^-- no width parameter for Doc & render
+  open module Pretty {w} = Text.Pretty w hiding (Doc; render)
+  --                 ^-- implicit width parameter for the combinators
+
+  pretty : Doc w
+  pretty = ? -- you can use the combinators here and there won't be any
+             -- issues related to the fact that `w` cannot be reconstructed
+             -- anymore
+
+  main = do
+    -- you can now use the same pretty with different widths:
+    putStrLn $ render 40 pretty
+    putStrLn $ render 80 pretty
+  ```
+
+* In `Text.Regex.Search` the `searchND` function finding infix matches has
+  been tweaked to make sure the returned solution is a local maximum in terms
+  of length. It used to be that we would make the match start as late as
+  possible and finish as early as possible. It's now the reverse.
+
+  So `[a-zA-Z]+.agdai?` run on "the path _build/Main.agdai corresponds to"
+  will return "Main.agdai" when it used to be happy to just return "n.agda".
+
+### Other
+
+* In accordance with changes to the flags in Agda 2.6.3, all modules that previously used
+  the `--without-K` flag now use the `--cubical-compatible` flag instead.
+
+* In `Algebra.Core` the operations `Opₗ` and `Opᵣ` have moved to `Algebra.Module.Core`.
+
+* In `Algebra.Definitions.RawMagma.Divisibility` the definitions for `_∣ˡ_` and `_∣ʳ_`
+  have been changed from being defined as raw products to being defined as records. However,
+  the record constructors are called `_,_` so the changes required are minimal.
+
+* In `Codata.Guarded.Stream` the following functions have been modified to have simpler definitions:
+  * `cycle`
+  * `interleave⁺`
+  * `cantor`
+  Furthermore, the direction of interleaving of `cantor` has changed. Precisely,
+  suppose `pair` is the cantor pairing function, then `lookup (pair i j) (cantor xss)`
+  according to the old definition corresponds to `lookup (pair j i) (cantor xss)`
+  according to the new definition.
+  For a concrete example see the one included at the end of the module.
+
+* In `Data.Fin.Base` the relations `_≤_` `_≥_` `_<_` `_>_`  have been
+  generalised so they can now relate `Fin` terms with different indices.
+  Should be mostly backwards compatible, but very occasionally when proving
+  properties about the orderings themselves the second index must be provided
+  explicitly.
+
+* In `Data.Fin.Properties` the proof `inj⇒≟` that an injection from a type
+  `A` into `Fin n` induces a decision procedure for `_≡_` on `A` has been
+  generalised to other equivalences over `A` (i.e. to arbitrary setoids), and
+  renamed from `eq?` to the more descriptive  and `inj⇒decSetoid`.
+
+* In `Data.Fin.Properties` the proof `pigeonhole` has been strengthened
+  so that the a proof that `i < j` rather than a mere `i ≢ j` is returned.
+
+* In `Data.Fin.Substitution.TermSubst` the fixity of `_/Var_` has been changed
+  from `infix 8` to `infixl 8`.
+
+* In `Data.Integer.DivMod` the previous implementations of
+  `_divℕ_`, `_div_`, `_modℕ_`, `_mod_` internally converted to the unary
+  `Fin` datatype resulting in poor performance. The implementation has been
+  updated to use the corresponding operations from `Data.Nat.DivMod` which are
+  efficiently implemented using the Haskell backend.
+
+* In `Data.Integer.Properties` the first two arguments of `m≡n⇒m-n≡0`
+  (now renamed `i≡j⇒i-j≡0`) have been made implicit.
+
+* In `Data.(List|Vec).Relation.Binary.Lex.Strict` the argument `xs` in
+  `xs≮[]` in introduced in PRs #1648 and #1672 has now been made implicit.
+
+* In `Data.List.NonEmpty` the functions `split`, `flatten` and `flatten-split`
+  have been removed from. In their place `groupSeqs` and `ungroupSeqs`
+  have been added to `Data.List.NonEmpty.Base` which morally perform the same
+  operations but without computing the accompanying proofs. The proofs can be
+  found in `Data.List.NonEmpty.Properties` under the names `groupSeqs-groups`
+  and `ungroupSeqs` and `groupSeqs`.
+
+* In `Data.List.Relation.Unary.Grouped.Properties` the proofs `map⁺` and `map⁻`
+  have had their preconditions weakened so the equivalences no longer require congruence
+  proofs.
+
+* In `Data.Nat.Divisibility` the proof `m/n/o≡m/[n*o]` has been removed. In it's
+  place a new more general proof `m/n/o≡m/[n*o]` has been added to `Data.Nat.DivMod`
+  that doesn't require the `n * o ∣ m` pre-condition.
+
+* In `Data.Product.Relation.Binary.Lex.Strict` the proof of wellfoundedness
+  of the lexicographic ordering on products, no longer
+  requires the assumption of symmetry for the first equality relation `_≈₁_`.
+
+* In `Data.Rational.Base` the constructors `+0` and `+[1+_]` from `Data.Integer.Base`
+  are no longer re-exported by `Data.Rational.Base`. You will have to open `Data.Integer(.Base)`
+  directly to use them.
+
+* In `Data.Rational(.Unnormalised).Properties` the types of the proofs
+  `pos⇒1/pos`/`1/pos⇒pos` and `neg⇒1/neg`/`1/neg⇒neg` have been switched,
+  as the previous naming scheme didn't correctly generalise to e.g. `pos+pos⇒pos`.
+  For example the types of `pos⇒1/pos`/`1/pos⇒pos` were:
+  ```agda
+  pos⇒1/pos : ∀ p .{{_ : NonZero p}} .{{Positive (1/ p)}} → Positive p
+  1/pos⇒pos : ∀ p .{{_ : Positive p}} → Positive (1/ p)
+  ```
+  but are now:
+  ```agda
+  pos⇒1/pos : ∀ p .{{_ : Positive p}} → Positive (1/ p)
+  1/pos⇒pos : ∀ p .{{_ : NonZero p}} .{{Positive (1/ p)}} → Positive p
+  ```
+
+* In `Data.Sum.Base` the definitions `fromDec` and `toDec` have been moved to `Data.Sum`.
+
+* In `Data.Vec.Base` the definition of `_>>=_` under `Data.Vec.Base` has been
+  moved to the submodule `CartesianBind` in order to avoid clashing with the
+  new, alternative definition of `_>>=_`, located in the second new submodule
+  `DiagonalBind`.
+
+* In `Data.Vec.Base` the definitions `init` and `last` have been changed from the `initLast`
+  view-derived implementation to direct recursive definitions.
+
+* In `Data.Vec.Properties` the type of the proof `zipWith-comm` has been generalised from:
+  ```agda
+  zipWith-comm : ∀ {f : A → A → B} (comm : ∀ x y → f x y ≡ f y x) (xs ys : Vec A n) →
+                 zipWith f xs ys ≡ zipWith f ys xs
+  ```
+  to
+  ```agda
+  zipWith-comm : ∀ {f : A → B → C} {g : B → A → C}  (comm : ∀ x y → f x y ≡ g y x) (xs : Vec A n) ys →
+                 zipWith f xs ys ≡ zipWith g ys xs
+  ```
+
+* In `Data.Vec.Relation.Unary.All` the functions `lookup` and `tabulate` have
+  been moved to `Data.Vec.Relation.Unary.All.Properties` and renamed
+  `lookup⁺` and `lookup⁻` respectively.
+
+* In `Data.Vec.Base` and `Data.Vec.Functional` the functions `iterate` and `replicate`
+  now take the length of vector, `n`, as an explicit rather than an implicit argument, i.e.
+  the new types are:
+  ```agda
+  iterate : (A → A) → A → ∀ n → Vec A n
+  replicate : ∀ n → A → Vec A n
+  ```
+
+* In `Relation.Binary.Construct.Closure.Symmetric` the operation
+  `SymClosure` on relations in has been reimplemented
+  as a data type `SymClosure _⟶_ a b` that is parameterized by the
+  input relation `_⟶_` (as well as the elements `a` and `b` of the
+  domain) so that `_⟶_` can be inferred, which it could not from the
+  previous implementation using the sum type `a ⟶ b ⊎ b ⟶ a`.
+
+* In `Relation.Nullary.Decidable.Core` the name `excluded-middle` has been
+  renamed to `¬¬-excluded-middle`.
+
+
+Other major improvements
+------------------------
+
+### Improvements to ring solver tactic
+
+* The ring solver tactic has been greatly improved. In particular:
+
+  1. When the solver is used for concrete ring types, e.g. ℤ, the equality can now use
+     all the ring operations defined natively for that type, rather than having
+     to use the operations defined in `AlmostCommutativeRing`. For example
+     previously you could not use `Data.Integer.Base._*_` but instead had to
+     use `AlmostCommutativeRing._*_`.
+
+  2. The solver now supports use of the subtraction operator `_-_` whenever
+     it is defined immediately in terms of `_+_` and `-_`. This is the case for
+     `Data.Integer` and `Data.Rational`.
+
+### Moved `_%_` and `_/_` operators to `Data.Nat.Base`
+
+* Previously the division and modulus operators were defined in `Data.Nat.DivMod`
+  which in turn meant that using them required importing `Data.Nat.Properties`
+  which is a very heavy dependency.
+
+* To fix this, these operators have been moved to `Data.Nat.Base`. The properties
+  for them still live in `Data.Nat.DivMod` (which also publicly re-exports them
+  to provide backwards compatibility).
+
+* Beneficiaries of this change include `Data.Rational.Unnormalised.Base` whose
+  dependencies are now significantly smaller.
+
+### Moved raw bundles from `Data.X.Properties` to `Data.X.Base`
+
+* Raw bundles by design don't contain any proofs so should in theory be able to live
+  in `Data.X.Base` rather than `Data.X.Bundles`.
+
+* To achieve this while keeping the dependency footprint small, the definitions of
+  raw bundles (`RawMagma`, `RawMonoid` etc.) have been moved from `Algebra(.Lattice)Bundles` to
+  a new module `Algebra(.Lattice).Bundles.Raw` which can be imported at much lower cost
+  from `Data.X.Base`.
+
+* We have then moved raw bundles defined in `Data.X.Properties` to `Data.X.Base` for
+  `X` = `Nat`/`Nat.Binary`/`Integer`/`Rational`/`Rational.Unnormalised`.
+
+### Upgrades to `README` sub-library
+
+* The `README` sub-library has been moved to `doc/README` and a new `doc/standard-library-doc.agda-lib` has been added.
+
+* The first consequence is that `README` files now can be type-checked in Emacs
+  using an out-of-the-box standard Agda installation without altering the main
+  `standard-library.agda-lib` file.
+
+* The second is that the `README` files are now their own first-class library
+  and can be imported like an other library.
+
+Deprecated modules
+------------------
+
+### Moving `Data.Erased` to `Data.Irrelevant`
+
+* This fixes the fact we had picked the wrong name originally. The erased modality
+  corresponds to `@0` whereas the irrelevance one corresponds to `.`.
+
+### Deprecation of `Data.Fin.Substitution.Example`
+
+* The module `Data.Fin.Substitution.Example` has been deprecated, and moved to `README.Data.Fin.Substitution.UntypedLambda`
+
+### Deprecation of `Data.Nat.Properties.Core`
+
+* The module `Data.Nat.Properties.Core` has been deprecated, and its one lemma moved to `Data.Nat.Base`, renamed as `s≤s⁻¹`
+
+### Deprecation of `Data.Product.Function.Dependent.Setoid.WithK`
+
+* This module has been deprecated, as none of its contents actually depended on axiom K.
+  The contents has been moved to `Data.Product.Function.Dependent.Setoid`.
+
+### Moving `Function.Related`
+
+* The module `Function.Related` has been deprecated in favour of `Function.Related.Propositional`
+  whose code uses the new function hierarchy. This also opens up the possibility of a more
+  general `Function.Related.Setoid` at a later date. Several of the names have been changed
+  in this process to bring them into line with the camelcase naming convention used
+  in the rest of the library:
+  ```agda
+  reverse-implication ↦ reverseImplication
+  reverse-injection   ↦ reverseInjection
+  left-inverse        ↦ leftInverse
+
+  Symmetric-kind      ↦ SymmetricKind
+  Forward-kind        ↦ ForwardKind
+  Backward-kind       ↦ BackwardKind
+  Equivalence-kind    ↦ EquivalenceKind
+  ```
+
+### Moving `Relation.Binary.Construct.(Converse/Flip)`
+
+* The following files have been moved:
+  ```agda
+  Relation.Binary.Construct.Converse ↦ Relation.Binary.Construct.Flip.EqAndOrd
+  Relation.Binary.Construct.Flip     ↦ Relation.Binary.Construct.Flip.Ord
+  ```
+
+### Moving `Relation.Binary.Properties.XLattice`
+
+* The following files have been moved:
+  ```agda
+  Relation.Binary.Properties.BoundedJoinSemilattice.agda  ↦ Relation.Binary.Lattice.Properties.BoundedJoinSemilattice.agda
+  Relation.Binary.Properties.BoundedLattice.agda          ↦ Relation.Binary.Lattice.Properties.BoundedLattice.agda
+  Relation.Binary.Properties.BoundedMeetSemilattice.agda  ↦ Relation.Binary.Lattice.Properties.BoundedMeetSemilattice.agda
+  Relation.Binary.Properties.DistributiveLattice.agda     ↦ Relation.Binary.Lattice.Properties.DistributiveLattice.agda
+  Relation.Binary.Properties.HeytingAlgebra.agda         ↦ Relation.Binary.Lattice.Properties.HeytingAlgebra.agda
+  Relation.Binary.Properties.JoinSemilattice.agda         ↦ Relation.Binary.Lattice.Properties.JoinSemilattice.agda
+  Relation.Binary.Properties.Lattice.agda                 ↦ Relation.Binary.Lattice.Properties.Lattice.agda
+  Relation.Binary.Properties.MeetSemilattice.agda         ↦ Relation.Binary.Lattice.Properties.MeetSemilattice.agda
+  ```
+
+Deprecated names
+----------------
+
+* In `Algebra.Consequences.Propositional`:
+  ```agda
+  comm+assoc⇒middleFour             ↦  comm∧assoc⇒middleFour
+  identity+middleFour⇒assoc         ↦  identity∧middleFour⇒assoc
+  identity+middleFour⇒comm          ↦  identity∧middleFour⇒comm
+  comm+distrˡ⇒distrʳ                ↦  comm∧distrˡ⇒distrʳ
+  comm+distrʳ⇒distrˡ                ↦  comm∧distrʳ⇒distrˡ
+  assoc+distribʳ+idʳ+invʳ⇒zeˡ       ↦  assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ
+  assoc+distribˡ+idʳ+invʳ⇒zeʳ       ↦  assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ
+  assoc+id+invʳ⇒invˡ-unique         ↦  assoc∧id∧invʳ⇒invˡ-unique
+  assoc+id+invˡ⇒invʳ-unique         ↦  assoc∧id∧invˡ⇒invʳ-unique
+  subst+comm⇒sym                    ↦  subst∧comm⇒sym
+  ```
+
+* In `Algebra.Consequences.Setoid`:
+  ```agda
+  comm+assoc⇒middleFour             ↦  comm∧assoc⇒middleFour
+  identity+middleFour⇒assoc         ↦  identity∧middleFour⇒assoc
+  identity+middleFour⇒comm          ↦  identity∧middleFour⇒comm
+  comm+cancelˡ⇒cancelʳ              ↦  comm∧cancelˡ⇒cancelʳ
+  comm+cancelʳ⇒cancelˡ              ↦  comm∧cancelʳ⇒cancelˡ
+  comm+almostCancelˡ⇒almostCancelʳ  ↦  comm∧almostCancelˡ⇒almostCancelʳ
+  comm+almostCancelʳ⇒almostCancelˡ  ↦  comm∧almostCancelʳ⇒almostCancelˡ
+  comm+idˡ⇒idʳ                      ↦  comm∧idˡ⇒idʳ
+  comm+idʳ⇒idˡ                      ↦  comm∧idʳ⇒idˡ
+  comm+zeˡ⇒zeʳ                      ↦  comm∧zeˡ⇒zeʳ
+  comm+zeʳ⇒zeˡ                      ↦  comm∧zeʳ⇒zeˡ
+  comm+invˡ⇒invʳ                    ↦  comm∧invˡ⇒invʳ
+  comm+invʳ⇒invˡ                    ↦  comm∧invʳ⇒invˡ
+  comm+distrˡ⇒distrʳ                ↦  comm∧distrˡ⇒distrʳ
+  comm+distrʳ⇒distrˡ                ↦  comm∧distrʳ⇒distrˡ
+  assoc+distribʳ+idʳ+invʳ⇒zeˡ       ↦  assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ
+  assoc+distribˡ+idʳ+invʳ⇒zeʳ       ↦  assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ
+  assoc+id+invʳ⇒invˡ-unique         ↦  assoc∧id∧invʳ⇒invˡ-unique
+  assoc+id+invˡ⇒invʳ-unique         ↦  assoc∧id∧invˡ⇒invʳ-unique
+  subst+comm⇒sym                    ↦  subst∧comm⇒sym
+  ```
+
+* In `Algebra.Construct.Zero`:
+  ```agda
+  rawMagma   ↦  Algebra.Construct.Terminal.rawMagma
+  magma      ↦  Algebra.Construct.Terminal.magma
+  semigroup  ↦  Algebra.Construct.Terminal.semigroup
+  band       ↦  Algebra.Construct.Terminal.band
+  ```
+
+* In `Codata.Guarded.Stream.Properties`:
+  ```agda
+  map-identity  ↦  map-id
+  map-fusion    ↦  map-∘
+  drop-fusion   ↦  drop-drop
+  ```
+
+* In `Codata.Sized.Colist.Properties`:
+  ```agda
+  map-identity      ↦  map-id
+  map-map-fusion    ↦  map-∘
+  drop-drop-fusion  ↦  drop-drop
+  ```
+
+* In `Codata.Sized.Covec.Properties`:
+  ```agda
+  map-identity   ↦  map-id
+  map-map-fusion  ↦  map-∘
+  ```
+
+* In `Codata.Sized.Delay.Properties`:
+  ```agda
+  map-identity      ↦  map-id
+  map-map-fusion    ↦  map-∘
+  map-unfold-fusion  ↦  map-unfold
+  ```
+
+* In `Codata.Sized.M.Properties`:
+  ```agda
+  map-compose  ↦  map-∘
+  ```
+
+* In `Codata.Sized.Stream.Properties`:
+  ```agda
+  map-identity   ↦  map-id
+  map-map-fusion  ↦  map-∘
+  ```
+
+* In `Data.Container.Related`:
+  ```agda
+  _∼[_]_  ↦  _≲[_]_
+  ```
+
+* In `Data.Bool.Properties` (Issue #2046):
+  ```agda
+  push-function-into-if ↦ if-float
+  ```
+
+* In `Data.Fin.Base`: two new, hopefully more memorable, names `↑ˡ` `↑ʳ`
+  for the 'left', resp. 'right' injection of a Fin m into a 'larger' type,
+  `Fin (m + n)`, resp. `Fin (n + m)`, with argument order to reflect the
+  position of the `Fin m` argument.
+  ```
+  inject+  ↦  flip _↑ˡ_
+  raise    ↦  _↑ʳ_
+  ```
+
+* In `Data.Fin.Properties`:
+  ```
+  toℕ-raise        ↦ toℕ-↑ʳ
+  toℕ-inject+      ↦ toℕ-↑ˡ
+  splitAt-inject+  ↦ splitAt-↑ˡ m i n
+  splitAt-raise    ↦ splitAt-↑ʳ
+  Fin0↔⊥           ↦ 0↔⊥
+  eq?              ↦ inj⇒≟
+  ```
+
+* In `Data.Fin.Permutation.Components`:
+  ```
+  reverse            ↦ Data.Fin.Base.opposite
+  reverse-prop       ↦ Data.Fin.Properties.opposite-prop
+  reverse-involutive ↦ Data.Fin.Properties.opposite-involutive
+  reverse-suc        ↦ Data.Fin.Properties.opposite-suc
+  ```
+
+* In `Data.Integer.DivMod` the operator names have been renamed to
+  be consistent with those in `Data.Nat.DivMod`:
+  ```
+  _divℕ_  ↦ _/ℕ_
+  _div_   ↦ _/_
+  _modℕ_  ↦ _%ℕ_
+  _mod_   ↦ _%_
+  ```
+
+* In `Data.Integer.Properties` references to variables in names have
+  been made consistent so that `m`, `n` always refer to naturals and
+  `i` and `j` always refer to integers:
+  ```
+  ≤-steps        ↦  i≤j⇒i≤k+j
+  ≤-step         ↦  i≤j⇒i≤1+j
+
+  ≤-steps-neg    ↦  i≤j⇒i-k≤j
+  ≤-step-neg     ↦  i≤j⇒pred[i]≤j
+
+  n≮n            ↦  i≮i
+  ∣n∣≡0⇒n≡0       ↦  ∣i∣≡0⇒i≡0
+  ∣-n∣≡∣n∣         ↦  ∣-i∣≡∣i∣
+  0≤n⇒+∣n∣≡n      ↦  0≤i⇒+∣i∣≡i
+  +∣n∣≡n⇒0≤n      ↦  +∣i∣≡i⇒0≤i
+  +∣n∣≡n⊎+∣n∣≡-n   ↦  +∣i∣≡i⊎+∣i∣≡-i
+  ∣m+n∣≤∣m∣+∣n∣     ↦  ∣i+j∣≤∣i∣+∣j∣
+  ∣m-n∣≤∣m∣+∣n∣     ↦  ∣i-j∣≤∣i∣+∣j∣
+  signₙ◃∣n∣≡n     ↦  signᵢ◃∣i∣≡i
+  ◃-≡            ↦  ◃-cong
+  ∣m-n∣≡∣n-m∣      ↦  ∣i-j∣≡∣j-i∣
+  m≡n⇒m-n≡0      ↦  i≡j⇒i-j≡0
+  m-n≡0⇒m≡n      ↦  i-j≡0⇒i≡j
+  m≤n⇒m-n≤0      ↦  i≤j⇒i-j≤0
+  m-n≤0⇒m≤n      ↦  i-j≤0⇒i≤j
+  m≤n⇒0≤n-m      ↦  i≤j⇒0≤j-i
+  0≤n-m⇒m≤n      ↦  0≤i-j⇒j≤i
+  n≤1+n          ↦  i≤suc[i]
+  n≢1+n          ↦  i≢suc[i]
+  m≤pred[n]⇒m<n  ↦  i≤pred[j]⇒i<j
+  m<n⇒m≤pred[n]  ↦  i<j⇒i≤pred[j]
+  -1*n≡-n        ↦  -1*i≡-i
+  m*n≡0⇒m≡0∨n≡0  ↦  i*j≡0⇒i≡0∨j≡0
+  ∣m*n∣≡∣m∣*∣n∣  ↦  ∣i*j∣≡∣i∣*∣j∣
+  m≤m+n          ↦  i≤i+j
+  n≤m+n          ↦  i≤j+i
+  m-n≤m          ↦  i≤i-j
+
+  +-pos-monoʳ-≤    ↦  +-monoʳ-≤
+  +-neg-monoʳ-≤    ↦  +-monoʳ-≤
+  *-monoʳ-≤-pos    ↦  *-monoʳ-≤-nonNeg
+  *-monoˡ-≤-pos    ↦  *-monoˡ-≤-nonNeg
+  *-monoʳ-≤-neg    ↦  *-monoʳ-≤-nonPos
+  *-monoˡ-≤-neg    ↦  *-monoˡ-≤-nonPos
+  *-cancelˡ-<-neg  ↦  *-cancelˡ-<-nonPos
+  *-cancelʳ-<-neg  ↦  *-cancelʳ-<-nonPos
+
+  ^-semigroup-morphism ↦ ^-isMagmaHomomorphism
+  ^-monoid-morphism    ↦ ^-isMonoidHomomorphism
+
+  pos-distrib-* ↦ pos-*
+  pos-+-commute ↦ pos-+
+  abs-*-commute ↦ abs-*
+
+  +-isAbelianGroup ↦ +-0-isAbelianGroup
+  ```
+
+* In `Data.List.Base`:
+  ```agda
+  _─_  ↦  removeAt
+  ```
+
+* In `Data.List.Properties`:
+  ```agda
+  map-id₂         ↦  map-id-local
+  map-cong₂       ↦  map-cong-local
+  map-compose     ↦  map-∘
+
+  map-++-commute       ↦  map-++
+  sum-++-commute       ↦  sum-++
+  reverse-map-commute  ↦  reverse-map
+  reverse-++-commute   ↦  reverse-++
+
+  zipWith-identityˡ  ↦  zipWith-zeroˡ
+  zipWith-identityʳ  ↦  zipWith-zeroʳ
+
+  ʳ++-++  ↦  ++-ʳ++
+
+  take++drop  ↦  take++drop≡id
+
+  length-─  ↦  length-removeAt
+  map-─     ↦  map-removeAt
+  ```
+
+* In `Data.List.NonEmpty.Properties`:
+  ```agda
+  map-compose     ↦  map-∘
+
+  map-++⁺-commute ↦  map-++⁺
+  ```
+
+* In `Data.List.Relation.Unary.All.Properties`:
+  ```agda
+  gmap  ↦  gmap⁺
+
+  updateAt-id-relative      ↦  updateAt-id-local
+  updateAt-compose-relative ↦  updateAt-updateAt-local
+  updateAt-compose          ↦  updateAt-updateAt
+  updateAt-cong-relative    ↦  updateAt-cong-local
+  ```
+
+* In `Data.List.Relation.Unary.Any.Properties`:
+  ```agda
+  map-with-∈⁺  ↦  mapWith∈⁺
+  map-with-∈⁻  ↦  mapWith∈⁻
+  map-with-∈↔  ↦  mapWith∈↔
+  ```
+
+* In `Data.List.Relation.Binary.Subset.Propositional.Properties`:
+  ```agda
+  map-with-∈⁺  ↦  mapWith∈⁺
+  ```
+
+* In `Data.List.Zipper.Properties`:
+  ```agda
+  toList-reverse-commute ↦  toList-reverse
+  toList-ˡ++-commute     ↦  toList-ˡ++
+  toList-++ʳ-commute     ↦  toList-++ʳ
+  toList-map-commute    ↦  toList-map
+  toList-foldr-commute  ↦  toList-foldr
+  ```
+
+* In `Data.Maybe.Properties`:
+  ```agda
+  map-id₂     ↦  map-id-local
+  map-cong₂   ↦  map-cong-local
+
+  map-compose    ↦  map-∘
+
+  map-<∣>-commute ↦  map-<∣>
+  ```
+
+* In `Data.Nat.Properties`:
+  ```agda
+  suc[pred[n]]≡n  ↦  suc-pred
+  ≤-step          ↦  m≤n⇒m≤1+n
+  ≤-stepsˡ        ↦  m≤n⇒m≤o+n
+  ≤-stepsʳ        ↦  m≤n⇒m≤n+o
+  <-step          ↦  m<n⇒m<1+n
+  pred-mono       ↦  pred-mono-≤
+
+  <-transʳ        ↦  ≤-<-trans
+  <-transˡ        ↦  <-≤-trans
+  ```
+
+* In `Data.Rational.Unnormalised.Base`:
+  ```agda
+  _≠_  ↦  _≄_
+  +-rawMonoid ↦ +-0-rawMonoid
+  *-rawMonoid ↦ *-1-rawMonoid
+  ```
+
+* In `Data.Rational.Unnormalised.Properties`:
+  ```agda
+  ↥[p/q]≡p         ↦  ↥[n/d]≡n
+  ↧[p/q]≡q         ↦  ↧[n/d]≡d
+  *-monoˡ-≤-pos    ↦  *-monoˡ-≤-nonNeg
+  *-monoʳ-≤-pos    ↦  *-monoʳ-≤-nonNeg
+  ≤-steps          ↦  p≤q⇒p≤r+q
+  *-monoˡ-≤-neg    ↦  *-monoˡ-≤-nonPos
+  *-monoʳ-≤-neg    ↦  *-monoʳ-≤-nonPos
+  *-cancelˡ-<-pos  ↦  *-cancelˡ-<-nonNeg
+  *-cancelʳ-<-pos  ↦  *-cancelʳ-<-nonNeg
+
+  positive⇒nonNegative  ↦ pos⇒nonNeg
+  negative⇒nonPositive  ↦ neg⇒nonPos
+  negative<positive     ↦ neg<pos
+  ```
+
+* In `Data.Rational.Base`:
+  ```agda
+  +-rawMonoid ↦ +-0-rawMonoid
+  *-rawMonoid ↦ *-1-rawMonoid
+  ```
+
+* In `Data.Rational.Properties`:
+  ```agda
+  *-monoʳ-≤-neg    ↦  *-monoʳ-≤-nonPos
+  *-monoˡ-≤-neg    ↦  *-monoˡ-≤-nonPos
+  *-monoʳ-≤-pos    ↦  *-monoʳ-≤-nonNeg
+  *-monoˡ-≤-pos    ↦  *-monoˡ-≤-nonNeg
+  *-cancelˡ-<-pos  ↦  *-cancelˡ-<-nonNeg
+  *-cancelʳ-<-pos  ↦  *-cancelʳ-<-nonNeg
+  *-cancelˡ-<-neg  ↦  *-cancelˡ-<-nonPos
+  *-cancelʳ-<-neg  ↦  *-cancelʳ-<-nonPos
+
+  negative<positive     ↦ neg<pos
+  ```
+
+* In `Data.Rational.Unnormalised.Base`:
+  ```agda
+  +-rawMonoid ↦ +-0-rawMonoid
+  *-rawMonoid ↦ *-1-rawMonoid
+  ```
+
+* In `Data.Rational.Unnormalised.Properties`:
+  ```agda
+  ≤-steps  ↦  p≤q⇒p≤r+q
+  ```
+
+* In `Data.Sum.Properties`:
+  ```agda
+  [,]-∘-distr      ↦  [,]-∘
+  [,]-map-commute  ↦  [,]-map
+  map-commute      ↦  map-map
+  map₁₂-commute    ↦  map₁₂-map₂₁
+  ```
+
+* In `Data.Tree.AVL`:
+  ```agda
+  _∈?_ ↦ member
+  ```
+
+* In `Data.Tree.AVL.IndexedMap`:
+  ```agda
+  _∈?_ ↦ member
+  ```
+
+* In `Data.Tree.AVL.Map`:
+  ```agda
+  _∈?_ ↦ member
+  ```
+
+* In `Data.Tree.AVL.Sets`:
+  ```agda
+  _∈?_ ↦ member
+  ```
+
+* In `Data.Tree.Binary.Zipper.Properties`:
+  ```agda
+  toTree-#nodes-commute   ↦  toTree-#nodes
+  toTree-#leaves-commute  ↦  toTree-#leaves
+  toTree-map-commute      ↦  toTree-map
+  toTree-foldr-commute    ↦  toTree-foldr
+  toTree-⟪⟫ˡ-commute      ↦  toTree--⟪⟫ˡ
+  toTree-⟪⟫ʳ-commute      ↦  toTree-⟪⟫ʳ
+  ```
+
+* In `Data.Tree.Rose.Properties`:
+  ```agda
+  map-compose     ↦  map-∘
+  ```
+
+* In `Data.Vec.Base`:
+  ```agda
+  remove  ↦  removeAt
+  insert  ↦  insertAt
+  ```
+
+* In `Data.Vec.Properties`:
+  ```agda
+  take-distr-zipWith ↦  take-zipWith
+  take-distr-map     ↦  take-map
+  drop-distr-zipWith ↦  drop-zipWith
+  drop-distr-map     ↦  drop-map
+
+  updateAt-id-relative      ↦  updateAt-id-local
+  updateAt-compose-relative ↦  updateAt-updateAt-local
+  updateAt-compose          ↦  updateAt-updateAt
+  updateAt-cong-relative    ↦  updateAt-cong-local
+
+  []%=-compose    ↦  []%=-∘
+
+  []≔-++-inject+  ↦ []≔-++-↑ˡ
+  []≔-++-raise    ↦ []≔-++-↑ʳ
+  idIsFold        ↦ id-is-foldr
+  sum-++-commute  ↦ sum-++
+
+  take-drop-id  ↦  take++drop≡id
+
+  map-insert       ↦  map-insertAt
+
+  insert-lookup    ↦  insertAt-lookup
+  insert-punchIn   ↦  insertAt-punchIn
+  remove-PunchOut  ↦  removeAt-punchOut
+  remove-insert    ↦  removeAt-insertAt
+  insert-remove    ↦  insertAt-removeAt
+
+  lookup-inject≤-take ↦ lookup-take-inject≤
+  ```
+
+* In `Data.Vec.Functional.Properties`:
+  ```agda
+  updateAt-id-relative      ↦  updateAt-id-local
+  updateAt-compose-relative ↦  updateAt-updateAt-local
+  updateAt-compose          ↦  updateAt-updateAt
+  updateAt-cong-relative    ↦  updateAt-cong-local
+
+  map-updateAt              ↦  map-updateAt-local
+
+  insert-lookup             ↦  insertAt-lookup
+  insert-punchIn            ↦  insertAt-punchIn
+  remove-punchOut           ↦  removeAt-punchOut
+  remove-insert             ↦  removeAt-insertAt
+  insert-remove             ↦  insertAt-removeAt
+  ```
+  NB. This last one is complicated by the *addition* of a 'global' property `map-updateAt`
+
+* In `Data.Vec.Recursive.Properties`:
+  ```agda
+  append-cons-commute  ↦  append-cons
+  ```
+
+* In `Data.Vec.Relation.Binary.Equality.Setoid`:
+  ```agda
+  map-++-commute ↦  map-++
+  ```
+
+* In `Function.Base`:
+  ```agda
+  case_return_of_   ↦   case_returning_of_
+  ```
+
+* In `Function.Construct.Composition`:
+  ```agda
+  _∘-⟶_   ↦   _⟶-∘_
+  _∘-↣_   ↦   _↣-∘_
+  _∘-↠_   ↦   _↠-∘_
+  _∘-⤖_  ↦   _⤖-∘_
+  _∘-⇔_   ↦   _⇔-∘_
+  _∘-↩_   ↦   _↩-∘_
+  _∘-↪_   ↦   _↪-∘_
+  _∘-↔_   ↦   _↔-∘_
+  ```
+
+  * In `Function.Construct.Identity`:
+  ```agda
+  id-⟶   ↦   ⟶-id
+  id-↣   ↦   ↣-id
+  id-↠   ↦   ↠-id
+  id-⤖  ↦   ⤖-id
+  id-⇔   ↦   ⇔-id
+  id-↩   ↦   ↩-id
+  id-↪   ↦   ↪-id
+  id-↔   ↦   ↔-id
+  ```
+
+* In `Function.Construct.Symmetry`:
+  ```agda
+  sym-⤖   ↦   ⤖-sym
+  sym-⇔   ↦   ⇔-sym
+  sym-↩   ↦   ↩-sym
+  sym-↪   ↦   ↪-sym
+  sym-↔   ↦   ↔-sym
+  ```
+
+* In `Function.Related.Propositional.Reasoning`:
+  ```agda
+  _↔⟨⟩_  ↦  _≡⟨⟩_
+  ```
+
+* In `Foreign.Haskell.Either` and `Foreign.Haskell.Pair`:
+  ```agda
+  toForeign   ↦ Foreign.Haskell.Coerce.coerce
+  fromForeign ↦ Foreign.Haskell.Coerce.coerce
+  ```
+
+* In `Relation.Binary.Properties.Preorder`:
+  ```agda
+  invIsPreorder ↦ converse-isPreorder
+  invPreorder   ↦ converse-preorder
+  ```
+
+* In `Relation.Binary.PropositionalEquality`:
+  ```agda
+  isPropositional ↦ Relation.Nullary.Irrelevant
+  ```
+
+* In `Relation.Unary.Consequences`:
+  ```agda
+  dec⟶recomputable  ↦  dec⇒recomputable
+  ```
+
+## Missing fixity declarations added
+
+* An effort has been made to add sensible fixities for many declarations:
+  ```
+  infix   4 _≟H_ _≟N_                                        (Algebra.Solver.Ring)
+  infixr  5 _∷_                                              (Codata.Guarded.Stream)
+  infix   4 _[_]                                             (Codata.Guarded.Stream)
+  infixr  5 _∷_                                              (Codata.Guarded.Stream.Relation.Binary.Pointwise)
+  infix   4 _≈∞_                                             (Codata.Guarded.Stream.Relation.Binary.Pointwise)
+  infixr  5 _∷_                                              (Codata.Guarded.Stream.Relation.Unary.All)
+  infixr  5 _∷_                                              (Codata.Musical.Colist)
+  infix   4 _≈_                                              (Codata.Musical.Conat)
+  infixr  5 _∷_                                              (Codata.Musical.Colist.Bisimilarity)
+  infixr  5 _∷_                                              (Codata.Musical.Colist.Relation.Unary.All)
+  infixr  5 _∷_                                              (Codata.Sized.Colist)
+  infixr  5 _∷_                                              (Codata.Sized.Covec)
+  infixr  5 _∷_                                              (Codata.Sized.Cowriter)
+  infixl  1 _>>=_                                            (Codata.Sized.Cowriter)
+  infixr  5 _∷_                                              (Codata.Sized.Stream)
+  infixr  5 _∷_                                              (Codata.Sized.Colist.Bisimilarity)
+  infix   4 _ℕ≤?_                                            (Codata.Sized.Conat.Properties)
+  infixr  5 _∷_                                              (Codata.Sized.Covec.Bisimilarity)
+  infixr  5 _∷_                                              (Codata.Sized.Cowriter.Bisimilarity)
+  infixr  5 _∷_                                              (Codata.Sized.Stream.Bisimilarity)
+  infix   4 _ℕ<_ _ℕ≤infinity _ℕ≤_                            (Codata.Sized.Conat)
+  infix   6 _ℕ+_ _+ℕ_                                        (Codata.Sized.Conat)
+  infixr  8 _⇒_ _⊸_                                          (Data.Container.Core)
+  infixr -1 _<$>_ _<*>_                                      (Data.Container.FreeMonad)
+  infixl  1 _>>=_                                            (Data.Container.FreeMonad)
+  infix   5 _▷_                                              (Data.Container.Indexed)
+  infixr  4 _,_                                              (Data.Container.Relation.Binary.Pointwise)
+  infix   4 _≈_                                              (Data.Float.Base)
+  infixl  4 _+ _*                                            (Data.List.Kleene.Base)
+  infixr  4 _++++_ _+++*_ _*+++_ _*++*_                      (Data.List.Kleene.Base)
+  infix   4 _[_]* _[_]+                                      (Data.List.Kleene.Base)
+  infix   4 _≢∈_                                             (Data.List.Membership.Propositional)
+  infixr  5 _`∷_                                             (Data.List.Reflection)
+  infix   4 _≡?_                                             (Data.List.Relation.Binary.Equality.DecPropositional)
+  infixr  5 _++ᵖ_                                            (Data.List.Relation.Binary.Prefix.Heterogeneous)
+  infixr  5 _++ˢ_                                            (Data.List.Relation.Binary.Suffix.Heterogeneous)
+  infixr  5 _++_ _++[]                                       (Data.List.Relation.Ternary.Appending.Propositional)
+  infixr  5 _∷=_                                             (Data.List.Relation.Unary.Any)
+  infixr  5 _++_                                             (Data.List.Ternary.Appending)
+  infixl  7 _⊓′_                                             (Data.Nat.Base)
+  infixl  6 _⊔′_                                             (Data.Nat.Base)
+  infixr  8 _^_                                              (Data.Nat.Base)
+  infix   4 _!≢0 _!*_!≢0                                     (Data.Nat.Properties)
+  infixl  6.5 _P′_ _P_ _C′_ _C_                              (Data.Nat.Combinatorics.Base)
+  infix   8 _⁻¹                                              (Data.Parity.Base)
+  infixr  2 _×-⇔_ _×-↣_ _×-↞_ _×-↠_ _×-↔_ _×-cong_           (Data.Product.Function.NonDependent.Propositional)
+  infixr  2 _×-⟶_                                           (Data.Product.Function.NonDependent.Setoid)
+  infixr  2 _×-equivalence_ _×-injection_ _×-left-inverse_   (Data.Product.Function.NonDependent.Setoid)
+  infixr  2 _×-surjection_ _×-inverse_                       (Data.Product.Function.NonDependent.Setoid)
+  infix   4 _≃?_                                             (Data.Rational.Unnormalised.Properties)
+  infixr  4 _,_                                              (Data.Refinement)
+  infixr  1 _⊎-⇔_ _⊎-↣_ _⊎-↞_ _⊎-↠_ _⊎-↔_ _⊎-cong_           (Data.Sum.Function.Propositional)
+  infixr  1 _⊎-⟶_                                           (Data.Sum.Function.Setoid)
+  infixr  1 _⊎-equivalence_ _⊎-injection_ _⊎-left-inverse_   (Data.Sum.Function.Setoid)
+  infixr  1 _⊎-surjection_ _⊎-inverse_                       (Data.Sum.Function.Setoid)
+  infixr  4 _,_                                              (Data.Tree.AVL.Value)
+  infix   4 _≈ₖᵥ_                                            (Data.Tree.AVL.Map.Membership.Propositional)
+  infixr  5 _`∷_                                             (Data.Vec.Reflection)
+  infixr  5 _∷=_                                             (Data.Vec.Membership.Setoid)
+  infix  -1 _$ⁿ_                                             (Data.Vec.N-ary)
+  infix   4 _≋_                                              (Data.Vec.Functional.Relation.Binary.Equality.Setoid)
+  infixl  1 _>>=-cong_ _≡->>=-cong_                          (Effect.Monad.Partiality)
+  infixl  1 _?>=′_                                           (Effect.Monad.Predicate)
+  infixl  1 _>>=-cong_ _>>=-congP_                           (Effect.Monad.Partiality.All)
+  infixr  5 _∷_                                              (Foreign.Haskell.List.NonEmpty)
+  infixr  4 _,_                                              (Foreign.Haskell.Pair)
+  infixr  8 _^_                                              (Function.Endomorphism.Propositional)
+  infixr  8 _^_                                              (Function.Endomorphism.Setoid)
+  infix   4 _≃_                                              (Function.HalfAdjointEquivalence)
+  infix   4 _≈_ _≈ᵢ_ _≤_                                     (Function.Metric.Bundles)
+  infixl  6 _∙_                                              (Function.Metric.Bundles)
+  infix   4 _≈_                                              (Function.Metric.Nat.Bundles)
+  infix   4 _≈_                                              (Function.Metric.Rational.Bundles)
+  infix   3 _←_ _↢_                                          (Function.Related)
+  infix   4 _<_                                              (Induction.WellFounded)
+  infixl  6 _ℕ+_                                             (Level.Literals)
+  infixr  4 _,_                                              (Reflection.AnnotatedAST)
+  infix   4 _≟_                                              (Reflection.AST.Definition)
+  infix   4 _≡ᵇ_                                             (Reflection.AST.Literal)
+  infix   4 _≈?_ _≟_ _≈_                                     (Reflection.AST.Meta)
+  infix   4 _≈?_ _≟_ _≈_                                     (Reflection.AST.Name)
+  infix   4 _≟-Telescope_                                    (Reflection.AST.Term)
+  infix   4 _≟_                                              (Reflection.AST.Argument.Information)
+  infix   4 _≟_                                              (Reflection.AST.Argument.Modality)
+  infix   4 _≟_                                              (Reflection.AST.Argument.Quantity)
+  infix   4 _≟_                                              (Reflection.AST.Argument.Relevance)
+  infix   4 _≟_                                              (Reflection.AST.Argument.Visibility)
+  infixr  4 _,_                                              (Reflection.AST.Traversal)
+  infix   4 _∈FV_                                            (Reflection.AST.DeBruijn)
+  infixr  9 _;_                                              (Relation.Binary.Construct.Composition)
+  infixl  6 _+²_                                             (Relation.Binary.HeterogeneousEquality.Quotients.Examples)
+  infixr -1 _atₛ_                                             (Relation.Binary.Indexed.Heterogeneous.Construct.At)
+  infixr -1 _atₛ_                                             (Relation.Binary.Indexed.Homogeneous.Construct.At)
+  infix   4 _∈_ _∉_                                          (Relation.Unary.Indexed)
+  infix   4 _≈_                                              (Relation.Binary.Bundles)
+  infixl  6 _∩_                                              (Relation.Binary.Construct.Intersection)
+  infix   4 _<₋_                                             (Relation.Binary.Construct.Add.Infimum.Strict)
+  infix   4 _≈∙_                                             (Relation.Binary.Construct.Add.Point.Equality)
+  infix   4 _≤⁺_ _≤⊤⁺                                        (Relation.Binary.Construct.Add.Supremum.NonStrict)
+  infixr  5 _∷ʳ_                                             (Relation.Binary.Construct.Closure.Transitive)
+  infixr  6 _∪_                                              (Relation.Binary.Construct.Union)
+  infixl  6 _+ℤ_                                             (Relation.Binary.HeterogeneousEquality.Quotients.Examples)
+  infix   4 _≉_ _≈ᵢ_ _≤ᵢ_                                    (Relation.Binary.Indexed.Homogeneous.Bundles)
+  infixr  9 _⍮_                                              (Relation.Unary.PredicateTransformer)
+  infix   8 ∼_                                               (Relation.Unary.PredicateTransformer)
+  infix   2 _×?_ _⊙?_                                        (Relation.Unary.Properties)
+  infix   10 _~?                                             (Relation.Unary.Properties)
+  infixr  1 _⊎?_                                             (Relation.Unary.Properties)
+  infixr  7 _∩?_                                             (Relation.Unary.Properties)
+  infixr  6 _∪?_                                             (Relation.Unary.Properties)
+  infixr  5 _∷ᴹ_ _∷⁻¹ᴹ_                                      (Text.Regex.Search)
+  infixl  6 _`⊜_                                             (Tactic.RingSolver)
+  infix   8 ⊝_                                               (Tactic.RingSolver.Core.Expression)
+  infix   4 _∈ᴿ?_ _∉ᴿ?_ _∈?ε _∈?[_] _∈?[^_]                  (Text.Regex.Properties)
+  infix   4 _∈?_ _∉?_                                        (Text.Regex.Derivative.Brzozowski)
+  infix   4 _∈_ _∉_ _∈?_ _∉?_                                (Text.Regex.String.Unsafe)
+  ```
+
+New modules
+-----------
+
+* Constructive algebraic structures with apartness relations:
+  ```
+  Algebra.Apartness
+  Algebra.Apartness.Bundles
+  Algebra.Apartness.Structures
+  Algebra.Apartness.Properties.CommutativeHeytingAlgebra
+  Relation.Binary.Properties.ApartnessRelation
+  ```
+
+* Algebraic structures obtained by flipping their binary operations:
+  ```
+  Algebra.Construct.Flip.Op
+  ```
+
+* Algebraic structures when freely adding an identity element:
+  ```
+  Algebra.Construct.Add.Identity
+  ```
+
+* Definitions for algebraic modules:
+  ```
+  Algebra.Module
+  Algebra.Module.Core
+  Algebra.Module.Definitions.Bi.Simultaneous
+  Algebra.Module.Morphism.Construct.Composition
+  Algebra.Module.Morphism.Construct.Identity
+  Algebra.Module.Morphism.Definitions
+  Algebra.Module.Morphism.ModuleHomomorphism
+  Algebra.Module.Morphism.Structures
+  Algebra.Module.Properties
+  ```
+
+* Identity morphisms and composition of morphisms between algebraic structures:
+  ```
+  Algebra.Morphism.Construct.Composition
+  Algebra.Morphism.Construct.Identity
+  ```
+
+* Properties of various new algebraic structures:
+  ```
+  Algebra.Properties.MoufangLoop
+  Algebra.Properties.Quasigroup
+  Algebra.Properties.MiddleBolLoop
+  Algebra.Properties.Loop
+  Algebra.Properties.KleeneAlgebra
+  ```
+
+* Properties of rings without a unit
+  ```
+  Algebra.Properties.RingWithoutOne`
+  ```
+
+* Proof of the Binomial Theorem for semirings
+  ```
+  Algebra.Properties.Semiring.Binomial
+  Algebra.Properties.CommutativeSemiring.Binomial
+  ```
+
+* 'Optimised' tail-recursive exponentiation properties:
+  ```
+  Algebra.Properties.Semiring.Exp.TailRecursiveOptimised
+  ```
+
+* An implementation of M-types with `--guardedness` flag:
+  ```
+  Codata.Guarded.M
+  ```
+
+* A definition of infinite streams using coinductive records:
+  ```
+  Codata.Guarded.Stream
+  Codata.Guarded.Stream.Properties
+  Codata.Guarded.Stream.Relation.Binary.Pointwise
+  Codata.Guarded.Stream.Relation.Unary.All
+  Codata.Guarded.Stream.Relation.Unary.Any
+  ```
+
+* A small library for function arguments with default values:
+  ```
+  Data.Default
+  ```
+
+* A small library defining a structurally recursive view of `Fin n`:
+  ```
+  Data.Fin.Relation.Unary.Top
+  ```
+
+* A small library for a non-empty fresh list:
+  ```
+  Data.List.Fresh.NonEmpty
+  ```
+
+* A small library defining a structurally inductive view of lists:
+  ```
+  Data.List.Relation.Unary.Sufficient
+  ```
+
+* Combinations and permutations for ℕ.
+  ```
+  Data.Nat.Combinatorics
+  Data.Nat.Combinatorics.Base
+  Data.Nat.Combinatorics.Spec
+  ```
+
+* A small library defining parity and its algebra:
+  ```
+  Data.Parity
+  Data.Parity.Base
+  Data.Parity.Instances
+  Data.Parity.Properties
+  ```
+
+* New base module for `Data.Product` containing only the basic definitions.
+  ```
+  Data.Product.Base
+  ```
+
+* Reflection utilities for some specific types:
+  ```
+  Data.List.Reflection
+  Data.Vec.Reflection
+  ```
+
+* The `All` predicate over non-empty lists:
+  ```
+  Data.List.NonEmpty.Relation.Unary.All
+  ```
+
+* Some n-ary functions manipulating lists
+  ```
+  Data.List.Nary.NonDependent
+  ```
+
+* Added Logarithm base 2 on natural numbers:
+  ```
+  Data.Nat.Logarithm.Core
+  Data.Nat.Logarithm
+  ```
+
+* Show module for unnormalised rationals:
+  ```
+  Data.Rational.Unnormalised.Show
+  ```
+
+* Membership relations for maps and sets
+  ```
+  Data.Tree.AVL.Map.Membership.Propositional
+  Data.Tree.AVL.Map.Membership.Propositional.Properties
+  Data.Tree.AVL.Sets.Membership
+  Data.Tree.AVL.Sets.Membership.Properties
+  ```
+
+* Port of `Linked` to `Vec`:
+  ```
+  Data.Vec.Relation.Unary.Linked
+  Data.Vec.Relation.Unary.Linked.Properties
+  ```
+
+* Combinators for propositional equational reasoning on vectors with different indices
+  ```
+  Data.Vec.Relation.Binary.Equality.Cast
+  ```
+
+* Relations on indexed sets
+  ```
+  Function.Indexed.Bundles
+  ```
+
+* Properties of various types of functions:
+  ```
+  Function.Consequences
+  Function.Consequences.Setoid
+  Function.Consequences.Propositional
+  Function.Properties.Bijection
+  Function.Properties.RightInverse
+  Function.Properties.Surjection
+  Function.Construct.Constant
+  ```
+
+* New interface for `NonEmpty` Haskell lists:
+  ```
+  Foreign.Haskell.List.NonEmpty
+  ```
+
+* In order to improve modularity, the contents of `Relation.Binary.Lattice` has been
+  split out into the standard:
+  ```
+  Relation.Binary.Lattice.Definitions
+  Relation.Binary.Lattice.Structures
+  Relation.Binary.Lattice.Bundles
+  ```
+  All contents is re-exported by `Relation.Binary.Lattice` as before.
+
+
+* Added relational reasoning over apartness relations:
+  ```
+  Relation.Binary.Reasoning.Base.Apartness`
+  ```
+
+* Algebraic properties of `_∩_` and `_∪_` for predicates
+  ```
+  Relation.Unary.Algebra
+  ```
+
+* Both versions of equality on predicates are equivalences
+  ```
+  Relation.Unary.Relation.Binary.Equality
+  ```
+
+* The subset relations on predicates define an order
+  ```
+  Relation.Unary.Relation.Binary.Subset
+  ```
+
+* Polymorphic versions of some unary relations and their properties
+  ```
+  Relation.Unary.Polymorphic
+  Relation.Unary.Polymorphic.Properties
+  ```
+
+* Alpha equality over reflected terms
+  ```
+  Reflection.AST.AlphaEquality
+  ```
+
+* Various system types and primitives:
+  ```
+  System.Clock.Primitive
+  System.Clock
+  System.Console.ANSI
+  System.Directory.Primitive
+  System.Directory
+  System.FilePath.Posix.Primitive
+  System.FilePath.Posix
+  System.Process.Primitive
+  System.Process
+  ```
+
+* A new `cong!` tactic for automatically deriving arguments to `cong`
+  ```
+  Tactic.Cong
+  ```
+
+* A golden testing library with test pools, an options parser, a runner:
+  ```
+  Test.Golden
+  ```
+
+Additions to existing modules
+-----------------------------
+
+* The module `Algebra` now publicly re-exports the contents of
+  `Algebra.Structures.Biased`.
+
+* Added new definitions to `Algebra.Bundles`:
+  ```agda
+  record UnitalMagma           c ℓ : Set (suc (c ⊔ ℓ))
+  record InvertibleMagma       c ℓ : Set (suc (c ⊔ ℓ))
+  record InvertibleUnitalMagma c ℓ : Set (suc (c ⊔ ℓ))
+  record Quasigroup            c ℓ : Set (suc (c ⊔ ℓ))
+  record Loop                  c ℓ : Set (suc (c ⊔ ℓ))
+  record RingWithoutOne        c ℓ : Set (suc (c ⊔ ℓ))
+  record IdempotentSemiring    c ℓ : Set (suc (c ⊔ ℓ))
+  record KleeneAlgebra         c ℓ : Set (suc (c ⊔ ℓ))
+  record Quasiring             c ℓ : Set (suc (c ⊔ ℓ))
+  record Nearring              c ℓ : Set (suc (c ⊔ ℓ))
+  record IdempotentMagma       c ℓ : Set (suc (c ⊔ ℓ))
+  record AlternateMagma        c ℓ : Set (suc (c ⊔ ℓ))
+  record FlexibleMagma         c ℓ : Set (suc (c ⊔ ℓ))
+  record MedialMagma           c ℓ : Set (suc (c ⊔ ℓ))
+  record SemimedialMagma       c ℓ : Set (suc (c ⊔ ℓ))
+  record LeftBolLoop           c ℓ : Set (suc (c ⊔ ℓ))
+  record RightBolLoop          c ℓ : Set (suc (c ⊔ ℓ))
+  record MoufangLoop           c ℓ : Set (suc (c ⊔ ℓ))
+  record NonAssociativeRing    c ℓ : Set (suc (c ⊔ ℓ))
+  record MiddleBolLoop         c ℓ : Set (suc (c ⊔ ℓ))
+  ```
+
+* Added new definitions to `Algebra.Bundles.Raw`:
+  ```agda
+  record RawLoop               c ℓ : Set (suc (c ⊔ ℓ))
+  record RawQuasiGroup         c ℓ : Set (suc (c ⊔ ℓ))
+  record RawRingWithoutOne     c ℓ : Set (suc (c ⊔ ℓ))
+  ```
+
+* Added new definitions to `Algebra.Structures`:
+  ```agda
+  record IsUnitalMagma (_∙_ : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
+  record IsInvertibleMagma (_∙_ : Op₂ A) (ε : A) (_⁻¹ : Op₁ A) : Set (a ⊔ ℓ)
+  record IsInvertibleUnitalMagma (_∙_ : Op₂ A) (ε : A) (⁻¹ : Op₁ A) : Set (a ⊔ ℓ)
+  record IsQuasigroup (∙ \\ // : Op₂ A) : Set (a ⊔ ℓ)
+  record IsLoop (∙ \\ // : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
+  record IsRingWithoutOne (+ * : Op₂ A) (-_ : Op₁ A) (0# : A) : Set (a ⊔ ℓ)
+  record IsIdempotentSemiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ)
+  record IsKleeneAlgebra (+ * : Op₂ A) (⋆ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ)
+  record IsQuasiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ) where
+  record IsNearring (+ * : Op₂ A) (0# 1# : A) (_⁻¹ : Op₁ A) : Set (a ⊔ ℓ) where
+  record IsIdempotentMagma (∙ : Op₂ A) : Set (a ⊔ ℓ)
+  record IsAlternativeMagma (∙ : Op₂ A) : Set (a ⊔ ℓ)
+  record IsFlexibleMagma (∙ : Op₂ A) : Set (a ⊔ ℓ)
+  record IsMedialMagma (∙ : Op₂ A) : Set (a ⊔ ℓ)
+  record IsSemimedialMagma (∙ : Op₂ A) : Set (a ⊔ ℓ)
+  record IsLeftBolLoop (∙ \\ // : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
+  record IsRightBolLoop (∙ \\ // : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
+  record IsMoufangLoop (∙ \\ // : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
+  record IsNonAssociativeRing (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ)
+  record IsMiddleBolLoop (∙ \\ // : Op₂ A) (ε : A) : Set (a ⊔ ℓ)
+  ```
+
+* Added new proof to `Algebra.Consequences.Base`:
+  ```agda
+  reflexive∧selfInverse⇒involutive : Reflexive _≈_ → SelfInverse _≈_ f → Involutive _≈_ f
+  ```
+
+* Added new proofs to `Algebra.Consequences.Propositional`:
+  ```agda
+  comm∧assoc⇒middleFour     : Commutative _∙_ → Associative _∙_ → _∙_ MiddleFourExchange _∙_
+  identity∧middleFour⇒assoc : Identity e _∙_ → _∙_ MiddleFourExchange _∙_ → Associative _∙_
+  identity∧middleFour⇒comm  : Identity e _+_ → _∙_ MiddleFourExchange _+_ → Commutative _∙_
+  ```
+
+* Added new proofs to `Algebra.Consequences.Setoid`:
+  ```agda
+  comm∧assoc⇒middleFour     : Congruent₂ _∙_ → Commutative _∙_ → Associative _∙_ → _∙_ MiddleFourExchange _∙_
+  identity∧middleFour⇒assoc : Congruent₂ _∙_ → Identity e _∙_ → _∙_ MiddleFourExchange _∙_ → Associative _∙_
+  identity∧middleFour⇒comm  : Congruent₂ _∙_ → Identity e _+_ → _∙_ MiddleFourExchange _+_ → Commutative _∙_
+
+  involutive⇒surjective  : Involutive f  → Surjective f
+  selfInverse⇒involutive : SelfInverse f → Involutive f
+  selfInverse⇒congruent  : SelfInverse f → Congruent f
+  selfInverse⇒inverseᵇ   : SelfInverse f → Inverseᵇ f f
+  selfInverse⇒surjective : SelfInverse f → Surjective f
+  selfInverse⇒injective  : SelfInverse f → Injective f
+  selfInverse⇒bijective  : SelfInverse f → Bijective f
+
+  comm∧idˡ⇒id              : Commutative _∙_ → LeftIdentity  e _∙_ → Identity e _∙_
+  comm∧idʳ⇒id              : Commutative _∙_ → RightIdentity e _∙_ → Identity e _∙_
+  comm∧zeˡ⇒ze              : Commutative _∙_ → LeftZero      e _∙_ → Zero     e _∙_
+  comm∧zeʳ⇒ze              : Commutative _∙_ → RightZero     e _∙_ → Zero     e _∙_
+  comm∧invˡ⇒inv            : Commutative _∙_ → LeftInverse  e _⁻¹ _∙_ → Inverse e _⁻¹ _∙_
+  comm∧invʳ⇒inv            : Commutative _∙_ → RightInverse e _⁻¹ _∙_ → Inverse e _⁻¹ _∙_
+  comm∧distrˡ⇒distr        : Commutative _∙_ → _∙_ DistributesOverˡ _◦_ → _∙_ DistributesOver _◦_
+  comm∧distrʳ⇒distr        : Commutative _∙_ → _∙_ DistributesOverʳ _◦_ → _∙_ DistributesOver _◦_
+  distrib∧absorbs⇒distribˡ : Associative _∙_ → Commutative _◦_ → _∙_ Absorbs _◦_ → _◦_ Absorbs _∙_ → _◦_ DistributesOver _∙_ → _∙_ DistributesOverˡ _◦_
+  ```
+
+* Added new functions to `Algebra.Construct.DirectProduct`:
+  ```agda
+  rawSemiring                     : RawSemiring a ℓ₁ → RawSemiring b ℓ₂ → RawSemiring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  rawRing                         : RawRing a ℓ₁ → RawRing b ℓ₂ → RawRing (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  semiringWithoutAnnihilatingZero : SemiringWithoutAnnihilatingZero a ℓ₁ →
+                                    SemiringWithoutAnnihilatingZero b ℓ₂ →
+                                    SemiringWithoutAnnihilatingZero (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  semiring                        : Semiring a ℓ₁ → Semiring b ℓ₂ → Semiring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  commutativeSemiring             : CommutativeSemiring a ℓ₁ →
+                                        CommutativeSemiring b ℓ₂ →
+                                    CommutativeSemiring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  ring                            : Ring a ℓ₁ → Ring b ℓ₂ → Ring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  commutativeRing                 : CommutativeRing a ℓ₁ → CommutativeRing b ℓ₂ → CommutativeRing (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  rawQuasigroup                   : RawQuasigroup a ℓ₁ → RawQuasigroup b ℓ₂ → RawQuasigroup (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  rawLoop                         : RawLoop a ℓ₁ → RawLoop b ℓ₂ → RawLoop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  unitalMagma                     : UnitalMagma a ℓ₁ → UnitalMagma b ℓ₂ → UnitalMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  invertibleMagma                 : InvertibleMagma a ℓ₁ → InvertibleMagma b ℓ₂ → InvertibleMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  invertibleUnitalMagma           : InvertibleUnitalMagma a ℓ₁ →
+                                        InvertibleUnitalMagma b ℓ₂ →
+                                    InvertibleUnitalMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  quasigroup                      : Quasigroup a ℓ₁ → Quasigroup b ℓ₂ → Quasigroup (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  loop                            : Loop a ℓ₁ → Loop b ℓ₂ → Loop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  idempotentSemiring              : IdempotentSemiring a ℓ₁ →
+                                    IdempotentSemiring b ℓ₂ →
+                                                                        IdempotentSemiring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  idempotentMagma                 : IdempotentMagma a ℓ₁ → IdempotentMagma b ℓ₂ → IdempotentMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  alternativeMagma                : AlternativeMagma a ℓ₁ → AlternativeMagma b ℓ₂ → AlternativeMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  flexibleMagma                   : FlexibleMagma a ℓ₁ → FlexibleMagma b ℓ₂ → FlexibleMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  medialMagma                     : MedialMagma a ℓ₁ → MedialMagma b ℓ₂ → MedialMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  semimedialMagma                 : SemimedialMagma a ℓ₁ → SemimedialMagma b ℓ₂ → SemimedialMagma (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  kleeneAlgebra                   : KleeneAlgebra a ℓ₁ → KleeneAlgebra b ℓ₂ → KleeneAlgebra (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  leftBolLoop                     : LeftBolLoop a ℓ₁ → LeftBolLoop b ℓ₂ → LeftBolLoop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  rightBolLoop                    : RightBolLoop a ℓ₁ → RightBolLoop b ℓ₂ → RightBolLoop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  middleBolLoop                   : MiddleBolLoop a ℓ₁ → MiddleBolLoop b ℓ₂ → MiddleBolLoop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  moufangLoop                     : MoufangLoop a ℓ₁ → MoufangLoop b ℓ₂ → MoufangLoop (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  rawRingWithoutOne               : RawRingWithoutOne a ℓ₁ → RawRingWithoutOne b ℓ₂ → RawRingWithoutOne (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  ringWithoutOne                  : RingWithoutOne a ℓ₁ → RingWithoutOne b ℓ₂ → RingWithoutOne (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  nonAssociativeRing              : NonAssociativeRing a ℓ₁ →
+                                            NonAssociativeRing b ℓ₂ →
+                                                                        NonAssociativeRing (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  quasiring                       : Quasiring a ℓ₁ → Quasiring b ℓ₂ → Quasiring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  nearring                        : Nearring a ℓ₁ → Nearring b ℓ₂ → Nearring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+  ```
+
+* Added new definition to `Algebra.Definitions`:
+  ```agda
+  _*_ MiddleFourExchange _+_ = ∀ w x y z → ((w + x) * (y + z)) ≈ ((w + y) * (x + z))
+
+  SelfInverse f = ∀ {x y} → f x ≈ y → f y ≈ x
+
+  LeftDividesˡ  _∙_ _\\_ = ∀ x y → (x ∙ (x \\ y)) ≈ y
+  LeftDividesʳ  _∙_ _\\_ = ∀ x y → (x \\ (x ∙ y)) ≈ y
+  RightDividesˡ _∙_ _//_ = ∀ x y → ((y // x) ∙ x) ≈ y
+  RightDividesʳ _∙_ _//_ = ∀ x y → ((y ∙ x) // x) ≈ y
+  LeftDivides    ∙   \\ = (LeftDividesˡ ∙ \\) × (LeftDividesʳ ∙ \\)
+  RightDivides   ∙   // = (RightDividesˡ ∙ //) × (RightDividesʳ ∙ //)
+
+  LeftInvertible  e _∙_ x = ∃[ x⁻¹ ] (x⁻¹ ∙ x) ≈ e
+  RightInvertible e _∙_ x = ∃[ x⁻¹ ] (x ∙ x⁻¹) ≈ e
+  Invertible      e _∙_ x = ∃[ x⁻¹ ] ((x⁻¹ ∙ x) ≈ e) × ((x ∙ x⁻¹) ≈ e)
+  StarRightExpansive e _+_ _∙_ _⁻* = ∀ x → (e + (x ∙ (x ⁻*))) ≈ (x ⁻*)
+  StarLeftExpansive e _+_ _∙_ _⁻* = ∀ x →  (e + ((x ⁻*) ∙ x)) ≈ (x ⁻*)
+  StarExpansive e _+_ _∙_ _* = (StarLeftExpansive e _+_ _∙_ _*) × (StarRightExpansive e _+_ _∙_ _*)
+  StarLeftDestructive _+_ _∙_ _* = ∀ a b x → (b + (a ∙ x)) ≈ x → ((a *) ∙ b) ≈ x
+  StarRightDestructive _+_ _∙_ _* = ∀ a b x → (b + (x ∙ a)) ≈ x → (b ∙ (a *)) ≈ x
+  StarDestructive _+_ _∙_ _* = (StarLeftDestructive _+_ _∙_ _*) × (StarRightDestructive _+_ _∙_ _*)
+  LeftAlternative _∙_ = ∀ x y  →  ((x ∙ x) ∙ y) ≈ (x ∙ (y ∙ y))
+  RightAlternative _∙_ = ∀ x y → (x ∙ (y ∙ y)) ≈ ((x ∙ y) ∙ y)
+  Alternative _∙_ = (LeftAlternative _∙_ ) × (RightAlternative _∙_)
+  Flexible _∙_ = ∀ x y → ((x ∙ y) ∙ x) ≈ (x ∙ (y ∙ x))
+  Medial _∙_ = ∀ x y u z → ((x ∙ y) ∙ (u ∙ z)) ≈ ((x ∙ u) ∙ (y ∙ z))
+  LeftSemimedial _∙_ = ∀ x y z → ((x ∙ x) ∙ (y ∙ z)) ≈ ((x ∙ y) ∙ (x ∙ z))
+  RightSemimedial _∙_ = ∀ x y z → ((y ∙ z) ∙ (x ∙ x)) ≈ ((y ∙ x) ∙ (z ∙ x))
+  Semimedial _∙_ = (LeftSemimedial _∙_) × (RightSemimedial _∙_)
+  LeftBol _∙_ = ∀ x y z → (x ∙ (y ∙ (x ∙ z))) ≈ ((x ∙ (y ∙ z)) ∙ z )
+  RightBol _∙_ = ∀ x y z → (((z ∙ x) ∙ y) ∙ x) ≈ (z ∙ ((x ∙ y) ∙ x))
+  MiddleBol _∙_ _\\_ _//_ = ∀ x y z → (x ∙ ((y ∙ z) \\ x)) ≈ ((x // z) ∙ (y \\ x))
+  ```
+
+* Added new functions to `Algebra.Definitions.RawSemiring`:
+  ```agda
+  _^[_]*_ : A → ℕ → A → A
+  _^ᵗ_    : A → ℕ → A
+  ```
+
+* In `Algebra.Bundles.Lattice` the existing record `Lattice` now provides
+  ```agda
+  ∨-commutativeSemigroup : CommutativeSemigroup c ℓ
+  ∧-commutativeSemigroup : CommutativeSemigroup c ℓ
+  ```
+  and their corresponding algebraic sub-bundles.
+
+* In `Algebra.Lattice.Structures` the record `IsLattice` now provides
+  ```
+  ∨-isCommutativeSemigroup : IsCommutativeSemigroup ∨
+  ∧-isCommutativeSemigroup : IsCommutativeSemigroup ∧
+  ```
+  and their corresponding algebraic substructures.
+
+* The module `Algebra.Properties.Magma.Divisibility` now re-exports operations
+  `_∣ˡ_`, `_∤ˡ_`, `_∣ʳ_`, `_∤ʳ_` from `Algebra.Definitions.Magma`.
+
+* Added new records to `Algebra.Morphism.Structures`:
+  ```agda
+  record IsQuasigroupHomomorphism     (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsQuasigroupMonomorphism     (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsQuasigroupIsomorphism      (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsLoopHomomorphism           (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsLoopMonomorphism           (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsLoopIsomorphism            (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsRingWithoutOneHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsRingWithoutOneMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsRingWithoutOneIsoMorphism  (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsKleeneAlgebraHomomorphism  (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsKleeneAlgebraMonomorphism  (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂)
+  record IsKleeneAlgebraIsomorphism   (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)
+  ```
+
+* Added new proofs to `Algebra.Properties.CommutativeSemigroup`:
+  ```agda
+  xy∙xx≈x∙yxx : (x ∙ y) ∙ (x ∙ x) ≈ x ∙ (y ∙ (x ∙ x))
+
+  interchange : Interchangable _∙_ _∙_
+  leftSemimedial : LeftSemimedial _∙_
+  rightSemimedial : RightSemimedial _∙_
+  middleSemimedial : (x ∙ y) ∙ (z ∙ x) ≈ (x ∙ z) ∙ (y ∙ x)
+  semimedial : Semimedial _∙_
+  ```
+
+* Added new functions to `Algebra.Properties.CommutativeMonoid`
+  ```agda
+  invertibleˡ⇒invertibleʳ : LeftInvertible  _≈_ 0# _+_ x → RightInvertible _≈_ 0# _+_ x
+  invertibleʳ⇒invertibleˡ : RightInvertible _≈_ 0# _+_ x → LeftInvertible  _≈_ 0# _+_ x
+  invertibleˡ⇒invertible  : LeftInvertible  _≈_ 0# _+_ x → Invertible      _≈_ 0# _+_ x
+  invertibleʳ⇒invertible  : RightInvertible _≈_ 0# _+_ x → Invertible      _≈_ 0# _+_ x
+  ```
+
+* Added new proof to `Algebra.Properties.Monoid.Mult`:
+  ```agda
+  ×-congˡ : (_× x) Preserves _≡_ ⟶ _≈_
+  ```
+
+* Added new proof to `Algebra.Properties.Monoid.Sum`:
+  ```agda
+  sum-init-last : (t : Vector _ (suc n)) → sum t ≈ sum (init t) + last t
+  ```
+
+* Added new proofs to `Algebra.Properties.Semigroup`:
+  ```agda
+  leftAlternative  : LeftAlternative _∙_
+  rightAlternative : RightAlternative _∙_
+  alternative      : Alternative _∙_
+  flexible         : Flexible _∙_
+  ```
+
+* Added new proofs to `Algebra.Properties.Semiring.Exp`:
+  ```agda
+  ^-congʳ               : (x ^_) Preserves _≡_ ⟶ _≈_
+  y*x^m*y^n≈x^m*y^[n+1] : x * y ≈ y * x → y * (x ^ m * y ^ n) ≈ x ^ m * y ^ suc n
+  ```
+
+* Added new proofs to `Algebra.Properties.Semiring.Mult`:
+  ```agda
+  1×-identityʳ : 1 × x ≈ x
+  ×-comm-*    : x * (n × y) ≈ n × (x * y)
+  ×-assoc-*   : (n × x) * y ≈ n × (x * y)
+  ```
+
+* Added new proofs to `Algebra.Properties.Ring`:
+  ```agda
+  -1*x≈-x      : - 1# * x ≈ - x
+  x+x≈x⇒x≈0    : x + x ≈ x → x ≈ 0#
+  x[y-z]≈xy-xz : x * (y - z) ≈ x * y - x * z
+  [y-z]x≈yx-zx : (y - z) * x ≈ (y * x) - (z * x)
+  ```
+
+* Added new functions in `Codata.Guarded.Stream`:
+  ```
+  transpose  : List (Stream A) → Stream (List A)
+  transpose⁺ : List⁺ (Stream A) → Stream (List⁺ A)
+  concat     : Stream (List⁺ A) → Stream A
+  ```
+
+* Added new proofs in `Codata.Guarded.Stream.Properties`:
+  ```
+  cong-concat       : ass ≈ bss → concat ass ≈ concat bss
+  map-concat        : map f (concat ass) ≈ concat (map (List⁺.map f) ass)
+  lookup-transpose  : lookup n (transpose ass) ≡ List.map (lookup n) ass
+  lookup-transpose⁺ : lookup n (transpose⁺ ass) ≡ List⁺.map (lookup n) ass
+  ```
+
+* Added new proofs in `Data.Bool.Properties`:
+  ```agda
+  <-wellFounded : WellFounded _<_
+  ∨-conicalˡ : LeftConical false _∨_
+  ∨-conicalʳ : RightConical false _∨_
+  ∨-conical  : Conical false _∨_
+  ∧-conicalˡ : LeftConical true _∧_
+  ∧-conicalʳ : RightConical true _∧_
+  ∧-conical  : Conical true _∧_
+
+  true-xor            : true xor x ≡ not x
+  xor-same            : x xor x ≡ false
+  not-distribˡ-xor    : not (x xor y) ≡ (not x) xor y
+  not-distribʳ-xor    : not (x xor y) ≡ x xor (not y)
+  xor-assoc           : Associative _xor_
+  xor-comm            : Commutative _xor_
+  xor-identityˡ       : LeftIdentity false _xor_
+  xor-identityʳ       : RightIdentity false _xor_
+  xor-identity        : Identity false _xor_
+  xor-inverseˡ        : LeftInverse true not _xor_
+  xor-inverseʳ        : RightInverse true not _xor_
+  xor-inverse         : Inverse true not _xor_
+  ∧-distribˡ-xor      : _∧_ DistributesOverˡ _xor_
+  ∧-distribʳ-xor      : _∧_ DistributesOverʳ _xor_
+  ∧-distrib-xor       : _∧_ DistributesOver _xor_
+  xor-annihilates-not : (not x) xor (not y) ≡ x xor y
+  ```
+
+* Exposed container combinator conversion functions from `Data.Container.Combinator.Properties`
+  separately from their correctness proofs in `Data.Container.Combinator`:
+  ```
+  to-id      : F.id A → ⟦ id ⟧ A
+  from-id    : ⟦ id ⟧ A → F.id A
+  to-const   : A → ⟦ const A ⟧ B
+  from-const : ⟦ const A ⟧ B → A
+  to-∘       : ⟦ C₁ ⟧ (⟦ C₂ ⟧ A) → ⟦ C₁ ∘ C₂ ⟧ A
+  from-∘     : ⟦ C₁ ∘ C₂ ⟧ A → ⟦ C₁ ⟧ (⟦ C₂ ⟧ A)
+  to-×       : ⟦ C₁ ⟧ A P.× ⟦ C₂ ⟧ A → ⟦ C₁ × C₂ ⟧ A
+  from-×     : ⟦ C₁ × C₂ ⟧ A → ⟦ C₁ ⟧ A P.× ⟦ C₂ ⟧ A
+  to-Π       : (∀ i → ⟦ Cᵢ i ⟧ A) → ⟦ Π I Cᵢ ⟧ A
+  from-Π     : ⟦ Π I Cᵢ ⟧ A → ∀ i → ⟦ Cᵢ i ⟧ A
+  to-⊎       : ⟦ C₁ ⟧ A S.⊎ ⟦ C₂ ⟧ A → ⟦ C₁ ⊎ C₂ ⟧ A
+  from-⊎     : ⟦ C₁ ⊎ C₂ ⟧ A → ⟦ C₁ ⟧ A S.⊎ ⟦ C₂ ⟧ A
+  to-Σ       : (∃ λ i → ⟦ C i ⟧ A) → ⟦ Σ I C ⟧ A
+  from-Σ     : ⟦ Σ I C ⟧ A → ∃ λ i → ⟦ C i ⟧ A
+  ```
+
+* Added new functions in `Data.Fin.Base`:
+  ```
+  finToFun  : Fin (m ^ n) → (Fin n → Fin m)
+  funToFin  : (Fin m → Fin n) → Fin (n ^ m)
+  quotient  : Fin (m * n) → Fin m
+  remainder : Fin (m * n) → Fin n
+  ```
+
+* Added new proofs in `Data.Fin.Induction`:
+  ```agda
+  spo-wellFounded : IsStrictPartialOrder _≈_ _⊏_ → WellFounded _⊏_
+  spo-noetherian  : IsStrictPartialOrder _≈_ _⊏_ → WellFounded (flip _⊏_)
+
+  <-weakInduction-startingFrom : P i →  (∀ j → P (inject₁ j) → P (suc j)) → ∀ {j} → j ≥ i → P j
+  ```
+
+* Added new definitions and proofs in `Data.Fin.Permutation`:
+  ```agda
+  insert         : Fin (suc m) → Fin (suc n) → Permutation m n → Permutation (suc m) (suc n)
+  insert-punchIn : insert i j π ⟨$⟩ʳ punchIn i k ≡ punchIn j (π ⟨$⟩ʳ k)
+  insert-remove  : insert i (π ⟨$⟩ʳ i) (remove i π) ≈ π
+  remove-insert  : remove i (insert i j π) ≈ π
+  ```
+
+* Added new proofs in `Data.Fin.Properties`:
+  ```
+  1↔⊤                : Fin 1 ↔ ⊤
+  2↔Bool             : Fin 2 ↔ Bool
+
+  0≢1+n              : zero ≢ suc i
+
+  ↑ˡ-injective       : i ↑ˡ n ≡ j ↑ˡ n → i ≡ j
+  ↑ʳ-injective       : n ↑ʳ i ≡ n ↑ʳ j → i ≡ j
+  finTofun-funToFin  : funToFin ∘ finToFun ≗ id
+  funTofin-funToFun  : finToFun (funToFin f) ≗ f
+  ^↔→                : Extensionality _ _ → Fin (m ^ n) ↔ (Fin n → Fin m)
+
+  toℕ-mono-<         : i < j → toℕ i ℕ.< toℕ j
+  toℕ-mono-≤         : i ≤ j → toℕ i ℕ.≤ toℕ j
+  toℕ-cancel-≤       : toℕ i ℕ.≤ toℕ j → i ≤ j
+  toℕ-cancel-<       : toℕ i ℕ.< toℕ j → i < j
+
+  splitAt⁻¹-↑ˡ       : splitAt m {n} i ≡ inj₁ j → j ↑ˡ n ≡ i
+  splitAt⁻¹-↑ʳ       : splitAt m {n} i ≡ inj₂ j → m ↑ʳ j ≡ i
+
+  toℕ-combine        : toℕ (combine i j) ≡ k ℕ.* toℕ i ℕ.+ toℕ j
+  combine-injectiveˡ : combine i j ≡ combine k l → i ≡ k
+  combine-injectiveʳ : combine i j ≡ combine k l → j ≡ l
+  combine-injective  : combine i j ≡ combine k l → i ≡ k × j ≡ l
+  combine-surjective : ∀ i → ∃₂ λ j k → combine j k ≡ i
+  combine-monoˡ-<    : i < j → combine i k < combine j l
+
+  ℕ-ℕ≡toℕ‿ℕ-         : n ℕ-ℕ i ≡ toℕ (n ℕ- i)
+
+  lower₁-injective   : lower₁ i n≢i ≡ lower₁ j n≢j → i ≡ j
+  pinch-injective    : suc i ≢ j → suc i ≢ k → pinch i j ≡ pinch i k → j ≡ k
+
+  i<1+i              : i < suc i
+
+  injective⇒≤               : ∀ {f : Fin m → Fin n} → Injective f → m ℕ.≤ n
+  <⇒notInjective            : ∀ {f : Fin m → Fin n} → n ℕ.< m → ¬ (Injective f)
+  ℕ→Fin-notInjective        : ∀ (f : ℕ → Fin n) → ¬ (Injective f)
+  cantor-schröder-bernstein : ∀ {f : Fin m → Fin n} {g : Fin n → Fin m} → Injective f → Injective g → m ≡ n
+
+  cast-is-id    : cast eq k ≡ k
+  subst-is-cast : subst Fin eq k ≡ cast eq k
+  cast-trans    : cast eq₂ (cast eq₁ k) ≡ cast (trans eq₁ eq₂) k
+
+  fromℕ≢inject₁      : {i : Fin n} → fromℕ n ≢ inject₁ i
+
+  inject≤-trans      : inject≤ (inject≤ i m≤n) n≤o ≡ inject≤ i (≤-trans m≤n n≤o)
+  inject≤-irrelevant : inject≤ i m≤n ≡ inject≤ i m≤n′
+  i≤inject₁[j]⇒i≤1+j : i ≤ inject₁ j → i ≤ suc j
+  ```
+
+* Added new lemmas in `Data.Fin.Substitution.Lemmas.TermLemmas`:
+  ```
+  map-var≡ : (∀ x → lookup ρ₁ x ≡ f x) → (∀ x → lookup ρ₂ x ≡ T.var (f x)) → map var ρ₁ ≡ ρ₂
+  wk≡wk    : map var VarSubst.wk ≡ T.wk {n = n}
+  id≡id    : map var VarSubst.id ≡ T.id {n = n}
+  sub≡sub  : map var (VarSubst.sub x) ≡ T.sub (T.var x)
+  ↑≡↑      : map var (ρ VarSubst.↑) ≡ map T.var ρ T.↑
+  /Var≡/   : t /Var ρ ≡ t T./ map T.var ρ
+
+  sub-renaming-commutes : t /Var VarSubst.sub x T./ ρ ≡ t T./ ρ T.↑ T./ T.sub (lookup ρ x)
+  sub-commutes-with-renaming : t T./ T.sub t′ /Var ρ ≡ t /Var ρ VarSubst.↑ T./ T.sub (t′ /Var ρ)
+  ```
+
+* Added new functions and definitions in `Data.Integer.Base`:
+  ```agda
+  _^_ : ℤ → ℕ → ℤ
+
+  +-0-rawGroup  : Rawgroup 0ℓ 0ℓ
+
+  *-rawMagma    : RawMagma 0ℓ 0ℓ
+  *-1-rawMonoid : RawMonoid 0ℓ 0ℓ
+ ```
+
+* Added new proofs in `Data.Integer.Properties`:
+  ```agda
+  sign-cong′ : s₁ ◃ n₁ ≡ s₂ ◃ n₂ → s₁ ≡ s₂ ⊎ (n₁ ≡ 0 × n₂ ≡ 0)
+  ≤-⊖        : m ℕ.≤ n → n ⊖ m ≡ + (n ∸ m)
+  ∣⊖∣-≤      : m ℕ.≤ n → ∣ m ⊖ n ∣ ≡ n ∸ m
+  ∣-∣-≤      : i ≤ j → + ∣ i - j ∣ ≡ j - i
+
+  i^n≡0⇒i≡0      : i ^ n ≡ 0ℤ → i ≡ 0ℤ
+  ^-identityʳ    : i ^ 1 ≡ i
+  ^-zeroˡ        : 1 ^ n ≡ 1
+  ^-*-assoc      : (i ^ m) ^ n ≡ i ^ (m ℕ.* n)
+  ^-distribˡ-+-* : i ^ (m ℕ.+ n) ≡ i ^ m * i ^ n
+
+  ^-isMagmaHomomorphism  : IsMagmaHomomorphism  ℕ.+-rawMagma    *-rawMagma    (i ^_)
+  ^-isMonoidHomomorphism : IsMonoidHomomorphism ℕ.+-0-rawMonoid *-1-rawMonoid (i ^_)
+  ```
+
+* Added new proofs in `Data.Integer.GCD`:
+  ```agda
+  gcd-assoc : Associative gcd
+  gcd-zeroˡ : LeftZero 1ℤ gcd
+  gcd-zeroʳ : RightZero 1ℤ gcd
+  gcd-zero  : Zero 1ℤ gcd
+  ```
+
+* Added new functions and definitions to `Data.List.Base`:
+  ```agda
+  takeWhileᵇ   : (A → Bool) → List A → List A
+  dropWhileᵇ   : (A → Bool) → List A → List A
+  filterᵇ      : (A → Bool) → List A → List A
+  partitionᵇ   : (A → Bool) → List A → List A × List A
+  spanᵇ        : (A → Bool) → List A → List A × List A
+  breakᵇ       : (A → Bool) → List A → List A × List A
+  linesByᵇ     : (A → Bool) → List A → List (List A)
+  wordsByᵇ     : (A → Bool) → List A → List (List A)
+  derunᵇ       : (A → A → Bool) → List A → List A
+  deduplicateᵇ : (A → A → Bool) → List A → List A
+
+  findᵇ        : (A → Bool) → List A -> Maybe A
+  findIndexᵇ   : (A → Bool) → (xs : List A) → Maybe $ Fin (length xs)
+  findIndicesᵇ : (A → Bool) → (xs : List A) → List $ Fin (length xs)
+  find         : Decidable P → List A → Maybe A
+  findIndex    : Decidable P → (xs : List A) → Maybe $ Fin (length xs)
+  findIndices  : Decidable P → (xs : List A) → List $ Fin (length xs)
+
+  catMaybes       : List (Maybe A) → List A
+  ap              : List (A → B) → List A → List B
+  ++-rawMagma     : Set a → RawMagma a _
+  ++-[]-rawMonoid : Set a → RawMonoid a _
+
+  iterate : (A → A) → A → ℕ → List A
+  insertAt : (xs : List A) → Fin (suc (length xs)) → A → List A
+  updateAt : (xs : List A) → Fin (length xs) → (A → A) → List A
+  ```
+
+* Added new proofs in `Data.List.Relation.Binary.Lex.Strict`:
+  ```agda
+  xs≮[] : ¬ xs < []
+  ```
+
+* Added new proofs to `Data.List.Relation.Binary.Permutation.Propositional.Properties`:
+  ```agda
+  Any-resp-[σ⁻¹∘σ] : (σ : xs ↭ ys) → (ix : Any P xs) → Any-resp-↭ (trans σ (↭-sym σ)) ix ≡ ix
+  ∈-resp-[σ⁻¹∘σ]   : (σ : xs ↭ ys) → (ix : x ∈ xs)   → ∈-resp-↭   (trans σ (↭-sym σ)) ix ≡ ix
+  ```
+
+* In `Data.List.Relation.Binary.Permutation.Setoid.Properties`:
+  ```agda
+  foldr-commMonoid : xs ↭ ys → foldr _∙_ ε xs ≈ foldr _∙_ ε ys
+  ```
+
+* Added new function to `Data.List.Relation.Binary.Permutation.Propositional.Properties`
+  ```agda
+  ↭-reverse : reverse xs ↭ xs
+  ```
+
+* Added new proofs to `Data.List.Relation.Binary.Sublist.Setoid.Properties`:
+  ```
+  ⊆-mergeˡ : xs ⊆ merge _≤?_ xs ys
+  ⊆-mergeʳ : ys ⊆ merge _≤?_ xs ys
+  ```
+
+* Added new functions in `Data.List.Relation.Unary.All`:
+  ```
+  decide :  Π[ P ∪ Q ] → Π[ All P ∪ Any Q ]
+  ```
+
+* Added new proof to `Data.List.Relation.Unary.All.Properties`:
+  ```agda
+  gmap⁻ : Q ∘ f ⋐ P → All Q ∘ map f ⋐ All P
+  ```
+
+* Added new functions in `Data.List.Fresh.Relation.Unary.All`:
+  ```
+  decide :  Π[ P ∪ Q ] → Π[ All {R = R} P ∪ Any Q ]
+  ```
+
+* Added new proofs to `Data.List.Membership.Propositional.Properties`:
+  ```agda
+  mapWith∈-id  : mapWith∈ xs (λ {x} _ → x) ≡ xs
+  map-mapWith∈ : map g (mapWith∈ xs f) ≡ mapWith∈ xs (g ∘′ f)
+  ```
+
+* Added new proofs to `Data.List.Membership.Setoid.Properties`:
+  ```agda
+  mapWith∈-id     : mapWith∈ xs (λ {x} _ → x) ≡ xs
+  map-mapWith∈    : map g (mapWith∈ xs f) ≡ mapWith∈ xs (g ∘′ f)
+  index-injective : index x₁∈xs ≡ index x₂∈xs → x₁ ≈ x₂
+
+  ∈-++⁺∘++⁻         : (p : v ∈ xs ++ ys) → [ ∈-++⁺ˡ , ∈-++⁺ʳ xs ]′ (∈-++⁻ xs p) ≡ p
+  ∈-++⁻∘++⁺         : (p : v ∈ xs ⊎ v ∈ ys) → ∈-++⁻ xs ([ ∈-++⁺ˡ , ∈-++⁺ʳ xs ]′ p) ≡ p
+  ∈-++↔             : (v ∈ xs ⊎ v ∈ ys) ↔ v ∈ xs ++ ys
+  ∈-++-comm         : v ∈ xs ++ ys → v ∈ ys ++ xs
+  ∈-++-comm∘++-comm : (p : v ∈ xs ++ ys) → ∈-++-comm ys xs (∈-++-comm xs ys p) ≡ p
+  ∈-++↔++           : v ∈ xs ++ ys ↔ v ∈ ys ++ xs
+  ```
+
+* Add new proofs in `Data.List.Properties`:
+  ```agda
+  ∈⇒∣product : n ∈ ns → n ∣ product ns
+  ∷ʳ-++      : xs ∷ʳ a ++ ys ≡ xs ++ a ∷ ys
+
+  concatMap-cong : f ≗ g → concatMap f ≗ concatMap g
+  concatMap-pure : concatMap [_] ≗ id
+  concatMap-map  : concatMap g (map f xs) ≡ concatMap (g ∘′ f) xs
+  map-concatMap  : map f ∘′ concatMap g ≗ concatMap (map f ∘′ g)
+
+  length-isMagmaHomomorphism  : (A : Set a) → IsMagmaHomomorphism (++-rawMagma A) +-rawMagma length
+  length-isMonoidHomomorphism : (A : Set a) → IsMonoidHomomorphism (++-[]-rawMonoid A) +-0-rawMonoid length
+
+  take-map : take n (map f xs) ≡ map f (take n xs)
+  drop-map : drop n (map f xs) ≡ map f (drop n xs)
+  head-map : head (map f xs) ≡ Maybe.map f (head xs)
+
+  take-suc               : take (suc m) xs ≡ take m xs ∷ʳ lookup xs i
+  take-suc-tabulate      : take (suc m) (tabulate f) ≡ take m (tabulate f) ∷ʳ f i
+  drop-take-suc          : drop m (take (suc m) xs) ≡ [ lookup xs i ]
+  drop-take-suc-tabulate : drop m (take (suc m) (tabulate f)) ≡ [ f i ]
+
+  take-all : n ≥ length xs → take n xs ≡ xs
+  drop-all : n ≥ length xs → drop n xs ≡ []
+
+  take-[] : take m [] ≡ []
+  drop-[] : drop m [] ≡ []
+
+  drop-drop : drop n (drop m xs) ≡ drop (m + n) xs
+
+  lookup-replicate  : lookup (replicate n x) i ≡ x
+  map-replicate     : map f (replicate n x) ≡ replicate n (f x)
+  zipWith-replicate : zipWith _⊕_ (replicate n x) (replicate n y) ≡ replicate n (x ⊕ y)
+
+  length-iterate : length (iterate f x n) ≡ n
+  iterate-id     : iterate id x n ≡ replicate n x
+  lookup-iterate : lookup (iterate f x n) (cast (sym (length-iterate f x n)) i) ≡ ℕ.iterate f x (toℕ i)
+
+  length-insertAt   : length (insertAt xs i v) ≡ suc (length xs)
+  length-removeAt′  : length xs ≡ suc (length (removeAt xs k))
+  removeAt-insertAt : removeAt (insertAt xs i v) ((cast (sym (length-insertAt xs i v)) i)) ≡ xs
+  insertAt-removeAt : insertAt (removeAt xs i) (cast (sym (lengthAt-removeAt xs i)) i) (lookup xs i) ≡ xs
+
+  cartesianProductWith-zeroˡ       : cartesianProductWith f [] ys ≡ []
+  cartesianProductWith-zeroʳ       : cartesianProductWith f xs [] ≡ []
+  cartesianProductWith-distribʳ-++ : cartesianProductWith f (xs ++ ys) zs ≡
+                                     cartesianProductWith f xs zs ++ cartesianProductWith f ys zs
+
+  foldr-map : foldr f x (map g xs) ≡ foldr (g -⟨ f ∣) x xs
+  foldl-map : foldl f x (map g xs) ≡ foldl (∣ f ⟩- g) x xs
+  ```
+
+* In `Data.List.NonEmpty.Base`:
+  ```agda
+  drop+ : ℕ → List⁺ A → List⁺ A
+  ```
+
+* Added new proofs in `Data.List.NonEmpty.Properties`:
+  ```agda
+  length-++⁺      : length (xs ++⁺ ys) ≡ length xs + length ys
+  length-++⁺-tail : length (xs ++⁺ ys) ≡ suc (length xs + length (tail ys))
+  ++-++⁺          : (xs ++ ys) ++⁺ zs ≡ xs ++⁺ ys ++⁺ zs
+  ++⁺-cancelˡ′    : xs ++⁺ zs ≡ ys ++⁺ zs′ → List.length xs ≡ List.length ys → zs ≡ zs′
+  ++⁺-cancelˡ     : xs ++⁺ ys ≡ xs ++⁺ zs → ys ≡ zs
+  drop+-++⁺       : drop+ (length xs) (xs ++⁺ ys) ≡ ys
+  map-++⁺-commute : map f (xs ++⁺ ys) ≡ map f xs ++⁺ map f ys
+  length-map      : length (map f xs) ≡ length xs
+  map-cong        : f ≗ g → map f ≗ map g
+  map-compose     : map (g ∘ f) ≗ map g ∘ map f
+  ```
+
+* Added new proof to `Data.Maybe.Properties`
+  ```agda
+  <∣>-idem : Idempotent _<∣>_
+  ```
+
+* Added new patterns and definitions to `Data.Nat.Base`:
+  ```agda
+  pattern z<s {n}         = s≤s (z≤n {n})
+  pattern s<s {m} {n} m<n = s≤s {m} {n} m<n
+
+  s≤s⁻¹ : suc m ≤ suc n → m ≤ n
+  s<s⁻¹ : suc m < suc n → m < n
+
+  pattern <′-base          = ≤′-refl
+  pattern <′-step {n} m<′n = ≤′-step {n} m<′n
+
+  pattern ≤″-offset k = less-than-or-equal {k} refl
+  pattern <″-offset k = ≤″-offset k
+
+  s≤″s⁻¹ : suc m ≤″ suc n → m ≤″ n
+  s<″s⁻¹ : suc m <″ suc n → m <″ n
+
+  pattern 2+ n = suc (suc n)
+  pattern 1<2+n {n} = s<s (z<s {n})
+
+  NonTrivial            : Pred ℕ 0ℓ
+  instance nonTrivial   : NonTrivial (2+ n)
+  n>1⇒nonTrivial        : 1 < n → NonTrivial n
+  nonZero⇒≢1⇒nonTrivial : .{{NonZero n}} → n ≢ 1 → NonTrivial n
+  recompute-nonTrivial  : .{{NonTrivial n}} → NonTrivial n
+  nonTrivial⇒nonZero    : .{{NonTrivial n}} → NonZero n
+  nonTrivial⇒n>1        : .{{NonTrivial n}} → 1 < n
+  nonTrivial⇒≢1         : .{{NonTrivial n}} → n ≢ 1
+
+  _⊔′_ : ℕ → ℕ → ℕ
+  _⊓′_ : ℕ → ℕ → ℕ
+  ∣_-_∣′ : ℕ → ℕ → ℕ
+  _! : ℕ → ℕ
+
+  parity : ℕ → Parity
+
+  +-rawMagma          : RawMagma 0ℓ 0ℓ
+  +-0-rawMonoid       : RawMonoid 0ℓ 0ℓ
+  *-rawMagma          : RawMagma 0ℓ 0ℓ
+  *-1-rawMonoid       : RawMonoid 0ℓ 0ℓ
+  +-*-rawNearSemiring : RawNearSemiring 0ℓ 0ℓ
+  +-*-rawSemiring     : RawSemiring 0ℓ 0ℓ
+  ```
+
+* Added a new proof to `Data.Nat.Binary.Properties`:
+  ```agda
+  suc-injective : Injective _≡_ _≡_ suc
+  toℕ-inverseˡ  : Inverseˡ _≡_ _≡_ toℕ fromℕ
+  toℕ-inverseʳ  : Inverseʳ _≡_ _≡_ toℕ fromℕ
+  toℕ-inverseᵇ  : Inverseᵇ _≡_ _≡_ toℕ fromℕ
+
+  <-asym : Asymmetric _<_
+  ```
+
+* Added a new pattern synonym and a new definition to `Data.Nat.Divisibility.Core`:
+  ```agda
+  pattern divides-refl q = divides q refl
+  record _HasNonTrivialDivisorLessThan_ (m n : ℕ) : Set where
+  ```
+
+* Added new proofs to `Data.Nat.Divisibility`:
+  ```agda
+  hasNonTrivialDivisor-≢ : .{{NonTrivial d}} → .{{NonZero n}} → d ≢ n → d ∣ n → n HasNonTrivialDivisorLessThan n
+  hasNonTrivialDivisor-∣ : m HasNonTrivialDivisorLessThan n → m ∣ o → o HasNonTrivialDivisorLessThan n
+  hasNonTrivialDivisor-≤ : m HasNonTrivialDivisorLessThan n → n ≤ o → m HasNonTrivialDivisorLessThan o
+  ```
+
+* Added new definitions, smart constructors and proofs to `Data.Nat.Primality`:
+  ```agda
+  infix 10 _Rough_
+  _Rough_           : ℕ → Pred ℕ _
+  0-rough           : 0 Rough n
+  1-rough           : 1 Rough n
+  2-rough           : 2 Rough n
+  rough⇒≤           : .{{NonTrivial n}} → m Rough n → m ≤ n
+  ∤⇒rough-suc        : m ∤ n → m Rough n → (suc m) Rough n
+  rough∧∣⇒rough     : m Rough o → n ∣ o → m Rough n
+  Composite         : ℕ → Set
+  composite-≢       : .{{NonTrivial d}} → .{{NonZero n}} → d ≢ n → d ∣ n → Composite n
+  composite-∣       : .{{NonZero n}} → Composite m → m ∣ n → Composite n
+  composite?        : Decidable Composite
+  Irreducible       : ℕ → Set
+  irreducible?      : Decidable Irreducible
+  composite⇒¬prime  : Composite n → ¬ Prime n
+  ¬composite⇒prime  : .{{NonTrivial n} → ¬ Composite n → Prime n
+  prime⇒¬composite  : Prime n → ¬ Composite n
+  ¬prime⇒composite  : .{{NonTrivial n} → ¬ Prime n → Composite n
+  prime⇒irreducible : Prime p → Irreducible p
+  irreducible⇒prime : .{{NonTrivial p}} → Irreducible p → Prime p
+  euclidsLemma      : Prime p → p ∣ m * n → p ∣ m ⊎ p ∣ n
+  ```
+
+* Added new proofs in `Data.Nat.Properties`:
+  ```agda
+  nonZero?  : Decidable NonZero
+  n≮0       : n ≮ 0
+  n+1+m≢m   : n + suc m ≢ m
+  m*n≡0⇒m≡0 : .{{_ : NonZero n}} → m * n ≡ 0 → m ≡ 0
+  n>0⇒n≢0   : n > 0 → n ≢ 0
+  m*n≢0     : .{{_ : NonZero m}} .{{_ : NonZero n}} → NonZero (m * n)
+  m*n≢0⇒m≢0 : .{{NonZero (m * n)}} → NonZero m
+  m*n≢0⇒n≢0 : .{{NonZero (m * n)}} → NonZero n
+  m≢0∧n>1⇒m*n>1 : .{{_ : NonZero m}} .{{_ : NonTrivial n}} → NonTrivial (m * n)
+  n≢0∧m>1⇒m*n>1 : .{{_ : NonZero n}} .{{_ : NonTrivial m}} → NonTrivial (m * n)
+  m^n≢0     : .{{_ : NonZero m}} → NonZero (m ^ n)
+  m≤n⇒n∸m≤n : m ≤ n → n ∸ m ≤ n
+
+  s<s-injective : s<s p ≡ s<s q → p ≡ q
+  <-step        : m < n → m < 1 + n
+  m<1+n⇒m<n∨m≡n : m < suc n → m < n ⊎ m ≡ n
+
+  pred-mono-≤   : m ≤ n → pred m ≤ pred n
+  pred-mono-<   : .{{_ : NonZero m}} → m < n → pred m < pred n
+
+  z<′s : zero <′ suc n
+  s<′s : m <′ n → suc m <′ suc n
+  <⇒<′ : m < n → m <′ n
+  <′⇒< : m <′ n → m < n
+
+  ≤″-proof : (le : m ≤″ n) → let less-than-or-equal {k} _ = le in m + k ≡ n
+
+  m+n≤p⇒m≤p∸n         : m + n ≤ p → m ≤ p ∸ n
+  m≤p∸n⇒m+n≤p         : n ≤ p → m ≤ p ∸ n → m + n ≤ p
+
+  1≤n!    : 1 ≤ n !
+  _!≢0    : NonZero (n !)
+  _!*_!≢0 : NonZero (m ! * n !)
+
+  anyUpTo? : ∀ (P? : U.Decidable P) (v : ℕ) → Dec (∃ λ n → n < v × P n)
+  allUpTo? : ∀ (P? : U.Decidable P) (v : ℕ) → Dec (∀ {n} → n < v → P n)
+
+  n≤1⇒n≡0∨n≡1 : n ≤ 1 → n ≡ 0 ⊎ n ≡ 1
+
+  m^n>0 : .{{_ : NonZero m}} n → m ^ n > 0
+
+  ^-monoˡ-≤ : (_^ n) Preserves _≤_ ⟶ _≤_
+  ^-monoʳ-≤ : .{{_ : NonZero m}} → (m ^_) Preserves _≤_ ⟶ _≤_
+  ^-monoˡ-< : .{{_ : NonZero n}} → (_^ n) Preserves _<_ ⟶ _<_
+  ^-monoʳ-< : 1 < m → (m ^_) Preserves _<_ ⟶ _<_
+
+  n≡⌊n+n/2⌋ : n ≡ ⌊ n + n /2⌋
+  n≡⌈n+n/2⌉ : n ≡ ⌈ n + n /2⌉
+
+  m<n⇒m<n*o : .{{_ : NonZero o}} → m < n → m < n * o
+  m<n⇒m<o*n : .{{_ : NonZero o}} → m < n → m < o * n
+  ∸-monoˡ-< : m < o → n ≤ m → m ∸ n < o ∸ n
+
+  m≤n⇒∣m-n∣≡n∸m : m ≤ n → ∣ m - n ∣ ≡ n ∸ m
+
+  ⊔≡⊔′ : m ⊔ n ≡ m ⊔′ n
+  ⊓≡⊓′ : m ⊓ n ≡ m ⊓′ n
+  ∣-∣≡∣-∣′ : ∣ m - n ∣ ≡ ∣ m - n ∣′
+
+  nonTrivial? : Decidable NonTrivial
+  eq? : A ↣ ℕ → DecidableEquality A
+  ≤-<-connex : Connex _≤_ _<_
+  ≥->-connex : Connex _≥_ _>_
+  <-≤-connex : Connex _<_ _≤_
+  >-≥-connex : Connex _>_ _≥_
+  <-cmp : Trichotomous _≡_ _<_
+  anyUpTo? : (P? : Decidable P) → ∀ v → Dec (∃ λ n → n < v × P n)
+  allUpTo? : (P? : Decidable P) → ∀ v → Dec (∀ {n} → n < v → P n)
+  ```
+
+* Added new proofs in `Data.Nat.Combinatorics`:
+  ```agda
+  [n-k]*[n-k-1]!≡[n-k]!   : k < n → (n ∸ k) * (n ∸ suc k) ! ≡ (n ∸ k) !
+  [n-k]*d[k+1]≡[k+1]*d[k] : k < n → (n ∸ k) * ((suc k) ! * (n ∸ suc k) !) ≡ (suc k) * (k ! * (n ∸ k) !)
+  k![n∸k]!∣n!             : k ≤ n → k ! * (n ∸ k) ! ∣ n !
+  nP1≡n                   : n P 1 ≡ n
+  nC1≡n                   : n C 1 ≡ n
+  nCk+nC[k+1]≡[n+1]C[k+1] : n C k + n C (suc k) ≡ suc n C suc k
+  ```
+
+* Added new proofs in `Data.Nat.DivMod`:
+  ```agda
+  m%n≤n           : .{{_ : NonZero n}} → m % n ≤ n
+  m*n/m!≡n/[m∸1]! : .{{_ : NonZero m}} → m * n / m ! ≡ n / (pred m) !
+
+  %-congˡ             : .{{_ : NonZero o}} → m ≡ n → m % o ≡ n % o
+  %-congʳ             : .{{_ : NonZero m}} .{{_ : NonZero n}} → m ≡ n → o % m ≡ o % n
+  m≤n⇒[n∸m]%m≡n%m     : .{{_ : NonZero m}} → m ≤ n → (n ∸ m) % m ≡ n % m
+  m*n≤o⇒[o∸m*n]%n≡o%n : .{{_ : NonZero n}} → m * n ≤ o → (o ∸ m * n) % n ≡ o % n
+  m∣n⇒o%n%m≡o%m       : .{{_ : NonZero m}} .{{_ : NonZero n}} → m ∣ n → o % n % m ≡ o % m
+  m<n⇒m%n≡m           : .{{_ : NonZero n}} → m < n → m % n ≡ m
+  m*n/o*n≡m/o         : .{{_ : NonZero o}} {{_ : NonZero (o * n)}} → m * n / (o * n) ≡ m / o
+  m<n*o⇒m/o<n         : .{{_ : NonZero o}} → m < n * o → m / o < n
+  [m∸n]/n≡m/n∸1       : .{{_ : NonZero n}} → (m ∸ n) / n ≡ pred (m / n)
+  [m∸n*o]/o≡m/o∸n     : .{{_ : NonZero o}} → (m ∸ n * o) / o ≡ m / o ∸ n
+  m/n/o≡m/[n*o]       : .{{_ : NonZero n}} .{{_ : NonZero o}} .{{_ : NonZero (n * o)}} → m / n / o ≡ m / (n * o)
+  m%[n*o]/o≡m/o%n     : .{{_ : NonZero n}} .{{_ : NonZero o}} {{_ : NonZero (n * o)}} → m % (n * o) / o ≡ m / o % n
+  m%n*o≡m*o%[n*o]     : .{{_ : NonZero n}} {{_ : NonZero (n * o)}} → m % n * o ≡ m * o % (n * o)
+
+  [m*n+o]%[p*n]≡[m*n]%[p*n]+o : {{_ : NonZero (p * n)}} → o < n → (m * n + o) % (p * n) ≡ (m * n) % (p * n) + o
+  ```
+
+* Added new proofs in `Data.Nat.Divisibility`:
+  ```agda
+  n∣m*n*o       : n ∣ m * n * o
+  m*n∣⇒m∣       : m * n ∣ i → m ∣ i
+  m*n∣⇒n∣       : m * n ∣ i → n ∣ i
+  m≤n⇒m!∣n!     : m ≤ n → m ! ∣ n !
+  m/n/o≡m/[n*o] : .{{NonZero n}} .{{NonZero o}} → n * o ∣ m → (m / n) / o ≡ m / (n * o)
+  ```
+
+* Added new proofs in `Data.Nat.GCD`:
+  ```agda
+  gcd-assoc     : Associative gcd
+  gcd-identityˡ : LeftIdentity 0 gcd
+  gcd-identityʳ : RightIdentity 0 gcd
+  gcd-identity  : Identity 0 gcd
+  gcd-zeroˡ     : LeftZero 1 gcd
+  gcd-zeroʳ     : RightZero 1 gcd
+  gcd-zero      : Zero 1 gcd
+  ```
+
+* Added new patterns in `Data.Nat.Reflection`:
+  ```agda
+  pattern `ℕ     = def (quote ℕ) []
+  pattern `zero  = con (quote ℕ.zero) []
+  pattern `suc x = con (quote ℕ.suc) (x ⟨∷⟩ [])
+  ```
+
+* Added new functions and proofs in `Data.Nat.GeneralisedArithmetic`:
+  ```agda
+  iterate         : (A → A) → A → ℕ → A
+  iterate-is-fold : fold z s m ≡ iterate s z m
+  ```
+
+* Added new proofs in `Data.Parity.Properties`:
+  ```agda
+  suc-homo-⁻¹ : (parity (suc n)) ⁻¹ ≡ parity n
+  +-homo-+    : parity (m ℕ.+ n) ≡ parity m ℙ.+ parity n
+  *-homo-*    : parity (m ℕ.* n) ≡ parity m ℙ.* parity n
+  parity-isMagmaHomomorphism : IsMagmaHomomorphism ℕ.+-rawMagma ℙ.+-rawMagma parity
+  parity-isMonoidHomomorphism : IsMonoidHomomorphism ℕ.+-0-rawMonoid ℙ.+-0-rawMonoid parity
+  parity-isNearSemiringHomomorphism : IsNearSemiringHomomorphism ℕ.+-*-rawNearSemiring ℙ.+-*-rawNearSemiring parity
+  parity-isSemiringHomomorphism : IsSemiringHomomorphism ℕ.+-*-rawSemiring ℙ.+-*-rawSemiring parity
+  ```
+
+* Added new rounding functions in `Data.Rational.Base`:
+  ```agda
+  floor ceiling truncate round ⌊_⌋ ⌈_⌉ [_] : ℚ → ℤ
+  fracPart : ℚ → ℚ
+  ```
+
+* Added new definitions and proofs in `Data.Rational.Properties`:
+  ```agda
+  ↥ᵘ-toℚᵘ     : ↥ᵘ (toℚᵘ p) ≡ ↥ p
+  ↧ᵘ-toℚᵘ     : ↧ᵘ (toℚᵘ p) ≡ ↧ p
+  ↥p≡↥q≡0⇒p≡q : ↥ p ≡ 0ℤ → ↥ q ≡ 0ℤ → p ≡ q
+
+  _≥?_ : Decidable _≥_
+  _>?_ : Decidable _>_
+
+  +-*-rawNearSemiring                 : RawNearSemiring 0ℓ 0ℓ
+  +-*-rawSemiring                     : RawSemiring 0ℓ 0ℓ
+  toℚᵘ-isNearSemiringHomomorphism-+-* : IsNearSemiringHomomorphism +-*-rawNearSemiring ℚᵘ.+-*-rawNearSemiring toℚᵘ
+  toℚᵘ-isNearSemiringMonomorphism-+-* : IsNearSemiringMonomorphism +-*-rawNearSemiring ℚᵘ.+-*-rawNearSemiring toℚᵘ
+  toℚᵘ-isSemiringHomomorphism-+-*     : IsSemiringHomomorphism     +-*-rawSemiring     ℚᵘ.+-*-rawSemiring     toℚᵘ
+  toℚᵘ-isSemiringMonomorphism-+-*     : IsSemiringMonomorphism     +-*-rawSemiring     ℚᵘ.+-*-rawSemiring     toℚᵘ
+
+  pos⇒nonZero       : .{{Positive p}} → NonZero p
+  neg⇒nonZero       : .{{Negative p}} → NonZero p
+  nonZero⇒1/nonZero : .{{_ : NonZero p}} → NonZero (1/ p)
+
+  <-dense              : Dense _<_
+  <-isDenseLinearOrder : IsDenseLinearOrder _≡_ _<_
+  <-denseLinearOrder   : DenseLinearOrder 0ℓ 0ℓ 0ℓ
+  ```
+
+* Added new rounding functions in `Data.Rational.Unnormalised.Base`:
+  ```agda
+  floor ceiling truncate round ⌊_⌋ ⌈_⌉ [_] : ℚᵘ → ℤ
+  fracPart : ℚᵘ → ℚᵘ
+  ```
+
+* Added new definitions in `Data.Rational.Unnormalised.Properties`:
+  ```agda
+  ↥p≡0⇒p≃0    : ↥ p ≡ 0ℤ → p ≃ 0ℚᵘ
+  p≃0⇒↥p≡0    : p ≃ 0ℚᵘ → ↥ p ≡ 0ℤ
+  ↥p≡↥q≡0⇒p≃q : ↥ p ≡ 0ℤ → ↥ q ≡ 0ℤ → p ≃ q
+
+  +-*-rawNearSemiring : RawNearSemiring 0ℓ 0ℓ
+  +-*-rawSemiring     : RawSemiring 0ℓ 0ℓ
+
+  ≰⇒≥ : _≰_ ⇒ _≥_
+
+  _≥?_ : Decidable _≥_
+  _>?_ : Decidable _>_
+
+  *-mono-≤-nonNeg   : .{{_ : NonNegative p}} .{{_ : NonNegative r}} → p ≤ q → r ≤ s → p * r ≤ q * s
+  *-mono-<-nonNeg   : .{{_ : NonNegative p}} .{{_ : NonNegative r}} → p < q → r < s → p * r < q * s
+  1/-antimono-≤-pos : .{{_ : Positive p}}    .{{_ : Positive q}}    → p ≤ q → 1/ q ≤ 1/ p
+  ⊓-mono-<          : _⊓_ Preserves₂ _<_ ⟶ _<_ ⟶ _<_
+  ⊔-mono-<          : _⊔_ Preserves₂ _<_ ⟶ _<_ ⟶ _<_
+
+  pos⇒nonZero          : .{{_ : Positive p}} → NonZero p
+  neg⇒nonZero          : .{{_ : Negative p}} → NonZero p
+  pos+pos⇒pos          : .{{_ : Positive p}}    .{{_ : Positive q}}    → Positive (p + q)
+  nonNeg+nonNeg⇒nonNeg : .{{_ : NonNegative p}} .{{_ : NonNegative q}} → NonNegative (p + q)
+  pos*pos⇒pos          : .{{_ : Positive p}}    .{{_ : Positive q}}    → Positive (p * q)
+  nonNeg*nonNeg⇒nonNeg : .{{_ : NonNegative p}} .{{_ : NonNegative q}} → NonNegative (p * q)
+  pos⊓pos⇒pos          : .{{_ : Positive p}}    .{{_ : Positive q}}    → Positive (p ⊓ q)
+  pos⊔pos⇒pos          : .{{_ : Positive p}}    .{{_ : Positive q}}    → Positive (p ⊔ q)
+  1/nonZero⇒nonZero    : .{{_ : NonZero p}} → NonZero (1/ p)
+
+  0≄1             : 0ℚᵘ ≄ 1ℚᵘ
+  ≃-≄-irreflexive : Irreflexive _≃_ _≄_
+  ≄-symmetric     : Symmetric _≄_
+  ≄-cotransitive  : Cotransitive _≄_
+  ≄⇒invertible    : p ≄ q → Invertible _≃_ 1ℚᵘ _*_ (p - q)
+
+  <-dense         : Dense _<_
+
+  <-isDenseLinearOrder         : IsDenseLinearOrder _≃_ _<_
+  +-*-isHeytingCommutativeRing : IsHeytingCommutativeRing _≃_ _≄_ _+_ _*_ -_ 0ℚᵘ 1ℚᵘ
+  +-*-isHeytingField           : IsHeytingField _≃_ _≄_ _+_ _*_ -_ 0ℚᵘ 1ℚᵘ
+
+  <-denseLinearOrder           : DenseLinearOrder 0ℓ 0ℓ 0ℓ
+  +-*-heytingCommutativeRing   : HeytingCommutativeRing 0ℓ 0ℓ 0ℓ
+  +-*-heytingField             : HeytingField 0ℓ 0ℓ 0ℓ
+
+  module ≃-Reasoning = SetoidReasoning ≃-setoid
+  ```
+
+* Added new functions to `Data.Product.Nary.NonDependent`:
+  ```agda
+  zipWith : (∀ k → Projₙ as k → Projₙ bs k → Projₙ cs k) → Product n as → Product n bs → Product n cs
+  ```
+
+* Added new proof to `Data.Product.Properties`:
+  ```agda
+  map-cong : f ≗ g → h ≗ i → map f h ≗ map g i
+  ```
+
+* Added new definitions to `Data.Product.Properties`:
+  ```
+  Σ-≡,≡→≡ : (∃ λ (p : proj₁ p₁ ≡ proj₁ p₂) → subst B p (proj₂ p₁) ≡ proj₂ p₂) → p₁ ≡ p₂
+  Σ-≡,≡←≡ : p₁ ≡ p₂ → (∃ λ (p : proj₁ p₁ ≡ proj₁ p₂) → subst B p (proj₂ p₁) ≡ proj₂ p₂)
+  ×-≡,≡→≡ : (proj₁ p₁ ≡ proj₁ p₂ × proj₂ p₁ ≡ proj₂ p₂) → p₁ ≡ p₂
+  ×-≡,≡←≡ : p₁ ≡ p₂ → (proj₁ p₁ ≡ proj₁ p₂ × proj₂ p₁ ≡ proj₂ p₂)
+  ```
+
+* Added new proofs to `Data.Product.Relation.Binary.Lex.Strict`
+  ```agda
+  ×-respectsʳ : Transitive _≈₁_ → _<₁_ Respectsʳ _≈₁_ → _<₂_ Respectsʳ _≈₂_ → _<ₗₑₓ_ Respectsʳ _≋_
+  ×-respectsˡ : Symmetric _≈₁_ → Transitive _≈₁_ → _<₁_ Respectsˡ _≈₁_ → _<₂_ Respectsˡ _≈₂_ → _<ₗₑₓ_ Respectsˡ _≋_
+  ×-wellFounded' : Transitive _≈₁_ → _<₁_ Respectsʳ _≈₁_ → WellFounded _<₁_ → WellFounded _<₂_ → WellFounded _<ₗₑₓ_
+  ```
+
+* Added new definitions to `Data.Sign.Base`:
+  ```agda
+  *-rawMagma : RawMagma 0ℓ 0ℓ
+  *-1-rawMonoid : RawMonoid 0ℓ 0ℓ
+  *-1-rawGroup : RawGroup 0ℓ 0ℓ
+  ```
+
+* Added new proofs to `Data.Sign.Properties`:
+  ```agda
+  *-inverse : Inverse + id _*_
+  *-isCommutativeSemigroup : IsCommutativeSemigroup _*_
+  *-isCommutativeMonoid : IsCommutativeMonoid _*_ +
+  *-isGroup : IsGroup _*_ + id
+  *-isAbelianGroup : IsAbelianGroup _*_ + id
+  *-commutativeSemigroup : CommutativeSemigroup 0ℓ 0ℓ
+  *-commutativeMonoid : CommutativeMonoid 0ℓ 0ℓ
+  *-group : Group 0ℓ 0ℓ
+  *-abelianGroup : AbelianGroup 0ℓ 0ℓ
+  ≡-isDecEquivalence : IsDecEquivalence _≡_
+  ```
+
+* Added new functions in `Data.String.Base`:
+  ```agda
+  wordsByᵇ : (Char → Bool) → String → List String
+  linesByᵇ : (Char → Bool) → String → List String
+  ```
+
+* Added new proofs in `Data.String.Properties`:
+  ```agda
+  ≤-isDecTotalOrder-≈ : IsDecTotalOrder _≈_ _≤_
+  ≤-decTotalOrder-≈   : DecTotalOrder _ _ _
+  ```
+* Added new definitions in `Data.Sum.Properties`:
+  ```agda
+  swap-↔ : (A ⊎ B) ↔ (B ⊎ A)
+  ```
+
+* Added new proofs in `Data.Sum.Properties`:
+  ```agda
+  map-assocˡ : map (map f g) h ∘ assocˡ ≗ assocˡ ∘ map f (map g h)
+  map-assocʳ : map f (map g h) ∘ assocʳ ≗ assocʳ ∘ map (map f g) h
+  ```
+
+* Made `Map` public in `Data.Tree.AVL.IndexedMap`
+
+* Added new definitions in `Data.Vec.Base`:
+  ```agda
+  truncate : m ≤ n → Vec A n → Vec A m
+  pad      : m ≤ n → A → Vec A m → Vec A n
+
+  FoldrOp A B = A → B n → B (suc n)
+  FoldlOp A B = B n → A → B (suc n)
+
+  foldr′ : (A → B → B) → B → Vec A n → B
+  foldl′ : (B → A → B) → B → Vec A n → B
+  countᵇ : (A → Bool) → Vec A n → ℕ
+
+  iterate : (A → A) → A → Vec A n
+
+  diagonal           : Vec (Vec A n) n → Vec A n
+  DiagonalBind._>>=_ : Vec A n → (A → Vec B n) → Vec B n
+
+  _ʳ++_              : Vec A m → Vec A n → Vec A (m + n)
+
+  cast : .(eq : m ≡ n) → Vec A m → Vec A n
+  ```
+
+* Added new instance in `Data.Vec.Effectful`:
+  ```agda
+  monad : RawMonad (λ (A : Set a) → Vec A n)
+  ```
+
+* Added new proofs in `Data.Vec.Properties`:
+  ```agda
+  padRight-refl      : padRight ≤-refl a xs ≡ xs
+  padRight-replicate : replicate a ≡ padRight le a (replicate a)
+  padRight-trans     : padRight (≤-trans m≤n n≤p) a xs ≡ padRight n≤p a (padRight m≤n a xs)
+
+  truncate-refl     : truncate ≤-refl xs ≡ xs
+  truncate-trans    : truncate (≤-trans m≤n n≤p) xs ≡ truncate m≤n (truncate n≤p xs)
+  truncate-padRight : truncate m≤n (padRight m≤n a xs) ≡ xs
+
+  map-const    : map (const x) xs ≡ replicate x
+  map-⊛        : map f xs ⊛ map g xs ≡ map (f ˢ g) xs
+  map-++       : map f (xs ++ ys) ≡ map f xs ++ map f ys
+  map-is-foldr : map f ≗ foldr (Vec B) (λ x ys → f x ∷ ys) []
+  map-∷ʳ       : map f (xs ∷ʳ x) ≡ (map f xs) ∷ʳ (f x)
+  map-reverse  : map f (reverse xs) ≡ reverse (map f xs)
+  map-ʳ++      : map f (xs ʳ++ ys) ≡ map f xs ʳ++ map f ys
+  map-insert   : map f (insert xs i x) ≡ insert (map f xs) i (f x)
+  toList-map   : toList (map f xs) ≡ List.map f (toList xs)
+
+  lookup-concat : lookup (concat xss) (combine i j) ≡ lookup (lookup xss i) j
+
+  ⊛-is->>=    : fs ⊛ xs ≡ fs >>= flip map xs
+  lookup-⊛*   : lookup (fs ⊛* xs) (combine i j) ≡ (lookup fs i $ lookup xs j)
+  ++-is-foldr : xs ++ ys ≡ foldr ((Vec A) ∘ (_+ n)) _∷_ ys xs
+  []≔-++-↑ʳ   : (xs ++ ys) [ m ↑ʳ i ]≔ y ≡ xs ++ (ys [ i ]≔ y)
+  unfold-ʳ++  : xs ʳ++ ys ≡ reverse xs ++ ys
+
+  foldl-universal : (e : C zero) → ∀ {n} → Vec A n → C n) →
+                    (∀ ... → h C g e [] ≡ e) →
+                    (∀ ... → h C g e ∘ (x ∷_) ≗ h (C ∘ suc) g (g e x)) →
+                    h B f e ≗ foldl B f e
+  foldl-fusion  : h d ≡ e → (∀ ... → h (f b x) ≡ g (h b) x) → h ∘ foldl B f d ≗ foldl C g e
+  foldl-∷ʳ      : foldl B f e (ys ∷ʳ y) ≡ f (foldl B f e ys) y
+  foldl-[]      : foldl B f e [] ≡ e
+  foldl-reverse : foldl B {n} f e ∘ reverse ≗ foldr B (flip f) e
+
+  foldr-[]      : foldr B f e [] ≡ e
+  foldr-++      : foldr B f e (xs ++ ys) ≡ foldr (B ∘ (_+ n)) f (foldr B f e ys) xs
+  foldr-∷ʳ      : foldr B f e (ys ∷ʳ y) ≡ foldr (B ∘ suc) f (f y e) ys
+  foldr-ʳ++     : foldr B f e (xs ʳ++ ys) ≡ foldl (B ∘ (_+ n)) (flip f) (foldr B f e ys) xs
+  foldr-reverse : foldr B f e ∘ reverse ≗ foldl B (flip f) e
+
+  ∷ʳ-injective  : xs ∷ʳ x ≡ ys ∷ʳ y → xs ≡ ys × x ≡ y
+  ∷ʳ-injectiveˡ : xs ∷ʳ x ≡ ys ∷ʳ y → xs ≡ ys
+  ∷ʳ-injectiveʳ : xs ∷ʳ x ≡ ys ∷ʳ y → x ≡ y
+
+  unfold-∷ʳ : cast eq (xs ∷ʳ x) ≡ xs ++ [ x ]
+  init-∷ʳ   : init (xs ∷ʳ x) ≡ xs
+  last-∷ʳ   : last (xs ∷ʳ x) ≡ x
+  cast-∷ʳ   : cast eq (xs ∷ʳ x) ≡ (cast (cong pred eq) xs) ∷ʳ x
+  ++-∷ʳ     : cast eq ((xs ++ ys) ∷ʳ z) ≡ xs ++ (ys ∷ʳ z)
+  ∷ʳ-++     : cast eq ((xs ∷ʳ a) ++ ys) ≡ xs ++ (a ∷ ys)
+
+  reverse-∷          : reverse (x ∷ xs) ≡ reverse xs ∷ʳ x
+  reverse-involutive : Involutive _≡_ reverse
+  reverse-reverse    : reverse xs ≡ ys → reverse ys ≡ xs
+  reverse-injective  : reverse xs ≡ reverse ys → xs ≡ ys
+
+  transpose-replicate : transpose (replicate xs) ≡ map replicate xs
+  toList-replicate    : toList (replicate {n = n} a) ≡ List.replicate n a
+
+  toList-++ : toList (xs ++ ys) ≡ toList xs List.++ toList ys
+
+  cast-is-id    : cast eq xs ≡ xs
+  subst-is-cast : subst (Vec A) eq xs ≡ cast eq xs
+  cast-sym      : cast eq xs ≡ ys → cast (sym eq) ys ≡ xs
+  cast-trans    : cast eq₂ (cast eq₁ xs) ≡ cast (trans eq₁ eq₂) xs
+  map-cast      : map f (cast eq xs) ≡ cast eq (map f xs)
+  lookup-cast   : lookup (cast eq xs) (Fin.cast eq i) ≡ lookup xs i
+  lookup-cast₁  : lookup (cast eq xs) i ≡ lookup xs (Fin.cast (sym eq) i)
+  lookup-cast₂  : lookup xs (Fin.cast eq i) ≡ lookup (cast (sym eq) xs) i
+  cast-reverse  : cast eq ∘ reverse ≗ reverse ∘ cast eq
+  cast-++ˡ      : cast (cong (_+ n) eq) (xs ++ ys) ≡ cast eq xs ++ ys
+  cast-++ʳ      : cast (cong (m +_) eq) (xs ++ ys) ≡ xs ++ cast eq ys
+
+  iterate-id     : iterate id x n ≡ replicate x
+  take-iterate   : take n (iterate f x (n + m)) ≡ iterate f x n
+  drop-iterate   : drop n (iterate f x n) ≡ []
+  lookup-iterate : lookup (iterate f x n) i ≡ ℕ.iterate f x (toℕ i)
+  toList-iterate : toList (iterate f x n) ≡ List.iterate f x n
+
+  zipwith-++ : zipWith f (xs ++ ys) (xs' ++ ys') ≡ zipWith f xs xs' ++ zipWith f ys ys'
+
+  ++-assoc     : cast eq ((xs ++ ys) ++ zs) ≡ xs ++ (ys ++ zs)
+  ++-identityʳ : cast eq (xs ++ []) ≡ xs
+  init-reverse : init ∘ reverse ≗ reverse ∘ tail
+  last-reverse : last ∘ reverse ≗ head
+  reverse-++   : cast eq (reverse (xs ++ ys)) ≡ reverse ys ++ reverse xs
+
+  toList-cast   : toList (cast eq xs) ≡ toList xs
+  cast-fromList : cast _ (fromList xs) ≡ fromList ys
+  fromList-map  : cast _ (fromList (List.map f xs)) ≡ map f (fromList xs)
+  fromList-++   : cast _ (fromList (xs List.++ ys)) ≡ fromList xs ++ fromList ys
+  fromList-reverse : cast (Listₚ.length-reverse xs) (fromList (List.reverse xs)) ≡ reverse (fromList xs)
+
+  ∷-ʳ++   : cast eq ((a ∷ xs) ʳ++ ys) ≡ xs ʳ++ (a ∷ ys)
+  ++-ʳ++  : cast eq ((xs ++ ys) ʳ++ zs) ≡ ys ʳ++ (xs ʳ++ zs)
+  ʳ++-ʳ++ : cast eq ((xs ʳ++ ys) ʳ++ zs) ≡ ys ʳ++ (xs ++ zs)
+
+  length-toList   : List.length (toList xs) ≡ length xs
+  toList-insertAt : toList (insertAt xs i v) ≡ List.insertAt (toList xs) (Fin.cast (cong suc (sym (length-toList xs))) i) v
+
+  truncate≡take       : .(eq : n ≡ m + o) → truncate m≤n xs ≡ take m (cast eq xs)
+  take≡truncate       : take m xs ≡ truncate (m≤m+n m n) xs
+  lookup-truncate     : lookup (truncate m≤n xs) i ≡ lookup xs (Fin.inject≤ i m≤n)
+  lookup-take-inject≤ : lookup (take m xs) i ≡ lookup xs (Fin.inject≤ i (m≤m+n m n))
+  ```
+
+* Added new proofs in `Data.Vec.Membership.Propositional.Properties`:
+  ```agda
+  index-∈-fromList⁺ : Any.index (∈-fromList⁺ v∈xs) ≡ indexₗ v∈xs
+  ```
+
+* Added new isomorphisms to `Data.Unit.Polymorphic.Properties`:
+  ```agda
+  ⊤↔⊤* : ⊤ ↔ ⊤*
+  ```
+
+* Added new proofs in `Data.Vec.Functional.Properties`:
+  ```
+  map-updateAt : f ∘ g ≗ h ∘ f → map f (updateAt i g xs) ≗ updateAt i h (map f xs)
+  ```
+
+* Added new proofs in `Data.Vec.Relation.Binary.Lex.Strict`:
+  ```agda
+  xs≮[] : ¬ xs < []
+
+  <-respectsˡ : IsPartialEquivalence _≈_ → _≺_ Respectsˡ _≈_ → _<_ Respectsˡ _≋_
+  <-respectsʳ : IsPartialEquivalence _≈_ → _≺_ Respectsʳ _≈_ → _<_ _Respectsʳ _≋_
+  <-wellFounded : Transitive _≈_ → _≺_ Respectsʳ _≈_ → WellFounded _≺_ → WellFounded _<_
+  ```
+
+* Added new function to `Data.Vec.Relation.Binary.Pointwise.Inductive`
+  ```agda
+  cong-[_]≔ : Pointwise _∼_ xs ys → Pointwise _∼_ (xs [ i ]≔ p) (ys [ i ]≔ p)
+  ```
+
+* Added new function to `Data.Vec.Relation.Binary.Equality.Setoid`
+  ```agda
+  map-[]≔ : map f (xs [ i ]≔ p) ≋ map f xs [ i ]≔ f p
+  ```
+
+* Added new functions in `Data.Vec.Relation.Unary.Any`:
+  ```
+  lookup : Any P xs → A
+  ```
+
+* Added new functions in `Data.Vec.Relation.Unary.All`:
+  ```
+  decide :  Π[ P ∪ Q ] → Π[ All P ∪ Any Q ]
+
+  lookupAny : All P xs → (i : Any Q xs) → (P ∩ Q) (Any.lookup i)
+  lookupWith : ∀[ P ⇒ Q ⇒ R ] → All P xs → (i : Any Q xs) → R (Any.lookup i)
+  lookup : All P xs → (∀ {x} → x ∈ₚ xs → P x)
+  lookupₛ : P Respects _≈_ → All P xs → (∀ {x} → x ∈ xs → P x)
+  ```
+
+* Added vector associativity proof to  `Data.Vec.Relation.Binary.Equality.Setoid`:
+  ```
+  ++-assoc : (xs ++ ys) ++ zs ≋ xs ++ (ys ++ zs)
+  ```
+
+* Added new isomorphisms to `Data.Vec.N-ary`:
+  ```agda
+  Vec↔N-ary : ∀ n → (Vec A n → B) ↔ N-ary n A B
+  ```
+
+* Added new isomorphisms to `Data.Vec.Recursive`:
+  ```agda
+  lift↔             : A ↔ B → A ^ n ↔ B ^ n
+  Fin[m^n]↔Fin[m]^n : Fin (m ^ n) ↔ Fin m Vec.^ n
+  ```
+
+* Added new functions in `Effect.Monad.State`:
+  ```
+  runState  : State s a → s → a × s
+  evalState : State s a → s → a
+  execState : State s a → s → s
+  ```
+
+* Added a non-dependent version of `flip` in `Function.Base`:
+  ```agda
+  flip′ : (A → B → C) → (B → A → C)
+  ```
+
+* Added new proofs and definitions in `Function.Bundles`:
+  ```agda
+  LeftInverse.isSplitSurjection : LeftInverse → IsSplitSurjection to
+  LeftInverse.surjection        : LeftInverse → Surjection
+  SplitSurjection               = LeftInverse
+  _⟨$⟩_ = Func.to
+  ```
+
+* Added new proofs to `Function.Properties.Inverse`:
+  ```agda
+  ↔-refl  : Reflexive _↔_
+  ↔-sym   : Symmetric _↔_
+  ↔-trans : Transitive _↔_
+
+  ↔⇒↣   : A ↔ B → A ↣ B
+  ↔-fun : A ↔ B → C ↔ D → (A → C) ↔ (B → D)
+
+  Inverse⇒Injection : Inverse S T → Injection S T
+  ```
+
+* Added new proofs in `Function.Construct.Symmetry`:
+  ```
+  bijective     : Bijective ≈₁ ≈₂ f → Symmetric ≈₂ → Transitive ≈₂ → Congruent ≈₁ ≈₂ f → Bijective ≈₂ ≈₁ f⁻¹
+  isBijection   : IsBijection ≈₁ ≈₂ f → Congruent ≈₂ ≈₁ f⁻¹ → IsBijection ≈₂ ≈₁ f⁻¹
+  isBijection-≡ : IsBijection ≈₁ _≡_ f → IsBijection _≡_ ≈₁ f⁻¹
+  bijection     : Bijection R S → Congruent IB.Eq₂._≈_ IB.Eq₁._≈_ f⁻¹ → Bijection S R
+  bijection-≡   : Bijection R (setoid B) → Bijection (setoid B) R
+  sym-⤖        : A ⤖ B → B ⤖ A
+  ```
+
+* Added new operations in `Function.Strict`:
+  ```
+  _!|>_  : (a : A) → (∀ a → B a) → B a
+  _!|>′_ : A → (A → B) → B
+  ```
+
+* Added new proof and record in `Function.Structures`:
+  ```agda
+  record IsSplitSurjection (f : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)
+  ```
+
+* Added new definition to the `Surjection` module in `Function.Related.Surjection`:
+  ```
+  f⁻ = proj₁ ∘ surjective
+  ```
+
+* Added new proof to `Induction.WellFounded`
+  ```agda
+  Acc-resp-flip-≈ : _<_ Respectsʳ (flip _≈_) → (Acc _<_) Respects _≈_
+  acc⇒asym        : Acc _<_ x → x < y → ¬ (y < x)
+  wf⇒asym         : WellFounded _<_ → Asymmetric _<_
+  wf⇒irrefl       : _<_ Respects₂ _≈_ → Symmetric _≈_ → WellFounded _<_ → Irreflexive _≈_ _<_
+  ```
+
+* Added new operations in `IO`:
+  ```
+  Colist.forM  : Colist A → (A → IO B) → IO (Colist B)
+  Colist.forM′ : Colist A → (A → IO B) → IO ⊤
+
+  List.forM  : List A → (A → IO B) → IO (List B)
+  List.forM′ : List A → (A → IO B) → IO ⊤
+  ```
+
+* Added new operations in `IO.Base`:
+  ```
+  lift! : IO A → IO (Lift b A)
+  _<$_  : B → IO A → IO B
+  _=<<_ : (A → IO B) → IO A → IO B
+  _<<_  : IO B → IO A → IO B
+  lift′ : Prim.IO ⊤ → IO {a} ⊤
+
+  when   : Bool → IO ⊤ → IO ⊤
+  unless : Bool → IO ⊤ → IO ⊤
+
+  whenJust  : Maybe A → (A → IO ⊤) → IO ⊤
+  untilJust : IO (Maybe A) → IO A
+  untilRight : (A → IO (A ⊎ B)) → A → IO B
+  ```
+
+* Added new functions in `Reflection.AST.Term`:
+  ```
+  stripPis     : Term → List (String × Arg Type) × Term
+  prependLams  : List (String × Visibility) → Term → Term
+  prependHLams : List String → Term → Term
+  prependVLams : List String → Term → Term
+  ```
+
+* Added new types and operations to `Reflection.TCM`:
+  ```
+  Blocker : Set
+  blockerMeta : Meta → Blocker
+  blockerAny : List Blocker → Blocker
+  blockerAll : List Blocker → Blocker
+  blockTC : Blocker → TC A
+  ```
+
+* Added new operations in `Relation.Binary.Construct.Closure.Equivalence`:
+  ```
+  fold   : IsEquivalence _∼_ → _⟶_ ⇒ _∼_ → EqClosure _⟶_ ⇒ _∼_
+  gfold  : IsEquivalence _∼_ → _⟶_ =[ f ]⇒ _∼_ → EqClosure _⟶_ =[ f ]⇒ _∼_
+  return : _⟶_ ⇒ EqClosure _⟶_
+  join   : EqClosure (EqClosure _⟶_) ⇒ EqClosure _⟶_
+  _⋆     : _⟶₁_ ⇒ EqClosure _⟶₂_ → EqClosure _⟶₁_ ⇒ EqClosure _⟶₂_
+  ```
+
+* Added new operations in `Relation.Binary.Construct.Closure.Symmetric`:
+  ```
+  fold   : Symmetric _∼_ → _⟶_ ⇒ _∼_ → SymClosure _⟶_ ⇒ _∼_
+  gfold  : Symmetric _∼_ → _⟶_ =[ f ]⇒ _∼_ → SymClosure _⟶_ =[ f ]⇒ _∼_
+  return : _⟶_ ⇒ SymClosure _⟶_
+  join   : SymClosure (SymClosure _⟶_) ⇒ SymClosure _⟶_
+  _⋆     : _⟶₁_ ⇒ SymClosure _⟶₂_ → SymClosure _⟶₁_ ⇒ SymClosure _⟶₂_
+  ```
+
+* Added new proofs to `Relation.Binary.Lattice.Properties.{Join,Meet}Semilattice`:
+  ```agda
+  isPosemigroup           : IsPosemigroup _≈_ _≤_ _∨_
+  posemigroup             : Posemigroup c ℓ₁ ℓ₂
+  ≈-dec⇒≤-dec             : Decidable _≈_ → Decidable _≤_
+  ≈-dec⇒isDecPartialOrder : Decidable _≈_ → IsDecPartialOrder _≈_ _≤_
+  ```
+
+* Added new proofs to `Relation.Binary.Lattice.Properties.Bounded{Join,Meet}Semilattice`:
+  ```agda
+  isCommutativePomonoid : IsCommutativePomonoid _≈_ _≤_ _∨_ ⊥
+  commutativePomonoid   : CommutativePomonoid c ℓ₁ ℓ₂
+  ```
+
+* Added new proofs to `Relation.Binary.Properties.Poset`:
+  ```agda
+  ≤-dec⇒≈-dec             : Decidable _≤_ → Decidable _≈_
+  ≤-dec⇒isDecPartialOrder : Decidable _≤_ → IsDecPartialOrder _≈_ _≤_
+  ```
+
+* Added new proofs in `Relation.Binary.Properties.StrictPartialOrder`:
+  ```agda
+  >-strictPartialOrder : StrictPartialOrder s₁ s₂ s₃
+  ```
+
+* Added new proofs in `Relation.Binary.PropositionalEquality.Properties`:
+  ```
+  subst-application′ : subst Q eq (f x p) ≡ f y (subst P eq p)
+  sym-cong           : sym (cong f p) ≡ cong f (sym p)
+  ```
+
+* Added new proofs in `Relation.Binary.HeterogeneousEquality`:
+  ```
+  subst₂-removable : subst₂ _∼_ eq₁ eq₂ p ≅ p
+  ```
+
+* Added new definitions in `Relation.Unary`:
+  ```
+  _≐_  : Pred A ℓ₁ → Pred A ℓ₂ → Set _
+  _≐′_ : Pred A ℓ₁ → Pred A ℓ₂ → Set _
+  _∖_  : Pred A ℓ₁ → Pred A ℓ₂ → Pred A _
+  ```
+
+* Added new proofs in `Relation.Unary.Properties`:
+  ```
+  ⊆-reflexive : _≐_ ⇒ _⊆_
+  ⊆-antisym   : Antisymmetric _≐_ _⊆_
+  ⊆-min       : Min _⊆_ ∅
+  ⊆-max       : Max _⊆_ U
+  ⊂⇒⊆         : _⊂_ ⇒ _⊆_
+  ⊂-trans     : Trans _⊂_ _⊂_ _⊂_
+  ⊂-⊆-trans   : Trans _⊂_ _⊆_ _⊂_
+  ⊆-⊂-trans   : Trans _⊆_ _⊂_ _⊂_
+  ⊂-respʳ-≐   : _⊂_ Respectsʳ _≐_
+  ⊂-respˡ-≐   : _⊂_ Respectsˡ _≐_
+  ⊂-resp-≐    : _⊂_ Respects₂ _≐_
+  ⊂-irrefl    : Irreflexive _≐_ _⊂_
+  ⊂-antisym   : Antisymmetric _≐_ _⊂_
+
+  ∅-⊆′         : (P : Pred A ℓ) → ∅ ⊆′ P
+  ⊆′-U         : (P : Pred A ℓ) → P ⊆′ U
+  ⊆′-refl      : Reflexive {A = Pred A ℓ} _⊆′_
+  ⊆′-reflexive : _≐′_ ⇒ _⊆′_
+  ⊆′-trans     : Trans _⊆′_ _⊆′_ _⊆′_
+  ⊆′-antisym   : Antisymmetric _≐′_ _⊆′_
+  ⊆′-min       : Min _⊆′_ ∅
+  ⊆′-max       : Max _⊆′_ U
+  ⊂′-trans     : Trans _⊂′_ _⊂′_ _⊂′_
+  ⊂′-⊆′-trans  : Trans _⊂′_ _⊆′_ _⊂′_
+  ⊆′-⊂′-trans  : Trans _⊆′_ _⊂′_ _⊂′_
+  ⊂′-respʳ-≐′  : _⊂′_ Respectsʳ _≐′_
+  ⊂′-respˡ-≐′  : _⊂′_ Respectsˡ _≐′_
+  ⊂′-resp-≐′   : _⊂′_ Respects₂ _≐′_
+  ⊂′-irrefl    : Irreflexive _≐′_ _⊂′_
+  ⊂′-antisym   : Antisymmetric _≐′_ _⊂′_
+  ⊂′⇒⊆′        : _⊂′_ ⇒ _⊆′_
+  ⊆⇒⊆′         : _⊆_ ⇒ _⊆′_
+  ⊆′⇒⊆         : _⊆′_ ⇒ _⊆_
+  ⊂⇒⊂′         : _⊂_ ⇒ _⊂′_
+  ⊂′⇒⊂         : _⊂′_ ⇒ _⊂_
+
+  ≐-refl   : Reflexive _≐_
+  ≐-sym    : Sym _≐_ _≐_
+  ≐-trans  : Trans _≐_ _≐_ _≐_
+  ≐′-refl  : Reflexive _≐′_
+  ≐′-sym   : Sym _≐′_ _≐′_
+  ≐′-trans : Trans _≐′_ _≐′_ _≐′_
+  ≐⇒≐′     : _≐_ ⇒ _≐′_
+  ≐′⇒≐     : _≐′_ ⇒ _≐_
+
+  U-irrelevant : Irrelevant U
+  ∁-irrelevant : (P : Pred A ℓ) → Irrelevant (∁ P)
+  ```
+
+* Generalised proofs in `Relation.Unary.Properties`:
+  ```
+  ⊆-trans : Trans _⊆_ _⊆_ _⊆_
+  ```
+
+* Added new proofs in `Relation.Binary.Properties.Setoid`:
+  ```
+  ≈-isPreorder     : IsPreorder _≈_ _≈_
+  ≈-isPartialOrder : IsPartialOrder _≈_ _≈_
+
+  ≈-preorder : Preorder a ℓ ℓ
+  ≈-poset    : Poset a ℓ ℓ
+  ```
+
+* Added new definitions in `Relation.Binary.Definitions`:
+  ```
+  RightTrans R S = Trans R S R
+  LeftTrans  S R = Trans S R R
+
+  Dense        _<_ = x < y → ∃[ z ] x < z × z < y
+  Cotransitive _#_ = x # y → ∀ z → (x # z) ⊎ (z # y)
+  Tight    _≈_ _#_ = (¬ x # y → x ≈ y) × (x ≈ y → ¬ x # y)
+
+  Monotonic₁         _≤_ _⊑_ f     = f Preserves _≤_ ⟶ _⊑_
+  Antitonic₁         _≤_ _⊑_ f     = f Preserves (flip _≤_) ⟶ _⊑_
+  Monotonic₂         _≤_ _⊑_ _≼_ ∙ = ∙ Preserves₂ _≤_ ⟶ _⊑_ ⟶ _≼_
+  MonotonicAntitonic _≤_ _⊑_ _≼_ ∙ = ∙ Preserves₂ _≤_ ⟶ (flip _⊑_) ⟶ _≼_
+  AntitonicMonotonic _≤_ _⊑_ _≼_ ∙ = ∙ Preserves₂ (flip _≤_) ⟶ _⊑_ ⟶ _≼_
+  Antitonic₂         _≤_ _⊑_ _≼_ ∙ = ∙ Preserves₂ (flip _≤_) ⟶ (flip _⊑_) ⟶ _≼_
+  Adjoint            _≤_ _⊑_ f g   = (f x ⊑ y → x ≤ g y) × (x ≤ g y → f x ⊑ y)
+  ```
+
+* Added new definitions in `Relation.Binary.Bundles`:
+  ```
+  record DenseLinearOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
+  record ApartnessRelation c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
+  ```
+
+* Added new definitions in `Relation.Binary.Structures`:
+  ```
+  record IsDenseLinearOrder (_<_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
+  record IsApartnessRelation (_#_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
+  ```
+
+* Added new proofs to `Relation.Binary.Consequences`:
+  ```
+  sym⇒¬-sym       : Symmetric _∼_ → Symmetric (¬_ ∘₂ _∼_)
+  cotrans⇒¬-trans : Cotransitive _∼_ → Transitive (¬_ ∘₂ _∼_)
+  irrefl⇒¬-refl   : Reflexive _≈_ → Irreflexive _≈_ _∼_ →  Reflexive (¬_ ∘₂ _∼_)
+  mono₂⇒cong₂     : Symmetric ≈₁ → ≈₁ ⇒ ≤₁ → Antisymmetric ≈₂ ≤₂ → ∀ {f} →
+                    f Preserves₂ ≤₁ ⟶ ≤₁ ⟶ ≤₂ →
+                    f Preserves₂ ≈₁ ⟶ ≈₁ ⟶ ≈₂
+  ```
+
+* Added new proofs to `Relation.Binary.Construct.Closure.Transitive`:
+  ```
+  accessible⁻  : Acc _∼⁺_ x → Acc _∼_ x
+  wellFounded⁻ : WellFounded _∼⁺_ → WellFounded _∼_
+  accessible   : Acc _∼_ x → Acc _∼⁺_ x
+  ```
+
+* Added new operations in `Relation.Binary.PropositionalEquality.Properties`:
+  ```
+  J       : (B : (y : A) → x ≡ y → Set b) (p : x ≡ y) → B x refl → B y p
+  dcong   : (p : x ≡ y) → subst B p (f x) ≡ f y
+  dcong₂  : (p : x₁ ≡ x₂) → subst B p y₁ ≡ y₂ → f x₁ y₁ ≡ f x₂ y₂
+  dsubst₂ : (p : x₁ ≡ x₂) → subst B p y₁ ≡ y₂ → C x₁ y₁ → C x₂ y₂
+  ddcong₂ : (p : x₁ ≡ x₂) (q : subst B p y₁ ≡ y₂) → dsubst₂ C p q (f x₁ y₁) ≡ f x₂ y₂
+
+  isPartialOrder : IsPartialOrder _≡_ _≡_
+  poset          : Set a → Poset _ _ _
+  ```
+
+* Added new proof in `Relation.Nullary.Reflects`:
+  ```agda
+  T-reflects : Reflects (T b) b
+  T-reflects-elim : Reflects (T a) b → b ≡ a
+  ```
+
+* Added new operations in `System.Exit`:
+  ```
+  isSuccess : ExitCode → Bool
+  isFailure : ExitCode → Bool
+  ```
+
+NonZero/Positive/Negative changes
+---------------------------------
+
+This is a full list of proofs that have changed form to use irrelevant instance arguments:
+
+* In `Data.Nat.Base`:
+  ```
+  ≢-nonZero⁻¹ : ∀ {n} → .(NonZero n) → n ≢ 0
+  >-nonZero⁻¹ : ∀ {n} → .(NonZero n) → n > 0
+  ```
+
+* In `Data.Nat.Properties`:
+  ```
+  *-cancelʳ-≡ : ∀ m n {o} → m * suc o ≡ n * suc o → m ≡ n
+  *-cancelˡ-≡ : ∀ {m n} o → suc o * m ≡ suc o * n → m ≡ n
+  *-cancelʳ-≤ : ∀ m n o → m * suc o ≤ n * suc o → m ≤ n
+  *-cancelˡ-≤ : ∀ {m n} o → suc o * m ≤ suc o * n → m ≤ n
+  *-monoˡ-<   : ∀ n → (_* suc n) Preserves _<_ ⟶ _<_
+  *-monoʳ-<   : ∀ n → (suc n *_) Preserves _<_ ⟶ _<_
+
+  m≤m*n          : ∀ m {n} → 0 < n → m ≤ m * n
+  m≤n*m          : ∀ m {n} → 0 < n → m ≤ n * m
+  m<m*n          : ∀ {m n} → 0 < m → 1 < n → m < m * n
+  suc[pred[n]]≡n : ∀ {n} → n ≢ 0 → suc (pred n) ≡ n
+  ```
+
+* In `Data.Nat.Coprimality`:
+  ```
+  ¬0-coprimeTo-2+ : ∀ {n} → ¬ Coprime 0 (2 + n)
+  Bézout-coprime  : ∀ {i j d} → Bézout.Identity (suc d) (i * suc d) (j * suc d) → Coprime i j
+  prime⇒coprime   : ∀ m → Prime m → ∀ n → 0 < n → n < m → Coprime m n
+  ```
+
+* In `Data.Nat.Divisibility`
+  ```agda
+  m%n≡0⇒n∣m : ∀ m n → m % suc n ≡ 0 → suc n ∣ m
+  n∣m⇒m%n≡0 : ∀ m n → suc n ∣ m → m % suc n ≡ 0
+  m%n≡0⇔n∣m : ∀ m n → m % suc n ≡ 0 ⇔ suc n ∣ m
+  ∣⇒≤       : ∀ {m n} → m ∣ suc n → m ≤ suc n
+  >⇒∤        : ∀ {m n} → m > suc n → m ∤ suc n
+  *-cancelˡ-∣ : ∀ {i j} k → suc k * i ∣ suc k * j → i ∣ j
+  ```
+
+* In `Data.Nat.DivMod`:
+  ```
+  m≡m%n+[m/n]*n : ∀ m n → m ≡ m % suc n + (m / suc n) * suc n
+  m%n≡m∸m/n*n   : ∀ m n → m % suc n ≡ m ∸ (m / suc n) * suc n
+  n%n≡0         : ∀ n → suc n % suc n ≡ 0
+  m%n%n≡m%n     : ∀ m n → m % suc n % suc n ≡ m % suc n
+  [m+n]%n≡m%n   : ∀ m n → (m + suc n) % suc n ≡ m % suc n
+  [m+kn]%n≡m%n  : ∀ m k n → (m + k * (suc n)) % suc n ≡ m % suc n
+  m*n%n≡0       : ∀ m n → (m * suc n) % suc n ≡ 0
+  m%n<n         : ∀ m n → m % suc n < suc n
+  m%n≤m         : ∀ m n → m % suc n ≤ m
+  m≤n⇒m%n≡m     : ∀ {m n} → m ≤ n → m % suc n ≡ m
+
+  m/n<m         : ∀ m n {≢0} → m ≥ 1 → n ≥ 2 → (m / n) {≢0} < m
+  ```
+
+* In `Data.Nat.GCD`
+  ```
+  GCD-* : ∀ {m n d c} → GCD (m * suc c) (n * suc c) (d * suc c) → GCD m n d
+  gcd[m,n]≤n : ∀ m n → gcd m (suc n) ≤ suc n
+  ```
+
+* In `Data.Integer.Properties`:
+  ```
+  positive⁻¹        : ∀ {i} → Positive i → i > 0ℤ
+  negative⁻¹        : ∀ {i} → Negative i → i < 0ℤ
+  nonPositive⁻¹     : ∀ {i} → NonPositive i → i ≤ 0ℤ
+  nonNegative⁻¹     : ∀ {i} → NonNegative i → i ≥ 0ℤ
+  negative<positive : ∀ {i j} → Negative i → Positive j → i < j
+
+  sign-◃    : ∀ s n → sign (s ◃ suc n) ≡ s
+  sign-cong : ∀ {s₁ s₂ n₁ n₂} → s₁ ◃ suc n₁ ≡ s₂ ◃ suc n₂ → s₁ ≡ s₂
+  -◃<+◃     : ∀ m n → Sign.- ◃ (suc m) < Sign.+ ◃ n
+  m⊖1+n<m   : ∀ m n → m ⊖ suc n < + m
+
+  *-cancelʳ-≡     : ∀ i j k → k ≢ + 0 → i * k ≡ j * k → i ≡ j
+  *-cancelˡ-≡     : ∀ i j k → i ≢ + 0 → i * j ≡ i * k → j ≡ k
+  *-cancelʳ-≤-pos : ∀ m n o → m * + suc o ≤ n * + suc o → m ≤ n
+
+  ≤-steps     : ∀ n → i ≤ j → i ≤ + n + j
+  ≤-steps-neg : ∀ n → i ≤ j → i - + n ≤ j
+  n≤m+n       : ∀ n → i ≤ + n + i
+  m≤m+n       : ∀ n → i ≤ i + + n
+  m-n≤m       : ∀ i n → i - + n ≤ i
+
+  *-cancelʳ-≤-pos    : ∀ m n o → m * + suc o ≤ n * + suc o → m ≤ n
+  *-cancelˡ-≤-pos    : ∀ m j k → + suc m * j ≤ + suc m * k → j ≤ k
+  *-cancelˡ-≤-neg    : ∀ m {j k} → -[1+ m ] * j ≤ -[1+ m ] * k → j ≥ k
+  *-cancelʳ-≤-neg    : ∀ {n o} m → n * -[1+ m ] ≤ o * -[1+ m ] → n ≥ o
+  *-cancelˡ-<-nonNeg : ∀ n → + n * i < + n * j → i < j
+  *-cancelʳ-<-nonNeg : ∀ n → i * + n < j * + n → i < j
+  *-monoʳ-≤-nonNeg   : ∀ n → (_* + n) Preserves _≤_ ⟶ _≤_
+  *-monoˡ-≤-nonNeg   : ∀ n → (+ n *_) Preserves _≤_ ⟶ _≤_
+  *-monoˡ-≤-nonPos   : ∀ i → NonPositive i → (i *_) Preserves _≤_ ⟶ _≥_
+  *-monoʳ-≤-nonPos   : ∀ i → NonPositive i → (_* i) Preserves _≤_ ⟶ _≥_
+  *-monoˡ-<-pos      : ∀ n → (+[1+ n ] *_) Preserves _<_ ⟶ _<_
+  *-monoʳ-<-pos      : ∀ n → (_* +[1+ n ]) Preserves _<_ ⟶ _<_
+  *-monoˡ-<-neg      : ∀ n → (-[1+ n ] *_) Preserves _<_ ⟶ _>_
+  *-monoʳ-<-neg      : ∀ n → (_* -[1+ n ]) Preserves _<_ ⟶ _>_
+  *-cancelˡ-<-nonPos : ∀ n → NonPositive n → n * i < n * j → i > j
+  *-cancelʳ-<-nonPos : ∀ n → NonPositive n → i * n < j * n → i > j
+
+  *-distribˡ-⊓-nonNeg : ∀ m j k → + m * (j ⊓ k) ≡ (+ m * j) ⊓ (+ m * k)
+  *-distribʳ-⊓-nonNeg : ∀ m j k → (j ⊓ k) * + m ≡ (j * + m) ⊓ (k * + m)
+  *-distribˡ-⊓-nonPos : ∀ i → NonPositive i → ∀ j k → i * (j ⊓ k) ≡ (i * j) ⊔ (i * k)
+  *-distribʳ-⊓-nonPos : ∀ i → NonPositive i → ∀ j k → (j ⊓ k) * i ≡ (j * i) ⊔ (k * i)
+  *-distribˡ-⊔-nonNeg : ∀ m j k → + m * (j ⊔ k) ≡ (+ m * j) ⊔ (+ m * k)
+  *-distribʳ-⊔-nonNeg : ∀ m j k → (j ⊔ k) * + m ≡ (j * + m) ⊔ (k * + m)
+  *-distribˡ-⊔-nonPos : ∀ i → NonPositive i → ∀ j k → i * (j ⊔ k) ≡ (i * j) ⊓ (i * k)
+  *-distribʳ-⊔-nonPos : ∀ i → NonPositive i → ∀ j k → (j ⊔ k) * i ≡ (j * i) ⊓ (k * i)
+  ```
+
+* In `Data.Integer.Divisibility`:
+  ```
+  *-cancelˡ-∣ : ∀ k {i j} → k ≢ + 0 → k * i ∣ k * j → i ∣ j
+  *-cancelʳ-∣ : ∀ k {i j} → k ≢ + 0 → i * k ∣ j * k → i ∣ j
+  ```
+
+* In `Data.Integer.Divisibility.Signed`:
+  ```
+  *-cancelˡ-∣ : ∀ k {i j} → k ≢ + 0 → k * i ∣ k * j → i ∣ j
+  *-cancelʳ-∣ : ∀ k {i j} → k ≢ + 0 → i * k ∣ j * k → i ∣ j
+  ```
+
+* In `Data.Rational.Unnormalised.Properties`:
+  ```agda
+  positive⁻¹           : ∀ {q} → .(Positive q) → q > 0ℚᵘ
+  nonNegative⁻¹        : ∀ {q} → .(NonNegative q) → q ≥ 0ℚᵘ
+  negative⁻¹           : ∀ {q} → .(Negative q) → q < 0ℚᵘ
+  nonPositive⁻¹        : ∀ {q} → .(NonPositive q) → q ≤ 0ℚᵘ
+  positive⇒nonNegative : ∀ {p} → Positive p → NonNegative p
+  negative⇒nonPositive : ∀ {p} → Negative p → NonPositive p
+  negative<positive    : ∀ {p q} → .(Negative p) → .(Positive q) → p < q
+  nonNeg∧nonPos⇒0      : ∀ {p} → .(NonNegative p) → .(NonPositive p) → p ≃ 0ℚᵘ
+
+  p≤p+q   : ∀ {p q} → NonNegative q → p ≤ p + q
+  p≤q+p   : ∀ {p} → NonNegative p → ∀ {q} → q ≤ p + q
+
+  *-cancelʳ-≤-pos    : ∀ {r} → Positive r → ∀ {p q} → p * r ≤ q * r → p ≤ q
+  *-cancelˡ-≤-pos    : ∀ {r} → Positive r → ∀ {p q} → r * p ≤ r * q → p ≤ q
+  *-cancelʳ-≤-neg    : ∀ r → Negative r → ∀ {p q} → p * r ≤ q * r → q ≤ p
+  *-cancelˡ-≤-neg    : ∀ r → Negative r → ∀ {p q} → r * p ≤ r * q → q ≤ p
+  *-cancelˡ-<-nonNeg : ∀ {r} → NonNegative r → ∀ {p q} → r * p < r * q → p < q
+  *-cancelʳ-<-nonNeg : ∀ {r} → NonNegative r → ∀ {p q} → p * r < q * r → p < q
+  *-cancelˡ-<-nonPos : ∀ r → NonPositive r → ∀ {p q} → r * p < r * q → q < p
+  *-cancelʳ-<-nonPos : ∀ r → NonPositive r → ∀ {p q} → p * r < q * r → q < p
+  *-monoˡ-≤-nonNeg   : ∀ {r} → NonNegative r → (_* r) Preserves _≤_ ⟶ _≤_
+  *-monoʳ-≤-nonNeg   : ∀ {r} → NonNegative r → (r *_) Preserves _≤_ ⟶ _≤_
+  *-monoˡ-≤-nonPos   : ∀ r → NonPositive r → (_* r) Preserves _≤_ ⟶ _≥_
+  *-monoʳ-≤-nonPos   : ∀ r → NonPositive r → (r *_) Preserves _≤_ ⟶ _≥_
+  *-monoˡ-<-pos      : ∀ {r} → Positive r → (_* r) Preserves _<_ ⟶ _<_
+  *-monoʳ-<-pos      : ∀ {r} → Positive r → (r *_) Preserves _<_ ⟶ _<_
+  *-monoˡ-<-neg      : ∀ r → Negative r → (_* r) Preserves _<_ ⟶ _>_
+  *-monoʳ-<-neg      : ∀ r → Negative r → (r *_) Preserves _<_ ⟶ _>_
+
+  pos⇒1/pos : ∀ p (p>0 : Positive p) → Positive ((1/ p) {{pos⇒≢0 p p>0}})
+  neg⇒1/neg : ∀ p (p<0 : Negative p) → Negative ((1/ p) {{neg⇒≢0 p p<0}})
+
+  *-distribʳ-⊓-nonNeg : ∀ p → NonNegative p → ∀ q r → (q ⊓ r) * p ≃ (q * p) ⊓ (r * p)
+  *-distribˡ-⊓-nonNeg : ∀ p → NonNegative p → ∀ q r → p * (q ⊓ r) ≃ (p * q) ⊓ (p * r)
+  *-distribˡ-⊔-nonNeg : ∀ p → NonNegative p → ∀ q r → p * (q ⊔ r) ≃ (p * q) ⊔ (p * r)
+  *-distribʳ-⊔-nonNeg : ∀ p → NonNegative p → ∀ q r → (q ⊔ r) * p ≃ (q * p) ⊔ (r * p)
+  *-distribˡ-⊔-nonPos : ∀ p → NonPositive p → ∀ q r → p * (q ⊔ r) ≃ (p * q) ⊓ (p * r)
+  *-distribʳ-⊔-nonPos : ∀ p → NonPositive p → ∀ q r → (q ⊔ r) * p ≃ (q * p) ⊓ (r * p)
+  *-distribˡ-⊓-nonPos : ∀ p → NonPositive p → ∀ q r → p * (q ⊓ r) ≃ (p * q) ⊔ (p * r)
+  *-distribʳ-⊓-nonPos : ∀ p → NonPositive p → ∀ q r → (q ⊓ r) * p ≃ (q * p) ⊔ (r * p)
+  ```
+
+* In `Data.Rational.Properties`:
+  ```
+  positive⁻¹ : Positive p → p > 0ℚ
+  nonNegative⁻¹ : NonNegative p → p ≥ 0ℚ
+  negative⁻¹ : Negative p → p < 0ℚ
+  nonPositive⁻¹ : NonPositive p → p ≤ 0ℚ
+  negative<positive : Negative p → Positive q → p < q
+  nonNeg≢neg : ∀ p q → NonNegative p → Negative q → p ≢ q
+  pos⇒nonNeg : ∀ p → Positive p → NonNegative p
+  neg⇒nonPos : ∀ p → Negative p → NonPositive p
+  nonNeg∧nonZero⇒pos : ∀ p → NonNegative p → NonZero p → Positive p
+
+  *-cancelʳ-≤-pos    : ∀ r → Positive r → ∀ {p q} → p * r ≤ q * r → p ≤ q
+  *-cancelˡ-≤-pos    : ∀ r → Positive r → ∀ {p q} → r * p ≤ r * q → p ≤ q
+  *-cancelʳ-≤-neg    : ∀ r → Negative r → ∀ {p q} → p * r ≤ q * r → p ≥ q
+  *-cancelˡ-≤-neg    : ∀ r → Negative r → ∀ {p q} → r * p ≤ r * q → p ≥ q
+  *-cancelˡ-<-nonNeg : ∀ r → NonNegative r → ∀ {p q} → r * p < r * q → p < q
+  *-cancelʳ-<-nonNeg : ∀ r → NonNegative r → ∀ {p q} → p * r < q * r → p < q
+  *-cancelˡ-<-nonPos : ∀ r → NonPositive r → ∀ {p q} → r * p < r * q → p > q
+  *-cancelʳ-<-nonPos : ∀ r → NonPositive r → ∀ {p q} → p * r < q * r → p > q
+  *-monoʳ-≤-nonNeg   : ∀ r → NonNegative r → (_* r) Preserves _≤_ ⟶ _≤_
+  *-monoˡ-≤-nonNeg   : ∀ r → NonNegative r → (r *_) Preserves _≤_ ⟶ _≤_
+  *-monoʳ-≤-nonPos   : ∀ r → NonPositive r → (_* r) Preserves _≤_ ⟶ _≥_
+  *-monoˡ-≤-nonPos   : ∀ r → NonPositive r → (r *_) Preserves _≤_ ⟶ _≥_
+  *-monoˡ-<-pos      : ∀ r → Positive r → (_* r) Preserves _<_ ⟶ _<_
+  *-monoʳ-<-pos      : ∀ r → Positive r → (r *_) Preserves _<_ ⟶ _<_
+  *-monoˡ-<-neg      : ∀ r → Negative r → (_* r) Preserves _<_ ⟶ _>_
+  *-monoʳ-<-neg      : ∀ r → Negative r → (r *_) Preserves _<_ ⟶ _>_
+
+  *-distribˡ-⊓-nonNeg : ∀ p → NonNegative p → ∀ q r → p * (q ⊓ r) ≡ (p * q) ⊓ (p * r)
+  *-distribʳ-⊓-nonNeg : ∀ p → NonNegative p → ∀ q r → (q ⊓ r) * p ≡ (q * p) ⊓ (r * p)
+  *-distribˡ-⊔-nonNeg : ∀ p → NonNegative p → ∀ q r → p * (q ⊔ r) ≡ (p * q) ⊔ (p * r)
+  *-distribʳ-⊔-nonNeg : ∀ p → NonNegative p → ∀ q r → (q ⊔ r) * p ≡ (q * p) ⊔ (r * p)
+  *-distribˡ-⊔-nonPos : ∀ p → NonPositive p → ∀ q r → p * (q ⊔ r) ≡ (p * q) ⊓ (p * r)
+  *-distribʳ-⊔-nonPos : ∀ p → NonPositive p → ∀ q r → (q ⊔ r) * p ≡ (q * p) ⊓ (r * p)
+  *-distribˡ-⊓-nonPos : ∀ p → NonPositive p → ∀ q r → p * (q ⊓ r) ≡ (p * q) ⊔ (p * r)
+  *-distribʳ-⊓-nonPos : ∀ p → NonPositive p → ∀ q r → (q ⊓ r) * p ≡ (q * p) ⊔ (r * p)
+
+  pos⇒1/pos : ∀ p (p>0 : Positive p) → Positive ((1/ p) {{pos⇒≢0 p p>0}})
+  neg⇒1/neg : ∀ p (p<0 : Negative p) → Negative ((1/ p) {{neg⇒≢0 p p<0}})
+  1/pos⇒pos : ∀ p .{{_ : NonZero p}} → (1/p : Positive (1/ p)) → Positive p
+  1/neg⇒neg : ∀ p .{{_ : NonZero p}} → (1/p : Negative (1/ p)) → Negative p
+  ```
diff --git a/CITATION.cff b/CITATION.cff
new file mode 100644
index 0000000000..5e965d00fa
--- /dev/null
+++ b/CITATION.cff
@@ -0,0 +1,8 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+- name: "The Agda Community"
+title: "Agda Standard Library"
+version: 2.0
+date-released: 2023-12-11
+url: "https://github.com/agda/agda-stdlib"
\ No newline at end of file
diff --git a/GNUmakefile b/GNUmakefile
index 685d1c990b..e744f066cc 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -9,11 +9,14 @@ AGDA=$(AGDA_EXEC) $(AGDA_OPTIONS) $(AGDA_RTS_OPTIONS)
 #   cabal install fix-whitespace
 
 test: Everything.agda check-whitespace
-	$(AGDA) -i. -isrc README.agda
+	cd doc && $(AGDA) README.agda
 
 testsuite:
 	$(MAKE) -C tests test AGDA="$(AGDA)" AGDA_EXEC="$(AGDA_EXEC)" only=$(only)
 
+fix-whitespace:
+	cabal exec -- fix-whitespace
+
 check-whitespace:
 	cabal exec -- fix-whitespace --check
 
@@ -21,11 +24,12 @@ setup: Everything.agda
 
 .PHONY: Everything.agda
 Everything.agda:
-	cabal run GenerateEverything
+	cabal run GenerateEverything -- --out-dir doc
 
 .PHONY: listings
 listings: Everything.agda
-	$(AGDA) -i. -isrc --html README.agda -v0
+	cd doc && $(AGDA) --html README.agda -v0
 
 clean :
 	find . -type f -name '*.agdai' -delete
+	rm -f Everything.agda EverythingSafe.agda
diff --git a/GenerateEverything.hs b/GenerateEverything.hs
index d513da0ab8..801c1b7e35 100644
--- a/GenerateEverything.hs
+++ b/GenerateEverything.hs
@@ -1,5 +1,7 @@
 {-# LANGUAGE PatternGuards #-}
 {-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE MultiWayIf #-}
 
 import Control.Applicative
 import Control.Monad
@@ -42,6 +44,18 @@ unsafeModules = map modToFile
   , "Codata.Musical.Covec"
   , "Codata.Musical.Conversion"
   , "Codata.Musical.Stream"
+  , "Data.Bytestring.Base"
+  , "Data.Bytestring.Builder.Base"
+  , "Data.Bytestring.Builder.Primitive"
+  , "Data.Bytestring.IO"
+  , "Data.Bytestring.IO.Primitive"
+  , "Data.Bytestring.Primitive"
+  , "Data.Word8.Base"
+  , "Data.Word8.Literals"
+  , "Data.Word8.Primitive"
+  , "Data.Word64.Primitive"
+  , "Data.Word8.Show"
+  , "Data.Word64.Show"
   , "Debug.Trace"
   , "Effect.Monad.IO"
   , "Effect.Monad.IO.Instances"
@@ -53,11 +67,15 @@ unsafeModules = map modToFile
   , "Foreign.Haskell.Pair"
   , "IO"
   , "IO.Base"
+  , "IO.Categorical"
+  , "IO.Handle"
   , "IO.Infinite"
   , "IO.Instances"
   , "IO.Effectful"
   , "IO.Finite"
   , "IO.Primitive"
+  , "IO.Primitive.Core"
+  , "IO.Primitive.Handle"
   , "IO.Primitive.Infinite"
   , "IO.Primitive.Finite"
   , "Relation.Binary.PropositionalEquality.TrustMe"
@@ -73,6 +91,8 @@ unsafeModules = map modToFile
   , "System.FilePath.Posix.Primitive"
   , "System.Process"
   , "System.Process.Primitive"
+  , "System.Random"
+  , "System.Random.Primitive"
   , "Test.Golden"
   , "Text.Pretty.Core"
   , "Text.Pretty"
@@ -121,6 +141,7 @@ sizedTypesModules = map modToFile
   , "Codata.Sized.Cofin.Literals"
   , "Codata.Sized.Colist"
   , "Codata.Sized.Colist.Bisimilarity"
+  , "Codata.Sized.Colist.Categorical"
   , "Codata.Sized.Colist.Effectful"
   , "Codata.Sized.Colist.Properties"
   , "Codata.Sized.Conat"
@@ -129,6 +150,7 @@ sizedTypesModules = map modToFile
   , "Codata.Sized.Conat.Properties"
   , "Codata.Sized.Covec"
   , "Codata.Sized.Covec.Bisimilarity"
+  , "Codata.Sized.Covec.Categorical"
   , "Codata.Sized.Covec.Effectful"
   , "Codata.Sized.Covec.Instances"
   , "Codata.Sized.Covec.Properties"
@@ -136,6 +158,7 @@ sizedTypesModules = map modToFile
   , "Codata.Sized.Cowriter.Bisimilarity"
   , "Codata.Sized.Delay"
   , "Codata.Sized.Delay.Bisimilarity"
+  , "Codata.Sized.Delay.Categorical"
   , "Codata.Sized.Delay.Effectful"
   , "Codata.Sized.Delay.Properties"
   , "Codata.Sized.M"
@@ -143,6 +166,7 @@ sizedTypesModules = map modToFile
   , "Codata.Sized.M.Properties"
   , "Codata.Sized.Stream"
   , "Codata.Sized.Stream.Bisimilarity"
+  , "Codata.Sized.Stream.Categorical"
   , "Codata.Sized.Stream.Effectful"
   , "Codata.Sized.Stream.Instances"
   , "Codata.Sized.Stream.Properties"
@@ -221,10 +245,10 @@ extractHeader mod = extract
 
 -- | A crude classifier looking for lines containing options
 
-data Status = Deprecated | Unsafe | Safe
-  deriving (Eq)
+data Safety = Unsafe | Safe deriving (Eq)
+data Status = Deprecated | Active deriving (Eq)
 
-classify :: FilePath -> [String] -> [String] -> Exc Status
+classify :: FilePath -> [String] -> [String] -> Exc (Safety, Status)
 classify fp hd ls
   -- We start with sanity checks
   | isUnsafe && safe          = throwError $ fp ++ contradiction "unsafe" "safe"
@@ -233,11 +257,12 @@ classify fp hd ls
   | isWithK && not withK      = throwError $ fp ++ missingWithK
   | not (isWithK || cubicalC) = throwError $ fp ++ uncategorized "as relying on K" "cubical-compatible"
   -- And then perform the actual classification
-  | deprecated                = pure $ Deprecated
-  | isUnsafe                  = pure $ Unsafe
-  | safe                      = pure $ Safe
-  -- We know that @not (isUnsafe || safe)@, all cases are covered
-  | otherwise                 = error "IMPOSSIBLE"
+  | otherwise = do
+      let safety = if | safe -> Safe
+                      | isUnsafe -> Unsafe
+                      | otherwise -> error "IMPOSSIBLE"
+      let status = if deprecated then Deprecated else Active
+      pure (safety, status)
 
   where
 
@@ -274,18 +299,20 @@ classify fp hd ls
 data LibraryFile = LibraryFile
   { filepath   :: FilePath -- ^ FilePath of the source file
   , header     :: [String] -- ^ All lines in the headers are already prefixed with \"-- \".
-  , status     :: Status   -- ^ Safety options used by the module
+  , safety     :: Safety
+  , status     :: Status   -- ^ Deprecation status options used by the module
   }
 
 analyse :: FilePath -> IO LibraryFile
 analyse fp = do
   ls <- lines <$> readFileUTF8 fp
   hd <- runExc $ extractHeader fp ls
-  cl <- runExc $ classify fp hd ls
+  (sf, st) <- runExc $ classify fp hd ls
   return $ LibraryFile
-    { filepath   = fp
-    , header     = hd
-    , status     = cl
+    { filepath = fp
+    , header   = hd
+    , safety   = sf
+    , status   = st
     }
 
 checkFilePaths :: String -> [FilePath] -> IO ()
@@ -294,18 +321,37 @@ checkFilePaths cat fps = forM_ fps $ \ fp -> do
   unless b $
     die $ fp ++ " is listed as " ++ cat ++ " but does not exist."
 
+data Options = Options
+  { includeDeprecated :: Bool
+  , outputDirectory :: FilePath
+  }
+
+initOptions :: Options
+initOptions = Options
+  { includeDeprecated = False
+  , outputDirectory = "."
+  }
+
+parseOptions :: [String] -> Options -> Maybe Options
+parseOptions [] opts = pure opts
+parseOptions ("--include-deprecated" : rest) opts
+  = parseOptions rest (opts { includeDeprecated = True })
+parseOptions ("--out-dir" : dir : rest) opts
+  = parseOptions rest (opts { outputDirectory = dir })
+parseOptions _ _ = Nothing
+
 ---------------------------------------------------------------------------
 -- Collecting all non-Core library files, analysing them and generating
--- 4 files:
+-- 2 files:
 -- Everything.agda                 all the modules
 -- EverythingSafe.agda             all the safe modules
 
+main :: IO ()
 main = do
   args <- getArgs
-  includeDeprecated <- case args of
-    [] -> return False
-    ["--include-deprecated"] -> return True
-    _  -> hPutStr stderr usage >> exitFailure
+  Options{..} <- case parseOptions args initOptions of
+    Just opts -> pure opts
+    Nothing -> hPutStr stderr usage >> exitFailure
 
   checkFilePaths "unsafe" unsafeModules
   checkFilePaths "using K" withKModules
@@ -320,18 +366,18 @@ main = do
 
   let mkModule str = "module " ++ str ++ " where"
 
-  writeFileUTF8 (allOutputFile ++ ".agda") $
+  writeFileUTF8 (outputDirectory ++ "/" ++ allOutputFile ++ ".agda") $
     unlines [ header
             , "{-# OPTIONS --rewriting --guardedness --sized-types #-}\n"
             , mkModule allOutputFile
             , format libraryfiles
             ]
 
-  writeFileUTF8 (safeOutputFile ++ ".agda") $
+  writeFileUTF8 (outputDirectory ++ "/" ++ safeOutputFile ++ ".agda") $
     unlines [ header
             , "{-# OPTIONS --safe --guardedness #-}\n"
             , mkModule safeOutputFile
-            , format $ filter ((Unsafe /=) . status) libraryfiles
+            , format $ filter ((Unsafe /=) . safety) libraryfiles
             ]
 
 -- | Usage info.
@@ -348,6 +394,9 @@ usage = unlines
   , "The program generates documentation for the library by extracting"
   , "headers from library modules. The output is written to " ++ allOutputFile
   , "with the file " ++ headerFile ++ " inserted verbatim at the beginning."
+  , ""
+  , "If the option --out-dir is used then the output is placed in the"
+  , "subdirectory thus selected."
   ]
 
 
diff --git a/HACKING.md b/HACKING.md
index b2d619ec32..4e8925648d 100644
--- a/HACKING.md
+++ b/HACKING.md
@@ -4,7 +4,7 @@ Contributing to the library
 Thank you for your interest in contributing to the Agda standard library.
 Hopefully this guide should make it easy to do so! Feel free to ask any
 questions on the Agda mailing list. Before you start please read the
-[style-guide](https://github.com/agda/agda-stdlib/blob/master/notes/style-guide.md).
+[style-guide](https://github.com/agda/agda-stdlib/blob/master/doc/style-guide.md).
 
 What is an acceptable contribution?
 ===================================
@@ -27,6 +27,18 @@ What is an acceptable contribution?
 In general, if something is in a general undergraduate Computer Science or Mathematics
 textbook it is probably (!) contributable.
 
+Note on contributions to related/'coupled' modules
+==================================================
+
+Before making changes to a `Data` module please have a look at related modules
+and see if they have any content along similar lines. If so, then please
+follow those conventions (e.g. naming, argument order).
+For example, if working on `Data.Rational`, please check `Data.Rational.Unnormalised`
+or if working on `Data.Vec` please check `Data.List` and vice versa.
+Likewise, if adding to such modules, please try to make companion additions
+to the related ones, or at least to make a task-list in the comments on your PR,
+indicating what outstanding work may be left for subsequent contributions/contributors.
+
 Setup
 =====
 
@@ -110,9 +122,9 @@ git checkout master
 git pull
 ```
 
-The second step is to create a branch for that feature based off of `master`.
+The second step is to create a branch for that feature based off `master`.
 Make sure to pick a fresh name in place of `new_feature`. We promptly push
-this new branch to our fork using the `-u` option fo `push`.
+this new branch to our fork using the `-u` option for `push`.
 
 ```shell
 git checkout -b new_feature
@@ -124,7 +136,7 @@ git push USER -u new_feature
 
 You can then proceed to make your changes. Please follow existing
 conventions in the library, see
-[style-guide](https://github.com/agda/agda-stdlib/blob/master/notes/style-guide.md).
+[style-guide](https://github.com/agda/agda-stdlib/blob/master/doc/style-guide.md).
 for details. Document your changes in `agda-stdlib-fork/CHANGELOG.md`.
 
 If you are creating new modules, please make sure you are having a
@@ -244,23 +256,14 @@ you are never committing anything with a whitespace violation:
 Type-checking the README directory
 ----------------------------------
 
-* By default the README directory is not exported in the
-  `standard-library.agda-lib` file in order to avoid clashing with other people's
-  README files. This means that by default type-checking a file in the README
-  directory fails.
-
-* If you wish to type-check a README file, then you will need to change the line:
-  ```
-  include: src
-  ```
-  to
-  ```
-  include: src .
-  ```
-  in the `standard-library.agda-lib` file.
-
-* Please do not include this change in your pull request.
+* By default the README files are not exported in the
+  `standard-library.agda-lib` file in order to avoid
+  clashing with other people's README files.
 
+* If you wish to type-check a README file, then you will
+  need to change the present working directory to `doc/`
+  where an appropriate `standard-library-doc.agda-lib`
+  file is present.
 
 Continuous Integration (CI)
 ===========================
diff --git a/LICENCE b/LICENCE
index 75026ebb47..3cd3c4395b 100644
--- a/LICENCE
+++ b/LICENCE
@@ -1,4 +1,4 @@
-Copyright (c) 2007-2021 Nils Anders Danielsson, Ulf Norell, Shin-Cheng
+Copyright (c) 2007-2024 Nils Anders Danielsson, Ulf Norell, Shin-Cheng
 Mu, Bradley Hardy, Samuel Bronson, Dan Doel, Patrik Jansson,
 Liang-Ting Chen, Jean-Philippe Bernardy, Andrés Sicard-Ramírez,
 Nicolas Pouillard, Darin Morrison, Peter Berry, Daniel Brown,
@@ -7,7 +7,8 @@ Eric Mertens, Joachim Breitner, Liyang Hu, Noam Zeilberger, Érdi Gergő,
 Stevan Andjelkovic, Helmut Grohne, Guilhem Moulin, Noriyuki Ohkawa,
 Evgeny Kotelnikov, James Chapman, Wen Kokke, Matthew Daggitt, Jason Hu,
 Sandro Stucki, Milo Turner, Zack Grannan, Lex van der Stoep,
-Jacques Carette, James McKinna and some anonymous contributors.
+Jacques Carette, James McKinna, Guillaume Allais
+and some anonymous contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the
diff --git a/README.md b/README.md
index 16a2f10959..4eba8bf8cd 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-![Travis (.org) branch](https://img.shields.io/travis/agda/agda-stdlib/master?label=master)
-![Travis (.org) branch](https://img.shields.io/travis/agda/agda-stdlib/experimental?label=experimental)
+[![Ubuntu build](https://github.com/agda/agda-stdlib/actions/workflows/ci-ubuntu.yml/badge.svg)](https://github.com/agda/agda-stdlib/actions/workflows/ci-ubuntu.yml)
 
+[![Ubuntu build](https://github.com/agda/agda-stdlib/actions/workflows/ci-ubuntu.yml/badge.svg?branch=experimental)](https://github.com/agda/agda-stdlib/actions/workflows/ci-ubuntu.yml)
 
 The Agda standard library
 =========================
@@ -18,36 +18,33 @@ If you're looking to find your way around the library, there are several
 different ways to get started:
 
 - The library's structure and the associated design choices are described
-in the [README.agda](https://github.com/agda/agda-stdlib/tree/master/README.agda).
+in the [README.agda](https://github.com/agda/agda-stdlib/tree/master/doc/README.agda).
 
-- The [README folder](https://github.com/agda/agda-stdlib/tree/master/README),
+- The [README folder](https://github.com/agda/agda-stdlib/tree/master/doc/README),
 which mirrors the structure of the main library, contains examples of how to
 use some of the more common modules. Feel free to [open a new issue](https://github.com/agda/agda-stdlib/issues/new) if there's a particular module you feel could do with
 some more documentation.
 
-- You can [browse the library's source code](https://agda.github.io/agda-stdlib/README.html)
+- You can [browse the library's source code](https://agda.github.io/agda-stdlib/)
 in glorious clickable HTML.
 
-- Finally, you can get an overview of the entire library by looking at the
-[index](https://agda.github.io/agda-stdlib/), which lists all modules
-in the library except the deprecated ones.
-
 ## Installation instructions
 
-See the [installation instructions](https://github.com/agda/agda-stdlib/blob/master/notes/installation-guide.md) for the latest version of the standard library.
+See the [installation instructions](https://github.com/agda/agda-stdlib/blob/master/doc/installation-guide.md) for the latest version of the standard library.
 
 #### Old versions of Agda
 
 If you're using an old version of Agda, you can download the corresponding version
 of the standard library on the [Agda wiki](http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Libraries.StandardLibrary).
 The module index for older versions of the library is also available. For example,
-version 0.17 can be found at https://agda.github.io/agda-stdlib/v0.17/, just
-replace in the URL 0.17 with the version that you need.
+version 1.7 can be found at https://agda.github.io/agda-stdlib/v1.7/, just
+replace in the URL 1.7 with the version that you need.
 
 #### Development version of Agda
 
 If you're using a development version of Agda rather than the latest official release,
 you should use the `experimental` branch of the standard library rather than `master`.
+[Instructions for updating the `experimental` branch](https://github.com/agda/agda-stdlib/blob/master/doc/updating-experimental.txt).
 The `experimental` branch contains non-backward compatible patches for upcoming
 changes to the language.
 
@@ -56,14 +53,14 @@ changes to the language.
 #### The `--safe` flag
 
 Most of the library can be type-checked using the `--safe` flag. Please consult
-[GenerateEverything.hs](https://github.com/agda/agda-stdlib/blob/master/GenerateEverything.hs#L23)
+[GenerateEverything.hs](https://github.com/agda/agda-stdlib/blob/master/GenerateEverything.hs#L32-L82)
 for a full list of modules that use unsafe features.
 
-#### The `--without-k` flag
+#### The `--cubical-compatible` flag
 
-Most of the library can be type-checked using the `--without-k` flag. Please consult
-[GenerateEverything.hs](https://github.com/agda/agda-stdlib/blob/master/GenerateEverything.hs#L74)
-for a full list of modules that use axiom K.
+Most of the library can be type-checked using the `--cubical-compatible` flag, which since Agda v2.6.3 supersedes the former `--without-K` flag. Please consult
+[GenerateEverything.hs](https://github.com/agda/agda-stdlib/blob/master/GenerateEverything.hs#L91-L111)
+for a full list of modules that use axiom K, requiring the `--with-K` flag.
 
 ## Contributing to the library
 
diff --git a/agda-stdlib-utils.cabal b/agda-stdlib-utils.cabal
index 880494db15..d9fe1dc676 100644
--- a/agda-stdlib-utils.cabal
+++ b/agda-stdlib-utils.cabal
@@ -1,13 +1,16 @@
 cabal-version:   2.4
 name:            agda-stdlib-utils
-version:         2.0
+version:         2.1
 build-type:      Simple
 description:     Helper programs for setting up the Agda standard library.
 license:         MIT
 
 tested-with:
-  GHC == 9.4.4
-  GHC == 9.2.6
+  GHC == 9.10.1
+  GHC == 9.8.2
+  GHC == 9.6.5
+  GHC == 9.4.8
+  GHC == 9.2.8
   GHC == 9.0.2
   GHC == 8.10.7
   GHC == 8.8.4
@@ -21,7 +24,7 @@ common common-build-parameters
     PatternSynonyms
 
   build-depends:
-      base          >= 4.12.0.0 && < 4.18
+      base          >= 4.12.0.0 && < 4.21
     , filemanip     >= 0.3.6.2  && < 0.4
 
 executable GenerateEverything
@@ -31,7 +34,7 @@ executable GenerateEverything
 
   build-depends:
       directory     >= 1.0.0.0  && < 1.4
-    , filepath      >= 1.4.1.0  && < 1.5
+    , filepath      >= 1.4.1.0  && < 1.6
     , mtl           >= 2.2.2    && < 2.4
 
 executable AllNonAsciiChars
@@ -40,4 +43,4 @@ executable AllNonAsciiChars
   main-is:          AllNonAsciiChars.hs
 
   build-depends:
-      text          >= 1.2.3.1  && < 2.1
+      text          >= 1.2.3.1  && < 2.2
diff --git a/dev/.gitignore b/dev/.gitignore
new file mode 100644
index 0000000000..f59ec20aab
--- /dev/null
+++ b/dev/.gitignore
@@ -0,0 +1 @@
+*
\ No newline at end of file
diff --git a/dev/README.md b/dev/README.md
new file mode 100644
index 0000000000..d97d344209
--- /dev/null
+++ b/dev/README.md
@@ -0,0 +1,4 @@
+# Development playground
+
+This directory allows you to develop modules against the current dev
+version of the stdlib as it currently sits in `src/`.
diff --git a/dev/experimental.agda-lib b/dev/experimental.agda-lib
new file mode 100644
index 0000000000..cb094977d8
--- /dev/null
+++ b/dev/experimental.agda-lib
@@ -0,0 +1,4 @@
+name: standard-library-dev
+include: . ../src
+flags:
+  --warning=noUnsupportedIndexedMatch
diff --git a/README.agda b/doc/README.agda
similarity index 93%
rename from README.agda
rename to doc/README.agda
index 2d87cb56d2..6a9a3e398c 100644
--- a/README.agda
+++ b/doc/README.agda
@@ -7,18 +7,19 @@ module README where
 --
 -- Authors: Nils Anders Danielsson, Matthew Daggitt, Guillaume Allais
 -- with contributions from Andreas Abel, Stevan Andjelkovic,
--- Jean-Philippe Bernardy, Peter Berry, Bradley Hardy Joachim Breitner,
+-- Jean-Philippe Bernardy, Peter Berry, Bradley Hardy, Joachim Breitner,
 -- Samuel Bronson, Daniel Brown, Jacques Carette, James Chapman,
 -- Liang-Ting Chen, Dominique Devriese, Dan Doel, Érdi Gergő,
 -- Zack Grannan, Helmut Grohne, Simon Foster, Liyang Hu, Jason Hu,
 -- Patrik Jansson, Alan Jeffrey, Wen Kokke, Evgeny Kotelnikov,
--- Sergei Meshveliani, Eric Mertens, Darin Morrison, Guilhem Moulin,
--- Shin-Cheng Mu, Ulf Norell, Noriyuki Ohkawa, Nicolas Pouillard,
--- Andrés Sicard-Ramírez, Lex van der Stoep, Sandro Stucki, Milo Turner,
--- Noam Zeilberger and other anonymous contributors.
+-- James McKinna, Sergei Meshveliani, Eric Mertens, Darin Morrison,
+-- Guilhem Moulin, Shin-Cheng Mu, Ulf Norell, Noriyuki Ohkawa,
+-- Nicolas Pouillard, Andrés Sicard-Ramírez, Lex van der Stoep,
+-- Sandro Stucki, Milo Turner, Noam Zeilberger, Shu-Hung You
+-- and other anonymous contributors.
 ------------------------------------------------------------------------
 
--- This version of the library has been tested using Agda 2.6.2.
+-- This version of the library has been tested using Agda 2.6.4.
 
 -- The library comes with a .agda-lib file, for use with the library
 -- management system.
@@ -221,6 +222,10 @@ import Text.Printf
 
 import README.Case
 
+-- Showcasing the framework for well-scoped substitutions
+
+import README.Data.Fin.Substitution.UntypedLambda
+
 -- Some examples showing how combinators can be used to emulate
 -- "functional reasoning"
 
diff --git a/README/Axiom.agda b/doc/README/Axiom.agda
similarity index 100%
rename from README/Axiom.agda
rename to doc/README/Axiom.agda
diff --git a/README/Case.agda b/doc/README/Case.agda
similarity index 87%
rename from README/Case.agda
rename to doc/README/Case.agda
index 358460a63b..62fec18c0f 100644
--- a/README/Case.agda
+++ b/doc/README/Case.agda
@@ -12,13 +12,8 @@ module README.Case where
 open import Data.Fin   hiding (pred)
 open import Data.Maybe hiding (from-just)
 open import Data.Nat   hiding (pred)
-open import Data.List
-open import Data.Sum
-open import Data.Product
-open import Function.Base using (case_of_; case_return_of_)
+open import Function.Base using (case_of_; case_returning_of_)
 open import Relation.Nullary
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
 
 ------------------------------------------------------------------------
 -- Different types of pattern-matching lambdas
@@ -40,7 +35,7 @@ pred n = case n of λ
 -- where-introduced and indentation-identified block of list of clauses
 
 from-just : ∀ {a} {A : Set a} (x : Maybe A) → From-just x
-from-just x = case x return From-just of λ where
+from-just x = case x returning From-just of λ where
   (just x) → x
   nothing  → _
 
diff --git a/README/Data.agda b/doc/README/Data.agda
similarity index 96%
rename from README/Data.agda
rename to doc/README/Data.agda
index be35a5bfc4..c1e900e541 100644
--- a/README/Data.agda
+++ b/doc/README/Data.agda
@@ -209,11 +209,17 @@ import README.Data.Record
 
 import README.Data.Trie.NonDependent
 
+-- Examples of equational reasoning about vectors of non-definitionally
+-- equal lengths.
+
+import README.Data.Vec.Relation.Binary.Equality.Cast
+
 -- Examples how (indexed) containers and constructions over them (free
 -- monad, least fixed point, etc.) can be used
 
 import README.Data.Container.FreeMonad
-import README.Data.Container.Indexed
+import README.Data.Container.Indexed.VectorExample
+import README.Data.Container.Indexed.MultiSortedAlgebraExample
 
 -- Wrapping n-ary relations into a record definition so type-inference
 -- remembers the things being related.
diff --git a/README/Data/Container/FreeMonad.agda b/doc/README/Data/Container/FreeMonad.agda
similarity index 91%
rename from README/Data/Container/FreeMonad.agda
rename to doc/README/Data/Container/FreeMonad.agda
index 7c4460609e..3d3b2d5ff4 100644
--- a/README/Data/Container/FreeMonad.agda
+++ b/doc/README/Data/Container/FreeMonad.agda
@@ -15,13 +15,13 @@ open import Data.Empty
 open import Data.Unit
 open import Data.Bool.Base using (Bool; true)
 open import Data.Nat
-open import Data.Sum using (inj₁; inj₂)
-open import Data.Product renaming (_×_ to _⟨×⟩_)
+open import Data.Sum.Base using (inj₁; inj₂)
+open import Data.Product.Base
 open import Data.Container using (Container; _▷_)
-open import Data.Container.Combinator
-open import Data.Container.FreeMonad as FreeMonad
+open import Data.Container.Combinator hiding (_×_)
+open import Data.Container.FreeMonad
 open import Data.W
-open import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.PropositionalEquality as ≡
 
 ------------------------------------------------------------------------
 -- Defining the signature of an effect and building trees describing
@@ -51,13 +51,13 @@ prog =
   where
   open RawMonad monad using (_>>_)
 
-runState : {S X : Set} → State S ⋆ X → (S → X ⟨×⟩ S)
+runState : {S X : Set} → State S ⋆ X → (S → X × S)
 runState (pure x)                = λ s → x , s
 runState (impure ((inj₁ _) , k)) = λ s → runState (k s) s
 runState (impure ((inj₂ s) , k)) = λ _ → runState (k _) s
 
 test : runState prog 0 ≡ (true , 1)
-test = P.refl
+test = ≡.refl
 
 -- It should be noted that @State S ⋆ X@ is not the state monad. If we
 -- could quotient @State S ⋆ X@ by the seven axioms of state (see
diff --git a/doc/README/Data/Container/Indexed/MultiSortedAlgebraExample.agda b/doc/README/Data/Container/Indexed/MultiSortedAlgebraExample.agda
new file mode 100644
index 0000000000..0c466c932c
--- /dev/null
+++ b/doc/README/Data/Container/Indexed/MultiSortedAlgebraExample.agda
@@ -0,0 +1,431 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Example of multi-sorted algebras as indexed containers
+------------------------------------------------------------------------
+
+{-# OPTIONS --safe --cubical-compatible #-}
+
+module README.Data.Container.Indexed.MultiSortedAlgebraExample where
+
+------------------------------------------------------------------------
+-- Preliminaries
+------------------------------------------------------------------------
+-- We import library content for indexed containers, standard types,
+-- and setoids.
+
+open import Level
+
+open import Data.Container.Indexed.Core using (Container; ⟦_⟧; _◃_/_)
+open import Data.Container.Indexed.FreeMonad using (_⋆C_)
+open import Data.W.Indexed using (W; sup)
+
+open import Data.Product using (Σ; _×_; _,_; Σ-syntax)
+open import Data.Sum using (_⊎_; inj₁; inj₂; [_,_])
+open import Data.Empty.Polymorphic using (⊥; ⊥-elim)
+
+open import Function using (_∘_)
+open import Function.Bundles using (Func)
+
+open import Relation.Binary using (Setoid; IsEquivalence)
+open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+
+import Data.Container.Indexed.Relation.Binary.Equality.Setoid as ICSetoid
+import Relation.Binary.Reasoning.Setoid as SetoidReasoning
+
+open Setoid using (Carrier; _≈_; isEquivalence)
+open Func renaming (to to apply)
+
+-- Letter ℓ denotes universe levels.
+
+variable
+  ℓ ℓ' ℓˢ ℓᵒ ℓᵃ ℓᵐ ℓᵉ ℓⁱ : Level
+  I : Set ℓⁱ
+  S : Set ℓˢ
+
+------------------------------------------------------------------------
+-- The interpretation of a container (Op ◃ Ar / sort) is
+--
+--   ⟦ Op ◃ Ar / sort ⟧ X s = Σ[ o ∈ Op s ] ((i : Ar o) → X (sort o i))
+--
+-- which contains pairs consisting of an operator $o$ and its collection
+-- of arguments.  The least fixed point of (X ↦ ⟦ C ⟧ X) is the indexed
+-- W-type given by C, and it contains closed first-order terms of the
+-- multi-sorted algebra C.
+
+-- We need to interpret indexed containers on Setoids.
+-- This definition is missing from the standard library v1.7.
+
+⟦_⟧s : (C : Container I S ℓᵒ ℓᵃ) (ξ : I → Setoid ℓᵐ ℓᵉ) → S → Setoid _ _
+⟦ C ⟧s ξ = ICSetoid.setoid ξ C
+
+------------------------------------------------------------------------
+-- Multi-sorted algebras
+--------------------------------------------------------------------------
+-- A multi-sorted algebra is an indexed container.
+--
+-- * Sorts are indexes.
+--
+-- * Operators are commands/shapes.
+--
+-- * Arities/argument are responses/positions.
+--
+-- Closed terms (initial model) are given by the W type for a container,
+-- renamed to μ here (for least fixed-point).
+
+-- We assume a fixed signature (Sort, Ops).
+
+module _ (Sort : Set ℓˢ) (Ops : Container Sort Sort ℓᵒ ℓᵃ) where
+  open Container Ops renaming
+    ( Command   to  Op
+    ; Response  to  Arity
+    ; next      to  sort
+    )
+
+-- We let letter $s$ range over sorts and $\mathit{op}$ over operators.
+
+  variable
+    s s'    : Sort
+    op op'  : Op s
+
+------------------------------------------------------------------------
+-- Models
+
+  -- A model is given by an interpretation (Den $s$) for each sort $s$
+  -- plus an interpretation (den $o$) for each operator $o$.
+
+  record SetModel ℓᵐ : Set (ℓˢ ⊔ ℓᵒ ⊔ ℓᵃ ⊔ suc ℓᵐ) where
+    field
+      Den : Sort → Set ℓᵐ
+      den : {s : Sort} → ⟦ Ops ⟧ Den s → Den s
+
+  -- The setoid model requires operators to respect equality.
+  -- The Func record packs a function (apply) with a proof (cong)
+  -- that the function maps equals to equals.
+
+  record SetoidModel ℓᵐ ℓᵉ : Set (ℓˢ ⊔ ℓᵒ ⊔ ℓᵃ ⊔ suc (ℓᵐ ⊔ ℓᵉ)) where
+    field
+      Den  :  Sort → Setoid ℓᵐ ℓᵉ
+      den  :  {s : Sort} → Func (⟦ Ops ⟧s Den s) (Den s)
+
+
+------------------------------------------------------------------------
+-- Terms
+
+  -- To obtain terms with free variables, we add additional nullary
+  -- operators, each representing a variable.
+  --
+  -- These are covered in the standard library FreeMonad module,
+  -- albeit with the restriction that the operator and variable sets
+  -- have the same size.
+
+  Cxt = Sort → Set ℓᵒ
+
+  variable
+    Γ Δ : Cxt
+
+  -- Terms with free variables in Var.
+
+  module _ (Var : Cxt) where
+
+    -- We keep the same sorts, but add a nullary operator for each variable.
+
+    Ops⁺ : Container Sort Sort ℓᵒ ℓᵃ
+    Ops⁺ = Ops ⋆C Var
+
+    -- Terms with variables are then given by the W-type for the extended container.
+
+    Tm = W Ops⁺
+
+    -- We define nice constructors for variables and operator application
+    -- via pattern synonyms.
+    -- Note that the $f$ in constructor var' is a function from the empty set,
+    -- so it should be uniquely determined.  However, Agda's equality is
+    -- more intensional and will not identify all functions from the empty set.
+    -- Since we do not make use of the axiom of function extensionality,
+    -- we sometimes have to consult the extensional equality of the
+    -- function setoid.
+
+    pattern _∙_ op args  = sup (inj₂ op , args)
+    pattern var' x f     = sup (inj₁ x , f    )
+    pattern var x        = var' x _
+
+  -- Letter $t$ ranges over terms, and $\mathit{ts}$ over argument vectors.
+
+  variable
+    t t' t₁ t₂ t₃  :  Tm Γ s
+    ts ts'         :  (i : Arity op) → Tm Γ (sort _ i)
+
+------------------------------------------------------------------------
+-- Parallel substitutions
+
+  -- A substitution from Δ to Γ holds a term in Γ for each variable in Δ.
+
+  Sub : (Γ Δ : Cxt) → Set _
+  Sub Γ Δ = ∀{s} (x : Δ s) → Tm Γ s
+
+  -- Application of a substitution.
+
+  _[_] : (t : Tm Δ s) (σ : Sub Γ Δ) → Tm Γ s
+  (var x  )  [ σ ] = σ x
+  (op ∙ ts)  [ σ ] = op ∙ λ i → ts i [ σ ]
+
+  -- Letter $σ$ ranges over substitutions.
+
+  variable
+    σ σ' : Sub Γ Δ
+
+------------------------------------------------------------------------
+-- Interpretation of terms in a model
+------------------------------------------------------------------------
+
+  -- Given an algebra $M$ of set-size $ℓ^m$ and equality-size $ℓ^e$,
+  -- we define the interpretation of an $s$-sorted term $t$ as element
+  -- of $M(s)$ according to an environment $ρ$ that maps each variable
+  -- of sort $s'$ to an element of $M(s')$.
+
+  module _ {M : SetoidModel ℓᵐ ℓᵉ} where
+    open SetoidModel M
+
+    -- Equality in $M$'s interpretation of sort $s$.
+
+    _≃_ : Den s .Carrier → Den s .Carrier → Set _
+    _≃_ {s = s} = Den s ._≈_
+
+    -- An environment for Γ maps each variable $x : Γ(s)$ to an element of $M(s)$.
+    -- Equality of environments is defined pointwise.
+
+    Env : Cxt → Setoid _ _
+    Env Γ .Carrier   = {s : Sort} (x : Γ s) → Den s .Carrier
+    Env Γ ._≈_ ρ ρ'  = {s : Sort} (x : Γ s) → ρ x ≃ ρ' x
+    Env Γ .isEquivalence .IsEquivalence.refl   {s = s}   x = Den s .Setoid.refl
+    Env Γ .isEquivalence .IsEquivalence.sym       h {s}  x = Den s .Setoid.sym   (h x)
+    Env Γ .isEquivalence .IsEquivalence.trans  g  h {s}  x = Den s .Setoid.trans (g x) (h x)
+
+    -- Interpretation of terms is iteration on the W-type.
+    -- The standard library offers `iter' (on sets), but we need this to be a Func (on setoids).
+
+    ⦅_⦆ : ∀{s} (t : Tm Γ s) → Func (Env Γ) (Den s)
+    ⦅ var x      ⦆ .apply  ρ     = ρ x
+    ⦅ var x      ⦆ .cong   ρ=ρ'  = ρ=ρ' x
+    ⦅ op ∙ args  ⦆ .apply  ρ     = den .apply  (op    , λ i → ⦅ args i ⦆ .apply ρ)
+    ⦅ op ∙ args  ⦆ .cong   ρ=ρ'  = den .cong   (refl  , λ i → ⦅ args i ⦆ .cong ρ=ρ')
+
+    -- An equality between two terms holds in a model
+    -- if the two terms are equal under all valuations of their free variables.
+
+    Equal : ∀ {Γ s} (t t' : Tm Γ s) → Set _
+    Equal {Γ} {s} t t' = ∀ (ρ : Env Γ .Carrier) → ⦅ t ⦆ .apply ρ ≃ ⦅ t' ⦆ .apply ρ
+
+    -- This notion is an equivalence relation.
+
+    isEquiv : IsEquivalence (Equal {Γ = Γ} {s = s})
+    isEquiv {s = s} .IsEquivalence.refl  ρ       = Den s .Setoid.refl
+    isEquiv {s = s} .IsEquivalence.sym   e ρ     = Den s .Setoid.sym (e ρ)
+    isEquiv {s = s} .IsEquivalence.trans e e' ρ  = Den s .Setoid.trans (e ρ) (e' ρ)
+
+------------------------------------------------------------------------
+-- Substitution lemma
+
+    -- Evaluation of a substitution gives an environment.
+
+    ⦅_⦆s : Sub Γ Δ → Env Γ .Carrier → Env Δ .Carrier
+    ⦅ σ ⦆s ρ x = ⦅ σ x ⦆ .apply ρ
+
+    -- Substitution lemma: ⦅t[σ]⦆ρ ≃ ⦅t⦆⦅σ⦆ρ
+
+    substitution : (t : Tm Δ s) (σ : Sub Γ Δ) (ρ : Env Γ .Carrier) →
+      ⦅ t [ σ ] ⦆ .apply ρ ≃ ⦅ t ⦆ .apply (⦅ σ ⦆s ρ)
+    substitution (var x)    σ ρ = Den _ .Setoid.refl
+    substitution (op ∙ ts)  σ ρ = den .cong (refl , λ i → substitution (ts i) σ ρ)
+
+------------------------------------------------------------------------
+-- Equations
+
+  -- An equation is a pair $t ≐ t'$ of terms of the same sort in the same context.
+
+  record Eq : Set (ℓˢ ⊔ suc ℓᵒ ⊔ ℓᵃ) where
+    constructor _≐_
+    field
+      {cxt}  : Sort → Set ℓᵒ
+      {srt}  : Sort
+      lhs    : Tm cxt srt
+      rhs    : Tm cxt srt
+
+  -- Equation $t ≐ t'$ holding in model $M$.
+
+  _⊧_ : (M : SetoidModel ℓᵐ ℓᵉ) (eq : Eq) → Set _
+  M ⊧ (t ≐ t') = Equal {M = M} t t'
+
+  -- Sets of equations are presented as collection E : I → Eq
+  -- for some index set I : Set ℓⁱ.
+
+  -- An entailment/consequence $E ⊃ t ≐ t'$ is valid
+  -- if $t ≐ t'$ holds in all models that satify equations $E$.
+
+  module _ {ℓᵐ ℓᵉ} where
+
+    _⊃_ : (E : I → Eq) (eq : Eq) → Set _
+    E ⊃ eq = ∀ (M : SetoidModel ℓᵐ ℓᵉ) → (∀ i → M ⊧ E i) → M ⊧ eq
+
+  -- Derivations
+  --------------
+
+  -- Equalitional logic allows us to prove entailments via the
+  -- inference rules for the judgment $E ⊢ Γ ▹ t ≡ t'$.
+  -- This could be coined as equational theory over a given
+  -- set of equations $E$.
+  -- Relation $E ⊢ Γ ▹ \_ ≡ \_$ is the least congruence over the equations $E$.
+
+  data _⊢_▹_≡_ {I : Set ℓⁱ}
+    (E : I → Eq) : (Γ : Cxt) (t t' : Tm Γ s) → Set (ℓˢ ⊔ suc ℓᵒ ⊔ ℓᵃ ⊔ ℓⁱ) where
+
+    hyp    :  ∀ i → let t ≐ t' = E i in
+              E ⊢ _ ▹ t ≡ t'
+
+    base   :  ∀ (x : Γ s) {f f' : (i : ⊥) → Tm _ (⊥-elim i)} →
+              E ⊢ Γ ▹ var' x f ≡ var' x f'
+
+    app    :  (∀ i → E ⊢ Γ ▹ ts i ≡ ts' i) →
+              E ⊢ Γ ▹ (op ∙ ts) ≡ (op ∙ ts')
+
+    sub    :  E ⊢ Δ ▹ t ≡ t' →
+              ∀ (σ : Sub Γ Δ) →
+              E ⊢ Γ ▹ (t [ σ ]) ≡ (t' [ σ ])
+
+    refl   :  ∀ (t : Tm Γ s) →
+              E ⊢ Γ ▹ t ≡ t
+
+    sym    :  E ⊢ Γ ▹ t ≡ t' →
+              E ⊢ Γ ▹ t' ≡ t
+
+    trans  :  E ⊢ Γ ▹ t₁ ≡ t₂ →
+              E ⊢ Γ ▹ t₂ ≡ t₃ →
+              E ⊢ Γ ▹ t₁ ≡ t₃
+
+------------------------------------------------------------------------
+-- Soundness of the inference rules
+
+  -- We assume a model $M$ that validates all equations in $E$.
+
+  module Soundness {I : Set ℓⁱ} (E : I → Eq) (M : SetoidModel ℓᵐ ℓᵉ)
+    (V : ∀ i → M ⊧ E i) where
+    open SetoidModel M
+
+    -- In any model $M$ that satisfies the equations $E$,
+    -- derived equality is actual equality.
+
+    sound : E ⊢ Γ ▹ t ≡ t' → M ⊧ (t ≐ t')
+
+    sound (hyp i)                        =  V i
+    sound (app {op = op} es) ρ           =  den .cong (refl , λ i → sound (es i) ρ)
+    sound (sub {t = t} {t' = t'} e σ) ρ  =  begin
+      ⦅ t [ σ ]   ⦆ .apply ρ   ≈⟨ substitution {M = M} t σ ρ ⟩
+      ⦅ t         ⦆ .apply ρ'  ≈⟨ sound e ρ' ⟩
+      ⦅ t'        ⦆ .apply ρ'  ≈⟨ substitution {M = M} t' σ ρ ⟨
+      ⦅ t' [ σ ]  ⦆ .apply ρ   ∎
+      where
+      open SetoidReasoning (Den _)
+      ρ' = ⦅ σ ⦆s ρ
+
+    sound (base x {f} {f'})              =  isEquiv {M = M} .IsEquivalence.refl {var' x λ()}
+
+    sound (refl t)                       =  isEquiv {M = M} .IsEquivalence.refl {t}
+    sound (sym {t = t} {t' = t'} e)      =  isEquiv {M = M} .IsEquivalence.sym
+                                            {x = t} {y = t'} (sound e)
+    sound (trans  {t₁ = t₁} {t₂ = t₂}
+                  {t₃ = t₃} e e')        =  isEquiv {M = M} .IsEquivalence.trans
+                                            {i = t₁} {j = t₂} {k = t₃} (sound e) (sound e')
+
+
+------------------------------------------------------------------------
+-- Birkhoff's completeness theorem
+------------------------------------------------------------------------
+
+  -- Birkhoff proved that any equation $t ≐ t'$ is derivable from $E$
+  -- when it is valid in all models satisfying $E$.  His proof (for
+  -- single-sorted algebras) is a blue print for many more
+  -- completeness proofs.  They all proceed by constructing a
+  -- universal model aka term model.  In our case, it is terms
+  -- quotiented by derivable equality $E ⊢ Γ ▹ \_ ≡ \_$.  It then
+  -- suffices to prove that this model satisfies all equations in $E$.
+
+------------------------------------------------------------------------
+-- Universal model
+
+  -- A term model for $E$ and $Γ$ interprets sort $s$ by (Tm Γ s) quotiented by $E ⊢ Γ ▹ \_ ≡ \_$.
+
+  module TermModel {I : Set ℓⁱ} (E : I → Eq) where
+    open SetoidModel
+
+    -- Tm Γ s quotiented by E⊢Γ▹·≡·.
+
+    TmSetoid : Cxt → Sort → Setoid _ _
+    TmSetoid Γ s .Carrier                             = Tm Γ s
+    TmSetoid Γ s ._≈_                                 = E ⊢ Γ ▹_≡_
+    TmSetoid Γ s .isEquivalence .IsEquivalence.refl   = refl _
+    TmSetoid Γ s .isEquivalence .IsEquivalence.sym    = sym
+    TmSetoid Γ s .isEquivalence .IsEquivalence.trans  = trans
+
+    -- The interpretation of an operator is simply the operator.
+    -- This works because $E⊢Γ▹\_≡\_$ is a congruence.
+
+    tmInterp : ∀ {Γ s} → Func (⟦ Ops ⟧s (TmSetoid Γ) s) (TmSetoid Γ s)
+    tmInterp .apply (op , ts) = op ∙ ts
+    tmInterp .cong (refl , h) = app h
+
+    -- The term model per context Γ.
+
+    M : Cxt → SetoidModel _ _
+    M Γ .Den = TmSetoid Γ
+    M Γ .den = tmInterp
+
+    -- The identity substitution σ₀ maps variables to themselves.
+
+    σ₀ : {Γ : Cxt} → Sub Γ Γ
+    σ₀ x = var' x  λ()
+
+    -- σ₀ acts indeed as identity.
+
+    identity : (t : Tm Γ s) → E ⊢ Γ ▹ t [ σ₀ ] ≡ t
+    identity (var x)    = base x
+    identity (op ∙ ts)  = app λ i → identity (ts i)
+
+    -- Evaluation in the term model is substitution $E ⊢ Γ ▹ ⦅t⦆σ ≡ t[σ]$.
+    -- This would even hold "up to the nose" if we had function extensionality.
+
+    evaluation : (t : Tm Δ s) (σ : Sub Γ Δ) → E ⊢ Γ ▹ (⦅_⦆ {M = M Γ} t .apply σ) ≡ (t [ σ ])
+    evaluation (var x)    σ = refl (σ x)
+    evaluation (op ∙ ts)  σ = app (λ i → evaluation (ts i) σ)
+
+    -- The term model satisfies all the equations it started out with.
+
+    satisfies : ∀ i → M Γ ⊧ E i
+    satisfies i σ = begin
+      ⦅ tₗ ⦆ .apply σ  ≈⟨ evaluation tₗ σ ⟩
+      tₗ [ σ ]         ≈⟨ sub (hyp i) σ ⟩
+      tᵣ [ σ ]         ≈⟨ evaluation tᵣ σ ⟨
+      ⦅ tᵣ ⦆ .apply σ  ∎
+      where
+      open SetoidReasoning (TmSetoid _ _)
+      tₗ  = E i .Eq.lhs
+      tᵣ = E i .Eq.rhs
+
+------------------------------------------------------------------------
+-- Completeness
+
+-- Birkhoff's completeness theorem \citeyearpar{birkhoff:1935}:
+-- Any valid consequence is derivable in the equational theory.
+
+  module Completeness {I : Set ℓⁱ} (E : I → Eq) {Γ s} {t t' : Tm Γ s} where
+    open TermModel E
+
+    completeness : E ⊃ (t ≐ t') → E ⊢ Γ ▹ t ≡ t'
+    completeness V =     begin
+      t                  ≈˘⟨ identity t ⟩
+      t  [ σ₀ ]          ≈˘⟨ evaluation t σ₀ ⟩
+      ⦅ t   ⦆ .apply σ₀  ≈⟨ V (M Γ) satisfies σ₀ ⟩
+      ⦅ t'  ⦆ .apply σ₀  ≈⟨ evaluation t' σ₀ ⟩
+      t' [ σ₀ ]          ≈⟨ identity t' ⟩
+      t'                 ∎
+      where open SetoidReasoning (TmSetoid Γ s)
diff --git a/README/Data/Container/Indexed.agda b/doc/README/Data/Container/Indexed/VectorExample.agda
similarity index 87%
rename from README/Data/Container/Indexed.agda
rename to doc/README/Data/Container/Indexed/VectorExample.agda
index 0c94e182ec..45d45cc740 100644
--- a/README/Data/Container/Indexed.agda
+++ b/doc/README/Data/Container/Indexed/VectorExample.agda
@@ -6,13 +6,13 @@
 
 {-# OPTIONS --with-K --safe --guardedness #-}
 
-module README.Data.Container.Indexed where
+module README.Data.Container.Indexed.VectorExample where
 
 open import Data.Unit
 open import Data.Empty
 open import Data.Nat.Base
-open import Data.Product
-open import Function
+open import Data.Product.Base using (_,_)
+open import Function.Base using (_∋_)
 open import Data.W.Indexed
 open import Data.Container.Indexed
 open import Data.Container.Indexed.WithK
@@ -27,12 +27,14 @@ module _ {a} (A : Set a) where
 -- 2. Responses the indexed container returns to these commands
 -- 3. Update of the index based on the command and the response issued.
 
--- For a vector, commands are constructors, responses are the number of subvectors
--- (0 if the vector is empty, 1 otherwise) and the update corresponds to setting the
--- size of the tail (if it exists). We can formalize these ideas like so:
+-- For a vector, commands are constructors, responses are the number
+-- of subvectors (0 if the vector is empty, 1 otherwise) and the
+-- update corresponds to setting the size of the tail (if it exists).
+-- We can formalize these ideas like so:
 
--- Depending on the size of the vector, we may have reached the end already (nil)
--- or we may specify what the head should be (cons). This is the type of commands.
+-- Depending on the size of the vector, we may have reached the end
+-- already (nil) or we may specify what the head should be (cons).
+-- This is the type of commands.
 
   data VecC : ℕ → Set a where
     nil  :           VecC zero
diff --git a/README/Data/Default.agda b/doc/README/Data/Default.agda
similarity index 100%
rename from README/Data/Default.agda
rename to doc/README/Data/Default.agda
diff --git a/doc/README/Data/Fin/Relation/Unary/Top.agda b/doc/README/Data/Fin/Relation/Unary/Top.agda
new file mode 100644
index 0000000000..390a48d58f
--- /dev/null
+++ b/doc/README/Data/Fin/Relation/Unary/Top.agda
@@ -0,0 +1,100 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Example use of the 'top' view of Fin
+--
+-- This is an example of a view of (elements of) a datatype,
+-- here i : Fin (suc n), which exhibits every such i as
+-- * either, i = fromℕ n
+-- * or, i = inject₁ j for a unique j : Fin n
+--
+-- Using this view, we can redefine certain operations in `Data.Fin.Base`,
+-- together with their corresponding properties in `Data.Fin.Properties`.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module README.Data.Fin.Relation.Unary.Top where
+
+open import Data.Nat.Base using (ℕ; zero; suc; _∸_; _≤_)
+open import Data.Nat.Properties using (n∸n≡0; +-∸-assoc; ≤-reflexive)
+open import Data.Fin.Base using (Fin; zero; suc; toℕ; fromℕ; inject₁; _>_)
+open import Data.Fin.Properties using (toℕ-fromℕ; toℕ<n; toℕ-inject₁)
+open import Data.Fin.Induction hiding (>-weakInduction)
+open import Data.Fin.Relation.Unary.Top
+import Induction.WellFounded as WF
+open import Level using (Level)
+open import Relation.Binary.PropositionalEquality
+open import Relation.Unary using (Pred)
+
+private
+  variable
+    ℓ : Level
+    n : ℕ
+
+------------------------------------------------------------------------
+-- Reimplementation of `Data.Fin.Base.opposite`, and its properties
+
+-- Definition
+
+opposite : Fin n → Fin n
+opposite {suc n} i with view i
+... | ‵fromℕ     = zero
+... | ‵inject₁ j = suc (opposite {n} j)
+
+-- Properties
+
+opposite-zero≡fromℕ : ∀ n → opposite {suc n} zero ≡ fromℕ n
+opposite-zero≡fromℕ zero    = refl
+opposite-zero≡fromℕ (suc n) = cong suc (opposite-zero≡fromℕ n)
+
+opposite-fromℕ≡zero : ∀ n → opposite {suc n} (fromℕ n) ≡ zero
+opposite-fromℕ≡zero n rewrite view-fromℕ n = refl
+
+opposite-suc≡inject₁-opposite : (j : Fin n) →
+                                opposite (suc j) ≡ inject₁ (opposite j)
+opposite-suc≡inject₁-opposite {suc n} i with view i
+... | ‵fromℕ     = refl
+... | ‵inject₁ j = cong suc (opposite-suc≡inject₁-opposite {n} j)
+
+opposite-involutive : (j : Fin n) → opposite (opposite j) ≡ j
+opposite-involutive {suc n} zero
+  rewrite opposite-zero≡fromℕ n
+        | view-fromℕ n              = refl
+opposite-involutive {suc n} (suc i)
+  rewrite opposite-suc≡inject₁-opposite i
+        | view-inject₁ (opposite i) = cong suc (opposite-involutive i)
+
+opposite-suc : (j : Fin n) → toℕ (opposite (suc j)) ≡ toℕ (opposite j)
+opposite-suc j = begin
+  toℕ (opposite (suc j))      ≡⟨ cong toℕ (opposite-suc≡inject₁-opposite j) ⟩
+  toℕ (inject₁ (opposite j))  ≡⟨ toℕ-inject₁ (opposite j) ⟩
+  toℕ (opposite j)            ∎ where open ≡-Reasoning
+
+opposite-prop : (j : Fin n) → toℕ (opposite j) ≡ n ∸ suc (toℕ j)
+opposite-prop {suc n} i with view i
+... | ‵fromℕ  rewrite toℕ-fromℕ n | n∸n≡0 n = refl
+... | ‵inject₁ j = begin
+  suc (toℕ (opposite j)) ≡⟨ cong suc (opposite-prop j) ⟩
+  suc (n ∸ suc (toℕ j))  ≡⟨ +-∸-assoc 1 (toℕ<n j) ⟨
+  n ∸ toℕ j              ≡⟨ cong (n ∸_) (toℕ-inject₁ j) ⟨
+  n ∸ toℕ (inject₁ j)    ∎ where open ≡-Reasoning
+
+------------------------------------------------------------------------
+-- Reimplementation of `Data.Fin.Induction.>-weakInduction`
+
+open WF using (Acc; acc)
+
+>-weakInduction : (P : Pred (Fin (suc n)) ℓ) →
+                  P (fromℕ n) →
+                  (∀ i → P (suc i) → P (inject₁ i)) →
+                  ∀ i → P i
+>-weakInduction P Pₙ Pᵢ₊₁⇒Pᵢ i = induct (>-wellFounded i)
+  where
+  induct : ∀ {i} → Acc _>_ i → P i
+  induct {i} (acc rec) with view i
+  ... | ‵fromℕ = Pₙ
+  ... | ‵inject₁ j = Pᵢ₊₁⇒Pᵢ j (induct (rec _ inject₁[j]+1≤[j+1]))
+    where
+    inject₁[j]+1≤[j+1] : suc (toℕ (inject₁ j)) ≤ toℕ (suc j)
+    inject₁[j]+1≤[j+1] = ≤-reflexive (toℕ-inject₁ (suc j))
diff --git a/doc/README/Data/Fin/Substitution/UntypedLambda.agda b/doc/README/Data/Fin/Substitution/UntypedLambda.agda
new file mode 100644
index 0000000000..036f7ed5ca
--- /dev/null
+++ b/doc/README/Data/Fin/Substitution/UntypedLambda.agda
@@ -0,0 +1,103 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- An example of how Data.Fin.Substitution can be used: a definition
+-- of substitution for the untyped λ-calculus, along with some lemmas
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module README.Data.Fin.Substitution.UntypedLambda where
+
+open import Data.Fin.Substitution
+open import Data.Fin.Substitution.Lemmas
+open import Data.Nat.Base hiding (_/_)
+open import Data.Fin.Base using (Fin)
+open import Data.Vec.Base
+open import Relation.Binary.PropositionalEquality
+  using (_≡_; refl; sym; cong; cong₂; module ≡-Reasoning)
+open import Relation.Binary.Construct.Closure.ReflexiveTransitive
+  using (Star; ε; _◅_)
+
+open ≡-Reasoning
+
+private
+  variable
+    m n : ℕ
+
+------------------------------------------------------------------------
+-- A representation of the untyped λ-calculus. Uses de Bruijn indices.
+
+infixl 9 _·_
+
+data Lam (n : ℕ) : Set where
+  var : (x : Fin n) → Lam n
+  ƛ   : (t : Lam (suc n)) → Lam n
+  _·_ : (t₁ t₂ : Lam n) → Lam n
+
+------------------------------------------------------------------------
+-- Code for applying substitutions.
+
+module LamApp {ℓ} {T : ℕ → Set ℓ} (l : Lift T Lam) where
+  open Lift l hiding (var)
+
+  -- Applies a substitution to a term.
+
+  infixl 8 _/_
+
+  _/_ : Lam m → Sub T m n → Lam n
+  var x   / ρ = lift (lookup ρ x)
+  ƛ t     / ρ = ƛ (t / ρ ↑)
+  t₁ · t₂ / ρ = (t₁ / ρ) · (t₂ / ρ)
+
+  open Application (record { _/_ = _/_ }) using (_/✶_)
+
+  -- Some lemmas about _/_.
+
+  ƛ-/✶-↑✶ : ∀ k {t} (ρs : Subs T m n) →
+            ƛ t /✶ ρs ↑✶ k ≡ ƛ (t /✶ ρs ↑✶ suc k)
+  ƛ-/✶-↑✶ k ε        = refl
+  ƛ-/✶-↑✶ k (ρ ◅ ρs) = cong (_/ _) (ƛ-/✶-↑✶ k ρs)
+
+  ·-/✶-↑✶ : ∀ k {t₁ t₂} (ρs : Subs T m n) →
+            t₁ · t₂ /✶ ρs ↑✶ k ≡ (t₁ /✶ ρs ↑✶ k) · (t₂ /✶ ρs ↑✶ k)
+  ·-/✶-↑✶ k ε        = refl
+  ·-/✶-↑✶ k (ρ ◅ ρs) = cong (_/ _) (·-/✶-↑✶ k ρs)
+
+lamSubst : TermSubst Lam
+lamSubst = record { var = var; app = LamApp._/_ }
+
+open TermSubst lamSubst hiding (var)
+
+------------------------------------------------------------------------
+-- Substitution lemmas.
+
+lamLemmas : TermLemmas Lam
+lamLemmas = record
+  { termSubst = lamSubst
+  ; app-var   = refl
+  ; /✶-↑✶     = Lemma./✶-↑✶
+  }
+  where
+  module Lemma {T₁ T₂} {lift₁ : Lift T₁ Lam} {lift₂ : Lift T₂ Lam} where
+
+    open Lifted lift₁ using () renaming (_↑✶_ to _↑✶₁_; _/✶_ to _/✶₁_)
+    open Lifted lift₂ using () renaming (_↑✶_ to _↑✶₂_; _/✶_ to _/✶₂_)
+
+    /✶-↑✶ : (ρs₁ : Subs T₁ m n) (ρs₂ : Subs T₂ m n) →
+            (∀ k x → var x /✶₁ ρs₁ ↑✶₁ k ≡ var x /✶₂ ρs₂ ↑✶₂ k) →
+             ∀ k t → t     /✶₁ ρs₁ ↑✶₁ k ≡ t     /✶₂ ρs₂ ↑✶₂ k
+    /✶-↑✶ ρs₁ ρs₂ hyp k (var x) = hyp k x
+    /✶-↑✶ ρs₁ ρs₂ hyp k (ƛ t)   = begin
+      ƛ t /✶₁ ρs₁ ↑✶₁ k        ≡⟨ LamApp.ƛ-/✶-↑✶ _ k ρs₁ ⟩
+      ƛ (t /✶₁ ρs₁ ↑✶₁ suc k)  ≡⟨ cong ƛ (/✶-↑✶ ρs₁ ρs₂ hyp (suc k) t) ⟩
+      ƛ (t /✶₂ ρs₂ ↑✶₂ suc k)  ≡⟨ sym (LamApp.ƛ-/✶-↑✶ _ k ρs₂) ⟩
+      ƛ t /✶₂ ρs₂ ↑✶₂ k        ∎
+    /✶-↑✶ ρs₁ ρs₂ hyp k (t₁ · t₂) = begin
+      t₁ · t₂ /✶₁ ρs₁ ↑✶₁ k                    ≡⟨ LamApp.·-/✶-↑✶ _ k ρs₁ ⟩
+      (t₁ /✶₁ ρs₁ ↑✶₁ k) · (t₂ /✶₁ ρs₁ ↑✶₁ k)  ≡⟨ cong₂ _·_ (/✶-↑✶ ρs₁ ρs₂ hyp k t₁)
+                                                            (/✶-↑✶ ρs₁ ρs₂ hyp k t₂) ⟩
+      (t₁ /✶₂ ρs₂ ↑✶₂ k) · (t₂ /✶₂ ρs₂ ↑✶₂ k)  ≡⟨ sym (LamApp.·-/✶-↑✶ _ k ρs₂) ⟩
+      t₁ · t₂ /✶₂ ρs₂ ↑✶₂ k                    ∎
+
+open TermLemmas lamLemmas public hiding (var)
diff --git a/README/Data/Integer.agda b/doc/README/Data/Integer.agda
similarity index 83%
rename from README/Data/Integer.agda
rename to doc/README/Data/Integer.agda
index e93333dcf5..bb3f867137 100644
--- a/README/Data/Integer.agda
+++ b/doc/README/Data/Integer.agda
@@ -33,30 +33,29 @@ ex₃ = + 1  +  + 3 * - + 2  -  + 4
 -- Propositional equality and some related properties can be found
 -- in Relation.Binary.PropositionalEquality.
 
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)
 
 ex₄ : ex₃ ≡ - + 9
-ex₄ = P.refl
+ex₄ = ≡.refl
 
 -- Data.Integer.Properties contains a number of properties related to
 -- integers. Algebra defines what a commutative ring is, among other
 -- things.
 
-import Data.Integer.Properties as ℤₚ
+import Data.Integer.Properties as ℤ
 
 ex₅ : ∀ i j → i * j ≡ j * i
-ex₅ i j = ℤₚ.*-comm i j
+ex₅ i j = ℤ.*-comm i j
 
 -- The module ≡-Reasoning in Relation.Binary.PropositionalEquality
 -- provides some combinators for equational reasoning.
 
-open P.≡-Reasoning
-open import Data.Product
+open ≡.≡-Reasoning
 
 ex₆ : ∀ i j → i * (j + + 0) ≡ j * i
 ex₆ i j = begin
-  i * (j + + 0)  ≡⟨ P.cong (i *_) (ℤₚ.+-identityʳ j) ⟩
-  i * j          ≡⟨ ℤₚ.*-comm i j ⟩
+  i * (j + + 0)  ≡⟨ ≡.cong (i *_) (ℤ.+-identityʳ j) ⟩
+  i * j          ≡⟨ ℤ.*-comm i j ⟩
   j * i          ∎
 
 -- The module RingSolver in Data.Integer.Solver contains a solver
@@ -68,4 +67,4 @@ open +-*-Solver
 
 ex₇ : ∀ i j → i * - j - j * i ≡ - + 2 * i * j
 ex₇ = solve 2 (λ i j → i :* :- j :- j :* i  :=  :- con (+ 2) :* i :* j)
-              P.refl
+              ≡.refl
diff --git a/README/Data/List.agda b/doc/README/Data/List.agda
similarity index 99%
rename from README/Data/List.agda
rename to doc/README/Data/List.agda
index 6cb8bba0b1..2c284daa78 100644
--- a/README/Data/List.agda
+++ b/doc/README/Data/List.agda
@@ -48,7 +48,7 @@ lem₅ = refl
 open import Data.List.Properties
 
 lem₆ : ∀ n (xs : List ℕ) → take n xs ++ drop n xs ≡ xs
-lem₆ = take++drop
+lem₆ = take++drop≡id
 
 lem₇ : ∀ (xs : List ℕ) → reverse (reverse xs) ≡ xs
 lem₇ = reverse-involutive
diff --git a/README/Data/List/Fresh.agda b/doc/README/Data/List/Fresh.agda
similarity index 97%
rename from README/Data/List/Fresh.agda
rename to doc/README/Data/List/Fresh.agda
index 27f7eb7ca0..4723c0631e 100644
--- a/README/Data/List/Fresh.agda
+++ b/doc/README/Data/List/Fresh.agda
@@ -12,7 +12,7 @@ open import Data.Nat
 open import Data.List.Base
 open import Data.List.Fresh
 open import Data.List.Relation.Unary.AllPairs as AllPairs using (AllPairs)
-open import Data.Product
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Relation.Nary using (⌊_⌋; fromWitness)
 
 -- A sorted list of natural numbers can be seen as a fresh list
diff --git a/README/Data/List/Membership.agda b/doc/README/Data/List/Membership.agda
similarity index 91%
rename from README/Data/List/Membership.agda
rename to doc/README/Data/List/Membership.agda
index 9cb89a8159..38732fe631 100644
--- a/README/Data/List/Membership.agda
+++ b/doc/README/Data/List/Membership.agda
@@ -7,11 +7,11 @@
 module README.Data.List.Membership where
 
 open import Data.Char.Base using (Char; fromℕ)
-open import Data.Char.Properties as CharProp hiding (setoid)
-open import Data.Nat as ℕ using (ℕ; _+_; _<_; s≤s; z≤n; _*_; _∸_; _≤_)
+open import Data.Char.Properties as Char hiding (setoid)
 open import Data.List.Base using (List; []; _∷_; map)
+open import Data.Nat as ℕ using (ℕ)
 open import Relation.Binary.PropositionalEquality
-  using (_≡_; refl; sym; cong; setoid)
+  using (_≡_; refl; cong; setoid)
 
 ------------------------------------------------------------------------
 -- Membership
@@ -66,7 +66,7 @@ import Data.List.Membership.Propositional.Properties as PropProperties
 -- following the first `∈` refers to lists of type `List ℕ` whereas
 -- the second `∈` refers to lists of type `List Char`.
 
-open DecPropMembership CharProp._≟_ renaming (_∈_ to _∈ᶜ_)
+open DecPropMembership Char._≟_ renaming (_∈_ to _∈ᶜ_)
 open SetoidProperties using (∈-map⁺)
 
 lem₂ : {v : ℕ} {xs : List ℕ} → v ∈ xs → fromℕ v ∈ᶜ map fromℕ xs
diff --git a/README/Data/List/Relation/Binary/Equality.agda b/doc/README/Data/List/Relation/Binary/Equality.agda
similarity index 96%
rename from README/Data/List/Relation/Binary/Equality.agda
rename to doc/README/Data/List/Relation/Binary/Equality.agda
index 6201dc5c5d..5820501564 100644
--- a/README/Data/List/Relation/Binary/Equality.agda
+++ b/doc/README/Data/List/Relation/Binary/Equality.agda
@@ -9,10 +9,8 @@
 module README.Data.List.Relation.Binary.Equality where
 
 open import Data.Nat using (ℕ; _+_; _<_; s≤s; z≤n; _*_; _∸_; _≤_)
-open import Data.Nat.Properties as NatProp
+open import Data.Nat.Properties as ℕ
 open import Data.List.Base
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; refl; sym; cong; setoid)
 
 ------------------------------------------------------------------------
 -- Pointwise equality
@@ -54,7 +52,7 @@ open import Relation.Binary.PropositionalEquality using (_≗_)
 -- to `_≗_`. However instead of using the pointwise module directly
 -- to write:
 
-open import Data.List.Relation.Binary.Pointwise using (Pointwise)
+open import Data.List.Relation.Binary.Pointwise.Base using (Pointwise)
 
 lem₃ : Pointwise _≗_ ((λ x → x + 1) ∷ []) ((λ x → x + 2 ∸ 1) ∷ [])
 lem₃ = {!!}
diff --git a/README/Data/List/Relation/Binary/Permutation.agda b/doc/README/Data/List/Relation/Binary/Permutation.agda
similarity index 100%
rename from README/Data/List/Relation/Binary/Permutation.agda
rename to doc/README/Data/List/Relation/Binary/Permutation.agda
diff --git a/README/Data/List/Relation/Binary/Pointwise.agda b/doc/README/Data/List/Relation/Binary/Pointwise.agda
similarity index 96%
rename from README/Data/List/Relation/Binary/Pointwise.agda
rename to doc/README/Data/List/Relation/Binary/Pointwise.agda
index 4932413ad4..da804f12c9 100644
--- a/README/Data/List/Relation/Binary/Pointwise.agda
+++ b/doc/README/Data/List/Relation/Binary/Pointwise.agda
@@ -7,7 +7,7 @@
 module README.Data.List.Relation.Binary.Pointwise where
 
 open import Data.Nat using (ℕ; _<_; s≤s; z≤n)
-open import Data.List using (List; []; _∷_; length)
+open import Data.List.Base using (List; []; _∷_; length)
 open import Relation.Binary.PropositionalEquality
   using (_≡_; refl; sym; cong; setoid)
 open import Relation.Nullary.Negation using (¬_)
diff --git a/README/Data/List/Relation/Binary/Subset.agda b/doc/README/Data/List/Relation/Binary/Subset.agda
similarity index 93%
rename from README/Data/List/Relation/Binary/Subset.agda
rename to doc/README/Data/List/Relation/Binary/Subset.agda
index 44ba3fa053..ccef725cca 100644
--- a/README/Data/List/Relation/Binary/Subset.agda
+++ b/doc/README/Data/List/Relation/Binary/Subset.agda
@@ -4,7 +4,7 @@
 -- Documentation for subset relations over `List`s
 ------------------------------------------------------------------------
 
-open import Data.List using (List; _∷_; [])
+open import Data.List.Base using (List; _∷_; [])
 open import Data.List.Membership.Propositional.Properties
   using (∈-++⁺ˡ; ∈-insert)
 open import Data.List.Relation.Binary.Subset.Propositional using (_⊆_)
@@ -21,7 +21,8 @@ module README.Data.List.Relation.Binary.Subset where
 -- tell Agda which equality relation to use.
 
 -- Decidable equality over Strings
-open import Data.String using (String; _≟_)
+open import Data.String.Base using (String)
+open import Data.String.Properties using (_≟_)
 
 -- Open the decidable membership module using Decidable ≡ over Strings
 open import Data.List.Membership.DecPropositional _≟_
diff --git a/README/Data/List/Relation/Ternary/Interleaving.agda b/doc/README/Data/List/Relation/Ternary/Interleaving.agda
similarity index 100%
rename from README/Data/List/Relation/Ternary/Interleaving.agda
rename to doc/README/Data/List/Relation/Ternary/Interleaving.agda
diff --git a/README/Data/List/Relation/Unary/All.agda b/doc/README/Data/List/Relation/Unary/All.agda
similarity index 100%
rename from README/Data/List/Relation/Unary/All.agda
rename to doc/README/Data/List/Relation/Unary/All.agda
diff --git a/README/Data/List/Relation/Unary/Any.agda b/doc/README/Data/List/Relation/Unary/Any.agda
similarity index 100%
rename from README/Data/List/Relation/Unary/Any.agda
rename to doc/README/Data/List/Relation/Unary/Any.agda
diff --git a/README/Data/Nat.agda b/doc/README/Data/Nat.agda
similarity index 100%
rename from README/Data/Nat.agda
rename to doc/README/Data/Nat.agda
diff --git a/README/Data/Nat/Induction.agda b/doc/README/Data/Nat/Induction.agda
similarity index 87%
rename from README/Data/Nat/Induction.agda
rename to doc/README/Data/Nat/Induction.agda
index d430d6d992..6f47ddc07f 100644
--- a/README/Data/Nat/Induction.agda
+++ b/doc/README/Data/Nat/Induction.agda
@@ -9,11 +9,19 @@ module README.Data.Nat.Induction where
 
 open import Data.Nat
 open import Data.Nat.Induction
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (_∘_)
 open import Induction.WellFounded
 open import Relation.Binary.PropositionalEquality
 
+private
+
+  n<′1+n : ∀ {n} → n <′ suc n
+  n<′1+n = ≤′-refl
+
+  n<′2+n : ∀ {n} → n <′ suc (suc n)
+  n<′2+n = ≤′-step ≤′-refl
+
 -- Doubles its input.
 
 twice : ℕ → ℕ
@@ -46,7 +54,7 @@ mutual
   half₂-step = λ
     { zero          _   → zero
     ; (suc zero)    _   → zero
-    ; (suc (suc n)) rec → suc (rec n (≤′-step ≤′-refl))
+    ; (suc (suc n)) rec → suc (rec n<′2+n)
     }
 
   half₂ : ℕ → ℕ
@@ -92,21 +100,21 @@ half₂-2+ n = begin
 
   half₂-step (2 + n) (<′-recBuilder _ half₂-step (2 + n))     ≡⟨⟩
 
-  1 + <′-recBuilder _ half₂-step (2 + n) n (≤′-step ≤′-refl)  ≡⟨⟩
+  1 + <′-recBuilder _ half₂-step (2 + n) n<′2+n  ≡⟨⟩
 
   1 + Some.wfRecBuilder _ half₂-step (2 + n)
-        (<′-wellFounded (2 + n)) n (≤′-step ≤′-refl)          ≡⟨⟩
+        (<′-wellFounded (2 + n)) n<′2+n          ≡⟨⟩
 
   1 + Some.wfRecBuilder _ half₂-step (2 + n)
-        (acc (<′-wellFounded′ (2 + n))) n (≤′-step ≤′-refl)   ≡⟨⟩
+        (acc (<′-wellFounded′ (2 + n))) n<′2+n   ≡⟨⟩
 
   1 + half₂-step n
         (Some.wfRecBuilder _ half₂-step n
-           (<′-wellFounded′ (2 + n) n (≤′-step ≤′-refl)))     ≡⟨⟩
+           (<′-wellFounded′ (2 + n) n<′2+n))     ≡⟨⟩
 
   1 + half₂-step n
         (Some.wfRecBuilder _ half₂-step n
-           (<′-wellFounded′ (1 + n) n ≤′-refl))               ≡⟨⟩
+           (<′-wellFounded′ (1 + n) n<′1+n))               ≡⟨⟩
 
   1 + half₂-step n
         (Some.wfRecBuilder _ half₂-step n (<′-wellFounded n)) ≡⟨⟩
@@ -146,7 +154,7 @@ half₁-+₂ = <′-rec _ λ
   { zero          _   → refl
   ; (suc zero)    _   → refl
   ; (suc (suc n)) rec →
-      cong (suc ∘ suc) (rec n (≤′-step ≤′-refl))
+      cong (suc ∘ suc) (rec n<′2+n)
   }
 
 half₂-+₂ : ∀ n → half₂ (twice n) ≡ n
@@ -154,6 +162,6 @@ half₂-+₂ = <′-rec _ λ
   { zero          _   → refl
   ; (suc zero)    _   → refl
   ; (suc (suc n)) rec →
-      cong (suc ∘ suc) (rec n (≤′-step ≤′-refl))
+      cong (suc ∘ suc) (rec n<′2+n)
   }
 
diff --git a/README/Data/Record.agda b/doc/README/Data/Record.agda
similarity index 91%
rename from README/Data/Record.agda
rename to doc/README/Data/Record.agda
index 5800d11e54..63fea328ae 100644
--- a/README/Data/Record.agda
+++ b/doc/README/Data/Record.agda
@@ -11,11 +11,11 @@
 
 module README.Data.Record where
 
-open import Data.Product
+open import Data.Product.Base using (_,_)
 open import Data.String
 open import Function.Base using (flip)
 open import Level
-open import Relation.Binary
+open import Relation.Binary.Definitions using (Symmetric; Transitive)
 
 import Data.Record as Record
 
diff --git a/README/Data/Tree/AVL.agda b/doc/README/Data/Tree/AVL.agda
similarity index 90%
rename from README/Data/Tree/AVL.agda
rename to doc/README/Data/Tree/AVL.agda
index 1d14058ff8..7e29f09f17 100644
--- a/README/Data/Tree/AVL.agda
+++ b/doc/README/Data/Tree/AVL.agda
@@ -20,9 +20,9 @@ import Data.Tree.AVL
 -- natural numbers as keys and vectors of strings as values.
 
 open import Data.Nat.Properties using (<-strictTotalOrder)
-open import Data.Product as Prod using (_,_; _,′_)
-open import Data.String using (String)
-open import Data.Vec using (Vec; _∷_; [])
+open import Data.Product.Base as Product using (_,_; _,′_)
+open import Data.String.Base using (String)
+open import Data.Vec.Base using (Vec; _∷_; [])
 open import Relation.Binary.PropositionalEquality
 
 open Data.Tree.AVL <-strictTotalOrder renaming (Tree to Tree′)
@@ -60,7 +60,7 @@ t₃ = delete 2 t₂
 
 -- Conversion of a list of key-value mappings to a tree.
 
-open import Data.List using (_∷_; [])
+open import Data.List.Base using (_∷_; [])
 
 t₄ : Tree
 t₄ = fromList ((2 , v₂) ∷ (1 , v₁) ∷ [])
@@ -111,14 +111,14 @@ open import Function.Base using (id)
 v₆ : headTail t₀ ≡ nothing
 v₆ = refl
 
-v₇ : Maybe.map (Prod.map₂ toList) (headTail t₂) ≡
+v₇ : Maybe.map (Product.map₂ toList) (headTail t₂) ≡
      just ((1 , v₁) , ((2 , v₂) ∷ []))
 v₇ = refl
 
 v₈ : initLast t₀ ≡ nothing
 v₈ = refl
 
-v₉ : Maybe.map (Prod.map₁ toList) (initLast t₄) ≡
+v₉ : Maybe.map (Product.map₁ toList) (initLast t₄) ≡
      just (((1 , v₁) ∷ []) ,′ (2 , v₂))
 v₉ = refl
 
diff --git a/README/Data/Tree/Binary.agda b/doc/README/Data/Tree/Binary.agda
similarity index 95%
rename from README/Data/Tree/Binary.agda
rename to doc/README/Data/Tree/Binary.agda
index cf7e2de90a..0f03ad7b79 100644
--- a/README/Data/Tree/Binary.agda
+++ b/doc/README/Data/Tree/Binary.agda
@@ -4,7 +4,7 @@
 -- Some examples showing how the Binary tree module can be used
 ------------------------------------------------------------------------
 
-{-# OPTIONS --cubical-compatible --safe --sized-types #-}
+{-# OPTIONS --cubical-compatible --sized-types #-}
 
 module README.Data.Tree.Binary where
 
diff --git a/README/Data/Tree/Rose.agda b/doc/README/Data/Tree/Rose.agda
similarity index 100%
rename from README/Data/Tree/Rose.agda
rename to doc/README/Data/Tree/Rose.agda
diff --git a/README/Data/Trie/NonDependent.agda b/doc/README/Data/Trie/NonDependent.agda
similarity index 91%
rename from README/Data/Trie/NonDependent.agda
rename to doc/README/Data/Trie/NonDependent.agda
index 09825c30c3..385e981880 100644
--- a/README/Data/Trie/NonDependent.agda
+++ b/doc/README/Data/Trie/NonDependent.agda
@@ -51,18 +51,19 @@ module README.Data.Trie.NonDependent where
 open import Level
 open import Data.Unit
 open import Data.Bool
-open import Data.Char        as Char
-import Data.Char.Properties  as Char
-open import Data.List        as List using (List; []; _∷_)
-open import Data.List.Fresh  as List# using (List#; []; _∷#_)
-open import Data.Maybe       as Maybe
-open import Data.Product     as Prod
-open import Data.String      as String using (String)
-open import Data.These       as These
+open import Data.Char              as Char
+import Data.Char.Properties        as Char
+open import Data.List.Base         as List using (List; []; _∷_)
+open import Data.List.Fresh        as List# using (List#; []; _∷#_)
+open import Data.Maybe             as Maybe
+open import Data.Product.Base      as Product using (_×_; ∃; proj₁; _,_)
+open import Data.String.Base       as String using (String)
+open import Data.String.Properties as String using (_≟_)
+open import Data.These             as These
 
 open import Function.Base using (case_of_; _$_; _∘′_; id; _on_)
 open import Relation.Nary
-open import Relation.Binary using (Rel)
+open import Relation.Binary.Core using (Rel)
 open import Relation.Nullary.Decidable using (¬?)
 
 open import Data.Trie Char.<-strictTotalOrder
@@ -126,7 +127,7 @@ module _ {t} (L : Lexer t) where
     -- characters one by one
 
     init : Keywords
-    init = fromList $ List.map (Prod.map₁ String.toList) $ proj₁ $ List#.toList keywords
+    init = fromList $ List.map (Product.map₁ String.toList) $ proj₁ $ List#.toList keywords
 
     -- Kickstart the tokeniser with an empty accumulator and the initial
     -- trie.
diff --git a/doc/README/Data/Vec/Relation/Binary/Equality/Cast.agda b/doc/README/Data/Vec/Relation/Binary/Equality/Cast.agda
new file mode 100644
index 0000000000..e06cdb49f0
--- /dev/null
+++ b/doc/README/Data/Vec/Relation/Binary/Equality/Cast.agda
@@ -0,0 +1,282 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- An equational reasoning library for propositional equality over
+-- vectors of different indices using cast.
+--
+-- To see example usages of this library, scroll to the `Combinators`
+-- section.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module README.Data.Vec.Relation.Binary.Equality.Cast where
+
+open import Agda.Primitive
+open import Data.List.Base as List using (List)
+import Data.List.Properties as List
+open import Data.Nat.Base
+open import Data.Nat.Properties
+open import Data.Vec.Base
+open import Data.Vec.Properties
+open import Data.Vec.Relation.Binary.Equality.Cast
+open import Relation.Binary.PropositionalEquality
+  using (_≡_; refl; sym; cong; module ≡-Reasoning)
+
+private variable
+  a : Level
+  A : Set a
+  l m n o : ℕ
+  xs ys zs ws : Vec A n
+
+
+------------------------------------------------------------------------
+-- Motivation
+--
+-- The `cast` function is the computational variant of `subst` for
+-- vectors. Since `cast` computes under vector constructors, it
+-- enables reasoning about vectors with non-definitionally equal indices
+-- by induction. See, e.g., Jacques Carette's comment in issue #1668.
+-- <https://github.com/agda/agda-stdlib/pull/1668#issuecomment-1003449509>
+--
+-- Suppose we want to prove that ‘xs ++ [] ≡ xs’. Because `xs ++ []`
+-- has type `Vec A (n + 0)` while `xs` has type `Vec A n`, they cannot
+-- be directly related by homogeneous equality.
+-- To resolve the issue, `++-right-identity` uses `cast` to recast
+-- `xs ++ []` as a vector in `Vec A n`.
+--
+++-right-identity : ∀ .(eq : n + 0 ≡ n) (xs : Vec A n) → cast eq (xs ++ []) ≡ xs
+++-right-identity eq []       = refl
+++-right-identity eq (x ∷ xs) = cong (x ∷_) (++-right-identity (cong pred eq) xs)
+--
+-- When the input is `x ∷ xs`, because `cast eq (x ∷ _)` equals
+-- `x ∷ cast (cong pred eq) _`, the proof obligation
+--     cast eq (x ∷ xs ++ []) ≡ x ∷ xs
+-- simplifies to
+--     x :: cast (cong pred eq) (xs ++ []) ≡ x ∷ xs
+
+
+-- Although `cast` makes it possible to prove vector identities by ind-
+-- uction, the explicit type-casting nature poses a significant barrier
+-- to code reuse in larger proofs. For example, consider the identity
+-- ‘fromList (xs List.∷ʳ x) ≡ (fromList xs) ∷ʳ x’ where `List._∷ʳ_` is the
+-- snoc function of lists. We have
+--
+--     fromList (xs List.∷ʳ x)            : Vec A (List.length (xs List.∷ʳ x))
+--   =   {- by definition -}
+--     fromList (xs List.++ List.[ x ])   : Vec A (List.length (xs List.++ List.[ x ]))
+--   =   {- by fromList-++ -}
+--     fromList xs ++ fromList List.[ x ] : Vec A (List.length xs + List.length [ x ])
+--   =   {- by definition -}
+--     fromList xs ++ [ x ]               : Vec A (List.length xs + 1)
+--   =   {- by unfold-∷ʳ -}
+--     fromList xs ∷ʳ x                   : Vec A (suc (List.length xs))
+-- where
+--     fromList-++ : cast _ (fromList (xs List.++ ys)) ≡ fromList xs ++ fromList ys
+--     unfold-∷ʳ   : cast _ (xs ∷ʳ x) ≡ xs ++ [ x ]
+--
+-- Although the identity itself is simple, the reasoning process changes
+-- the index in the type twice. Consequently, its Agda translation must
+-- insert two `cast`s in the proof. Moreover, the proof first has to
+-- rearrange (the Agda version of) the identity into one with two
+-- `cast`s, resulting in lots of boilerplate code as demonstrated by
+-- `example1a-fromList-∷ʳ`.
+example1a-fromList-∷ʳ : ∀ (x : A) xs →
+                        .(eq : List.length (xs List.∷ʳ x) ≡ suc (List.length xs)) →
+                        cast eq (fromList (xs List.∷ʳ x)) ≡ fromList xs ∷ʳ x
+example1a-fromList-∷ʳ x xs eq = begin
+  cast eq (fromList (xs List.∷ʳ x))
+    ≡⟨⟩
+  cast eq (fromList (xs List.++ List.[ x ]))
+    ≡⟨ cast-trans eq₁ eq₂ (fromList (xs List.++ List.[ x ])) ⟨
+  cast eq₂ (cast eq₁ (fromList (xs List.++ List.[ x ])))
+    ≡⟨ cong (cast eq₂) (fromList-++ xs) ⟩
+  cast eq₂ (fromList xs ++ [ x ])
+    ≡⟨ ≈-sym (unfold-∷ʳ (sym eq₂) x (fromList xs)) ⟩
+  fromList xs ∷ʳ x
+    ∎
+  where
+  open ≡-Reasoning
+  eq₁ = List.length-++ xs {List.[ x ]}
+  eq₂ = +-comm (List.length xs) 1
+
+-- The `cast`s are irrelevant to core of the proof. At the same time,
+-- they can be inferred from the lemmas used during the reasoning steps
+-- (e.g. `fromList-++` and `unfold-∷ʳ`). To eliminate the boilerplate,
+-- this library provides a set of equational reasoning combinators for
+-- equality of the form `cast eq xs ≡ ys`.
+example1b-fromList-∷ʳ : ∀ (x : A) xs →
+                        .(eq : List.length (xs List.∷ʳ x) ≡ suc (List.length xs)) →
+                        cast eq (fromList (xs List.∷ʳ x)) ≡ fromList xs ∷ʳ x
+example1b-fromList-∷ʳ x xs eq = begin
+  fromList (xs List.∷ʳ x)
+    ≈⟨⟩
+  fromList (xs List.++ List.[ x ])
+    ≈⟨ fromList-++ xs ⟩
+  fromList xs ++ [ x ]
+    ≈⟨ unfold-∷ʳ (+-comm 1 (List.length xs)) x (fromList xs) ⟨
+  fromList xs ∷ʳ x
+    ∎
+  where open CastReasoning
+
+
+------------------------------------------------------------------------
+-- Combinators
+--
+-- Let `xs ≈[ m≡n ] ys` denote `cast m≡n xs ≡ ys`. We have reflexivity,
+-- symmetry and transitivity:
+--     ≈-reflexive : xs ≈[ refl ] xs
+--     ≈-sym       : xs ≈[ m≡n ] ys → ys ≈[ sym m≡n ] xs
+--     ≈-trans     : xs ≈[ m≡n ] ys → ys ≈[ n≡o ] zs → xs ≈[ trans m≡n n≡o ] zs
+-- Accordingly, `_≈[_]_` admits the standard set of equational reasoning
+-- combinators. Suppose `≈-eqn : xs ≈[ m≡n ] ys`,
+--     xs ≈⟨ ≈-eqn ⟩   -- `_≈⟨_⟩_` takes a `_≈[_]_` step, adjusting
+--     ys              -- the index at the same time
+--
+--     ys ≈⟨ ≈-eqn ⟨   -- `_≈⟨_⟨_` takes a symmetric `_≈[_]_` step
+--     xs
+example2a : ∀ .(eq : suc m + n ≡ m + suc n) (xs : Vec A m) a ys →
+            cast eq ((reverse xs ∷ʳ a) ++ ys) ≡ reverse xs ++ (a ∷ ys)
+example2a eq xs a ys = begin
+  (reverse xs ∷ʳ a) ++ ys ≈⟨ ∷ʳ-++ eq a (reverse xs) ⟩ -- index: suc m + n
+  reverse xs ++ (a ∷ ys)  ∎                            -- index: m + suc n
+  where open CastReasoning
+
+-- To interoperate with `_≡_`, this library provides `_≂⟨_⟩_` (\-~) for
+-- taking a `_≡_` step during equational reasoning.
+-- Let `≡-eqn : xs ≡ ys`, then
+--     xs ≂⟨ ≡-eqn  ⟩    -- Takes a `_≡_` step; no change to the index
+--     ys
+--
+--     ys ≂⟨ ≡-eqn ⟨    -- Takes a symmetric `_≡_` step
+--     xs
+-- Equivalently, `≈-reflexive` injects `_≡_` into `_≈[_]_`. That is,
+-- `xs ≂⟨ ≡-eqn ⟩ ys` is the same as `xs ≈⟨ ≈-reflexive ≡-eqn ⟩ ys`.
+-- Extending `example2a`, we have:
+example2b : ∀ .(eq : suc m + n ≡ m + suc n) (xs : Vec A m) a ys →
+            cast eq ((a ∷ xs) ʳ++ ys) ≡ xs ʳ++ (a ∷ ys)
+example2b eq xs a ys = begin
+  (a ∷ xs) ʳ++ ys         ≂⟨ unfold-ʳ++ (a ∷ xs) ys ⟩          -- index: suc m + n
+  reverse (a ∷ xs) ++ ys  ≂⟨ cong (_++ ys) (reverse-∷ a xs) ⟩  -- index: suc m + n
+  (reverse xs ∷ʳ a) ++ ys ≈⟨ ∷ʳ-++ eq a (reverse xs) ⟩         -- index: suc m + n
+  reverse xs ++ (a ∷ ys)  ≂⟨ unfold-ʳ++ xs (a ∷ ys) ⟨          -- index: m + suc n
+  xs ʳ++ (a ∷ ys)         ∎                                    -- index: m + suc n
+  where open CastReasoning
+
+-- Oftentimes index-changing identities apply to only part of the proof
+-- term. When reasoning about `_≡_`, `cong` shifts the focus to the
+-- subterm of interest. In this library, `≈-cong` does a similar job.
+-- Suppose `f : A → B`, `xs : B`, `ys zs : A`, `ys≈zs : ys ≈[ _ ] zs`
+-- and `xs≈f⟨c·ys⟩ : xs ≈[ _ ] f (cast _ ys)`, we have
+--     xs ≈⟨ ≈-cong f xs≈f⟨c·ys⟩ ys≈zs ⟩
+--     f zs
+-- The reason for having the extra argument `xs≈f⟨c·ys⟩` is to expose
+-- `cast` in the subterm in order to apply the step `ys≈zs`. When using
+-- ordinary `cong` the proof has to explicitly push `cast` inside:
+--     xs            ≈⟨ xs≈f⟨c·ys⟩ ⟩
+--     f (cast _ ys) ≂⟨ cong f ys≈zs ⟩
+--     f zs
+-- Note. Technically, `A` and `B` should be vectors of different length
+-- and that `ys`, `zs` are vectors of non-definitionally equal index.
+example3a-fromList-++-++ : {xs ys zs : List A} →
+                           .(eq : List.length (xs List.++ ys List.++ zs) ≡
+                                  List.length xs + (List.length ys + List.length zs)) →
+                           cast eq (fromList (xs List.++ ys List.++ zs)) ≡
+                                   fromList xs ++ fromList ys ++ fromList zs
+example3a-fromList-++-++ {xs = xs} {ys} {zs} eq = begin
+  fromList (xs List.++ ys List.++ zs)
+    ≈⟨ fromList-++ xs ⟩
+  fromList xs ++ fromList (ys List.++ zs)
+    ≈⟨ ≈-cong (fromList xs ++_) (cast-++ʳ (List.length-++ ys) (fromList xs)) (fromList-++ ys) ⟩
+  fromList xs ++ fromList ys ++ fromList zs
+    ∎
+  where open CastReasoning
+
+-- As an alternative, one can manually apply `cast-++ʳ` to expose `cast`
+-- in the subterm. However, this unavoidably duplicates the proof term.
+example3b-fromList-++-++′ : {xs ys zs : List A} →
+                            .(eq : List.length (xs List.++ ys List.++ zs) ≡
+                                   List.length xs + (List.length ys + List.length zs)) →
+                            cast eq (fromList (xs List.++ ys List.++ zs)) ≡
+                                    fromList xs ++ fromList ys ++ fromList zs
+example3b-fromList-++-++′ {xs = xs} {ys} {zs} eq = begin
+  fromList (xs List.++ ys List.++ zs)
+    ≈⟨ fromList-++ xs ⟩
+  fromList xs ++ fromList (ys List.++ zs)
+    ≈⟨ cast-++ʳ (List.length-++ ys) (fromList xs) ⟩
+  fromList xs ++ cast _ (fromList (ys List.++ zs))
+    ≂⟨ cong (fromList xs ++_) (fromList-++ ys) ⟩
+  fromList xs ++ fromList ys ++ fromList zs
+    ∎
+  where open CastReasoning
+
+-- `≈-cong` can be chained together much like how `cong` can be nested.
+-- In this example, `unfold-∷ʳ` is applied to the term `xs ++ [ a ]`
+-- in `(_++ ys)` inside of `reverse`. Thus the proof employs two
+-- `≈-cong`.
+example4-cong² : ∀ .(eq : (m + 1) + n ≡ n + suc m) a (xs : Vec A m) ys →
+          cast eq (reverse ((xs ++ [ a ]) ++ ys)) ≡ ys ʳ++ reverse (xs ∷ʳ a)
+example4-cong² {m = m} {n} eq a xs ys = begin
+  reverse ((xs ++ [ a ]) ++ ys)
+    ≈⟨ ≈-cong reverse (cast-reverse (cong (_+ n) (+-comm 1 m)) ((xs ∷ʳ a) ++ ys))
+                                             (≈-cong (_++ ys) (cast-++ˡ (+-comm 1 m) (xs ∷ʳ a))
+                                                     (unfold-∷ʳ _ a xs)) ⟨
+  reverse ((xs ∷ʳ a) ++ ys)
+    ≈⟨ reverse-++ (+-comm (suc m) n) (xs ∷ʳ a) ys ⟩
+  reverse ys ++ reverse (xs ∷ʳ a)
+    ≂⟨ unfold-ʳ++ ys (reverse (xs ∷ʳ a)) ⟨
+  ys ʳ++ reverse (xs ∷ʳ a)
+    ∎
+  where open CastReasoning
+
+------------------------------------------------------------------------
+-- Interoperation between `_≈[_]_` and `_≡_`
+--
+-- This library is designed to interoperate with `_≡_`. Examples in the
+-- combinators section showed how to apply `_≂⟨_⟩_` to take an `_≡_`
+-- step during equational reasoning about `_≈[_]_`. Recall that
+-- `xs ≈[ m≡n ] ys` is a shorthand for `cast m≡n xs ≡ ys`, the
+-- combinator is essentially the composition of `_≡_` on the left-hand
+-- side of `_≈[_]_`. Dually, the combinator `_≃⟨_⟩_` composes `_≡_` on
+-- the right-hand side of `_≈[_]_`. Thus `_≃⟨_⟩_` intuitively ends the
+-- reasoning system of `_≈[_]_` and switches back to the reasoning
+-- system of `_≡_`.
+example5-fromList-++-++′ : {xs ys zs : List A} →
+                           .(eq : List.length (xs List.++ ys List.++ zs) ≡
+                                  List.length xs + (List.length ys + List.length zs)) →
+                           cast eq (fromList (xs List.++ ys List.++ zs)) ≡
+                                   fromList xs ++ fromList ys ++ fromList zs
+example5-fromList-++-++′ {xs = xs} {ys} {zs} eq = begin
+  fromList (xs List.++ ys List.++ zs)
+    ≈⟨ fromList-++ xs ⟩
+  fromList xs ++ fromList (ys List.++ zs)
+    ≃⟨ cast-++ʳ (List.length-++ ys) (fromList xs) ⟩
+  fromList xs ++ cast _ (fromList (ys List.++ zs))
+    ≡⟨ cong (fromList xs ++_) (fromList-++ ys) ⟩
+  fromList xs ++ fromList ys ++ fromList zs
+    ≡-∎
+  where open CastReasoning
+
+-- Of course, it is possible to start with the reasoning system of `_≡_`
+-- and then switch to the reasoning system of `_≈[_]_`.
+example6a-reverse-∷ʳ : ∀ x (xs : Vec A n) → reverse (xs ∷ʳ x) ≡ x ∷ reverse xs
+example6a-reverse-∷ʳ {n = n} x xs = begin-≡
+  reverse (xs ∷ʳ x)
+    ≡⟨ ≈-reflexive refl ⟨
+  reverse (xs ∷ʳ x)
+    ≈⟨ ≈-cong reverse (cast-reverse _ _) (unfold-∷ʳ (+-comm 1 n) x xs) ⟩
+  reverse (xs ++ [ x ])
+    ≈⟨ reverse-++ (+-comm n 1) xs [ x ] ⟩
+  x ∷ reverse xs
+    ∎
+  where open CastReasoning
+
+example6b-reverse-∷ʳ-by-induction : ∀ x (xs : Vec A n) → reverse (xs ∷ʳ x) ≡ x ∷ reverse xs
+example6b-reverse-∷ʳ-by-induction x []       = refl
+example6b-reverse-∷ʳ-by-induction x (y ∷ xs) = begin
+  reverse (y ∷ (xs ∷ʳ x)) ≡⟨ reverse-∷ y (xs ∷ʳ x) ⟩
+  reverse (xs ∷ʳ x) ∷ʳ y  ≡⟨ cong (_∷ʳ y) (example6b-reverse-∷ʳ-by-induction x xs) ⟩
+  (x ∷ reverse xs) ∷ʳ y   ≡⟨⟩
+  x ∷ (reverse xs ∷ʳ y)   ≡⟨ cong (x ∷_) (reverse-∷ y xs) ⟨
+  x ∷ reverse (y ∷ xs)    ∎
+  where open ≡-Reasoning
diff --git a/README/Data/Wrap.agda b/doc/README/Data/Wrap.agda
similarity index 99%
rename from README/Data/Wrap.agda
rename to doc/README/Data/Wrap.agda
index 35009e4ed4..7273e787d1 100644
--- a/README/Data/Wrap.agda
+++ b/doc/README/Data/Wrap.agda
@@ -13,9 +13,8 @@ open import Data.Wrap
 open import Algebra
 open import Data.Nat
 open import Data.Nat.Properties
-open import Data.Product
+open import Data.Product.Base using (_,_; ∃; ∃₂; _×_)
 open import Level using (Level)
-open import Relation.Binary
 
 private
   variable
diff --git a/README/Debug/Trace.agda b/doc/README/Debug/Trace.agda
similarity index 100%
rename from README/Debug/Trace.agda
rename to doc/README/Debug/Trace.agda
diff --git a/README/Design/Decidability.agda b/doc/README/Design/Decidability.agda
similarity index 97%
rename from README/Design/Decidability.agda
rename to doc/README/Design/Decidability.agda
index e615af282e..c6f086424f 100644
--- a/README/Design/Decidability.agda
+++ b/doc/README/Design/Decidability.agda
@@ -9,13 +9,13 @@
 module README.Design.Decidability where
 
 open import Data.Bool
-open import Data.List
+open import Data.List.Base using (List; []; _∷_)
 open import Data.List.Properties using (∷-injective)
 open import Data.Nat
 open import Data.Nat.Properties using (suc-injective)
-open import Data.Product
+open import Data.Product.Base using (uncurry)
 open import Data.Unit
-open import Function
+open import Function.Base using (id;  _∘_)
 open import Relation.Binary.PropositionalEquality
 open import Relation.Nary
 
diff --git a/README/Design/Fixity.agda b/doc/README/Design/Fixity.agda
similarity index 89%
rename from README/Design/Fixity.agda
rename to doc/README/Design/Fixity.agda
index 87907e49b6..52394ff864 100644
--- a/README/Design/Fixity.agda
+++ b/doc/README/Design/Fixity.agda
@@ -23,6 +23,8 @@ module README.Design.Fixity where
 -- ternary reasoning infix 1 _⊢_≈_
 -- composition infixr 9 _∘_
 -- application infixr -1 _$_ _$!_
+-- combinatorics infixl 6.5 _P_ _P′_ _C_ _C′_
+-- pair infixr 4 _,_
 
 -- Reasoning:
 -- QED  infix  3 _∎
@@ -32,3 +34,4 @@ module README.Design.Fixity where
 -- type formers:
 -- product-like infixr 2 _×_ _-×-_ _-,-_
 -- sum-like infixr 1 _⊎_
+-- binary properties infix 4 _Absorbs_
diff --git a/README/Design/Hierarchies.agda b/doc/README/Design/Hierarchies.agda
similarity index 89%
rename from README/Design/Hierarchies.agda
rename to doc/README/Design/Hierarchies.agda
index 0a91586086..71ca5eed44 100644
--- a/README/Design/Hierarchies.agda
+++ b/doc/README/Design/Hierarchies.agda
@@ -8,9 +8,9 @@
 
 module README.Design.Hierarchies where
 
-open import Data.Sum using (_⊎_)
+open import Data.Sum.Base using (_⊎_)
 open import Level using (Level; _⊔_; suc)
-open import Relation.Binary using (_Preserves₂_⟶_⟶_)
+open import Relation.Binary.Core using (_Preserves₂_⟶_⟶_)
 
 private
   variable
@@ -249,6 +249,43 @@ record Semigroup : Set (suc (a ⊔ ℓ)) where
 -- differently, as a function with an unknown domain an codomain is
 -- of little use.
 
+-------------------------
+-- Bundle re-exporting --
+-------------------------
+
+-- In general ensuring that bundles re-export everything in their
+-- sub-bundles can get a little tricky.
+
+-- Imagine we have the following general scenario where bundle A is a
+-- direct refinement of bundle C (i.e. the record `IsA` has a `IsC` field)
+-- but is also morally a refinement of bundles B and D.
+
+--   Structures               Bundles
+--   ==========               =======
+--       IsA                     A
+--    /  ||   \               /  ||  \
+-- IsB   IsC   IsD          B    C    D
+
+-- The procedure for re-exports in the bundles is as follows:
+
+-- 1. `open IsA isA public using (IsC, M)` where `M` is everything
+--    exported by `IsA` that is not exported by `IsC`.
+
+-- 2. Construct `c : C` via the `isC` obtained in step 1.
+
+-- 3. `open C c public hiding (N)` where `N` is the list of fields
+--    shared by both `A` and `C`.
+
+-- 4. Construct `b : B` via the `isB` obtained in step 1.
+
+-- 5. `open B b public using (O)` where `O` is everything exported
+--    by `B` but not exported by `IsA`.
+
+-- 6. Construct `d : D` via the `isC` obtained in step 1.
+
+-- 7. `open D d public using (P)` where `P` is everything exported
+--    by `D` but not exported by `IsA`
+
 ------------------------------------------------------------------------
 -- Other hierarchy modules
 ------------------------------------------------------------------------
diff --git a/doc/README/Design/LevelPolymorphism.md b/doc/README/Design/LevelPolymorphism.md
new file mode 100644
index 0000000000..59436fe4a3
--- /dev/null
+++ b/doc/README/Design/LevelPolymorphism.md
@@ -0,0 +1,15 @@
+* Level polymorphism
+
+`⊥` in `Data.Empty` and `⊤` in `Data.Unit` are not `Level`-polymorphic as that
+tends to lead to unsolved metas (see discussion at issue #312).  This is understandable
+as very often the level of (say) `⊤` is under-determined by its surrounding context,
+leading to unsolved metas. This is frequent enough that it makes sense for the default
+versions to be monomorphic (at Level 0).
+
+But there are other cases where exactly the opposite is needed.  for that purpose,
+there are level-polymorphic versions in `Data.Empty.Polymorphic` and
+`Data.Unit.Polymorphic` respectively.
+
+The same issue happens in `Relation.Unary` which defines `Ø` and `U` at `Level` 0, else
+a lot of unsolved metas appear (for example in `Relation.Unary.Properties`). For that
+purpose, `Relation.Unary.Polymorphic` exists.
diff --git a/doc/README/Effect/Monad/Partiality.agda b/doc/README/Effect/Monad/Partiality.agda
new file mode 100644
index 0000000000..7b96749cd5
--- /dev/null
+++ b/doc/README/Effect/Monad/Partiality.agda
@@ -0,0 +1,27 @@
+-----------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Example showing the use of the partiality Monad
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe --guardedness #-}
+
+module README.Effect.Monad.Partiality where
+
+open import Codata.Musical.Notation using (♯_)
+open import Data.Bool.Base using (false; true)
+open import Data.Nat using (ℕ; _+_; _∸_; _≤?_)
+open import Effect.Monad.Partiality
+open import Relation.Nullary.Decidable using (does)
+
+open Workaround
+
+-- McCarthy's f91:
+
+f91′ : ℕ → ℕ ⊥P
+f91′ n with does (n ≤? 100)
+... | true  = later (♯ (f91′ (11 + n) >>= f91′))
+... | false = now (n ∸ 10)
+
+f91 : ℕ → ℕ ⊥
+f91 n = ⟦ f91′ n ⟧P
diff --git a/README/Foreign/Haskell.agda b/doc/README/Foreign/Haskell.agda
similarity index 98%
rename from README/Foreign/Haskell.agda
rename to doc/README/Foreign/Haskell.agda
index 61e757ea8f..38c6c78c4e 100644
--- a/README/Foreign/Haskell.agda
+++ b/doc/README/Foreign/Haskell.agda
@@ -22,7 +22,7 @@ open import Data.Bool.Base using (Bool; if_then_else_)
 open import Data.Char as Char
 open import Data.List.Base as List using (List; _∷_; []; takeWhile; dropWhile)
 open import Data.Maybe.Base using (Maybe; just; nothing)
-open import Data.Product
+open import Data.Product.Base using (_×_; _,_)
 open import Function
 open import Relation.Nullary.Decidable
 
diff --git a/README/Function/Reasoning.agda b/doc/README/Function/Reasoning.agda
similarity index 83%
rename from README/Function/Reasoning.agda
rename to doc/README/Function/Reasoning.agda
index 0c9afa4532..810f048aa3 100644
--- a/README/Function/Reasoning.agda
+++ b/doc/README/Function/Reasoning.agda
@@ -1,9 +1,9 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Some examples showing how the Function.Reasoning module
--- can be used to perform "functional reasoning" similar to what is being
--- described in: https://stackoverflow.com/q/22676703/3168666
+-- Some examples showing how the Function.Reasoning module can be used
+-- to perform "functional reasoning" similar to what is being described
+-- in: https://stackoverflow.com/q/22676703/3168666
 ------------------------------------------------------------------------
 
 {-# OPTIONS --with-K #-}
@@ -35,10 +35,11 @@ module _ {A B C : Set} {A→B : A → B} {B→C : B → C} where
 open import Data.Nat
 open import Data.List.Base
 open import Data.Char.Base
-open import Data.String as String using (String; toList; fromList; _==_)
-open import Function
+open import Data.String.Base as String using (String; toList; fromList)
+open import Data.String.Properties as String using (_==_)
+open import Function.Base using (_∘_)
 open import Data.Bool hiding (_≤?_)
-open import Data.Product as P using (_×_; <_,_>; uncurry; proj₁)
+open import Data.Product.Base using (_×_; <_,_>; uncurry; proj₁)
 open import Agda.Builtin.Equality
 
 -- This can give us for instance this decomposition of a function
diff --git a/README/IO.agda b/doc/README/IO.agda
similarity index 87%
rename from README/IO.agda
rename to doc/README/IO.agda
index 880ad1fa32..bf913bbfdd 100644
--- a/README/IO.agda
+++ b/doc/README/IO.agda
@@ -11,8 +11,9 @@ module README.IO where
 open import Level
 open import Data.Nat.Base
 open import Data.Nat.Show using (show)
-open import Data.String using (String; _++_; lines)
+open import Data.String.Base using (String; _++_; lines)
 open import Data.Unit.Polymorphic
+open import Function.Base using (_$_)
 open import IO
 
 ------------------------------------------------------------------------
@@ -86,10 +87,21 @@ cat fp = do
   let ls = lines content
   List.mapM′ putStrLn ls
 
-open import Codata.Musical.Notation
-open import Codata.Musical.Colist
-open import Data.Bool
-open import Data.Unit.Polymorphic.Base
+------------------------------------------------------------------------
+-- TOP-LEVEL LOOP
+
+-- If you simply want to repeat the same action over and over again, you
+-- can use `forever` e.g. the following defines a REPL that echos whatever
+-- the user types
+
+echo : IO ⊤
+echo = do
+  hSetBuffering stdout noBuffering
+  forever $ do
+    putStr "echo< "
+    str ← getLine
+    putStrLn ("echo> " ++ str)
+
 
 ------------------------------------------------------------------------
 -- GUARDEDNESS
@@ -101,6 +113,10 @@ open import Data.Unit.Polymorphic.Base
 -- In this case you cannot use the convenient combinators that make `do`-notations
 -- and have to revert back to the underlying coinductive constructors.
 
+open import Codata.Musical.Notation
+open import Codata.Musical.Colist using (Colist; []; _∷_)
+open import Data.Bool
+open import Data.Unit.Polymorphic.Base
 
 -- Whether a colist is finite is semi decidable: just let the user wait until
 -- you reach the end!
diff --git a/README/Inspect.agda b/doc/README/Inspect.agda
similarity index 96%
rename from README/Inspect.agda
rename to doc/README/Inspect.agda
index e10877c44c..2199a499c8 100644
--- a/README/Inspect.agda
+++ b/doc/README/Inspect.agda
@@ -11,8 +11,9 @@ module README.Inspect where
 
 open import Data.Nat.Base
 open import Data.Nat.Properties
-open import Data.Product
-open import Relation.Binary.PropositionalEquality
+open import Data.Product.Base using (_×_; _,_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality using (inspect; [_])
 
 ------------------------------------------------------------------------
 -- Using inspect
diff --git a/README/Nary.agda b/doc/README/Nary.agda
similarity index 98%
rename from README/Nary.agda
rename to doc/README/Nary.agda
index 826d7b74e6..b8b337832a 100644
--- a/README/Nary.agda
+++ b/doc/README/Nary.agda
@@ -15,11 +15,11 @@ open import Data.Nat.Properties
 open import Data.Fin using (Fin; fromℕ; #_; inject₁)
 open import Data.List
 open import Data.List.Properties
-open import Data.Product using (_×_; _,_)
-open import Data.Sum using (inj₁; inj₂)
-open import Function
+open import Data.Product.Base using (_×_; _,_)
+open import Data.Sum.Base using (inj₁; inj₂)
+open import Function.Base using (id; flip; _∘′_)
 open import Relation.Nullary
-open import Relation.Binary using (module Tri); open Tri
+open import Relation.Binary.Definitions using (module Tri); open Tri
 open import Relation.Binary.PropositionalEquality
 
 private
diff --git a/README/Reflection/External.agda b/doc/README/Reflection/External.agda
similarity index 100%
rename from README/Reflection/External.agda
rename to doc/README/Reflection/External.agda
diff --git a/README/Relation/Binary/TypeClasses.agda b/doc/README/Relation/Binary/TypeClasses.agda
similarity index 97%
rename from README/Relation/Binary/TypeClasses.agda
rename to doc/README/Relation/Binary/TypeClasses.agda
index 023e98c3e4..a836389ee4 100644
--- a/README/Relation/Binary/TypeClasses.agda
+++ b/doc/README/Relation/Binary/TypeClasses.agda
@@ -19,7 +19,7 @@ open import Data.List.Instances
 open import Data.List.Relation.Binary.Lex.NonStrict using (Lex-≤)
 open import Data.Nat.Base renaming (_≤_ to _≤ℕ_)
 open import Data.Nat.Instances
-open import Data.Product
+open import Data.Product.Base using (_×_; _,_; Σ)
 open import Data.Product.Instances
 open import Data.Unit.Base renaming (_≤_ to _≤⊤_)
 open import Data.Unit.Instances
diff --git a/README/Tactic/Cong.agda b/doc/README/Tactic/Cong.agda
similarity index 64%
rename from README/Tactic/Cong.agda
rename to doc/README/Tactic/Cong.agda
index 6503604d71..01365aee96 100644
--- a/README/Tactic/Cong.agda
+++ b/doc/README/Tactic/Cong.agda
@@ -3,12 +3,13 @@
 module README.Tactic.Cong where
 
 open import Data.Nat
+open import Data.Nat.DivMod
 open import Data.Nat.Properties
 
-open import Relation.Binary.PropositionalEquality as Eq
-import Relation.Binary.Reasoning.Preorder as PR
+open import Relation.Binary.PropositionalEquality
+  using (_≡_; refl; sym; cong; module ≡-Reasoning)
 
-open import Tactic.Cong using (cong!)
+open import Tactic.Cong using (cong! ; ⌞_⌟)
 
 ----------------------------------------------------------------------
 -- Usage
@@ -26,14 +27,14 @@ open import Tactic.Cong using (cong!)
 
 verbose-example : ∀ m n → m ≡ n → suc (suc (m + 0)) + m ≡ suc (suc n) + (n + 0)
 verbose-example m n eq =
-  let open Eq.≡-Reasoning in
+  let open ≡-Reasoning in
   begin
     suc (suc (m + 0)) + m
   ≡⟨ cong (λ ϕ → suc (suc (ϕ + m))) (+-identityʳ m) ⟩
     suc (suc m) + m
   ≡⟨ cong (λ ϕ → suc (suc (ϕ + ϕ))) eq ⟩
     suc (suc n) + n
-  ≡˘⟨ cong (λ ϕ → suc (suc (n + ϕ))) (+-identityʳ n) ⟩
+  ≡⟨ cong (λ ϕ → suc (suc (n + ϕ))) (+-identityʳ n) ⟨
     suc (suc n) + (n + 0)
   ∎
 
@@ -44,19 +45,19 @@ verbose-example m n eq =
 
 succinct-example : ∀ m n → m ≡ n → suc (suc (m + 0)) + m ≡ suc (suc n) + (n + 0)
 succinct-example m n eq =
-  let open Eq.≡-Reasoning in
+  let open ≡-Reasoning in
   begin
     suc (suc (m + 0)) + m
   ≡⟨ cong! (+-identityʳ m) ⟩
     suc (suc m) + m
   ≡⟨ cong! eq ⟩
     suc (suc n) + n
-  ≡˘⟨ cong! (+-identityʳ n) ⟩
+  ≡⟨ cong! (+-identityʳ n) ⟨
     suc (suc n) + (n + 0)
   ∎
 
 ----------------------------------------------------------------------
--- Limitations
+-- Explicit markings
 ----------------------------------------------------------------------
 
 -- The 'cong!' tactic can handle simple cases, but will
@@ -68,6 +69,29 @@ succinct-example m n eq =
 -- to deduce where to generalize. When presented with two sides
 -- of an equality like 'm + n ≡ n + m', it will anti-unify to
 -- 'ϕ + ϕ', which is too specific.
+--
+-- In cases like these, you may explicitly mark the subterms to
+-- be generalized by wrapping them in the marker function, ⌞_⌟.
+
+marker-example₁ : ∀ m n o p → m + n + (o + p) ≡ n + m + (p + o)
+marker-example₁ m n o p =
+  let open ≡-Reasoning in
+  begin
+    ⌞ m + n ⌟ + (o + p)
+  ≡⟨ cong! (+-comm m n) ⟩
+    n + m + ⌞ o + p ⌟
+  ≡⟨ cong! (+-comm p o) ⟨
+    n + m + (p + o)
+  ∎
+
+marker-example₂ : ∀ m n → m + n + (m + n) ≡ n + m + (n + m)
+marker-example₂ m n =
+  let open ≤-Reasoning in
+  begin-equality
+    ⌞ m + n ⌟ + ⌞ m + n ⌟
+  ≡⟨ cong! (+-comm m n) ⟩
+    n + m + (n + m)
+  ∎
 
 ----------------------------------------------------------------------
 -- Unit Tests
@@ -117,24 +141,56 @@ module EquationalReasoningTests where
 
   test₁ : ∀ m n → m ≡ n → suc (suc (m + 0)) + m ≡ suc (suc n) + (n + 0)
   test₁ m n eq =
-    let open Eq.≡-Reasoning in
+    let open ≡-Reasoning in
     begin
       suc (suc (m + 0)) + m
     ≡⟨ cong! (+-identityʳ m) ⟩
       suc (suc m) + m
     ≡⟨ cong! eq ⟩
       suc (suc n) + n
-    ≡˘⟨ cong! (+-identityʳ n) ⟩
+    ≡⟨ cong! (+-identityʳ n) ⟨
       suc (suc n) + (n + 0)
     ∎
 
   test₂ : ∀ m n → m ≡ n → suc (m + m) ≤ suc (suc (n + n))
   test₂ m n eq =
-    let open PR ≤-preorder in
+    let open ≤-Reasoning in
     begin
       suc (m + m)
     ≡⟨ cong! eq ⟩
       suc (n + n)
-    ∼⟨ ≤-step ≤-refl ⟩
+    ≤⟨ n≤1+n _ ⟩
       suc (suc (n + n))
     ∎
+
+module MetaTests where
+
+  test₁ : ∀ m n o → .⦃ _ : NonZero o ⦄ → (m + n) / o ≡ (n + m) / o
+  test₁ m n o =
+    let open ≤-Reasoning in
+    begin-equality
+      ⌞ m + n ⌟ / o
+     ≡⟨ cong! (+-comm m n) ⟩
+      (n + m) / o
+    ∎
+
+  test₂ : ∀ m n o p q r → .⦃ _ : NonZero o ⦄ → .⦃ _ : NonZero p ⦄ →
+          .⦃ _ : NonZero q ⦄ → p ≡ q ^ r → (m + n) % o % p ≡ (n + m) % o % p
+  test₂ m n o p q r eq =
+    let
+      open ≤-Reasoning
+      instance q^r≢0 = m^n≢0 q r
+    in
+    begin-equality
+      (m + n) % o % p
+     ≡⟨ %-congʳ eq ⟩
+      ⌞ m + n ⌟ % o % q ^ r
+     ≡⟨ cong! (+-comm m n) ⟩
+      ⌞ n + m ⌟ % o % q ^ r
+     ≡⟨ cong! (+-comm m n) ⟨
+      ⌞ m + n ⌟ % o % q ^ r
+     ≡⟨ cong! (+-comm m n) ⟩
+      (n + m) % o % q ^ r
+     ≡⟨ %-congʳ eq ⟨
+      (n + m) % o % p
+    ∎
diff --git a/README/Tactic/MonoidSolver.agda b/doc/README/Tactic/MonoidSolver.agda
similarity index 83%
rename from README/Tactic/MonoidSolver.agda
rename to doc/README/Tactic/MonoidSolver.agda
index 530091bc97..4631d67089 100644
--- a/README/Tactic/MonoidSolver.agda
+++ b/doc/README/Tactic/MonoidSolver.agda
@@ -10,11 +10,9 @@ module README.Tactic.MonoidSolver {a ℓ} (M : Monoid a ℓ) where
 
 open Monoid M
 
-open import Data.Nat as Nat using (ℕ; suc; zero; _+_)
-open import Data.Nat.Properties as Properties using (+-0-monoid; +-comm)
 open import Relation.Binary.Reasoning.Setoid setoid
 
-open import Tactic.MonoidSolver using (solve; solve-macro)
+open import Tactic.MonoidSolver using (solve)
 
 -- The monoid solver is capable to of solving equations without having
 -- to specify the equation itself in the proof.
diff --git a/README/Tactic/RingSolver.agda b/doc/README/Tactic/RingSolver.agda
similarity index 98%
rename from README/Tactic/RingSolver.agda
rename to doc/README/Tactic/RingSolver.agda
index cc1db1ad21..8071bee39c 100644
--- a/README/Tactic/RingSolver.agda
+++ b/doc/README/Tactic/RingSolver.agda
@@ -28,8 +28,7 @@ instance
 ------------------------------------------------------------------------------
 -- Imports!
 
-open import Data.List as List using (List; _∷_; [])
-open import Function
+open import Data.List.Base as List using (List; _∷_; [])
 open import Relation.Binary.PropositionalEquality
   using (subst; cong; _≡_; module ≡-Reasoning)
 open import Data.Bool as Bool using (Bool; true; false; if_then_else_)
diff --git a/README/Text/Pretty.agda b/doc/README/Text/Pretty.agda
similarity index 99%
rename from README/Text/Pretty.agda
rename to doc/README/Text/Pretty.agda
index 2525ff5242..855c599f08 100644
--- a/README/Text/Pretty.agda
+++ b/doc/README/Text/Pretty.agda
@@ -14,7 +14,7 @@ open import Data.Bool.Base
 open import Data.List.Base as List
 open import Data.List.NonEmpty as List⁺
 open import Data.Nat.Base
-open import Data.Product
+open import Data.Product.Base using (_×_; uncurry; _,_)
 open import Data.String.Base hiding (parens; _<+>_)
 open import Data.Vec.Base as Vec
 open import Function.Base
diff --git a/README/Text/Printf.agda b/doc/README/Text/Printf.agda
similarity index 100%
rename from README/Text/Printf.agda
rename to doc/README/Text/Printf.agda
diff --git a/README/Text/Regex.agda b/doc/README/Text/Regex.agda
similarity index 99%
rename from README/Text/Regex.agda
rename to doc/README/Text/Regex.agda
index 5b4ce805c0..17d3fe45f9 100644
--- a/README/Text/Regex.agda
+++ b/doc/README/Text/Regex.agda
@@ -9,7 +9,7 @@
 module README.Text.Regex where
 
 open import Data.Bool using (true; false)
-open import Data.List using (_∷_; [])
+open import Data.List.Base using (_∷_; [])
 open import Data.String
 open import Function.Base using () renaming (_$′_ to _$_)
 open import Relation.Nullary.Decidable using (yes)
diff --git a/README/Text/Tabular.agda b/doc/README/Text/Tabular.agda
similarity index 100%
rename from README/Text/Tabular.agda
rename to doc/README/Text/Tabular.agda
diff --git a/notes/installation-guide.md b/doc/installation-guide.md
similarity index 84%
rename from notes/installation-guide.md
rename to doc/installation-guide.md
index f7f351b484..956fc317db 100644
--- a/notes/installation-guide.md
+++ b/doc/installation-guide.md
@@ -3,19 +3,19 @@ Installation instructions
 
 Note: the full story on installing Agda libraries can be found at [readthedocs](http://agda.readthedocs.io/en/latest/tools/package-system.html).
 
-Use version v1.7.1 of the standard library with Agda 2.6.2.2, 2.6.2.1, or 2.6.2.
+Use version v2.0 of the standard library with Agda 2.6.4 or 2.6.4.1.
 
 1. Navigate to a suitable directory `$HERE` (replace appropriately) where
    you would like to install the library.
 
-2. Download the tarball of v1.7.1 of the standard library. This can either be
+2. Download the tarball of v2.0 of the standard library. This can either be
    done manually by visiting the Github repository for the library, or via the
    command line as follows:
    ```
-   wget -O agda-stdlib.tar https://github.com/agda/agda-stdlib/archive/v1.7.1.tar.gz
+   wget -O agda-stdlib.tar https://github.com/agda/agda-stdlib/archive/v2.0.tar.gz
    ```
    Note that you can replace `wget` with other popular tools such as `curl` and that
-   you can replace `1.7.1` with any other version of the library you desire.
+   you can replace `2.0` with any other version of the library you desire.
 
 3. Extract the standard library from the tarball. Again this can either be
    done manually or via the command line as follows:
@@ -26,7 +26,7 @@ Use version v1.7.1 of the standard library with Agda 2.6.2.2, 2.6.2.1, or 2.6.2.
 4. [ OPTIONAL ] If using [cabal](https://www.haskell.org/cabal/) then run
    the commands to install via cabal:
    ```
-   cd agda-stdlib-1.7.1
+   cd agda-stdlib-2.0
    cabal install
    ```
 
@@ -40,7 +40,7 @@ Use version v1.7.1 of the standard library with Agda 2.6.2.2, 2.6.2.1, or 2.6.2.
 6. Register the standard library with Agda's package system by adding
    the following line to `$HOME/.agda/libraries`:
    ```
-   $HERE/agda-stdlib-1.7.1/standard-library.agda-lib
+   $HERE/agda-stdlib-2.0/standard-library.agda-lib
    ```
 
 Now, the standard library is ready to be used either:
diff --git a/notes/release-guide.txt b/doc/release-guide.txt
similarity index 69%
rename from notes/release-guide.txt
rename to doc/release-guide.txt
index 56fb2458cc..77a5e77ba5 100644
--- a/notes/release-guide.txt
+++ b/doc/release-guide.txt
@@ -3,17 +3,15 @@ procedure should be followed:
 
 #### Pre-release changes
 
-* Update `README.agda` by replacing 'development version' by 'version X.Y' in the title.
+* Update `doc/README.agda` by replacing 'development version' by 'version X.Y' in the title.
 
-* Update `README.md`
-
-* Update `agda-stdlib-utils.cabal` version to `X.Y`.
-
-* Update the version in standard-library.agda-lib to `X.Y`
-
-* Update `notes/installation-guide.txt`
-
-* Update `CHANGELOG.md`.
+* Update the version to `X.Y` in:
+  - `agda-stdlib-utils.cabal`
+  - `standard-library.agda-lib`
+  - `CITATION.cff`
+  - `CHANGELOG.md`
+  - `README.md`
+  - `doc/installation-guide.md`
 
 * Update the copyright year range in the LICENSE file, if necessary.
 
@@ -63,20 +61,12 @@ procedure should be followed:
 * Announce the release of the new version on the Agda mailing lists
   (users and developers).
 
-* Add v$VERSION to the list of protected directories in the .travis.yml
-  file of BOTH master and experimental. They should look something like:
-
-  >  git checkout HEAD -- v0.16/ v0.17/ v1.0/ v1.1/ (...)
-
-  Commit & push these changes. This will prevent the next step from being
-  overwritten by travis.
-
 * Generate and upload documentation for the released version:
 
-    cp travis/* .
-    runhaskell GenerateEverything.hs
+    cp .github/tooling/* .
+    cabal run GenerateEverything.hs
     ./index.sh
-    agda -i. -isrc --html index.agda
+    agda -i. -idoc -isrc --html index.agda
     mv html v$VERSION
     git checkout gh-pages
     git add v$VERSION/*.html v$VERSION/*.css
@@ -92,4 +82,4 @@ procedure should be followed:
 
 * Create new CHANGELOG.md file
 
-* Revert changes in README.md to reference development version
+* Update `standard-library.agda-lib` to the new version/milestone on `master`
diff --git a/doc/standard-library-doc.agda-lib b/doc/standard-library-doc.agda-lib
new file mode 100644
index 0000000000..02aaaba402
--- /dev/null
+++ b/doc/standard-library-doc.agda-lib
@@ -0,0 +1,4 @@
+name: standard-library-doc
+include: . ../src
+flags:
+  --warning=noUnsupportedIndexedMatch
diff --git a/notes/style-guide.md b/doc/style-guide.md
similarity index 64%
rename from notes/style-guide.md
rename to doc/style-guide.md
index 2f9fa18553..1a8b883f3a 100644
--- a/notes/style-guide.md
+++ b/doc/style-guide.md
@@ -121,8 +121,9 @@ automate most of this.
 
 * If it is important that certain names only come into scope later in
   the file then the module should still be imported at the top of the
-  file but it can be given a shorter name using the keyword `as` and then
-  opened later on in the file when needed, e.g.
+  file but it can be imported *qualified*, i.e. given a shorter name
+  using the keyword `as` and then opened later on in the file when needed,
+  e.g.
   ```agda
   import Data.List.Relation.Binary.Equality.Setoid as SetoidEquality
   ...
@@ -130,6 +131,39 @@ automate most of this.
   open SetoidEquality S
   ```
 
+* If importing a parametrised module, qualified or otherwise, with its
+  parameters instantiated, then such 'instantiated imports' should be placed
+  *after* the main block of `import`s, and *before* any `variable` declarations.
+
+* Naming conventions for qualified `import`s: if importing a module under
+  a root of the form `Data.X` (e.g. the `Base` module for basic operations,
+  or `Properties` for lemmas about them etc.) then conventionally, the
+  qualified name(s) for the import(s) should (all) share as qualified name
+  that of the name of the `X` datatype defined: i.e. `Data.Nat.Base`
+  should be imported as `ℕ`, `Data.List.Properties` as `List`,  etc.
+  In this spirit, the convention applies also to (the datatype defined by)
+  `Relation.Binary.PropositionalEquality.*` which should be imported qualified
+  with the name `≡`.
+  Other modules should be given a 'suitable' qualified name based on its 'long'
+  path-derived name (such as `SetoidEquality` in the example above); commonly
+  occurring examples such as `Algebra.Structures` should be imported qualified
+  as `Structures` etc.
+  NB. Historical legacy means that these conventions have not always been observed!
+
+* Special case of the above for `*-Reasoning` (sub-)modules: by analogy with
+  `Relation.Binary.PropositionalEquality.≡-Reasoning`, when importing qualified
+  the `-Reasoning` (sub-)module associated with a given (canonical) choice of
+  symbol (eg. `≲` for `Preorder` reasoning), use the qualified name
+  `<symbol>-Reasoning`, ie. `≲-Reasoning` for the example given.
+
+* Qualified `open import`s should, in general, avoid `renaming`
+  identifiers, in favour of using the long(er) qualified name,
+  although similar remarks about legacy failure to observe this
+  recommendation apply!
+  NB. `renaming` directives are, of course, permitted when a module is
+  imported qualified, in order to be *subsequently* `open`ed for
+  `public` export (see below).
+
 * When using only a few items (i.e. < 5) from a module, it is a good practice to
   enumerate the items that will be used by declaring the import statement
   with the directive `using`. This makes the dependencies clearer, e.g.
@@ -195,6 +229,34 @@ automate most of this.
     }
   ```
 
+#### Layout of initial `private` block
+
+* Since the introduction of generalizable `variable`s (see below),
+  this block provides a very useful way to 'fix'/standardise notation
+  for the rest of the module, as well as introducing local
+  instantiations of parameterised `module` definitions, again for the
+  sake of fixing notation via qualified names.
+
+* It should typically follow the `import` and `open` declarations, as
+  above, separated by one blankline, and be followed by *two* blank
+  lines ahead of the main module body.
+
+* The current preferred layout is to use successive indentation by two spaces, eg.
+  ```agda
+  private
+    variable
+      a : Level
+      A : Set a
+  ```
+  rather than to use the more permissive 'stacked' style, available
+  since [agda/agda#5319](https://github.com/agda/agda/pull/5319).
+
+* A possible exception to the above rule is when a *single* declaration
+  is made, such as eg.
+  ```agda
+  private open module M = ...
+  ```
+
 #### Layout of `where` blocks
 
 * `where` blocks are preferred rather than the `let` construction.
@@ -333,6 +395,16 @@ line of code, indented by two spaces.
   ...                  | false = filter p xs
   ```
 
+* Instance arguments, and their types, should use the vanilla ASCII/UTF-8 `{{_}}`
+  syntax in preference to the Unicode `⦃_⦄` syntax (written using `\{{`/`\}}`),
+  which moreover requires additional whitespace to parse correctly.
+  NB. Even for irrelevant instances, such as typically for `NonZero` arguments,
+  neverthelesss it is necessary to supply an underscore binding `{{_ : NonZero n}}`
+  if subsequent terms occurring in the type rely on that argument to be well-formed:
+  eg in `Data.Nat.DivMod`, in the use of `_/ n` and `_% n`
+  ```agda
+  m≡m%n+[m/n]*n : ∀ m n .{{_ : NonZero n}} → m ≡ m % n + (m / n) * n
+  ```
 
 ## Types
 
@@ -347,12 +419,12 @@ line of code, indented by two spaces.
 
 #### Variables
 
-* `Level` and `Set`s can always be generalized using the keyword `variable`.
+* `Level` and `Set`s can always be generalised using the keyword `variable`.
 
 * A file may only declare variables of other types if those types are used
   in the definition of the main type that the file concerns itself with.
-  At the moment the policy is *not* to generalize over any other types to
-  minimize the amount of information that users have to keep in their head
+  At the moment the policy is *not* to generalise over any other types to
+  minimise the amount of information that users have to keep in their head
   concurrently.
 
 * Example 1: the main type in `Data.List.Properties` is `List A` where `A : Set a`.
@@ -402,7 +474,7 @@ word within a compound word is capitalized except for the first word.
 
 * Rational variables are named `p`, `q`, `r`, ... (default `p`)
 
-* All other variables tend to be named `x`, `y`, `z`.
+* All other variables should be named `x`, `y`, `z`.
 
 * Collections of elements are usually indicated by appending an `s`
   (e.g. if you are naming your variables `x` and `y` then lists
@@ -443,6 +515,104 @@ word within a compound word is capitalized except for the first word.
   relations should be used over the `¬` symbol (e.g. `m+n≮n` should be
   used instead of `¬m+n<n`).
 
+#### Symbols for operators and relations
+
+* The stdlib aims to use a consistent set of notations, governed by a
+  consistent set of conventions, but sometimes, different
+  Unicode/emacs-input-method symbols nevertheless can be rendered by
+  identical-*seeming* symbols, so this is an attempt to document these.
+
+* The typical binary operator in the `Algebra` hierarchy, inheriting
+  from the root `Structure`/`Bundle` `isMagma`/`Magma`, is written as
+  infix `∙`, obtained as `\.`, NOT as `\bu2`. Nevertheless, there is
+  also a 'generic' operator, written as infix `·`, obtained as
+  `\cdot`. Do NOT attempt to use related, but typographically
+  indistinguishable, symbols.
+
+* Similarly, 'primed' names and symbols, used to standardise names
+  apart, or to provide (more) simply-typed versions of
+  dependently-typed operations, should be written using `\'`, NOT the
+  unmarked `'` character.
+
+* Likewise, standard infix symbols for eg, divisibility on numeric
+  datatypes/algebraic structure, should be written `\|`, NOT the
+  unmarked `|` character. An exception to this is the *strict*
+  ordering relation, written using `<`, NOT `\<` as might be expected.
+
+* Since v2.0, the `Algebra` hierarchy systematically introduces
+  consistent symbolic notation for the negated versions of the usual
+  binary predicates for equality, ordering etc. These are obtained
+  from the corresponding input sequence by adding `n` to the symbol
+  name, so that `≤`, obtained as `\le`, becomes `≰` obtained as
+  `\len`, etc.
+
+* Correspondingly, the flipped symbols (and their negations) for the
+  converse relations are systematically introduced, eg `≥` as `\ge`
+  and `≱` as `\gen`.
+
+* Any exceptions to these conventions should be flagged on the GitHub
+  `agda-stdlib` issue tracker in the usual way.
+
+#### Fixity
+
+All functions and operators that are not purely prefix (typically
+anything that has a `_` in its name) should have an explicit fixity
+declared for it. The guidelines for these are as follows:
+
+General operations and relations:
+
+* binary relations of all kinds are `infix 4`
+
+* unary prefix relations `infix 4 ε∣_`
+
+* unary postfix relations `infixr 8 _∣0`
+
+* multiplication-like: `infixl 7 _*_`
+
+* addition-like  `infixl 6 _+_`
+
+* arithmetic prefix minus-like  `infix  8 -_`
+
+* arithmetic infix binary minus-like `infixl 6 _-_`
+
+* and-like  `infixr 7 _∧_`
+
+* or-like  `infixr 6 _∨_`
+
+* negation-like `infix 3 ¬_`
+
+* post-fix inverse  `infix  8 _⁻¹`
+
+* bind `infixl 1 _>>=_`
+
+* list concat-like `infixr 5 _∷_`
+
+* ternary reasoning `infix 1 _⊢_≈_`
+
+* composition `infixr 9 _∘_`
+
+* application `infixr -1 _$_ _$!_`
+
+* combinatorics `infixl 6.5 _P_ _P′_ _C_ _C′_`
+
+* pair `infixr 4 _,_`
+
+Reasoning:
+
+* QED  `infix  3 _∎`
+
+* stepping  `infixr 2 _≡⟨⟩_ step-≡ step-≡˘`
+
+* begin  `infix  1 begin_`
+
+Type formers:
+
+* product-like `infixr 2 _×_ _-×-_ _-,-_`
+
+* sum-like `infixr 1 _⊎_`
+
+*  binary properties `infix 4 _Absorbs_`
+
 #### Functions and relations over specific datatypes
 
 * When defining a new relation `P` over a datatype `X` in a `Data.X.Relation` module,
@@ -461,6 +631,16 @@ word within a compound word is capitalized except for the first word.
   map⁻ : Pointwise R (map f as) (map g bs) → Pointwise (λ a b → R (f a) (g b)) as bs
   ```
 
+* When specifying a property over a container, there are usually two choices. Either
+  assume the property holds for generally (e.g. `map id xs ≡ xs`) or a assume that
+  it only holds for the elements within the container (e.g. `All (λ x → f x ≡ x) xs → map f xs ≡ xs`).
+  The naming convention is to add a `-local` suffix on to the name of the latter variety.
+  e.g.
+  ```agda
+  map-id       :  map id xs ≡ xs
+  map-id-local :  All (λ x → f x ≡ x) xs → map f xs ≡ xs
+  ```
+
 #### Keywords
 
 * If the name of something clashes with a keyword in Agda, then convention
@@ -474,3 +654,30 @@ word within a compound word is capitalized except for the first word.
 
 * The names of patterns for reflected syntax are also *appended* with an
   additional backtick.
+
+#### Specific pragmatics/idiomatic patterns
+
+## Use of `pattern` synonyms
+
+In general, these are intended to be used to provide specialised
+constructors for `Data` types (and sometimes, inductive
+families/binary relations such as `Data.Nat.Divisibility._∣_`), and as
+such, their use should be restricted to `Base` or `Core` modules, and
+not pollute the namespaces of `Properties` or other modules.
+
+## Use of `with` notation
+
+Thinking on this has changed since the early days of the library, with
+a desire to avoid 'unnecessary' uses of `with`: see Issues
+[#1937](https://github.com/agda/agda-stdlib/issues/1937) and
+[#2123](https://github.com/agda/agda-stdlib/issues/2123).
+
+## Proving instances of `Decidable` for sets, predicates, relations, ...
+
+Issue [#803](https://github.com/agda/agda-stdlib/issues/803)
+articulates a programming pattern for writing proofs of decidability,
+used successfully in PR
+[#799](https://github.com/agda/agda-stdlib/pull/799) and made
+systematic for `Nary` relations in PR
+[#811](https://github.com/agda/agda-stdlib/pull/811)
+
diff --git a/notes/updating-experimental.txt b/doc/updating-experimental.txt
similarity index 100%
rename from notes/updating-experimental.txt
rename to doc/updating-experimental.txt
diff --git a/fix-whitespace.yaml b/fix-whitespace.yaml
index 6f50570fcf..aacf310d54 100644
--- a/fix-whitespace.yaml
+++ b/fix-whitespace.yaml
@@ -5,8 +5,6 @@ included-dirs:
 included-files:
   - "*.agda"
   - "*.md"
-  - ".travis.yml"
 
 excluded-files:
-  - "README/Text/Tabular.agda"
-  - CHANGELOG.md
+  - "README/Text/Tabular.agda"
\ No newline at end of file
diff --git a/src/Algebra/Apartness/Properties/HeytingCommutativeRing.agda b/src/Algebra/Apartness/Properties/HeytingCommutativeRing.agda
index 7ac5b3e58a..d8b3ffcdfd 100644
--- a/src/Algebra/Apartness/Properties/HeytingCommutativeRing.agda
+++ b/src/Algebra/Apartness/Properties/HeytingCommutativeRing.agda
@@ -11,23 +11,98 @@ open import Algebra.Apartness.Bundles using (HeytingCommutativeRing)
 module Algebra.Apartness.Properties.HeytingCommutativeRing
   {c ℓ₁ ℓ₂} (HCR : HeytingCommutativeRing c ℓ₁ ℓ₂) where
 
-open import Data.Product using (_,_; proj₂)
-open import Algebra using (CommutativeRing; RightIdentity)
+open import Function.Base using (_∘_)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
+open import Algebra using (CommutativeRing; RightIdentity; Invertible; LeftInvertible; RightInvertible)
 
 open HeytingCommutativeRing HCR
-open CommutativeRing commutativeRing using (ring)
+open CommutativeRing commutativeRing using (ring; *-commutativeMonoid)
 
-open import Algebra.Properties.Ring ring using (-0#≈0#)
+open import Algebra.Properties.Ring ring
+  using (-0#≈0#; -‿distribˡ-*; -‿distribʳ-*; -‿anti-homo-+; -‿involutive)
+open import Relation.Binary.Definitions using (Symmetric)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
+open import Algebra.Properties.CommutativeMonoid *-commutativeMonoid
 
+private variable
+  x y z : Carrier
+
+invertibleˡ⇒# : LeftInvertible _≈_ 1# _*_ (x - y) → x # y
+invertibleˡ⇒# = invertible⇒# ∘ invertibleˡ⇒invertible
+
+invertibleʳ⇒# : RightInvertible _≈_ 1# _*_ (x - y) → x # y
+invertibleʳ⇒# = invertible⇒# ∘ invertibleʳ⇒invertible
 
 x-0≈x : RightIdentity _≈_ 0# _-_
 x-0≈x x = trans (+-congˡ -0#≈0#) (+-identityʳ x)
 
 1#0 : 1# # 0#
-1#0 = invertible⇒# (1# , 1*[x-0]≈x , [x-0]*1≈x)
+1#0 = invertibleˡ⇒# (1# , 1*[x-0]≈x)
   where
-  1*[x-0]≈x : ∀ {x} → 1# * (x - 0#) ≈ x
+  1*[x-0]≈x : 1# * (x - 0#) ≈ x
   1*[x-0]≈x {x} = trans (*-identityˡ (x - 0#)) (x-0≈x x)
 
-  [x-0]*1≈x : ∀ {x} → (x - 0#) * 1# ≈ x
-  [x-0]*1≈x {x} = trans (*-comm (x - 0#) 1#) 1*[x-0]≈x
+x#0y#0→xy#0 : x # 0# → y # 0# → x * y # 0#
+x#0y#0→xy#0 {x} {y} x#0 y#0 = helper (#⇒invertible x#0) (#⇒invertible y#0)
+  where
+
+  helper : Invertible _≈_ 1# _*_ (x - 0#) → Invertible _≈_ 1# _*_ (y - 0#) → x * y # 0#
+  helper (x⁻¹ , x⁻¹*x≈1 , x*x⁻¹≈1) (y⁻¹ , y⁻¹*y≈1 , y*y⁻¹≈1)
+    = invertibleˡ⇒# (y⁻¹ * x⁻¹ , y⁻¹*x⁻¹*x*y≈1)
+    where
+    open ≈-Reasoning setoid
+
+    y⁻¹*x⁻¹*x*y≈1 : y⁻¹ * x⁻¹ * (x * y - 0#) ≈ 1#
+    y⁻¹*x⁻¹*x*y≈1 = begin
+      y⁻¹ * x⁻¹ * (x * y - 0#)     ≈⟨ *-congˡ (x-0≈x (x * y)) ⟩
+      y⁻¹ * x⁻¹ * (x * y)          ≈⟨ *-assoc y⁻¹ x⁻¹ (x * y) ⟩
+      y⁻¹ * (x⁻¹ * (x * y))       ≈⟨ *-congˡ (*-assoc x⁻¹ x y) ⟨
+      y⁻¹ * ((x⁻¹ * x) * y)       ≈⟨ *-congˡ (*-congʳ (*-congˡ (x-0≈x x))) ⟨
+      y⁻¹ * ((x⁻¹ * (x - 0#)) * y) ≈⟨ *-congˡ (*-congʳ x⁻¹*x≈1) ⟩
+      y⁻¹ * (1# * y)               ≈⟨ *-congˡ (*-identityˡ y) ⟩
+      y⁻¹ * y                     ≈⟨ *-congˡ (x-0≈x y) ⟨
+      y⁻¹ * (y - 0#)               ≈⟨ y⁻¹*y≈1 ⟩
+      1# ∎
+
+#-sym : Symmetric _#_
+#-sym {x} {y} x#y = invertibleˡ⇒# (- x-y⁻¹ , x-y⁻¹*y-x≈1)
+  where
+  open ≈-Reasoning setoid
+  InvX-Y : Invertible _≈_ 1# _*_ (x - y)
+  InvX-Y = #⇒invertible x#y
+
+  x-y⁻¹ = InvX-Y .proj₁
+
+  y-x≈-[x-y] : y - x ≈ - (x - y)
+  y-x≈-[x-y] = begin
+    y - x     ≈⟨ +-congʳ (-‿involutive y) ⟨
+    - - y - x ≈⟨ -‿anti-homo-+ x (- y) ⟨
+    - (x - y) ∎
+
+  x-y⁻¹*y-x≈1 : (- x-y⁻¹) * (y - x) ≈ 1#
+  x-y⁻¹*y-x≈1 = begin
+    (- x-y⁻¹) * (y - x)   ≈⟨ -‿distribˡ-* x-y⁻¹ (y - x) ⟨
+    - (x-y⁻¹ * (y - x))    ≈⟨ -‿cong (*-congˡ y-x≈-[x-y]) ⟩
+    - (x-y⁻¹ * - (x - y)) ≈⟨ -‿cong (-‿distribʳ-* x-y⁻¹ (x - y)) ⟨
+    - - (x-y⁻¹ * (x - y))  ≈⟨ -‿involutive (x-y⁻¹ * ((x - y))) ⟩
+    x-y⁻¹ * (x - y)        ≈⟨ InvX-Y .proj₂ .proj₁ ⟩
+    1# ∎
+
+#-congʳ : x ≈ y → x # z → y # z
+#-congʳ {x} {y} {z} x≈y x#z = helper (#⇒invertible x#z)
+  where
+
+  helper : Invertible _≈_ 1# _*_ (x - z) → y # z
+  helper (x-z⁻¹ , x-z⁻¹*x-z≈1# , x-z*x-z⁻¹≈1#)
+    = invertibleˡ⇒# (x-z⁻¹ , x-z⁻¹*y-z≈1)
+    where
+    open ≈-Reasoning setoid
+
+    x-z⁻¹*y-z≈1 : x-z⁻¹ * (y - z) ≈ 1#
+    x-z⁻¹*y-z≈1 = begin
+      x-z⁻¹ * (y - z) ≈⟨ *-congˡ (+-congʳ x≈y) ⟨
+      x-z⁻¹ * (x - z)  ≈⟨ x-z⁻¹*x-z≈1# ⟩
+      1# ∎
+
+#-congˡ : y ≈ z → x # y → x # z
+#-congˡ y≈z x#y = #-sym (#-congʳ y≈z (#-sym x#y))
diff --git a/src/Algebra/Apartness/Structures.agda b/src/Algebra/Apartness/Structures.agda
index 3311234945..a8c5c88982 100644
--- a/src/Algebra/Apartness/Structures.agda
+++ b/src/Algebra/Apartness/Structures.agda
@@ -17,7 +17,7 @@ module Algebra.Apartness.Structures
   where
 
 open import Level using (_⊔_; suc)
-open import Data.Product using (∃-syntax; _×_; _,_; proj₂)
+open import Data.Product.Base using (∃-syntax; _×_; _,_; proj₂)
 open import Algebra.Definitions _≈_ using (Invertible)
 open import Algebra.Structures _≈_ using (IsCommutativeRing)
 open import Relation.Binary.Structures using (IsEquivalence; IsApartnessRelation)
diff --git a/src/Algebra/Bundles.agda b/src/Algebra/Bundles.agda
index 2598fde953..d96584a733 100644
--- a/src/Algebra/Bundles.agda
+++ b/src/Algebra/Bundles.agda
@@ -14,19 +14,37 @@ module Algebra.Bundles where
 import Algebra.Bundles.Raw as Raw
 open import Algebra.Core
 open import Algebra.Structures
-open import Relation.Binary
-open import Function.Base
-import Relation.Nullary as N
+open import Relation.Binary.Core using (Rel)
 open import Level
 
 ------------------------------------------------------------------------
 -- Re-export definitions of 'raw' bundles
 
 open Raw public
-  using (RawMagma; RawMonoid; RawGroup
+  using ( RawSuccessorSet; RawMagma; RawMonoid; RawGroup
         ; RawNearSemiring; RawSemiring
         ; RawRingWithoutOne; RawRing
-        ; RawQuasigroup; RawLoop)
+        ; RawQuasigroup; RawLoop; RawKleeneAlgebra)
+
+------------------------------------------------------------------------
+-- Bundles with 1 unary operation & 1 element
+------------------------------------------------------------------------
+
+record SuccessorSet c ℓ : Set (suc (c ⊔ ℓ)) where
+  infix  4 _≈_
+  field
+    Carrier          : Set c
+    _≈_              : Rel Carrier ℓ
+    suc#             : Op₁ Carrier
+    zero#            : Carrier
+    isSuccessorSet   : IsSuccessorSet _≈_ suc# zero#
+
+  open IsSuccessorSet isSuccessorSet public
+
+  rawSuccessorSet : RawSuccessorSet _ _
+  rawSuccessorSet = record { _≈_ = _≈_; suc# = suc#; zero# = zero# }
+
+  open RawSuccessorSet rawSuccessorSet public
 
 ------------------------------------------------------------------------
 -- Bundles with 1 binary operation
@@ -225,6 +243,30 @@ record CommutativeSemigroup c ℓ : Set (suc (c ⊔ ℓ)) where
   commutativeMagma : CommutativeMagma c ℓ
   commutativeMagma = record { isCommutativeMagma = isCommutativeMagma }
 
+record CommutativeBand c ℓ : Set (suc (c ⊔ ℓ)) where
+  infixl 7 _∙_
+  infix  4 _≈_
+  field
+    Carrier            : Set c
+    _≈_                : Rel Carrier ℓ
+    _∙_                : Op₂ Carrier
+    isCommutativeBand  : IsCommutativeBand _≈_ _∙_
+
+  open IsCommutativeBand isCommutativeBand public
+
+  band : Band _ _
+  band = record { isBand = isBand }
+
+  open Band band public
+    using (_≉_; magma; rawMagma; semigroup)
+
+  commutativeSemigroup : CommutativeSemigroup c ℓ
+  commutativeSemigroup = record { isCommutativeSemigroup = isCommutativeSemigroup }
+
+  open CommutativeSemigroup commutativeSemigroup public
+    using (commutativeMagma)
+
+
 ------------------------------------------------------------------------
 -- Bundles with 1 binary operation & 1 element
 ------------------------------------------------------------------------
@@ -297,6 +339,27 @@ record CommutativeMonoid c ℓ : Set (suc (c ⊔ ℓ)) where
   open CommutativeSemigroup commutativeSemigroup public
     using (commutativeMagma)
 
+record IdempotentMonoid c ℓ : Set (suc (c ⊔ ℓ)) where
+  infixl 7 _∙_
+  infix  4 _≈_
+  field
+    Carrier            : Set c
+    _≈_                : Rel Carrier ℓ
+    _∙_                : Op₂ Carrier
+    ε                  : Carrier
+    isIdempotentMonoid : IsIdempotentMonoid _≈_ _∙_ ε
+
+  open IsIdempotentMonoid isIdempotentMonoid public
+
+  monoid : Monoid _ _
+  monoid = record { isMonoid = isMonoid }
+
+  open Monoid monoid public
+    using (_≉_; rawMagma; magma; semigroup; unitalMagma; rawMonoid)
+
+  band : Band _ _
+  band = record { isBand = isBand }
+
 
 record IdempotentCommutativeMonoid c ℓ : Set (suc (c ⊔ ℓ)) where
   infixl 7 _∙_
@@ -313,6 +376,12 @@ record IdempotentCommutativeMonoid c ℓ : Set (suc (c ⊔ ℓ)) where
   commutativeMonoid : CommutativeMonoid _ _
   commutativeMonoid = record { isCommutativeMonoid = isCommutativeMonoid }
 
+  idempotentMonoid : IdempotentMonoid _ _
+  idempotentMonoid = record { isIdempotentMonoid = isIdempotentMonoid }
+
+  commutativeBand : CommutativeBand _ _
+  commutativeBand = record { isCommutativeBand = isCommutativeBand }
+
   open CommutativeMonoid commutativeMonoid public
     using
     ( _≉_; rawMagma; magma; unitalMagma; commutativeMagma
@@ -320,6 +389,8 @@ record IdempotentCommutativeMonoid c ℓ : Set (suc (c ⊔ ℓ)) where
     ; rawMonoid; monoid
     )
 
+  open CommutativeBand commutativeBand public
+    using (band)
 
 -- Idempotent commutative monoids are also known as bounded lattices.
 -- Note that the BoundedLattice necessarily uses the notation inherited
@@ -504,7 +575,7 @@ record SemiringWithoutOne c ℓ : Set (suc (c ⊔ ℓ)) where
 
   open NearSemiring nearSemiring public
     using
-    ( _≉_; +-rawMagma; +-magma; +-unitalMagma; +-semigroup
+    ( +-rawMagma; +-magma; +-unitalMagma; +-semigroup
     ; +-rawMonoid; +-monoid
     ; *-rawMagma; *-magma; *-semigroup
     ; rawNearSemiring
@@ -542,7 +613,7 @@ record CommutativeSemiringWithoutOne c ℓ : Set (suc (c ⊔ ℓ)) where
 
   open SemiringWithoutOne semiringWithoutOne public
     using
-    ( _≉_; +-rawMagma; +-magma; +-unitalMagma; +-semigroup; +-commutativeSemigroup
+    ( +-rawMagma; +-magma; +-unitalMagma; +-semigroup; +-commutativeSemigroup
     ; *-rawMagma; *-magma; *-semigroup
     ; +-rawMonoid; +-monoid; +-commutativeMonoid
     ; nearSemiring; rawNearSemiring
@@ -760,6 +831,16 @@ record IdempotentSemiring c ℓ : Set (suc (c ⊔ ℓ)) where
     ; rawSemiring
     )
 
+  +-idempotentCommutativeMonoid : IdempotentCommutativeMonoid _ _
+  +-idempotentCommutativeMonoid = record { isIdempotentCommutativeMonoid = +-isIdempotentCommutativeMonoid }
+
+  open IdempotentCommutativeMonoid +-idempotentCommutativeMonoid public
+    using ()
+    renaming ( band to +-band
+             ; commutativeBand to +-commutativeBand
+             ; idempotentMonoid to +-idempotentMonoid
+             )
+
 record KleeneAlgebra c ℓ : Set (suc (c ⊔ ℓ)) where
   infix  8 _⋆
   infixl 7 _*_
@@ -892,7 +973,14 @@ record NonAssociativeRing c ℓ : Set (suc (c ⊔ ℓ)) where
   open AbelianGroup +-abelianGroup public
     using () renaming (group to +-group; invertibleMagma to +-invertibleMagma; invertibleUnitalMagma to +-invertibleUnitalMagma)
 
+  *-unitalMagma : UnitalMagma _ _
+  *-unitalMagma = record { isUnitalMagma = *-isUnitalMagma}
+
+  open UnitalMagma *-unitalMagma public
+    using () renaming (magma to *-magma; identity to *-identity)
+
 record Nearring c ℓ : Set (suc (c ⊔ ℓ)) where
+  infix  8 -_
   infixl 7 _*_
   infixl 6 _+_
   infix  4 _≈_
@@ -938,6 +1026,9 @@ record Ring c ℓ : Set (suc (c ⊔ ℓ)) where
   +-abelianGroup : AbelianGroup _ _
   +-abelianGroup = record { isAbelianGroup = +-isAbelianGroup }
 
+  ringWithoutOne : RingWithoutOne _ _
+  ringWithoutOne = record { isRingWithoutOne = isRingWithoutOne }
+
   semiring : Semiring _ _
   semiring = record { isSemiring = isSemiring }
 
@@ -952,6 +1043,9 @@ record Ring c ℓ : Set (suc (c ⊔ ℓ)) where
     ; semiringWithoutAnnihilatingZero
     )
 
+  open NearSemiring nearSemiring public
+    using (rawNearSemiring)
+
   open AbelianGroup +-abelianGroup public
     using () renaming (group to +-group; invertibleMagma to +-invertibleMagma; invertibleUnitalMagma to +-invertibleUnitalMagma)
 
@@ -965,6 +1059,9 @@ record Ring c ℓ : Set (suc (c ⊔ ℓ)) where
     ; 1#  = 1#
     }
 
+  open RawRing rawRing public
+    using (rawRingWithoutOne; +-rawGroup)
+
 
 record CommutativeRing c ℓ : Set (suc (c ⊔ ℓ)) where
   infix  8 -_
@@ -1158,3 +1255,4 @@ record MiddleBolLoop c ℓ : Set (suc (c ⊔ ℓ)) where
 
   open Loop loop public
     using (quasigroup)
+
diff --git a/src/Algebra/Bundles/Raw.agda b/src/Algebra/Bundles/Raw.agda
index e7f9be1349..5c99d02790 100644
--- a/src/Algebra/Bundles/Raw.agda
+++ b/src/Algebra/Bundles/Raw.agda
@@ -13,6 +13,20 @@ open import Relation.Binary.Core using (Rel)
 open import Level using (suc; _⊔_)
 open import Relation.Nullary.Negation.Core using (¬_)
 
+------------------------------------------------------------------------
+-- Raw bundles with 1 unary operation & 1 element
+------------------------------------------------------------------------
+
+-- A raw SuccessorSet is a SuccessorSet without any laws.
+
+record RawSuccessorSet c ℓ : Set (suc (c ⊔ ℓ)) where
+  infix  4 _≈_
+  field
+    Carrier : Set c
+    _≈_     : Rel Carrier ℓ
+    suc#    : Op₁ Carrier
+    zero#   : Carrier
+
 ------------------------------------------------------------------------
 -- Raw bundles with 1 binary operation
 ------------------------------------------------------------------------
@@ -153,12 +167,12 @@ record RawRingWithoutOne c ℓ : Set (suc (c ⊔ ℓ)) where
   infixl 6 _+_
   infix  4 _≈_
   field
-    Carrier           : Set c
-    _≈_               : Rel Carrier ℓ
-    _+_               : Op₂ Carrier
-    _*_               : Op₂ Carrier
-    -_                : Op₁ Carrier
-    0#                : Carrier
+    Carrier : Set c
+    _≈_     : Rel Carrier ℓ
+    _+_     : Op₂ Carrier
+    _*_     : Op₂ Carrier
+    -_      : Op₁ Carrier
+    0#      : Carrier
 
   +-rawGroup : RawGroup c ℓ
   +-rawGroup = record
@@ -213,14 +227,18 @@ record RawRing c ℓ : Set (suc (c ⊔ ℓ)) where
     ; *-rawMagma; *-rawMonoid
     )
 
-  +-rawGroup : RawGroup c ℓ
-  +-rawGroup = record
+  rawRingWithoutOne : RawRingWithoutOne c ℓ
+  rawRingWithoutOne = record
     { _≈_ = _≈_
-    ; _∙_ = _+_
-    ; ε   = 0#
-    ; _⁻¹ = -_
+    ; _+_ = _+_
+    ; _*_ = _*_
+    ; -_ = -_
+    ; 0# = 0#
     }
 
+  open RawRingWithoutOne rawRingWithoutOne public
+    using (+-rawGroup)
+
 ------------------------------------------------------------------------
 -- Raw bundles with 3 binary operations
 ------------------------------------------------------------------------
@@ -285,3 +303,33 @@ record RawLoop  c ℓ : Set (suc (c ⊔ ℓ)) where
 
   open RawQuasigroup rawQuasigroup public
     using (_≉_ ; ∙-rawMagma; \\-rawMagma; //-rawMagma)
+
+record RawKleeneAlgebra c ℓ : Set (suc (c ⊔ ℓ)) where
+  infix  8 _⋆
+  infixl 7 _*_
+  infixl 6 _+_
+  infix  4 _≈_
+  field
+    Carrier : Set c
+    _≈_     : Rel Carrier ℓ
+    _+_     : Op₂ Carrier
+    _*_     : Op₂ Carrier
+    _⋆      : Op₁ Carrier
+    0#      : Carrier
+    1#      : Carrier
+
+  rawSemiring : RawSemiring c ℓ
+  rawSemiring = record
+    { _≈_ = _≈_
+    ; _+_ = _+_
+    ; _*_ = _*_
+    ; 0#  = 0#
+    ; 1#  = 1#
+    }
+
+  open RawSemiring rawSemiring public
+    using
+    ( _≉_
+    ; +-rawMagma; +-rawMonoid
+    ; *-rawMagma; *-rawMonoid
+    )
diff --git a/src/Algebra/Consequences/Base.agda b/src/Algebra/Consequences/Base.agda
index 1a3e105604..574ad48a16 100644
--- a/src/Algebra/Consequences/Base.agda
+++ b/src/Algebra/Consequences/Base.agda
@@ -19,14 +19,25 @@ open import Relation.Binary.Definitions using (Reflexive)
 module _ {ℓ} {_•_ : Op₂ A} (_≈_ : Rel A ℓ) where
 
   sel⇒idem : Selective _≈_ _•_ → Idempotent _≈_ _•_
-  sel⇒idem sel x with sel x x
-  ... | inj₁ x•x≈x = x•x≈x
-  ... | inj₂ x•x≈x = x•x≈x
+  sel⇒idem sel x = reduce (sel x x)
 
 module _ {ℓ} {f : Op₁ A} (_≈_ : Rel A ℓ) where
 
-  reflexive+selfInverse⇒involutive : Reflexive _≈_ →
+  reflexive∧selfInverse⇒involutive : Reflexive _≈_ →
                                      SelfInverse _≈_ f →
                                      Involutive _≈_ f
-  reflexive+selfInverse⇒involutive refl inv _ = inv refl
+  reflexive∧selfInverse⇒involutive refl inv _ = inv refl
 
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
+
+reflexive+selfInverse⇒involutive = reflexive∧selfInverse⇒involutive
+{-# WARNING_ON_USAGE reflexive+selfInverse⇒involutive
+"Warning: reflexive+selfInverse⇒involutive was deprecated in v2.0.
+Please use reflexive∧selfInverse⇒involutive instead."
+#-}
diff --git a/src/Algebra/Consequences/Propositional.agda b/src/Algebra/Consequences/Propositional.agda
index 05278fea34..29490cbd0c 100644
--- a/src/Algebra/Consequences/Propositional.agda
+++ b/src/Algebra/Consequences/Propositional.agda
@@ -11,8 +11,13 @@ module Algebra.Consequences.Propositional
   {a} {A : Set a} where
 
 open import Data.Sum.Base using (inj₁; inj₂)
-open import Relation.Binary using (Rel; Setoid; Symmetric; Total)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (Symmetric; Total)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; cong₂; subst)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (setoid)
 open import Relation.Unary using (Pred)
 
 open import Algebra.Core
@@ -24,83 +29,176 @@ import Algebra.Consequences.Setoid (setoid A) as Base
 
 open Base public
   hiding
-  ( assoc+distribʳ+idʳ+invʳ⇒zeˡ
+  ( comm∧assoc⇒middleFour
+  ; identity∧middleFour⇒assoc
+  ; identity∧middleFour⇒comm
+  ; assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ
+  ; assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ
+  ; assoc∧id∧invʳ⇒invˡ-unique
+  ; assoc∧id∧invˡ⇒invʳ-unique
+  ; comm∧distrˡ⇒distrʳ
+  ; comm∧distrʳ⇒distrˡ
+  ; comm⇒sym[distribˡ]
+  ; subst∧comm⇒sym
+  ; wlog
+  ; sel⇒idem
+-- plus all the deprecated versions of the above
+  ; comm+assoc⇒middleFour
+  ; identity+middleFour⇒assoc
+  ; identity+middleFour⇒comm
+  ; assoc+distribʳ+idʳ+invʳ⇒zeˡ
   ; assoc+distribˡ+idʳ+invʳ⇒zeʳ
   ; assoc+id+invʳ⇒invˡ-unique
   ; assoc+id+invˡ⇒invʳ-unique
   ; comm+distrˡ⇒distrʳ
   ; comm+distrʳ⇒distrˡ
-  ; comm⇒sym[distribˡ]
   ; subst+comm⇒sym
-  ; wlog
-  ; sel⇒idem
   )
 
 ------------------------------------------------------------------------
 -- Group-like structures
 
-module _ {_•_ _⁻¹ ε} where
+module _ {_∙_ _⁻¹ ε} where
 
-  assoc+id+invʳ⇒invˡ-unique : Associative _•_ → Identity ε _•_ →
-                              RightInverse ε _⁻¹ _•_ →
-                              ∀ x y → (x • y) ≡ ε → x ≡ (y ⁻¹)
-  assoc+id+invʳ⇒invˡ-unique = Base.assoc+id+invʳ⇒invˡ-unique (cong₂ _)
+  assoc∧id∧invʳ⇒invˡ-unique : Associative _∙_ → Identity ε _∙_ →
+                              RightInverse ε _⁻¹ _∙_ →
+                              ∀ x y → (x ∙ y) ≡ ε → x ≡ (y ⁻¹)
+  assoc∧id∧invʳ⇒invˡ-unique = Base.assoc∧id∧invʳ⇒invˡ-unique (cong₂ _)
 
-  assoc+id+invˡ⇒invʳ-unique : Associative _•_ → Identity ε _•_ →
-                              LeftInverse ε _⁻¹ _•_ →
-                              ∀ x y → (x • y) ≡ ε → y ≡ (x ⁻¹)
-  assoc+id+invˡ⇒invʳ-unique = Base.assoc+id+invˡ⇒invʳ-unique (cong₂ _)
+  assoc∧id∧invˡ⇒invʳ-unique : Associative _∙_ → Identity ε _∙_ →
+                              LeftInverse ε _⁻¹ _∙_ →
+                              ∀ x y → (x ∙ y) ≡ ε → y ≡ (x ⁻¹)
+  assoc∧id∧invˡ⇒invʳ-unique = Base.assoc∧id∧invˡ⇒invʳ-unique (cong₂ _)
 
 ------------------------------------------------------------------------
 -- Ring-like structures
 
 module _ {_+_ _*_ -_ 0#} where
 
-  assoc+distribʳ+idʳ+invʳ⇒zeˡ : Associative _+_ → _*_ DistributesOverʳ _+_ →
+  assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ : Associative _+_ → _*_ DistributesOverʳ _+_ →
                                 RightIdentity 0# _+_ → RightInverse 0# -_ _+_ →
                                 LeftZero 0# _*_
-  assoc+distribʳ+idʳ+invʳ⇒zeˡ =
-    Base.assoc+distribʳ+idʳ+invʳ⇒zeˡ (cong₂ _+_) (cong₂ _*_)
+  assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ =
+    Base.assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ (cong₂ _+_) (cong₂ _*_)
 
-  assoc+distribˡ+idʳ+invʳ⇒zeʳ : Associative _+_ → _*_ DistributesOverˡ _+_ →
+  assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ : Associative _+_ → _*_ DistributesOverˡ _+_ →
                                 RightIdentity 0# _+_ → RightInverse 0# -_ _+_ →
                                 RightZero 0# _*_
-  assoc+distribˡ+idʳ+invʳ⇒zeʳ =
-    Base.assoc+distribˡ+idʳ+invʳ⇒zeʳ (cong₂ _+_) (cong₂ _*_)
+  assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ =
+    Base.assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ (cong₂ _+_) (cong₂ _*_)
 
 ------------------------------------------------------------------------
 -- Bisemigroup-like structures
 
-module _ {_•_ _◦_ : Op₂ A} (•-comm : Commutative _•_) where
+module _ {_∙_ _◦_ : Op₂ A} (∙-comm : Commutative _∙_) where
 
-  comm+distrˡ⇒distrʳ : _•_ DistributesOverˡ _◦_ → _•_ DistributesOverʳ _◦_
-  comm+distrˡ⇒distrʳ = Base.comm+distrˡ⇒distrʳ (cong₂ _) •-comm
+  comm∧distrˡ⇒distrʳ : _∙_ DistributesOverˡ _◦_ → _∙_ DistributesOverʳ _◦_
+  comm∧distrˡ⇒distrʳ = Base.comm+distrˡ⇒distrʳ (cong₂ _) ∙-comm
 
-  comm+distrʳ⇒distrˡ : _•_ DistributesOverʳ _◦_ → _•_ DistributesOverˡ _◦_
-  comm+distrʳ⇒distrˡ = Base.comm+distrʳ⇒distrˡ (cong₂ _) •-comm
+  comm∧distrʳ⇒distrˡ : _∙_ DistributesOverʳ _◦_ → _∙_ DistributesOverˡ _◦_
+  comm∧distrʳ⇒distrˡ = Base.comm∧distrʳ⇒distrˡ (cong₂ _) ∙-comm
 
-  comm⇒sym[distribˡ] : ∀ x → Symmetric (λ y z → (x ◦ (y • z)) ≡ ((x ◦ y) • (x ◦ z)))
-  comm⇒sym[distribˡ] = Base.comm⇒sym[distribˡ] (cong₂ _◦_) •-comm
+  comm⇒sym[distribˡ] : ∀ x → Symmetric (λ y z → (x ◦ (y ∙ z)) ≡ ((x ◦ y) ∙ (x ◦ z)))
+  comm⇒sym[distribˡ] = Base.comm⇒sym[distribˡ] (cong₂ _◦_) ∙-comm
 
 ------------------------------------------------------------------------
 -- Selectivity
 
-module _ {_•_ : Op₂ A} where
+module _ {_∙_ : Op₂ A} where
 
-  sel⇒idem : Selective _•_ → Idempotent _•_
+  sel⇒idem : Selective _∙_ → Idempotent _∙_
   sel⇒idem = Base.sel⇒idem _≡_
 
+------------------------------------------------------------------------
+-- Middle-Four Exchange
+
+module _ {_∙_ : Op₂ A} where
+
+  comm∧assoc⇒middleFour : Commutative _∙_ → Associative _∙_ →
+                          _∙_ MiddleFourExchange _∙_
+  comm∧assoc⇒middleFour = Base.comm∧assoc⇒middleFour (cong₂ _∙_)
+
+  identity∧middleFour⇒assoc : {e : A} → Identity e _∙_ →
+                              _∙_ MiddleFourExchange _∙_ →
+                              Associative _∙_
+  identity∧middleFour⇒assoc = Base.identity∧middleFour⇒assoc (cong₂ _∙_)
+
+  identity∧middleFour⇒comm : {_+_ : Op₂ A} {e : A} → Identity e _+_ →
+                             _∙_ MiddleFourExchange _+_ →
+                             Commutative _∙_
+  identity∧middleFour⇒comm = Base.identity∧middleFour⇒comm (cong₂ _∙_)
+
 ------------------------------------------------------------------------
 -- Without Loss of Generality
 
 module _ {p} {P : Pred A p} where
 
-  subst+comm⇒sym : ∀ {f} (f-comm : Commutative f) →
+  subst∧comm⇒sym : ∀ {f} (f-comm : Commutative f) →
                    Symmetric (λ a b → P (f a b))
-  subst+comm⇒sym = Base.subst+comm⇒sym {P = P} subst
+  subst∧comm⇒sym = Base.subst∧comm⇒sym {P = P} subst
 
   wlog : ∀ {f} (f-comm : Commutative f) →
          ∀ {r} {_R_ : Rel _ r} → Total _R_ →
          (∀ a b → a R b → P (f a b)) →
          ∀ a b → P (f a b)
   wlog = Base.wlog {P = P} subst
+
+
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
+
+comm+assoc⇒middleFour = comm∧assoc⇒middleFour
+{-# WARNING_ON_USAGE comm+assoc⇒middleFour
+"Warning: comm+assoc⇒middleFour was deprecated in v2.0.
+Please use comm∧assoc⇒middleFour instead."
+#-}
+identity+middleFour⇒assoc = identity∧middleFour⇒assoc
+{-# WARNING_ON_USAGE identity+middleFour⇒assoc
+"Warning: identity+middleFour⇒assoc was deprecated in v2.0.
+Please use identity∧middleFour⇒assoc instead."
+#-}
+identity+middleFour⇒comm = identity∧middleFour⇒comm
+{-# WARNING_ON_USAGE identity+middleFour⇒comm
+"Warning: identity+middleFour⇒comm was deprecated in v2.0.
+Please use identity∧middleFour⇒comm instead."
+#-}
+comm+distrˡ⇒distrʳ = comm∧distrˡ⇒distrʳ
+{-# WARNING_ON_USAGE comm+distrˡ⇒distrʳ
+"Warning: comm+distrˡ⇒distrʳ was deprecated in v2.0.
+Please use comm∧distrˡ⇒distrʳ instead."
+#-}
+comm+distrʳ⇒distrˡ = comm∧distrʳ⇒distrˡ
+{-# WARNING_ON_USAGE comm+distrʳ⇒distrˡ
+"Warning: comm+distrʳ⇒distrˡ was deprecated in v2.0.
+Please use comm∧distrʳ⇒distrˡ instead."
+#-}
+assoc+distribʳ+idʳ+invʳ⇒zeˡ = assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ
+{-# WARNING_ON_USAGE assoc+distribʳ+idʳ+invʳ⇒zeˡ
+"Warning: assoc+distribʳ+idʳ+invʳ⇒zeˡ was deprecated in v2.0.
+Please use assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ instead."
+#-}
+assoc+distribˡ+idʳ+invʳ⇒zeʳ = assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ
+{-# WARNING_ON_USAGE assoc+distribˡ+idʳ+invʳ⇒zeʳ
+"Warning: assoc+distribˡ+idʳ+invʳ⇒zeʳ was deprecated in v2.0.
+Please use assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ instead."
+#-}
+assoc+id+invʳ⇒invˡ-unique = assoc∧id∧invʳ⇒invˡ-unique
+{-# WARNING_ON_USAGE assoc+id+invʳ⇒invˡ-unique
+"Warning: assoc+id+invʳ⇒invˡ-unique was deprecated in v2.0.
+Please use assoc∧id∧invʳ⇒invˡ-unique instead."
+#-}
+assoc+id+invˡ⇒invʳ-unique = assoc∧id∧invˡ⇒invʳ-unique
+{-# WARNING_ON_USAGE assoc+id+invˡ⇒invʳ-unique
+"Warning: assoc+id+invˡ⇒invʳ-unique was deprecated in v2.0.
+Please use assoc∧id∧invˡ⇒invʳ-unique instead."
+#-}
+subst+comm⇒sym = subst∧comm⇒sym
+{-# WARNING_ON_USAGE subst+comm⇒sym
+"Warning: subst+comm⇒sym was deprecated in v2.0.
+Please use subst∧comm⇒sym instead."
+#-}
diff --git a/src/Algebra/Consequences/Setoid.agda b/src/Algebra/Consequences/Setoid.agda
index c51a6ee8b1..66e441a9e0 100644
--- a/src/Algebra/Consequences/Setoid.agda
+++ b/src/Algebra/Consequences/Setoid.agda
@@ -7,7 +7,10 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; Setoid; Substitutive; Symmetric; Total)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions
+  using (Substitutive; Symmetric; Total)
 
 module Algebra.Consequences.Setoid {a ℓ} (S : Setoid a ℓ) where
 
@@ -15,9 +18,9 @@ open Setoid S renaming (Carrier to A)
 open import Algebra.Core
 open import Algebra.Definitions _≈_
 open import Data.Sum.Base using (inj₁; inj₂)
-open import Data.Product using (_,_)
-open import Function.Base using (_$_)
-import Function.Definitions as FunDefs
+open import Data.Product.Base using (_,_)
+open import Function.Base using (_$_; id; _∘_)
+open import Function.Definitions
 import Relation.Binary.Consequences as Bin
 open import Relation.Binary.Reasoning.Setoid S
 open import Relation.Unary using (Pred)
@@ -30,228 +33,249 @@ open import Relation.Unary using (Pred)
 open import Algebra.Consequences.Base public
 
 ------------------------------------------------------------------------
--- Involutive/SelfInverse functions
+-- MiddleFourExchange
+
+module _ {_∙_ : Op₂ A} (cong : Congruent₂ _∙_) where
+
+  comm∧assoc⇒middleFour : Commutative _∙_ → Associative _∙_ →
+                          _∙_ MiddleFourExchange _∙_
+  comm∧assoc⇒middleFour comm assoc w x y z = begin
+    (w ∙ x) ∙ (y ∙ z) ≈⟨ assoc w x (y ∙ z) ⟩
+    w ∙ (x ∙ (y ∙ z)) ≈⟨ cong refl (sym (assoc x y z)) ⟩
+    w ∙ ((x ∙ y) ∙ z) ≈⟨ cong refl (cong (comm x y) refl) ⟩
+    w ∙ ((y ∙ x) ∙ z) ≈⟨ cong refl (assoc y x z) ⟩
+    w ∙ (y ∙ (x ∙ z)) ≈⟨ sym (assoc w y (x ∙ z)) ⟩
+    (w ∙ y) ∙ (x ∙ z) ∎
+
+  identity∧middleFour⇒assoc : {e : A} → Identity e _∙_ →
+                              _∙_ MiddleFourExchange _∙_ →
+                              Associative _∙_
+  identity∧middleFour⇒assoc {e} (identityˡ , identityʳ) middleFour x y z = begin
+    (x ∙ y) ∙ z       ≈⟨ cong refl (sym (identityˡ z)) ⟩
+    (x ∙ y) ∙ (e ∙ z) ≈⟨ middleFour x y e z ⟩
+    (x ∙ e) ∙ (y ∙ z) ≈⟨ cong (identityʳ x) refl ⟩
+    x ∙ (y ∙ z)       ∎
+
+  identity∧middleFour⇒comm : {_+_ : Op₂ A} {e : A} → Identity e _+_ →
+                             _∙_ MiddleFourExchange _+_ →
+                             Commutative _∙_
+  identity∧middleFour⇒comm {_+_} {e} (identityˡ , identityʳ) middleFour x y
+    = begin
+    x ∙ y             ≈⟨ sym (cong (identityˡ x) (identityʳ y)) ⟩
+    (e + x) ∙ (y + e) ≈⟨ middleFour e x y e ⟩
+    (e + y) ∙ (x + e) ≈⟨ cong (identityˡ y) (identityʳ x) ⟩
+    y ∙ x             ∎
 
-module _ {f : Op₁ A} (inv : Involutive f) where
-
-  open FunDefs _≈_ _≈_
-
-  involutive⇒surjective : Surjective f
-  involutive⇒surjective y = f y , inv y
+------------------------------------------------------------------------
+-- SelfInverse
 
 module _ {f : Op₁ A} (self : SelfInverse f) where
 
   selfInverse⇒involutive : Involutive f
-  selfInverse⇒involutive = reflexive+selfInverse⇒involutive _≈_ refl self
-
-  private
+  selfInverse⇒involutive = reflexive∧selfInverse⇒involutive _≈_ refl self
 
-    inv = selfInverse⇒involutive
-
-  open FunDefs _≈_ _≈_
-
-  selfInverse⇒congruent : Congruent f
+  selfInverse⇒congruent : Congruent _≈_ _≈_ f
   selfInverse⇒congruent {x} {y} x≈y = sym (self (begin
-    f (f x) ≈⟨ inv x ⟩
+    f (f x) ≈⟨ selfInverse⇒involutive x ⟩
     x       ≈⟨ x≈y ⟩
     y       ∎))
 
-  selfInverse⇒inverseᵇ : Inverseᵇ f f
-  selfInverse⇒inverseᵇ = inv , inv
+  selfInverse⇒inverseᵇ : Inverseᵇ _≈_ _≈_ f f
+  selfInverse⇒inverseᵇ = self ∘ sym , self ∘ sym
 
-  selfInverse⇒surjective : Surjective f
-  selfInverse⇒surjective = involutive⇒surjective inv
+  selfInverse⇒surjective : Surjective _≈_ _≈_ f
+  selfInverse⇒surjective y = f y , self ∘ sym
 
-  selfInverse⇒injective : Injective f
+  selfInverse⇒injective : Injective _≈_ _≈_ f
   selfInverse⇒injective {x} {y} x≈y = begin
-    x       ≈˘⟨ self x≈y ⟩
-    f (f y) ≈⟨ inv y ⟩
+    x       ≈⟨ self x≈y ⟨
+    f (f y) ≈⟨ selfInverse⇒involutive y ⟩
     y       ∎
 
-  selfInverse⇒bijective : Bijective f
+  selfInverse⇒bijective : Bijective _≈_ _≈_ f
   selfInverse⇒bijective = selfInverse⇒injective , selfInverse⇒surjective
 
 ------------------------------------------------------------------------
 -- Magma-like structures
 
-module _ {_•_ : Op₂ A} (comm : Commutative _•_) where
+module _ {_∙_ : Op₂ A} (comm : Commutative _∙_) where
 
-  comm+cancelˡ⇒cancelʳ : LeftCancellative _•_ → RightCancellative _•_
-  comm+cancelˡ⇒cancelʳ cancelˡ x y z eq = cancelˡ x y z $ begin
-    x • y ≈⟨ comm x y ⟩
-    y • x ≈⟨ eq ⟩
-    z • x ≈⟨ comm z x ⟩
-    x • z ∎
+  comm∧cancelˡ⇒cancelʳ : LeftCancellative _∙_ → RightCancellative _∙_
+  comm∧cancelˡ⇒cancelʳ cancelˡ x y z eq = cancelˡ x y z $ begin
+    x ∙ y ≈⟨ comm x y ⟩
+    y ∙ x ≈⟨ eq ⟩
+    z ∙ x ≈⟨ comm z x ⟩
+    x ∙ z ∎
 
-  comm+cancelʳ⇒cancelˡ : RightCancellative _•_ → LeftCancellative _•_
-  comm+cancelʳ⇒cancelˡ cancelʳ x y z eq = cancelʳ x y z $ begin
-    y • x ≈⟨ comm y x ⟩
-    x • y ≈⟨ eq ⟩
-    x • z ≈⟨ comm x z ⟩
-    z • x ∎
+  comm∧cancelʳ⇒cancelˡ : RightCancellative _∙_ → LeftCancellative _∙_
+  comm∧cancelʳ⇒cancelˡ cancelʳ x y z eq = cancelʳ x y z $ begin
+    y ∙ x ≈⟨ comm y x ⟩
+    x ∙ y ≈⟨ eq ⟩
+    x ∙ z ≈⟨ comm x z ⟩
+    z ∙ x ∎
 
 ------------------------------------------------------------------------
 -- Monoid-like structures
 
-module _ {_•_ : Op₂ A} (comm : Commutative _•_) {e : A} where
+module _ {_∙_ : Op₂ A} (comm : Commutative _∙_) {e : A} where
 
-  comm+idˡ⇒idʳ : LeftIdentity e _•_ → RightIdentity e _•_
-  comm+idˡ⇒idʳ idˡ x = begin
-    x • e ≈⟨ comm x e ⟩
-    e • x ≈⟨ idˡ x ⟩
+  comm∧idˡ⇒idʳ : LeftIdentity e _∙_ → RightIdentity e _∙_
+  comm∧idˡ⇒idʳ idˡ x = begin
+    x ∙ e ≈⟨ comm x e ⟩
+    e ∙ x ≈⟨ idˡ x ⟩
     x     ∎
 
-  comm+idʳ⇒idˡ : RightIdentity e _•_ → LeftIdentity e _•_
-  comm+idʳ⇒idˡ idʳ x = begin
-    e • x ≈⟨ comm e x ⟩
-    x • e ≈⟨ idʳ x ⟩
+  comm∧idʳ⇒idˡ : RightIdentity e _∙_ → LeftIdentity e _∙_
+  comm∧idʳ⇒idˡ idʳ x = begin
+    e ∙ x ≈⟨ comm e x ⟩
+    x ∙ e ≈⟨ idʳ x ⟩
     x     ∎
 
-  comm+idˡ⇒id : LeftIdentity e _•_ → Identity e _•_
-  comm+idˡ⇒id idˡ = idˡ , comm+idˡ⇒idʳ idˡ
+  comm∧idˡ⇒id : LeftIdentity e _∙_ → Identity e _∙_
+  comm∧idˡ⇒id idˡ = idˡ , comm∧idˡ⇒idʳ idˡ
 
-  comm+idʳ⇒id : RightIdentity e _•_ → Identity e _•_
-  comm+idʳ⇒id idʳ = comm+idʳ⇒idˡ idʳ , idʳ
+  comm∧idʳ⇒id : RightIdentity e _∙_ → Identity e _∙_
+  comm∧idʳ⇒id idʳ = comm∧idʳ⇒idˡ idʳ , idʳ
 
-  comm+zeˡ⇒zeʳ : LeftZero e _•_ → RightZero e _•_
-  comm+zeˡ⇒zeʳ zeˡ x = begin
-    x • e ≈⟨ comm x e ⟩
-    e • x ≈⟨ zeˡ x ⟩
+  comm∧zeˡ⇒zeʳ : LeftZero e _∙_ → RightZero e _∙_
+  comm∧zeˡ⇒zeʳ zeˡ x = begin
+    x ∙ e ≈⟨ comm x e ⟩
+    e ∙ x ≈⟨ zeˡ x ⟩
     e     ∎
 
-  comm+zeʳ⇒zeˡ : RightZero e _•_ → LeftZero e _•_
-  comm+zeʳ⇒zeˡ zeʳ x = begin
-    e • x ≈⟨ comm e x ⟩
-    x • e ≈⟨ zeʳ x ⟩
+  comm∧zeʳ⇒zeˡ : RightZero e _∙_ → LeftZero e _∙_
+  comm∧zeʳ⇒zeˡ zeʳ x = begin
+    e ∙ x ≈⟨ comm e x ⟩
+    x ∙ e ≈⟨ zeʳ x ⟩
     e     ∎
 
-  comm+zeˡ⇒ze : LeftZero e _•_ → Zero e _•_
-  comm+zeˡ⇒ze zeˡ = zeˡ , comm+zeˡ⇒zeʳ zeˡ
+  comm∧zeˡ⇒ze : LeftZero e _∙_ → Zero e _∙_
+  comm∧zeˡ⇒ze zeˡ = zeˡ , comm∧zeˡ⇒zeʳ zeˡ
 
-  comm+zeʳ⇒ze : RightZero e _•_ → Zero e _•_
-  comm+zeʳ⇒ze zeʳ = comm+zeʳ⇒zeˡ zeʳ , zeʳ
+  comm∧zeʳ⇒ze : RightZero e _∙_ → Zero e _∙_
+  comm∧zeʳ⇒ze zeʳ = comm∧zeʳ⇒zeˡ zeʳ , zeʳ
 
-  comm+almostCancelˡ⇒almostCancelʳ : AlmostLeftCancellative e _•_ →
-                                     AlmostRightCancellative e _•_
-  comm+almostCancelˡ⇒almostCancelʳ cancelˡ-nonZero x y z x≉e yx≈zx =
+  comm∧almostCancelˡ⇒almostCancelʳ : AlmostLeftCancellative e _∙_ →
+                                     AlmostRightCancellative e _∙_
+  comm∧almostCancelˡ⇒almostCancelʳ cancelˡ-nonZero x y z x≉e yx≈zx =
     cancelˡ-nonZero x y z x≉e $ begin
-      x • y ≈⟨ comm x y ⟩
-      y • x ≈⟨ yx≈zx ⟩
-      z • x ≈⟨ comm z x ⟩
-      x • z ∎
-
-  comm+almostCancelʳ⇒almostCancelˡ : AlmostRightCancellative e _•_ →
-                                     AlmostLeftCancellative e _•_
-  comm+almostCancelʳ⇒almostCancelˡ cancelʳ-nonZero x y z x≉e xy≈xz =
+      x ∙ y ≈⟨ comm x y ⟩
+      y ∙ x ≈⟨ yx≈zx ⟩
+      z ∙ x ≈⟨ comm z x ⟩
+      x ∙ z ∎
+
+  comm∧almostCancelʳ⇒almostCancelˡ : AlmostRightCancellative e _∙_ →
+                                     AlmostLeftCancellative e _∙_
+  comm∧almostCancelʳ⇒almostCancelˡ cancelʳ-nonZero x y z x≉e xy≈xz =
     cancelʳ-nonZero x y z x≉e $ begin
-      y • x ≈⟨ comm y x ⟩
-      x • y ≈⟨ xy≈xz ⟩
-      x • z ≈⟨ comm x z ⟩
-      z • x ∎
+      y ∙ x ≈⟨ comm y x ⟩
+      x ∙ y ≈⟨ xy≈xz ⟩
+      x ∙ z ≈⟨ comm x z ⟩
+      z ∙ x ∎
 
 ------------------------------------------------------------------------
 -- Group-like structures
 
-module _ {_•_ : Op₂ A} {_⁻¹ : Op₁ A} {e} (comm : Commutative _•_) where
+module _ {_∙_ : Op₂ A} {_⁻¹ : Op₁ A} {e} (comm : Commutative _∙_) where
 
-  comm+invˡ⇒invʳ : LeftInverse e _⁻¹ _•_ → RightInverse e _⁻¹ _•_
-  comm+invˡ⇒invʳ invˡ x = begin
-    x • (x ⁻¹) ≈⟨ comm x (x ⁻¹) ⟩
-    (x ⁻¹) • x ≈⟨ invˡ x ⟩
+  comm∧invˡ⇒invʳ : LeftInverse e _⁻¹ _∙_ → RightInverse e _⁻¹ _∙_
+  comm∧invˡ⇒invʳ invˡ x = begin
+    x ∙ (x ⁻¹) ≈⟨ comm x (x ⁻¹) ⟩
+    (x ⁻¹) ∙ x ≈⟨ invˡ x ⟩
     e          ∎
 
-  comm+invˡ⇒inv : LeftInverse e _⁻¹ _•_ → Inverse e _⁻¹ _•_
-  comm+invˡ⇒inv invˡ = invˡ , comm+invˡ⇒invʳ invˡ
+  comm∧invˡ⇒inv : LeftInverse e _⁻¹ _∙_ → Inverse e _⁻¹ _∙_
+  comm∧invˡ⇒inv invˡ = invˡ , comm∧invˡ⇒invʳ invˡ
 
-  comm+invʳ⇒invˡ : RightInverse e _⁻¹ _•_ → LeftInverse e _⁻¹ _•_
-  comm+invʳ⇒invˡ invʳ x = begin
-    (x ⁻¹) • x ≈⟨ comm (x ⁻¹) x ⟩
-    x • (x ⁻¹) ≈⟨ invʳ x ⟩
+  comm∧invʳ⇒invˡ : RightInverse e _⁻¹ _∙_ → LeftInverse e _⁻¹ _∙_
+  comm∧invʳ⇒invˡ invʳ x = begin
+    (x ⁻¹) ∙ x ≈⟨ comm (x ⁻¹) x ⟩
+    x ∙ (x ⁻¹) ≈⟨ invʳ x ⟩
     e          ∎
 
-  comm+invʳ⇒inv : RightInverse e _⁻¹ _•_ → Inverse e _⁻¹ _•_
-  comm+invʳ⇒inv invʳ = comm+invʳ⇒invˡ invʳ , invʳ
+  comm∧invʳ⇒inv : RightInverse e _⁻¹ _∙_ → Inverse e _⁻¹ _∙_
+  comm∧invʳ⇒inv invʳ = comm∧invʳ⇒invˡ invʳ , invʳ
 
-module _ {_•_ : Op₂ A} {_⁻¹ : Op₁ A} {e} (cong : Congruent₂ _•_) where
+module _ {_∙_ : Op₂ A} {_⁻¹ : Op₁ A} {e} (cong : Congruent₂ _∙_) where
 
-  assoc+id+invʳ⇒invˡ-unique : Associative _•_ →
-                              Identity e _•_ → RightInverse e _⁻¹ _•_ →
-                              ∀ x y → (x • y) ≈ e → x ≈ (y ⁻¹)
-  assoc+id+invʳ⇒invˡ-unique assoc (idˡ , idʳ) invʳ x y eq = begin
+  assoc∧id∧invʳ⇒invˡ-unique : Associative _∙_ →
+                              Identity e _∙_ → RightInverse e _⁻¹ _∙_ →
+                              ∀ x y → (x ∙ y) ≈ e → x ≈ (y ⁻¹)
+  assoc∧id∧invʳ⇒invˡ-unique assoc (idˡ , idʳ) invʳ x y eq = begin
     x                ≈⟨ sym (idʳ x) ⟩
-    x • e            ≈⟨ cong refl (sym (invʳ y)) ⟩
-    x • (y • (y ⁻¹)) ≈⟨ sym (assoc x y (y ⁻¹)) ⟩
-    (x • y) • (y ⁻¹) ≈⟨ cong eq refl ⟩
-    e • (y ⁻¹)       ≈⟨ idˡ (y ⁻¹) ⟩
+    x ∙ e            ≈⟨ cong refl (sym (invʳ y)) ⟩
+    x ∙ (y ∙ (y ⁻¹)) ≈⟨ sym (assoc x y (y ⁻¹)) ⟩
+    (x ∙ y) ∙ (y ⁻¹) ≈⟨ cong eq refl ⟩
+    e ∙ (y ⁻¹)       ≈⟨ idˡ (y ⁻¹) ⟩
     y ⁻¹             ∎
 
-  assoc+id+invˡ⇒invʳ-unique : Associative _•_ →
-                              Identity e _•_ → LeftInverse e _⁻¹ _•_ →
-                              ∀ x y → (x • y) ≈ e → y ≈ (x ⁻¹)
-  assoc+id+invˡ⇒invʳ-unique assoc (idˡ , idʳ) invˡ x y eq = begin
+  assoc∧id∧invˡ⇒invʳ-unique : Associative _∙_ →
+                              Identity e _∙_ → LeftInverse e _⁻¹ _∙_ →
+                              ∀ x y → (x ∙ y) ≈ e → y ≈ (x ⁻¹)
+  assoc∧id∧invˡ⇒invʳ-unique assoc (idˡ , idʳ) invˡ x y eq = begin
     y                ≈⟨ sym (idˡ y) ⟩
-    e • y            ≈⟨ cong (sym (invˡ x)) refl ⟩
-    ((x ⁻¹) • x) • y ≈⟨ assoc (x ⁻¹) x y ⟩
-    (x ⁻¹) • (x • y) ≈⟨ cong refl eq ⟩
-    (x ⁻¹) • e       ≈⟨ idʳ (x ⁻¹) ⟩
+    e ∙ y            ≈⟨ cong (sym (invˡ x)) refl ⟩
+    ((x ⁻¹) ∙ x) ∙ y ≈⟨ assoc (x ⁻¹) x y ⟩
+    (x ⁻¹) ∙ (x ∙ y) ≈⟨ cong refl eq ⟩
+    (x ⁻¹) ∙ e       ≈⟨ idʳ (x ⁻¹) ⟩
     x ⁻¹             ∎
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Bisemigroup-like structures
 
-module _ {_•_ _◦_ : Op₂ A}
+module _ {_∙_ _◦_ : Op₂ A}
          (◦-cong : Congruent₂ _◦_)
-         (•-comm : Commutative _•_)
+         (∙-comm : Commutative _∙_)
          where
 
-  comm+distrˡ⇒distrʳ :  _•_ DistributesOverˡ _◦_ → _•_ DistributesOverʳ _◦_
-  comm+distrˡ⇒distrʳ distrˡ x y z = begin
-    (y ◦ z) • x       ≈⟨ •-comm (y ◦ z) x ⟩
-    x • (y ◦ z)       ≈⟨ distrˡ x y z ⟩
-    (x • y) ◦ (x • z) ≈⟨ ◦-cong (•-comm x y) (•-comm x z) ⟩
-    (y • x) ◦ (z • x) ∎
+  comm∧distrˡ⇒distrʳ :  _∙_ DistributesOverˡ _◦_ → _∙_ DistributesOverʳ _◦_
+  comm∧distrˡ⇒distrʳ distrˡ x y z = begin
+    (y ◦ z) ∙ x       ≈⟨ ∙-comm (y ◦ z) x ⟩
+    x ∙ (y ◦ z)       ≈⟨ distrˡ x y z ⟩
+    (x ∙ y) ◦ (x ∙ z) ≈⟨ ◦-cong (∙-comm x y) (∙-comm x z) ⟩
+    (y ∙ x) ◦ (z ∙ x) ∎
 
-  comm+distrʳ⇒distrˡ : _•_ DistributesOverʳ _◦_ → _•_ DistributesOverˡ _◦_
-  comm+distrʳ⇒distrˡ distrˡ x y z = begin
-    x • (y ◦ z)       ≈⟨ •-comm x (y ◦ z) ⟩
-    (y ◦ z) • x       ≈⟨ distrˡ x y z ⟩
-    (y • x) ◦ (z • x) ≈⟨ ◦-cong (•-comm y x) (•-comm z x) ⟩
-    (x • y) ◦ (x • z) ∎
+  comm∧distrʳ⇒distrˡ : _∙_ DistributesOverʳ _◦_ → _∙_ DistributesOverˡ _◦_
+  comm∧distrʳ⇒distrˡ distrˡ x y z = begin
+    x ∙ (y ◦ z)       ≈⟨ ∙-comm x (y ◦ z) ⟩
+    (y ◦ z) ∙ x       ≈⟨ distrˡ x y z ⟩
+    (y ∙ x) ◦ (z ∙ x) ≈⟨ ◦-cong (∙-comm y x) (∙-comm z x) ⟩
+    (x ∙ y) ◦ (x ∙ z) ∎
 
-  comm+distrˡ⇒distr :  _•_ DistributesOverˡ _◦_ → _•_ DistributesOver _◦_
-  comm+distrˡ⇒distr distrˡ = distrˡ , comm+distrˡ⇒distrʳ distrˡ
+  comm∧distrˡ⇒distr :  _∙_ DistributesOverˡ _◦_ → _∙_ DistributesOver _◦_
+  comm∧distrˡ⇒distr distrˡ = distrˡ , comm∧distrˡ⇒distrʳ distrˡ
 
-  comm+distrʳ⇒distr :  _•_ DistributesOverʳ _◦_ → _•_ DistributesOver _◦_
-  comm+distrʳ⇒distr distrʳ = comm+distrʳ⇒distrˡ distrʳ , distrʳ
+  comm∧distrʳ⇒distr :  _∙_ DistributesOverʳ _◦_ → _∙_ DistributesOver _◦_
+  comm∧distrʳ⇒distr distrʳ = comm∧distrʳ⇒distrˡ distrʳ , distrʳ
 
-  comm⇒sym[distribˡ] : ∀ x → Symmetric (λ y z → (x ◦ (y • z)) ≈ ((x ◦ y) • (x ◦ z)))
+  comm⇒sym[distribˡ] : ∀ x → Symmetric (λ y z → (x ◦ (y ∙ z)) ≈ ((x ◦ y) ∙ (x ◦ z)))
   comm⇒sym[distribˡ] x {y} {z} prf = begin
-    x ◦ (z • y)       ≈⟨ ◦-cong refl (•-comm z y) ⟩
-    x ◦ (y • z)       ≈⟨ prf ⟩
-    (x ◦ y) • (x ◦ z) ≈⟨ •-comm (x ◦ y) (x ◦ z) ⟩
-    (x ◦ z) • (x ◦ y) ∎
+    x ◦ (z ∙ y)       ≈⟨ ◦-cong refl (∙-comm z y) ⟩
+    x ◦ (y ∙ z)       ≈⟨ prf ⟩
+    (x ◦ y) ∙ (x ◦ z) ≈⟨ ∙-comm (x ◦ y) (x ◦ z) ⟩
+    (x ◦ z) ∙ (x ◦ y) ∎
 
 
-module _ {_•_ _◦_ : Op₂ A}
-         (•-cong  : Congruent₂ _•_)
-         (•-assoc : Associative _•_)
+module _ {_∙_ _◦_ : Op₂ A}
+         (∙-cong  : Congruent₂ _∙_)
+         (∙-assoc : Associative _∙_)
          (◦-comm  : Commutative _◦_)
          where
 
-  distrib+absorbs⇒distribˡ : _•_ Absorbs _◦_ →
-                             _◦_ Absorbs _•_ →
-                             _◦_ DistributesOver _•_ →
-                             _•_ DistributesOverˡ _◦_
-  distrib+absorbs⇒distribˡ •-absorbs-◦ ◦-absorbs-• (◦-distribˡ-• , ◦-distribʳ-•) x y z = begin
-    x • (y ◦ z)                    ≈˘⟨ •-cong (•-absorbs-◦ _ _) refl ⟩
-    (x • (x ◦ y)) • (y ◦ z)        ≈⟨  •-cong (•-cong refl (◦-comm _ _)) refl ⟩
-    (x • (y ◦ x)) • (y ◦ z)        ≈⟨  •-assoc _ _ _ ⟩
-    x • ((y ◦ x) • (y ◦ z))        ≈˘⟨ •-cong refl (◦-distribˡ-• _ _ _) ⟩
-    x • (y ◦ (x • z))              ≈˘⟨ •-cong (◦-absorbs-• _ _) refl ⟩
-    (x ◦ (x • z)) • (y ◦ (x • z))  ≈˘⟨ ◦-distribʳ-• _ _ _ ⟩
-    (x • y) ◦ (x • z)              ∎
-
-----------------------------------------------------------------------
+  distrib∧absorbs⇒distribˡ : _∙_ Absorbs _◦_ →
+                             _◦_ Absorbs _∙_ →
+                             _◦_ DistributesOver _∙_ →
+                             _∙_ DistributesOverˡ _◦_
+  distrib∧absorbs⇒distribˡ ∙-absorbs-◦ ◦-absorbs-∙ (◦-distribˡ-∙ , ◦-distribʳ-∙) x y z = begin
+    x ∙ (y ◦ z)                    ≈⟨ ∙-cong (∙-absorbs-◦ _ _) refl ⟨
+    (x ∙ (x ◦ y)) ∙ (y ◦ z)        ≈⟨  ∙-cong (∙-cong refl (◦-comm _ _)) refl ⟩
+    (x ∙ (y ◦ x)) ∙ (y ◦ z)        ≈⟨  ∙-assoc _ _ _ ⟩
+    x ∙ ((y ◦ x) ∙ (y ◦ z))        ≈⟨ ∙-cong refl (◦-distribˡ-∙ _ _ _) ⟨
+    x ∙ (y ◦ (x ∙ z))              ≈⟨ ∙-cong (◦-absorbs-∙ _ _) refl ⟨
+    (x ◦ (x ∙ z)) ∙ (y ◦ (x ∙ z))  ≈⟨ ◦-distribʳ-∙ _ _ _ ⟨
+    (x ∙ y) ◦ (x ∙ z)              ∎
+
+------------------------------------------------------------------------
 -- Ring-like structures
 
 module _ {_+_ _*_ : Op₂ A}
@@ -260,10 +284,10 @@ module _ {_+_ _*_ : Op₂ A}
          (*-cong : Congruent₂ _*_)
          where
 
-  assoc+distribʳ+idʳ+invʳ⇒zeˡ : Associative _+_ → _*_ DistributesOverʳ _+_ →
+  assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ : Associative _+_ → _*_ DistributesOverʳ _+_ →
                                 RightIdentity 0# _+_ → RightInverse 0# _⁻¹ _+_ →
                                 LeftZero 0# _*_
-  assoc+distribʳ+idʳ+invʳ⇒zeˡ +-assoc distribʳ idʳ invʳ  x = begin
+  assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ +-assoc distribʳ idʳ invʳ  x = begin
     0# * x                                 ≈⟨ sym (idʳ _) ⟩
     (0# * x) + 0#                          ≈⟨ +-cong refl (sym (invʳ _)) ⟩
     (0# * x) + ((0# * x)  + ((0# * x)⁻¹))  ≈⟨ sym (+-assoc _ _ _) ⟩
@@ -272,10 +296,10 @@ module _ {_+_ _*_ : Op₂ A}
     (0# * x) + ((0# * x)⁻¹)                ≈⟨ invʳ _ ⟩
     0#                                     ∎
 
-  assoc+distribˡ+idʳ+invʳ⇒zeʳ : Associative _+_ → _*_ DistributesOverˡ _+_ →
+  assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ : Associative _+_ → _*_ DistributesOverˡ _+_ →
                                 RightIdentity 0# _+_ → RightInverse 0# _⁻¹ _+_ →
                                 RightZero 0# _*_
-  assoc+distribˡ+idʳ+invʳ⇒zeʳ +-assoc distribˡ idʳ invʳ  x = begin
+  assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ +-assoc distribˡ idʳ invʳ  x = begin
      x * 0#                                ≈⟨ sym (idʳ _) ⟩
      (x * 0#) + 0#                         ≈⟨ +-cong refl (sym (invʳ _)) ⟩
      (x * 0#) + ((x * 0#) + ((x * 0#)⁻¹))  ≈⟨ sym (+-assoc _ _ _) ⟩
@@ -292,10 +316,130 @@ module _ {p} {f : Op₂ A} {P : Pred A p}
          (comm : Commutative f)
          where
 
-  subst+comm⇒sym : Symmetric (λ a b → P (f a b))
-  subst+comm⇒sym = ≈-subst P (comm _ _)
+  subst∧comm⇒sym : Symmetric (λ a b → P (f a b))
+  subst∧comm⇒sym = ≈-subst P (comm _ _)
 
   wlog : ∀ {r} {_R_ : Rel _ r} → Total _R_ →
          (∀ a b → a R b → P (f a b)) →
          ∀ a b → P (f a b)
-  wlog r-total = Bin.wlog r-total subst+comm⇒sym
+  wlog r-total = Bin.wlog r-total subst∧comm⇒sym
+
+
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
+
+comm+assoc⇒middleFour = comm∧assoc⇒middleFour
+{-# WARNING_ON_USAGE comm+assoc⇒middleFour
+"Warning: comm+assoc⇒middleFour was deprecated in v2.0.
+Please use comm∧assoc⇒middleFour instead."
+#-}
+identity+middleFour⇒assoc = identity∧middleFour⇒assoc
+{-# WARNING_ON_USAGE identity+middleFour⇒assoc
+"Warning: identity+middleFour⇒assoc was deprecated in v2.0.
+Please use identity∧middleFour⇒assoc instead."
+#-}
+identity+middleFour⇒comm = identity∧middleFour⇒comm
+{-# WARNING_ON_USAGE identity+middleFour⇒comm
+"Warning: identity+middleFour⇒comm was deprecated in v2.0.
+Please use identity∧middleFour⇒comm instead."
+#-}
+comm+cancelˡ⇒cancelʳ = comm∧cancelˡ⇒cancelʳ
+{-# WARNING_ON_USAGE comm+cancelˡ⇒cancelʳ
+"Warning: comm+cancelˡ⇒cancelʳ was deprecated in v2.0.
+Please use comm∧cancelˡ⇒cancelʳ instead."
+#-}
+comm+cancelʳ⇒cancelˡ = comm∧cancelʳ⇒cancelˡ
+{-# WARNING_ON_USAGE comm+cancelʳ⇒cancelˡ
+"Warning: comm+cancelʳ⇒cancelˡ was deprecated in v2.0.
+Please use comm∧cancelʳ⇒cancelˡ instead."
+#-}
+comm+idˡ⇒idʳ = comm∧idˡ⇒idʳ
+{-# WARNING_ON_USAGE comm+idˡ⇒idʳ
+"Warning: comm+idˡ⇒idʳ was deprecated in v2.0.
+Please use comm∧idˡ⇒idʳ instead."
+#-}
+comm+idʳ⇒idˡ = comm∧idʳ⇒idˡ
+{-# WARNING_ON_USAGE comm+idʳ⇒idˡ
+"Warning: comm+idʳ⇒idˡ was deprecated in v2.0.
+Please use comm∧idʳ⇒idˡ instead."
+#-}
+comm+zeˡ⇒zeʳ = comm∧zeˡ⇒zeʳ
+{-# WARNING_ON_USAGE comm+zeˡ⇒zeʳ
+"Warning: comm+zeˡ⇒zeʳ was deprecated in v2.0.
+Please use comm∧zeˡ⇒zeʳ instead."
+#-}
+comm+zeʳ⇒zeˡ = comm∧zeʳ⇒zeˡ
+{-# WARNING_ON_USAGE comm+zeʳ⇒zeˡ
+"Warning: comm+zeʳ⇒zeˡ was deprecated in v2.0.
+Please use comm∧zeʳ⇒zeˡ instead."
+#-}
+comm+almostCancelˡ⇒almostCancelʳ = comm∧almostCancelˡ⇒almostCancelʳ
+{-# WARNING_ON_USAGE comm+almostCancelˡ⇒almostCancelʳ
+"Warning: comm+almostCancelˡ⇒almostCancelʳ was deprecated in v2.0.
+Please use comm∧almostCancelˡ⇒almostCancelʳ instead."
+#-}
+comm+almostCancelʳ⇒almostCancelˡ = comm∧almostCancelʳ⇒almostCancelˡ
+{-# WARNING_ON_USAGE comm+almostCancelʳ⇒almostCancelˡ
+"Warning: comm+almostCancelʳ⇒almostCancelˡ was deprecated in v2.0.
+Please use comm∧almostCancelʳ⇒almostCancelˡ instead."
+#-}
+comm+invˡ⇒invʳ = comm∧invˡ⇒invʳ
+{-# WARNING_ON_USAGE comm+invˡ⇒invʳ
+"Warning: comm+invˡ⇒invʳ was deprecated in v2.0.
+Please use comm∧invˡ⇒invʳ instead."
+#-}
+comm+invʳ⇒invˡ = comm∧invʳ⇒invˡ
+{-# WARNING_ON_USAGE comm+invʳ⇒invˡ
+"Warning: comm+invʳ⇒invˡ was deprecated in v2.0.
+Please use comm∧invʳ⇒invˡ instead."
+#-}
+comm+invˡ⇒inv = comm∧invˡ⇒inv
+{-# WARNING_ON_USAGE comm+invˡ⇒inv
+"Warning: comm+invˡ⇒inv was deprecated in v2.0.
+Please use comm∧invˡ⇒inv instead."
+#-}
+comm+invʳ⇒inv = comm∧invʳ⇒inv
+{-# WARNING_ON_USAGE comm+invʳ⇒inv
+"Warning: comm+invʳ⇒inv was deprecated in v2.0.
+Please use comm∧invʳ⇒inv instead."
+#-}
+comm+distrˡ⇒distrʳ = comm∧distrˡ⇒distrʳ
+{-# WARNING_ON_USAGE comm+distrˡ⇒distrʳ
+"Warning: comm+distrˡ⇒distrʳ was deprecated in v2.0.
+Please use comm∧distrˡ⇒distrʳ instead."
+#-}
+comm+distrʳ⇒distrˡ = comm∧distrʳ⇒distrˡ
+{-# WARNING_ON_USAGE comm+distrʳ⇒distrˡ
+"Warning: comm+distrʳ⇒distrˡ was deprecated in v2.0.
+Please use comm∧distrʳ⇒distrˡ instead."
+#-}
+assoc+distribʳ+idʳ+invʳ⇒zeˡ = assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ
+{-# WARNING_ON_USAGE assoc+distribʳ+idʳ+invʳ⇒zeˡ
+"Warning: assoc+distribʳ+idʳ+invʳ⇒zeˡ was deprecated in v2.0.
+Please use assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ instead."
+#-}
+assoc+distribˡ+idʳ+invʳ⇒zeʳ = assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ
+{-# WARNING_ON_USAGE assoc+distribˡ+idʳ+invʳ⇒zeʳ
+"Warning: assoc+distribˡ+idʳ+invʳ⇒zeʳ was deprecated in v2.0.
+Please use assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ instead."
+#-}
+assoc+id+invʳ⇒invˡ-unique = assoc∧id∧invʳ⇒invˡ-unique
+{-# WARNING_ON_USAGE assoc+id+invʳ⇒invˡ-unique
+"Warning: assoc+id+invʳ⇒invˡ-unique was deprecated in v2.0.
+Please use assoc∧id∧invʳ⇒invˡ-unique instead."
+#-}
+assoc+id+invˡ⇒invʳ-unique = assoc∧id∧invˡ⇒invʳ-unique
+{-# WARNING_ON_USAGE assoc+id+invˡ⇒invʳ-unique
+"Warning: assoc+id+invˡ⇒invʳ-unique was deprecated in v2.0.
+Please use assoc∧id∧invˡ⇒invʳ-unique instead."
+#-}
+subst+comm⇒sym = subst∧comm⇒sym
+{-# WARNING_ON_USAGE subst+comm⇒sym
+"Warning: subst+comm⇒sym was deprecated in v2.0.
+Please use subst∧comm⇒sym instead."
+#-}
diff --git a/src/Algebra/Construct/Add/Identity.agda b/src/Algebra/Construct/Add/Identity.agda
index 750c69523e..dc82a1c67b 100644
--- a/src/Algebra/Construct/Add/Identity.agda
+++ b/src/Algebra/Construct/Add/Identity.agda
@@ -14,7 +14,7 @@ open import Algebra.Core using (Op₂)
 open import Algebra.Definitions
 open import Algebra.Structures
 open import Relation.Binary.Construct.Add.Point.Equality renaming (_≈∙_ to lift≈)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Level using (Level; _⊔_)
 open import Relation.Binary.Core
 open import Relation.Binary.Definitions
diff --git a/src/Algebra/Construct/DirectProduct.agda b/src/Algebra/Construct/DirectProduct.agda
index 7722662114..3c0ec699ee 100644
--- a/src/Algebra/Construct/DirectProduct.agda
+++ b/src/Algebra/Construct/DirectProduct.agda
@@ -16,7 +16,7 @@
 module Algebra.Construct.DirectProduct where
 
 open import Algebra
-open import Data.Product
+open import Data.Product.Base using (_×_; zip; _,_; map; _<*>_; uncurry)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent
 open import Level using (Level; _⊔_)
 
@@ -61,6 +61,16 @@ rawSemiring R S = record
   ; 1#      = R.1# , S.1#
   } where module R = RawSemiring R; module S = RawSemiring S
 
+rawRingWithoutOne : RawRingWithoutOne a ℓ₁ → RawRingWithoutOne b ℓ₂ → RawRingWithoutOne (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+rawRingWithoutOne R S = record
+  { Carrier = R.Carrier × S.Carrier
+  ; _≈_     = Pointwise R._≈_ S._≈_
+  ; _+_     = zip R._+_ S._+_
+  ; _*_     = zip R._*_ S._*_
+  ; -_      = map R.-_ S.-_
+  ; 0#      = R.0# , S.0#
+  } where module R = RawRingWithoutOne R; module S = RawRingWithoutOne S
+
 rawRing : RawRing a ℓ₁ → RawRing b ℓ₂ → RawRing (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
 rawRing R S = record
   { Carrier = R.Carrier × S.Carrier
@@ -317,6 +327,57 @@ kleeneAlgebra K L = record
       }
   } where module K = KleeneAlgebra K;  module L = KleeneAlgebra L
 
+ringWithoutOne : RingWithoutOne a ℓ₁ → RingWithoutOne b ℓ₂ → RingWithoutOne (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+ringWithoutOne R S = record
+  { isRingWithoutOne = record
+      { +-isAbelianGroup = AbelianGroup.isAbelianGroup ((abelianGroup R.+-abelianGroup S.+-abelianGroup))
+      ; *-cong           = Semigroup.∙-cong (semigroup R.*-semigroup S.*-semigroup)
+      ; *-assoc          = Semigroup.assoc (semigroup R.*-semigroup S.*-semigroup)
+      ; distrib          = (λ x y z → (R.distribˡ , S.distribˡ) <*> x <*> y <*> z)
+                            , (λ x y z → (R.distribʳ , S.distribʳ) <*> x <*> y <*> z)
+      }
+
+  } where module R = RingWithoutOne R; module S = RingWithoutOne S
+
+nonAssociativeRing : NonAssociativeRing a ℓ₁ → NonAssociativeRing b ℓ₂ → NonAssociativeRing (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+nonAssociativeRing R S = record
+  { isNonAssociativeRing = record
+      { +-isAbelianGroup = AbelianGroup.isAbelianGroup ((abelianGroup R.+-abelianGroup S.+-abelianGroup))
+      ; *-cong           = UnitalMagma.∙-cong (unitalMagma R.*-unitalMagma S.*-unitalMagma)
+      ; *-identity       = UnitalMagma.identity (unitalMagma R.*-unitalMagma S.*-unitalMagma)
+      ; distrib          = (λ x y z → (R.distribˡ , S.distribˡ) <*> x <*> y <*> z)
+                            , (λ x y z → (R.distribʳ , S.distribʳ) <*> x <*> y <*> z)
+      ; zero             = uncurry (λ x y → R.zeroˡ x , S.zeroˡ y)
+                            , uncurry (λ x y → R.zeroʳ x , S.zeroʳ y)
+      }
+
+  } where module R = NonAssociativeRing R; module S = NonAssociativeRing S
+
+quasiring : Quasiring a ℓ₁ → Quasiring b ℓ₂ → Quasiring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+quasiring R S = record
+  { isQuasiring = record
+      { +-isMonoid = Monoid.isMonoid ((monoid R.+-monoid S.+-monoid))
+      ; *-cong           = Monoid.∙-cong (monoid R.*-monoid S.*-monoid)
+      ; *-assoc          = Monoid.assoc (monoid R.*-monoid S.*-monoid)
+      ; *-identity       = Monoid.identity ((monoid R.*-monoid S.*-monoid))
+      ; distrib          = (λ x y z → (R.distribˡ , S.distribˡ) <*> x <*> y <*> z)
+                            , (λ x y z → (R.distribʳ , S.distribʳ) <*> x <*> y <*> z)
+      ; zero             = uncurry (λ x y → R.zeroˡ x , S.zeroˡ y)
+                            , uncurry (λ x y → R.zeroʳ x , S.zeroʳ y)
+      }
+
+  } where module R = Quasiring R; module S = Quasiring S
+
+nearring : Nearring a ℓ₁ → Nearring b ℓ₂ → Nearring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
+nearring R S =  record
+  { isNearring = record
+      { isQuasiring = Quasiring.isQuasiring (quasiring R.quasiring S.quasiring)
+      ; +-inverse   = (λ x → (R.+-inverseˡ , S.+-inverseˡ) <*> x)
+                      , (λ x → (R.+-inverseʳ , S.+-inverseʳ) <*> x)
+      ; ⁻¹-cong     = map R.⁻¹-cong S.⁻¹-cong
+      }
+  } where module R = Nearring R; module S = Nearring S
+
 ring : Ring a ℓ₁ → Ring b ℓ₂ → Ring (a ⊔ b) (ℓ₁ ⊔ ℓ₂)
 ring R S = record
   { -_     = uncurry (λ x y → R.-_ x , S.-_ y)
@@ -326,7 +387,6 @@ ring R S = record
       ; *-assoc          = Semiring.*-assoc Semi
       ; *-identity       = Semiring.*-identity Semi
       ; distrib          = Semiring.distrib Semi
-      ; zero             = Semiring.zero Semi
       }
   }
   where
diff --git a/src/Algebra/Construct/Flip/Op.agda b/src/Algebra/Construct/Flip/Op.agda
index f5d86e7714..dd139e4ba1 100644
--- a/src/Algebra/Construct/Flip/Op.agda
+++ b/src/Algebra/Construct/Flip/Op.agda
@@ -9,13 +9,9 @@
 
 module Algebra.Construct.Flip.Op where
 
-open import Algebra.Core
-open import Algebra.Bundles
-import Algebra.Definitions as Def
-import Algebra.Structures as Str
-import Algebra.Consequences.Setoid as Consequences
-import Data.Product as Prod
-import Data.Sum as Sum
+open import Algebra
+import Data.Product.Base as Product
+import Data.Sum.Base as Sum
 open import Function.Base using (flip)
 open import Level using (Level)
 open import Relation.Binary.Core using (Rel; _Preserves₂_⟶_⟶_)
@@ -37,272 +33,136 @@ preserves₂ : (∼ ≈ ≋ : Rel A ℓ) →
              ∙ Preserves₂ ∼ ⟶ ≈ ⟶ ≋ → (flip ∙) Preserves₂ ≈ ⟶ ∼ ⟶ ≋
 preserves₂ _ _ _ pres = flip pres
 
-module ∙-Properties (≈ : Rel A ℓ) (∙ : Op₂ A) where
+module _ (≈ : Rel A ℓ) (∙ : Op₂ A) where
 
-  open Def ≈
-
-  associative : Symmetric ≈ → Associative ∙ → Associative (flip ∙)
+  associative : Symmetric ≈ → Associative ≈ ∙ → Associative ≈ (flip ∙)
   associative sym assoc x y z = sym (assoc z y x)
 
-  identity : Identity ε ∙ → Identity ε (flip ∙)
-  identity id = Prod.swap id
+  identity : Identity ≈ ε ∙ → Identity ≈ ε (flip ∙)
+  identity id = Product.swap id
 
-  commutative : Commutative ∙ → Commutative (flip ∙)
+  commutative : Commutative ≈ ∙ → Commutative ≈ (flip ∙)
   commutative comm = flip comm
 
-  selective : Selective ∙ → Selective (flip ∙)
+  selective : Selective ≈ ∙ → Selective ≈ (flip ∙)
   selective sel x y = Sum.swap (sel y x)
 
-  idempotent : Idempotent ∙ → Idempotent (flip ∙)
+  idempotent : Idempotent ≈ ∙ → Idempotent ≈ (flip ∙)
   idempotent idem = idem
 
-  inverse : Inverse ε ⁻¹ ∙ → Inverse ε ⁻¹ (flip ∙)
-  inverse inv = Prod.swap inv
-
-  zero : Zero ε ∙ → Zero ε (flip ∙)
-  zero zer = Prod.swap zer
-
-module *-Properties (≈ : Rel A ℓ) (* + : Op₂ A) where
-
-  open Def ≈
-
-  distributes : * DistributesOver + → (flip *) DistributesOver +
-  distributes distrib = Prod.swap distrib
+  inverse : Inverse ≈ ε ⁻¹ ∙ → Inverse ≈ ε ⁻¹ (flip ∙)
+  inverse inv = Product.swap inv
 
 ------------------------------------------------------------------------
 -- Structures
 
 module _ {≈ : Rel A ℓ} {∙ : Op₂ A} where
 
-  open Def ≈
-  open Str ≈
-  open ∙-Properties ≈ ∙
-
-  isMagma : IsMagma ∙ → IsMagma (flip ∙)
+  isMagma : IsMagma ≈ ∙ → IsMagma ≈ (flip ∙)
   isMagma m = record
     { isEquivalence = isEquivalence
     ; ∙-cong        = preserves₂ ≈ ≈ ≈ ∙-cong
     }
     where open IsMagma m
 
-  isSelectiveMagma : IsSelectiveMagma ∙ → IsSelectiveMagma (flip ∙)
+  isSelectiveMagma : IsSelectiveMagma ≈ ∙ → IsSelectiveMagma ≈ (flip ∙)
   isSelectiveMagma m = record
     { isMagma = isMagma m.isMagma
-    ; sel     = selective m.sel
+    ; sel     = selective ≈ ∙ m.sel
     }
     where module m = IsSelectiveMagma m
 
-  isCommutativeMagma : IsCommutativeMagma ∙ → IsCommutativeMagma (flip ∙)
+  isCommutativeMagma : IsCommutativeMagma ≈ ∙ → IsCommutativeMagma ≈ (flip ∙)
   isCommutativeMagma m = record
     { isMagma = isMagma m.isMagma
-    ; comm    = commutative m.comm
+    ; comm    = commutative ≈ ∙ m.comm
     }
     where module m = IsCommutativeMagma m
 
-  isSemigroup : IsSemigroup ∙ → IsSemigroup (flip ∙)
+  isSemigroup : IsSemigroup ≈ ∙ → IsSemigroup ≈ (flip ∙)
   isSemigroup s = record
     { isMagma = isMagma s.isMagma
-    ; assoc   = associative s.sym s.assoc
+    ; assoc   = associative ≈ ∙ s.sym s.assoc
     }
     where module s = IsSemigroup s
 
-  isBand : IsBand ∙ → IsBand (flip ∙)
+  isBand : IsBand ≈ ∙ → IsBand ≈ (flip ∙)
   isBand b = record
     { isSemigroup = isSemigroup b.isSemigroup
     ; idem        = b.idem
     }
     where module b = IsBand b
 
-  isCommutativeSemigroup : IsCommutativeSemigroup ∙ →
-                           IsCommutativeSemigroup (flip ∙)
+  isCommutativeSemigroup : IsCommutativeSemigroup ≈ ∙ →
+                           IsCommutativeSemigroup ≈ (flip ∙)
   isCommutativeSemigroup s = record
     { isSemigroup = isSemigroup s.isSemigroup
-    ; comm        = commutative s.comm
+    ; comm        = commutative ≈ ∙ s.comm
     }
     where module s = IsCommutativeSemigroup s
 
-  isUnitalMagma : IsUnitalMagma ∙ ε → IsUnitalMagma (flip ∙) ε
+  isUnitalMagma : IsUnitalMagma ≈ ∙ ε → IsUnitalMagma ≈ (flip ∙) ε
   isUnitalMagma m = record
     { isMagma  = isMagma m.isMagma
-    ; identity = identity m.identity
+    ; identity = identity ≈ ∙ m.identity
     }
     where module m = IsUnitalMagma m
 
-  isMonoid : IsMonoid ∙ ε → IsMonoid (flip ∙) ε
+  isMonoid : IsMonoid ≈ ∙ ε → IsMonoid ≈ (flip ∙) ε
   isMonoid m = record
     { isSemigroup = isSemigroup m.isSemigroup
-    ; identity    = identity m.identity
+    ; identity    = identity ≈ ∙ m.identity
     }
     where module m = IsMonoid m
 
-  isCommutativeMonoid : IsCommutativeMonoid ∙ ε →
-                        IsCommutativeMonoid (flip ∙) ε
+  isCommutativeMonoid : IsCommutativeMonoid ≈ ∙ ε →
+                        IsCommutativeMonoid ≈ (flip ∙) ε
   isCommutativeMonoid m = record
     { isMonoid = isMonoid m.isMonoid
-    ; comm     = commutative m.comm
+    ; comm     = commutative ≈ ∙ m.comm
     }
     where module m = IsCommutativeMonoid m
 
-  isIdempotentCommutativeMonoid : IsIdempotentCommutativeMonoid ∙ ε →
-                                  IsIdempotentCommutativeMonoid (flip ∙) ε
+  isIdempotentCommutativeMonoid : IsIdempotentCommutativeMonoid ≈ ∙ ε →
+                                  IsIdempotentCommutativeMonoid ≈ (flip ∙) ε
   isIdempotentCommutativeMonoid m = record
     { isCommutativeMonoid = isCommutativeMonoid m.isCommutativeMonoid
-    ; idem                = idempotent m.idem
+    ; idem                = idempotent ≈ ∙ m.idem
     }
     where module m = IsIdempotentCommutativeMonoid m
 
-  isInvertibleMagma : IsInvertibleMagma ∙ ε ⁻¹ →
-                      IsInvertibleMagma (flip ∙) ε ⁻¹
+  isInvertibleMagma : IsInvertibleMagma ≈ ∙ ε ⁻¹ →
+                      IsInvertibleMagma ≈ (flip ∙) ε ⁻¹
   isInvertibleMagma m = record
     { isMagma = isMagma m.isMagma
-    ; inverse = inverse m.inverse
+    ; inverse = inverse ≈ ∙ m.inverse
     ; ⁻¹-cong = m.⁻¹-cong
     }
     where module m = IsInvertibleMagma m
 
-  isInvertibleUnitalMagma : IsInvertibleUnitalMagma ∙ ε ⁻¹ →
-                            IsInvertibleUnitalMagma (flip ∙) ε ⁻¹
+  isInvertibleUnitalMagma : IsInvertibleUnitalMagma ≈ ∙ ε ⁻¹ →
+                            IsInvertibleUnitalMagma ≈ (flip ∙) ε ⁻¹
   isInvertibleUnitalMagma m = record
     { isInvertibleMagma = isInvertibleMagma m.isInvertibleMagma
-    ; identity          = identity m.identity
+    ; identity          = identity ≈ ∙ m.identity
     }
     where module m = IsInvertibleUnitalMagma m
 
-  isGroup : IsGroup ∙ ε ⁻¹ → IsGroup (flip ∙) ε ⁻¹
+  isGroup : IsGroup ≈ ∙ ε ⁻¹ → IsGroup ≈ (flip ∙) ε ⁻¹
   isGroup g = record
     { isMonoid = isMonoid g.isMonoid
-    ; inverse  = inverse g.inverse
+    ; inverse  = inverse ≈ ∙ g.inverse
     ; ⁻¹-cong  = g.⁻¹-cong
     }
     where module g = IsGroup g
 
-  isAbelianGroup : IsAbelianGroup ∙ ε ⁻¹ → IsAbelianGroup (flip ∙) ε ⁻¹
+  isAbelianGroup : IsAbelianGroup ≈ ∙ ε ⁻¹ → IsAbelianGroup ≈ (flip ∙) ε ⁻¹
   isAbelianGroup g = record
     { isGroup = isGroup g.isGroup
-    ; comm    = commutative g.comm
+    ; comm    = commutative ≈ ∙ g.comm
     }
     where module g = IsAbelianGroup g
 
-module _ {≈ : Rel A ℓ} {+ * : Op₂ A} {0# 1# : A} where
-
-  open Str ≈
-  open ∙-Properties ≈ *
-  open *-Properties ≈ * +
-
-  isSemiringWithoutAnnihilatingZero : IsSemiringWithoutAnnihilatingZero + * 0# 1# →
-                                      IsSemiringWithoutAnnihilatingZero + (flip *) 0# 1#
-  isSemiringWithoutAnnihilatingZero r = record
-    { +-isCommutativeMonoid = r.+-isCommutativeMonoid
-    ; *-cong = preserves₂ ≈ ≈ ≈ r.*-cong
-    ; *-assoc = associative r.sym r.*-assoc
-    ; *-identity = identity r.*-identity
-    ; distrib = distributes r.distrib
-    }
-    where module r = IsSemiringWithoutAnnihilatingZero r
-
-  isSemiring : IsSemiring + * 0# 1# → IsSemiring + (flip *) 0# 1#
-  isSemiring r = record
-    { isSemiringWithoutAnnihilatingZero = isSemiringWithoutAnnihilatingZero r.isSemiringWithoutAnnihilatingZero
-    ; zero = zero r.zero
-    }
-    where module r = IsSemiring r
-
-  isCommutativeSemiring : IsCommutativeSemiring + * 0# 1# →
-                          IsCommutativeSemiring + (flip *) 0# 1#
-  isCommutativeSemiring r = record
-    { isSemiring = isSemiring r.isSemiring
-    ; *-comm = commutative r.*-comm
-    }
-    where module r = IsCommutativeSemiring r
-
-  isCancellativeCommutativeSemiring : IsCancellativeCommutativeSemiring + * 0# 1# →
-                                      IsCancellativeCommutativeSemiring + (flip *) 0# 1#
-  isCancellativeCommutativeSemiring r = record
-    { isCommutativeSemiring = isCommutativeSemiring r.isCommutativeSemiring
-    ; *-cancelˡ-nonZero = Consequences.comm+almostCancelˡ⇒almostCancelʳ r.setoid r.*-comm r.*-cancelˡ-nonZero
-    }
-    where module r = IsCancellativeCommutativeSemiring r
-
-  isIdempotentSemiring : IsIdempotentSemiring + * 0# 1# →
-                         IsIdempotentSemiring + (flip *) 0# 1#
-  isIdempotentSemiring r = record
-    { isSemiring = isSemiring r.isSemiring
-    ; +-idem = r.+-idem
-    }
-    where module r = IsIdempotentSemiring r
-
-  isQuasiring : IsQuasiring + * 0# 1# → IsQuasiring + (flip *) 0# 1#
-  isQuasiring r = record
-    { +-isMonoid = r.+-isMonoid
-    ; *-cong = preserves₂ ≈ ≈ ≈ r.*-cong
-    ; *-assoc = associative r.sym r.*-assoc
-    ; *-identity = identity r.*-identity
-    ; distrib = distributes r.distrib
-    ; zero = zero r.zero
-    }
-    where module r = IsQuasiring r
-
-module _ {≈ : Rel A ℓ} {+ * : Op₂ A} { - : Op₁ A} {0# : A} where
-
-  open Str ≈
-  open ∙-Properties ≈ *
-  open *-Properties ≈ * +
-
-  isRingWithoutOne : IsRingWithoutOne + * - 0# → IsRingWithoutOne + (flip *) - 0#
-  isRingWithoutOne r = record
-    { +-isAbelianGroup = r.+-isAbelianGroup
-    ; *-cong = preserves₂ ≈ ≈ ≈ r.*-cong
-    ; *-assoc = associative r.sym r.*-assoc
-    ; distrib = distributes r.distrib
-    ; zero = zero r.zero
-    }
-    where module r = IsRingWithoutOne r
-
-module _ {≈ : Rel A ℓ} {+ * : Op₂ A} { - : Op₁ A} {0# 1# : A} where
-
-  open Str ≈
-  open ∙-Properties ≈ *
-  open *-Properties ≈ * +
-
-  isNonAssociativeRing : IsNonAssociativeRing + * - 0# 1# →
-                         IsNonAssociativeRing + (flip *) - 0# 1#
-  isNonAssociativeRing r = record
-    { +-isAbelianGroup = r.+-isAbelianGroup
-    ; *-cong = preserves₂ ≈ ≈ ≈ r.*-cong
-    ; identity = identity r.identity
-    ; distrib = distributes r.distrib
-    ; zero = zero r.zero
-    }
-    where module r = IsNonAssociativeRing r
-
-  isNearring : IsNearring + * 0# 1# - → IsNearring + (flip *) 0# 1# -
-  isNearring r = record
-    { isQuasiring = isQuasiring r.isQuasiring
-    ; +-inverse = r.+-inverse
-    ; ⁻¹-cong = r.⁻¹-cong
-    }
-    where module r = IsNearring r
-
-  isRing : IsRing + * - 0# 1# → IsRing + (flip *) - 0# 1#
-  isRing r = record
-    { +-isAbelianGroup = r.+-isAbelianGroup
-    ; *-cong = preserves₂ ≈ ≈ ≈ r.*-cong
-    ; *-assoc = associative r.sym r.*-assoc
-    ; *-identity = identity r.*-identity
-    ; distrib = distributes r.distrib
-    ; zero = zero r.zero
-    }
-    where module r = IsRing r
-
-  isCommutativeRing : IsCommutativeRing + * - 0# 1# →
-                      IsCommutativeRing + (flip *) - 0# 1#
-  isCommutativeRing r = record
-    { isRing = isRing r.isRing
-    ; *-comm = commutative r.*-comm
-    }
-    where module r = IsCommutativeRing r
-
-
 ------------------------------------------------------------------------
 -- Bundles
 
@@ -379,54 +239,3 @@ group g = record { isGroup = isGroup g.isGroup }
 abelianGroup : AbelianGroup a ℓ → AbelianGroup a ℓ
 abelianGroup g = record { isAbelianGroup = isAbelianGroup g.isAbelianGroup }
   where module g = AbelianGroup g
-
-semiringWithoutAnnihilatingZero : SemiringWithoutAnnihilatingZero a ℓ →
-                                  SemiringWithoutAnnihilatingZero a ℓ
-semiringWithoutAnnihilatingZero r = record
-  { isSemiringWithoutAnnihilatingZero = isSemiringWithoutAnnihilatingZero r.isSemiringWithoutAnnihilatingZero }
-  where module r = SemiringWithoutAnnihilatingZero r
-
-semiring : Semiring a ℓ → Semiring a ℓ
-semiring r = record { isSemiring = isSemiring r.isSemiring }
-  where module r = Semiring r
-
-commutativeSemiring : CommutativeSemiring a ℓ → CommutativeSemiring a ℓ
-commutativeSemiring r = record
-  { isCommutativeSemiring = isCommutativeSemiring r.isCommutativeSemiring }
-  where module r = CommutativeSemiring r
-
-cancellativeCommutativeSemiring : CancellativeCommutativeSemiring a ℓ →
-                                  CancellativeCommutativeSemiring a ℓ
-cancellativeCommutativeSemiring r = record
-  { isCancellativeCommutativeSemiring = isCancellativeCommutativeSemiring r.isCancellativeCommutativeSemiring }
-  where module r = CancellativeCommutativeSemiring r
-
-idempotentSemiring : IdempotentSemiring a ℓ → IdempotentSemiring a ℓ
-idempotentSemiring r = record
-  { isIdempotentSemiring = isIdempotentSemiring r.isIdempotentSemiring }
-  where module r = IdempotentSemiring r
-
-quasiring : Quasiring a ℓ → Quasiring a ℓ
-quasiring r = record { isQuasiring = isQuasiring r.isQuasiring }
-  where module r = Quasiring r
-
-ringWithoutOne : RingWithoutOne a ℓ → RingWithoutOne a ℓ
-ringWithoutOne r = record { isRingWithoutOne = isRingWithoutOne r.isRingWithoutOne }
-  where module r = RingWithoutOne r
-
-nonAssociativeRing : NonAssociativeRing a ℓ → NonAssociativeRing a ℓ
-nonAssociativeRing r = record
-  { isNonAssociativeRing = isNonAssociativeRing r.isNonAssociativeRing }
-  where module r = NonAssociativeRing r
-
-nearring : Nearring a ℓ → Nearring a ℓ
-nearring r = record { isNearring = isNearring r.isNearring }
-  where module r = Nearring r
-
-ring : Ring a ℓ → Ring a ℓ
-ring r = record { isRing = isRing r.isRing }
-  where module r = Ring r
-
-commutativeRing : CommutativeRing a ℓ → CommutativeRing a ℓ
-commutativeRing r = record { isCommutativeRing = isCommutativeRing r.isCommutativeRing }
-  where module r = CommutativeRing r
diff --git a/src/Algebra/Construct/Initial.agda b/src/Algebra/Construct/Initial.agda
index e542446248..57648d6735 100644
--- a/src/Algebra/Construct/Initial.agda
+++ b/src/Algebra/Construct/Initial.agda
@@ -4,8 +4,8 @@
 -- Instances of algebraic structures where the carrier is ⊥.
 -- In mathematics, this is usually called 0.
 --
--- From monoids up, these are zero-objects – i.e, the initial
--- object is the terminal object in the relevant category.
+-- From monoids up, these are zero-objects – i.e, the terminal
+-- object is *also* the initial object in the relevant category.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
@@ -22,7 +22,10 @@ open import Algebra.Core using (Op₂)
 open import Algebra.Definitions using (Congruent₂)
 open import Algebra.Structures using (IsMagma; IsSemigroup; IsBand)
 open import Data.Empty.Polymorphic
-open import Relation.Binary using (Rel; Reflexive; Symmetric; Transitive; IsEquivalence)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
 
 
 ------------------------------------------------------------------------
diff --git a/src/Algebra/Construct/LexProduct.agda b/src/Algebra/Construct/LexProduct.agda
index 1301ff7c04..3fbcf86c80 100644
--- a/src/Algebra/Construct/LexProduct.agda
+++ b/src/Algebra/Construct/LexProduct.agda
@@ -6,16 +6,18 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Algebra
-open import Data.Bool using (true; false)
-open import Data.Product
+open import Algebra.Bundles using (Magma)
+open import Algebra.Definitions
+open import Data.Bool.Base using (true; false)
+open import Data.Product.Base using (_×_; _,_)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent using (Pointwise)
-open import Data.Sum.Base using (inj₁; inj₂)
+open import Data.Sum.Base using (inj₁; inj₂; map)
 open import Function.Base using (_∘_)
-open import Relation.Binary
-open import Relation.Nullary using (¬_; does; yes; no)
-open import Relation.Nullary.Negation using (contradiction; contradiction₂)
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Decidable)
+open import Relation.Nullary.Decidable.Core using (does; yes; no)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction; contradiction₂)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 module Algebra.Construct.LexProduct
   {ℓ₁ ℓ₂ ℓ₃ ℓ₄} (M : Magma ℓ₁ ℓ₂) (N : Magma ℓ₃ ℓ₄)
@@ -105,6 +107,4 @@ sel ∙-sel ◦-sel (a , x) (b , y) with (a ∙ b) ≟₁ a | (a ∙ b) ≟₁ b
 ... | no  ab≉a | no  ab≉b  = contradiction₂ (∙-sel a b) ab≉a ab≉b
 ... | yes ab≈a | no  _     = inj₁ (ab≈a , ≈₂-refl)
 ... | no  _    | yes ab≈b  = inj₂ (ab≈b , ≈₂-refl)
-... | yes ab≈a | yes ab≈b  with ◦-sel x y
-...   | inj₁ xy≈x = inj₁ (ab≈a , xy≈x)
-...   | inj₂ xy≈y = inj₂ (ab≈b , xy≈y)
+... | yes ab≈a | yes ab≈b  = map (ab≈a ,_) (ab≈b ,_) (◦-sel x y)
diff --git a/src/Algebra/Construct/LexProduct/Base.agda b/src/Algebra/Construct/LexProduct/Base.agda
index 6076d1afc3..85686fd20c 100644
--- a/src/Algebra/Construct/LexProduct/Base.agda
+++ b/src/Algebra/Construct/LexProduct/Base.agda
@@ -8,10 +8,10 @@
 
 open import Algebra.Core using (Op₂)
 open import Data.Bool.Base using (true; false)
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Relation.Binary.Core using (Rel)
 open import Relation.Binary.Definitions using (Decidable)
-open import Relation.Nullary.Decidable using (does; yes; no)
+open import Relation.Nullary.Decidable.Core using (does; yes; no)
 
 module Algebra.Construct.LexProduct.Base
   {a b ℓ} {A : Set a} {B : Set b}
diff --git a/src/Algebra/Construct/LexProduct/Inner.agda b/src/Algebra/Construct/LexProduct/Inner.agda
index 718bde2610..beff9e9e3a 100644
--- a/src/Algebra/Construct/LexProduct/Inner.agda
+++ b/src/Algebra/Construct/LexProduct/Inner.agda
@@ -8,7 +8,7 @@
 
 open import Algebra
 open import Data.Bool.Base using (false; true)
-open import Data.Product using (_×_; _,_; swap; map; uncurry′)
+open import Data.Product.Base using (_×_; _,_; swap; map; uncurry′)
 open import Function.Base using (_∘_)
 open import Level using (Level; _⊔_)
 open import Relation.Binary.Definitions using (Decidable)
@@ -82,8 +82,8 @@ module NaturalOrder where
 
   ≤∙ˡ-trans : Associative _≈₁_ _∙_ → (a ∙ b) ≈₁ b → (b ∙ c) ≈₁ c → (a ∙ c) ≈₁ c
   ≤∙ˡ-trans {a} {b} {c} ∙-assoc ab≈b bc≈c = begin
-    a ∙ c        ≈˘⟨ ∙-congˡ bc≈c ⟩
-    a ∙ (b ∙ c)  ≈˘⟨ ∙-assoc a b c ⟩
+    a ∙ c        ≈⟨ ∙-congˡ bc≈c ⟨
+    a ∙ (b ∙ c)  ≈⟨ ∙-assoc a b c ⟨
     (a ∙ b) ∙ c  ≈⟨  ∙-congʳ ab≈b ⟩
     b ∙ c        ≈⟨  bc≈c ⟩
     c            ∎
@@ -165,8 +165,9 @@ cong₁ a≈b = cong₁₂ a≈b M.refl
 cong₂ : b ≈₁ c → lex a b x y ≈₂ lex a c x y
 cong₂ = cong₁₂ M.refl
 
--- It is possible to relax this. Instead of ∙ being selective and ◦ being associative it's also
--- possible for _◦_ to return a single idempotent element.
+-- It is possible to relax this. Instead of ∙ being selective and ◦
+-- being associative it's also possible for _◦_ to return a single
+-- idempotent element.
 assoc : Associative _≈₁_ _∙_ → Commutative _≈₁_ _∙_ →
         Selective _≈₁_ _∙_ → Associative _≈₂_ _◦_ →
         ∀ a b c x y z  → lex (a ∙ b) c (lex a b x y) z  ≈₂ lex a (b ∙ c) x (lex b c y z)
@@ -178,51 +179,51 @@ assoc ∙-assoc ∙-comm ∙-sel ◦-assoc a b c x y z
 ... | no ab≉a  | yes ab≈b | yes bc≈b | yes bc≈c = begin
   lex (a ∙ b) c y z        ≈⟨  cong₁ ab≈b ⟩
   lex b c y z              ≈⟨  case₃ bc≈b bc≈c ⟩
-  y ◦ z                    ≈˘⟨ case₂ ab≉a ab≈b ⟩
-  lex a b x (y ◦ z)        ≈˘⟨ cong₂ bc≈b ⟩
+  y ◦ z                    ≈⟨ case₂ ab≉a ab≈b ⟨
+  lex a b x (y ◦ z)        ≈⟨ cong₂ bc≈b ⟨
   lex a (b ∙ c) x (y ◦ z)  ∎
 ... | no ab≉a  | yes ab≈b | yes bc≈b | no bc≉c = begin
   lex (a ∙ b) c y z        ≈⟨  cong₁ ab≈b ⟩
   lex b c y z              ≈⟨  case₁ bc≈b bc≉c ⟩
-  y                        ≈˘⟨ case₂ ab≉a ab≈b ⟩
-  lex a b x y              ≈˘⟨ cong₂ bc≈b ⟩
+  y                        ≈⟨ case₂ ab≉a ab≈b ⟨
+  lex a b x y              ≈⟨ cong₂ bc≈b ⟨
   lex a (b ∙ c) x y        ∎
 ... | yes ab≈a | yes ab≈b | yes bc≈b | no bc≉c = begin
   lex (a ∙ b) c (x ◦ y) z  ≈⟨  cong₁ ab≈b ⟩
   lex b c (x ◦ y) z        ≈⟨  case₁ bc≈b bc≉c ⟩
-  x ◦ y                    ≈˘⟨ case₃ ab≈a ab≈b ⟩
-  lex a b x y              ≈˘⟨ cong₂ bc≈b ⟩
+  x ◦ y                    ≈⟨ case₃ ab≈a ab≈b ⟨
+  lex a b x y              ≈⟨ cong₂ bc≈b ⟨
   lex a (b ∙ c) x y        ∎
 ... | yes ab≈a | yes ab≈b | yes bc≈b | yes bc≈c = begin
   lex (a ∙ b) c (x ◦ y) z  ≈⟨  cong₁ ab≈b ⟩
   lex b c (x ◦ y) z        ≈⟨  case₃ bc≈b bc≈c  ⟩
   (x ◦ y) ◦ z              ≈⟨  ◦-assoc x y z ⟩
-  x ◦ (y ◦ z)              ≈˘⟨ case₃ ab≈a ab≈b ⟩
-  lex a b x (y ◦ z)        ≈˘⟨ cong₂ bc≈b ⟩
+  x ◦ (y ◦ z)              ≈⟨ case₃ ab≈a ab≈b ⟨
+  lex a b x (y ◦ z)        ≈⟨ cong₂ bc≈b ⟨
   lex a (b ∙ c) x (y ◦ z)  ∎
 ... | yes ab≈a | yes ab≈b | no bc≉b | yes bc≈c = begin
   lex (a ∙ b) c (x ◦ y) z  ≈⟨  cong₁ ab≈b ⟩
   lex b c (x ◦ y) z        ≈⟨  case₂ bc≉b bc≈c ⟩
-  z                        ≈˘⟨ case₂ bc≉b bc≈c ⟩
-  lex b c x z              ≈˘⟨ cong₁₂ (M.trans (M.sym ab≈a) ab≈b) bc≈c ⟩
+  z                        ≈⟨ case₂ bc≉b bc≈c ⟨
+  lex b c x z              ≈⟨ cong₁₂ (M.trans (M.sym ab≈a) ab≈b) bc≈c ⟨
   lex a (b ∙ c) x z        ∎
 ... | yes ab≈a | no ab≉b | yes bc≈b | yes bc≈c = begin
   lex (a ∙ b) c x z        ≈⟨  cong₁₂ ab≈a (M.trans (M.sym bc≈c) bc≈b) ⟩
   lex a b x z              ≈⟨  case₁ ab≈a ab≉b ⟩
-  x                        ≈˘⟨ case₁ ab≈a ab≉b ⟩
-  lex a b x (y ◦ z)        ≈˘⟨ cong₂ bc≈b ⟩
+  x                        ≈⟨ case₁ ab≈a ab≉b ⟨
+  lex a b x (y ◦ z)        ≈⟨ cong₂ bc≈b ⟨
   lex a (b ∙ c) x (y ◦ z)  ∎
 ... | no ab≉a | yes ab≈b | no bc≉b | yes bc≈c = begin
   lex (a ∙ b) c y z        ≈⟨  cong₁ ab≈b ⟩
   lex b c y z              ≈⟨  case₂ bc≉b bc≈c ⟩
-  z                        ≈˘⟨ uncurry′ case₂ (<∙ˡ-trans ∙-assoc ∙-comm ab≈b ab≉a bc≈c) ⟩
-  lex a c x z              ≈˘⟨ cong₂ bc≈c ⟩
+  z                        ≈⟨ uncurry′ case₂ (<∙ˡ-trans ∙-assoc ∙-comm ab≈b ab≉a bc≈c) ⟨
+  lex a c x z              ≈⟨ cong₂ bc≈c ⟨
   lex a (b ∙ c) x z        ∎
 ... | yes ab≈a | no ab≉b | yes bc≈b | no bc≉c = begin
   lex (a ∙ b) c x z        ≈⟨  cong₁ ab≈a ⟩
   lex a c x z              ≈⟨  uncurry′ case₁ (<∙ʳ-trans ∙-assoc ∙-comm ab≈a bc≈b bc≉c) ⟩
-  x                        ≈˘⟨ case₁ ab≈a ab≉b ⟩
-  lex a b x y              ≈˘⟨ cong₂ bc≈b ⟩
+  x                        ≈⟨ case₁ ab≈a ab≉b ⟨
+  lex a b x y              ≈⟨ cong₂ bc≈b ⟨
   lex a (b ∙ c) x y        ∎
 
 comm : Commutative _≈₁_ _∙_ → Commutative _≈₂_ _◦_ →
diff --git a/src/Algebra/Construct/LiftedChoice.agda b/src/Algebra/Construct/LiftedChoice.agda
index 357d2e725a..e3d37009ed 100644
--- a/src/Algebra/Construct/LiftedChoice.agda
+++ b/src/Algebra/Construct/LiftedChoice.agda
@@ -11,15 +11,17 @@ open import Algebra
 module Algebra.Construct.LiftedChoice where
 
 open import Algebra.Consequences.Base
-open import Relation.Binary
-open import Relation.Nullary using (¬_; yes; no)
-open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_])
-open import Data.Product using (_×_; _,_)
+open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_]; [_,_]′)
+open import Data.Product.Base using (_×_; _,_)
+open import Function.Base using (const; _$_)
 open import Level using (Level; _⊔_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (Rel; _⇒_; _Preserves_⟶_)
+open import Relation.Nullary using (¬_; yes; no)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Binary.Structures using (IsEquivalence)
 open import Relation.Unary using (Pred)
 
-import Relation.Binary.Reasoning.Setoid as EqReasoning
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 private
   variable
@@ -33,9 +35,7 @@ private
 module _ (_≈_ : Rel B ℓ) (_•_ : Op₂ B) where
 
   Lift : Selective _≈_ _•_ → (A → B) → Op₂ A
-  Lift ∙-sel f x y with ∙-sel (f x) (f y)
-  ... | inj₁ _ = x
-  ... | inj₂ _ = y
+  Lift ∙-sel f x y = [ const x , const y ]′ $ ∙-sel (f x) (f y)
 
 ------------------------------------------------------------------------
 -- Algebraic properties
@@ -45,7 +45,7 @@ module _ {_≈_ : Rel B ℓ} {_∙_ : Op₂ B}
 
   private module M = IsSelectiveMagma ∙-isSelectiveMagma
   open M hiding (sel; isMagma)
-  open EqReasoning setoid
+  open ≈-Reasoning setoid
 
   module _ (f : A → B) where
 
@@ -54,8 +54,8 @@ module _ {_≈_ : Rel B ℓ} {_∙_ : Op₂ B}
 
     sel-≡ : Selective _≡_ _◦_
     sel-≡ x y with M.sel (f x) (f y)
-    ... | inj₁ _ = inj₁ P.refl
-    ... | inj₂ _ = inj₂ P.refl
+    ... | inj₁ _ = inj₁ ≡.refl
+    ... | inj₂ _ = inj₂ ≡.refl
 
     distrib : ∀ x y → ((f x) ∙ (f y)) ≈ f (x ◦ y)
     distrib x y with M.sel (f x) (f y)
@@ -99,8 +99,8 @@ module _ {_≈_ : Rel B ℓ} {_∙_ : Op₂ B}
 
     assoc : Associative _≈_ _∙_ → Associative _≈′_ _◦_
     assoc ∙-assoc x y z = f-injective (begin
-      f ((x ◦ y) ◦ z)   ≈˘⟨ distrib f (x ◦ y) z ⟩
-      f (x ◦ y) ∙ f z   ≈˘⟨ ∙-congʳ (distrib f x y) ⟩
+      f ((x ◦ y) ◦ z)   ≈⟨ distrib f (x ◦ y) z ⟨
+      f (x ◦ y) ∙ f z   ≈⟨ ∙-congʳ (distrib f x y) ⟨
       (f x ∙ f y) ∙ f z ≈⟨  ∙-assoc (f x) (f y) (f z) ⟩
       f x ∙ (f y ∙ f z) ≈⟨  ∙-congˡ (distrib f y z) ⟩
       f x ∙ f (y ◦ z)   ≈⟨  distrib f x (y ◦ z) ⟩
@@ -108,7 +108,7 @@ module _ {_≈_ : Rel B ℓ} {_∙_ : Op₂ B}
 
     comm : Commutative _≈_ _∙_ → Commutative _≈′_ _◦_
     comm ∙-comm x y = f-injective (begin
-      f (x ◦ y) ≈˘⟨ distrib f x y ⟩
+      f (x ◦ y) ≈⟨ distrib f x y ⟨
       f x ∙ f y ≈⟨  ∙-comm (f x) (f y) ⟩
       f y ∙ f x ≈⟨  distrib f y x ⟩
       f (y ◦ x) ∎)
diff --git a/src/Algebra/Construct/NaturalChoice/Base.agda b/src/Algebra/Construct/NaturalChoice/Base.agda
index 901f7a5413..6b4d4d13b7 100644
--- a/src/Algebra/Construct/NaturalChoice/Base.agda
+++ b/src/Algebra/Construct/NaturalChoice/Base.agda
@@ -10,8 +10,8 @@
 open import Algebra.Core
 open import Level as L hiding (_⊔_)
 open import Function.Base using (flip)
-open import Relation.Binary
-open import Relation.Binary.Construct.Converse using ()
+open import Relation.Binary.Bundles using (TotalPreorder)
+open import Relation.Binary.Construct.Flip.EqAndOrd using ()
   renaming (totalPreorder to flipOrder)
 import Relation.Binary.Properties.TotalOrder as TotalOrderProperties
 
diff --git a/src/Algebra/Construct/NaturalChoice/Max.agda b/src/Algebra/Construct/NaturalChoice/Max.agda
index 592b887f6b..3e4c8f7db8 100644
--- a/src/Algebra/Construct/NaturalChoice/Max.agda
+++ b/src/Algebra/Construct/NaturalChoice/Max.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (TotalOrder)
 
 module Algebra.Construct.NaturalChoice.Max
   {a ℓ₁ ℓ₂} (totalOrder : TotalOrder a ℓ₁ ℓ₂) where
@@ -14,7 +14,7 @@ module Algebra.Construct.NaturalChoice.Max
 open import Algebra.Core
 open import Algebra.Definitions
 open import Algebra.Construct.NaturalChoice.Base
-open import Relation.Binary.Construct.Converse using ()
+open import Relation.Binary.Construct.Flip.EqAndOrd using ()
   renaming (totalOrder to flip)
 
 open TotalOrder totalOrder renaming (Carrier to A)
diff --git a/src/Algebra/Construct/NaturalChoice/MaxOp.agda b/src/Algebra/Construct/NaturalChoice/MaxOp.agda
index 28accb65b3..8e4b032950 100644
--- a/src/Algebra/Construct/NaturalChoice/MaxOp.agda
+++ b/src/Algebra/Construct/NaturalChoice/MaxOp.agda
@@ -11,8 +11,9 @@ open import Algebra.Core
 open import Algebra.Construct.NaturalChoice.Base
 import Algebra.Construct.NaturalChoice.MinOp as MinOp
 open import Function.Base using (flip)
-open import Relation.Binary
-open import Relation.Binary.Construct.Converse using ()
+open import Relation.Binary.Core using (_Preserves_⟶_)
+open import Relation.Binary.Bundles using (TotalPreorder)
+open import Relation.Binary.Construct.Flip.EqAndOrd using ()
   renaming (totalPreorder to flipOrder)
 
 module Algebra.Construct.NaturalChoice.MaxOp
diff --git a/src/Algebra/Construct/NaturalChoice/Min.agda b/src/Algebra/Construct/NaturalChoice/Min.agda
index 1184f4fe30..6d2482a4a9 100644
--- a/src/Algebra/Construct/NaturalChoice/Min.agda
+++ b/src/Algebra/Construct/NaturalChoice/Min.agda
@@ -9,10 +9,10 @@
 open import Algebra.Core
 open import Algebra.Bundles
 open import Algebra.Construct.NaturalChoice.Base
-open import Data.Sum using (inj₁; inj₂; [_,_])
-open import Data.Product using (_,_)
-open import Function using (id)
-open import Relation.Binary
+open import Data.Sum.Base using (inj₁; inj₂; [_,_])
+open import Data.Product.Base using (_,_)
+open import Function.Base using (id)
+open import Relation.Binary.Bundles using (TotalOrder)
 import Algebra.Construct.NaturalChoice.MinOp as MinOp
 
 module Algebra.Construct.NaturalChoice.Min
diff --git a/src/Algebra/Construct/NaturalChoice/MinMaxOp.agda b/src/Algebra/Construct/NaturalChoice/MinMaxOp.agda
index 4b7d0e20e8..7b64727832 100644
--- a/src/Algebra/Construct/NaturalChoice/MinMaxOp.agda
+++ b/src/Algebra/Construct/NaturalChoice/MinMaxOp.agda
@@ -11,9 +11,10 @@ open import Algebra.Core
 open import Algebra.Bundles
 open import Algebra.Construct.NaturalChoice.Base
 open import Data.Sum.Base as Sum using (inj₁; inj₂; [_,_])
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (id; _∘_; flip)
-open import Relation.Binary
+open import Relation.Binary.Core using (_Preserves_⟶_)
+open import Relation.Binary.Bundles using (TotalPreorder)
 open import Relation.Binary.Consequences
 
 module Algebra.Construct.NaturalChoice.MinMaxOp
@@ -50,11 +51,11 @@ open import Algebra.Construct.NaturalChoice.MaxOp maxOp public
 ⊓-distribˡ-⊔ x y z with total y z
 ... | inj₁ y≤z = begin-equality
   x ⊓ (y ⊔ z)       ≈⟨  ⊓-congˡ x (x≤y⇒x⊔y≈y y≤z) ⟩
-  x ⊓ z             ≈˘⟨ x≤y⇒x⊔y≈y (⊓-monoʳ-≤ x y≤z) ⟩
+  x ⊓ z             ≈⟨ x≤y⇒x⊔y≈y (⊓-monoʳ-≤ x y≤z) ⟨
   (x ⊓ y) ⊔ (x ⊓ z) ∎
 ... | inj₂ y≥z = begin-equality
   x ⊓ (y ⊔ z)       ≈⟨  ⊓-congˡ x (x≥y⇒x⊔y≈x y≥z) ⟩
-  x ⊓ y             ≈˘⟨ x≥y⇒x⊔y≈x (⊓-monoʳ-≤ x y≥z) ⟩
+  x ⊓ y             ≈⟨ x≥y⇒x⊔y≈x (⊓-monoʳ-≤ x y≥z) ⟨
   (x ⊓ y) ⊔ (x ⊓ z) ∎
 
 ⊓-distribʳ-⊔ : _⊓_ DistributesOverʳ _⊔_
@@ -67,11 +68,11 @@ open import Algebra.Construct.NaturalChoice.MaxOp maxOp public
 ⊔-distribˡ-⊓ x y z with total y z
 ... | inj₁ y≤z = begin-equality
   x ⊔ (y ⊓ z)       ≈⟨  ⊔-congˡ x (x≤y⇒x⊓y≈x y≤z) ⟩
-  x ⊔ y             ≈˘⟨ x≤y⇒x⊓y≈x (⊔-monoʳ-≤ x y≤z) ⟩
+  x ⊔ y             ≈⟨ x≤y⇒x⊓y≈x (⊔-monoʳ-≤ x y≤z) ⟨
   (x ⊔ y) ⊓ (x ⊔ z) ∎
 ... | inj₂ y≥z = begin-equality
   x ⊔ (y ⊓ z)       ≈⟨  ⊔-congˡ x (x≥y⇒x⊓y≈y y≥z) ⟩
-  x ⊔ z             ≈˘⟨ x≥y⇒x⊓y≈y (⊔-monoʳ-≤ x y≥z) ⟩
+  x ⊔ z             ≈⟨ x≥y⇒x⊓y≈y (⊔-monoʳ-≤ x y≥z) ⟨
   (x ⊔ y) ⊓ (x ⊔ z) ∎
 
 ⊔-distribʳ-⊓ : _⊔_ DistributesOverʳ _⊓_
@@ -118,11 +119,11 @@ antimono-≤-distrib-⊓ : ∀ {f} → f Preserves _≈_ ⟶ _≈_ → f Preserv
 antimono-≤-distrib-⊓ {f} cong antimono x y with total x y
 ... | inj₁ x≤y = begin-equality
   f (x ⊓ y)  ≈⟨ cong (x≤y⇒x⊓y≈x x≤y) ⟩
-  f x        ≈˘⟨ x≥y⇒x⊔y≈x (antimono x≤y) ⟩
+  f x        ≈⟨ x≥y⇒x⊔y≈x (antimono x≤y) ⟨
   f x ⊔ f y  ∎
 ... | inj₂ y≤x = begin-equality
   f (x ⊓ y)  ≈⟨ cong (x≥y⇒x⊓y≈y y≤x) ⟩
-  f y        ≈˘⟨ x≤y⇒x⊔y≈y (antimono y≤x) ⟩
+  f y        ≈⟨ x≤y⇒x⊔y≈y (antimono y≤x) ⟨
   f x ⊔ f y  ∎
 
 antimono-≤-distrib-⊔ : ∀ {f} → f Preserves _≈_ ⟶ _≈_ → f Preserves _≤_ ⟶ _≥_ →
@@ -130,11 +131,11 @@ antimono-≤-distrib-⊔ : ∀ {f} → f Preserves _≈_ ⟶ _≈_ → f Preserv
 antimono-≤-distrib-⊔ {f} cong antimono x y with total x y
 ... | inj₁ x≤y = begin-equality
   f (x ⊔ y)  ≈⟨ cong (x≤y⇒x⊔y≈y x≤y) ⟩
-  f y        ≈˘⟨ x≥y⇒x⊓y≈y (antimono x≤y) ⟩
+  f y        ≈⟨ x≥y⇒x⊓y≈y (antimono x≤y) ⟨
   f x ⊓ f y  ∎
 ... | inj₂ y≤x = begin-equality
   f (x ⊔ y)  ≈⟨ cong (x≥y⇒x⊔y≈x y≤x) ⟩
-  f x        ≈˘⟨ x≤y⇒x⊓y≈x (antimono y≤x) ⟩
+  f x        ≈⟨ x≤y⇒x⊓y≈x (antimono y≤x) ⟨
   f x ⊓ f y  ∎
 
 x⊓y≤x⊔y : ∀ x y → x ⊓ y ≤ x ⊔ y
diff --git a/src/Algebra/Construct/NaturalChoice/MinOp.agda b/src/Algebra/Construct/NaturalChoice/MinOp.agda
index 37ed331c7e..7ad8983a1f 100644
--- a/src/Algebra/Construct/NaturalChoice/MinOp.agda
+++ b/src/Algebra/Construct/NaturalChoice/MinOp.agda
@@ -11,9 +11,11 @@ open import Algebra.Core
 open import Algebra.Bundles
 open import Algebra.Construct.NaturalChoice.Base
 open import Data.Sum.Base as Sum using (inj₁; inj₂; [_,_])
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (id; _∘_)
-open import Relation.Binary
+open import Relation.Binary.Core using (_Preserves_⟶_; _Preserves₂_⟶_⟶_)
+open import Relation.Binary.Bundles using (TotalPreorder)
+open import Relation.Binary.Definitions using (Maximum; Minimum)
 open import Relation.Binary.Consequences
 
 module Algebra.Construct.NaturalChoice.MinOp
@@ -37,13 +39,13 @@ open import Relation.Binary.Reasoning.Preorder preorder
 
 x⊓y≤x : ∀ x y → x ⊓ y ≤ x
 x⊓y≤x x y with total x y
-... | inj₁ x≤y = ≤-respˡ-≈ (Eq.sym (x≤y⇒x⊓y≈x x≤y)) refl
+... | inj₁ x≤y = reflexive (x≤y⇒x⊓y≈x x≤y)
 ... | inj₂ y≤x = ≤-respˡ-≈ (Eq.sym (x≥y⇒x⊓y≈y y≤x)) y≤x
 
 x⊓y≤y : ∀ x y → x ⊓ y ≤ y
 x⊓y≤y x y with total x y
 ... | inj₁ x≤y = ≤-respˡ-≈ (Eq.sym (x≤y⇒x⊓y≈x x≤y)) x≤y
-... | inj₂ y≤x = ≤-respˡ-≈ (Eq.sym (x≥y⇒x⊓y≈y y≤x)) refl
+... | inj₂ y≤x = reflexive (x≥y⇒x⊓y≈y y≤x)
 
 ------------------------------------------------------------------------
 -- Algebraic properties
@@ -57,17 +59,17 @@ x⊓y≤y x y with total x y
 ⊓-congˡ x {y} {r} y≈r with total x y
 ... | inj₁ x≤y = begin-equality
   x ⊓ y  ≈⟨  x≤y⇒x⊓y≈x x≤y ⟩
-  x      ≈˘⟨ x≤y⇒x⊓y≈x (≤-respʳ-≈ y≈r x≤y) ⟩
+  x      ≈⟨ x≤y⇒x⊓y≈x (≤-respʳ-≈ y≈r x≤y) ⟨
   x ⊓ r  ∎
 ... | inj₂ y≤x = begin-equality
   x ⊓ y  ≈⟨  x≥y⇒x⊓y≈y y≤x ⟩
   y      ≈⟨  y≈r ⟩
-  r      ≈˘⟨ x≥y⇒x⊓y≈y (≤-respˡ-≈ y≈r y≤x) ⟩
+  r      ≈⟨ x≥y⇒x⊓y≈y (≤-respˡ-≈ y≈r y≤x) ⟨
   x ⊓ r  ∎
 
 ⊓-congʳ : ∀ x → Congruent₁ (_⊓ x)
 ⊓-congʳ x {y₁} {y₂} y₁≈y₂ = begin-equality
-  y₁ ⊓ x  ≈˘⟨ ⊓-comm x y₁ ⟩
+  y₁ ⊓ x  ≈⟨ ⊓-comm x y₁ ⟨
   x  ⊓ y₁ ≈⟨  ⊓-congˡ x y₁≈y₂ ⟩
   x  ⊓ y₂ ≈⟨  ⊓-comm x y₂ ⟩
   y₂ ⊓ x  ∎
@@ -80,16 +82,16 @@ x⊓y≤y x y with total x y
 ⊓-assoc x y r | inj₁ x≤y | inj₁ y≤r = begin-equality
   (x ⊓ y) ⊓ r  ≈⟨ ⊓-congʳ r (x≤y⇒x⊓y≈x x≤y) ⟩
   x ⊓ r        ≈⟨ x≤y⇒x⊓y≈x (trans x≤y y≤r) ⟩
-  x            ≈˘⟨ x≤y⇒x⊓y≈x x≤y ⟩
-  x ⊓ y        ≈˘⟨ ⊓-congˡ x (x≤y⇒x⊓y≈x y≤r) ⟩
+  x            ≈⟨ x≤y⇒x⊓y≈x x≤y ⟨
+  x ⊓ y        ≈⟨ ⊓-congˡ x (x≤y⇒x⊓y≈x y≤r) ⟨
   x ⊓ (y ⊓ r)  ∎
 ⊓-assoc x y r | inj₁ x≤y | inj₂ r≤y = begin-equality
   (x ⊓ y) ⊓ r  ≈⟨ ⊓-congʳ r (x≤y⇒x⊓y≈x x≤y) ⟩
-  x ⊓ r        ≈˘⟨ ⊓-congˡ x (x≥y⇒x⊓y≈y r≤y) ⟩
+  x ⊓ r        ≈⟨ ⊓-congˡ x (x≥y⇒x⊓y≈y r≤y) ⟨
   x ⊓ (y ⊓ r)  ∎
 ⊓-assoc x y r | inj₂ y≤x | _ = begin-equality
   (x ⊓ y) ⊓ r  ≈⟨ ⊓-congʳ r (x≥y⇒x⊓y≈y y≤x) ⟩
-  y ⊓ r        ≈˘⟨ x≥y⇒x⊓y≈y (trans (x⊓y≤x y r) y≤x) ⟩
+  y ⊓ r        ≈⟨ x≥y⇒x⊓y≈y (trans (x⊓y≤x y r) y≤x) ⟨
   x ⊓ (y ⊓ r)  ∎
 
 ⊓-idem : Idempotent _⊓_
@@ -213,11 +215,11 @@ mono-≤-distrib-⊓ : ∀ {f} → f Preserves _≈_ ⟶ _≈_ → f Preserves _
 mono-≤-distrib-⊓ {f} cong mono x y with total x y
 ... | inj₁ x≤y = begin-equality
   f (x ⊓ y)  ≈⟨ cong (x≤y⇒x⊓y≈x x≤y) ⟩
-  f x        ≈˘⟨ x≤y⇒x⊓y≈x (mono x≤y) ⟩
+  f x        ≈⟨ x≤y⇒x⊓y≈x (mono x≤y) ⟨
   f x ⊓ f y  ∎
 ... | inj₂ y≤x = begin-equality
   f (x ⊓ y)  ≈⟨ cong (x≥y⇒x⊓y≈y y≤x) ⟩
-  f y        ≈˘⟨ x≥y⇒x⊓y≈y (mono y≤x) ⟩
+  f y        ≈⟨ x≥y⇒x⊓y≈y (mono y≤x) ⟨
   f x ⊓ f y  ∎
 
 x≤y⇒x⊓z≤y : ∀ {x y} z → x ≤ y → x ⊓ z ≤ y
@@ -248,8 +250,8 @@ x≤y⊓z⇒x≤z y z x≤y⊓z = trans x≤y⊓z (x⊓y≤y y z)
 
 ⊓-triangulate : ∀ x y z → x ⊓ y ⊓ z ≈ (x ⊓ y) ⊓ (y ⊓ z)
 ⊓-triangulate x y z = begin-equality
-  x ⊓ y ⊓ z           ≈˘⟨ ⊓-congʳ z (⊓-congˡ x (⊓-idem y)) ⟩
+  x ⊓ y ⊓ z           ≈⟨ ⊓-congʳ z (⊓-congˡ x (⊓-idem y)) ⟨
   x ⊓ (y ⊓ y) ⊓ z     ≈⟨  ⊓-assoc x _ _ ⟩
   x ⊓ ((y ⊓ y) ⊓ z)   ≈⟨  ⊓-congˡ x (⊓-assoc y y z) ⟩
-  x ⊓ (y ⊓ (y ⊓ z))   ≈˘⟨ ⊓-assoc x y (y ⊓ z) ⟩
+  x ⊓ (y ⊓ (y ⊓ z))   ≈⟨ ⊓-assoc x y (y ⊓ z) ⟨
   (x ⊓ y) ⊓ (y ⊓ z)   ∎
diff --git a/src/Algebra/Construct/Pointwise.agda b/src/Algebra/Construct/Pointwise.agda
new file mode 100644
index 0000000000..5b984dbc19
--- /dev/null
+++ b/src/Algebra/Construct/Pointwise.agda
@@ -0,0 +1,184 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- For each `IsX` algebraic structure `S`, lift the structure to the
+-- 'pointwise' function space `A → S`: categorically, this is the
+-- *power* object in the relevant category of `X` objects and morphisms
+--
+-- NB the module is parametrised only wrt `A`
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Algebra.Construct.Pointwise {a} (A : Set a) where
+
+open import Algebra.Bundles
+open import Algebra.Core using (Op₁; Op₂)
+open import Algebra.Structures
+open import Data.Product.Base using (_,_)
+open import Function.Base using (id; _∘′_; const)
+open import Level
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+
+
+private
+
+  variable
+    c ℓ : Level
+    C : Set c
+    _≈_ : Rel C ℓ
+    ε 0# 1# : C
+    _⁻¹ -_ : Op₁ C
+    _∙_ _+_ _*_ : Op₂ C
+
+  lift₀ : C → A → C
+  lift₀ = const
+
+  lift₁ : Op₁ C → Op₁ (A → C)
+  lift₁ = _∘′_
+
+  lift₂ : Op₂ C → Op₂ (A → C)
+  lift₂ _∙_ g h x = (g x) ∙ (h x)
+
+  liftRel : Rel C ℓ → Rel (A → C) (a ⊔ ℓ)
+  liftRel _≈_ g h = ∀ x → (g x) ≈ (h x)
+
+
+------------------------------------------------------------------------
+-- Setoid structure: here rather than elsewhere? (could be imported?)
+
+isEquivalence : IsEquivalence _≈_ → IsEquivalence (liftRel _≈_)
+isEquivalence isEquivalence = record
+  { refl = λ {f} _ → refl {f _}
+  ; sym = λ f≈g _ → sym (f≈g _)
+  ; trans = λ f≈g g≈h _ → trans (f≈g _) (g≈h _)
+  }
+  where open IsEquivalence isEquivalence
+
+------------------------------------------------------------------------
+-- Structures
+
+isMagma : IsMagma _≈_ _∙_ → IsMagma (liftRel _≈_) (lift₂ _∙_)
+isMagma isMagma = record
+  { isEquivalence = isEquivalence M.isEquivalence
+  ; ∙-cong = λ g h _ → M.∙-cong (g _) (h _)
+  }
+  where module M = IsMagma isMagma
+
+isSemigroup : IsSemigroup _≈_ _∙_ → IsSemigroup (liftRel _≈_) (lift₂ _∙_)
+isSemigroup isSemigroup = record
+  { isMagma = isMagma M.isMagma
+  ; assoc = λ f g h _ → M.assoc (f _) (g _) (h _)
+  }
+  where module M = IsSemigroup isSemigroup
+
+isBand : IsBand _≈_ _∙_ → IsBand (liftRel _≈_) (lift₂ _∙_)
+isBand isBand = record
+  { isSemigroup = isSemigroup M.isSemigroup
+  ; idem = λ f _ → M.idem (f _)
+  }
+  where module M = IsBand isBand
+
+isCommutativeSemigroup : IsCommutativeSemigroup _≈_ _∙_ →
+                         IsCommutativeSemigroup (liftRel _≈_) (lift₂ _∙_)
+isCommutativeSemigroup isCommutativeSemigroup = record
+  { isSemigroup = isSemigroup M.isSemigroup
+  ; comm = λ f g _ → M.comm (f _) (g _)
+  }
+  where module M = IsCommutativeSemigroup isCommutativeSemigroup
+
+isMonoid : IsMonoid _≈_ _∙_ ε → IsMonoid (liftRel _≈_) (lift₂ _∙_) (lift₀ ε)
+isMonoid isMonoid = record
+  { isSemigroup = isSemigroup M.isSemigroup
+  ; identity = (λ f _ → M.identityˡ (f _)) , λ f _ → M.identityʳ (f _)
+  }
+  where module M = IsMonoid isMonoid
+
+isCommutativeMonoid : IsCommutativeMonoid _≈_ _∙_ ε →
+                      IsCommutativeMonoid (liftRel _≈_) (lift₂ _∙_) (lift₀ ε)
+isCommutativeMonoid isCommutativeMonoid = record
+  { isMonoid = isMonoid M.isMonoid
+  ; comm = λ f g _ → M.comm (f _) (g _)
+  }
+  where module M = IsCommutativeMonoid isCommutativeMonoid
+
+isGroup : IsGroup _≈_ _∙_ ε _⁻¹ →
+          IsGroup (liftRel _≈_) (lift₂ _∙_) (lift₀ ε) (lift₁ _⁻¹)
+isGroup isGroup = record
+  { isMonoid = isMonoid M.isMonoid
+  ; inverse = (λ f _ → M.inverseˡ (f _)) , λ f _ → M.inverseʳ (f _)
+  ; ⁻¹-cong = λ f _ → M.⁻¹-cong (f _)
+  }
+  where module M = IsGroup isGroup
+
+isAbelianGroup : IsAbelianGroup _≈_ _∙_ ε _⁻¹ →
+                 IsAbelianGroup (liftRel _≈_) (lift₂ _∙_) (lift₀ ε) (lift₁ _⁻¹)
+isAbelianGroup isAbelianGroup = record
+  { isGroup = isGroup M.isGroup
+  ; comm = λ f g _ → M.comm (f _) (g _)
+  }
+  where module M = IsAbelianGroup isAbelianGroup
+
+isSemiringWithoutAnnihilatingZero : IsSemiringWithoutAnnihilatingZero _≈_ _+_ _*_ 0# 1# →
+  IsSemiringWithoutAnnihilatingZero (liftRel _≈_) (lift₂ _+_) (lift₂ _*_) (lift₀ 0#) (lift₀ 1#)
+isSemiringWithoutAnnihilatingZero isSemiringWithoutAnnihilatingZero = record
+  { +-isCommutativeMonoid = isCommutativeMonoid M.+-isCommutativeMonoid
+  ; *-cong =  λ g h _ → M.*-cong (g _) (h _)
+  ; *-assoc =  λ f g h _ → M.*-assoc (f _) (g _) (h _)
+  ; *-identity = (λ f _ → M.*-identityˡ (f _)) , λ f _ → M.*-identityʳ (f _)
+  ; distrib = (λ f g h _ → M.distribˡ (f _) (g _) (h _)) , λ f g h _ → M.distribʳ (f _) (g _) (h _)
+  }
+  where module M = IsSemiringWithoutAnnihilatingZero isSemiringWithoutAnnihilatingZero
+
+isSemiring : IsSemiring _≈_ _+_ _*_ 0# 1# →
+             IsSemiring (liftRel _≈_) (lift₂ _+_) (lift₂ _*_) (lift₀ 0#) (lift₀ 1#)
+isSemiring isSemiring = record
+  { isSemiringWithoutAnnihilatingZero = isSemiringWithoutAnnihilatingZero M.isSemiringWithoutAnnihilatingZero
+  ; zero = (λ f _ → M.zeroˡ (f _)) , λ f _ → M.zeroʳ (f _)
+  }
+  where module M = IsSemiring isSemiring
+
+isRing : IsRing _≈_ _+_ _*_ -_ 0# 1# →
+         IsRing (liftRel _≈_) (lift₂ _+_) (lift₂ _*_) (lift₁ -_) (lift₀ 0#) (lift₀ 1#)
+isRing isRing = record
+  { +-isAbelianGroup = isAbelianGroup M.+-isAbelianGroup
+  ; *-cong = λ g h _ → M.*-cong (g _) (h _)
+  ; *-assoc = λ f g h _ → M.*-assoc (f _) (g _) (h _)
+  ; *-identity = (λ f _ → M.*-identityˡ (f _)) , λ f _ → M.*-identityʳ (f _)
+  ; distrib = (λ f g h _ → M.distribˡ (f _) (g _) (h _)) , λ f g h _ → M.distribʳ (f _) (g _) (h _)
+  }
+  where module M = IsRing isRing
+
+
+------------------------------------------------------------------------
+-- Bundles
+
+magma : Magma c ℓ → Magma (a ⊔ c) (a ⊔ ℓ)
+magma m = record { isMagma = isMagma (Magma.isMagma m) }
+
+semigroup : Semigroup c ℓ → Semigroup (a ⊔ c) (a ⊔ ℓ)
+semigroup m = record { isSemigroup = isSemigroup (Semigroup.isSemigroup m) }
+
+band : Band c ℓ → Band (a ⊔ c) (a ⊔ ℓ)
+band m = record { isBand = isBand (Band.isBand m) }
+
+commutativeSemigroup : CommutativeSemigroup c ℓ → CommutativeSemigroup (a ⊔ c) (a ⊔ ℓ)
+commutativeSemigroup m = record { isCommutativeSemigroup = isCommutativeSemigroup (CommutativeSemigroup.isCommutativeSemigroup m) }
+
+monoid : Monoid c ℓ → Monoid (a ⊔ c) (a ⊔ ℓ)
+monoid m = record { isMonoid = isMonoid (Monoid.isMonoid m) }
+
+group : Group c ℓ → Group (a ⊔ c) (a ⊔ ℓ)
+group m = record { isGroup = isGroup (Group.isGroup m) }
+
+abelianGroup : AbelianGroup c ℓ → AbelianGroup (a ⊔ c) (a ⊔ ℓ)
+abelianGroup m = record { isAbelianGroup = isAbelianGroup (AbelianGroup.isAbelianGroup m) }
+
+semiring : Semiring c ℓ → Semiring (a ⊔ c) (a ⊔ ℓ)
+semiring m = record { isSemiring = isSemiring (Semiring.isSemiring m) }
+
+ring : Ring c ℓ → Ring (a ⊔ c) (a ⊔ ℓ)
+ring m = record { isRing = isRing (Ring.isRing m) }
+
diff --git a/src/Algebra/Construct/Subst/Equality.agda b/src/Algebra/Construct/Subst/Equality.agda
index 697a29cd73..6dc1ced9e2 100644
--- a/src/Algebra/Construct/Subst/Equality.agda
+++ b/src/Algebra/Construct/Subst/Equality.agda
@@ -9,7 +9,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Product as Prod
+open import Data.Product.Base as Product
 open import Relation.Binary.Core
 
 module Algebra.Construct.Subst.Equality
@@ -19,7 +19,7 @@ module Algebra.Construct.Subst.Equality
 
 open import Algebra.Definitions
 open import Algebra.Structures
-import Data.Sum as Sum
+import Data.Sum.Base as Sum
 open import Function.Base
 open import Relation.Binary.Construct.Subst.Equality equiv
 
@@ -45,13 +45,13 @@ sel : ∀ {∙} → Selective ≈₁ ∙ → Selective ≈₂ ∙
 sel sel x y = Sum.map to to (sel x y)
 
 identity : ∀ {∙ e} → Identity ≈₁ e ∙ → Identity ≈₂ e ∙
-identity = Prod.map (to ∘_) (to ∘_)
+identity = Product.map (to ∘_) (to ∘_)
 
 inverse : ∀ {∙ e ⁻¹} → Inverse ≈₁ ⁻¹ ∙ e → Inverse ≈₂ ⁻¹ ∙ e
-inverse = Prod.map (to ∘_) (to ∘_)
+inverse = Product.map (to ∘_) (to ∘_)
 
 absorptive : ∀ {∙ ◦} → Absorptive ≈₁ ∙ ◦ → Absorptive ≈₂ ∙ ◦
-absorptive = Prod.map (λ f x y → to (f x y)) (λ f x y → to (f x y))
+absorptive = Product.map (λ f x y → to (f x y)) (λ f x y → to (f x y))
 
 distribˡ : ∀ {∙ ◦} → _DistributesOverˡ_ ≈₁ ∙ ◦ → _DistributesOverˡ_ ≈₂ ∙ ◦
 distribˡ distribˡ x y z = to (distribˡ x y z)
@@ -60,7 +60,7 @@ distribʳ : ∀ {∙ ◦} → _DistributesOverʳ_ ≈₁ ∙ ◦ → _Distribute
 distribʳ distribʳ x y z = to (distribʳ x y z)
 
 distrib : ∀ {∙ ◦} → _DistributesOver_ ≈₁ ∙ ◦ → _DistributesOver_ ≈₂ ∙ ◦
-distrib {∙} {◦} = Prod.map (distribˡ {∙} {◦}) (distribʳ {∙} {◦})
+distrib {∙} {◦} = Product.map (distribˡ {∙} {◦}) (distribʳ {∙} {◦})
 
 ------------------------------------------------------------------------
 -- Structures
@@ -92,7 +92,7 @@ isSelectiveMagma S = record
 isMonoid : ∀ {∙ ε} → IsMonoid ≈₁ ∙ ε → IsMonoid ≈₂ ∙ ε
 isMonoid S = record
   { isSemigroup = isSemigroup S.isSemigroup
-  ; identity    = Prod.map (to ∘_) (to ∘_) S.identity
+  ; identity    = Product.map (to ∘_) (to ∘_) S.identity
   } where module S = IsMonoid S
 
 isCommutativeMonoid : ∀ {∙ ε} →
@@ -113,7 +113,7 @@ isIdempotentCommutativeMonoid {∙} S = record
 isGroup : ∀ {∙ ε ⁻¹} → IsGroup ≈₁ ∙ ε ⁻¹ → IsGroup ≈₂ ∙ ε ⁻¹
 isGroup S = record
   { isMonoid = isMonoid S.isMonoid
-  ; inverse  = Prod.map (to ∘_) (to ∘_) S.inverse
+  ; inverse  = Product.map (to ∘_) (to ∘_) S.inverse
   ; ⁻¹-cong  = cong₁ S.⁻¹-cong
   } where module S = IsGroup S
 
@@ -141,7 +141,7 @@ isSemiringWithoutOne {+} {*} S = record
   ; *-cong                = cong₂ S.*-cong
   ; *-assoc               = assoc {*} S.*-assoc
   ; distrib               = distrib {*} {+} S.distrib
-  ; zero                  = Prod.map (to ∘_) (to ∘_) S.zero
+  ; zero                  = Product.map (to ∘_) (to ∘_) S.zero
   } where module S = IsSemiringWithoutOne S
 
 isCommutativeSemiringWithoutOne : ∀ {+ * 0#} →
diff --git a/src/Algebra/Construct/Terminal.agda b/src/Algebra/Construct/Terminal.agda
index 4a6f1decfe..202982da50 100644
--- a/src/Algebra/Construct/Terminal.agda
+++ b/src/Algebra/Construct/Terminal.agda
@@ -1,8 +1,8 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Instances of algebraic structures where the carrier is ⊤.
--- In mathematics, this is usually called 0 (1 in the case of Group).
+-- Instances of algebraic structures where the carrier is ⊤. In
+-- mathematics, this is usually called 0 (1 in the case of Monoid, Group).
 --
 -- From monoids up, these are zero-objects – i.e, both the initial
 -- and the terminal object in the relevant category.
@@ -27,7 +27,7 @@ module 𝕆ne where
   Carrier : Set c
   Carrier = ⊤
 
-  _≈_     : Rel Carrier ℓ
+  _≈_   : Rel Carrier ℓ
   _ ≈ _ = ⊤
 
 ------------------------------------------------------------------------
@@ -42,6 +42,9 @@ rawMonoid = record { 𝕆ne }
 rawGroup : RawGroup c ℓ
 rawGroup = record { 𝕆ne }
 
+rawNearSemiring : RawNearSemiring c ℓ
+rawNearSemiring = record { 𝕆ne }
+
 rawSemiring : RawSemiring c ℓ
 rawSemiring = record { 𝕆ne }
 
@@ -78,6 +81,9 @@ group = record { 𝕆ne }
 abelianGroup : AbelianGroup c ℓ
 abelianGroup = record { 𝕆ne }
 
+nearSemiring : NearSemiring c ℓ
+nearSemiring = record { 𝕆ne }
+
 semiring : Semiring c ℓ
 semiring = record { 𝕆ne }
 
diff --git a/src/Algebra/Construct/Zero.agda b/src/Algebra/Construct/Zero.agda
index 912c3c1e8d..38bfb59b13 100644
--- a/src/Algebra/Construct/Zero.agda
+++ b/src/Algebra/Construct/Zero.agda
@@ -1,8 +1,8 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Instances of algebraic structures where the carrier is ⊤.
--- In mathematics, this is usually called 0 (1 in the case of Group).
+-- Instances of algebraic structures where the carrier is ⊤. In
+-- mathematics, this is usually called 0 (1 in the case of Monoid, Group).
 --
 -- From monoids up, these are are zero-objects – i.e, both the initial
 -- and the terminal object in the relevant category.
diff --git a/src/Algebra/Definitions.agda b/src/Algebra/Definitions.agda
index e9e082e7e1..62528e5b70 100644
--- a/src/Algebra/Definitions.agda
+++ b/src/Algebra/Definitions.agda
@@ -15,17 +15,17 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary.Core
-open import Relation.Nullary.Negation using (¬_)
+open import Relation.Binary.Core using (Rel; _Preserves_⟶_; _Preserves₂_⟶_⟶_)
+open import Relation.Nullary.Negation.Core using (¬_)
 
 module Algebra.Definitions
   {a ℓ} {A : Set a}   -- The underlying set
   (_≈_ : Rel A ℓ)     -- The underlying equality
   where
 
-open import Algebra.Core
-open import Data.Product
-open import Data.Sum.Base
+open import Algebra.Core using (Op₁; Op₂)
+open import Data.Product.Base using (_×_; ∃-syntax)
+open import Data.Sum.Base using (_⊎_)
 
 ------------------------------------------------------------------------
 -- Properties of operations
@@ -97,6 +97,8 @@ RightConical e _∙_ = ∀ x y → (x ∙ y) ≈ e → y ≈ e
 Conical : A → Op₂ A → Set _
 Conical e ∙ = (LeftConical e ∙) × (RightConical e ∙)
 
+infix 4 _DistributesOverˡ_ _DistributesOverʳ_ _DistributesOver_
+
 _DistributesOverˡ_ : Op₂ A → Op₂ A → Set _
 _*_ DistributesOverˡ _+_ =
   ∀ x y z → (x * (y + z)) ≈ ((x * y) + (x * z))
@@ -108,6 +110,12 @@ _*_ DistributesOverʳ _+_ =
 _DistributesOver_ : Op₂ A → Op₂ A → Set _
 * DistributesOver + = (* DistributesOverˡ +) × (* DistributesOverʳ +)
 
+infix 4 _MiddleFourExchange_ _IdempotentOn_ _Absorbs_
+
+_MiddleFourExchange_ : Op₂ A → Op₂ A → Set _
+_*_ MiddleFourExchange _+_ =
+  ∀ w x y z → ((w + x) * (y + z)) ≈ ((w + y) * (x + z))
+
 _IdempotentOn_ : Op₂ A → A → Set _
 _∙_ IdempotentOn x = (x ∙ x) ≈ x
 
diff --git a/src/Algebra/Definitions/RawMagma.agda b/src/Algebra/Definitions/RawMagma.agda
index 5189e02fb8..b8591e7ad2 100644
--- a/src/Algebra/Definitions/RawMagma.agda
+++ b/src/Algebra/Definitions/RawMagma.agda
@@ -10,11 +10,11 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Algebra.Bundles using (RawMagma)
-open import Data.Product using (_×_; ∃)
+open import Algebra.Bundles.Raw using (RawMagma)
+open import Data.Product.Base using (_×_; ∃)
 open import Level using (_⊔_)
-open import Relation.Binary.Core
-open import Relation.Nullary.Negation using (¬_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Nullary.Negation.Core using (¬_)
 
 module Algebra.Definitions.RawMagma
   {a ℓ} (M : RawMagma a ℓ)
@@ -25,20 +25,33 @@ open RawMagma M renaming (Carrier to A)
 ------------------------------------------------------------------------
 -- Divisibility
 
-infix 5 _∣ˡ_ _∤ˡ_ _∣ʳ_ _∤ʳ_ _∣_ _∤_
+infix 5 _∣ˡ_ _∤ˡ_ _∣ʳ_ _∤ʳ_ _∣_ _∤_ _∣∣_ _∤∤_
 
--- Divisibility from the left
-
-_∣ˡ_ : Rel A (a ⊔ ℓ)
-x ∣ˡ y = ∃ λ q → (x ∙ q) ≈ y
+-- Divisibility from the left.
+--
+-- This and, the definition of right divisibility below, are defined as
+-- records rather than in terms of the base product type in order to
+-- make the use of pattern synonyms more ergonomic (see #2216 for
+-- further details). The record field names are not designed to be
+-- used explicitly and indeed aren't re-exported publicly by
+-- `Algebra.X.Properties.Divisibility` modules.
+
+record _∣ˡ_ (x y : A) : Set (a ⊔ ℓ) where
+  constructor _,_
+  field
+    quotient : A
+    equality : x ∙ quotient ≈ y
 
 _∤ˡ_ : Rel A (a ⊔ ℓ)
 x ∤ˡ y = ¬ x ∣ˡ y
 
 -- Divisibility from the right
 
-_∣ʳ_ : Rel A (a ⊔ ℓ)
-x ∣ʳ y = ∃ λ q → (q ∙ x) ≈ y
+record _∣ʳ_ (x y : A) : Set (a ⊔ ℓ) where
+  constructor _,_
+  field
+    quotient : A
+    equality : quotient ∙ x ≈ y
 
 _∤ʳ_ : Rel A (a ⊔ ℓ)
 x ∤ʳ y = ¬ x ∣ʳ y
diff --git a/src/Algebra/Definitions/RawSemiring.agda b/src/Algebra/Definitions/RawSemiring.agda
index 01aebc2d18..b1819d856d 100644
--- a/src/Algebra/Definitions/RawSemiring.agda
+++ b/src/Algebra/Definitions/RawSemiring.agda
@@ -8,7 +8,7 @@
 
 open import Algebra.Bundles using (RawSemiring)
 open import Data.Sum.Base using (_⊎_)
-open import Data.Nat using (ℕ; zero; suc)
+open import Data.Nat.Base using (ℕ; zero; suc)
 open import Level using (_⊔_)
 open import Relation.Binary.Core using (Rel)
 
diff --git a/src/Algebra/FunctionProperties/Consequences.agda b/src/Algebra/FunctionProperties/Consequences.agda
index 03c9113995..e77b0b6d4e 100644
--- a/src/Algebra/FunctionProperties/Consequences.agda
+++ b/src/Algebra/FunctionProperties/Consequences.agda
@@ -6,7 +6,10 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; Setoid; Substitutive; Symmetric; Total)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions
+  using (Substitutive; Symmetric; Total)
 
 module Algebra.FunctionProperties.Consequences
   {a ℓ} (S : Setoid a ℓ) where
diff --git a/src/Algebra/Lattice/Bundles.agda b/src/Algebra/Lattice/Bundles.agda
index e278d0ffb4..51318bf65c 100644
--- a/src/Algebra/Lattice/Bundles.agda
+++ b/src/Algebra/Lattice/Bundles.agda
@@ -21,7 +21,8 @@ open import Algebra.Structures
 import Algebra.Lattice.Bundles.Raw as Raw
 open import Algebra.Lattice.Structures
 open import Level using (suc; _⊔_)
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Core using (Rel)
 
 ------------------------------------------------------------------------
 -- Re-export definitions of 'raw' bundles
@@ -42,7 +43,7 @@ record Semilattice c ℓ : Set (suc (c ⊔ ℓ)) where
     _∙_           : Op₂ Carrier
     isSemilattice : IsSemilattice _≈_ _∙_
 
-  open IsSemilattice isSemilattice public
+  open IsSemilattice _≈_ isSemilattice public
 
   band : Band c ℓ
   band = record { isBand = isBand }
diff --git a/src/Algebra/Lattice/Bundles/Raw.agda b/src/Algebra/Lattice/Bundles/Raw.agda
index 5ac79408a5..8b5501cb72 100644
--- a/src/Algebra/Lattice/Bundles/Raw.agda
+++ b/src/Algebra/Lattice/Bundles/Raw.agda
@@ -11,7 +11,7 @@ module Algebra.Lattice.Bundles.Raw where
 open import Algebra.Core
 open import Algebra.Bundles.Raw using (RawMagma)
 open import Level using (suc; _⊔_)
-open import Relation.Binary using (Rel)
+open import Relation.Binary.Core using (Rel)
 
 record RawLattice c ℓ : Set (suc (c ⊔ ℓ)) where
   infixr 7 _∧_
diff --git a/src/Algebra/Lattice/Construct/DirectProduct.agda b/src/Algebra/Lattice/Construct/DirectProduct.agda
index 9e2a825c99..0c68071a51 100644
--- a/src/Algebra/Lattice/Construct/DirectProduct.agda
+++ b/src/Algebra/Lattice/Construct/DirectProduct.agda
@@ -16,7 +16,7 @@
 open import Algebra
 open import Algebra.Lattice
 import Algebra.Construct.DirectProduct as DirectProduct
-open import Data.Product
+open import Data.Product.Base using (_,_; _<*>_)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent
 open import Level using (Level; _⊔_)
 
diff --git a/src/Algebra/Lattice/Construct/LiftedChoice.agda b/src/Algebra/Lattice/Construct/LiftedChoice.agda
index bcedcf2074..01cef531c6 100644
--- a/src/Algebra/Lattice/Construct/LiftedChoice.agda
+++ b/src/Algebra/Lattice/Construct/LiftedChoice.agda
@@ -9,7 +9,8 @@
 open import Algebra
 open import Algebra.Lattice
 open import Algebra.Construct.LiftedChoice
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _Preserves_⟶_)
+open import Relation.Binary.Structures using (IsEquivalence)
 open import Level using (Level)
 
 module Algebra.Lattice.Construct.LiftedChoice where
diff --git a/src/Algebra/Lattice/Construct/NaturalChoice/MaxOp.agda b/src/Algebra/Lattice/Construct/NaturalChoice/MaxOp.agda
index 445e685da0..4d00c28524 100644
--- a/src/Algebra/Lattice/Construct/NaturalChoice/MaxOp.agda
+++ b/src/Algebra/Lattice/Construct/NaturalChoice/MaxOp.agda
@@ -9,7 +9,7 @@
 
 open import Algebra.Construct.NaturalChoice.Base
 import Algebra.Lattice.Construct.NaturalChoice.MinOp as MinOp
-open import Relation.Binary
+open import Relation.Binary.Bundles using (TotalPreorder)
 
 module Algebra.Lattice.Construct.NaturalChoice.MaxOp
   {a ℓ₁ ℓ₂} {O : TotalPreorder a ℓ₁ ℓ₂} (maxOp : MaxOperator O)
diff --git a/src/Algebra/Lattice/Construct/NaturalChoice/MinMaxOp.agda b/src/Algebra/Lattice/Construct/NaturalChoice/MinMaxOp.agda
index 058bd694cf..b574147807 100644
--- a/src/Algebra/Lattice/Construct/NaturalChoice/MinMaxOp.agda
+++ b/src/Algebra/Lattice/Construct/NaturalChoice/MinMaxOp.agda
@@ -8,7 +8,7 @@
 
 open import Algebra.Lattice.Bundles
 open import Algebra.Construct.NaturalChoice.Base
-open import Relation.Binary
+open import Relation.Binary.Bundles using (TotalPreorder)
 
 module Algebra.Lattice.Construct.NaturalChoice.MinMaxOp
   {a ℓ₁ ℓ₂} {O : TotalPreorder a ℓ₁ ℓ₂}
diff --git a/src/Algebra/Lattice/Construct/NaturalChoice/MinOp.agda b/src/Algebra/Lattice/Construct/NaturalChoice/MinOp.agda
index 19468c0851..ac4328ded3 100644
--- a/src/Algebra/Lattice/Construct/NaturalChoice/MinOp.agda
+++ b/src/Algebra/Lattice/Construct/NaturalChoice/MinOp.agda
@@ -10,7 +10,7 @@
 open import Algebra.Bundles
 open import Algebra.Lattice.Bundles
 open import Algebra.Construct.NaturalChoice.Base
-open import Relation.Binary
+open import Relation.Binary.Bundles using (TotalPreorder)
 
 module Algebra.Lattice.Construct.NaturalChoice.MinOp
   {a ℓ₁ ℓ₂} {O : TotalPreorder a ℓ₁ ℓ₂} (minOp : MinOperator O) where
diff --git a/src/Algebra/Lattice/Construct/Subst/Equality.agda b/src/Algebra/Lattice/Construct/Subst/Equality.agda
index 19b4884e8e..48393f2b64 100644
--- a/src/Algebra/Lattice/Construct/Subst/Equality.agda
+++ b/src/Algebra/Lattice/Construct/Subst/Equality.agda
@@ -12,8 +12,7 @@
 open import Algebra.Core using (Op₂)
 open import Algebra.Definitions
 open import Algebra.Lattice.Structures
-import Data.Sum as Sum
-open import Data.Product as Prod
+open import Data.Product.Base using (_,_)
 open import Function.Base
 open import Relation.Binary.Core
 
@@ -36,7 +35,7 @@ isSemilattice : IsSemilattice ≈₁ ∧ → IsSemilattice ≈₂ ∧
 isSemilattice S = record
   { isBand = isBand S.isBand
   ; comm   = comm S.comm
-  } where module S = IsSemilattice S
+  } where module S = IsSemilattice ≈₁ S
 
 isLattice : IsLattice ≈₁ ∨ ∧ → IsLattice ≈₂ ∨ ∧
 isLattice {∨} {∧} S = record
diff --git a/src/Algebra/Lattice/Morphism/Construct/Composition.agda b/src/Algebra/Lattice/Morphism/Construct/Composition.agda
index 42f609c8de..fe5266af3d 100644
--- a/src/Algebra/Lattice/Morphism/Construct/Composition.agda
+++ b/src/Algebra/Lattice/Morphism/Construct/Composition.agda
@@ -57,5 +57,5 @@ module _ {L₁ : RawLattice a ℓ₁}
     → IsLatticeIsomorphism L₁ L₃ (g ∘ f)
   isLatticeIsomorphism f-iso g-iso = record
     { isLatticeMonomorphism = isLatticeMonomorphism F.isLatticeMonomorphism G.isLatticeMonomorphism
-    ; surjective            = Func.surjective (_≈_ L₁) _ _ ≈₃-trans G.⟦⟧-cong F.surjective G.surjective
+    ; surjective            = Func.surjective _ _ (_≈_ L₃) F.surjective G.surjective
     } where module F = IsLatticeIsomorphism f-iso; module G = IsLatticeIsomorphism g-iso
diff --git a/src/Algebra/Lattice/Morphism/Construct/Identity.agda b/src/Algebra/Lattice/Morphism/Construct/Identity.agda
index 9b5993696f..5fba1b976b 100644
--- a/src/Algebra/Lattice/Morphism/Construct/Identity.agda
+++ b/src/Algebra/Lattice/Morphism/Construct/Identity.agda
@@ -11,8 +11,9 @@ module Algebra.Lattice.Morphism.Construct.Identity where
 open import Algebra.Lattice.Bundles
 open import Algebra.Lattice.Morphism.Structures
   using ( module LatticeMorphisms )
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (id)
+import Function.Construct.Identity as Id
 open import Level using (Level)
 open import Relation.Binary.Morphism.Construct.Identity using (isRelHomomorphism)
 open import Relation.Binary.Definitions using (Reflexive)
@@ -40,5 +41,5 @@ module _ (L : RawLattice c ℓ) (open RawLattice L) (refl : Reflexive _≈_) whe
   isLatticeIsomorphism : IsLatticeIsomorphism id
   isLatticeIsomorphism = record
     { isLatticeMonomorphism = isLatticeMonomorphism
-    ; surjective = _, refl
+    ; surjective = Id.surjective _
     }
diff --git a/src/Algebra/Lattice/Morphism/LatticeMonomorphism.agda b/src/Algebra/Lattice/Morphism/LatticeMonomorphism.agda
index bfed8d01ec..9e16a46c4a 100644
--- a/src/Algebra/Lattice/Morphism/LatticeMonomorphism.agda
+++ b/src/Algebra/Lattice/Morphism/LatticeMonomorphism.agda
@@ -15,10 +15,10 @@ open import Algebra.Lattice.Morphism.Structures
 import Algebra.Consequences.Setoid as Consequences
 import Algebra.Morphism.MagmaMonomorphism as MagmaMonomorphisms
 import Algebra.Lattice.Properties.Lattice as LatticeProperties
-open import Data.Product using (_,_; map)
-open import Relation.Binary
+open import Data.Product.Base using (_,_; map)
+open import Relation.Binary.Bundles using (Setoid)
 import Relation.Binary.Morphism.RelMonomorphism as RelMonomorphisms
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 module Algebra.Lattice.Morphism.LatticeMonomorphism
   {a b ℓ₁ ℓ₂} {L₁ : RawLattice a ℓ₁} {L₂ : RawLattice b ℓ₂} {⟦_⟧}
@@ -73,7 +73,7 @@ module _ (⊔-⊓-isLattice : IsLattice _≈₂_ _⊔_ _⊓_) where
   setoid : Setoid b ℓ₂
   setoid = record { isEquivalence = isEquivalence }
 
-  open SetoidReasoning setoid
+  open ≈-Reasoning setoid
 
   ∨-absorbs-∧ : _Absorbs_ _≈₁_ _∨_ _∧_
   ∨-absorbs-∧ x y = injective (begin
@@ -97,8 +97,8 @@ module _ (⊔-⊓-isLattice : IsLattice _≈₂_ _⊔_ _⊓_) where
     ⟦ y ∧ z ∨ x ⟧                        ≈⟨ ∨-homo (y ∧ z) x ⟩
     ⟦ y ∧ z ⟧ ⊔ ⟦ x ⟧                    ≈⟨ ⊔-congʳ (∧-homo y z) ⟩
     ⟦ y ⟧ ⊓ ⟦ z ⟧ ⊔ ⟦ x ⟧                ≈⟨ distribʳ ⟦ x ⟧ ⟦ y ⟧ ⟦ z ⟧ ⟩
-    (⟦ y ⟧ ⊔ ⟦ x ⟧) ⊓ (⟦ z ⟧ ⊔ ⟦ x ⟧)    ≈˘⟨ ⊓-cong (∨-homo y x) (∨-homo z x) ⟩
-    ⟦ y ∨ x ⟧ ⊓ ⟦ z ∨ x ⟧                ≈˘⟨ ∧-homo (y ∨ x) (z ∨ x) ⟩
+    (⟦ y ⟧ ⊔ ⟦ x ⟧) ⊓ (⟦ z ⟧ ⊔ ⟦ x ⟧)    ≈⟨ ⊓-cong (∨-homo y x) (∨-homo z x) ⟨
+    ⟦ y ∨ x ⟧ ⊓ ⟦ z ∨ x ⟧                ≈⟨ ∧-homo (y ∨ x) (z ∨ x) ⟨
     ⟦ (y ∨ x) ∧ (z ∨ x) ⟧                ∎)
 
 isLattice : IsLattice _≈₂_ _⊔_ _⊓_ → IsLattice _≈₁_ _∨_ _∧_
diff --git a/src/Algebra/Lattice/Morphism/Structures.agda b/src/Algebra/Lattice/Morphism/Structures.agda
index 7e7c34c163..87cf92e616 100644
--- a/src/Algebra/Lattice/Morphism/Structures.agda
+++ b/src/Algebra/Lattice/Morphism/Structures.agda
@@ -12,7 +12,7 @@ open import Algebra.Morphism
 open import Algebra.Lattice.Bundles
 import Algebra.Morphism.Definitions as MorphismDefinitions
 open import Level using (Level; _⊔_)
-import Function.Definitions as FunctionDefinitions
+open import Function.Definitions
 open import Relation.Binary.Morphism.Structures
 open import Relation.Binary.Core
 
@@ -44,7 +44,6 @@ module LatticeMorphisms (L₁ : RawLattice a ℓ₁) (L₂ : RawLattice b ℓ₂
   module ∧ = MagmaMorphisms ∧-rawMagma₁ ∧-rawMagma₂
 
   open MorphismDefinitions A B _≈₂_
-  open FunctionDefinitions _≈₁_ _≈₂_
 
 
   record IsLatticeHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
@@ -71,7 +70,7 @@ module LatticeMorphisms (L₁ : RawLattice a ℓ₁) (L₂ : RawLattice b ℓ₂
   record IsLatticeMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isLatticeHomomorphism : IsLatticeHomomorphism ⟦_⟧
-      injective             : Injective ⟦_⟧
+      injective             : Injective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsLatticeHomomorphism isLatticeHomomorphism public
 
@@ -94,7 +93,7 @@ module LatticeMorphisms (L₁ : RawLattice a ℓ₁) (L₂ : RawLattice b ℓ₂
   record IsLatticeIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isLatticeMonomorphism : IsLatticeMonomorphism ⟦_⟧
-      surjective            : Surjective ⟦_⟧
+      surjective            : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsLatticeMonomorphism isLatticeMonomorphism public
 
diff --git a/src/Algebra/Lattice/Properties/BooleanAlgebra.agda b/src/Algebra/Lattice/Properties/BooleanAlgebra.agda
index 85295c9366..673434a48f 100644
--- a/src/Algebra/Lattice/Properties/BooleanAlgebra.agda
+++ b/src/Algebra/Lattice/Properties/BooleanAlgebra.agda
@@ -22,10 +22,9 @@ open import Algebra.Consequences.Setoid setoid
 open import Algebra.Bundles
 open import Algebra.Lattice.Structures _≈_
 open import Relation.Binary.Reasoning.Setoid setoid
-open import Relation.Binary
-open import Function.Base
+open import Function.Base using (id; _$_; _⟨_⟩_)
 open import Function.Bundles using (_⇔_; module Equivalence)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 
 ------------------------------------------------------------------------
 -- Export properties from distributive lattices
@@ -58,7 +57,7 @@ open DistribLatticeProperties distributiveLattice public
   x              ∎
 
 ∧-identityˡ : LeftIdentity ⊤ _∧_
-∧-identityˡ = comm+idʳ⇒idˡ ∧-comm ∧-identityʳ
+∧-identityˡ = comm∧idʳ⇒idˡ ∧-comm ∧-identityʳ
 
 ∧-identity : Identity ⊤ _∧_
 ∧-identity = ∧-identityˡ , ∧-identityʳ
@@ -70,35 +69,35 @@ open DistribLatticeProperties distributiveLattice public
   x              ∎
 
 ∨-identityˡ : LeftIdentity ⊥ _∨_
-∨-identityˡ = comm+idʳ⇒idˡ ∨-comm ∨-identityʳ
+∨-identityˡ = comm∧idʳ⇒idˡ ∨-comm ∨-identityʳ
 
 ∨-identity : Identity ⊥ _∨_
 ∨-identity = ∨-identityˡ , ∨-identityʳ
 
 ∧-zeroʳ : RightZero ⊥ _∧_
 ∧-zeroʳ x = begin
-  x ∧ ⊥          ≈˘⟨ ∧-congˡ (∧-complementʳ x) ⟩
-  x ∧  x  ∧ ¬ x  ≈˘⟨ ∧-assoc x x (¬ x) ⟩
+  x ∧ ⊥          ≈⟨ ∧-congˡ (∧-complementʳ x) ⟨
+  x ∧  x  ∧ ¬ x  ≈⟨ ∧-assoc x x (¬ x) ⟨
   (x ∧ x) ∧ ¬ x  ≈⟨  ∧-congʳ (∧-idem x) ⟩
   x       ∧ ¬ x  ≈⟨  ∧-complementʳ x ⟩
   ⊥              ∎
 
 ∧-zeroˡ : LeftZero ⊥ _∧_
-∧-zeroˡ = comm+zeʳ⇒zeˡ ∧-comm ∧-zeroʳ
+∧-zeroˡ = comm∧zeʳ⇒zeˡ ∧-comm ∧-zeroʳ
 
 ∧-zero : Zero ⊥ _∧_
 ∧-zero = ∧-zeroˡ , ∧-zeroʳ
 
 ∨-zeroʳ : ∀ x → x ∨ ⊤ ≈ ⊤
 ∨-zeroʳ x = begin
-  x ∨ ⊤          ≈˘⟨ ∨-congˡ (∨-complementʳ x) ⟩
-  x ∨  x  ∨ ¬ x  ≈˘⟨ ∨-assoc x x (¬ x) ⟩
+  x ∨ ⊤          ≈⟨ ∨-congˡ (∨-complementʳ x) ⟨
+  x ∨  x  ∨ ¬ x  ≈⟨ ∨-assoc x x (¬ x) ⟨
   (x ∨ x) ∨ ¬ x  ≈⟨ ∨-congʳ (∨-idem x) ⟩
   x       ∨ ¬ x  ≈⟨ ∨-complementʳ x ⟩
   ⊤              ∎
 
 ∨-zeroˡ : LeftZero ⊤ _∨_
-∨-zeroˡ = comm+zeʳ⇒zeˡ ∨-comm ∨-zeroʳ
+∨-zeroˡ = comm∧zeʳ⇒zeˡ ∨-comm ∨-zeroʳ
 
 ∨-zero : Zero ⊤ _∨_
 ∨-zero = ∨-zeroˡ , ∨-zeroʳ
@@ -183,12 +182,12 @@ open DistribLatticeProperties distributiveLattice public
 private
   lemma : ∀ x y → x ∧ y ≈ ⊥ → x ∨ y ≈ ⊤ → ¬ x ≈ y
   lemma x y x∧y=⊥ x∨y=⊤ = begin
-    ¬ x                ≈˘⟨ ∧-identityʳ _ ⟩
-    ¬ x ∧ ⊤            ≈˘⟨ ∧-congˡ x∨y=⊤ ⟩
+    ¬ x                ≈⟨ ∧-identityʳ _ ⟨
+    ¬ x ∧ ⊤            ≈⟨ ∧-congˡ x∨y=⊤ ⟨
     ¬ x ∧ (x ∨ y)      ≈⟨  ∧-distribˡ-∨ _ _ _ ⟩
     ¬ x ∧ x ∨ ¬ x ∧ y  ≈⟨  ∨-congʳ $ ∧-complementˡ _ ⟩
-    ⊥ ∨ ¬ x ∧ y        ≈˘⟨ ∨-congʳ x∧y=⊥ ⟩
-    x ∧ y ∨ ¬ x ∧ y    ≈˘⟨ ∧-distribʳ-∨ _ _ _ ⟩
+    ⊥ ∨ ¬ x ∧ y        ≈⟨ ∨-congʳ x∧y=⊥ ⟨
+    x ∧ y ∨ ¬ x ∧ y    ≈⟨ ∧-distribʳ-∨ _ _ _ ⟨
     (x ∨ ¬ x) ∧ y      ≈⟨  ∧-congʳ $ ∨-complementʳ _ ⟩
     ⊤ ∧ y              ≈⟨  ∧-identityˡ _ ⟩
     y                  ∎
@@ -223,7 +222,7 @@ deMorgan₁ x y = lemma (x ∧ y) (¬ x ∨ ¬ y) lem₁ lem₂
     ¬ x ∨ y                ∎
 
   lem₂ = begin
-    (x ∧ y) ∨ (¬ x ∨ ¬ y)  ≈˘⟨ ∨-assoc _ _ _ ⟩
+    (x ∧ y) ∨ (¬ x ∨ ¬ y)  ≈⟨ ∨-assoc _ _ _ ⟨
     ((x ∧ y) ∨ ¬ x) ∨ ¬ y  ≈⟨ ∨-congʳ lem₃ ⟩
     (¬ x ∨ y) ∨ ¬ y        ≈⟨ ∨-assoc _ _ _ ⟩
     ¬ x ∨ (y ∨ ¬ y)        ≈⟨ ∨-congˡ $ ∨-complementʳ _ ⟩
@@ -232,8 +231,8 @@ deMorgan₁ x y = lemma (x ∧ y) (¬ x ∨ ¬ y) lem₁ lem₂
 
 deMorgan₂ : ∀ x y → ¬ (x ∨ y) ≈ ¬ x ∧ ¬ y
 deMorgan₂ x y = begin
-  ¬ (x ∨ y)          ≈˘⟨ ¬-cong $ ((¬-involutive _) ⟨ ∨-cong ⟩ (¬-involutive _)) ⟩
-  ¬ (¬ ¬ x ∨ ¬ ¬ y)  ≈˘⟨ ¬-cong $ deMorgan₁ _ _ ⟩
+  ¬ (x ∨ y)          ≈⟨ ¬-cong $ ((¬-involutive _) ⟨ ∨-cong ⟩ (¬-involutive _)) ⟨
+  ¬ (¬ ¬ x ∨ ¬ ¬ y)  ≈⟨ ¬-cong $ deMorgan₁ _ _ ⟨
   ¬ ¬ (¬ x ∧ ¬ y)    ≈⟨ ¬-involutive _ ⟩
   ¬ x ∧ ¬ y          ∎
 
@@ -261,14 +260,14 @@ module XorRing
     x ⊕ u                ≈⟨  ⊕-def _ _ ⟩
     (x ∨ u) ∧ ¬ (x ∧ u)  ≈⟨  helper (x≈y ⟨ ∨-cong ⟩ u≈v)
                                     (x≈y ⟨ ∧-cong ⟩ u≈v) ⟩
-    (y ∨ v) ∧ ¬ (y ∧ v)  ≈˘⟨ ⊕-def _ _ ⟩
+    (y ∨ v) ∧ ¬ (y ∧ v)  ≈⟨ ⊕-def _ _ ⟨
     y ⊕ v                ∎
 
   ⊕-comm : Commutative _⊕_
   ⊕-comm x y = begin
     x ⊕ y                ≈⟨  ⊕-def _ _ ⟩
     (x ∨ y) ∧ ¬ (x ∧ y)  ≈⟨  helper (∨-comm _ _) (∧-comm _ _) ⟩
-    (y ∨ x) ∧ ¬ (y ∧ x)  ≈˘⟨ ⊕-def _ _ ⟩
+    (y ∨ x) ∧ ¬ (y ∧ x)  ≈⟨ ⊕-def _ _ ⟨
     y ⊕ x                ∎
 
   ¬-distribˡ-⊕ : ∀ x y → ¬ (x ⊕ y) ≈ ¬ x ⊕ y
@@ -280,7 +279,7 @@ module XorRing
     ¬ ((x ∧ ¬ y) ∨ (y ∧ ¬ x))              ≈⟨ deMorgan₂ _ _ ⟩
     ¬ (x ∧ ¬ y) ∧ ¬ (y ∧ ¬ x)              ≈⟨ ∧-congʳ $ deMorgan₁ _ _ ⟩
     (¬ x ∨ (¬ ¬ y)) ∧ ¬ (y ∧ ¬ x)          ≈⟨ helper (∨-congˡ $ ¬-involutive _) (∧-comm _ _) ⟩
-    (¬ x ∨ y) ∧ ¬ (¬ x ∧ y)                ≈˘⟨ ⊕-def _ _ ⟩
+    (¬ x ∨ y) ∧ ¬ (¬ x ∧ y)                ≈⟨ ⊕-def _ _ ⟨
     ¬ x ⊕ y                                ∎
     where
     lem : ∀ x y → x ∧ ¬ (x ∧ y) ≈ x ∧ ¬ y
@@ -300,7 +299,7 @@ module XorRing
 
   ⊕-annihilates-¬ : ∀ x y → x ⊕ y ≈ ¬ x ⊕ ¬ y
   ⊕-annihilates-¬ x y = begin
-    x ⊕ y        ≈˘⟨ ¬-involutive _ ⟩
+    x ⊕ y        ≈⟨ ¬-involutive _ ⟨
     ¬ ¬ (x ⊕ y)  ≈⟨  ¬-cong $ ¬-distribˡ-⊕ _ _ ⟩
     ¬ (¬ x ⊕ y)  ≈⟨  ¬-distribʳ-⊕ _ _ ⟩
     ¬ x ⊕ ¬ y    ∎
@@ -335,50 +334,50 @@ module XorRing
   ∧-distribˡ-⊕ : _∧_ DistributesOverˡ _⊕_
   ∧-distribˡ-⊕ x y z = begin
     x ∧ (y ⊕ z)                ≈⟨ ∧-congˡ $ ⊕-def _ _ ⟩
-    x ∧ ((y ∨ z) ∧ ¬ (y ∧ z))  ≈˘⟨ ∧-assoc _ _ _ ⟩
+    x ∧ ((y ∨ z) ∧ ¬ (y ∧ z))  ≈⟨ ∧-assoc _ _ _ ⟨
     (x ∧ (y ∨ z)) ∧ ¬ (y ∧ z)  ≈⟨ ∧-congˡ $ deMorgan₁ _ _ ⟩
     (x ∧ (y ∨ z)) ∧
-    (¬ y ∨ ¬ z)                ≈˘⟨ ∨-identityˡ _ ⟩
+    (¬ y ∨ ¬ z)                ≈⟨ ∨-identityˡ _ ⟨
     ⊥ ∨
     ((x ∧ (y ∨ z)) ∧
     (¬ y ∨ ¬ z))               ≈⟨ ∨-congʳ lem₃ ⟩
     ((x ∧ (y ∨ z)) ∧ ¬ x) ∨
     ((x ∧ (y ∨ z)) ∧
-    (¬ y ∨ ¬ z))               ≈˘⟨ ∧-distribˡ-∨ _ _ _ ⟩
+    (¬ y ∨ ¬ z))               ≈⟨ ∧-distribˡ-∨ _ _ _ ⟨
     (x ∧ (y ∨ z)) ∧
-    (¬ x ∨ (¬ y ∨ ¬ z))        ≈˘⟨ ∧-congˡ $ ∨-congˡ (deMorgan₁ _ _) ⟩
+    (¬ x ∨ (¬ y ∨ ¬ z))        ≈⟨ ∧-congˡ $ ∨-congˡ (deMorgan₁ _ _) ⟨
     (x ∧ (y ∨ z)) ∧
-    (¬ x ∨ ¬ (y ∧ z))          ≈˘⟨ ∧-congˡ (deMorgan₁ _ _) ⟩
+    (¬ x ∨ ¬ (y ∧ z))          ≈⟨ ∧-congˡ (deMorgan₁ _ _) ⟨
     (x ∧ (y ∨ z)) ∧
     ¬ (x ∧ (y ∧ z))            ≈⟨ helper refl lem₁ ⟩
     (x ∧ (y ∨ z)) ∧
     ¬ ((x ∧ y) ∧ (x ∧ z))      ≈⟨ ∧-congʳ $ ∧-distribˡ-∨ _ _ _ ⟩
     ((x ∧ y) ∨ (x ∧ z)) ∧
-    ¬ ((x ∧ y) ∧ (x ∧ z))      ≈˘⟨ ⊕-def _ _ ⟩
+    ¬ ((x ∧ y) ∧ (x ∧ z))      ≈⟨ ⊕-def _ _ ⟨
     (x ∧ y) ⊕ (x ∧ z)          ∎
       where
       lem₂ = begin
-        x ∧ (y ∧ z)  ≈˘⟨ ∧-assoc _ _ _ ⟩
+        x ∧ (y ∧ z)  ≈⟨ ∧-assoc _ _ _ ⟨
         (x ∧ y) ∧ z  ≈⟨ ∧-congʳ $ ∧-comm _ _ ⟩
         (y ∧ x) ∧ z  ≈⟨ ∧-assoc _ _ _ ⟩
         y ∧ (x ∧ z)  ∎
 
       lem₁ = begin
-        x ∧ (y ∧ z)        ≈˘⟨ ∧-congʳ (∧-idem _) ⟩
+        x ∧ (y ∧ z)        ≈⟨ ∧-congʳ (∧-idem _) ⟨
         (x ∧ x) ∧ (y ∧ z)  ≈⟨ ∧-assoc _ _ _ ⟩
         x ∧ (x ∧ (y ∧ z))  ≈⟨ ∧-congˡ lem₂ ⟩
-        x ∧ (y ∧ (x ∧ z))  ≈˘⟨ ∧-assoc _ _ _ ⟩
+        x ∧ (y ∧ (x ∧ z))  ≈⟨ ∧-assoc _ _ _ ⟨
         (x ∧ y) ∧ (x ∧ z)  ∎
 
       lem₃ = begin
-        ⊥                      ≈˘⟨ ∧-zeroʳ _ ⟩
-        (y ∨ z) ∧ ⊥            ≈˘⟨ ∧-congˡ (∧-complementʳ _) ⟩
-        (y ∨ z) ∧ (x ∧ ¬ x)    ≈˘⟨ ∧-assoc _ _ _ ⟩
-        ((y ∨ z) ∧ x) ∧ ¬ x    ≈⟨ ∧-comm _ _ ⟨ ∧-cong ⟩ refl  ⟩
+        ⊥                      ≈⟨ ∧-zeroʳ _ ⟨
+        (y ∨ z) ∧ ⊥            ≈⟨ ∧-congˡ (∧-complementʳ _) ⟨
+        (y ∨ z) ∧ (x ∧ ¬ x)    ≈⟨ ∧-assoc _ _ _ ⟨
+        ((y ∨ z) ∧ x) ∧ ¬ x    ≈⟨ ∧-congʳ (∧-comm _ _) ⟩
         (x ∧ (y ∨ z)) ∧ ¬ x    ∎
 
   ∧-distribʳ-⊕ : _∧_ DistributesOverʳ _⊕_
-  ∧-distribʳ-⊕ = comm+distrˡ⇒distrʳ ⊕-cong ∧-comm ∧-distribˡ-⊕
+  ∧-distribʳ-⊕ = comm∧distrˡ⇒distrʳ ⊕-cong ∧-comm ∧-distribˡ-⊕
 
   ∧-distrib-⊕ : _∧_ DistributesOver _⊕_
   ∧-distrib-⊕ = ∧-distribˡ-⊕ , ∧-distribʳ-⊕
@@ -399,10 +398,10 @@ module XorRing
 
   ⊕-assoc : Associative _⊕_
   ⊕-assoc x y z = sym $ begin
-    x ⊕ (y ⊕ z)                                ≈⟨ refl ⟨ ⊕-cong ⟩ ⊕-def _ _ ⟩
+    x ⊕ (y ⊕ z)                                ≈⟨ ⊕-cong refl (⊕-def _ _) ⟩
     x ⊕ ((y ∨ z) ∧ ¬ (y ∧ z))                  ≈⟨ ⊕-def _ _ ⟩
       (x ∨ ((y ∨ z) ∧ ¬ (y ∧ z))) ∧
-    ¬ (x ∧ ((y ∨ z) ∧ ¬ (y ∧ z)))              ≈⟨ lem₃ ⟨ ∧-cong ⟩ lem₄ ⟩
+    ¬ (x ∧ ((y ∨ z) ∧ ¬ (y ∧ z)))              ≈⟨ ∧-cong lem₃ lem₄ ⟩
     (((x ∨ y) ∨ z) ∧ ((x ∨ ¬ y) ∨ ¬ z)) ∧
     (((¬ x ∨ ¬ y) ∨ z) ∧ ((¬ x ∨ y) ∨ ¬ z))    ≈⟨ ∧-assoc _ _ _ ⟩
     ((x ∨ y) ∨ z) ∧
@@ -410,40 +409,40 @@ module XorRing
      (((¬ x ∨ ¬ y) ∨ z) ∧ ((¬ x ∨ y) ∨ ¬ z)))  ≈⟨ ∧-congˡ lem₅ ⟩
     ((x ∨ y) ∨ z) ∧
     (((¬ x ∨ ¬ y) ∨ z) ∧
-     (((x ∨ ¬ y) ∨ ¬ z) ∧ ((¬ x ∨ y) ∨ ¬ z)))  ≈˘⟨ ∧-assoc _ _ _ ⟩
+     (((x ∨ ¬ y) ∨ ¬ z) ∧ ((¬ x ∨ y) ∨ ¬ z)))  ≈⟨ ∧-assoc _ _ _ ⟨
     (((x ∨ y) ∨ z) ∧ ((¬ x ∨ ¬ y) ∨ z)) ∧
-    (((x ∨ ¬ y) ∨ ¬ z) ∧ ((¬ x ∨ y) ∨ ¬ z))    ≈⟨ lem₁ ⟨ ∧-cong ⟩ lem₂ ⟩
+    (((x ∨ ¬ y) ∨ ¬ z) ∧ ((¬ x ∨ y) ∨ ¬ z))    ≈⟨ ∧-cong lem₁ lem₂ ⟩
       (((x ∨ y) ∧ ¬ (x ∧ y)) ∨ z) ∧
-    ¬ (((x ∨ y) ∧ ¬ (x ∧ y)) ∧ z)              ≈˘⟨ ⊕-def _ _ ⟩
-    ((x ∨ y) ∧ ¬ (x ∧ y)) ⊕ z                  ≈˘⟨ ⊕-def _ _ ⟨ ⊕-cong ⟩ refl ⟩
+    ¬ (((x ∨ y) ∧ ¬ (x ∧ y)) ∧ z)              ≈⟨ ⊕-def _ _ ⟨
+    ((x ∨ y) ∧ ¬ (x ∧ y)) ⊕ z                  ≈⟨ ⊕-cong (⊕-def _ _) refl ⟨
     (x ⊕ y) ⊕ z                                ∎
     where
     lem₁ = begin
-      ((x ∨ y) ∨ z) ∧ ((¬ x ∨ ¬ y) ∨ z)  ≈˘⟨ ∨-distribʳ-∧ _ _ _ ⟩
-      ((x ∨ y) ∧ (¬ x ∨ ¬ y)) ∨ z        ≈˘⟨ ∨-congʳ $ ∧-congˡ (deMorgan₁ _ _) ⟩
+      ((x ∨ y) ∨ z) ∧ ((¬ x ∨ ¬ y) ∨ z)  ≈⟨ ∨-distribʳ-∧ _ _ _ ⟨
+      ((x ∨ y) ∧ (¬ x ∨ ¬ y)) ∨ z        ≈⟨ ∨-congʳ $ ∧-congˡ (deMorgan₁ _ _) ⟨
       ((x ∨ y) ∧ ¬ (x ∧ y)) ∨ z          ∎
 
     lem₂′ = begin
-      (x ∨ ¬ y) ∧ (¬ x ∨ y)              ≈˘⟨ ∧-identityˡ _ ⟨ ∧-cong ⟩ ∧-identityʳ _ ⟩
-      (⊤ ∧ (x ∨ ¬ y)) ∧ ((¬ x ∨ y) ∧ ⊤)  ≈˘⟨  (∨-complementˡ _ ⟨ ∧-cong ⟩ ∨-comm _ _)
-                                                ⟨ ∧-cong ⟩
-                                              (∧-congˡ $ ∨-complementˡ _) ⟩
+      (x ∨ ¬ y) ∧ (¬ x ∨ y)              ≈⟨ ∧-cong (∧-identityˡ _) (∧-identityʳ _) ⟨
+      (⊤ ∧ (x ∨ ¬ y)) ∧ ((¬ x ∨ y) ∧ ⊤)  ≈⟨ ∧-cong
+                                              (∧-cong (∨-complementˡ _) (∨-comm _ _))
+                                              (∧-congˡ $ ∨-complementˡ _) ⟨
       ((¬ x ∨ x) ∧ (¬ y ∨ x)) ∧
-      ((¬ x ∨ y) ∧ (¬ y ∨ y))            ≈˘⟨ lemma₂ _ _ _ _ ⟩
-      (¬ x ∧ ¬ y) ∨ (x ∧ y)              ≈˘⟨ deMorgan₂ _ _ ⟨ ∨-cong ⟩ ¬-involutive _ ⟩
-      ¬ (x ∨ y) ∨ ¬ ¬ (x ∧ y)            ≈˘⟨ deMorgan₁ _ _ ⟩
+      ((¬ x ∨ y) ∧ (¬ y ∨ y))            ≈⟨ lemma₂ _ _ _ _ ⟨
+      (¬ x ∧ ¬ y) ∨ (x ∧ y)              ≈⟨ ∨-cong (deMorgan₂ _ _) (¬-involutive _) ⟨
+      ¬ (x ∨ y) ∨ ¬ ¬ (x ∧ y)            ≈⟨ deMorgan₁ _ _ ⟨
       ¬ ((x ∨ y) ∧ ¬ (x ∧ y))            ∎
 
     lem₂ = begin
-      ((x ∨ ¬ y) ∨ ¬ z) ∧ ((¬ x ∨ y) ∨ ¬ z)  ≈˘⟨ ∨-distribʳ-∧ _ _ _ ⟩
+      ((x ∨ ¬ y) ∨ ¬ z) ∧ ((¬ x ∨ y) ∨ ¬ z)  ≈⟨ ∨-distribʳ-∧ _ _ _ ⟨
       ((x ∨ ¬ y) ∧ (¬ x ∨ y)) ∨ ¬ z          ≈⟨ ∨-congʳ lem₂′ ⟩
-      ¬ ((x ∨ y) ∧ ¬ (x ∧ y)) ∨ ¬ z          ≈˘⟨ deMorgan₁ _ _ ⟩
+      ¬ ((x ∨ y) ∧ ¬ (x ∧ y)) ∨ ¬ z          ≈⟨ deMorgan₁ _ _ ⟨
       ¬ (((x ∨ y) ∧ ¬ (x ∧ y)) ∧ z)          ∎
 
     lem₃ = begin
       x ∨ ((y ∨ z) ∧ ¬ (y ∧ z))          ≈⟨ ∨-congˡ $ ∧-congˡ $ deMorgan₁ _ _ ⟩
       x ∨ ((y ∨ z) ∧ (¬ y ∨ ¬ z))        ≈⟨ ∨-distribˡ-∧ _ _ _ ⟩
-      (x ∨ (y ∨ z)) ∧ (x ∨ (¬ y ∨ ¬ z))  ≈˘⟨ ∨-assoc _ _ _ ⟨ ∧-cong ⟩ ∨-assoc _ _ _ ⟩
+      (x ∨ (y ∨ z)) ∧ (x ∨ (¬ y ∨ ¬ z))  ≈⟨ ∨-assoc _ _ _ ⟨ ∧-cong ⟩ ∨-assoc _ _ _ ⟨
       ((x ∨ y) ∨ z) ∧ ((x ∨ ¬ y) ∨ ¬ z)  ∎
 
     lem₄′ = begin
@@ -463,7 +462,7 @@ module XorRing
       ¬ x ∨ ¬ ((y ∨ z) ∧ ¬ (y ∧ z))  ≈⟨ ∨-congˡ lem₄′ ⟩
       ¬ x ∨ ((y ∨ ¬ z) ∧ (¬ y ∨ z))  ≈⟨ ∨-distribˡ-∧ _ _ _ ⟩
       (¬ x ∨ (y     ∨ ¬ z)) ∧
-      (¬ x ∨ (¬ y ∨ z))              ≈˘⟨ ∨-assoc _ _ _ ⟨ ∧-cong ⟩ ∨-assoc _ _ _ ⟩
+      (¬ x ∨ (¬ y ∨ z))              ≈⟨ ∨-assoc _ _ _ ⟨ ∧-cong ⟩ ∨-assoc _ _ _ ⟨
       ((¬ x ∨ y)     ∨ ¬ z) ∧
       ((¬ x ∨ ¬ y) ∨ z)              ≈⟨ ∧-comm _ _ ⟩
       ((¬ x ∨ ¬ y) ∨ z) ∧
@@ -471,7 +470,7 @@ module XorRing
 
     lem₅ = begin
       ((x ∨ ¬ y) ∨ ¬ z) ∧
-      (((¬ x ∨ ¬ y) ∨ z) ∧ ((¬ x ∨ y) ∨ ¬ z))    ≈˘⟨ ∧-assoc _ _ _ ⟩
+      (((¬ x ∨ ¬ y) ∨ z) ∧ ((¬ x ∨ y) ∨ ¬ z))    ≈⟨ ∧-assoc _ _ _ ⟨
       (((x ∨ ¬ y) ∨ ¬ z) ∧ ((¬ x ∨ ¬ y) ∨ z)) ∧
       ((¬ x ∨ y) ∨ ¬ z)                          ≈⟨ ∧-congʳ $ ∧-comm _ _ ⟩
       (((¬ x ∨ ¬ y) ∨ z) ∧ ((x ∨ ¬ y) ∨ ¬ z)) ∧
@@ -517,7 +516,6 @@ module XorRing
     ; *-assoc = ∧-assoc
     ; *-identity = ∧-identity
     ; distrib = ∧-distrib-⊕
-    ; zero = ∧-zero
     }
 
   ⊕-∧-isCommutativeRing : IsCommutativeRing _⊕_ _∧_ id ⊥ ⊤
diff --git a/src/Algebra/Lattice/Properties/BooleanAlgebra/Expression.agda b/src/Algebra/Lattice/Properties/BooleanAlgebra/Expression.agda
index 587a5dcc2c..96e6b69103 100644
--- a/src/Algebra/Lattice/Properties/BooleanAlgebra/Expression.agda
+++ b/src/Algebra/Lattice/Properties/BooleanAlgebra/Expression.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Algebra.Lattice
+open import Algebra.Lattice using (BooleanAlgebra; isBooleanAlgebraʳ;
+  isDistributiveLatticeʳʲᵐ)
 
 module Algebra.Lattice.Properties.BooleanAlgebra.Expression
   {b} (B : BooleanAlgebra b b)
@@ -14,19 +15,20 @@ module Algebra.Lattice.Properties.BooleanAlgebra.Expression
 
 open BooleanAlgebra B
 
-open import Effect.Applicative as Applicative
-open import Effect.Monad
 open import Data.Fin.Base using (Fin)
-open import Data.Nat.Base
-open import Data.Product using (_,_; proj₁; proj₂)
+open import Data.Nat.Base using (ℕ)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Data.Vec.Base as Vec using (Vec)
-import Data.Vec.Effectful as VecCat
-import Function.Identity.Effectful as IdCat
+import Data.Vec.Effectful as Vec
+import Function.Identity.Effectful as Identity
 open import Data.Vec.Properties using (lookup-map)
 open import Data.Vec.Relation.Binary.Pointwise.Extensional as PW
   using (Pointwise; ext)
-open import Function
-open import Relation.Binary.PropositionalEquality as P using (_≗_)
+open import Effect.Applicative as Applicative
+open import Function.Base using (_∘_; _$_; flip)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≗_)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 import Relation.Binary.Reflection as Reflection
 
 -- Expressions made up of variables and the operations of a boolean
@@ -68,7 +70,7 @@ module Naturality
   (f : Applicative.Morphism A₁ A₂)
   where
 
-  open P.≡-Reasoning
+  open ≡-Reasoning
   open Applicative.Morphism f
   open Semantics A₁ renaming (⟦_⟧ to ⟦_⟧₁)
   open Semantics A₂ renaming (⟦_⟧ to ⟦_⟧₂)
@@ -77,21 +79,21 @@ module Naturality
 
   natural : ∀ {n} (e : Expr n) → op ∘ ⟦ e ⟧₁ ≗ ⟦ e ⟧₂ ∘ Vec.map op
   natural (var x) ρ = begin
-    op (Vec.lookup ρ x)                                            ≡⟨ P.sym $ lookup-map x op ρ ⟩
+    op (Vec.lookup ρ x)                                            ≡⟨ ≡.sym $ lookup-map x op ρ ⟩
     Vec.lookup (Vec.map op ρ) x                                    ∎
   natural (e₁ or e₂) ρ = begin
     op (_∨_ <$>₁ ⟦ e₁ ⟧₁ ρ ⊛₁ ⟦ e₂ ⟧₁ ρ)                       ≡⟨ op-⊛ _ _ ⟩
-    op (_∨_ <$>₁ ⟦ e₁ ⟧₁ ρ) ⊛₂ op (⟦ e₂ ⟧₁ ρ)                  ≡⟨ P.cong₂ _⊛₂_ (op-<$> _ _) P.refl ⟩
-    _∨_ <$>₂ op (⟦ e₁ ⟧₁ ρ) ⊛₂ op (⟦ e₂ ⟧₁ ρ)                  ≡⟨ P.cong₂ (λ e₁ e₂ → _∨_ <$>₂ e₁ ⊛₂ e₂) (natural e₁ ρ) (natural e₂ ρ) ⟩
+    op (_∨_ <$>₁ ⟦ e₁ ⟧₁ ρ) ⊛₂ op (⟦ e₂ ⟧₁ ρ)                  ≡⟨ ≡.cong₂ _⊛₂_ (op-<$> _ _) ≡.refl ⟩
+    _∨_ <$>₂ op (⟦ e₁ ⟧₁ ρ) ⊛₂ op (⟦ e₂ ⟧₁ ρ)                  ≡⟨ ≡.cong₂ (λ e₁ e₂ → _∨_ <$>₂ e₁ ⊛₂ e₂) (natural e₁ ρ) (natural e₂ ρ) ⟩
     _∨_ <$>₂ ⟦ e₁ ⟧₂ (Vec.map op ρ) ⊛₂ ⟦ e₂ ⟧₂ (Vec.map op ρ)  ∎
   natural (e₁ and e₂) ρ = begin
     op (_∧_ <$>₁ ⟦ e₁ ⟧₁ ρ ⊛₁ ⟦ e₂ ⟧₁ ρ)                       ≡⟨ op-⊛ _ _ ⟩
-    op (_∧_ <$>₁ ⟦ e₁ ⟧₁ ρ) ⊛₂ op (⟦ e₂ ⟧₁ ρ)                  ≡⟨ P.cong₂ _⊛₂_ (op-<$> _ _) P.refl ⟩
-    _∧_ <$>₂ op (⟦ e₁ ⟧₁ ρ) ⊛₂ op (⟦ e₂ ⟧₁ ρ)                  ≡⟨ P.cong₂ (λ e₁ e₂ → _∧_ <$>₂ e₁ ⊛₂ e₂) (natural e₁ ρ) (natural e₂ ρ) ⟩
+    op (_∧_ <$>₁ ⟦ e₁ ⟧₁ ρ) ⊛₂ op (⟦ e₂ ⟧₁ ρ)                  ≡⟨ ≡.cong₂ _⊛₂_ (op-<$> _ _) ≡.refl ⟩
+    _∧_ <$>₂ op (⟦ e₁ ⟧₁ ρ) ⊛₂ op (⟦ e₂ ⟧₁ ρ)                  ≡⟨ ≡.cong₂ (λ e₁ e₂ → _∧_ <$>₂ e₁ ⊛₂ e₂) (natural e₁ ρ) (natural e₂ ρ) ⟩
     _∧_ <$>₂ ⟦ e₁ ⟧₂ (Vec.map op ρ) ⊛₂ ⟦ e₂ ⟧₂ (Vec.map op ρ)  ∎
   natural (not e) ρ = begin
     op (¬_ <$>₁ ⟦ e ⟧₁ ρ)                                      ≡⟨ op-<$> _ _ ⟩
-    ¬_ <$>₂ op (⟦ e ⟧₁ ρ)                                      ≡⟨ P.cong (¬_ <$>₂_) (natural e ρ) ⟩
+    ¬_ <$>₂ op (⟦ e ⟧₁ ρ)                                      ≡⟨ ≡.cong (¬_ <$>₂_) (natural e ρ) ⟩
     ¬_ <$>₂ ⟦ e ⟧₂ (Vec.map op ρ)                              ∎
   natural top ρ = begin
     op (pure₁ ⊤)                                                   ≡⟨ op-pure _ ⟩
@@ -165,18 +167,18 @@ lift n = record
     }
   }
   where
-  open RawApplicative VecCat.applicative
+  open RawApplicative Vec.applicative
     using (pure; zipWith) renaming (_<$>_ to map)
 
   ⟦_⟧Id : ∀ {n} → Expr n → Vec Carrier n → Carrier
-  ⟦_⟧Id = Semantics.⟦_⟧ IdCat.applicative
+  ⟦_⟧Id = Semantics.⟦_⟧ Identity.applicative
 
   ⟦_⟧Vec : ∀ {m n} → Expr n → Vec (Vec Carrier m) n → Vec Carrier m
-  ⟦_⟧Vec = Semantics.⟦_⟧ VecCat.applicative
+  ⟦_⟧Vec = Semantics.⟦_⟧ Vec.applicative
 
   open module R {n} (i : Fin n) =
     Reflection setoid var
       (λ e ρ → Vec.lookup (⟦ e ⟧Vec ρ) i)
       (λ e ρ → ⟦ e ⟧Id (Vec.map (flip Vec.lookup i) ρ))
       (λ e ρ → sym $ reflexive $
-                 Naturality.natural (VecCat.lookup-morphism i) e ρ)
+                 Naturality.natural (Vec.lookup-morphism i) e ρ)
diff --git a/src/Algebra/Lattice/Properties/Lattice.agda b/src/Algebra/Lattice/Properties/Lattice.agda
index 747541e49c..281330ef15 100644
--- a/src/Algebra/Lattice/Properties/Lattice.agda
+++ b/src/Algebra/Lattice/Properties/Lattice.agda
@@ -8,10 +8,10 @@
 
 open import Algebra.Lattice.Bundles
 import Algebra.Lattice.Properties.Semilattice as SemilatticeProperties
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Poset)
 import Relation.Binary.Lattice as R
 open import Function.Base
-open import Data.Product using (_,_; swap)
+open import Data.Product.Base using (_,_; swap)
 
 module Algebra.Lattice.Properties.Lattice
   {l₁ l₂} (L : Lattice l₁ l₂) where
@@ -27,7 +27,7 @@ open import Relation.Binary.Reasoning.Setoid setoid
 
 ∧-idem : Idempotent _∧_
 ∧-idem x = begin
-  x ∧ x            ≈˘⟨ ∧-congˡ (∨-absorbs-∧ _ _) ⟩
+  x ∧ x            ≈⟨ ∧-congˡ (∨-absorbs-∧ _ _) ⟨
   x ∧ (x ∨ x ∧ x)  ≈⟨  ∧-absorbs-∨ _ _ ⟩
   x                ∎
 
@@ -73,7 +73,7 @@ open SemilatticeProperties ∧-semilattice public
 
 ∨-idem : Idempotent _∨_
 ∨-idem x = begin
-  x ∨ x      ≈˘⟨ ∨-congˡ (∧-idem _) ⟩
+  x ∨ x      ≈⟨ ∨-congˡ (∧-idem _) ⟨
   x ∨ x ∧ x  ≈⟨  ∨-absorbs-∧ _ _ ⟩
   x          ∎
 
diff --git a/src/Algebra/Lattice/Properties/Semilattice.agda b/src/Algebra/Lattice/Properties/Semilattice.agda
index 4b8fc114fc..7b8135ced7 100644
--- a/src/Algebra/Lattice/Properties/Semilattice.agda
+++ b/src/Algebra/Lattice/Properties/Semilattice.agda
@@ -6,11 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Algebra.Lattice
-open import Algebra.Structures
-open import Function
-open import Data.Product
-open import Relation.Binary
+open import Algebra.Lattice.Bundles using (Semilattice)
+open import Relation.Binary.Bundles using (Poset)
 import Relation.Binary.Lattice as B
 import Relation.Binary.Properties.Poset as PosetProperties
 
@@ -30,8 +27,8 @@ import Relation.Binary.Construct.NaturalOrder.Left _≈_ _∧_
 poset : Poset c ℓ ℓ
 poset = LeftNaturalOrder.poset isSemilattice
 
-open Poset poset using (_≤_; isPartialOrder)
-open PosetProperties poset using (_≥_; ≥-isPartialOrder)
+open Poset poset using (_≤_; _≥_; isPartialOrder)
+open PosetProperties poset using (≥-isPartialOrder)
 
 ------------------------------------------------------------------------
 -- Every algebraic semilattice can be turned into an order-theoretic one.
diff --git a/src/Algebra/Lattice/Structures.agda b/src/Algebra/Lattice/Structures.agda
index 8e80c4a87b..c82ed2db9e 100644
--- a/src/Algebra/Lattice/Structures.agda
+++ b/src/Algebra/Lattice/Structures.agda
@@ -14,9 +14,11 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra.Core
-open import Data.Product using (proj₁; proj₂)
+open import Data.Product.Base using (proj₁; proj₂)
 open import Level using (_⊔_)
-open import Relation.Binary using (Rel; Setoid; IsEquivalence)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
 
 module Algebra.Lattice.Structures
   {a ℓ} {A : Set a}  -- The underlying set
@@ -29,26 +31,20 @@ open import Algebra.Structures _≈_
 ------------------------------------------------------------------------
 -- Structures with 1 binary operation
 
-record IsSemilattice (∙ : Op₂ A) : Set (a ⊔ ℓ) where
-  field
-    isBand : IsBand ∙
-    comm   : Commutative ∙
-
+IsSemilattice = IsCommutativeBand
+module IsSemilattice {∙} (L : IsSemilattice ∙) where
+  open IsCommutativeBand L public
+    using (isBand; comm)
   open IsBand isBand public
-    renaming
-    ( ∙-cong  to ∧-cong
-    ; ∙-congˡ to ∧-congˡ
-    ; ∙-congʳ to ∧-congʳ
-    )
 
 -- Used to bring names appropriate for a meet semilattice into scope.
 IsMeetSemilattice = IsSemilattice
 module IsMeetSemilattice {∧} (L : IsMeetSemilattice ∧) where
   open IsSemilattice L public
     renaming
-    ( ∧-cong  to ∧-cong
-    ; ∧-congˡ to ∧-congˡ
-    ; ∧-congʳ to ∧-congʳ
+    ( ∙-cong  to ∧-cong
+    ; ∙-congˡ to ∧-congˡ
+    ; ∙-congʳ to ∧-congʳ
     )
 
 -- Used to bring names appropriate for a join semilattice into scope.
@@ -56,9 +52,9 @@ IsJoinSemilattice = IsSemilattice
 module IsJoinSemilattice {∨} (L : IsJoinSemilattice ∨) where
   open IsSemilattice L public
     renaming
-    ( ∧-cong  to ∨-cong
-    ; ∧-congˡ to ∨-congˡ
-    ; ∧-congʳ to ∨-congʳ
+    ( ∙-cong  to ∨-cong
+    ; ∙-congˡ to ∨-congˡ
+    ; ∙-congʳ to ∨-congʳ
     )
 
 ------------------------------------------------------------------------
@@ -70,12 +66,7 @@ IsBoundedSemilattice = IsIdempotentCommutativeMonoid
 module IsBoundedSemilattice {∙ ε} (L : IsBoundedSemilattice ∙ ε) where
 
   open IsIdempotentCommutativeMonoid L public
-
-  isSemilattice : IsSemilattice ∙
-  isSemilattice = record
-    { isBand = isBand
-    ; comm   = comm
-    }
+    renaming (isCommutativeBand to isSemilattice)
 
 
 -- Used to bring names appropriate for a bounded meet semilattice
diff --git a/src/Algebra/Lattice/Structures/Biased.agda b/src/Algebra/Lattice/Structures/Biased.agda
index 66a93df06d..5da9714354 100644
--- a/src/Algebra/Lattice/Structures/Biased.agda
+++ b/src/Algebra/Lattice/Structures/Biased.agda
@@ -14,9 +14,11 @@
 
 open import Algebra.Core
 open import Algebra.Consequences.Setoid
-open import Data.Product using (proj₁; proj₂)
+open import Data.Product.Base using (proj₁; proj₂)
 open import Level using (_⊔_)
-open import Relation.Binary using (Rel; Setoid; IsEquivalence)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
 
 module Algebra.Lattice.Structures.Biased
   {a ℓ} {A : Set a}  -- The underlying set
@@ -80,9 +82,9 @@ record IsDistributiveLatticeʳʲᵐ (∨ ∧ : Op₂ A) : Set (a ⊔ ℓ) where
   setoid : Setoid a ℓ
   setoid = record { isEquivalence = isEquivalence }
 
-  ∨-distrib-∧  = comm+distrʳ⇒distr setoid ∧-cong ∨-comm ∨-distribʳ-∧
-  ∧-distribˡ-∨ = distrib+absorbs⇒distribˡ setoid ∧-cong ∧-assoc ∨-comm ∧-absorbs-∨ ∨-absorbs-∧ ∨-distrib-∧
-  ∧-distrib-∨  = comm+distrˡ⇒distr setoid ∨-cong ∧-comm ∧-distribˡ-∨
+  ∨-distrib-∧  = comm∧distrʳ⇒distr setoid ∧-cong ∨-comm ∨-distribʳ-∧
+  ∧-distribˡ-∨ = distrib∧absorbs⇒distribˡ setoid ∧-cong ∧-assoc ∨-comm ∧-absorbs-∨ ∨-absorbs-∧ ∨-distrib-∧
+  ∧-distrib-∨  = comm∧distrˡ⇒distr setoid ∨-cong ∧-comm ∧-distribˡ-∨
 
   isDistributiveLatticeʳʲᵐ : IsDistributiveLattice ∨ ∧
   isDistributiveLatticeʳʲᵐ = record
@@ -113,8 +115,8 @@ record IsBooleanAlgebraʳ
   isBooleanAlgebraʳ : IsBooleanAlgebra  ∨ ∧ ¬ ⊤ ⊥
   isBooleanAlgebraʳ = record
     { isDistributiveLattice = isDistributiveLattice
-    ; ∨-complement          = comm+invʳ⇒inv setoid ∨-comm ∨-complementʳ
-    ; ∧-complement          = comm+invʳ⇒inv setoid ∧-comm ∧-complementʳ
+    ; ∨-complement          = comm∧invʳ⇒inv setoid ∨-comm ∨-complementʳ
+    ; ∧-complement          = comm∧invʳ⇒inv setoid ∧-comm ∧-complementʳ
     ; ¬-cong                = ¬-cong
     }
 
diff --git a/src/Algebra/Module/Bundles.agda b/src/Algebra/Module/Bundles.agda
index e6b33ed065..5df96258d6 100644
--- a/src/Algebra/Module/Bundles.agda
+++ b/src/Algebra/Module/Bundles.agda
@@ -28,20 +28,31 @@ module Algebra.Module.Bundles where
 open import Algebra.Bundles
 open import Algebra.Core
 open import Algebra.Definitions using (Involutive)
+import Algebra.Module.Bundles.Raw as Raw
 open import Algebra.Module.Core
 open import Algebra.Module.Structures
 open import Algebra.Module.Definitions
 open import Algebra.Properties.Group
 open import Function.Base
 open import Level
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
 open import Relation.Nullary    using (¬_)
-import Relation.Binary.Reasoning.Setoid as SetR
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 private
   variable
     r ℓr s ℓs : Level
 
+------------------------------------------------------------------------
+-- Re-export definitions of 'raw' bundles
+
+open Raw public
+  using ( RawLeftSemimodule; RawLeftModule
+        ; RawRightSemimodule; RawRightModule
+        ; RawBisemimodule; RawBimodule
+        ; RawSemimodule; RawModule
+        )
+
 ------------------------------------------------------------------------
 -- Left modules
 ------------------------------------------------------------------------
@@ -62,10 +73,6 @@ record LeftSemimodule (semiring : Semiring r ℓr) m ℓm
     0ᴹ : Carrierᴹ
     isLeftSemimodule : IsLeftSemimodule semiring _≈ᴹ_ _+ᴹ_ 0ᴹ _*ₗ_
 
-  infix 4 _≉ᴹ_
-  _≉ᴹ_ : Rel Carrierᴹ _
-  a ≉ᴹ b = ¬ (a ≈ᴹ b)
-
   open IsLeftSemimodule isLeftSemimodule public
 
   +ᴹ-commutativeMonoid : CommutativeMonoid m ℓm
@@ -80,8 +87,17 @@ record LeftSemimodule (semiring : Semiring r ℓr) m ℓm
     ; magma     to +ᴹ-magma
     ; rawMagma  to +ᴹ-rawMagma
     ; rawMonoid to +ᴹ-rawMonoid
+    ; _≉_ to _≉ᴹ_
     )
 
+  rawLeftSemimodule : RawLeftSemimodule Carrier m ℓm
+  rawLeftSemimodule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ₗ_ = _*ₗ_
+    ; 0ᴹ = 0ᴹ
+    }
+
 record LeftModule (ring : Ring r ℓr) m ℓm : Set (r ⊔ ℓr ⊔ suc (m ⊔ ℓm)) where
   open Ring ring
 
@@ -106,7 +122,7 @@ record LeftModule (ring : Ring r ℓr) m ℓm : Set (r ⊔ ℓr ⊔ suc (m ⊔ 
 
   open LeftSemimodule leftSemimodule public
     using ( +ᴹ-commutativeMonoid; +ᴹ-monoid; +ᴹ-semigroup; +ᴹ-magma
-          ; +ᴹ-rawMagma; +ᴹ-rawMonoid; _≉ᴹ_)
+          ; +ᴹ-rawMagma; +ᴹ-rawMonoid; rawLeftSemimodule; _≉ᴹ_)
 
   +ᴹ-abelianGroup : AbelianGroup m ℓm
   +ᴹ-abelianGroup = record { isAbelianGroup = +ᴹ-isAbelianGroup }
@@ -114,6 +130,15 @@ record LeftModule (ring : Ring r ℓr) m ℓm : Set (r ⊔ ℓr ⊔ suc (m ⊔ 
   open AbelianGroup +ᴹ-abelianGroup public
     using () renaming (group to +ᴹ-group; rawGroup to +ᴹ-rawGroup)
 
+  rawLeftModule : RawLeftModule Carrier m ℓm
+  rawLeftModule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ₗ_ = _*ₗ_
+    ; 0ᴹ = 0ᴹ
+    ; -ᴹ_ = -ᴹ_
+    }
+
 ------------------------------------------------------------------------
 -- Right modules
 ------------------------------------------------------------------------
@@ -134,10 +159,6 @@ record RightSemimodule (semiring : Semiring r ℓr) m ℓm
     0ᴹ : Carrierᴹ
     isRightSemimodule : IsRightSemimodule semiring _≈ᴹ_ _+ᴹ_ 0ᴹ _*ᵣ_
 
-  infix 4 _≉ᴹ_
-  _≉ᴹ_ : Rel Carrierᴹ _
-  a ≉ᴹ b = ¬ (a ≈ᴹ b)
-
   open IsRightSemimodule isRightSemimodule public
 
   +ᴹ-commutativeMonoid : CommutativeMonoid m ℓm
@@ -152,8 +173,17 @@ record RightSemimodule (semiring : Semiring r ℓr) m ℓm
     ; magma     to +ᴹ-magma
     ; rawMagma  to +ᴹ-rawMagma
     ; rawMonoid to +ᴹ-rawMonoid
+    ; _≉_ to _≉ᴹ_
     )
 
+  rawRightSemimodule : RawRightSemimodule Carrier m ℓm
+  rawRightSemimodule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ᵣ_ = _*ᵣ_
+    ; 0ᴹ = 0ᴹ
+    }
+
 record RightModule (ring : Ring r ℓr) m ℓm : Set (r ⊔ ℓr ⊔ suc (m ⊔ ℓm)) where
   open Ring ring
 
@@ -178,7 +208,7 @@ record RightModule (ring : Ring r ℓr) m ℓm : Set (r ⊔ ℓr ⊔ suc (m ⊔
 
   open RightSemimodule rightSemimodule public
     using ( +ᴹ-commutativeMonoid; +ᴹ-monoid; +ᴹ-semigroup; +ᴹ-magma
-          ; +ᴹ-rawMagma; +ᴹ-rawMonoid; _≉ᴹ_)
+          ; +ᴹ-rawMagma; +ᴹ-rawMonoid; rawRightSemimodule; _≉ᴹ_)
 
   +ᴹ-abelianGroup : AbelianGroup m ℓm
   +ᴹ-abelianGroup = record { isAbelianGroup = +ᴹ-isAbelianGroup }
@@ -186,6 +216,15 @@ record RightModule (ring : Ring r ℓr) m ℓm : Set (r ⊔ ℓr ⊔ suc (m ⊔
   open AbelianGroup +ᴹ-abelianGroup public
     using () renaming (group to +ᴹ-group; rawGroup to +ᴹ-rawGroup)
 
+  rawRightModule : RawRightModule Carrier m ℓm
+  rawRightModule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ᵣ_ = _*ᵣ_
+    ; 0ᴹ = 0ᴹ
+    ; -ᴹ_ = -ᴹ_
+    }
+
 ------------------------------------------------------------------------
 -- Bimodules
 ------------------------------------------------------------------------
@@ -220,7 +259,19 @@ record Bisemimodule (R-semiring : Semiring r ℓr) (S-semiring : Semiring s ℓs
 
   open LeftSemimodule leftSemimodule public
     using ( +ᴹ-commutativeMonoid; +ᴹ-monoid; +ᴹ-semigroup; +ᴹ-magma; +ᴹ-rawMagma
-          ; +ᴹ-rawMonoid; _≉ᴹ_)
+          ; +ᴹ-rawMonoid; rawLeftSemimodule; _≉ᴹ_)
+
+  open RightSemimodule rightSemimodule public
+    using ( rawRightSemimodule )
+
+  rawBisemimodule : RawBisemimodule R.Carrier S.Carrier m ℓm
+  rawBisemimodule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ₗ_ = _*ₗ_
+    ; _*ᵣ_ = _*ᵣ_
+    ; 0ᴹ = 0ᴹ
+    }
 
 record Bimodule (R-ring : Ring r ℓr) (S-ring : Ring s ℓs) m ℓm
                 : Set (r ⊔ s ⊔ ℓr ⊔ ℓs ⊔ suc (m ⊔ ℓm)) where
@@ -228,6 +279,7 @@ record Bimodule (R-ring : Ring r ℓr) (S-ring : Ring s ℓs) m ℓm
     module R = Ring R-ring
     module S = Ring S-ring
 
+  infix 8 -ᴹ_
   infixr 7 _*ₗ_
   infixl 7 _*ᵣ_
   infixl 6 _+ᴹ_
@@ -254,13 +306,26 @@ record Bimodule (R-ring : Ring r ℓr) (S-ring : Ring s ℓs) m ℓm
   open LeftModule leftModule public
     using ( +ᴹ-abelianGroup; +ᴹ-commutativeMonoid; +ᴹ-group; +ᴹ-monoid
           ; +ᴹ-semigroup; +ᴹ-magma; +ᴹ-rawMagma; +ᴹ-rawMonoid; +ᴹ-rawGroup
-          ; _≉ᴹ_)
+          ; rawLeftSemimodule; rawLeftModule; _≉ᴹ_)
+
+  open RightModule rightModule public
+    using ( rawRightSemimodule; rawRightModule )
 
   bisemimodule : Bisemimodule R.semiring S.semiring m ℓm
   bisemimodule = record { isBisemimodule = isBisemimodule }
 
   open Bisemimodule bisemimodule public
-    using (leftSemimodule; rightSemimodule)
+    using (leftSemimodule; rightSemimodule; rawBisemimodule)
+
+  rawBimodule : RawBimodule R.Carrier S.Carrier m ℓm
+  rawBimodule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ₗ_ = _*ₗ_
+    ; _*ᵣ_ = _*ᵣ_
+    ; 0ᴹ = 0ᴹ
+    ; -ᴹ_ = -ᴹ_
+    }
 
 ------------------------------------------------------------------------
 -- Modules over commutative structures
@@ -296,9 +361,11 @@ record Semimodule (commutativeSemiring : CommutativeSemiring r ℓr) m ℓm
   open Bisemimodule bisemimodule public
     using ( leftSemimodule; rightSemimodule
           ; +ᴹ-commutativeMonoid; +ᴹ-monoid; +ᴹ-semigroup; +ᴹ-magma
-          ; +ᴹ-rawMagma; +ᴹ-rawMonoid; _≉ᴹ_)
+          ; +ᴹ-rawMagma; +ᴹ-rawMonoid; rawLeftSemimodule; rawRightSemimodule
+          ; rawBisemimodule; _≉ᴹ_
+          )
 
-  open SetR ≈ᴹ-setoid
+  open ≈-Reasoning ≈ᴹ-setoid
 
   *ₗ-comm : L.Commutative _*ₗ_
   *ₗ-comm x y m = begin
@@ -314,6 +381,9 @@ record Semimodule (commutativeSemiring : CommutativeSemiring r ℓr) m ℓm
     m *ᵣ (y * x)  ≈⟨ ≈ᴹ-sym (*ᵣ-assoc m y x) ⟩
     m *ᵣ y *ᵣ x   ∎
 
+  rawSemimodule : RawSemimodule Carrier m ℓm
+  rawSemimodule = rawBisemimodule
+
 record Module (commutativeRing : CommutativeRing r ℓr) m ℓm
               : Set (r ⊔ ℓr ⊔ suc (m ⊔ ℓm)) where
   open CommutativeRing commutativeRing
@@ -343,9 +413,13 @@ record Module (commutativeRing : CommutativeRing r ℓr) m ℓm
     using ( leftModule; rightModule; leftSemimodule; rightSemimodule
           ; +ᴹ-abelianGroup; +ᴹ-group; +ᴹ-commutativeMonoid; +ᴹ-monoid
           ; +ᴹ-semigroup; +ᴹ-magma ; +ᴹ-rawMonoid; +ᴹ-rawMagma
-          ; +ᴹ-rawGroup; _≉ᴹ_)
+          ; +ᴹ-rawGroup; rawLeftSemimodule; rawLeftModule; rawRightSemimodule
+          ; rawRightModule; rawBisemimodule; rawBimodule; _≉ᴹ_)
 
   semimodule : Semimodule commutativeSemiring m ℓm
   semimodule = record { isSemimodule = isSemimodule }
 
-  open Semimodule semimodule public using (*ₗ-comm; *ᵣ-comm)
+  open Semimodule semimodule public using (*ₗ-comm; *ᵣ-comm; rawSemimodule)
+
+  rawModule : RawModule Carrier m ℓm
+  rawModule = rawBimodule
diff --git a/src/Algebra/Module/Bundles/Raw.agda b/src/Algebra/Module/Bundles/Raw.agda
new file mode 100644
index 0000000000..2eb280875f
--- /dev/null
+++ b/src/Algebra/Module/Bundles/Raw.agda
@@ -0,0 +1,251 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Definitions of 'raw' bundles for module-like algebraic structures
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Algebra.Module.Bundles.Raw where
+
+open import Algebra.Bundles.Raw
+open import Algebra.Core
+open import Algebra.Module.Core
+open import Level
+open import Relation.Nullary.Negation.Core using (¬_)
+open import Relation.Binary.Core using (Rel)
+
+private
+  variable
+    r ℓr s ℓs : Level
+
+------------------------------------------------------------------------
+-- Raw left modules
+------------------------------------------------------------------------
+
+record RawLeftSemimodule (R : Set r) m ℓm : Set (r ⊔ suc (m ⊔ ℓm)) where
+  infixr 7 _*ₗ_
+  infixl 6 _+ᴹ_
+  infix 4 _≈ᴹ_
+
+  field
+    Carrierᴹ : Set m
+    _≈ᴹ_ : Rel Carrierᴹ ℓm
+    _+ᴹ_ : Op₂ Carrierᴹ
+    _*ₗ_ : Opₗ R Carrierᴹ
+    0ᴹ : Carrierᴹ
+
+  +ᴹ-rawMonoid : RawMonoid m ℓm
+  +ᴹ-rawMonoid = record
+    { _≈_ = _≈ᴹ_
+    ; _∙_ = _+ᴹ_
+    ; ε = 0ᴹ
+    }
+
+  open RawMonoid +ᴹ-rawMonoid public
+    using ()
+    renaming (rawMagma to +ᴹ-rawMagma; _≉_ to _≉ᴹ_)
+
+record RawLeftModule (R : Set r) m ℓm : Set (r ⊔ suc (m ⊔ ℓm)) where
+  infix 8 -ᴹ_
+  infixr 7 _*ₗ_
+  infixl 6 _+ᴹ_
+  infix 4 _≈ᴹ_
+
+  field
+    Carrierᴹ : Set m
+    _≈ᴹ_ : Rel Carrierᴹ ℓm
+    _+ᴹ_ : Op₂ Carrierᴹ
+    _*ₗ_ : Opₗ R Carrierᴹ
+    0ᴹ : Carrierᴹ
+    -ᴹ_ : Op₁ Carrierᴹ
+
+  rawLeftSemimodule : RawLeftSemimodule R m ℓm
+  rawLeftSemimodule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ₗ_ = _*ₗ_
+    ; 0ᴹ = 0ᴹ
+    }
+
+  open RawLeftSemimodule rawLeftSemimodule public
+    using (+ᴹ-rawMagma; +ᴹ-rawMonoid; _≉ᴹ_)
+
+  +ᴹ-rawGroup : RawGroup m ℓm
+  +ᴹ-rawGroup = record
+    { _≈_ = _≈ᴹ_
+    ; _∙_ = _+ᴹ_
+    ; ε = 0ᴹ
+    ; _⁻¹ = -ᴹ_
+    }
+
+------------------------------------------------------------------------
+-- Raw right modules
+------------------------------------------------------------------------
+
+record RawRightSemimodule (R : Set r) m ℓm : Set (r ⊔ suc (m ⊔ ℓm)) where
+  infixl 7 _*ᵣ_
+  infixl 6 _+ᴹ_
+  infix 4 _≈ᴹ_
+
+  field
+    Carrierᴹ : Set m
+    _≈ᴹ_ : Rel Carrierᴹ ℓm
+    _+ᴹ_ : Op₂ Carrierᴹ
+    _*ᵣ_ : Opᵣ R Carrierᴹ
+    0ᴹ : Carrierᴹ
+
+  +ᴹ-rawMonoid : RawMonoid m ℓm
+  +ᴹ-rawMonoid = record
+    { _≈_ = _≈ᴹ_
+    ; _∙_ = _+ᴹ_
+    ; ε = 0ᴹ
+    }
+
+  open RawMonoid +ᴹ-rawMonoid public
+    using ()
+    renaming (rawMagma to +ᴹ-rawMagma; _≉_ to _≉ᴹ_)
+
+record RawRightModule (R : Set r) m ℓm : Set (r ⊔ suc (m ⊔ ℓm)) where
+  infix 8 -ᴹ_
+  infixl 7 _*ᵣ_
+  infixl 6 _+ᴹ_
+  infix 4 _≈ᴹ_
+
+  field
+    Carrierᴹ : Set m
+    _≈ᴹ_ : Rel Carrierᴹ ℓm
+    _+ᴹ_ : Op₂ Carrierᴹ
+    _*ᵣ_ : Opᵣ R Carrierᴹ
+    0ᴹ : Carrierᴹ
+    -ᴹ_ : Op₁ Carrierᴹ
+
+  rawRightSemimodule : RawRightSemimodule R m ℓm
+  rawRightSemimodule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ᵣ_ = _*ᵣ_
+    ; 0ᴹ = 0ᴹ
+    }
+
+  open RawRightSemimodule rawRightSemimodule public
+    using (+ᴹ-rawMagma; +ᴹ-rawMonoid; _≉ᴹ_)
+
+  +ᴹ-rawGroup : RawGroup m ℓm
+  +ᴹ-rawGroup = record
+    { _≈_ = _≈ᴹ_
+    ; _∙_ = _+ᴹ_
+    ; ε = 0ᴹ
+    ; _⁻¹ = -ᴹ_
+    }
+
+------------------------------------------------------------------------
+-- Bimodules
+------------------------------------------------------------------------
+
+record RawBisemimodule (R : Set r) (S : Set s) m ℓm : Set (r ⊔ s ⊔ suc (m ⊔ ℓm)) where
+  infixr 7 _*ₗ_
+  infixl 7 _*ᵣ_
+  infixl 6 _+ᴹ_
+  infix 4 _≈ᴹ_
+
+  field
+    Carrierᴹ : Set m
+    _≈ᴹ_ : Rel Carrierᴹ ℓm
+    _+ᴹ_ : Op₂ Carrierᴹ
+    _*ₗ_ : Opₗ R Carrierᴹ
+    _*ᵣ_ : Opᵣ S Carrierᴹ
+    0ᴹ : Carrierᴹ
+
+  rawLeftSemimodule : RawLeftSemimodule R m ℓm
+  rawLeftSemimodule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ₗ_ = _*ₗ_
+    ; 0ᴹ = 0ᴹ
+    }
+
+  rawRightSemimodule : RawRightSemimodule S m ℓm
+  rawRightSemimodule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ᵣ_ = _*ᵣ_
+    ; 0ᴹ = 0ᴹ
+    }
+
+  open RawLeftSemimodule rawLeftSemimodule public
+    using (+ᴹ-rawMagma; +ᴹ-rawMonoid; _≉ᴹ_)
+
+record RawBimodule (R : Set r) (S : Set s) m ℓm : Set (r ⊔ s ⊔ suc (m ⊔ ℓm)) where
+  infix 8 -ᴹ_
+  infixr 7 _*ₗ_
+  infixl 7 _*ᵣ_
+  infixl 6 _+ᴹ_
+  infix 4 _≈ᴹ_
+
+  field
+    Carrierᴹ : Set m
+    _≈ᴹ_ : Rel Carrierᴹ ℓm
+    _+ᴹ_ : Op₂ Carrierᴹ
+    _*ₗ_ : Opₗ R Carrierᴹ
+    _*ᵣ_ : Opᵣ S Carrierᴹ
+    0ᴹ : Carrierᴹ
+    -ᴹ_ : Op₁ Carrierᴹ
+
+  rawLeftModule : RawLeftModule R m ℓm
+  rawLeftModule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ₗ_ = _*ₗ_
+    ; 0ᴹ = 0ᴹ
+    ; -ᴹ_ = -ᴹ_
+    }
+
+  rawRightModule : RawRightModule S m ℓm
+  rawRightModule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ᵣ_ = _*ᵣ_
+    ; 0ᴹ = 0ᴹ
+    ; -ᴹ_ = -ᴹ_
+    }
+
+  rawBisemimodule : RawBisemimodule R S m ℓm
+  rawBisemimodule = record
+    { _≈ᴹ_ = _≈ᴹ_
+    ; _+ᴹ_ = _+ᴹ_
+    ; _*ₗ_ = _*ₗ_
+    ; _*ᵣ_ = _*ᵣ_
+    ; 0ᴹ = 0ᴹ
+    }
+
+  open RawBisemimodule rawBisemimodule public
+    using (+ᴹ-rawMagma; +ᴹ-rawMonoid; rawLeftSemimodule; rawRightSemimodule; _≉ᴹ_)
+
+  open RawLeftModule rawLeftModule public
+    using (+ᴹ-rawGroup)
+
+------------------------------------------------------------------------
+-- Modules over commutative structures
+------------------------------------------------------------------------
+
+RawSemimodule : ∀ (R : Set r) m ℓm → Set (r ⊔ suc (m ⊔ ℓm))
+RawSemimodule R = RawBisemimodule R R
+
+module RawSemimodule {R : Set r} {m ℓm} (M : RawSemimodule R m ℓm) where
+  open RawBisemimodule M public
+
+  rawBisemimodule : RawBisemimodule R R m ℓm
+  rawBisemimodule = M
+
+RawModule : ∀ (R : Set r) m ℓm → Set (r ⊔ suc(m ⊔ ℓm))
+RawModule R = RawBimodule R R
+
+module RawModule {R : Set r} {m ℓm} (M : RawModule R m ℓm) where
+  open RawBimodule M public
+
+  rawBimodule : RawBimodule R R m ℓm
+  rawBimodule = M
+
+  rawSemimodule : RawSemimodule R m ℓm
+  rawSemimodule = rawBisemimodule
diff --git a/src/Algebra/Module/Consequences.agda b/src/Algebra/Module/Consequences.agda
index 4741349edc..2ee2c98d7e 100644
--- a/src/Algebra/Module/Consequences.agda
+++ b/src/Algebra/Module/Consequences.agda
@@ -14,8 +14,9 @@ open import Algebra.Module.Core using (Opₗ; Opᵣ)
 open import Algebra.Module.Definitions
 open import Function.Base using (flip)
 open import Level using (Level)
-open import Relation.Binary using (Rel; Setoid)
-import Relation.Binary.Reasoning.Setoid as Rea
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 private
   variable
@@ -26,7 +27,7 @@ private
 module _ (_≈ᴬ_ : Rel {a} A ℓa) (S : Setoid c ℓ) where
 
   open Setoid S
-  open Rea S
+  open ≈-Reasoning S
   open Defs _≈ᴬ_
 
   private
@@ -44,7 +45,7 @@ module _ (_≈ᴬ_ : Rel {a} A ℓa) (S : Setoid c ℓ) where
       L.Associative _*_ _*ₗ_ → Commutative _*_ → R.Associative _*_ _*ᵣ_
     *ₗ-assoc+comm⇒*ᵣ-assoc *ₗ-congʳ *ₗ-assoc *-comm m x y = begin
       (m *ᵣ x) *ᵣ y  ≈⟨ refl ⟩
-      y *ₗ (x *ₗ m)  ≈˘⟨ *ₗ-assoc _ _ _ ⟩
+      y *ₗ (x *ₗ m)  ≈⟨ *ₗ-assoc _ _ _ ⟨
       (y * x) *ₗ m   ≈⟨ *ₗ-congʳ (*-comm y x) ⟩
       (x * y) *ₗ m   ≈⟨ refl ⟩
       m *ᵣ (x * y)   ∎
@@ -54,7 +55,7 @@ module _ (_≈ᴬ_ : Rel {a} A ℓa) (S : Setoid c ℓ) where
       L.Associative _*_ _*ₗ_ → Commutative _*_ → B.Associative _*ₗ_ _*ᵣ_
     *ₗ-assoc+comm⇒*ₗ-*ᵣ-assoc *ₗ-congʳ *ₗ-assoc *-comm x m y = begin
       ((x *ₗ m) *ᵣ y)  ≈⟨ refl ⟩
-      (y *ₗ (x *ₗ m))  ≈˘⟨ *ₗ-assoc _ _ _ ⟩
+      (y *ₗ (x *ₗ m))  ≈⟨ *ₗ-assoc _ _ _ ⟨
       ((y * x) *ₗ m)   ≈⟨ *ₗ-congʳ (*-comm y x) ⟩
       ((x * y) *ₗ m)   ≈⟨ *ₗ-assoc _ _ _ ⟩
       (x *ₗ (y *ₗ m))  ≈⟨ refl ⟩
@@ -71,7 +72,7 @@ module _ (_≈ᴬ_ : Rel {a} A ℓa) (S : Setoid c ℓ) where
     *ᵣ-assoc+comm⇒*ₗ-assoc *ᵣ-congˡ *ᵣ-assoc *-comm x y m = begin
       ((x * y) *ₗ m)   ≈⟨ refl ⟩
       (m *ᵣ (x * y))   ≈⟨ *ᵣ-congˡ (*-comm x y) ⟩
-      (m *ᵣ (y * x))   ≈˘⟨ *ᵣ-assoc _ _ _ ⟩
+      (m *ᵣ (y * x))   ≈⟨ *ᵣ-assoc _ _ _ ⟨
       ((m *ᵣ y) *ᵣ x)  ≈⟨ refl ⟩
       (x *ₗ (y *ₗ m))  ∎
 
@@ -82,6 +83,6 @@ module _ (_≈ᴬ_ : Rel {a} A ℓa) (S : Setoid c ℓ) where
       ((x *ₗ m) *ᵣ y)  ≈⟨ refl ⟩
       ((m *ᵣ x) *ᵣ y)  ≈⟨ *ᵣ-assoc _ _ _ ⟩
       (m *ᵣ (x * y))   ≈⟨ *ᵣ-congˡ (*-comm x y) ⟩
-      (m *ᵣ (y * x))   ≈˘⟨ *ᵣ-assoc _ _ _ ⟩
+      (m *ᵣ (y * x))   ≈⟨ *ᵣ-assoc _ _ _ ⟨
       ((m *ᵣ y) *ᵣ x)  ≈⟨ refl ⟩
       (x *ₗ (m *ᵣ y))  ∎
diff --git a/src/Algebra/Module/Construct/DirectProduct.agda b/src/Algebra/Module/Construct/DirectProduct.agda
index 3c168564bd..473e240801 100644
--- a/src/Algebra/Module/Construct/DirectProduct.agda
+++ b/src/Algebra/Module/Construct/DirectProduct.agda
@@ -14,7 +14,7 @@ module Algebra.Module.Construct.DirectProduct where
 open import Algebra.Bundles
 open import Algebra.Construct.DirectProduct
 open import Algebra.Module.Bundles
-open import Data.Product
+open import Data.Product.Base using (map; zip; _,_; proj₁; proj₂)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent
 open import Level
 
@@ -22,6 +22,83 @@ private
   variable
     r s ℓr ℓs m m′ ℓm ℓm′ : Level
 
+------------------------------------------------------------------------
+-- Raw bundles
+
+rawLeftSemimodule : {R : Set r} →
+                    RawLeftSemimodule R m ℓm →
+                    RawLeftSemimodule R m′ ℓm′ →
+                    RawLeftSemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+rawLeftSemimodule M N = record
+  { _≈ᴹ_ = Pointwise M._≈ᴹ_ N._≈ᴹ_
+  ; _+ᴹ_ = zip M._+ᴹ_ N._+ᴹ_
+  ; _*ₗ_ = λ r → map (r M.*ₗ_) (r N.*ₗ_)
+  ; 0ᴹ = M.0ᴹ , N.0ᴹ
+  } where module M = RawLeftSemimodule M; module N = RawLeftSemimodule N
+
+rawLeftModule : {R : Set r} →
+                RawLeftModule R m ℓm →
+                RawLeftModule R m′ ℓm′ →
+                RawLeftModule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+rawLeftModule M N = record
+  { RawLeftSemimodule (rawLeftSemimodule M.rawLeftSemimodule N.rawLeftSemimodule)
+  ; -ᴹ_ = map M.-ᴹ_ N.-ᴹ_
+  } where module M = RawLeftModule M; module N = RawLeftModule N
+
+
+rawRightSemimodule : {R : Set r} →
+                    RawRightSemimodule R m ℓm →
+                    RawRightSemimodule R m′ ℓm′ →
+                    RawRightSemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+rawRightSemimodule M N = record
+  { _≈ᴹ_ = Pointwise M._≈ᴹ_ N._≈ᴹ_
+  ; _+ᴹ_ = zip M._+ᴹ_ N._+ᴹ_
+  ; _*ᵣ_ = λ mn r → map (M._*ᵣ r) (N._*ᵣ r) mn
+  ; 0ᴹ = M.0ᴹ , N.0ᴹ
+  } where module M = RawRightSemimodule M; module N = RawRightSemimodule N
+
+rawRightModule : {R : Set r} →
+                RawRightModule R m ℓm →
+                RawRightModule R m′ ℓm′ →
+                RawRightModule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+rawRightModule M N = record
+  { RawRightSemimodule (rawRightSemimodule M.rawRightSemimodule N.rawRightSemimodule)
+  ; -ᴹ_ = map M.-ᴹ_ N.-ᴹ_
+  } where module M = RawRightModule M; module N = RawRightModule N
+
+rawBisemimodule : {R : Set r} {S : Set s} →
+                    RawBisemimodule R S m ℓm →
+                    RawBisemimodule R S m′ ℓm′ →
+                    RawBisemimodule R S (m ⊔ m′) (ℓm ⊔ ℓm′)
+rawBisemimodule M N = record
+  { _≈ᴹ_ = Pointwise M._≈ᴹ_ N._≈ᴹ_
+  ; _+ᴹ_ = zip M._+ᴹ_ N._+ᴹ_
+  ; _*ₗ_ = λ r → map (r M.*ₗ_) (r N.*ₗ_)
+  ; _*ᵣ_ = λ mn r → map (M._*ᵣ r) (N._*ᵣ r) mn
+  ; 0ᴹ = M.0ᴹ , N.0ᴹ
+  } where module M = RawBisemimodule M; module N = RawBisemimodule N
+
+rawBimodule : {R : Set r} {S : Set s} →
+                RawBimodule R S m ℓm →
+                RawBimodule R S m′ ℓm′ →
+                RawBimodule R S (m ⊔ m′) (ℓm ⊔ ℓm′)
+rawBimodule M N = record
+  { RawBisemimodule (rawBisemimodule M.rawBisemimodule N.rawBisemimodule)
+  ; -ᴹ_ = map M.-ᴹ_ N.-ᴹ_
+  } where module M = RawBimodule M; module N = RawBimodule N
+
+rawSemimodule : {R : Set r} →
+                RawSemimodule R m ℓm →
+                RawSemimodule R m′ ℓm′ →
+                RawSemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+rawSemimodule M N = rawBisemimodule M N
+
+rawModule : {R : Set r} →
+            RawModule R m ℓm →
+            RawModule R m′ ℓm′ →
+            RawModule R (m ⊔ m′) (ℓm ⊔ ℓm′)
+rawModule M N = rawBimodule M N
+
 ------------------------------------------------------------------------
 -- Bundles
 
@@ -97,6 +174,7 @@ semimodule M N = record
   { isSemimodule = record
     { isBisemimodule = Bisemimodule.isBisemimodule
       (bisemimodule M.bisemimodule N.bisemimodule)
+    ; *ₗ-*ᵣ-coincident = λ x m → M.*ₗ-*ᵣ-coincident x (proj₁ m) , N.*ₗ-*ᵣ-coincident x (proj₂ m)
     }
   } where module M = Semimodule M; module N = Semimodule N
 
@@ -155,5 +233,6 @@ bimodule M N = record
 ⟨module⟩ M N = record
   { isModule = record
     { isBimodule = Bimodule.isBimodule (bimodule M.bimodule N.bimodule)
+    ; *ₗ-*ᵣ-coincident = λ x m → M.*ₗ-*ᵣ-coincident x (proj₁ m) , N.*ₗ-*ᵣ-coincident x (proj₂ m)
     }
   } where module M = Module M; module N = Module N
diff --git a/src/Algebra/Module/Construct/Idealization.agda b/src/Algebra/Module/Construct/Idealization.agda
new file mode 100644
index 0000000000..4a393ea879
--- /dev/null
+++ b/src/Algebra/Module/Construct/Idealization.agda
@@ -0,0 +1,196 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- The non-commutative analogue of Nagata's construction of
+-- the "idealization of a module", (Local Rings, 1962; Wiley)
+-- defined here on R-R-*bi*modules M over a ring R, as used in
+-- "Forward- or reverse-mode automatic differentiation: What's the difference?"
+-- (Van den Berg, Schrijvers, McKinna, Vandenbroucke;
+-- Science of Computer Programming, Vol. 234, January 2024
+-- https://doi.org/10.1016/j.scico.2023.103010)
+--
+-- The construction N =def R ⋉ M , for which there is unfortunately
+-- no consistent notation in the literature, consists of:
+-- * carrier: pairs |R| × |M|
+-- * with additive structure that of the direct sum R ⊕ M _of modules_
+-- * but with multiplication _*_ such that M forms an _ideal_ of N
+-- * moreover satisfying 'm * m ≈ 0' for every m ∈ M ⊆ N
+--
+-- The fundamental lemma (proved here) is that N, in fact, defines a Ring:
+-- this ring is essentially the 'ring of dual numbers' construction R[M]
+-- (Clifford, 1874; generalised!) for an ideal M, and thus the synthetic/algebraic
+-- analogue of the tangent space of M (considered as a 'vector space' over R)
+-- in differential geometry, hence its application to Automatic Differentiation.
+--
+-- Nagata's more fundamental insight (not yet shown here) is that
+-- the lattice of R-submodules of M is in order-isomorphism with
+-- the lattice of _ideals_ of R ⋉ M , and hence that the study of
+-- modules can be reduced to that of ideals of a ring, and vice versa.
+--
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Algebra.Bundles using (AbelianGroup; Ring)
+open import Algebra.Module.Bundles using (Bimodule)
+
+module Algebra.Module.Construct.Idealization
+  {r ℓr m ℓm} (ring : Ring r ℓr) (bimodule : Bimodule ring ring m ℓm) where
+
+open import Algebra.Core
+import Algebra.Consequences.Setoid as Consequences
+import Algebra.Definitions as Definitions
+import Algebra.Module.Construct.DirectProduct as DirectProduct
+import Algebra.Module.Construct.TensorUnit as TensorUnit
+open import Algebra.Structures using (IsAbelianGroup; IsRing)
+open import Data.Product.Base using (_,_; ∃-syntax)
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Bundles using  (Setoid)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsEquivalence)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
+
+------------------------------------------------------------------------
+-- Definitions
+
+private
+  open module R = Ring ring
+    using ()
+    renaming (Carrier to R)
+
+  open module M = Bimodule bimodule
+    renaming (Carrierᴹ to M)
+
+  +ᴹ-middleFour = Consequences.comm∧assoc⇒middleFour ≈ᴹ-setoid +ᴹ-cong +ᴹ-comm +ᴹ-assoc
+
+  open module N = Bimodule (DirectProduct.bimodule TensorUnit.bimodule bimodule)
+    using ()
+    renaming ( Carrierᴹ to N
+             ; _≈ᴹ_ to _≈_
+             ; _+ᴹ_ to _+_
+             ; 0ᴹ to 0#
+             ; -ᴹ_ to -_
+             ; +ᴹ-isAbelianGroup to +-isAbelianGroup
+             )
+
+open AbelianGroup M.+ᴹ-abelianGroup hiding (_≈_)
+open ≈-Reasoning ≈ᴹ-setoid
+open Definitions _≈_
+
+-- Injections ι from the components of the direct sum
+-- ιᴹ in fact exhibits M as an _ideal_ of R ⋉ M (see below)
+ιᴿ : R → N
+ιᴿ r = r , 0ᴹ
+
+ιᴹ : M → N
+ιᴹ m = R.0# , m
+
+-- Multiplicative unit
+
+1# : N
+1# = ιᴿ R.1#
+
+-- Multiplication
+
+infixl 7 _*_
+
+_*_ : Op₂ N
+(r₁ , m₁) * (r₂ , m₂) = r₁ R.* r₂ , r₁ *ₗ m₂ +ᴹ m₁ *ᵣ r₂
+
+-- Properties: because we work in the direct sum, every proof has
+-- * an 'R'-component, which inherits directly from R, and
+-- * an 'M'-component, where the work happens
+
+*-cong : Congruent₂ _*_
+*-cong (r₁ , m₁) (r₂ , m₂) = R.*-cong r₁ r₂ , +ᴹ-cong (*ₗ-cong r₁ m₂) (*ᵣ-cong m₁ r₂)
+
+*-identityˡ : LeftIdentity 1# _*_
+*-identityˡ (r , m) = R.*-identityˡ r , (begin
+  R.1# *ₗ m +ᴹ 0ᴹ *ᵣ r ≈⟨ +ᴹ-cong (*ₗ-identityˡ m) (*ᵣ-zeroˡ r) ⟩
+  m +ᴹ 0ᴹ              ≈⟨ +ᴹ-identityʳ m ⟩
+  m                    ∎)
+
+*-identityʳ : RightIdentity 1# _*_
+*-identityʳ (r , m) = R.*-identityʳ r , (begin
+  r *ₗ 0ᴹ +ᴹ m *ᵣ R.1# ≈⟨ +ᴹ-cong (*ₗ-zeroʳ r) (*ᵣ-identityʳ m) ⟩
+  0ᴹ +ᴹ m              ≈⟨ +ᴹ-identityˡ m ⟩
+  m                    ∎)
+
+*-identity : Identity 1# _*_
+*-identity = *-identityˡ , *-identityʳ
+
+*-assoc : Associative _*_
+*-assoc (r₁ , m₁) (r₂ , m₂) (r₃ , m₃) = R.*-assoc r₁ r₂ r₃ , (begin
+  (r₁ R.* r₂) *ₗ m₃ +ᴹ (r₁ *ₗ m₂ +ᴹ m₁ *ᵣ r₂) *ᵣ r₃
+    ≈⟨ +ᴹ-cong (*ₗ-assoc r₁ r₂ m₃) (*ᵣ-distribʳ r₃ (r₁ *ₗ m₂) (m₁ *ᵣ r₂)) ⟩
+  r₁ *ₗ (r₂ *ₗ m₃) +ᴹ ((r₁ *ₗ m₂) *ᵣ r₃ +ᴹ (m₁ *ᵣ r₂) *ᵣ r₃)
+    ≈⟨ +ᴹ-congˡ (+ᴹ-congʳ (*ₗ-*ᵣ-assoc r₁ m₂ r₃)) ⟩
+  r₁ *ₗ (r₂ *ₗ m₃) +ᴹ (r₁ *ₗ (m₂ *ᵣ r₃) +ᴹ (m₁ *ᵣ r₂) *ᵣ r₃)
+    ≈⟨ +ᴹ-assoc (r₁ *ₗ (r₂ *ₗ m₃)) (r₁ *ₗ (m₂ *ᵣ r₃)) ((m₁ *ᵣ r₂) *ᵣ r₃) ⟨
+  (r₁ *ₗ (r₂ *ₗ m₃) +ᴹ r₁ *ₗ (m₂ *ᵣ r₃)) +ᴹ (m₁ *ᵣ r₂) *ᵣ r₃
+    ≈⟨ +ᴹ-cong (≈ᴹ-sym (*ₗ-distribˡ r₁ (r₂ *ₗ m₃) (m₂ *ᵣ r₃))) (*ᵣ-assoc m₁ r₂ r₃) ⟩
+  r₁ *ₗ (r₂ *ₗ m₃ +ᴹ m₂ *ᵣ r₃) +ᴹ m₁ *ᵣ (r₂ R.* r₃) ∎)
+
+distribˡ : _*_ DistributesOverˡ _+_
+distribˡ (r₁ , m₁) (r₂ , m₂) (r₃ , m₃) = R.distribˡ r₁ r₂ r₃ , (begin
+  r₁ *ₗ (m₂ +ᴹ m₃) +ᴹ m₁ *ᵣ (r₂ R.+ r₃)
+    ≈⟨ +ᴹ-cong (*ₗ-distribˡ r₁ m₂ m₃) (*ᵣ-distribˡ m₁ r₂ r₃) ⟩
+  (r₁ *ₗ m₂ +ᴹ r₁ *ₗ m₃) +ᴹ (m₁ *ᵣ r₂ +ᴹ m₁ *ᵣ r₃)
+    ≈⟨ +ᴹ-middleFour (r₁ *ₗ m₂) (r₁ *ₗ m₃) (m₁ *ᵣ r₂) (m₁ *ᵣ r₃) ⟩
+  (r₁ *ₗ m₂ +ᴹ m₁ *ᵣ r₂) +ᴹ (r₁ *ₗ m₃ +ᴹ m₁ *ᵣ r₃) ∎)
+
+
+distribʳ : _*_ DistributesOverʳ _+_
+distribʳ (r₁ , m₁) (r₂ , m₂) (r₃ , m₃) = R.distribʳ r₁ r₂ r₃ , (begin
+  (r₂ R.+ r₃) *ₗ m₁ +ᴹ (m₂ +ᴹ m₃) *ᵣ r₁
+    ≈⟨ +ᴹ-cong (*ₗ-distribʳ m₁ r₂ r₃) (*ᵣ-distribʳ r₁ m₂ m₃) ⟩
+  (r₂ *ₗ m₁ +ᴹ r₃ *ₗ m₁) +ᴹ (m₂ *ᵣ r₁ +ᴹ m₃ *ᵣ r₁)
+    ≈⟨ +ᴹ-middleFour (r₂ *ₗ m₁) (r₃ *ₗ m₁) (m₂ *ᵣ r₁) (m₃ *ᵣ r₁) ⟩
+  (r₂ *ₗ m₁ +ᴹ m₂ *ᵣ r₁) +ᴹ (r₃ *ₗ m₁ +ᴹ m₃ *ᵣ r₁) ∎)
+
+distrib : _*_ DistributesOver _+_
+distrib = distribˡ , distribʳ
+
+
+------------------------------------------------------------------------
+-- The Fundamental Lemma
+
+-- Structure
+
+isRingᴺ : IsRing _≈_ _+_ _*_ -_ 0#  1#
+isRingᴺ = record
+  { +-isAbelianGroup = +-isAbelianGroup
+  ; *-cong = *-cong
+  ; *-assoc = *-assoc
+  ; *-identity = *-identity
+  ; distrib = distrib
+  }
+
+-- Bundle
+
+ringᴺ : Ring (r ⊔ m) (ℓr ⊔ ℓm)
+ringᴺ = record { isRing = isRingᴺ }
+
+------------------------------------------------------------------------
+-- M is an ideal of R ⋉ M satisfying m₁ * m₂ ≈ 0#
+
+ιᴹ-idealˡ : (n : N) (m : M) → ∃[ n*m ] n * ιᴹ m ≈ ιᴹ n*m
+ιᴹ-idealˡ n@(r , _) m = _ , R.zeroʳ r , ≈ᴹ-refl
+
+ιᴹ-idealʳ : (m : M) (n : N) → ∃[ m*n ] ιᴹ m * n ≈ ιᴹ m*n
+ιᴹ-idealʳ m n@(r , _) = _ , R.zeroˡ r , ≈ᴹ-refl
+
+*-annihilates-ιᴹ : (m₁ m₂ : M) → ιᴹ m₁ * ιᴹ m₂ ≈ 0#
+*-annihilates-ιᴹ m₁ m₂ = R.zeroˡ R.0# , (begin
+  R.0# *ₗ m₂ +ᴹ m₁ *ᵣ R.0# ≈⟨ +ᴹ-cong (*ₗ-zeroˡ m₂) (*ᵣ-zeroʳ m₁) ⟩
+  0ᴹ +ᴹ 0ᴹ                 ≈⟨ +ᴹ-identityˡ 0ᴹ ⟩
+  0ᴹ                       ∎)
+
+m*m≈0 : (m : M) → ιᴹ m * ιᴹ m ≈ 0#
+m*m≈0 m = *-annihilates-ιᴹ m m
+
+------------------------------------------------------------------------
+-- Infix notation for when opening the module unparameterised
+
+infixl 4 _⋉_
+_⋉_ = ringᴺ
diff --git a/src/Algebra/Module/Construct/TensorUnit.agda b/src/Algebra/Module/Construct/TensorUnit.agda
index 6277210520..6c97b67de0 100644
--- a/src/Algebra/Module/Construct/TensorUnit.agda
+++ b/src/Algebra/Module/Construct/TensorUnit.agda
@@ -19,6 +19,62 @@ private
   variable
     c ℓ : Level
 
+------------------------------------------------------------------------
+-- Raw bundles
+
+rawLeftSemimodule : {R : RawSemiring c ℓ} → RawLeftSemimodule _ c ℓ
+rawLeftSemimodule {R = R} = record
+  { _≈ᴹ_ = _≈_
+  ; _+ᴹ_ = _+_
+  ; _*ₗ_ = _*_
+  ; 0ᴹ = 0#
+  } where open RawSemiring R
+
+rawLeftModule : {R : RawRing c ℓ} → RawLeftModule _ c ℓ
+rawLeftModule {R = R} = record
+  { RawLeftSemimodule (rawLeftSemimodule {R = rawSemiring})
+  ; -ᴹ_ = -_
+  } where open RawRing R
+
+rawRightSemimodule : {R : RawSemiring c ℓ} → RawRightSemimodule _ c ℓ
+rawRightSemimodule {R = R} = record
+  { _≈ᴹ_ = _≈_
+  ; _+ᴹ_ = _+_
+  ; _*ᵣ_ = _*_
+  ; 0ᴹ = 0#
+  } where open RawSemiring R
+
+rawRightModule : {R : RawRing c ℓ} → RawRightModule _ c ℓ
+rawRightModule {R = R} = record
+  { RawRightSemimodule (rawRightSemimodule {R = rawSemiring})
+  ; -ᴹ_ = -_
+  } where open RawRing R
+
+rawBisemimodule : {R : RawSemiring c ℓ} → RawBisemimodule _ _ c ℓ
+rawBisemimodule {R = R} = record
+  { _≈ᴹ_ = _≈_
+  ; _+ᴹ_ = _+_
+  ; _*ₗ_ = _*_
+  ; _*ᵣ_ = _*_
+  ; 0ᴹ = 0#
+  } where open RawSemiring R
+
+rawBimodule : {R : RawRing c ℓ} → RawBimodule _ _ c ℓ
+rawBimodule {R = R} = record
+  { RawBisemimodule (rawBisemimodule {R = rawSemiring})
+  ; -ᴹ_ = -_
+  } where open RawRing R
+
+
+rawSemimodule : {R : RawSemiring c ℓ} → RawSemimodule _ c ℓ
+rawSemimodule {R = R} = rawBisemimodule {R = R}
+
+rawModule : {R : RawRing c ℓ} → RawModule _ c ℓ
+rawModule {R = R} = rawBimodule {R = R}
+
+------------------------------------------------------------------------
+-- Bundles
+
 leftSemimodule : {R : Semiring c ℓ} → LeftSemimodule R c ℓ
 leftSemimodule {R = semiring} = record
   { Carrierᴹ = Carrier
@@ -77,6 +133,7 @@ semimodule : {R : CommutativeSemiring c ℓ} → Semimodule R c ℓ
 semimodule {R = commutativeSemiring} = record
   { isSemimodule = record
     { isBisemimodule = Bisemimodule.isBisemimodule bisemimodule
+    ; *ₗ-*ᵣ-coincident = *-comm
     }
   } where open CommutativeSemiring commutativeSemiring
 
@@ -113,5 +170,6 @@ bimodule {R = ring} = record
 ⟨module⟩ {R = commutativeRing} = record
   { isModule = record
     { isBimodule = Bimodule.isBimodule bimodule
+    ; *ₗ-*ᵣ-coincident = *-comm
     }
   } where open CommutativeRing commutativeRing
diff --git a/src/Algebra/Module/Construct/Zero.agda b/src/Algebra/Module/Construct/Zero.agda
index 624cd04598..256f70e8c0 100644
--- a/src/Algebra/Module/Construct/Zero.agda
+++ b/src/Algebra/Module/Construct/Zero.agda
@@ -35,14 +35,33 @@ module ℤero where
   _≈ᴹ_     : Rel Carrierᴹ ℓ
   _ ≈ᴹ _ = ⊤
 
-open ℤero
-
 ------------------------------------------------------------------------
--- Raw bundles NOT YET IMPLEMENTED issue #1828
-{-
-rawModule : RawModule c ℓ
+-- Raw bundles
+
+rawLeftSemimodule : {R : Set r} → RawLeftSemimodule R c ℓ
+rawLeftSemimodule = record { ℤero }
+
+rawLeftModule : {R : Set r} → RawLeftModule R c ℓ
+rawLeftModule = record { ℤero }
+
+rawRightSemimodule : {R : Set r} → RawRightSemimodule R c ℓ
+rawRightSemimodule = record { ℤero }
+
+rawRightModule : {R : Set r} → RawRightModule R c ℓ
+rawRightModule = record { ℤero }
+
+rawBisemimodule : {R : Set r} {S : Set s} → RawBisemimodule R S c ℓ
+rawBisemimodule = record { ℤero }
+
+rawBimodule : {R : Set r} {S : Set s} → RawBimodule R S c ℓ
+rawBimodule = record { ℤero }
+
+rawSemimodule : {R : Set r} → RawSemimodule R c ℓ
+rawSemimodule = record { ℤero }
+
+rawModule : {R : Set r} → RawModule R c ℓ
 rawModule = record { ℤero }
--}
+
 ------------------------------------------------------------------------
 -- Bundles
 
diff --git a/src/Algebra/Module/Definitions.agda b/src/Algebra/Module/Definitions.agda
index cb02f94469..949aa45119 100644
--- a/src/Algebra/Module/Definitions.agda
+++ b/src/Algebra/Module/Definitions.agda
@@ -7,14 +7,14 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
-
 module Algebra.Module.Definitions where
 
   import Algebra.Module.Definitions.Left as L
   import Algebra.Module.Definitions.Right as R
   import Algebra.Module.Definitions.Bi as B
+  import Algebra.Module.Definitions.Bi.Simultaneous as BS
 
   module LeftDefs = L
   module RightDefs = R
   module BiDefs = B
+  module SimultaneousBiDefs = BS
diff --git a/src/Algebra/Module/Definitions/Bi.agda b/src/Algebra/Module/Definitions/Bi.agda
index a6aa511af2..b85589b6fb 100644
--- a/src/Algebra/Module/Definitions/Bi.agda
+++ b/src/Algebra/Module/Definitions/Bi.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
 
 -- The properties are parameterised by the three carriers and
 -- the result equality.
diff --git a/src/Algebra/Module/Definitions/Bi/Simultaneous.agda b/src/Algebra/Module/Definitions/Bi/Simultaneous.agda
new file mode 100644
index 0000000000..686f4ff06c
--- /dev/null
+++ b/src/Algebra/Module/Definitions/Bi/Simultaneous.agda
@@ -0,0 +1,18 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Properties connecting left-scaling and right-scaling over the same scalars
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary
+
+module Algebra.Module.Definitions.Bi.Simultaneous
+  {a b ℓb} (A : Set a) {B : Set b} (_≈_ : Rel B ℓb)
+  where
+
+open import Algebra.Module.Core
+
+Coincident : Opₗ A B → Opᵣ A B → Set _
+Coincident _∙ₗ_ _∙ᵣ_ = ∀ x m → (x ∙ₗ m) ≈ (m ∙ᵣ x)
diff --git a/src/Algebra/Module/Definitions/Left.agda b/src/Algebra/Module/Definitions/Left.agda
index 1175292fcb..0bb7d530c3 100644
--- a/src/Algebra/Module/Definitions/Left.agda
+++ b/src/Algebra/Module/Definitions/Left.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core
+  using (Rel; _Preserves_⟶_; _Preserves₂_⟶_⟶_)
 
 -- The properties are parameterised by the two carriers and
 -- the result equality.
@@ -15,9 +16,6 @@ module Algebra.Module.Definitions.Left
   {a b ℓb} (A : Set a) {B : Set b} (_≈_ : Rel B ℓb)
   where
 
-open import Data.Sum
-open import Data.Product
-
 ------------------------------------------------------------------------
 -- Binary operations
 
@@ -33,6 +31,8 @@ LeftIdentity a _∙ᴮ_ = ∀ m → (a ∙ᴮ m) ≈ m
 Associative : Op₂ A → Opₗ A B → Set _
 Associative _∙ᴬ_ _∙ᴮ_ = ∀ x y m → ((x ∙ᴬ y) ∙ᴮ m) ≈ (x ∙ᴮ (y ∙ᴮ m))
 
+infix 4 _DistributesOverˡ_ _DistributesOverʳ_⟶_
+
 _DistributesOverˡ_ : Opₗ A B → Op₂ B → Set _
 _*_ DistributesOverˡ _+_ =
   ∀ x m n → (x * (m + n)) ≈ ((x * m) + (x * n))
diff --git a/src/Algebra/Module/Definitions/Right.agda b/src/Algebra/Module/Definitions/Right.agda
index 9f9dc67bf7..a023b09e52 100644
--- a/src/Algebra/Module/Definitions/Right.agda
+++ b/src/Algebra/Module/Definitions/Right.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core
+  using (Rel; _Preserves_⟶_; _Preserves₂_⟶_⟶_)
 
 -- The properties are parameterised by the two carriers and
 -- the result equality.
@@ -15,9 +16,6 @@ module Algebra.Module.Definitions.Right
   {a b ℓb} (A : Set a) {B : Set b} (_≈_ : Rel B ℓb)
   where
 
-open import Data.Product
-open import Data.Sum
-
 ------------------------------------------------------------------------
 -- Binary operations
 
@@ -33,6 +31,8 @@ RightIdentity a _∙ᴮ_ = ∀ m → (m ∙ᴮ a) ≈ m
 Associative : Op₂ A → Opᵣ A B → Set _
 Associative _∙ᴬ_ _∙ᴮ_ = ∀ m x y → ((m ∙ᴮ x) ∙ᴮ y) ≈ (m ∙ᴮ (x ∙ᴬ y))
 
+infix 4 _DistributesOverʳ_ _DistributesOverˡ_⟶_
+
 _DistributesOverˡ_⟶_ : Opᵣ A B → Op₂ A → Op₂ B → Set _
 _*_ DistributesOverˡ _+ᴬ_ ⟶ _+ᴮ_ =
   ∀ m x y → (m * (x +ᴬ y)) ≈ ((m * x) +ᴮ (m * y))
diff --git a/src/Algebra/Module/Morphism/Construct/Composition.agda b/src/Algebra/Module/Morphism/Construct/Composition.agda
index 3aeb7a5f26..ddeeef6893 100644
--- a/src/Algebra/Module/Morphism/Construct/Composition.agda
+++ b/src/Algebra/Module/Morphism/Construct/Composition.agda
@@ -8,24 +8,25 @@
 
 module Algebra.Module.Morphism.Construct.Composition where
 
-open import Algebra.Bundles
-open import Algebra.Module.Bundles
+open import Algebra.Module.Bundles.Raw
 open import Algebra.Module.Morphism.Structures
 open import Algebra.Morphism.Construct.Composition
 open import Function.Base using (_∘_)
 import Function.Construct.Composition as Func
 open import Level using (Level)
+open import Relation.Binary.Definitions using (Transitive)
 
 private
   variable
-    r ℓr s ℓs m₁ ℓm₁ m₂ ℓm₂ m₃ ℓm₃ : Level
+    r s m₁ ℓm₁ m₂ ℓm₂ m₃ ℓm₃ : Level
 
 module _
-  {semiring : Semiring r ℓr}
-  {M₁ : LeftSemimodule semiring m₁ ℓm₁}
-  {M₂ : LeftSemimodule semiring m₂ ℓm₂}
-  {M₃ : LeftSemimodule semiring m₃ ℓm₃}
-  (open LeftSemimodule)
+  {R : Set r}
+  {M₁ : RawLeftSemimodule R m₁ ℓm₁}
+  {M₂ : RawLeftSemimodule R m₂ ℓm₂}
+  {M₃ : RawLeftSemimodule R m₃ ℓm₃}
+  (open RawLeftSemimodule)
+  (≈ᴹ₃-trans : Transitive (_≈ᴹ_ M₃))
   {f : Carrierᴹ M₁ → Carrierᴹ M₂}
   {g : Carrierᴹ M₂ → Carrierᴹ M₃}
   where
@@ -34,8 +35,8 @@ module _
                                  IsLeftSemimoduleHomomorphism M₂ M₃ g →
                                  IsLeftSemimoduleHomomorphism M₁ M₃ (g ∘ f)
   isLeftSemimoduleHomomorphism f-homo g-homo = record
-    { +ᴹ-isMonoidHomomorphism = isMonoidHomomorphism (≈ᴹ-trans M₃) F.+ᴹ-isMonoidHomomorphism G.+ᴹ-isMonoidHomomorphism
-    ; *ₗ-homo                 = λ r x → ≈ᴹ-trans M₃ (G.⟦⟧-cong (F.*ₗ-homo r x)) (G.*ₗ-homo r (f x))
+    { +ᴹ-isMonoidHomomorphism = isMonoidHomomorphism ≈ᴹ₃-trans F.+ᴹ-isMonoidHomomorphism G.+ᴹ-isMonoidHomomorphism
+    ; *ₗ-homo                 = λ r x → ≈ᴹ₃-trans (G.⟦⟧-cong (F.*ₗ-homo r x)) (G.*ₗ-homo r (f x))
     } where module F = IsLeftSemimoduleHomomorphism f-homo; module G = IsLeftSemimoduleHomomorphism g-homo
 
   isLeftSemimoduleMonomorphism : IsLeftSemimoduleMonomorphism M₁ M₂ f →
@@ -51,15 +52,16 @@ module _
                                 IsLeftSemimoduleIsomorphism M₁ M₃ (g ∘ f)
   isLeftSemimoduleIsomorphism f-iso g-iso = record
     { isLeftSemimoduleMonomorphism = isLeftSemimoduleMonomorphism F.isLeftSemimoduleMonomorphism G.isLeftSemimoduleMonomorphism
-    ; surjective                   = Func.surjective (_≈ᴹ_ M₁) _ _ (≈ᴹ-trans M₃) G.⟦⟧-cong F.surjective G.surjective
+    ; surjective                   = Func.surjective _ _ (_≈ᴹ_ M₃) F.surjective G.surjective
     } where module F = IsLeftSemimoduleIsomorphism f-iso; module G = IsLeftSemimoduleIsomorphism g-iso
 
 module _
-  {ring : Ring r ℓr}
-  {M₁ : LeftModule ring m₁ ℓm₁}
-  {M₂ : LeftModule ring m₂ ℓm₂}
-  {M₃ : LeftModule ring m₃ ℓm₃}
-  (open LeftModule)
+  {R : Set r}
+  {M₁ : RawLeftModule R m₁ ℓm₁}
+  {M₂ : RawLeftModule R m₂ ℓm₂}
+  {M₃ : RawLeftModule R m₃ ℓm₃}
+  (open RawLeftModule)
+  (≈ᴹ₃-trans : Transitive (_≈ᴹ_ M₃))
   {f : Carrierᴹ M₁ → Carrierᴹ M₂}
   {g : Carrierᴹ M₂ → Carrierᴹ M₃}
   where
@@ -68,8 +70,8 @@ module _
                              IsLeftModuleHomomorphism M₂ M₃ g →
                              IsLeftModuleHomomorphism M₁ M₃ (g ∘ f)
   isLeftModuleHomomorphism f-homo g-homo = record
-    { +ᴹ-isGroupHomomorphism = isGroupHomomorphism (≈ᴹ-trans M₃) F.+ᴹ-isGroupHomomorphism G.+ᴹ-isGroupHomomorphism
-    ; *ₗ-homo = λ r x → ≈ᴹ-trans M₃ (G.⟦⟧-cong (F.*ₗ-homo r x)) (G.*ₗ-homo r (f x))
+    { +ᴹ-isGroupHomomorphism = isGroupHomomorphism ≈ᴹ₃-trans F.+ᴹ-isGroupHomomorphism G.+ᴹ-isGroupHomomorphism
+    ; *ₗ-homo = λ r x → ≈ᴹ₃-trans (G.⟦⟧-cong (F.*ₗ-homo r x)) (G.*ₗ-homo r (f x))
     } where module F = IsLeftModuleHomomorphism f-homo; module G = IsLeftModuleHomomorphism g-homo
 
   isLeftModuleMonomorphism : IsLeftModuleMonomorphism M₁ M₂ f →
@@ -85,15 +87,16 @@ module _
                             IsLeftModuleIsomorphism M₁ M₃ (g ∘ f)
   isLeftModuleIsomorphism f-iso g-iso = record
     { isLeftModuleMonomorphism = isLeftModuleMonomorphism F.isLeftModuleMonomorphism G.isLeftModuleMonomorphism
-    ; surjective               = Func.surjective (_≈ᴹ_ M₁) _ _ (≈ᴹ-trans M₃) G.⟦⟧-cong F.surjective G.surjective
+    ; surjective               = Func.surjective _ _ (_≈ᴹ_ M₃) F.surjective G.surjective
     } where module F = IsLeftModuleIsomorphism f-iso; module G = IsLeftModuleIsomorphism g-iso
 
 module _
-  {semiring : Semiring r ℓr}
-  {M₁ : RightSemimodule semiring m₁ ℓm₁}
-  {M₂ : RightSemimodule semiring m₂ ℓm₂}
-  {M₃ : RightSemimodule semiring m₃ ℓm₃}
-  (open RightSemimodule)
+  {R : Set r}
+  {M₁ : RawRightSemimodule R m₁ ℓm₁}
+  {M₂ : RawRightSemimodule R m₂ ℓm₂}
+  {M₃ : RawRightSemimodule R m₃ ℓm₃}
+  (open RawRightSemimodule)
+  (≈ᴹ₃-trans : Transitive (_≈ᴹ_ M₃))
   {f : Carrierᴹ M₁ → Carrierᴹ M₂}
   {g : Carrierᴹ M₂ → Carrierᴹ M₃}
   where
@@ -102,8 +105,8 @@ module _
                                   IsRightSemimoduleHomomorphism M₂ M₃ g →
                                   IsRightSemimoduleHomomorphism M₁ M₃ (g ∘ f)
   isRightSemimoduleHomomorphism f-homo g-homo = record
-    { +ᴹ-isMonoidHomomorphism = isMonoidHomomorphism (≈ᴹ-trans M₃) F.+ᴹ-isMonoidHomomorphism G.+ᴹ-isMonoidHomomorphism
-    ; *ᵣ-homo                 = λ r x → ≈ᴹ-trans M₃ (G.⟦⟧-cong (F.*ᵣ-homo r x)) (G.*ᵣ-homo r (f x))
+    { +ᴹ-isMonoidHomomorphism = isMonoidHomomorphism ≈ᴹ₃-trans F.+ᴹ-isMonoidHomomorphism G.+ᴹ-isMonoidHomomorphism
+    ; *ᵣ-homo                 = λ r x → ≈ᴹ₃-trans (G.⟦⟧-cong (F.*ᵣ-homo r x)) (G.*ᵣ-homo r (f x))
     } where module F = IsRightSemimoduleHomomorphism f-homo; module G = IsRightSemimoduleHomomorphism g-homo
 
   isRightSemimoduleMonomorphism : IsRightSemimoduleMonomorphism M₁ M₂ f →
@@ -119,15 +122,16 @@ module _
                                  IsRightSemimoduleIsomorphism M₁ M₃ (g ∘ f)
   isRightSemimoduleIsomorphism f-iso g-iso = record
     { isRightSemimoduleMonomorphism = isRightSemimoduleMonomorphism F.isRightSemimoduleMonomorphism G.isRightSemimoduleMonomorphism
-    ; surjective                    = Func.surjective (_≈ᴹ_ M₁) _ _ (≈ᴹ-trans M₃) G.⟦⟧-cong F.surjective G.surjective
+    ; surjective                    = Func.surjective _ _ (_≈ᴹ_ M₃) F.surjective G.surjective
     } where module F = IsRightSemimoduleIsomorphism f-iso; module G = IsRightSemimoduleIsomorphism g-iso
 
 module _
-  {ring : Ring r ℓr}
-  {M₁ : RightModule ring m₁ ℓm₁}
-  {M₂ : RightModule ring m₂ ℓm₂}
-  {M₃ : RightModule ring m₃ ℓm₃}
-  (open RightModule)
+  {R : Set r}
+  {M₁ : RawRightModule R m₁ ℓm₁}
+  {M₂ : RawRightModule R m₂ ℓm₂}
+  {M₃ : RawRightModule R m₃ ℓm₃}
+  (open RawRightModule)
+  (≈ᴹ₃-trans : Transitive (_≈ᴹ_ M₃))
   {f : Carrierᴹ M₁ → Carrierᴹ M₂}
   {g : Carrierᴹ M₂ → Carrierᴹ M₃}
   where
@@ -136,8 +140,8 @@ module _
                               IsRightModuleHomomorphism M₂ M₃ g →
                               IsRightModuleHomomorphism M₁ M₃ (g ∘ f)
   isRightModuleHomomorphism f-homo g-homo = record
-    { +ᴹ-isGroupHomomorphism = isGroupHomomorphism (≈ᴹ-trans M₃) F.+ᴹ-isGroupHomomorphism G.+ᴹ-isGroupHomomorphism
-    ; *ᵣ-homo                = λ r x → ≈ᴹ-trans M₃ (G.⟦⟧-cong (F.*ᵣ-homo r x)) (G.*ᵣ-homo r (f x))
+    { +ᴹ-isGroupHomomorphism = isGroupHomomorphism ≈ᴹ₃-trans F.+ᴹ-isGroupHomomorphism G.+ᴹ-isGroupHomomorphism
+    ; *ᵣ-homo                = λ r x → ≈ᴹ₃-trans (G.⟦⟧-cong (F.*ᵣ-homo r x)) (G.*ᵣ-homo r (f x))
     } where module F = IsRightModuleHomomorphism f-homo; module G = IsRightModuleHomomorphism g-homo
 
   isRightModuleMonomorphism : IsRightModuleMonomorphism M₁ M₂ f →
@@ -153,16 +157,17 @@ module _
                              IsRightModuleIsomorphism M₁ M₃ (g ∘ f)
   isRightModuleIsomorphism f-iso g-iso = record
     { isRightModuleMonomorphism = isRightModuleMonomorphism F.isRightModuleMonomorphism G.isRightModuleMonomorphism
-    ; surjective                = Func.surjective (_≈ᴹ_ M₁) _ _ (≈ᴹ-trans M₃) G.⟦⟧-cong F.surjective G.surjective
+    ; surjective                = Func.surjective _ _ (_≈ᴹ_ M₃) F.surjective G.surjective
     } where module F = IsRightModuleIsomorphism f-iso; module G = IsRightModuleIsomorphism g-iso
 
 module _
-  {R-semiring : Semiring r ℓr}
-  {S-semiring : Semiring s ℓs}
-  {M₁ : Bisemimodule R-semiring S-semiring m₁ ℓm₁}
-  {M₂ : Bisemimodule R-semiring S-semiring m₂ ℓm₂}
-  {M₃ : Bisemimodule R-semiring S-semiring m₃ ℓm₃}
-  (open Bisemimodule)
+  {R : Set r}
+  {S : Set s}
+  {M₁ : RawBisemimodule R S m₁ ℓm₁}
+  {M₂ : RawBisemimodule R S m₂ ℓm₂}
+  {M₃ : RawBisemimodule R S m₃ ℓm₃}
+  (open RawBisemimodule)
+  (≈ᴹ₃-trans : Transitive (_≈ᴹ_ M₃))
   {f : Carrierᴹ M₁ → Carrierᴹ M₂}
   {g : Carrierᴹ M₂ → Carrierᴹ M₃}
   where
@@ -171,9 +176,9 @@ module _
                                IsBisemimoduleHomomorphism M₂ M₃ g →
                                IsBisemimoduleHomomorphism M₁ M₃ (g ∘ f)
   isBisemimoduleHomomorphism f-homo g-homo = record
-    { +ᴹ-isMonoidHomomorphism = isMonoidHomomorphism (≈ᴹ-trans M₃) F.+ᴹ-isMonoidHomomorphism G.+ᴹ-isMonoidHomomorphism
-    ; *ₗ-homo                 = λ r x → ≈ᴹ-trans M₃ (G.⟦⟧-cong (F.*ₗ-homo r x)) (G.*ₗ-homo r (f x))
-    ; *ᵣ-homo                 = λ r x → ≈ᴹ-trans M₃ (G.⟦⟧-cong (F.*ᵣ-homo r x)) (G.*ᵣ-homo r (f x))
+    { +ᴹ-isMonoidHomomorphism = isMonoidHomomorphism ≈ᴹ₃-trans F.+ᴹ-isMonoidHomomorphism G.+ᴹ-isMonoidHomomorphism
+    ; *ₗ-homo                 = λ r x → ≈ᴹ₃-trans (G.⟦⟧-cong (F.*ₗ-homo r x)) (G.*ₗ-homo r (f x))
+    ; *ᵣ-homo                 = λ r x → ≈ᴹ₃-trans (G.⟦⟧-cong (F.*ᵣ-homo r x)) (G.*ᵣ-homo r (f x))
     } where module F = IsBisemimoduleHomomorphism f-homo; module G = IsBisemimoduleHomomorphism g-homo
 
   isBisemimoduleMonomorphism : IsBisemimoduleMonomorphism M₁ M₂ f →
@@ -189,16 +194,17 @@ module _
                               IsBisemimoduleIsomorphism M₁ M₃ (g ∘ f)
   isBisemimoduleIsomorphism f-iso g-iso = record
     { isBisemimoduleMonomorphism = isBisemimoduleMonomorphism F.isBisemimoduleMonomorphism G.isBisemimoduleMonomorphism
-    ; surjective                 = Func.surjective (_≈ᴹ_ M₁) _ _ (≈ᴹ-trans M₃) G.⟦⟧-cong F.surjective G.surjective
+    ; surjective                 = Func.surjective _ _ (_≈ᴹ_ M₃) F.surjective G.surjective
     } where module F = IsBisemimoduleIsomorphism f-iso; module G = IsBisemimoduleIsomorphism g-iso
 
 module _
-  {R-ring : Ring r ℓr}
-  {S-ring : Ring s ℓs}
-  {M₁ : Bimodule R-ring S-ring m₁ ℓm₁}
-  {M₂ : Bimodule R-ring S-ring m₂ ℓm₂}
-  {M₃ : Bimodule R-ring S-ring m₃ ℓm₃}
-  (open Bimodule)
+  {R : Set r}
+  {S : Set s}
+  {M₁ : RawBimodule R S m₁ ℓm₁}
+  {M₂ : RawBimodule R S m₂ ℓm₂}
+  {M₃ : RawBimodule R S m₃ ℓm₃}
+  (open RawBimodule)
+  (≈ᴹ₃-trans : Transitive (_≈ᴹ_ M₃))
   {f : Carrierᴹ M₁ → Carrierᴹ M₂}
   {g : Carrierᴹ M₂ → Carrierᴹ M₃}
   where
@@ -207,9 +213,9 @@ module _
                            IsBimoduleHomomorphism M₂ M₃ g →
                            IsBimoduleHomomorphism M₁ M₃ (g ∘ f)
   isBimoduleHomomorphism f-homo g-homo = record
-    { +ᴹ-isGroupHomomorphism = isGroupHomomorphism (≈ᴹ-trans M₃) F.+ᴹ-isGroupHomomorphism G.+ᴹ-isGroupHomomorphism
-    ; *ₗ-homo                = λ r x → ≈ᴹ-trans M₃ (G.⟦⟧-cong (F.*ₗ-homo r x)) (G.*ₗ-homo r (f x))
-    ; *ᵣ-homo                = λ r x → ≈ᴹ-trans M₃ (G.⟦⟧-cong (F.*ᵣ-homo r x)) (G.*ᵣ-homo r (f x))
+    { +ᴹ-isGroupHomomorphism = isGroupHomomorphism ≈ᴹ₃-trans F.+ᴹ-isGroupHomomorphism G.+ᴹ-isGroupHomomorphism
+    ; *ₗ-homo                = λ r x → ≈ᴹ₃-trans (G.⟦⟧-cong (F.*ₗ-homo r x)) (G.*ₗ-homo r (f x))
+    ; *ᵣ-homo                = λ r x → ≈ᴹ₃-trans (G.⟦⟧-cong (F.*ᵣ-homo r x)) (G.*ᵣ-homo r (f x))
     } where module F = IsBimoduleHomomorphism f-homo; module G = IsBimoduleHomomorphism g-homo
 
   isBimoduleMonomorphism : IsBimoduleMonomorphism M₁ M₂ f →
@@ -225,15 +231,16 @@ module _
                           IsBimoduleIsomorphism M₁ M₃ (g ∘ f)
   isBimoduleIsomorphism f-iso g-iso = record
     { isBimoduleMonomorphism = isBimoduleMonomorphism F.isBimoduleMonomorphism G.isBimoduleMonomorphism
-    ; surjective             = Func.surjective (_≈ᴹ_ M₁) _ _ (≈ᴹ-trans M₃) G.⟦⟧-cong F.surjective G.surjective
+    ; surjective             = Func.surjective _ _ (_≈ᴹ_ M₃) F.surjective G.surjective
     } where module F = IsBimoduleIsomorphism f-iso; module G = IsBimoduleIsomorphism g-iso
 
 module _
-  {commutativeSemiring : CommutativeSemiring r ℓr}
-  {M₁ : Semimodule commutativeSemiring m₁ ℓm₁}
-  {M₂ : Semimodule commutativeSemiring m₂ ℓm₂}
-  {M₃ : Semimodule commutativeSemiring m₃ ℓm₃}
-  (open Semimodule)
+  {R : Set r}
+  {M₁ : RawSemimodule R m₁ ℓm₁}
+  {M₂ : RawSemimodule R m₂ ℓm₂}
+  {M₃ : RawSemimodule R m₃ ℓm₃}
+  (open RawSemimodule)
+  (≈ᴹ₃-trans : Transitive (_≈ᴹ_ M₃))
   {f : Carrierᴹ M₁ → Carrierᴹ M₂}
   {g : Carrierᴹ M₂ → Carrierᴹ M₃}
   where
@@ -242,7 +249,7 @@ module _
                              IsSemimoduleHomomorphism M₂ M₃ g →
                              IsSemimoduleHomomorphism M₁ M₃ (g ∘ f)
   isSemimoduleHomomorphism f-homo g-homo = record
-    { isBisemimoduleHomomorphism = isBisemimoduleHomomorphism F.isBisemimoduleHomomorphism G.isBisemimoduleHomomorphism
+    { isBisemimoduleHomomorphism = isBisemimoduleHomomorphism ≈ᴹ₃-trans F.isBisemimoduleHomomorphism G.isBisemimoduleHomomorphism
     } where module F = IsSemimoduleHomomorphism f-homo; module G = IsSemimoduleHomomorphism g-homo
 
   isSemimoduleMonomorphism : IsSemimoduleMonomorphism M₁ M₂ f →
@@ -258,15 +265,16 @@ module _
                             IsSemimoduleIsomorphism M₁ M₃ (g ∘ f)
   isSemimoduleIsomorphism f-iso g-iso = record
     { isSemimoduleMonomorphism = isSemimoduleMonomorphism F.isSemimoduleMonomorphism G.isSemimoduleMonomorphism
-    ; surjective               = Func.surjective (_≈ᴹ_ M₁) _ _ (≈ᴹ-trans M₃) G.⟦⟧-cong F.surjective G.surjective
+    ; surjective               = Func.surjective _ _ (_≈ᴹ_ M₃) F.surjective G.surjective
     } where module F = IsSemimoduleIsomorphism f-iso; module G = IsSemimoduleIsomorphism g-iso
 
 module _
-  {commutativeRing : CommutativeRing r ℓr}
-  {M₁ : Module commutativeRing m₁ ℓm₁}
-  {M₂ : Module commutativeRing m₂ ℓm₂}
-  {M₃ : Module commutativeRing m₃ ℓm₃}
-  (open Module)
+  {R : Set r}
+  {M₁ : RawModule R m₁ ℓm₁}
+  {M₂ : RawModule R m₂ ℓm₂}
+  {M₃ : RawModule R m₃ ℓm₃}
+  (open RawModule)
+  (≈ᴹ₃-trans : Transitive (_≈ᴹ_ M₃))
   {f : Carrierᴹ M₁ → Carrierᴹ M₂}
   {g : Carrierᴹ M₂ → Carrierᴹ M₃}
   where
@@ -275,7 +283,7 @@ module _
                          IsModuleHomomorphism M₂ M₃ g →
                          IsModuleHomomorphism M₁ M₃ (g ∘ f)
   isModuleHomomorphism f-homo g-homo = record
-    { isBimoduleHomomorphism = isBimoduleHomomorphism F.isBimoduleHomomorphism G.isBimoduleHomomorphism
+    { isBimoduleHomomorphism = isBimoduleHomomorphism ≈ᴹ₃-trans F.isBimoduleHomomorphism G.isBimoduleHomomorphism
     } where module F = IsModuleHomomorphism f-homo; module G = IsModuleHomomorphism g-homo
 
   isModuleMonomorphism : IsModuleMonomorphism M₁ M₂ f →
@@ -291,5 +299,5 @@ module _
                         IsModuleIsomorphism M₁ M₃ (g ∘ f)
   isModuleIsomorphism f-iso g-iso = record
     { isModuleMonomorphism = isModuleMonomorphism F.isModuleMonomorphism G.isModuleMonomorphism
-    ; surjective           = Func.surjective (_≈ᴹ_ M₁) _ _ (≈ᴹ-trans M₃) G.⟦⟧-cong F.surjective G.surjective
+    ; surjective           = Func.surjective _ _ (_≈ᴹ_ M₃) F.surjective G.surjective
     } where module F = IsModuleIsomorphism f-iso; module G = IsModuleIsomorphism g-iso
diff --git a/src/Algebra/Module/Morphism/Construct/Identity.agda b/src/Algebra/Module/Morphism/Construct/Identity.agda
index f5e5d73b05..54a08af98c 100644
--- a/src/Algebra/Module/Morphism/Construct/Identity.agda
+++ b/src/Algebra/Module/Morphism/Construct/Identity.agda
@@ -8,8 +8,7 @@
 
 module Algebra.Module.Morphism.Construct.Identity where
 
-open import Algebra.Bundles
-open import Algebra.Module.Bundles
+open import Algebra.Module.Bundles.Raw
 open import Algebra.Module.Morphism.Structures
   using ( module LeftSemimoduleMorphisms
         ; module LeftModuleMorphisms
@@ -21,16 +20,17 @@ open import Algebra.Module.Morphism.Structures
         ; module ModuleMorphisms
         )
 open import Algebra.Morphism.Construct.Identity
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (id)
+import Function.Construct.Identity as Id
 open import Level using (Level)
+open import Relation.Binary.Definitions using (Reflexive)
 
 private
   variable
-    r ℓr s ℓs m ℓm : Level
+    r s m ℓm : Level
 
-module _ {semiring : Semiring r ℓr} (M : LeftSemimodule semiring m ℓm) where
-  open LeftSemimodule M using (≈ᴹ-refl)
+module _ {R : Set r} (M : RawLeftSemimodule R m ℓm) (open RawLeftSemimodule M) (≈ᴹ-refl : Reflexive _≈ᴹ_) where
   open LeftSemimoduleMorphisms M M
 
   isLeftSemimoduleHomomorphism : IsLeftSemimoduleHomomorphism id
@@ -48,11 +48,10 @@ module _ {semiring : Semiring r ℓr} (M : LeftSemimodule semiring m ℓm) where
   isLeftSemimoduleIsomorphism : IsLeftSemimoduleIsomorphism id
   isLeftSemimoduleIsomorphism = record
     { isLeftSemimoduleMonomorphism = isLeftSemimoduleMonomorphism
-    ; surjective                   = _, ≈ᴹ-refl
+    ; surjective                   = Id.surjective _
     }
 
-module _ {ring : Ring r ℓr} (M : LeftModule ring m ℓm) where
-  open LeftModule M using (≈ᴹ-refl)
+module _ {R : Set r} (M : RawLeftModule R m ℓm) (open RawLeftModule M) (≈ᴹ-refl : Reflexive _≈ᴹ_)  where
   open LeftModuleMorphisms M M
 
   isLeftModuleHomomorphism : IsLeftModuleHomomorphism id
@@ -70,11 +69,10 @@ module _ {ring : Ring r ℓr} (M : LeftModule ring m ℓm) where
   isLeftModuleIsomorphism : IsLeftModuleIsomorphism id
   isLeftModuleIsomorphism = record
     { isLeftModuleMonomorphism = isLeftModuleMonomorphism
-    ; surjective               = _, ≈ᴹ-refl
+    ; surjective               = Id.surjective _
     }
 
-module _ {semiring : Semiring r ℓr} (M : RightSemimodule semiring m ℓm) where
-  open RightSemimodule M using (≈ᴹ-refl)
+module _ {R : Set r} (M : RawRightSemimodule R m ℓm) (open RawRightSemimodule M) (≈ᴹ-refl : Reflexive _≈ᴹ_) where
   open RightSemimoduleMorphisms M M
 
   isRightSemimoduleHomomorphism : IsRightSemimoduleHomomorphism id
@@ -92,11 +90,10 @@ module _ {semiring : Semiring r ℓr} (M : RightSemimodule semiring m ℓm) wher
   isRightSemimoduleIsomorphism : IsRightSemimoduleIsomorphism id
   isRightSemimoduleIsomorphism = record
     { isRightSemimoduleMonomorphism = isRightSemimoduleMonomorphism
-    ; surjective                    = _, ≈ᴹ-refl
+    ; surjective                    = Id.surjective _
     }
 
-module _ {ring : Ring r ℓr} (M : RightModule ring m ℓm) where
-  open RightModule M using (≈ᴹ-refl)
+module _ {R : Set r} (M : RawRightModule R m ℓm) (open RawRightModule M) (≈ᴹ-refl : Reflexive _≈ᴹ_) where
   open RightModuleMorphisms M M
 
   isRightModuleHomomorphism : IsRightModuleHomomorphism id
@@ -114,11 +111,10 @@ module _ {ring : Ring r ℓr} (M : RightModule ring m ℓm) where
   isRightModuleIsomorphism : IsRightModuleIsomorphism id
   isRightModuleIsomorphism = record
     { isRightModuleMonomorphism = isRightModuleMonomorphism
-    ; surjective                = _, ≈ᴹ-refl
+    ; surjective                = Id.surjective _
     }
 
-module _ {R-semiring : Semiring r ℓr} {S-semiring : Semiring s ℓs} (M : Bisemimodule R-semiring S-semiring m ℓm) where
-  open Bisemimodule M using (≈ᴹ-refl)
+module _ {R : Set r} {S : Set s} (M : RawBisemimodule R S m ℓm) (open RawBisemimodule M) (≈ᴹ-refl : Reflexive _≈ᴹ_) where
   open BisemimoduleMorphisms M M
 
   isBisemimoduleHomomorphism : IsBisemimoduleHomomorphism id
@@ -137,11 +133,10 @@ module _ {R-semiring : Semiring r ℓr} {S-semiring : Semiring s ℓs} (M : Bise
   isBisemimoduleIsomorphism : IsBisemimoduleIsomorphism id
   isBisemimoduleIsomorphism = record
     { isBisemimoduleMonomorphism = isBisemimoduleMonomorphism
-    ; surjective                 = _, ≈ᴹ-refl
+    ; surjective                 = Id.surjective _
     }
 
-module _ {R-ring : Ring r ℓr} {S-ring : Ring r ℓr} (M : Bimodule R-ring S-ring m ℓm) where
-  open Bimodule M using (≈ᴹ-refl)
+module _ {R : Set r} {S : Set s} (M : RawBimodule R S m ℓm) (open RawBimodule M) (≈ᴹ-refl : Reflexive _≈ᴹ_) where
   open BimoduleMorphisms M M
 
   isBimoduleHomomorphism : IsBimoduleHomomorphism id
@@ -160,16 +155,15 @@ module _ {R-ring : Ring r ℓr} {S-ring : Ring r ℓr} (M : Bimodule R-ring S-ri
   isBimoduleIsomorphism : IsBimoduleIsomorphism id
   isBimoduleIsomorphism = record
     { isBimoduleMonomorphism = isBimoduleMonomorphism
-    ; surjective             = _, ≈ᴹ-refl
+    ; surjective             = Id.surjective _
     }
 
-module _ {commutativeSemiring : CommutativeSemiring r ℓr} (M : Semimodule commutativeSemiring m ℓm) where
-  open Semimodule M using (≈ᴹ-refl)
+module _ {R : Set r} (M : RawSemimodule R m ℓm) (open RawSemimodule M) (≈ᴹ-refl : Reflexive _≈ᴹ_)  where
   open SemimoduleMorphisms M M
 
   isSemimoduleHomomorphism : IsSemimoduleHomomorphism id
   isSemimoduleHomomorphism = record
-    { isBisemimoduleHomomorphism = isBisemimoduleHomomorphism _
+    { isBisemimoduleHomomorphism = isBisemimoduleHomomorphism _ ≈ᴹ-refl
     }
 
   isSemimoduleMonomorphism : IsSemimoduleMonomorphism id
@@ -181,16 +175,15 @@ module _ {commutativeSemiring : CommutativeSemiring r ℓr} (M : Semimodule comm
   isSemimoduleIsomorphism : IsSemimoduleIsomorphism id
   isSemimoduleIsomorphism = record
     { isSemimoduleMonomorphism = isSemimoduleMonomorphism
-    ; surjective               = _, ≈ᴹ-refl
+    ; surjective               = Id.surjective _
     }
 
-module _ {commutativeRing : CommutativeRing r ℓr} (M : Module commutativeRing m ℓm) where
-  open Module M using (≈ᴹ-refl)
+module _ {R : Set r} (M : RawModule R m ℓm) (open RawModule M) (≈ᴹ-refl : Reflexive _≈ᴹ_) where
   open ModuleMorphisms M M
 
   isModuleHomomorphism : IsModuleHomomorphism id
   isModuleHomomorphism = record
-    { isBimoduleHomomorphism = isBimoduleHomomorphism _
+    { isBimoduleHomomorphism = isBimoduleHomomorphism _ ≈ᴹ-refl
     }
 
   isModuleMonomorphism : IsModuleMonomorphism id
@@ -202,5 +195,5 @@ module _ {commutativeRing : CommutativeRing r ℓr} (M : Module commutativeRing
   isModuleIsomorphism : IsModuleIsomorphism id
   isModuleIsomorphism = record
     { isModuleMonomorphism = isModuleMonomorphism
-    ; surjective           = _, ≈ᴹ-refl
+    ; surjective           = Id.surjective _
     }
diff --git a/src/Algebra/Module/Morphism/ModuleHomomorphism.agda b/src/Algebra/Module/Morphism/ModuleHomomorphism.agda
index 47ae46de10..6bd7f2b4e6 100644
--- a/src/Algebra/Module/Morphism/ModuleHomomorphism.agda
+++ b/src/Algebra/Module/Morphism/ModuleHomomorphism.agda
@@ -17,15 +17,15 @@ module Algebra.Module.Morphism.ModuleHomomorphism
   {r ℓr m ℓm : Level}
   {ring      : CommutativeRing r ℓr}
   (modA modB  : Module ring m ℓm)
-  (open Module modA using () renaming (Carrierᴹ to A))
-  (open Module modB using () renaming (Carrierᴹ to B))
+  (open Module modA using () renaming (Carrierᴹ to A; rawModule to rawModA))
+  (open Module modB using () renaming (Carrierᴹ to B; rawModule to rawModB))
   {f : A → B}
-  (open MorphismStructures.ModuleMorphisms modA modB)
+  (open MorphismStructures.ModuleMorphisms rawModA rawModB)
   (isModuleHomomorphism : IsModuleHomomorphism f)
   where
 
 open import Axiom.DoubleNegationElimination
-open import Data.Product
+open import Data.Product.Base using (∃₂; _×_; _,_)
 open import Relation.Binary.Reasoning.MultiSetoid
 open import Relation.Nullary          using (¬_)
 open import Relation.Nullary.Negation using (contraposition)
diff --git a/src/Algebra/Module/Morphism/Structures.agda b/src/Algebra/Module/Morphism/Structures.agda
index 3dc5fba3c5..e874f4d341 100644
--- a/src/Algebra/Module/Morphism/Structures.agda
+++ b/src/Algebra/Module/Morphism/Structures.agda
@@ -7,29 +7,26 @@
 
 module Algebra.Module.Morphism.Structures where
 
-open import Algebra.Bundles
-open import Algebra.Module.Bundles
+open import Algebra.Module.Bundles.Raw
 import Algebra.Module.Morphism.Definitions as MorphismDefinitions
 import Algebra.Morphism.Structures as MorphismStructures
-import Function.Definitions as FunctionDefinitions
+open import Function.Definitions
 open import Level
 
 private
   variable
-    r ℓr s ℓs m₁ m₂ ℓm₁ ℓm₂ : Level
+    r s m₁ m₂ ℓm₁ ℓm₂ : Level
 
 module LeftSemimoduleMorphisms
-  {semiring : Semiring r ℓr}
-  (M₁ : LeftSemimodule semiring m₁ ℓm₁)
-  (M₂ : LeftSemimodule semiring m₂ ℓm₂)
+  {R : Set r}
+  (M₁ : RawLeftSemimodule R m₁ ℓm₁)
+  (M₂ : RawLeftSemimodule R m₂ ℓm₂)
   where
 
-  open Semiring semiring renaming (Carrier to R)
-  open LeftSemimodule M₁ renaming (Carrierᴹ to A; _*ₗ_ to _*ₗ₁_; _≈ᴹ_ to _≈ᴹ₁_)
-  open LeftSemimodule M₂ renaming (Carrierᴹ to B; _*ₗ_ to _*ₗ₂_; _≈ᴹ_ to _≈ᴹ₂_)
+  open RawLeftSemimodule M₁ renaming (Carrierᴹ to A; _*ₗ_ to _*ₗ₁_; _≈ᴹ_ to _≈ᴹ₁_)
+  open RawLeftSemimodule M₂ renaming (Carrierᴹ to B; _*ₗ_ to _*ₗ₂_; _≈ᴹ_ to _≈ᴹ₂_)
   open MorphismDefinitions R A B _≈ᴹ₂_
-  open FunctionDefinitions _≈ᴹ₁_ _≈ᴹ₂_
-  open MorphismStructures.MonoidMorphisms (LeftSemimodule.+ᴹ-rawMonoid M₁) (LeftSemimodule.+ᴹ-rawMonoid M₂)
+  open MorphismStructures.MonoidMorphisms (RawLeftSemimodule.+ᴹ-rawMonoid M₁) (RawLeftSemimodule.+ᴹ-rawMonoid M₂)
 
   record IsLeftSemimoduleHomomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
@@ -43,7 +40,7 @@ module LeftSemimoduleMorphisms
   record IsLeftSemimoduleMonomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isLeftSemimoduleHomomorphism : IsLeftSemimoduleHomomorphism ⟦_⟧
-      injective                    : Injective ⟦_⟧
+      injective                    : Injective  _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsLeftSemimoduleHomomorphism isLeftSemimoduleHomomorphism public
 
@@ -60,7 +57,7 @@ module LeftSemimoduleMorphisms
   record IsLeftSemimoduleIsomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ m₂ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isLeftSemimoduleMonomorphism : IsLeftSemimoduleMonomorphism ⟦_⟧
-      surjective                   : Surjective ⟦_⟧
+      surjective                   : Surjective  _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsLeftSemimoduleMonomorphism isLeftSemimoduleMonomorphism public
 
@@ -75,18 +72,16 @@ module LeftSemimoduleMorphisms
       renaming (isMagmaIsomorphism to +ᴹ-isMagmaIsomorphism)
 
 module LeftModuleMorphisms
-  {ring : Ring r ℓr}
-  (M₁ : LeftModule ring m₁ ℓm₁)
-  (M₂ : LeftModule ring m₂ ℓm₂)
+  {R : Set r}
+  (M₁ : RawLeftModule R m₁ ℓm₁)
+  (M₂ : RawLeftModule R m₂ ℓm₂)
   where
 
-  open Ring ring renaming (Carrier to R)
-  open LeftModule M₁ renaming (Carrierᴹ to A; _*ₗ_ to _*ₗ₁_; _≈ᴹ_ to _≈ᴹ₁_)
-  open LeftModule M₂ renaming (Carrierᴹ to B; _*ₗ_ to _*ₗ₂_; _≈ᴹ_ to _≈ᴹ₂_)
+  open RawLeftModule M₁ renaming (Carrierᴹ to A; _*ₗ_ to _*ₗ₁_; _≈ᴹ_ to _≈ᴹ₁_)
+  open RawLeftModule M₂ renaming (Carrierᴹ to B; _*ₗ_ to _*ₗ₂_; _≈ᴹ_ to _≈ᴹ₂_)
   open MorphismDefinitions R A B _≈ᴹ₂_
-  open FunctionDefinitions _≈ᴹ₁_ _≈ᴹ₂_
-  open MorphismStructures.GroupMorphisms (LeftModule.+ᴹ-rawGroup M₁) (LeftModule.+ᴹ-rawGroup M₂)
-  open LeftSemimoduleMorphisms (LeftModule.leftSemimodule M₁) (LeftModule.leftSemimodule M₂)
+  open MorphismStructures.GroupMorphisms (RawLeftModule.+ᴹ-rawGroup M₁) (RawLeftModule.+ᴹ-rawGroup M₂)
+  open LeftSemimoduleMorphisms (RawLeftModule.rawLeftSemimodule M₁) (RawLeftModule.rawLeftSemimodule M₂)
 
   record IsLeftModuleHomomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
@@ -108,7 +103,7 @@ module LeftModuleMorphisms
   record IsLeftModuleMonomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isLeftModuleHomomorphism : IsLeftModuleHomomorphism ⟦_⟧
-      injective                : Injective ⟦_⟧
+      injective                : Injective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsLeftModuleHomomorphism isLeftModuleHomomorphism public
 
@@ -130,7 +125,7 @@ module LeftModuleMorphisms
   record IsLeftModuleIsomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ m₂ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isLeftModuleMonomorphism : IsLeftModuleMonomorphism ⟦_⟧
-      surjective               : Surjective ⟦_⟧
+      surjective               : Surjective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsLeftModuleMonomorphism isLeftModuleMonomorphism public
 
@@ -150,17 +145,15 @@ module LeftModuleMorphisms
       }
 
 module RightSemimoduleMorphisms
-  {semiring : Semiring r ℓr}
-  (M₁ : RightSemimodule semiring m₁ ℓm₁)
-  (M₂ : RightSemimodule semiring m₂ ℓm₂)
+  {R : Set r}
+  (M₁ : RawRightSemimodule R m₁ ℓm₁)
+  (M₂ : RawRightSemimodule R m₂ ℓm₂)
   where
 
-  open Semiring semiring renaming (Carrier to R)
-  open RightSemimodule M₁ renaming (Carrierᴹ to A; _*ᵣ_ to _*ᵣ₁_; _≈ᴹ_ to _≈ᴹ₁_)
-  open RightSemimodule M₂ renaming (Carrierᴹ to B; _*ᵣ_ to _*ᵣ₂_; _≈ᴹ_ to _≈ᴹ₂_)
+  open RawRightSemimodule M₁ renaming (Carrierᴹ to A; _*ᵣ_ to _*ᵣ₁_; _≈ᴹ_ to _≈ᴹ₁_)
+  open RawRightSemimodule M₂ renaming (Carrierᴹ to B; _*ᵣ_ to _*ᵣ₂_; _≈ᴹ_ to _≈ᴹ₂_)
   open MorphismDefinitions R A B _≈ᴹ₂_
-  open FunctionDefinitions _≈ᴹ₁_ _≈ᴹ₂_
-  open MorphismStructures.MonoidMorphisms (RightSemimodule.+ᴹ-rawMonoid M₁) (RightSemimodule.+ᴹ-rawMonoid M₂)
+  open MorphismStructures.MonoidMorphisms (RawRightSemimodule.+ᴹ-rawMonoid M₁) (RawRightSemimodule.+ᴹ-rawMonoid M₂)
 
   record IsRightSemimoduleHomomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
@@ -174,7 +167,7 @@ module RightSemimoduleMorphisms
   record IsRightSemimoduleMonomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isRightSemimoduleHomomorphism : IsRightSemimoduleHomomorphism ⟦_⟧
-      injective                    : Injective ⟦_⟧
+      injective                    : Injective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsRightSemimoduleHomomorphism isRightSemimoduleHomomorphism public
 
@@ -191,7 +184,7 @@ module RightSemimoduleMorphisms
   record IsRightSemimoduleIsomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ m₂ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isRightSemimoduleMonomorphism : IsRightSemimoduleMonomorphism ⟦_⟧
-      surjective                   : Surjective ⟦_⟧
+      surjective                   : Surjective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsRightSemimoduleMonomorphism isRightSemimoduleMonomorphism public
 
@@ -206,18 +199,16 @@ module RightSemimoduleMorphisms
       renaming (isMagmaIsomorphism to +ᴹ-isMagmaIsomorphism)
 
 module RightModuleMorphisms
-  {ring : Ring r ℓr}
-  (M₁ : RightModule ring m₁ ℓm₁)
-  (M₂ : RightModule ring m₂ ℓm₂)
+  {R : Set r}
+  (M₁ : RawRightModule R m₁ ℓm₁)
+  (M₂ : RawRightModule R m₂ ℓm₂)
   where
 
-  open Ring ring renaming (Carrier to R)
-  open RightModule M₁ renaming (Carrierᴹ to A; _*ᵣ_ to _*ᵣ₁_; _≈ᴹ_ to _≈ᴹ₁_)
-  open RightModule M₂ renaming (Carrierᴹ to B; _*ᵣ_ to _*ᵣ₂_; _≈ᴹ_ to _≈ᴹ₂_)
+  open RawRightModule M₁ renaming (Carrierᴹ to A; _*ᵣ_ to _*ᵣ₁_; _≈ᴹ_ to _≈ᴹ₁_)
+  open RawRightModule M₂ renaming (Carrierᴹ to B; _*ᵣ_ to _*ᵣ₂_; _≈ᴹ_ to _≈ᴹ₂_)
   open MorphismDefinitions R A B _≈ᴹ₂_
-  open FunctionDefinitions _≈ᴹ₁_ _≈ᴹ₂_
-  open MorphismStructures.GroupMorphisms (RightModule.+ᴹ-rawGroup M₁) (RightModule.+ᴹ-rawGroup M₂)
-  open RightSemimoduleMorphisms (RightModule.rightSemimodule M₁) (RightModule.rightSemimodule M₂)
+  open MorphismStructures.GroupMorphisms (RawRightModule.+ᴹ-rawGroup M₁) (RawRightModule.+ᴹ-rawGroup M₂)
+  open RightSemimoduleMorphisms (RawRightModule.rawRightSemimodule M₁) (RawRightModule.rawRightSemimodule M₂)
 
   record IsRightModuleHomomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
@@ -238,7 +229,7 @@ module RightModuleMorphisms
   record IsRightModuleMonomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isRightModuleHomomorphism : IsRightModuleHomomorphism ⟦_⟧
-      injective                : Injective ⟦_⟧
+      injective                : Injective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsRightModuleHomomorphism isRightModuleHomomorphism public
 
@@ -260,7 +251,7 @@ module RightModuleMorphisms
   record IsRightModuleIsomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ m₂ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isRightModuleMonomorphism : IsRightModuleMonomorphism ⟦_⟧
-      surjective               : Surjective ⟦_⟧
+      surjective               : Surjective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsRightModuleMonomorphism isRightModuleMonomorphism public
 
@@ -280,22 +271,19 @@ module RightModuleMorphisms
       }
 
 module BisemimoduleMorphisms
-  {R-semiring : Semiring r ℓr}
-  {S-semiring : Semiring s ℓs}
-  (M₁ : Bisemimodule R-semiring S-semiring m₁ ℓm₁)
-  (M₂ : Bisemimodule R-semiring S-semiring m₂ ℓm₂)
+  {R : Set r}
+  {S : Set s}
+  (M₁ : RawBisemimodule R S m₁ ℓm₁)
+  (M₂ : RawBisemimodule R S m₂ ℓm₂)
   where
 
-  open Semiring R-semiring renaming (Carrier to R)
-  open Semiring S-semiring renaming (Carrier to S)
-  open Bisemimodule M₁ renaming (Carrierᴹ to A; _*ₗ_ to _*ₗ₁_; _*ᵣ_ to _*ᵣ₁_; _≈ᴹ_ to _≈ᴹ₁_)
-  open Bisemimodule M₂ renaming (Carrierᴹ to B; _*ₗ_ to _*ₗ₂_; _*ᵣ_ to _*ᵣ₂_; _≈ᴹ_ to _≈ᴹ₂_)
+  open RawBisemimodule M₁ renaming (Carrierᴹ to A; _*ₗ_ to _*ₗ₁_; _*ᵣ_ to _*ᵣ₁_; _≈ᴹ_ to _≈ᴹ₁_)
+  open RawBisemimodule M₂ renaming (Carrierᴹ to B; _*ₗ_ to _*ₗ₂_; _*ᵣ_ to _*ᵣ₂_; _≈ᴹ_ to _≈ᴹ₂_)
   open MorphismDefinitions R A B _≈ᴹ₂_ using (Homomorphicₗ)
   open MorphismDefinitions S A B _≈ᴹ₂_ using (Homomorphicᵣ)
-  open FunctionDefinitions _≈ᴹ₁_ _≈ᴹ₂_
-  open MorphismStructures.MonoidMorphisms (Bisemimodule.+ᴹ-rawMonoid M₁) (Bisemimodule.+ᴹ-rawMonoid M₂)
-  open LeftSemimoduleMorphisms (Bisemimodule.leftSemimodule M₁) (Bisemimodule.leftSemimodule M₂)
-  open RightSemimoduleMorphisms (Bisemimodule.rightSemimodule M₁) (Bisemimodule.rightSemimodule M₂)
+  open MorphismStructures.MonoidMorphisms (RawBisemimodule.+ᴹ-rawMonoid M₁) (RawBisemimodule.+ᴹ-rawMonoid M₂)
+  open LeftSemimoduleMorphisms (RawBisemimodule.rawLeftSemimodule M₁) (RawBisemimodule.rawLeftSemimodule M₂)
+  open RightSemimoduleMorphisms (RawBisemimodule.rawRightSemimodule M₁) (RawBisemimodule.rawRightSemimodule M₂)
 
   record IsBisemimoduleHomomorphism (⟦_⟧ : A → B) : Set (r ⊔ s ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
@@ -321,7 +309,7 @@ module BisemimoduleMorphisms
   record IsBisemimoduleMonomorphism (⟦_⟧ : A → B) : Set (r ⊔ s ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isBisemimoduleHomomorphism : IsBisemimoduleHomomorphism ⟦_⟧
-      injective                  : Injective ⟦_⟧
+      injective                  : Injective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsBisemimoduleHomomorphism isBisemimoduleHomomorphism public
 
@@ -343,7 +331,7 @@ module BisemimoduleMorphisms
   record IsBisemimoduleIsomorphism (⟦_⟧ : A → B) : Set (r ⊔ s ⊔ m₁ ⊔ m₂ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isBisemimoduleMonomorphism : IsBisemimoduleMonomorphism ⟦_⟧
-      surjective                 : Surjective ⟦_⟧
+      surjective                 : Surjective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsBisemimoduleMonomorphism isBisemimoduleMonomorphism public
 
@@ -363,23 +351,20 @@ module BisemimoduleMorphisms
       }
 
 module BimoduleMorphisms
-  {R-ring : Ring r ℓr}
-  {S-ring : Ring s ℓs}
-  (M₁ : Bimodule R-ring S-ring m₁ ℓm₁)
-  (M₂ : Bimodule R-ring S-ring m₂ ℓm₂)
+  {R : Set r}
+  {S : Set s}
+  (M₁ : RawBimodule R S m₁ ℓm₁)
+  (M₂ : RawBimodule R S m₂ ℓm₂)
   where
 
-  open Ring R-ring renaming (Carrier to R)
-  open Ring S-ring renaming (Carrier to S)
-  open Bimodule M₁ renaming (Carrierᴹ to A; _*ₗ_ to _*ₗ₁_; _*ᵣ_ to _*ᵣ₁_; _≈ᴹ_ to _≈ᴹ₁_)
-  open Bimodule M₂ renaming (Carrierᴹ to B; _*ₗ_ to _*ₗ₂_; _*ᵣ_ to _*ᵣ₂_; _≈ᴹ_ to _≈ᴹ₂_)
+  open RawBimodule M₁ renaming (Carrierᴹ to A; _*ₗ_ to _*ₗ₁_; _*ᵣ_ to _*ᵣ₁_; _≈ᴹ_ to _≈ᴹ₁_)
+  open RawBimodule M₂ renaming (Carrierᴹ to B; _*ₗ_ to _*ₗ₂_; _*ᵣ_ to _*ᵣ₂_; _≈ᴹ_ to _≈ᴹ₂_)
   open MorphismDefinitions R A B _≈ᴹ₂_ using (Homomorphicₗ)
   open MorphismDefinitions S A B _≈ᴹ₂_ using (Homomorphicᵣ)
-  open FunctionDefinitions _≈ᴹ₁_ _≈ᴹ₂_
-  open MorphismStructures.GroupMorphisms (Bimodule.+ᴹ-rawGroup M₁) (Bimodule.+ᴹ-rawGroup M₂)
-  open LeftModuleMorphisms (Bimodule.leftModule M₁) (Bimodule.leftModule M₂)
-  open RightModuleMorphisms (Bimodule.rightModule M₁) (Bimodule.rightModule M₂)
-  open BisemimoduleMorphisms (Bimodule.bisemimodule M₁) (Bimodule.bisemimodule M₂)
+  open MorphismStructures.GroupMorphisms (RawBimodule.+ᴹ-rawGroup M₁) (RawBimodule.+ᴹ-rawGroup M₂)
+  open LeftModuleMorphisms (RawBimodule.rawLeftModule M₁) (RawBimodule.rawLeftModule M₂)
+  open RightModuleMorphisms (RawBimodule.rawRightModule M₁) (RawBimodule.rawRightModule M₂)
+  open BisemimoduleMorphisms (RawBimodule.rawBisemimodule M₁) (RawBimodule.rawBisemimodule M₂)
 
   record IsBimoduleHomomorphism (⟦_⟧ : A → B) : Set (r ⊔ s ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
@@ -418,7 +403,7 @@ module BimoduleMorphisms
   record IsBimoduleMonomorphism (⟦_⟧ : A → B) : Set (r ⊔ s ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isBimoduleHomomorphism : IsBimoduleHomomorphism ⟦_⟧
-      injective              : Injective ⟦_⟧
+      injective              : Injective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsBimoduleHomomorphism isBimoduleHomomorphism public
 
@@ -459,7 +444,7 @@ module BimoduleMorphisms
   record IsBimoduleIsomorphism (⟦_⟧ : A → B) : Set (r ⊔ s ⊔ m₁ ⊔ m₂ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isBimoduleMonomorphism : IsBimoduleMonomorphism ⟦_⟧
-      surjective             : Surjective ⟦_⟧
+      surjective             : Surjective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsBimoduleMonomorphism isBimoduleMonomorphism public
 
@@ -498,15 +483,14 @@ module BimoduleMorphisms
       }
 
 module SemimoduleMorphisms
-  {commutativeSemiring : CommutativeSemiring r ℓr}
-  (M₁ : Semimodule commutativeSemiring m₁ ℓm₁)
-  (M₂ : Semimodule commutativeSemiring m₂ ℓm₂)
+  {R : Set r}
+  (M₁ : RawSemimodule R m₁ ℓm₁)
+  (M₂ : RawSemimodule R m₂ ℓm₂)
   where
 
-  open Semimodule M₁ renaming (Carrierᴹ to A; _≈ᴹ_ to _≈ᴹ₁_)
-  open Semimodule M₂ renaming (Carrierᴹ to B; _≈ᴹ_ to _≈ᴹ₂_)
-  open FunctionDefinitions _≈ᴹ₁_ _≈ᴹ₂_
-  open BisemimoduleMorphisms (Semimodule.bisemimodule M₁) (Semimodule.bisemimodule M₂)
+  open RawSemimodule M₁ renaming (Carrierᴹ to A; _≈ᴹ_ to _≈ᴹ₁_)
+  open RawSemimodule M₂ renaming (Carrierᴹ to B; _≈ᴹ_ to _≈ᴹ₂_)
+  open BisemimoduleMorphisms (RawSemimodule.rawBisemimodule M₁) (RawSemimodule.rawBisemimodule M₂)
 
   record IsSemimoduleHomomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
@@ -517,7 +501,7 @@ module SemimoduleMorphisms
   record IsSemimoduleMonomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isSemimoduleHomomorphism : IsSemimoduleHomomorphism ⟦_⟧
-      injective                : Injective ⟦_⟧
+      injective                : Injective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsSemimoduleHomomorphism isSemimoduleHomomorphism public
 
@@ -535,7 +519,7 @@ module SemimoduleMorphisms
   record IsSemimoduleIsomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ m₂ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isSemimoduleMonomorphism : IsSemimoduleMonomorphism ⟦_⟧
-      surjective               : Surjective ⟦_⟧
+      surjective               : Surjective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsSemimoduleMonomorphism isSemimoduleMonomorphism public
 
@@ -551,16 +535,15 @@ module SemimoduleMorphisms
             )
 
 module ModuleMorphisms
-  {commutativeRing : CommutativeRing r ℓr}
-  (M₁ : Module commutativeRing m₁ ℓm₁)
-  (M₂ : Module commutativeRing m₂ ℓm₂)
+  {R : Set r}
+  (M₁ : RawModule R m₁ ℓm₁)
+  (M₂ : RawModule R m₂ ℓm₂)
   where
 
-  open Module M₁ renaming (Carrierᴹ to A; _≈ᴹ_ to _≈ᴹ₁_)
-  open Module M₂ renaming (Carrierᴹ to B; _≈ᴹ_ to _≈ᴹ₂_)
-  open FunctionDefinitions _≈ᴹ₁_ _≈ᴹ₂_
-  open BimoduleMorphisms (Module.bimodule M₁) (Module.bimodule M₂)
-  open SemimoduleMorphisms (Module.semimodule M₁) (Module.semimodule M₂)
+  open RawModule M₁ renaming (Carrierᴹ to A; _≈ᴹ_ to _≈ᴹ₁_)
+  open RawModule M₂ renaming (Carrierᴹ to B; _≈ᴹ_ to _≈ᴹ₂_)
+  open BimoduleMorphisms (RawModule.rawBimodule M₁) (RawModule.rawBimodule M₂)
+  open SemimoduleMorphisms (RawModule.rawBisemimodule M₁) (RawModule.rawBisemimodule M₂)
 
   record IsModuleHomomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
@@ -576,7 +559,7 @@ module ModuleMorphisms
   record IsModuleMonomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isModuleHomomorphism : IsModuleHomomorphism ⟦_⟧
-      injective            : Injective ⟦_⟧
+      injective            : Injective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsModuleHomomorphism isModuleHomomorphism public
 
@@ -601,7 +584,7 @@ module ModuleMorphisms
   record IsModuleIsomorphism (⟦_⟧ : A → B) : Set (r ⊔ m₁ ⊔ m₂ ⊔ ℓm₁ ⊔ ℓm₂) where
     field
       isModuleMonomorphism : IsModuleMonomorphism ⟦_⟧
-      surjective           : Surjective ⟦_⟧
+      surjective           : Surjective _≈ᴹ₁_ _≈ᴹ₂_ ⟦_⟧
 
     open IsModuleMonomorphism isModuleMonomorphism public
 
diff --git a/src/Algebra/Module/Structures.agda b/src/Algebra/Module/Structures.agda
index 20269f13a6..64873252bd 100644
--- a/src/Algebra/Module/Structures.agda
+++ b/src/Algebra/Module/Structures.agda
@@ -6,7 +6,9 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; Setoid; IsEquivalence)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
 
 module Algebra.Module.Structures where
 
@@ -16,7 +18,7 @@ open import Algebra.Module.Core
 import Algebra.Definitions as Defs
 open import Algebra.Module.Definitions
 open import Algebra.Structures
-open import Data.Product using (_,_; proj₁; proj₂)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Level using (Level; _⊔_)
 
 private
@@ -164,13 +166,16 @@ module _ (commutativeSemiring : CommutativeSemiring r ℓr)
   open CommutativeSemiring commutativeSemiring renaming (Carrier to R)
 
   -- An R-semimodule is an R-R-bisemimodule where R is commutative.
-  -- This means that *ₗ and *ᵣ coincide up to mathematical equality, though it
+  -- We enforce that *ₗ and *ᵣ coincide up to mathematical equality, though it
   -- may be that they do not coincide up to definitional equality.
 
+  open SimultaneousBiDefs R ≈ᴹ
+
   record IsSemimodule (*ₗ : Opₗ R M) (*ᵣ : Opᵣ R M)
                       : Set (r ⊔ m ⊔ ℓr ⊔ ℓm) where
     field
       isBisemimodule : IsBisemimodule semiring semiring ≈ᴹ +ᴹ 0ᴹ *ₗ *ᵣ
+      *ₗ-*ᵣ-coincident : Coincident *ₗ *ᵣ
 
     open IsBisemimodule isBisemimodule public
 
@@ -279,14 +284,17 @@ module _ (commutativeRing : CommutativeRing r ℓr)
   open CommutativeRing commutativeRing renaming (Carrier to R)
 
   -- An R-module is an R-R-bimodule where R is commutative.
-  -- This means that *ₗ and *ᵣ coincide up to mathematical equality, though it
+  -- We enforce that *ₗ and *ᵣ coincide up to mathematical equality, though it
   -- may be that they do not coincide up to definitional equality.
 
+  open SimultaneousBiDefs R ≈ᴹ
+
   record IsModule (*ₗ : Opₗ R M) (*ᵣ : Opᵣ R M) : Set (r ⊔ m ⊔ ℓr ⊔ ℓm) where
     field
       isBimodule : IsBimodule ring ring ≈ᴹ +ᴹ 0ᴹ -ᴹ *ₗ *ᵣ
+      *ₗ-*ᵣ-coincident : Coincident *ₗ *ᵣ
 
     open IsBimodule isBimodule public
 
     isSemimodule : IsSemimodule commutativeSemiring ≈ᴹ +ᴹ 0ᴹ *ₗ *ᵣ
-    isSemimodule = record { isBisemimodule = isBisemimodule }
+    isSemimodule = record { isBisemimodule = isBisemimodule; *ₗ-*ᵣ-coincident = *ₗ-*ᵣ-coincident }
diff --git a/src/Algebra/Module/Structures/Biased.agda b/src/Algebra/Module/Structures/Biased.agda
index 74d825e335..764745c54c 100644
--- a/src/Algebra/Module/Structures/Biased.agda
+++ b/src/Algebra/Module/Structures/Biased.agda
@@ -7,7 +7,9 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; Setoid; IsEquivalence)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
 
 module Algebra.Module.Structures.Biased where
 
@@ -55,7 +57,10 @@ module _ (commutativeSemiring : CommutativeSemiring r ℓr) where
       }
 
     isSemimodule : IsSemimodule commutativeSemiring ≈ᴹ +ᴹ 0ᴹ *ₗ (flip *ₗ)
-    isSemimodule = record { isBisemimodule = isBisemimodule }
+    isSemimodule = record
+      { isBisemimodule = isBisemimodule
+      ; *ₗ-*ᵣ-coincident = λ _ _ → ≈ᴹ-refl
+      }
 
   -- Similarly, a right semimodule over a commutative semiring
   -- is already a semimodule.
@@ -86,7 +91,10 @@ module _ (commutativeSemiring : CommutativeSemiring r ℓr) where
       }
 
     isSemimodule : IsSemimodule commutativeSemiring ≈ᴹ +ᴹ 0ᴹ (flip *ᵣ) *ᵣ
-    isSemimodule = record { isBisemimodule = isBisemimodule }
+    isSemimodule = record
+      { isBisemimodule = isBisemimodule
+      ; *ₗ-*ᵣ-coincident = λ _ _ → ≈ᴹ-refl
+      }
 
 
 module _ (commutativeRing : CommutativeRing r ℓr) where
@@ -111,6 +119,7 @@ module _ (commutativeRing : CommutativeRing r ℓr) where
         ; -ᴹ‿cong = -ᴹ‿cong
         ; -ᴹ‿inverse = -ᴹ‿inverse
         }
+      ; *ₗ-*ᵣ-coincident = λ _ _ → ≈ᴹ-refl
       }
 
   -- Similarly, a right module over a commutative ring is already a module.
@@ -132,4 +141,5 @@ module _ (commutativeRing : CommutativeRing r ℓr) where
         ; -ᴹ‿cong = -ᴹ‿cong
         ; -ᴹ‿inverse = -ᴹ‿inverse
         }
+      ; *ₗ-*ᵣ-coincident = λ _ _ → ≈ᴹ-refl
       }
diff --git a/src/Algebra/Morphism.agda b/src/Algebra/Morphism.agda
index fbcb2b0d12..e3bcb53e9b 100644
--- a/src/Algebra/Morphism.agda
+++ b/src/Algebra/Morphism.agda
@@ -11,10 +11,10 @@ module Algebra.Morphism where
 import Algebra.Morphism.Definitions as MorphismDefinitions
 open import Algebra
 import Algebra.Properties.Group as GroupP
-open import Function hiding (Morphism)
+open import Function.Base
 open import Level
-open import Relation.Binary
-import Relation.Binary.Reasoning.Setoid as EqR
+open import Relation.Binary.Core using (Rel; _Preserves_⟶_)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 private
   variable
@@ -137,7 +137,7 @@ module _ {c₁ ℓ₁ c₂ ℓ₂}
     open IsMonoidMorphism mn-homo public
 
     ⁻¹-homo : Homomorphic₁ ⟦_⟧ F._⁻¹ T._⁻¹
-    ⁻¹-homo x = let open EqR T.setoid in T.uniqueˡ-⁻¹ ⟦ x F.⁻¹ ⟧ ⟦ x ⟧ $ begin
+    ⁻¹-homo x = let open ≈-Reasoning T.setoid in T.uniqueˡ-⁻¹ ⟦ x F.⁻¹ ⟧ ⟦ x ⟧ $ begin
       ⟦ x F.⁻¹ ⟧ T.∙ ⟦ x ⟧ ≈⟨ T.sym (∙-homo (x F.⁻¹) x) ⟩
       ⟦ x F.⁻¹ F.∙ x ⟧     ≈⟨ ⟦⟧-cong (F.inverseˡ x) ⟩
       ⟦ F.ε ⟧              ≈⟨ ε-homo ⟩
@@ -185,7 +185,7 @@ module _ {c₁ ℓ₁ c₂ ℓ₂}
 
 {-# WARNING_ON_USAGE IsSemigroupMorphism
 "Warning: IsSemigroupMorphism was deprecated in v1.5.
-Please use IsSemigroupHomomorphism instead."
+Please use IsMagmaHomomorphism instead."
 #-}
 {-# WARNING_ON_USAGE IsMonoidMorphism
 "Warning: IsMonoidMorphism was deprecated in v1.5.
diff --git a/src/Algebra/Morphism/Consequences.agda b/src/Algebra/Morphism/Consequences.agda
index d5bc6a8076..b451a87088 100644
--- a/src/Algebra/Morphism/Consequences.agda
+++ b/src/Algebra/Morphism/Consequences.agda
@@ -10,12 +10,12 @@ module Algebra.Morphism.Consequences where
 
 open import Algebra using (Magma)
 open import Algebra.Morphism.Definitions
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (id; _∘_)
 open import Function.Definitions
-import Relation.Binary.Reasoning.Setoid as EqR
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
----------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- If f and g are mutually inverse maps between A and B, g is congruent,
 -- f is a homomorphism, then g is a homomorphism.
 
@@ -29,20 +29,20 @@ module _ {α α= β β=} (M₁ : Magma α α=) (M₂ : Magma β β=) where
                       Inverseᵇ _≈₁_ _≈₂_ f g →
                       Homomorphic₂ _ _ _≈₂_ f _∙₁_ _∙₂_  →
                       Homomorphic₂ _ _ _≈₁_ g _∙₂_ _∙₁_
-  homomorphic₂-inv {f} {g} g-cong (f∘g=id , g∘f=id) homo x y = begin
-    g (x ∙₂ y)             ≈⟨ M₁.sym (g-cong (M₂.∙-cong (f∘g=id x) (f∘g=id y))) ⟩
-    g (f (g x) ∙₂ f (g y)) ≈⟨ M₁.sym (g-cong (homo (g x) (g y))) ⟩
-    g (f (g x ∙₁ g y))     ≈⟨ g∘f=id (g x ∙₁ g y) ⟩
+  homomorphic₂-inv {f} {g} g-cong (invˡ , invʳ) homo x y = begin
+    g (x ∙₂ y)             ≈⟨ g-cong (M₂.∙-cong (invˡ M₁.refl) (invˡ M₁.refl)) ⟨
+    g (f (g x) ∙₂ f (g y)) ≈⟨ g-cong (homo (g x) (g y)) ⟨
+    g (f (g x ∙₁ g y))     ≈⟨ invʳ M₂.refl ⟩
     g x ∙₁ g y             ∎
-    where open EqR M₁.setoid
+    where open ≈-Reasoning M₁.setoid
 
   homomorphic₂-inj  : ∀ {f g} → Injective _≈₁_ _≈₂_ f →
                       Inverseˡ _≈₁_ _≈₂_ f g →
                       Homomorphic₂ _ _ _≈₂_ f _∙₁_ _∙₂_  →
                       Homomorphic₂ _ _ _≈₁_ g _∙₂_ _∙₁_
   homomorphic₂-inj {f} {g} inj invˡ homo x y = inj (begin
-    f (g (x ∙₂ y))      ≈⟨ invˡ (x ∙₂ y) ⟩
-    x ∙₂ y              ≈⟨ M₂.sym (M₂.∙-cong (invˡ x) (invˡ y)) ⟩
-    f (g x) ∙₂ f (g y)  ≈⟨ M₂.sym (homo (g x) (g y)) ⟩
+    f (g (x ∙₂ y))      ≈⟨ invˡ M₁.refl ⟩
+    x ∙₂ y              ≈⟨ M₂.∙-cong (invˡ M₁.refl) (invˡ M₁.refl) ⟨
+    f (g x) ∙₂ f (g y)  ≈⟨ homo (g x) (g y) ⟨
     f (g x ∙₁ g y)      ∎)
-    where open EqR M₂.setoid
+    where open ≈-Reasoning M₂.setoid
diff --git a/src/Algebra/Morphism/Construct/Composition.agda b/src/Algebra/Morphism/Construct/Composition.agda
index 991fb93433..17d5f2798b 100644
--- a/src/Algebra/Morphism/Construct/Composition.agda
+++ b/src/Algebra/Morphism/Construct/Composition.agda
@@ -10,7 +10,6 @@ module Algebra.Morphism.Construct.Composition where
 
 open import Algebra.Bundles
 open import Algebra.Morphism.Structures
-open import Data.Product
 open import Function.Base using (_∘_)
 import Function.Construct.Composition as Func
 open import Level using (Level)
@@ -57,7 +56,7 @@ module _ {M₁ : RawMagma a ℓ₁}
     → IsMagmaIsomorphism M₁ M₃ (g ∘ f)
   isMagmaIsomorphism f-iso g-iso = record
     { isMagmaMonomorphism = isMagmaMonomorphism F.isMagmaMonomorphism G.isMagmaMonomorphism
-    ; surjective          = Func.surjective (_≈_ M₁) _ _ ≈₃-trans G.⟦⟧-cong F.surjective G.surjective
+    ; surjective          = Func.surjective _ _ (_≈_ M₃) F.surjective G.surjective
     } where module F = IsMagmaIsomorphism f-iso; module G = IsMagmaIsomorphism g-iso
 
 
@@ -97,7 +96,7 @@ module _ {M₁ : RawMonoid a ℓ₁}
     → IsMonoidIsomorphism M₁ M₃ (g ∘ f)
   isMonoidIsomorphism f-iso g-iso = record
     { isMonoidMonomorphism = isMonoidMonomorphism F.isMonoidMonomorphism G.isMonoidMonomorphism
-    ; surjective           = Func.surjective (_≈_ M₁) _ _ ≈₃-trans G.⟦⟧-cong F.surjective G.surjective
+    ; surjective           = Func.surjective _ _(_≈_ M₃)  F.surjective G.surjective
     } where module F = IsMonoidIsomorphism f-iso; module G = IsMonoidIsomorphism g-iso
 
 
@@ -138,7 +137,7 @@ module _ {G₁ : RawGroup a ℓ₁}
     → IsGroupIsomorphism G₁ G₃ (g ∘ f)
   isGroupIsomorphism f-iso g-iso = record
     { isGroupMonomorphism = isGroupMonomorphism F.isGroupMonomorphism G.isGroupMonomorphism
-    ; surjective          = Func.surjective (_≈_ G₁) _ _ ≈₃-trans G.⟦⟧-cong F.surjective G.surjective
+    ; surjective          = Func.surjective  _ _ (_≈_ G₃) F.surjective G.surjective
     } where module F = IsGroupIsomorphism f-iso; module G = IsGroupIsomorphism g-iso
 
 
@@ -178,7 +177,7 @@ module _ {R₁ : RawNearSemiring a ℓ₁}
     → IsNearSemiringIsomorphism R₁ R₃ (g ∘ f)
   isNearSemiringIsomorphism f-iso g-iso = record
     { isNearSemiringMonomorphism = isNearSemiringMonomorphism F.isNearSemiringMonomorphism G.isNearSemiringMonomorphism
-    ; surjective                 = Func.surjective (_≈_ R₁) _ _ ≈₃-trans G.⟦⟧-cong F.surjective G.surjective
+    ; surjective                 = Func.surjective _ _ (_≈_ R₃) F.surjective G.surjective
     } where module F = IsNearSemiringIsomorphism f-iso; module G = IsNearSemiringIsomorphism g-iso
 
 
@@ -220,7 +219,7 @@ module _
     → IsSemiringIsomorphism R₁ R₃ (g ∘ f)
   isSemiringIsomorphism f-iso g-iso = record
     { isSemiringMonomorphism = isSemiringMonomorphism F.isSemiringMonomorphism G.isSemiringMonomorphism
-    ; surjective             = Func.surjective (_≈_ R₁) _ _ ≈₃-trans G.⟦⟧-cong F.surjective G.surjective
+    ; surjective             = Func.surjective _ _ (_≈_ R₃) F.surjective G.surjective
     } where module F = IsSemiringIsomorphism f-iso; module G = IsSemiringIsomorphism g-iso
 
 ------------------------------------------------------------------------
@@ -260,7 +259,7 @@ module _ {R₁ : RawRingWithoutOne a ℓ₁}
     → IsRingWithoutOneIsoMorphism R₁ R₃ (g ∘ f)
   isRingWithoutOneIsoMorphism f-iso g-iso = record
     { isRingWithoutOneMonomorphism = isRingWithoutOneMonomorphism F.isRingWithoutOneMonomorphism G.isRingWithoutOneMonomorphism
-    ; surjective         = Func.surjective (_≈_ R₁) (_≈_ R₂) (_≈_ R₃) ≈₃-trans G.⟦⟧-cong F.surjective G.surjective
+    ; surjective         = Func.surjective _ _ (_≈_ R₃) F.surjective G.surjective
     } where module F = IsRingWithoutOneIsoMorphism f-iso; module G = IsRingWithoutOneIsoMorphism g-iso
 
 ------------------------------------------------------------------------
@@ -300,7 +299,7 @@ module _ {R₁ : RawRing a ℓ₁}
     → IsRingIsomorphism R₁ R₃ (g ∘ f)
   isRingIsomorphism f-iso g-iso = record
     { isRingMonomorphism = isRingMonomorphism F.isRingMonomorphism G.isRingMonomorphism
-    ; surjective         = Func.surjective (_≈_ R₁) _ _ ≈₃-trans G.⟦⟧-cong F.surjective G.surjective
+    ; surjective         = Func.surjective _ _ (_≈_ R₃) F.surjective G.surjective
     } where module F = IsRingIsomorphism f-iso; module G = IsRingIsomorphism g-iso
 
 ------------------------------------------------------------------------
@@ -342,7 +341,7 @@ module _ {Q₁ : RawQuasigroup a ℓ₁}
     → IsQuasigroupIsomorphism Q₁ Q₃ (g ∘ f)
   isQuasigroupIsomorphism f-iso g-iso = record
     { isQuasigroupMonomorphism = isQuasigroupMonomorphism F.isQuasigroupMonomorphism G.isQuasigroupMonomorphism
-    ; surjective               = Func.surjective (_≈_ Q₁) (_≈_ Q₂) (_≈_ Q₃) ≈₃-trans G.⟦⟧-cong F.surjective G.surjective
+    ; surjective               = Func.surjective _ _ (_≈_ Q₃) F.surjective G.surjective
     } where module F = IsQuasigroupIsomorphism f-iso; module G = IsQuasigroupIsomorphism g-iso
 
 ------------------------------------------------------------------------
@@ -382,5 +381,45 @@ module _ {L₁ : RawLoop a ℓ₁}
     → IsLoopIsomorphism L₁ L₃ (g ∘ f)
   isLoopIsomorphism f-iso g-iso = record
     { isLoopMonomorphism = isLoopMonomorphism F.isLoopMonomorphism G.isLoopMonomorphism
-    ; surjective               = Func.surjective (_≈_ L₁) (_≈_ L₂) (_≈_ L₃) ≈₃-trans G.⟦⟧-cong F.surjective G.surjective
+    ; surjective         = Func.surjective _ _ (_≈_ L₃) F.surjective G.surjective
     } where module F = IsLoopIsomorphism f-iso; module G = IsLoopIsomorphism g-iso
+
+------------------------------------------------------------------------
+-- KleeneAlgebra
+
+module _ {K₁ : RawKleeneAlgebra a ℓ₁}
+         {K₂ : RawKleeneAlgebra b ℓ₂}
+         {K₃ : RawKleeneAlgebra c ℓ₃}
+         (open RawKleeneAlgebra)
+         (≈₃-trans : Transitive (_≈_ K₃))
+         {f : Carrier K₁ → Carrier K₂}
+         {g : Carrier K₂ → Carrier K₃}
+         where
+
+  isKleeneAlgebraHomomorphism
+    : IsKleeneAlgebraHomomorphism K₁ K₂ f
+    → IsKleeneAlgebraHomomorphism K₂ K₃ g
+    → IsKleeneAlgebraHomomorphism K₁ K₃ (g ∘ f)
+  isKleeneAlgebraHomomorphism f-homo g-homo = record
+    { isSemiringHomomorphism = isSemiringHomomorphism ≈₃-trans F.isSemiringHomomorphism G.isSemiringHomomorphism
+    ; ⋆-homo              = λ x → ≈₃-trans (G.⟦⟧-cong (F.⋆-homo x)) (G.⋆-homo (f x))
+    } where module F = IsKleeneAlgebraHomomorphism f-homo; module G = IsKleeneAlgebraHomomorphism g-homo
+
+  isKleeneAlgebraMonomorphism
+    : IsKleeneAlgebraMonomorphism K₁ K₂ f
+    → IsKleeneAlgebraMonomorphism K₂ K₃ g
+    → IsKleeneAlgebraMonomorphism K₁ K₃ (g ∘ f)
+  isKleeneAlgebraMonomorphism f-mono g-mono = record
+    { isKleeneAlgebraHomomorphism = isKleeneAlgebraHomomorphism F.isKleeneAlgebraHomomorphism G.isKleeneAlgebraHomomorphism
+    ; injective = F.injective ∘ G.injective
+    } where module F = IsKleeneAlgebraMonomorphism f-mono;  module G = IsKleeneAlgebraMonomorphism g-mono
+
+  isKleeneAlgebraIsomorphism
+    : IsKleeneAlgebraIsomorphism K₁ K₂ f
+    → IsKleeneAlgebraIsomorphism K₂ K₃ g
+    → IsKleeneAlgebraIsomorphism K₁ K₃ (g ∘ f)
+  isKleeneAlgebraIsomorphism f-iso g-iso = record
+    { isKleeneAlgebraMonomorphism = isKleeneAlgebraMonomorphism F.isKleeneAlgebraMonomorphism G.isKleeneAlgebraMonomorphism
+    ; surjective                  = Func.surjective (_≈_ K₁) (_≈_ K₂) (_≈_ K₃) F.surjective G.surjective
+    } where module F = IsKleeneAlgebraIsomorphism f-iso; module G = IsKleeneAlgebraIsomorphism g-iso
+
diff --git a/src/Algebra/Morphism/Construct/Identity.agda b/src/Algebra/Morphism/Construct/Identity.agda
index 5ea2571de0..881a8cf15c 100644
--- a/src/Algebra/Morphism/Construct/Identity.agda
+++ b/src/Algebra/Morphism/Construct/Identity.agda
@@ -19,9 +19,11 @@ open import Algebra.Morphism.Structures
         ; module RingMorphisms
         ; module QuasigroupMorphisms
         ; module LoopMorphisms
+        ; module KleeneAlgebraMorphisms
         )
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (id)
+import Function.Construct.Identity as Id
 open import Level using (Level)
 open import Relation.Binary.Morphism.Construct.Identity using (isRelHomomorphism)
 open import Relation.Binary.Definitions using (Reflexive)
@@ -51,7 +53,7 @@ module _ (M : RawMagma c ℓ) (open RawMagma M) (refl : Reflexive _≈_) where
   isMagmaIsomorphism : IsMagmaIsomorphism id
   isMagmaIsomorphism = record
     { isMagmaMonomorphism = isMagmaMonomorphism
-    ; surjective = _, refl
+    ; surjective = Id.surjective _
     }
 
 ------------------------------------------------------------------------
@@ -75,7 +77,7 @@ module _ (M : RawMonoid c ℓ) (open RawMonoid M) (refl : Reflexive _≈_) where
   isMonoidIsomorphism : IsMonoidIsomorphism id
   isMonoidIsomorphism = record
     { isMonoidMonomorphism = isMonoidMonomorphism
-    ; surjective = _, refl
+    ; surjective = Id.surjective _
     }
 
 ------------------------------------------------------------------------
@@ -99,7 +101,7 @@ module _ (G : RawGroup c ℓ) (open RawGroup G) (refl : Reflexive _≈_) where
   isGroupIsomorphism : IsGroupIsomorphism id
   isGroupIsomorphism = record
     { isGroupMonomorphism = isGroupMonomorphism
-    ; surjective = _, refl
+    ; surjective = Id.surjective _
     }
 
 ------------------------------------------------------------------------
@@ -123,7 +125,7 @@ module _ (R : RawNearSemiring c ℓ) (open RawNearSemiring R) (refl : Reflexive
   isNearSemiringIsomorphism : IsNearSemiringIsomorphism id
   isNearSemiringIsomorphism = record
     { isNearSemiringMonomorphism = isNearSemiringMonomorphism
-    ; surjective = _, refl
+    ; surjective = Id.surjective _
     }
 
 ------------------------------------------------------------------------
@@ -147,7 +149,7 @@ module _ (R : RawSemiring c ℓ) (open RawSemiring R) (refl : Reflexive _≈_) w
   isSemiringIsomorphism : IsSemiringIsomorphism id
   isSemiringIsomorphism = record
     { isSemiringMonomorphism = isSemiringMonomorphism
-    ; surjective = _, refl
+    ; surjective = Id.surjective _
     }
 
 ------------------------------------------------------------------------
@@ -171,7 +173,7 @@ module _ (R : RawRingWithoutOne c ℓ) (open RawRingWithoutOne R) (refl : Reflex
   isRingWithoutOneIsoMorphism : IsRingWithoutOneIsoMorphism id
   isRingWithoutOneIsoMorphism = record
     { isRingWithoutOneMonomorphism = isRingWithoutOneMonomorphism
-    ; surjective = _, refl
+    ; surjective = Id.surjective _
     }
 
 ------------------------------------------------------------------------
@@ -195,7 +197,7 @@ module _ (R : RawRing c ℓ) (open RawRing R) (refl : Reflexive _≈_) where
   isRingIsomorphism : IsRingIsomorphism id
   isRingIsomorphism = record
     { isRingMonomorphism = isRingMonomorphism
-    ; surjective = _, refl
+    ; surjective = Id.surjective _
     }
 
 ------------------------------------------------------------------------
@@ -221,7 +223,7 @@ module _ (Q : RawQuasigroup c ℓ) (open RawQuasigroup Q) (refl : Reflexive _≈
   isQuasigroupIsomorphism : IsQuasigroupIsomorphism id
   isQuasigroupIsomorphism = record
     { isQuasigroupMonomorphism = isQuasigroupMonomorphism
-    ; surjective = _, refl
+    ; surjective = Id.surjective _
     }
 
 ------------------------------------------------------------------------
@@ -245,5 +247,30 @@ module _ (L : RawLoop c ℓ) (open RawLoop L) (refl : Reflexive _≈_) where
   isLoopIsomorphism : IsLoopIsomorphism id
   isLoopIsomorphism = record
     { isLoopMonomorphism = isLoopMonomorphism
-    ; surjective = _, refl
+    ; surjective = Id.surjective _
     }
+
+------------------------------------------------------------------------
+-- KleeneAlgebra
+
+module _ (K : RawKleeneAlgebra c ℓ) (open RawKleeneAlgebra K) (refl : Reflexive _≈_) where
+  open KleeneAlgebraMorphisms K K
+
+  isKleeneAlgebraHomomorphism : IsKleeneAlgebraHomomorphism id
+  isKleeneAlgebraHomomorphism = record
+    { isSemiringHomomorphism = isSemiringHomomorphism _ refl
+    ; ⋆-homo = λ _ → refl
+    }
+
+  isKleeneAlgebraMonomorphism : IsKleeneAlgebraMonomorphism id
+  isKleeneAlgebraMonomorphism = record
+    { isKleeneAlgebraHomomorphism = isKleeneAlgebraHomomorphism
+    ; injective = id
+    }
+
+  isKleeneAlgebraIsomorphism : IsKleeneAlgebraIsomorphism id
+  isKleeneAlgebraIsomorphism = record
+    { isKleeneAlgebraMonomorphism = isKleeneAlgebraMonomorphism
+    ; surjective = Id.surjective _
+    }
+
diff --git a/src/Algebra/Morphism/Construct/Initial.agda b/src/Algebra/Morphism/Construct/Initial.agda
new file mode 100644
index 0000000000..883b70109d
--- /dev/null
+++ b/src/Algebra/Morphism/Construct/Initial.agda
@@ -0,0 +1,62 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- The unique morphism from the initial object,
+-- for each of the relevant categories. Since
+-- `Semigroup` and `Band` are simply `Magma`s
+-- satisfying additional properties, it suffices to
+-- define the morphism on the underlying `RawMagma`.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Level using (Level)
+
+module Algebra.Morphism.Construct.Initial {c ℓ : Level} where
+
+open import Algebra.Bundles.Raw using (RawMagma)
+open import Algebra.Morphism.Structures
+open import Function.Definitions using (Injective)
+import Relation.Binary.Morphism.Definitions as Rel
+open import Relation.Binary.Morphism.Structures
+open import Relation.Binary.Core using (Rel)
+
+open import Algebra.Construct.Initial {c} {ℓ}
+
+private
+  variable
+    a m ℓm : Level
+    A : Set a
+    ≈ : Rel A ℓm
+
+------------------------------------------------------------------------
+-- The unique morphism
+
+zero : ℤero.Carrier → A
+zero ()
+
+------------------------------------------------------------------------
+-- Basic properties
+
+cong : (≈ : Rel A ℓm) → Rel.Homomorphic₂ ℤero.Carrier A ℤero._≈_ ≈ zero
+cong _ {x = ()}
+
+injective : (≈ : Rel A ℓm) → Injective ℤero._≈_ ≈ zero
+injective _ {x = ()}
+
+------------------------------------------------------------------------
+-- Morphism structures
+
+isMagmaHomomorphism : (M : RawMagma m ℓm) →
+                      IsMagmaHomomorphism rawMagma M zero
+isMagmaHomomorphism M = record
+  { isRelHomomorphism = record { cong = cong (RawMagma._≈_ M) }
+  ; homo = λ()
+  }
+
+isMagmaMonomorphism : (M : RawMagma m ℓm) →
+                      IsMagmaMonomorphism rawMagma M zero
+isMagmaMonomorphism M = record
+  { isMagmaHomomorphism = isMagmaHomomorphism M
+  ; injective = injective (RawMagma._≈_ M)
+  }
diff --git a/src/Algebra/Morphism/Construct/Terminal.agda b/src/Algebra/Morphism/Construct/Terminal.agda
new file mode 100644
index 0000000000..227ebf2887
--- /dev/null
+++ b/src/Algebra/Morphism/Construct/Terminal.agda
@@ -0,0 +1,88 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- The unique morphism to the terminal object,
+-- for each of the relevant categories. Since
+-- each terminal algebra builds on `Monoid`,
+-- possibly with additional (trivial) operations,
+-- satisfying additional properties, it suffices to
+-- define the morphism on the underlying `RawMonoid`
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Level using (Level)
+
+module Algebra.Morphism.Construct.Terminal {c ℓ : Level} where
+
+open import Algebra.Bundles.Raw
+  using (RawMagma; RawMonoid; RawGroup; RawNearSemiring; RawSemiring; RawRing)
+open import Algebra.Morphism.Structures
+
+open import Data.Product.Base using (_,_)
+open import Function.Definitions using (StrictlySurjective)
+import Relation.Binary.Morphism.Definitions as Rel
+open import Relation.Binary.Morphism.Structures
+
+open import Algebra.Construct.Terminal {c} {ℓ}
+
+private
+  variable
+    a ℓa : Level
+    A : Set a
+
+------------------------------------------------------------------------
+-- The unique morphism
+
+one : A → 𝕆ne.Carrier
+one _ = _
+
+------------------------------------------------------------------------
+-- Basic properties
+
+strictlySurjective : A → StrictlySurjective 𝕆ne._≈_ one
+strictlySurjective x _ = x , _
+
+------------------------------------------------------------------------
+-- Homomorphisms
+
+isMagmaHomomorphism : (M : RawMagma a ℓa) →
+                      IsMagmaHomomorphism M rawMagma one
+isMagmaHomomorphism M = record
+  { isRelHomomorphism = record { cong = _ }
+  ; homo = _
+  }
+
+isMonoidHomomorphism : (M : RawMonoid a ℓa) →
+                       IsMonoidHomomorphism M rawMonoid one
+isMonoidHomomorphism M = record
+  { isMagmaHomomorphism = isMagmaHomomorphism (RawMonoid.rawMagma M)
+  ; ε-homo = _
+  }
+
+isGroupHomomorphism : (G : RawGroup a ℓa) →
+                      IsGroupHomomorphism G rawGroup one
+isGroupHomomorphism G = record
+  { isMonoidHomomorphism = isMonoidHomomorphism (RawGroup.rawMonoid G)
+  ; ⁻¹-homo = λ _ → _
+  }
+
+isNearSemiringHomomorphism : (N : RawNearSemiring a ℓa) →
+                             IsNearSemiringHomomorphism N rawNearSemiring one
+isNearSemiringHomomorphism N = record
+  { +-isMonoidHomomorphism = isMonoidHomomorphism (RawNearSemiring.+-rawMonoid N)
+  ; *-homo = λ _ _ → _
+  }
+
+isSemiringHomomorphism : (S : RawSemiring a ℓa) →
+                         IsSemiringHomomorphism S rawSemiring one
+isSemiringHomomorphism S = record
+  { isNearSemiringHomomorphism = isNearSemiringHomomorphism (RawSemiring.rawNearSemiring S)
+  ; 1#-homo = _
+  }
+
+isRingHomomorphism : (R : RawRing a ℓa) → IsRingHomomorphism R rawRing one
+isRingHomomorphism R = record
+  { isSemiringHomomorphism = isSemiringHomomorphism (RawRing.rawSemiring R)
+  ; -‿homo = λ _ → _
+  }
diff --git a/src/Algebra/Morphism/GroupMonomorphism.agda b/src/Algebra/Morphism/GroupMonomorphism.agda
index b7a09ce92c..4b3349d141 100644
--- a/src/Algebra/Morphism/GroupMonomorphism.agda
+++ b/src/Algebra/Morphism/GroupMonomorphism.agda
@@ -26,8 +26,8 @@ open RawGroup G₂ renaming
 
 open import Algebra.Definitions
 open import Algebra.Structures
-open import Data.Product
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
+open import Data.Product.Base using (_,_)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 ------------------------------------------------------------------------
 -- Re-export all properties of monoid monomorphisms
@@ -41,14 +41,14 @@ open import Algebra.Morphism.MonoidMonomorphism
 module _ (◦-isMagma : IsMagma _≈₂_ _◦_) where
 
   open IsMagma ◦-isMagma renaming (∙-cong to ◦-cong)
-  open SetoidReasoning setoid
+  open ≈-Reasoning setoid
 
   inverseˡ : LeftInverse _≈₂_ ε₂ _⁻¹₂ _◦_ → LeftInverse _≈₁_ ε₁ _⁻¹₁ _∙_
   inverseˡ invˡ x = injective (begin
     ⟦ x ⁻¹₁ ∙ x ⟧     ≈⟨ ∙-homo (x ⁻¹₁ ) x ⟩
     ⟦ x ⁻¹₁ ⟧ ◦ ⟦ x ⟧ ≈⟨ ◦-cong (⁻¹-homo x) refl ⟩
     ⟦ x ⟧ ⁻¹₂ ◦ ⟦ x ⟧ ≈⟨ invˡ ⟦ x ⟧ ⟩
-    ε₂                ≈˘⟨ ε-homo ⟩
+    ε₂                ≈⟨ ε-homo ⟨
     ⟦ ε₁ ⟧ ∎)
 
   inverseʳ : RightInverse _≈₂_ ε₂ _⁻¹₂ _◦_ → RightInverse _≈₁_ ε₁ _⁻¹₁ _∙_
@@ -56,7 +56,7 @@ module _ (◦-isMagma : IsMagma _≈₂_ _◦_) where
     ⟦ x ∙ x ⁻¹₁ ⟧     ≈⟨ ∙-homo x (x ⁻¹₁) ⟩
     ⟦ x ⟧ ◦ ⟦ x ⁻¹₁ ⟧ ≈⟨ ◦-cong refl (⁻¹-homo x) ⟩
     ⟦ x ⟧ ◦ ⟦ x ⟧ ⁻¹₂ ≈⟨ invʳ ⟦ x ⟧ ⟩
-    ε₂                ≈˘⟨ ε-homo ⟩
+    ε₂                ≈⟨ ε-homo ⟨
     ⟦ ε₁ ⟧ ∎)
 
   inverse : Inverse _≈₂_ ε₂ _⁻¹₂ _◦_ → Inverse _≈₁_ ε₁ _⁻¹₁ _∙_
@@ -66,13 +66,13 @@ module _ (◦-isMagma : IsMagma _≈₂_ _◦_) where
   ⁻¹-cong ⁻¹-cong {x} {y} x≈y = injective (begin
     ⟦ x ⁻¹₁ ⟧ ≈⟨ ⁻¹-homo x ⟩
     ⟦ x ⟧ ⁻¹₂ ≈⟨ ⁻¹-cong (⟦⟧-cong x≈y) ⟩
-    ⟦ y ⟧ ⁻¹₂ ≈˘⟨ ⁻¹-homo y ⟩
+    ⟦ y ⟧ ⁻¹₂ ≈⟨ ⁻¹-homo y ⟨
     ⟦ y ⁻¹₁ ⟧ ∎)
 
 module _ (◦-isAbelianGroup : IsAbelianGroup _≈₂_ _◦_ ε₂ _⁻¹₂) where
 
   open IsAbelianGroup ◦-isAbelianGroup renaming (∙-cong to ◦-cong; ⁻¹-cong to ⁻¹₂-cong)
-  open SetoidReasoning setoid
+  open ≈-Reasoning setoid
 
   ⁻¹-distrib-∙ : (∀ x y → (x ◦ y) ⁻¹₂ ≈₂ (x ⁻¹₂) ◦ (y ⁻¹₂)) → (∀ x y → (x ∙ y) ⁻¹₁ ≈₁ (x ⁻¹₁) ∙ (y ⁻¹₁))
   ⁻¹-distrib-∙ ⁻¹-distrib-∙ x y = injective (begin
diff --git a/src/Algebra/Morphism/MagmaMonomorphism.agda b/src/Algebra/Morphism/MagmaMonomorphism.agda
index c952fe112e..fbe08a5861 100644
--- a/src/Algebra/Morphism/MagmaMonomorphism.agda
+++ b/src/Algebra/Morphism/MagmaMonomorphism.agda
@@ -25,9 +25,9 @@ open RawMagma M₂ renaming (Carrier to B; _≈_ to _≈₂_; _∙_ to _◦_)
 
 open import Algebra.Structures
 open import Algebra.Definitions
-open import Data.Product
+open import Data.Product.Base using (map)
 open import Data.Sum.Base using (inj₁; inj₂)
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 import Relation.Binary.Morphism.RelMonomorphism isRelMonomorphism as RelMorphism
 
 ------------------------------------------------------------------------
@@ -36,13 +36,13 @@ import Relation.Binary.Morphism.RelMonomorphism isRelMonomorphism as RelMorphism
 module _ (◦-isMagma : IsMagma _≈₂_ _◦_) where
 
   open IsMagma ◦-isMagma renaming (∙-cong to ◦-cong)
-  open SetoidReasoning setoid
+  open ≈-Reasoning setoid
 
   cong : Congruent₂ _≈₁_ _∙_
   cong {x} {y} {u} {v} x≈y u≈v = injective (begin
     ⟦ x ∙ u ⟧      ≈⟨  homo x u ⟩
     ⟦ x ⟧ ◦ ⟦ u ⟧  ≈⟨  ◦-cong (⟦⟧-cong x≈y) (⟦⟧-cong u≈v) ⟩
-    ⟦ y ⟧ ◦ ⟦ v ⟧  ≈˘⟨ homo y v ⟩
+    ⟦ y ⟧ ◦ ⟦ v ⟧  ≈⟨ homo y v ⟨
     ⟦ y ∙ v ⟧      ∎)
 
   assoc : Associative _≈₂_ _◦_ → Associative _≈₁_ _∙_
@@ -50,15 +50,15 @@ module _ (◦-isMagma : IsMagma _≈₂_ _◦_) where
     ⟦ (x ∙ y) ∙ z ⟧          ≈⟨  homo (x ∙ y) z ⟩
     ⟦ x ∙ y ⟧ ◦ ⟦ z ⟧        ≈⟨  ◦-cong (homo x y) refl ⟩
     (⟦ x ⟧ ◦ ⟦ y ⟧) ◦ ⟦ z ⟧  ≈⟨  assoc ⟦ x ⟧ ⟦ y ⟧ ⟦ z ⟧ ⟩
-    ⟦ x ⟧ ◦ (⟦ y ⟧ ◦ ⟦ z ⟧)  ≈˘⟨ ◦-cong refl (homo y z) ⟩
-    ⟦ x ⟧ ◦ ⟦ y ∙ z ⟧        ≈˘⟨ homo x (y ∙ z) ⟩
+    ⟦ x ⟧ ◦ (⟦ y ⟧ ◦ ⟦ z ⟧)  ≈⟨ ◦-cong refl (homo y z) ⟨
+    ⟦ x ⟧ ◦ ⟦ y ∙ z ⟧        ≈⟨ homo x (y ∙ z) ⟨
     ⟦ x ∙ (y ∙ z) ⟧          ∎)
 
   comm : Commutative _≈₂_ _◦_ → Commutative _≈₁_ _∙_
   comm comm x y = injective (begin
     ⟦ x ∙ y ⟧      ≈⟨  homo x y ⟩
     ⟦ x ⟧ ◦ ⟦ y ⟧  ≈⟨  comm ⟦ x ⟧ ⟦ y ⟧ ⟩
-    ⟦ y ⟧ ◦ ⟦ x ⟧  ≈˘⟨ homo y x ⟩
+    ⟦ y ⟧ ◦ ⟦ x ⟧  ≈⟨ homo y x ⟨
     ⟦ y ∙ x ⟧      ∎)
 
   idem : Idempotent _≈₂_ _◦_ → Idempotent _≈₁_ _∙_
@@ -80,14 +80,14 @@ module _ (◦-isMagma : IsMagma _≈₂_ _◦_) where
 
   cancelˡ : LeftCancellative _≈₂_ _◦_ → LeftCancellative _≈₁_ _∙_
   cancelˡ cancelˡ x y z x∙y≈x∙z = injective (cancelˡ ⟦ x ⟧ ⟦ y ⟧ ⟦ z ⟧ (begin
-    ⟦ x ⟧ ◦ ⟦ y ⟧  ≈˘⟨ homo x y ⟩
+    ⟦ x ⟧ ◦ ⟦ y ⟧  ≈⟨ homo x y ⟨
     ⟦ x ∙ y ⟧      ≈⟨  ⟦⟧-cong x∙y≈x∙z ⟩
     ⟦ x ∙ z ⟧      ≈⟨  homo x z ⟩
     ⟦ x ⟧ ◦ ⟦ z ⟧  ∎))
 
   cancelʳ : RightCancellative _≈₂_ _◦_ → RightCancellative _≈₁_ _∙_
   cancelʳ cancelʳ x y z y∙x≈z∙x = injective (cancelʳ ⟦ x ⟧ ⟦ y ⟧ ⟦ z ⟧ (begin
-    ⟦ y ⟧ ◦ ⟦ x ⟧  ≈˘⟨ homo y x ⟩
+    ⟦ y ⟧ ◦ ⟦ x ⟧  ≈⟨ homo y x ⟨
     ⟦ y ∙ x ⟧      ≈⟨  ⟦⟧-cong y∙x≈z∙x ⟩
     ⟦ z ∙ x ⟧      ≈⟨  homo z x ⟩
     ⟦ z ⟧ ◦ ⟦ x ⟧  ∎))
diff --git a/src/Algebra/Morphism/MonoidMonomorphism.agda b/src/Algebra/Morphism/MonoidMonomorphism.agda
index 5f2d85d86a..1b918295af 100644
--- a/src/Algebra/Morphism/MonoidMonomorphism.agda
+++ b/src/Algebra/Morphism/MonoidMonomorphism.agda
@@ -24,8 +24,8 @@ open RawMonoid M₂ renaming (Carrier to B; _≈_ to _≈₂_; _∙_ to _◦_; 
 
 open import Algebra.Definitions
 open import Algebra.Structures
-open import Data.Product using (map)
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
+open import Data.Product.Base using (map)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 ------------------------------------------------------------------------
 -- Re-export all properties of magma monomorphisms
@@ -39,7 +39,7 @@ open import Algebra.Morphism.MagmaMonomorphism
 module _ (◦-isMagma : IsMagma _≈₂_ _◦_) where
 
   open IsMagma ◦-isMagma renaming (∙-cong to ◦-cong)
-  open SetoidReasoning setoid
+  open ≈-Reasoning setoid
 
   identityˡ : LeftIdentity _≈₂_ ε₂ _◦_ → LeftIdentity _≈₁_ ε₁ _∙_
   identityˡ idˡ x = injective (begin
@@ -63,7 +63,7 @@ module _ (◦-isMagma : IsMagma _≈₂_ _◦_) where
     ⟦ ε₁ ∙ x ⟧     ≈⟨  homo ε₁ x ⟩
     ⟦ ε₁ ⟧ ◦ ⟦ x ⟧ ≈⟨  ◦-cong ε-homo refl ⟩
     ε₂   ◦ ⟦ x ⟧   ≈⟨  zeˡ ⟦ x ⟧ ⟩
-    ε₂             ≈˘⟨ ε-homo ⟩
+    ε₂             ≈⟨ ε-homo ⟨
     ⟦ ε₁ ⟧         ∎)
 
   zeroʳ : RightZero _≈₂_ ε₂ _◦_ → RightZero _≈₁_ ε₁ _∙_
@@ -71,7 +71,7 @@ module _ (◦-isMagma : IsMagma _≈₂_ _◦_) where
     ⟦ x ∙ ε₁ ⟧     ≈⟨  homo x ε₁ ⟩
     ⟦ x ⟧ ◦ ⟦ ε₁ ⟧ ≈⟨  ◦-cong refl ε-homo ⟩
     ⟦ x ⟧ ◦ ε₂     ≈⟨  zeʳ ⟦ x ⟧ ⟩
-    ε₂             ≈˘⟨ ε-homo ⟩
+    ε₂             ≈⟨ ε-homo ⟨
     ⟦ ε₁ ⟧         ∎)
 
   zero : Zero _≈₂_ ε₂ _◦_ → Zero _≈₁_ ε₁ _∙_
diff --git a/src/Algebra/Morphism/RingMonomorphism.agda b/src/Algebra/Morphism/RingMonomorphism.agda
index f9789e60b7..40e7a80d83 100644
--- a/src/Algebra/Morphism/RingMonomorphism.agda
+++ b/src/Algebra/Morphism/RingMonomorphism.agda
@@ -28,8 +28,8 @@ open RawRing R₂ renaming
 
 open import Algebra.Definitions
 open import Algebra.Structures
-open import Data.Product
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
+open import Data.Product.Base using (proj₁; proj₂; _,_)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 ------------------------------------------------------------------------
 -- Re-export all properties of group and monoid monomorphisms
@@ -83,15 +83,15 @@ module _ (+-isGroup : IsGroup _≈₂_ _⊕_ 0#₂ ⊝_)
 
   open IsGroup +-isGroup hiding (setoid; refl; sym)
   open IsMagma *-isMagma renaming (∙-cong to ◦-cong)
-  open SetoidReasoning setoid
+  open ≈-Reasoning setoid
 
   distribˡ : _DistributesOverˡ_ _≈₂_ _⊛_ _⊕_ → _DistributesOverˡ_ _≈₁_ _*_ _+_
   distribˡ distribˡ x y z = injective (begin
     ⟦ x * (y + z) ⟧               ≈⟨ *-homo x (y + z) ⟩
     ⟦ x ⟧ ⊛ ⟦ y + z ⟧             ≈⟨ ◦-cong refl (+-homo y z) ⟩
     ⟦ x ⟧ ⊛ (⟦ y ⟧ ⊕ ⟦ z ⟧)       ≈⟨ distribˡ ⟦ x ⟧ ⟦ y ⟧ ⟦ z ⟧ ⟩
-    ⟦ x ⟧ ⊛ ⟦ y ⟧ ⊕ ⟦ x ⟧ ⊛ ⟦ z ⟧ ≈˘⟨ ∙-cong (*-homo x y) (*-homo x z) ⟩
-    ⟦ x * y ⟧ ⊕ ⟦ x * z ⟧         ≈˘⟨ +-homo (x * y) (x * z) ⟩
+    ⟦ x ⟧ ⊛ ⟦ y ⟧ ⊕ ⟦ x ⟧ ⊛ ⟦ z ⟧ ≈⟨ ∙-cong (*-homo x y) (*-homo x z) ⟨
+    ⟦ x * y ⟧ ⊕ ⟦ x * z ⟧         ≈⟨ +-homo (x * y) (x * z) ⟨
     ⟦ x * y + x * z ⟧ ∎)
 
   distribʳ : _DistributesOverʳ_ _≈₂_ _⊛_ _⊕_ → _DistributesOverʳ_ _≈₁_ _*_ _+_
@@ -99,8 +99,8 @@ module _ (+-isGroup : IsGroup _≈₂_ _⊕_ 0#₂ ⊝_)
     ⟦ (y + z) * x ⟧               ≈⟨ *-homo (y + z) x ⟩
     ⟦ y + z ⟧ ⊛ ⟦ x ⟧             ≈⟨ ◦-cong (+-homo y z) refl ⟩
     (⟦ y ⟧ ⊕ ⟦ z ⟧) ⊛ ⟦ x ⟧       ≈⟨ distribˡ ⟦ x ⟧ ⟦ y ⟧ ⟦ z ⟧ ⟩
-    ⟦ y ⟧ ⊛ ⟦ x ⟧ ⊕ ⟦ z ⟧ ⊛ ⟦ x ⟧ ≈˘⟨ ∙-cong (*-homo y x) (*-homo z x) ⟩
-    ⟦ y * x ⟧ ⊕ ⟦ z * x ⟧         ≈˘⟨ +-homo (y * x) (z * x) ⟩
+    ⟦ y ⟧ ⊛ ⟦ x ⟧ ⊕ ⟦ z ⟧ ⊛ ⟦ x ⟧ ≈⟨ ∙-cong (*-homo y x) (*-homo z x) ⟨
+    ⟦ y * x ⟧ ⊕ ⟦ z * x ⟧         ≈⟨ +-homo (y * x) (z * x) ⟨
     ⟦ y * x + z * x ⟧ ∎)
 
   distrib : _DistributesOver_ _≈₂_ _⊛_ _⊕_ → _DistributesOver_ _≈₁_ _*_ _+_
@@ -111,7 +111,7 @@ module _ (+-isGroup : IsGroup _≈₂_ _⊕_ 0#₂ ⊝_)
     ⟦ 0# * x ⟧     ≈⟨ *-homo 0# x ⟩
     ⟦ 0# ⟧ ⊛ ⟦ x ⟧ ≈⟨ ◦-cong 0#-homo refl ⟩
     0#₂ ⊛ ⟦ x ⟧    ≈⟨ zeroˡ ⟦ x ⟧ ⟩
-    0#₂            ≈˘⟨ 0#-homo ⟩
+    0#₂            ≈⟨ 0#-homo ⟨
     ⟦ 0# ⟧         ∎)
 
   zeroʳ : RightZero _≈₂_ 0#₂ _⊛_ → RightZero _≈₁_ 0# _*_
@@ -119,7 +119,7 @@ module _ (+-isGroup : IsGroup _≈₂_ _⊕_ 0#₂ ⊝_)
     ⟦ x * 0# ⟧     ≈⟨ *-homo x 0# ⟩
     ⟦ x ⟧ ⊛ ⟦ 0# ⟧ ≈⟨ ◦-cong refl 0#-homo ⟩
     ⟦ x ⟧ ⊛ 0#₂    ≈⟨ zeroʳ ⟦ x ⟧ ⟩
-    0#₂            ≈˘⟨ 0#-homo ⟩
+    0#₂            ≈⟨ 0#-homo ⟨
     ⟦ 0# ⟧         ∎)
 
   zero : Zero _≈₂_ 0#₂ _⊛_ → Zero _≈₁_ 0# _*_
@@ -150,7 +150,6 @@ isRing isRing = record
   ; *-assoc          = *-assoc R.*-isMagma R.*-assoc
   ; *-identity       = *-identity R.*-isMagma R.*-identity
   ; distrib          = distrib R.+-isGroup R.*-isMagma R.distrib
-  ; zero             = zero R.+-isGroup R.*-isMagma R.zero
   } where module R = IsRing isRing
 
 isCommutativeRing : IsCommutativeRing _≈₂_ _⊕_ _⊛_ ⊝_ 0#₂ 1#₂ →
diff --git a/src/Algebra/Morphism/Structures.agda b/src/Algebra/Morphism/Structures.agda
index 525cbf5da0..c352904be7 100644
--- a/src/Algebra/Morphism/Structures.agda
+++ b/src/Algebra/Morphism/Structures.agda
@@ -6,21 +6,69 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary.Core
-
 module Algebra.Morphism.Structures where
 
 open import Algebra.Core
 open import Algebra.Bundles
 import Algebra.Morphism.Definitions as MorphismDefinitions
 open import Level using (Level; _⊔_)
-import Function.Definitions as FunctionDefinitions
+open import Function.Definitions
+open import Relation.Binary.Core
 open import Relation.Binary.Morphism.Structures
 
 private
   variable
     a b ℓ₁ ℓ₂ : Level
 
+------------------------------------------------------------------------
+-- Morphisms over SuccessorSet-like structures
+------------------------------------------------------------------------
+
+module SuccessorSetMorphisms
+  (N₁ : RawSuccessorSet a ℓ₁) (N₂ : RawSuccessorSet b ℓ₂)
+  where
+
+  open RawSuccessorSet N₁
+    renaming (Carrier to A; _≈_ to _≈₁_; suc# to suc#₁; zero# to zero#₁)
+  open RawSuccessorSet N₂
+    renaming (Carrier to B; _≈_ to _≈₂_; suc# to suc#₂; zero# to zero#₂)
+  open MorphismDefinitions A B _≈₂_
+
+
+  record IsSuccessorSetHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
+    field
+      isRelHomomorphism : IsRelHomomorphism _≈₁_ _≈₂_ ⟦_⟧
+      suc#-homo         : Homomorphic₁ ⟦_⟧ suc#₁ suc#₂
+      zero#-homo        : Homomorphic₀ ⟦_⟧ zero#₁ zero#₂
+
+  record IsSuccessorSetMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
+    field
+      isSuccessorSetHomomorphism : IsSuccessorSetHomomorphism ⟦_⟧
+      injective                  : Injective _≈₁_ _≈₂_ ⟦_⟧
+
+    open IsSuccessorSetHomomorphism isSuccessorSetHomomorphism public
+
+    isRelMonomorphism : IsRelMonomorphism _≈₁_ _≈₂_ ⟦_⟧
+    isRelMonomorphism = record
+      { isHomomorphism = isRelHomomorphism
+      ; injective      = injective
+      }
+
+
+  record IsSuccessorSetIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
+    field
+      isSuccessorSetMonomorphism : IsSuccessorSetMonomorphism ⟦_⟧
+      surjective                 : Surjective _≈₁_ _≈₂_ ⟦_⟧
+
+    open IsSuccessorSetMonomorphism isSuccessorSetMonomorphism public
+
+    isRelIsomorphism : IsRelIsomorphism _≈₁_ _≈₂_ ⟦_⟧
+    isRelIsomorphism = record
+      { isMonomorphism = isRelMonomorphism
+      ; surjective     = surjective
+      }
+
+
 ------------------------------------------------------------------------
 -- Morphisms over magma-like structures
 ------------------------------------------------------------------------
@@ -30,7 +78,6 @@ module MagmaMorphisms (M₁ : RawMagma a ℓ₁) (M₂ : RawMagma b ℓ₂) wher
   open RawMagma M₁ renaming (Carrier to A; _≈_ to _≈₁_; _∙_ to _∙_)
   open RawMagma M₂ renaming (Carrier to B; _≈_ to _≈₂_; _∙_ to _◦_)
   open MorphismDefinitions A B _≈₂_
-  open FunctionDefinitions _≈₁_ _≈₂_
 
 
   record IsMagmaHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
@@ -45,7 +92,7 @@ module MagmaMorphisms (M₁ : RawMagma a ℓ₁) (M₂ : RawMagma b ℓ₂) wher
   record IsMagmaMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isMagmaHomomorphism : IsMagmaHomomorphism ⟦_⟧
-      injective           : Injective ⟦_⟧
+      injective           : Injective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsMagmaHomomorphism isMagmaHomomorphism public
 
@@ -59,7 +106,7 @@ module MagmaMorphisms (M₁ : RawMagma a ℓ₁) (M₂ : RawMagma b ℓ₂) wher
   record IsMagmaIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isMagmaMonomorphism : IsMagmaMonomorphism ⟦_⟧
-      surjective          : Surjective ⟦_⟧
+      surjective          : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsMagmaMonomorphism isMagmaMonomorphism public
 
@@ -79,7 +126,6 @@ module MonoidMorphisms (M₁ : RawMonoid a ℓ₁) (M₂ : RawMonoid b ℓ₂) w
   open RawMonoid M₁ renaming (Carrier to A; _≈_ to _≈₁_; _∙_ to _∙_; ε to ε₁)
   open RawMonoid M₂ renaming (Carrier to B; _≈_ to _≈₂_; _∙_ to _◦_; ε to ε₂)
   open MorphismDefinitions A B _≈₂_
-  open FunctionDefinitions _≈₁_ _≈₂_
   open MagmaMorphisms (RawMonoid.rawMagma M₁) (RawMonoid.rawMagma M₂)
 
 
@@ -94,7 +140,7 @@ module MonoidMorphisms (M₁ : RawMonoid a ℓ₁) (M₂ : RawMonoid b ℓ₂) w
   record IsMonoidMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isMonoidHomomorphism : IsMonoidHomomorphism ⟦_⟧
-      injective            : Injective ⟦_⟧
+      injective            : Injective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsMonoidHomomorphism isMonoidHomomorphism public
 
@@ -111,7 +157,7 @@ module MonoidMorphisms (M₁ : RawMonoid a ℓ₁) (M₂ : RawMonoid b ℓ₂) w
   record IsMonoidIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isMonoidMonomorphism : IsMonoidMonomorphism ⟦_⟧
-      surjective           : Surjective ⟦_⟧
+      surjective           : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsMonoidMonomorphism isMonoidMonomorphism public
 
@@ -136,7 +182,6 @@ module GroupMorphisms (G₁ : RawGroup a ℓ₁) (G₂ : RawGroup b ℓ₂) wher
   open RawGroup G₂ renaming
     (Carrier to B; _≈_ to _≈₂_; _∙_ to _◦_; _⁻¹ to _⁻¹₂; ε to ε₂)
   open MorphismDefinitions A B _≈₂_
-  open FunctionDefinitions _≈₁_ _≈₂_
   open MagmaMorphisms  (RawGroup.rawMagma  G₁) (RawGroup.rawMagma  G₂)
   open MonoidMorphisms (RawGroup.rawMonoid G₁) (RawGroup.rawMonoid G₂)
 
@@ -152,7 +197,7 @@ module GroupMorphisms (G₁ : RawGroup a ℓ₁) (G₂ : RawGroup b ℓ₂) wher
   record IsGroupMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isGroupHomomorphism : IsGroupHomomorphism ⟦_⟧
-      injective           : Injective ⟦_⟧
+      injective           : Injective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsGroupHomomorphism isGroupHomomorphism public
       renaming (homo to ∙-homo)
@@ -170,7 +215,7 @@ module GroupMorphisms (G₁ : RawGroup a ℓ₁) (G₂ : RawGroup b ℓ₂) wher
   record IsGroupIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isGroupMonomorphism : IsGroupMonomorphism ⟦_⟧
-      surjective          : Surjective ⟦_⟧
+      surjective          : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsGroupMonomorphism isGroupMonomorphism public
 
@@ -207,7 +252,6 @@ module NearSemiringMorphisms (R₁ : RawNearSemiring a ℓ₁) (R₂ : RawNearSe
     module * = MagmaMorphisms *-rawMagma₁ *-rawMagma₂
 
   open MorphismDefinitions A B _≈₂_
-  open FunctionDefinitions _≈₁_ _≈₂_
 
 
   record IsNearSemiringHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
@@ -227,7 +271,7 @@ module NearSemiringMorphisms (R₁ : RawNearSemiring a ℓ₁) (R₂ : RawNearSe
   record IsNearSemiringMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isNearSemiringHomomorphism : IsNearSemiringHomomorphism ⟦_⟧
-      injective          : Injective ⟦_⟧
+      injective          : Injective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsNearSemiringHomomorphism isNearSemiringHomomorphism public
 
@@ -250,7 +294,7 @@ module NearSemiringMorphisms (R₁ : RawNearSemiring a ℓ₁) (R₂ : RawNearSe
   record IsNearSemiringIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isNearSemiringMonomorphism : IsNearSemiringMonomorphism ⟦_⟧
-      surjective                 : Surjective ⟦_⟧
+      surjective                 : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsNearSemiringMonomorphism isNearSemiringMonomorphism public
 
@@ -292,7 +336,6 @@ module SemiringMorphisms (R₁ : RawSemiring a ℓ₁) (R₂ : RawSemiring b ℓ
     module * = MonoidMorphisms *-rawMonoid₁ *-rawMonoid₂
 
   open MorphismDefinitions A B _≈₂_
-  open FunctionDefinitions _≈₁_ _≈₂_
   open NearSemiringMorphisms rawNearSemiring₁ rawNearSemiring₂
 
   record IsSemiringHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
@@ -311,7 +354,7 @@ module SemiringMorphisms (R₁ : RawSemiring a ℓ₁) (R₂ : RawSemiring b ℓ
   record IsSemiringMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isSemiringHomomorphism : IsSemiringHomomorphism ⟦_⟧
-      injective              : Injective ⟦_⟧
+      injective              : Injective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsSemiringHomomorphism isSemiringHomomorphism public
 
@@ -333,7 +376,7 @@ module SemiringMorphisms (R₁ : RawSemiring a ℓ₁) (R₂ : RawSemiring b ℓ
   record IsSemiringIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isSemiringMonomorphism : IsSemiringMonomorphism ⟦_⟧
-      surjective             : Surjective ⟦_⟧
+      surjective             : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsSemiringMonomorphism isSemiringMonomorphism public
 
@@ -375,7 +418,6 @@ module RingWithoutOneMorphisms (R₁ : RawRingWithoutOne a ℓ₁) (R₂ : RawRi
     module * = MagmaMorphisms *-rawMagma₁ *-rawMagma₂
 
   open MorphismDefinitions A B _≈₂_
-  open FunctionDefinitions _≈₁_ _≈₂_
 
   record IsRingWithoutOneHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
@@ -394,7 +436,7 @@ module RingWithoutOneMorphisms (R₁ : RawRingWithoutOne a ℓ₁) (R₂ : RawRi
   record IsRingWithoutOneMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isRingWithoutOneHomomorphism : IsRingWithoutOneHomomorphism ⟦_⟧
-      injective                    : Injective ⟦_⟧
+      injective                    : Injective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsRingWithoutOneHomomorphism isRingWithoutOneHomomorphism public
 
@@ -417,7 +459,7 @@ module RingWithoutOneMorphisms (R₁ : RawRingWithoutOne a ℓ₁) (R₂ : RawRi
   record IsRingWithoutOneIsoMorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isRingWithoutOneMonomorphism : IsRingWithoutOneMonomorphism ⟦_⟧
-      surjective                   : Surjective ⟦_⟧
+      surjective                   : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsRingWithoutOneMonomorphism isRingWithoutOneMonomorphism public
 
@@ -462,7 +504,6 @@ module RingMorphisms (R₁ : RawRing a ℓ₁) (R₂ : RawRing b ℓ₂) where
   module * = MonoidMorphisms *-rawMonoid₁ *-rawMonoid₂
 
   open MorphismDefinitions A B _≈₂_
-  open FunctionDefinitions _≈₁_ _≈₂_
   open SemiringMorphisms rawSemiring₁ rawSemiring₂
 
 
@@ -482,7 +523,7 @@ module RingMorphisms (R₁ : RawRing a ℓ₁) (R₂ : RawRing b ℓ₂) where
   record IsRingMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isRingHomomorphism : IsRingHomomorphism ⟦_⟧
-      injective          : Injective ⟦_⟧
+      injective          : Injective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsRingHomomorphism isRingHomomorphism public
 
@@ -518,7 +559,7 @@ module RingMorphisms (R₁ : RawRing a ℓ₁) (R₂ : RawRing b ℓ₂) where
   record IsRingIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isRingMonomorphism : IsRingMonomorphism ⟦_⟧
-      surjective         : Surjective ⟦_⟧
+      surjective         : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsRingMonomorphism isRingMonomorphism public
 
@@ -568,7 +609,6 @@ module QuasigroupMorphisms (Q₁ : RawQuasigroup a ℓ₁) (Q₂ : RawQuasigroup
   module // = MagmaMorphisms //-rawMagma₁ //-rawMagma₂
 
   open MorphismDefinitions A B _≈₂_
-  open FunctionDefinitions _≈₁_ _≈₂_
 
   record IsQuasigroupHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
@@ -601,7 +641,7 @@ module QuasigroupMorphisms (Q₁ : RawQuasigroup a ℓ₁) (Q₂ : RawQuasigroup
   record IsQuasigroupMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isQuasigroupHomomorphism : IsQuasigroupHomomorphism ⟦_⟧
-      injective                : Injective ⟦_⟧
+      injective                : Injective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsQuasigroupHomomorphism isQuasigroupHomomorphism public
 
@@ -631,7 +671,7 @@ module QuasigroupMorphisms (Q₁ : RawQuasigroup a ℓ₁) (Q₂ : RawQuasigroup
   record IsQuasigroupIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isQuasigroupMonomorphism : IsQuasigroupMonomorphism ⟦_⟧
-      surjective               : Surjective ⟦_⟧
+      surjective               : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsQuasigroupMonomorphism isQuasigroupMonomorphism public
 
@@ -669,7 +709,6 @@ module LoopMorphisms (L₁ : RawLoop a ℓ₁) (L₂ : RawLoop b ℓ₂) where
                             \\-rawMagma to \\-rawMagma₂; //-rawMagma to //-rawMagma₂;
                             _≈_ to _≈₂_; _∙_ to _∙₂_; _\\_ to _\\₂_; _//_ to _//₂_ ; ε to ε₂)
   open MorphismDefinitions A B _≈₂_
-  open FunctionDefinitions _≈₁_ _≈₂_
 
   open QuasigroupMorphisms (RawLoop.rawQuasigroup L₁) (RawLoop.rawQuasigroup L₂)
 
@@ -683,17 +722,58 @@ module LoopMorphisms (L₁ : RawLoop a ℓ₁) (L₂ : RawLoop b ℓ₂) where
   record IsLoopMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isLoopHomomorphism   : IsLoopHomomorphism ⟦_⟧
-      injective            : Injective ⟦_⟧
+      injective            : Injective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsLoopHomomorphism isLoopHomomorphism public
 
   record IsLoopIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       isLoopMonomorphism   : IsLoopMonomorphism ⟦_⟧
-      surjective           : Surjective ⟦_⟧
+      surjective           : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
     open IsLoopMonomorphism isLoopMonomorphism public
 
+------------------------------------------------------------------------
+-- Morphisms over Kleene algebra structures
+------------------------------------------------------------------------
+module KleeneAlgebraMorphisms (R₁ : RawKleeneAlgebra a ℓ₁) (R₂ : RawKleeneAlgebra b ℓ₂) where
+
+  open RawKleeneAlgebra R₁ renaming
+    ( Carrier to A; _≈_ to _≈₁_
+    ; _⋆ to _⋆₁
+    ; rawSemiring to rawSemiring₁
+    )
+
+  open RawKleeneAlgebra R₂ renaming
+    ( Carrier to B; _≈_ to _≈₂_
+    ; _⋆ to _⋆₂
+    ; rawSemiring to rawSemiring₂
+    )
+
+  open MorphismDefinitions A B _≈₂_
+  open SemiringMorphisms rawSemiring₁ rawSemiring₂
+
+  record IsKleeneAlgebraHomomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
+    field
+      isSemiringHomomorphism : IsSemiringHomomorphism ⟦_⟧
+      ⋆-homo :  Homomorphic₁ ⟦_⟧ _⋆₁ _⋆₂
+
+    open IsSemiringHomomorphism isSemiringHomomorphism public
+
+  record IsKleeneAlgebraMonomorphism (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
+    field
+      isKleeneAlgebraHomomorphism   : IsKleeneAlgebraHomomorphism ⟦_⟧
+      injective                     : Injective  _≈₁_ _≈₂_ ⟦_⟧
+
+    open IsKleeneAlgebraHomomorphism isKleeneAlgebraHomomorphism public
+
+  record IsKleeneAlgebraIsomorphism (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
+    field
+      isKleeneAlgebraMonomorphism   : IsKleeneAlgebraMonomorphism ⟦_⟧
+      surjective                    : Surjective  _≈₁_ _≈₂_ ⟦_⟧
+
+    open IsKleeneAlgebraMonomorphism isKleeneAlgebraMonomorphism public
+
 ------------------------------------------------------------------------
 -- Re-export contents of modules publicly
 
@@ -706,3 +786,4 @@ open RingWithoutOneMorphisms public
 open RingMorphisms public
 open QuasigroupMorphisms public
 open LoopMorphisms public
+open KleeneAlgebraMorphisms public
diff --git a/src/Algebra/Operations/CommutativeMonoid.agda b/src/Algebra/Operations/CommutativeMonoid.agda
index 3c94a94419..626d7570fb 100644
--- a/src/Algebra/Operations/CommutativeMonoid.agda
+++ b/src/Algebra/Operations/CommutativeMonoid.agda
@@ -12,7 +12,7 @@ open import Data.Fin.Base using (Fin; zero)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
 open import Function.Base using (_∘_)
 open import Relation.Binary.Core using (_Preserves_⟶_; _Preserves₂_⟶_⟶_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 module Algebra.Operations.CommutativeMonoid
   {s₁ s₂} (CM : CommutativeMonoid s₁ s₂)
@@ -58,7 +58,7 @@ suc n ×′ x = x + n ×′ x
 ×-congʳ (suc n) x≈x′ = +-cong x≈x′ (×-congʳ n x≈x′)
 
 ×-cong : _×_ Preserves₂ _≡_ ⟶ _≈_ ⟶ _≈_
-×-cong {u} P.refl x≈x′ = ×-congʳ u x≈x′
+×-cong {u} ≡.refl x≈x′ = ×-congʳ u x≈x′
 
 -- _×_ is homomorphic with respect to _ℕ+_/_+_.
 
@@ -98,7 +98,7 @@ suc n ×′ x = x + n ×′ x
 -- _×′_ preserves equality.
 
 ×′-cong : _×′_ Preserves₂ _≡_ ⟶ _≈_ ⟶ _≈_
-×′-cong {n} {_} {x} {y} P.refl x≈y = begin
+×′-cong {n} {_} {x} {y} ≡.refl x≈y = begin
   n  ×′ x ≈⟨ sym (×≈×′ n x) ⟩
   n  ×  x ≈⟨ ×-congʳ n x≈y ⟩
   n  ×  y ≈⟨ ×≈×′ n y ⟩
diff --git a/src/Algebra/Operations/Semiring.agda b/src/Algebra/Operations/Semiring.agda
index fbc6c254c2..08d55c884d 100644
--- a/src/Algebra/Operations/Semiring.agda
+++ b/src/Algebra/Operations/Semiring.agda
@@ -26,6 +26,6 @@ open Semiring S
 -- Re-exports
 
 open MonoidOperations +-commutativeMonoid public
-open import Algebra.Properties.Semiring.Exponentiation S public
-open import Algebra.Properties.Semiring.Multiplication S public
-  using (×1-homo-*; ×′1-homo-*)
+open import Algebra.Properties.Semiring.Exp S public
+open import Algebra.Properties.Semiring.Mult S public
+  using (×1-homo-*)
diff --git a/src/Algebra/Ordered.agda b/src/Algebra/Ordered.agda
deleted file mode 100644
index 5eb99aec36..0000000000
--- a/src/Algebra/Ordered.agda
+++ /dev/null
@@ -1,14 +0,0 @@
-------------------------------------------------------------------------
--- The Agda standard library
---
--- Definitions of ordered algebraic structures like promonoids and
--- posemigroups (packed in records together with sets, orders,
--- operations, etc.)
-------------------------------------------------------------------------
-
-{-# OPTIONS --cubical-compatible --safe #-}
-
-module Algebra.Ordered where
-
-open import Algebra.Ordered.Structures public
-open import Algebra.Ordered.Bundles public
diff --git a/src/Algebra/Ordered/Bundles.agda b/src/Algebra/Ordered/Bundles.agda
deleted file mode 100644
index fd69b7145d..0000000000
--- a/src/Algebra/Ordered/Bundles.agda
+++ /dev/null
@@ -1,438 +0,0 @@
-------------------------------------------------------------------------
--- The Agda standard library
---
--- Definitions of ordered algebraic structures like promonoids and
--- posemigroups (packed in records together with sets, orders,
--- operations, etc.)
-------------------------------------------------------------------------
-
--- The contents of this module should be accessed via `Algebra.Order`.
-
-{-# OPTIONS --cubical-compatible --safe #-}
-
-module Algebra.Ordered.Bundles where
-
-open import Algebra.Core
-open import Algebra.Bundles
-open import Algebra.Ordered.Structures
-open import Level using (suc; _⊔_)
-open import Relation.Binary using (Rel)
-open import Relation.Binary.Bundles using (Preorder; Poset)
-
-------------------------------------------------------------------------
--- Bundles of preordered structures
-
--- Preordered magmas (promagmas)
-
-record Promagma c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _∙_
-  field
-    Carrier    : Set c
-    _≈_        : Rel Carrier ℓ₁  -- The underlying equality.
-    _≤_        : Rel Carrier ℓ₂  -- The preorder.
-    _∙_        : Op₂ Carrier     -- Multiplication.
-    isPromagma : IsPromagma _≈_ _≤_ _∙_
-
-  open IsPromagma isPromagma public
-
-  preorder : Preorder c ℓ₁ ℓ₂
-  preorder = record { isPreorder = isPreorder }
-
-  magma : Magma c ℓ₁
-  magma = record { isMagma = isMagma }
-
--- Preordered semigroups (prosemigroups)
-
-record Prosemigroup c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _∙_
-  field
-    Carrier        : Set c
-    _≈_            : Rel Carrier ℓ₁  -- The underlying equality.
-    _≤_            : Rel Carrier ℓ₂  -- The preorder.
-    _∙_            : Op₂ Carrier     -- Multiplication.
-    isProsemigroup : IsProsemigroup _≈_ _≤_ _∙_
-
-  open IsProsemigroup isProsemigroup public
-
-  promagma : Promagma c ℓ₁ ℓ₂
-  promagma = record { isPromagma = isPromagma }
-
-  open Promagma promagma public using (preorder; magma)
-
-  semigroup : Semigroup c ℓ₁
-  semigroup = record { isSemigroup = isSemigroup }
-
--- Preordered monoids (promonoids)
-
-record Promonoid c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _∙_
-  field
-    Carrier     : Set c
-    _≈_         : Rel Carrier ℓ₁  -- The underlying equality.
-    _≤_         : Rel Carrier ℓ₂  -- The preorder.
-    _∙_         : Op₂ Carrier     -- The monoid multiplication.
-    ε           : Carrier         -- The monoid unit.
-    isPromonoid : IsPromonoid _≈_ _≤_ _∙_ ε
-
-  open IsPromonoid isPromonoid public
-
-  prosemigroup : Prosemigroup c ℓ₁ ℓ₂
-  prosemigroup = record { isProsemigroup = isProsemigroup }
-
-  open Prosemigroup prosemigroup public
-    using (preorder; magma; promagma; semigroup)
-
-  monoid : Monoid c ℓ₁
-  monoid = record { isMonoid = isMonoid }
-
--- Preordered commutative monoids (commutative promonoids)
-
-record CommutativePromonoid c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _∙_
-  field
-    Carrier : Set c
-    _≈_     : Rel Carrier ℓ₁  -- The underlying equality.
-    _≤_     : Rel Carrier ℓ₂  -- The preorder.
-    _∙_     : Op₂ Carrier     -- The monoid multiplication.
-    ε       : Carrier         -- The monoid unit.
-    isCommutativePromonoid : IsCommutativePromonoid _≈_ _≤_ _∙_ ε
-
-  open IsCommutativePromonoid isCommutativePromonoid public
-
-  promonoid : Promonoid c ℓ₁ ℓ₂
-  promonoid = record { isPromonoid = isPromonoid }
-
-  open Promonoid promonoid public
-    using (preorder; magma; promagma; semigroup; prosemigroup; monoid)
-
-  commutativeMonoid : CommutativeMonoid c ℓ₁
-  commutativeMonoid = record { isCommutativeMonoid = isCommutativeMonoid }
-
-  open CommutativeMonoid commutativeMonoid public using (commutativeSemigroup)
-
--- Preordered semirings (prosemirings)
-
-record Prosemiring c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _*_
-  infixl 6 _+_
-  field
-    Carrier       : Set c
-    _≈_           : Rel Carrier ℓ₁
-    _≤_           : Rel Carrier ℓ₂
-    _+_           : Op₂ Carrier
-    _*_           : Op₂ Carrier
-    0#            : Carrier
-    1#            : Carrier
-    isProsemiring : IsProsemiring _≈_ _≤_ _+_ _*_ 0# 1#
-
-  open IsProsemiring isProsemiring public
-
-  +-commutativePromonoid : CommutativePromonoid c ℓ₁ ℓ₂
-  +-commutativePromonoid = record
-    { isCommutativePromonoid = +-isCommutativePromonoid }
-
-  open CommutativePromonoid +-commutativePromonoid public
-    using (preorder)
-    renaming
-    ( magma                to +-magma
-    ; promagma             to +-promagma
-    ; semigroup            to +-semigroup
-    ; prosemigroup         to +-prosemigroup
-    ; monoid               to +-monoid
-    ; promonoid            to +-promonoid
-    ; commutativeSemigroup to +-commutativeSemigroup
-    ; commutativeMonoid    to +-commutativeMonoid
-    )
-
-  *-promonoid : Promonoid c ℓ₁ ℓ₂
-  *-promonoid = record { isPromonoid = *-isPromonoid }
-
-  open Promonoid *-promonoid public
-    using ()
-    renaming
-    ( magma        to *-magma
-    ; promagma     to *-promagma
-    ; semigroup    to *-semigroup
-    ; prosemigroup to *-prosemigroup
-    ; monoid       to *-monoid
-    )
-
-  semiring : Semiring c ℓ₁
-  semiring = record { isSemiring = isSemiring }
-
--- Preordered IdempotentSemiring (IdempotentProsemiring)
-
-record IdempotentProsemiring c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _*_
-  infixl 6 _+_
-  field
-    Carrier       : Set c
-    _≈_           : Rel Carrier ℓ₁
-    _≤_           : Rel Carrier ℓ₂
-    _+_           : Op₂ Carrier
-    _*_           : Op₂ Carrier
-    0#            : Carrier
-    1#            : Carrier
-    isIdempotentProsemiring : IsIdempotentProsemiring _≈_ _≤_ _+_ _*_ 0# 1#
-
-  open IsIdempotentProsemiring isIdempotentProsemiring public
-
-  idempotentSemiring : IdempotentSemiring c ℓ₁
-  idempotentSemiring = record { isIdempotentSemiring = isIdempotentSemiring }
-
--- Preordered KleeneAlgebra (proKleeneAlgebra)
-
-record ProKleeneAlgebra c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infix  8 _⋆
-  infixl 7 _*_
-  infixl 6 _+_
-  field
-    Carrier       : Set c
-    _≈_           : Rel Carrier ℓ₁
-    _≤_           : Rel Carrier ℓ₂
-    _+_           : Op₂ Carrier
-    _*_           : Op₂ Carrier
-    _⋆            : Op₁ Carrier
-    0#            : Carrier
-    1#            : Carrier
-    isProKleeneAlgebra : IsProKleeneAlgebra _≈_ _≤_ _+_ _*_ _⋆ 0# 1#
-
-  open IsProKleeneAlgebra isProKleeneAlgebra public
-
-  kleeneAlgebra : KleeneAlgebra c ℓ₁
-  kleeneAlgebra = record { isKleeneAlgebra = isKleeneAlgebra }
-
-------------------------------------------------------------------------
--- Bundles of partially ordered structures
-
--- Partially ordered magmas (pomagmas)
-
-record Pomagma c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _∙_
-  field
-    Carrier   : Set c
-    _≈_       : Rel Carrier ℓ₁  -- The underlying equality.
-    _≤_       : Rel Carrier ℓ₂  -- The partial order.
-    _∙_       : Op₂ Carrier     -- Multiplication.
-    isPomagma : IsPomagma _≈_ _≤_ _∙_
-
-  open IsPomagma isPomagma public
-
-  poset : Poset c ℓ₁ ℓ₂
-  poset = record { isPartialOrder = isPartialOrder }
-
-  promagma : Promagma c ℓ₁ ℓ₂
-  promagma = record { isPromagma = isPromagma }
-
-  open Promagma promagma public using (preorder; magma)
-
--- Partially ordered semigroups (posemigroups)
-
-record Posemigroup c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _∙_
-  field
-    Carrier       : Set c
-    _≈_           : Rel Carrier ℓ₁  -- The underlying equality.
-    _≤_           : Rel Carrier ℓ₂  -- The partial order.
-    _∙_           : Op₂ Carrier     -- Multiplication.
-    isPosemigroup : IsPosemigroup _≈_ _≤_ _∙_
-
-  open IsPosemigroup isPosemigroup public
-
-  pomagma : Pomagma c ℓ₁ ℓ₂
-  pomagma = record { isPomagma = isPomagma }
-
-  open Pomagma pomagma public using (preorder; poset; magma; promagma)
-
-  prosemigroup : Prosemigroup c ℓ₁ ℓ₂
-  prosemigroup = record { isProsemigroup = isProsemigroup }
-
-  open Prosemigroup prosemigroup public using (semigroup)
-
--- Partially ordered monoids (pomonoids)
-
-record Pomonoid c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _∙_
-  field
-    Carrier    : Set c
-    _≈_        : Rel Carrier ℓ₁  -- The underlying equality.
-    _≤_        : Rel Carrier ℓ₂  -- The partial order.
-    _∙_        : Op₂ Carrier     -- The monoid multiplication.
-    ε          : Carrier         -- The monoid unit.
-    isPomonoid : IsPomonoid _≈_ _≤_ _∙_ ε
-
-  open IsPomonoid isPomonoid public
-
-  posemigroup : Posemigroup c ℓ₁ ℓ₂
-  posemigroup = record { isPosemigroup = isPosemigroup }
-
-  open Posemigroup posemigroup public using
-    ( preorder
-    ; poset
-    ; magma
-    ; promagma
-    ; pomagma
-    ; semigroup
-    ; prosemigroup
-    )
-
-  promonoid : Promonoid c ℓ₁ ℓ₂
-  promonoid = record { isPromonoid = isPromonoid }
-
-  open Promonoid promonoid public using (monoid)
-
--- Partially ordered commutative monoids (commutative pomonoids)
-
-record CommutativePomonoid c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _∙_
-  field
-    Carrier               : Set c
-    _≈_                   : Rel Carrier ℓ₁  -- The underlying equality.
-    _≤_                   : Rel Carrier ℓ₂  -- The partial order.
-    _∙_                   : Op₂ Carrier     -- The monoid multiplication.
-    ε                     : Carrier         -- The monoid unit.
-    isCommutativePomonoid : IsCommutativePomonoid _≈_ _≤_ _∙_ ε
-
-  open IsCommutativePomonoid isCommutativePomonoid public
-
-  pomonoid : Pomonoid c ℓ₁ ℓ₂
-  pomonoid = record { isPomonoid = isPomonoid }
-
-  open Pomonoid pomonoid public using
-    ( preorder
-    ; poset
-    ; magma
-    ; promagma
-    ; pomagma
-    ; semigroup
-    ; prosemigroup
-    ; posemigroup
-    ; monoid
-    ; promonoid
-    )
-
-  commutativePromonoid : CommutativePromonoid c ℓ₁ ℓ₂
-  commutativePromonoid =
-    record { isCommutativePromonoid = isCommutativePromonoid }
-
-  open CommutativePromonoid commutativePromonoid public
-    using (commutativeSemigroup; commutativeMonoid)
-
--- Partially ordered semirings (posemirings)
-
-record Posemiring c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _*_
-  infixl 6 _+_
-  field
-    Carrier      : Set c
-    _≈_          : Rel Carrier ℓ₁
-    _≤_          : Rel Carrier ℓ₂
-    _+_          : Op₂ Carrier
-    _*_          : Op₂ Carrier
-    0#           : Carrier
-    1#           : Carrier
-    isPosemiring : IsPosemiring _≈_ _≤_ _+_ _*_ 0# 1#
-
-  open IsPosemiring isPosemiring public
-
-  +-commutativePomonoid : CommutativePomonoid c ℓ₁ ℓ₂
-  +-commutativePomonoid = record
-    { isCommutativePomonoid = +-isCommutativePomonoid }
-
-  open CommutativePomonoid +-commutativePomonoid public
-    using (preorder)
-    renaming
-    ( magma                to +-magma
-    ; promagma             to +-promagma
-    ; pomagma              to +-pomagma
-    ; semigroup            to +-semigroup
-    ; prosemigroup         to +-prosemigroup
-    ; posemigroup          to +-posemigroup
-    ; monoid               to +-monoid
-    ; promonoid            to +-promonoid
-    ; pomonoid             to +-pomonoid
-    ; commutativeSemigroup to +-commutativeSemigroup
-    ; commutativeMonoid    to +-commutativeMonoid
-    ; commutativePromonoid to +-commutativePromonoid
-    )
-
-  *-pomonoid : Pomonoid c ℓ₁ ℓ₂
-  *-pomonoid = record { isPomonoid = *-isPomonoid }
-
-  open Pomonoid *-pomonoid public
-    using ()
-    renaming
-    ( magma        to *-magma
-    ; promagma     to *-promagma
-    ; pomagma      to *-pomagma
-    ; semigroup    to *-semigroup
-    ; prosemigroup to *-prosemigroup
-    ; posemigroup  to *-posemigroup
-    ; monoid       to *-monoid
-    ; promonoid    to *-promonoid
-    )
-
-  prosemiring : Prosemiring c ℓ₁ ℓ₂
-  prosemiring = record { isProsemiring = isProsemiring }
-
-  open Prosemiring prosemiring public using (semiring)
-
--- Partially ordered idempotentSemiring (IdempotentPosemiring)
-
-record IdempotentPosemiring c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infixl 7 _*_
-  infixl 6 _+_
-  field
-    Carrier       : Set c
-    _≈_           : Rel Carrier ℓ₁
-    _≤_           : Rel Carrier ℓ₂
-    _+_           : Op₂ Carrier
-    _*_           : Op₂ Carrier
-    0#            : Carrier
-    1#            : Carrier
-    isIdempotentPosemiring : IsIdempotentPosemiring _≈_ _≤_ _+_ _*_ 0# 1#
-
-  open IsIdempotentPosemiring isIdempotentPosemiring public
-
-  idempotentProsemiring : IdempotentProsemiring c ℓ₁ ℓ₂
-  idempotentProsemiring = record { isIdempotentProsemiring = isIdempotentProsemiring }
-
-  open IdempotentProsemiring idempotentProsemiring public using (idempotentSemiring; +-idem)
-
--- Partially ordered KleeneAlgebra (PoKleeneAlgebra)
-
-record PoKleeneAlgebra c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix  4 _≈_ _≤_
-  infix  8 _⋆
-  infixl 7 _*_
-  infixl 6 _+_
-  field
-    Carrier       : Set c
-    _≈_           : Rel Carrier ℓ₁
-    _≤_           : Rel Carrier ℓ₂
-    _+_           : Op₂ Carrier
-    _*_           : Op₂ Carrier
-    _⋆            : Op₁ Carrier
-    0#            : Carrier
-    1#            : Carrier
-    isPoKleeneAlgebra : IsPoKleeneAlgebra _≈_ _≤_ _+_ _*_ _⋆ 0# 1#
-
-  open IsPoKleeneAlgebra isPoKleeneAlgebra public
-
-  proKleeneAlgebra : ProKleeneAlgebra c ℓ₁ ℓ₂
-  proKleeneAlgebra = record { isProKleeneAlgebra = isProKleeneAlgebra }
-
-  open ProKleeneAlgebra proKleeneAlgebra public using (starExpansive; starDestructive)
diff --git a/src/Algebra/Ordered/Structures.agda b/src/Algebra/Ordered/Structures.agda
deleted file mode 100644
index 1c46f007f7..0000000000
--- a/src/Algebra/Ordered/Structures.agda
+++ /dev/null
@@ -1,391 +0,0 @@
-------------------------------------------------------------------------
--- The Agda standard library
---
--- Ordered algebraic structures (not packed up with sets, orders,
--- operations, etc.)
-------------------------------------------------------------------------
-
--- The contents of this module should be accessed via
--- `Algebra.Ordered`.
-
-{-# OPTIONS --cubical-compatible --safe #-}
-
-open import Relation.Binary.Core using (Rel; _⇒_)
-
-module Algebra.Ordered.Structures
-  {a ℓ₁ ℓ₂} {A : Set a}  -- The underlying set
-  (_≈_ : Rel A ℓ₁)       -- The underlying equality relation
-  (_≤_ : Rel A ℓ₂)       -- The order
-  where
-
-open import Algebra.Core
-open import Algebra.Definitions _≈_
-open import Algebra.Structures _≈_
-open import Data.Product using (proj₁; proj₂)
-open import Function using (flip)
-open import Level using (_⊔_)
-open import Relation.Binary.Definitions using (Transitive; Monotonic₁; Monotonic₂)
-open import Relation.Binary.Structures using (IsPreorder; IsPartialOrder)
-open import Relation.Binary.Consequences using (mono₂⇒cong₂)
-
-------------------------------------------------------------------------
--- Preordered structures
-
--- Preordered magmas (promagmas)
-
-record IsPromagma (∙ : Op₂ A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isPreorder  : IsPreorder _≈_ _≤_
-    ∙-cong      : Congruent₂ ∙
-    mono        : Monotonic₂ _≤_ _≤_ _≤_ ∙
-
-  open IsPreorder isPreorder public
-
-  mono₁ : ∀ {x} → Monotonic₁ _≤_ _≤_ (flip ∙ x)
-  mono₁ y≈z = mono y≈z refl
-
-  mono₂ : ∀ {x} → Monotonic₁ _≤_ _≤_ (∙ x)
-  mono₂ y≈z = mono refl y≈z
-
-  isMagma : IsMagma ∙
-  isMagma = record { isEquivalence = isEquivalence ; ∙-cong = ∙-cong }
-
-  open IsMagma isMagma public using (setoid; ∙-congˡ; ∙-congʳ)
-
--- Preordered semigroups (prosemigroups)
-
-record IsProsemigroup (∙ : Op₂ A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isPromagma  : IsPromagma ∙
-    assoc       : Associative ∙
-
-  open IsPromagma isPromagma public
-
-  isSemigroup : IsSemigroup ∙
-  isSemigroup = record { isMagma = isMagma ; assoc = assoc }
-
--- Preordered monoids (promonoids)
-
-record IsPromonoid (∙ : Op₂ A) (ε : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isProsemigroup : IsProsemigroup ∙
-    identity       : Identity ε ∙
-
-  open IsProsemigroup isProsemigroup public
-
-  isMonoid : IsMonoid ∙ ε
-  isMonoid = record { isSemigroup = isSemigroup ; identity = identity }
-
-  open IsMonoid isMonoid public using (identityˡ; identityʳ)
-
--- Preordered commutative monoids (commutative promonoids)
-
-record IsCommutativePromonoid (∙ : Op₂ A) (ε : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isPromonoid : IsPromonoid ∙ ε
-    comm        : Commutative ∙
-
-  open IsPromonoid isPromonoid public
-
-  isCommutativeMonoid : IsCommutativeMonoid ∙ ε
-  isCommutativeMonoid = record { isMonoid = isMonoid ; comm = comm }
-
-  open IsCommutativeMonoid isCommutativeMonoid public
-    using (isCommutativeSemigroup)
-
--- Preordered semirings (prosemirings)
-
-record IsProsemiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    +-isCommutativePromonoid : IsCommutativePromonoid + 0#
-    *-cong                   : Congruent₂ *
-    *-mono                   : Monotonic₂ _≤_ _≤_ _≤_ *
-    *-assoc                  : Associative *
-    *-identity               : Identity 1# *
-    distrib                  : * DistributesOver +
-    zero                     : Zero 0# *
-
-  open IsCommutativePromonoid +-isCommutativePromonoid public
-    renaming
-    ( assoc                  to +-assoc
-    ; ∙-cong                 to +-cong
-    ; ∙-congˡ                to +-congˡ
-    ; ∙-congʳ                to +-congʳ
-    ; mono                   to +-mono
-    ; mono₁                  to +-mono₁
-    ; mono₂                  to +-mono₂
-    ; identity               to +-identity
-    ; identityˡ              to +-identityˡ
-    ; identityʳ              to +-identityʳ
-    ; comm                   to +-comm
-    ; isMagma                to +-isMagma
-    ; isSemigroup            to +-isSemigroup
-    ; isMonoid               to +-isMonoid
-    ; isCommutativeSemigroup to +-isCommutativeSemigroup
-    ; isCommutativeMonoid    to +-isCommutativeMonoid
-    )
-
-  *-isPromonoid : IsPromonoid * 1#
-  *-isPromonoid = record
-    { isProsemigroup = record
-      { isPromagma   = record
-        { isPreorder = isPreorder
-        ; ∙-cong     = *-cong
-        ; mono       = *-mono
-        }
-      ; assoc        = *-assoc
-      }
-    ; identity       = *-identity
-    }
-
-  open IsPromonoid *-isPromonoid public
-    using ()
-    renaming
-    ( ∙-congˡ     to *-congˡ
-    ; ∙-congʳ     to *-congʳ
-    ; mono₁       to *-mono₁
-    ; mono₂       to *-mono₂
-    ; identityˡ   to *-identityˡ
-    ; identityʳ   to *-identityʳ
-    ; isMagma     to *-isMagma
-    ; isSemigroup to *-isSemigroup
-    ; isMonoid    to *-isMonoid
-    )
-
-  isSemiring : IsSemiring + * 0# 1#
-  isSemiring = record
-    { isSemiringWithoutAnnihilatingZero = record
-      { +-isCommutativeMonoid           = +-isCommutativeMonoid
-      ; *-cong                          = *-cong
-      ; *-assoc                         = *-assoc
-      ; *-identity                      = *-identity
-      ; distrib                         = distrib
-      }
-    ; zero                              = zero
-    }
-
-  open IsSemiring isSemiring public using (distribˡ; distribʳ; zeroˡ; zeroʳ)
-
--- Preordered IdempotentSemiring (IdempotentProsemiring)
-
-record IsIdempotentProsemiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isProsemiring  : IsProsemiring + * 0# 1#
-    +-idem         : Idempotent +
-
-  open IsProsemiring isProsemiring public
-
-  isIdempotentSemiring : IsIdempotentSemiring + * 0# 1#
-  isIdempotentSemiring = record { isSemiring = isSemiring ; +-idem = +-idem }
-
-  open IsIdempotentSemiring isIdempotentSemiring public using (+-idem)
-
--- Preordered KleeneAlgebra (proKleeneAlgebra)
-
-record IsProKleeneAlgebra (+ * : Op₂ A) (⋆ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isIdempotentProsemiring : IsIdempotentProsemiring + * 0# 1#
-    starExpansive           : StarExpansive 1# + * ⋆
-    starDestructive         : StarDestructive + * ⋆
-
-  open IsIdempotentProsemiring isIdempotentProsemiring public
-
-  isKleeneAlgebra : IsKleeneAlgebra + * ⋆ 0# 1#
-  isKleeneAlgebra = record
-    { isIdempotentSemiring = isIdempotentSemiring
-    ; starExpansive        = starExpansive
-    ; starDestructive      = starDestructive
-    }
-
-  open IsKleeneAlgebra isKleeneAlgebra public using (starExpansive; starDestructive)
-
-------------------------------------------------------------------------
--- Partially ordered structures
-
--- Partially ordered magmas (pomagmas)
-
-record IsPomagma (∙ : Op₂ A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isPartialOrder : IsPartialOrder _≈_ _≤_
-    mono           : Monotonic₂ _≤_ _≤_ _≤_ ∙
-
-  open IsPartialOrder isPartialOrder public
-
-  ∙-cong : Congruent₂ ∙
-  ∙-cong = mono₂⇒cong₂ _≈_ _≈_ Eq.sym reflexive antisym mono
-
-  isPromagma : IsPromagma ∙
-  isPromagma = record
-    { isPreorder = isPreorder
-    ; ∙-cong     = ∙-cong
-    ; mono       = mono
-    }
-
-  open IsPromagma isPromagma public
-    using (setoid; ∙-congˡ; ∙-congʳ; mono₁; mono₂; isMagma)
-
--- Partially ordered semigroups (posemigroups)
-
-record IsPosemigroup (∙ : Op₂ A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isPomagma : IsPomagma ∙
-    assoc     : Associative ∙
-
-  open IsPomagma isPomagma public
-
-  isProsemigroup : IsProsemigroup ∙
-  isProsemigroup = record { isPromagma = isPromagma ; assoc = assoc }
-
-  open IsProsemigroup isProsemigroup public using (isSemigroup)
-
--- Partially ordered monoids (pomonoids)
-
-record IsPomonoid (∙ : Op₂ A) (ε : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isPosemigroup : IsPosemigroup ∙
-    identity      : Identity ε ∙
-
-  open IsPosemigroup isPosemigroup public
-
-  isPromonoid : IsPromonoid ∙ ε
-  isPromonoid = record
-    { isProsemigroup = isProsemigroup
-    ; identity       = identity
-    }
-
-  open IsPromonoid isPromonoid public
-    using (isMonoid; identityˡ; identityʳ)
-
--- Partially ordered commutative monoids (commutative pomonoids)
-
-record IsCommutativePomonoid (∙ : Op₂ A) (ε : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isPomonoid : IsPomonoid ∙ ε
-    comm       : Commutative ∙
-
-  open IsPomonoid isPomonoid public
-
-  isCommutativePromonoid : IsCommutativePromonoid ∙ ε
-  isCommutativePromonoid = record { isPromonoid = isPromonoid ; comm = comm }
-
-  open IsCommutativePromonoid isCommutativePromonoid public
-    using (isCommutativeMonoid; isCommutativeSemigroup)
-
--- Partially ordered semirings (posemirings)
-
-record IsPosemiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    +-isCommutativePomonoid : IsCommutativePomonoid + 0#
-    *-mono                  : Monotonic₂ _≤_ _≤_ _≤_ *
-    *-assoc                 : Associative *
-    *-identity              : Identity 1# *
-    distrib                 : * DistributesOver +
-    zero                    : Zero 0# *
-
-  open IsCommutativePomonoid +-isCommutativePomonoid public
-    renaming
-    ( assoc                  to +-assoc
-    ; ∙-cong                 to +-cong
-    ; ∙-congˡ                to +-congˡ
-    ; ∙-congʳ                to +-congʳ
-    ; mono                   to +-mono
-    ; mono₁                  to +-mono₁
-    ; mono₂                  to +-mono₂
-    ; identity               to +-identity
-    ; identityˡ              to +-identityˡ
-    ; identityʳ              to +-identityʳ
-    ; comm                   to +-comm
-    ; isMagma                to +-isMagma
-    ; isPromagma             to +-isPromagma
-    ; isPomagma              to +-isPomagma
-    ; isSemigroup            to +-isSemigroup
-    ; isProsemigroup         to +-isProsemigroup
-    ; isPosemigroup          to +-isPosemigroup
-    ; isMonoid               to +-isMonoid
-    ; isPromonoid            to +-isPromonoid
-    ; isPomonoid             to +-isPomonoid
-    ; isCommutativeSemigroup to +-isCommutativeSemigroup
-    ; isCommutativeMonoid    to +-isCommutativeMonoid
-    ; isCommutativePromonoid to +-isCommutativePromonoid
-    )
-
-  *-isPomonoid : IsPomonoid * 1#
-  *-isPomonoid = record
-    { isPosemigroup      = record
-      { isPomagma        = record
-        { isPartialOrder = isPartialOrder
-        ; mono           = *-mono
-        }
-      ; assoc            = *-assoc
-      }
-    ; identity           = *-identity
-    }
-
-  open IsPomonoid *-isPomonoid public
-    using ()
-    renaming
-    ( ∙-cong         to *-cong
-    ; ∙-congˡ        to *-congˡ
-    ; ∙-congʳ        to *-congʳ
-    ; mono₁          to *-mono₁
-    ; mono₂          to *-mono₂
-    ; identityˡ      to *-identityˡ
-    ; identityʳ      to *-identityʳ
-    ; isMagma        to *-isMagma
-    ; isPromagma     to *-isPromagma
-    ; isPomagma      to *-isPomagma
-    ; isSemigroup    to *-isSemigroup
-    ; isProsemigroup to *-isProsemigroup
-    ; isPosemigroup  to *-isPosemigroup
-    ; isMonoid       to *-isMonoid
-    ; isPromonoid    to *-isPromonoid
-    )
-
-  isProsemiring : IsProsemiring + * 0# 1#
-  isProsemiring = record
-    { +-isCommutativePromonoid = +-isCommutativePromonoid
-    ; *-cong                   = *-cong
-    ; *-mono                   = *-mono
-    ; *-assoc                  = *-assoc
-    ; *-identity               = *-identity
-    ; distrib                  = distrib
-    ; zero                     = zero
-    }
-
-  open IsProsemiring isProsemiring public
-    using (isSemiring; distribˡ; distribʳ; zeroˡ; zeroʳ)
-
--- Partially ordered idempotentSemiring (IdempotentPosemiring)
-
-record IsIdempotentPosemiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isPosemiring  : IsPosemiring + * 0# 1#
-    +-idem      : Idempotent +
-
-  open IsPosemiring isPosemiring public
-
-  isIdempotentProsemiring : IsIdempotentProsemiring + * 0# 1#
-  isIdempotentProsemiring = record { isProsemiring = isProsemiring ; +-idem = +-idem }
-
-  open IsIdempotentProsemiring isIdempotentProsemiring public
-    using (isIdempotentSemiring; +-idem)
-
--- Partially ordered KleeneAlgebra (PoKleeneAlgebra)
-
-record IsPoKleeneAlgebra (+ * : Op₂ A) (⋆ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  field
-    isIdempotentPosemiring  : IsIdempotentPosemiring + * 0# 1#
-    starExpansive           : StarExpansive 1# + * ⋆
-    starDestructive         : StarDestructive + * ⋆
-
-  open IsIdempotentPosemiring isIdempotentPosemiring public
-
-  isProKleeneAlgebra : IsProKleeneAlgebra + * ⋆ 0# 1#
-  isProKleeneAlgebra = record
-    { isIdempotentProsemiring = isIdempotentProsemiring
-    ; starExpansive           = starExpansive
-    ; starDestructive         = starDestructive
-    }
-
-  open IsProKleeneAlgebra isProKleeneAlgebra public
-    using (isKleeneAlgebra; starExpansive; starDestructive)
diff --git a/src/Algebra/Properties/AbelianGroup.agda b/src/Algebra/Properties/AbelianGroup.agda
index a1c2056ccb..b5eb290081 100644
--- a/src/Algebra/Properties/AbelianGroup.agda
+++ b/src/Algebra/Properties/AbelianGroup.agda
@@ -12,7 +12,7 @@ module Algebra.Properties.AbelianGroup
   {a ℓ} (G : AbelianGroup a ℓ) where
 
 open AbelianGroup G
-open import Function
+open import Function.Base using (_$_)
 open import Relation.Binary.Reasoning.Setoid setoid
 
 ------------------------------------------------------------------------
@@ -23,6 +23,9 @@ open import Algebra.Properties.Group group public
 ------------------------------------------------------------------------
 -- Properties of abelian groups
 
+⁻¹-anti-homo‿- : ∀ x y → (x - y) ⁻¹ ≈ y - x
+⁻¹-anti-homo‿- = ⁻¹-anti-homo-//
+
 xyx⁻¹≈y : ∀ x y → x ∙ y ∙ x ⁻¹ ≈ y
 xyx⁻¹≈y x y = begin
   x ∙ y ∙ x ⁻¹    ≈⟨ ∙-congʳ $ comm _ _ ⟩
@@ -33,6 +36,6 @@ xyx⁻¹≈y x y = begin
 
 ⁻¹-∙-comm : ∀ x y → x ⁻¹ ∙ y ⁻¹ ≈ (x ∙ y) ⁻¹
 ⁻¹-∙-comm x y = begin
-  x ⁻¹ ∙ y ⁻¹ ≈˘⟨ ⁻¹-anti-homo-∙ y x ⟩
+  x ⁻¹ ∙ y ⁻¹ ≈⟨ ⁻¹-anti-homo-∙ y x ⟨
   (y ∙ x) ⁻¹  ≈⟨ ⁻¹-cong $ comm y x ⟩
   (x ∙ y) ⁻¹  ∎
diff --git a/src/Algebra/Properties/BooleanAlgebra.agda b/src/Algebra/Properties/BooleanAlgebra.agda
index f53815b934..0445f20505 100644
--- a/src/Algebra/Properties/BooleanAlgebra.agda
+++ b/src/Algebra/Properties/BooleanAlgebra.agda
@@ -28,9 +28,8 @@ import Algebra.Properties.DistributiveLattice as DistribLatticeProperties
 
 open import Algebra.Structures _≈_
 open import Relation.Binary
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Equivalence using (_⇔_; module Equivalence)
-open import Data.Product using (_,_)
+open import Function.Bundles using (module Equivalence; _⇔_)
+open import Data.Product.Base using (_,_)
 
 ------------------------------------------------------------------------
 -- DEPRECATED NAMES
@@ -47,9 +46,9 @@ replace-equality {_≈′_} ≈⇔≈′ = record
   { isBooleanAlgebra = record
     { isDistributiveLattice = DistributiveLattice.isDistributiveLattice
         (DistribLatticeProperties.replace-equality distributiveLattice ≈⇔≈′)
-    ; ∨-complement          = ((λ x → to ⟨$⟩ ∨-complementˡ x) , λ x → to ⟨$⟩ ∨-complementʳ x)
-    ; ∧-complement          = ((λ x → to ⟨$⟩ ∧-complementˡ x) , λ x → to ⟨$⟩ ∧-complementʳ x)
-    ; ¬-cong                = λ i≈j → to ⟨$⟩ ¬-cong (from ⟨$⟩ i≈j)
+    ; ∨-complement          = ((λ x → to (∨-complementˡ x)) , λ x → to (∨-complementʳ x))
+    ; ∧-complement          = ((λ x → to (∧-complementˡ x)) , λ x → to (∧-complementʳ x))
+    ; ¬-cong                = λ i≈j → to (¬-cong (from i≈j))
     }
   } where open module E {x y} = Equivalence (≈⇔≈′ {x} {y})
 {-# WARNING_ON_USAGE replace-equality
diff --git a/src/Algebra/Properties/CancellativeCommutativeSemiring.agda b/src/Algebra/Properties/CancellativeCommutativeSemiring.agda
index f07f898eb2..e92fa5170e 100644
--- a/src/Algebra/Properties/CancellativeCommutativeSemiring.agda
+++ b/src/Algebra/Properties/CancellativeCommutativeSemiring.agda
@@ -9,7 +9,7 @@
 open import Algebra using (CancellativeCommutativeSemiring)
 open import Algebra.Definitions using (AlmostRightCancellative)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
-open import Relation.Binary using (Decidable)
+open import Relation.Binary.Definitions using (Decidable)
 open import Relation.Nullary.Decidable using (yes; no)
 open import Relation.Nullary.Negation using (contradiction)
 
diff --git a/src/Algebra/Properties/CommutativeMagma/Divisibility.agda b/src/Algebra/Properties/CommutativeMagma/Divisibility.agda
index 14ad404a37..3f6cae0f0c 100644
--- a/src/Algebra/Properties/CommutativeMagma/Divisibility.agda
+++ b/src/Algebra/Properties/CommutativeMagma/Divisibility.agda
@@ -7,7 +7,7 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra using (CommutativeMagma)
-open import Data.Product using (_×_; _,_; map)
+open import Data.Product.Base using (_×_; _,_; map)
 
 module Algebra.Properties.CommutativeMagma.Divisibility
   {a ℓ} (CM : CommutativeMagma a ℓ)
@@ -17,12 +17,12 @@ open CommutativeMagma CM
 
 open import Relation.Binary.Reasoning.Setoid setoid
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Re-export the contents of magmas
 
 open import Algebra.Properties.Magma.Divisibility magma public
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Further properties
 
 x∣xy : ∀ x y → x ∣ x ∙ y
diff --git a/src/Algebra/Properties/CommutativeMonoid.agda b/src/Algebra/Properties/CommutativeMonoid.agda
index 091e88ec61..cef85545a1 100644
--- a/src/Algebra/Properties/CommutativeMonoid.agda
+++ b/src/Algebra/Properties/CommutativeMonoid.agda
@@ -6,7 +6,9 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Algebra.Bundles
+open import Algebra.Bundles using (CommutativeMonoid)
+open import Algebra.Definitions using (LeftInvertible; RightInvertible; Invertible)
+open import Data.Product.Base using (_,_; proj₂)
 
 module Algebra.Properties.CommutativeMonoid
   {g₁ g₂} (M : CommutativeMonoid g₁ g₂) where
@@ -23,3 +25,18 @@ open CommutativeMonoid M
   ; assoc     to +-assoc
   ; comm      to +-comm
   )
+
+private variable
+  x : Carrier
+
+invertibleˡ⇒invertibleʳ : LeftInvertible _≈_ 0# _+_ x → RightInvertible _≈_ 0# _+_ x
+invertibleˡ⇒invertibleʳ {x} (-x , -x+x≈1) = -x , trans (+-comm x -x) -x+x≈1
+
+invertibleʳ⇒invertibleˡ : RightInvertible _≈_ 0# _+_ x → LeftInvertible _≈_ 0# _+_ x
+invertibleʳ⇒invertibleˡ {x} (-x , x+-x≈1) = -x , trans (+-comm -x x) x+-x≈1
+
+invertibleˡ⇒invertible : LeftInvertible _≈_ 0# _+_ x → Invertible _≈_ 0# _+_ x
+invertibleˡ⇒invertible left@(-x , -x+x≈1) = -x , -x+x≈1 , invertibleˡ⇒invertibleʳ left .proj₂
+
+invertibleʳ⇒invertible : RightInvertible _≈_ 0# _+_ x → Invertible _≈_ 0# _+_ x
+invertibleʳ⇒invertible right@(-x , x+-x≈1) = -x , invertibleʳ⇒invertibleˡ right .proj₂ , x+-x≈1
diff --git a/src/Algebra/Properties/CommutativeMonoid/Mult/TCOptimised.agda b/src/Algebra/Properties/CommutativeMonoid/Mult/TCOptimised.agda
index b61a3e987e..0774e5d7a1 100644
--- a/src/Algebra/Properties/CommutativeMonoid/Mult/TCOptimised.agda
+++ b/src/Algebra/Properties/CommutativeMonoid/Mult/TCOptimised.agda
@@ -10,7 +10,6 @@
 open import Algebra.Bundles using (CommutativeMonoid)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
 open import Relation.Binary.Core using (_Preserves_⟶_; _Preserves₂_⟶_⟶_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
 
 module Algebra.Properties.CommutativeMonoid.Mult.TCOptimised
   {a ℓ} (M : CommutativeMonoid a ℓ) where
@@ -41,7 +40,7 @@ open import Algebra.Properties.Monoid.Mult.TCOptimised monoid public
 
 ×-distrib-+ : ∀ x y n → n × (x + y) ≈ n × x + n × y
 ×-distrib-+ x y n = begin
-  n ×  (x + y)    ≈˘⟨ ×ᵤ≈× n (x + y) ⟩
+  n ×  (x + y)    ≈⟨ ×ᵤ≈× n (x + y) ⟨
   n ×ᵤ (x + y)    ≈⟨  U.×-distrib-+ x y n ⟩
   n ×ᵤ x + n ×ᵤ y ≈⟨  +-cong (×ᵤ≈× n x) (×ᵤ≈× n y) ⟩
   n ×  x + n ×  y ∎
diff --git a/src/Algebra/Properties/CommutativeMonoid/Sum.agda b/src/Algebra/Properties/CommutativeMonoid/Sum.agda
index f70b965130..351363c0d6 100644
--- a/src/Algebra/Properties/CommutativeMonoid/Sum.agda
+++ b/src/Algebra/Properties/CommutativeMonoid/Sum.agda
@@ -14,7 +14,7 @@ open import Data.Fin.Permutation as Perm using (Permutation; _⟨$⟩ˡ_; _⟨$
 open import Data.Fin.Patterns using (0F)
 open import Data.Vec.Functional
 open import Function.Base using (_∘_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Nullary.Negation using (contradiction)
 
 module Algebra.Properties.CommutativeMonoid.Sum
@@ -46,7 +46,7 @@ open import Algebra.Properties.Monoid.Sum monoid public
 
 -- When summing over a function from a finite set, we can pull out any
 -- value and move it to the front.
-sum-remove : ∀ {n} {i : Fin (suc n)} t → sum t ≈ t i + sum (remove i t)
+sum-remove : ∀ {n} {i : Fin (suc n)} t → sum t ≈ t i + sum (removeAt t i)
 sum-remove {_}     {zero}   xs = refl
 sum-remove {suc n} {suc i}  xs = begin
   t₀ + ∑t           ≈⟨ +-congˡ (sum-remove t) ⟩
@@ -57,7 +57,7 @@ sum-remove {suc n} {suc i}  xs = begin
   t₀ = head xs
   tᵢ = t i
   ∑t = sum t
-  ∑t′ = sum (remove i t)
+  ∑t′ = sum (removeAt t i)
 
 -- The '∑' operator distributes over addition.
 ∑-distrib-+ : ∀ {n} (f g : Vector Carrier n) → ∑[ i < n ] (f i + g i) ≈ ∑[ i < n ] f i + ∑[ i < n ] g i
@@ -90,13 +90,13 @@ sum-permute {zero}  {suc n} f π = contradiction π (Perm.refute λ())
 sum-permute {suc m} {zero}  f π = contradiction π (Perm.refute λ())
 sum-permute {suc m} {suc n} f π = begin
   sum f                                    ≡⟨⟩
-  f 0F  + sum f/0                          ≡˘⟨ P.cong (_+ sum f/0) (P.cong f (Perm.inverseʳ π)) ⟩
+  f 0F  + sum f/0                          ≡⟨ ≡.cong (_+ sum f/0) (≡.cong f (Perm.inverseʳ π)) ⟨
   πf π₀ + sum f/0                          ≈⟨ +-congˡ (sum-permute f/0 (Perm.remove π₀ π)) ⟩
-  πf π₀ + sum (rearrange (π/0 ⟨$⟩ʳ_) f/0)  ≡˘⟨ P.cong (πf π₀ +_) (sum-cong-≗ (P.cong f ∘ Perm.punchIn-permute′ π 0F)) ⟩
-  πf π₀ + sum (remove π₀ πf)               ≈⟨ sym (sum-remove πf) ⟩
+  πf π₀ + sum (rearrange (π/0 ⟨$⟩ʳ_) f/0)  ≡⟨ ≡.cong (πf π₀ +_) (sum-cong-≗ (≡.cong f ∘ Perm.punchIn-permute′ π 0F)) ⟨
+  πf π₀ + sum (removeAt πf π₀)             ≈⟨ sym (sum-remove πf) ⟩
   sum πf                                   ∎
   where
-  f/0 = remove 0F f
+  f/0 = removeAt f 0F
   π₀ = π ⟨$⟩ˡ 0F
   π/0 = Perm.remove π₀ π
   πf = rearrange (π ⟨$⟩ʳ_) f
diff --git a/src/Algebra/Properties/CommutativeSemigroup.agda b/src/Algebra/Properties/CommutativeSemigroup.agda
index 25d1ac0152..bcfee1fec2 100644
--- a/src/Algebra/Properties/CommutativeSemigroup.agda
+++ b/src/Algebra/Properties/CommutativeSemigroup.agda
@@ -16,31 +16,31 @@ open CommutativeSemigroup CS
 
 open import Algebra.Definitions _≈_
 open import Relation.Binary.Reasoning.Setoid setoid
-open import Data.Product
+open import Data.Product.Base using (_,_)
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Re-export the contents of semigroup
 
 open import Algebra.Properties.Semigroup semigroup public
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties
 
 interchange : Interchangable _∙_ _∙_
 interchange a b c d = begin
   (a ∙ b) ∙ (c ∙ d)  ≈⟨  assoc a b (c ∙ d) ⟩
-  a ∙ (b ∙ (c ∙ d))  ≈˘⟨ ∙-congˡ (assoc b c d) ⟩
+  a ∙ (b ∙ (c ∙ d))  ≈⟨ ∙-congˡ (assoc b c d) ⟨
   a ∙ ((b ∙ c) ∙ d)  ≈⟨  ∙-congˡ (∙-congʳ (comm b c)) ⟩
   a ∙ ((c ∙ b) ∙ d)  ≈⟨  ∙-congˡ (assoc c b d) ⟩
-  a ∙ (c ∙ (b ∙ d))  ≈˘⟨ assoc a c (b ∙ d) ⟩
+  a ∙ (c ∙ (b ∙ d))  ≈⟨ assoc a c (b ∙ d) ⟨
   (a ∙ c) ∙ (b ∙ d)  ∎
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Permutation laws for _∙_ for three factors.
 
 -- There are five nontrivial permutations.
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Partitions (1,1).
 
 x∙yz≈y∙xz :  ∀ x y z → x ∙ (y ∙ z) ≈ y ∙ (x ∙ z)
@@ -72,7 +72,7 @@ x∙yz≈z∙xy x y z = begin
   (x ∙ y) ∙ z   ≈⟨ comm _ z ⟩
   z ∙ (x ∙ y)   ∎
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Partitions (1,2).
 
 -- These permutation laws are proved by composing the proofs for
@@ -93,7 +93,7 @@ x∙yz≈yz∙x x y z =  trans (x∙yz≈y∙zx _ _ _) (sym (assoc y z x))
 x∙yz≈zx∙y :  ∀ x y z → x ∙ (y ∙ z) ≈ (z ∙ x) ∙ y
 x∙yz≈zx∙y x y z =  trans (x∙yz≈z∙xy x y z) (sym (assoc z x y))
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Partitions (2,1).
 
 -- Their laws are proved by composing proofs for partitions (1,1) with
@@ -114,7 +114,7 @@ xy∙z≈y∙zx x y z =  trans (assoc x y z) (x∙yz≈y∙zx x y z)
 xy∙z≈z∙xy :  ∀ x y z → (x ∙ y) ∙ z ≈ z ∙ (x ∙ y)
 xy∙z≈z∙xy x y z =  trans (assoc x y z) (x∙yz≈z∙xy x y z)
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Partitions (2,2).
 
 -- These proofs are by composing with the proofs for (2,1).
@@ -134,13 +134,13 @@ xy∙z≈yz∙x x y z =  trans (xy∙z≈y∙zx x y z) (sym (assoc y z x))
 xy∙z≈zx∙y :  ∀ x y z → (x ∙ y) ∙ z ≈ (z ∙ x) ∙ y
 xy∙z≈zx∙y x y z =  trans (xy∙z≈z∙xy x y z) (sym (assoc z x y))
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- commutative semigroup has Jordan identity
 
 xy∙xx≈x∙yxx : ∀ x y → (x ∙ y) ∙ (x ∙ x) ≈ x ∙ (y ∙ (x ∙ x))
 xy∙xx≈x∙yxx x y = assoc x y ((x ∙ x))
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- commutative semigroup is left/right/middle semiMedial
 
 semimedialˡ : LeftSemimedial _∙_
diff --git a/src/Algebra/Properties/CommutativeSemigroup/Divisibility.agda b/src/Algebra/Properties/CommutativeSemigroup/Divisibility.agda
index c17510e530..782b094fbe 100644
--- a/src/Algebra/Properties/CommutativeSemigroup/Divisibility.agda
+++ b/src/Algebra/Properties/CommutativeSemigroup/Divisibility.agda
@@ -7,8 +7,8 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra using (CommutativeSemigroup)
-open import Data.Product using (_,_)
-import Relation.Binary.Reasoning.Setoid as EqReasoning
+open import Data.Product.Base using (_,_)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 module Algebra.Properties.CommutativeSemigroup.Divisibility
   {a ℓ} (CS : CommutativeSemigroup a ℓ)
@@ -16,20 +16,20 @@ module Algebra.Properties.CommutativeSemigroup.Divisibility
 
 open CommutativeSemigroup CS
 open import Algebra.Properties.CommutativeSemigroup CS using (x∙yz≈xz∙y; x∙yz≈y∙xz)
-open EqReasoning setoid
+open ≈-Reasoning setoid
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Re-export the contents of divisibility over semigroups
 
 open import Algebra.Properties.Semigroup.Divisibility semigroup public
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Re-export the contents of divisibility over commutative magmas
 
 open import Algebra.Properties.CommutativeMagma.Divisibility commutativeMagma public
   using (x∣xy; xy≈z⇒x∣z; ∣-factors; ∣-factors-≈)
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- New properties
 
 x∣y∧z∣x/y⇒xz∣y : ∀ {x y z} → ((x/y , _) : x ∣ y) → z ∣ x/y → x ∙ z ∣ y
diff --git a/src/Algebra/Properties/CommutativeSemiring/Binomial.agda b/src/Algebra/Properties/CommutativeSemiring/Binomial.agda
new file mode 100644
index 0000000000..7a5524f3e8
--- /dev/null
+++ b/src/Algebra/Properties/CommutativeSemiring/Binomial.agda
@@ -0,0 +1,24 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- The Binomial Theorem for Commutative Semirings
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Algebra.Bundles
+  using (CommutativeSemiring)
+
+module Algebra.Properties.CommutativeSemiring.Binomial {a ℓ} (S : CommutativeSemiring a ℓ) where
+
+open CommutativeSemiring S
+open import Algebra.Properties.Semiring.Exp semiring using (_^_)
+import Algebra.Properties.Semiring.Binomial semiring as Binomial
+open Binomial public hiding (theorem)
+
+------------------------------------------------------------------------
+-- Here it is
+
+theorem : ∀ n x y → (x + y) ^ n ≈ binomialExpansion x y n
+theorem n x y = Binomial.theorem x y (*-comm x y) n
+
diff --git a/src/Algebra/Properties/CommutativeSemiring/Exp/TCOptimised.agda b/src/Algebra/Properties/CommutativeSemiring/Exp/TCOptimised.agda
index 6c06319032..67b37378bc 100644
--- a/src/Algebra/Properties/CommutativeSemiring/Exp/TCOptimised.agda
+++ b/src/Algebra/Properties/CommutativeSemiring/Exp/TCOptimised.agda
@@ -9,7 +9,6 @@
 open import Algebra
 open import Data.Nat.Base as ℕ using (zero; suc)
 import Data.Nat.Properties as ℕ
-open import Relation.Binary
 open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 module Algebra.Properties.CommutativeSemiring.Exp.TCOptimised
diff --git a/src/Algebra/Properties/DistributiveLattice.agda b/src/Algebra/Properties/DistributiveLattice.agda
index adb6266e62..df03dfa38a 100644
--- a/src/Algebra/Properties/DistributiveLattice.agda
+++ b/src/Algebra/Properties/DistributiveLattice.agda
@@ -12,8 +12,7 @@
 open import Algebra.Lattice.Bundles
 open import Algebra.Lattice.Structures.Biased
 open import Relation.Binary
-open import Function.Equality
-open import Function.Equivalence
+open import Function.Bundles using (module Equivalence; _⇔_)
 import Algebra.Construct.Subst.Equality as SubstEq
 
 module Algebra.Properties.DistributiveLattice
@@ -44,7 +43,7 @@ replace-equality {_≈′_} ≈⇔≈′ = record
   { isDistributiveLattice = isDistributiveLatticeʳʲᵐ (record
     { isLattice    = Lattice.isLattice
                        (LatticeProperties.replace-equality lattice ≈⇔≈′)
-    ; ∨-distribʳ-∧ = λ x y z → to ⟨$⟩ ∨-distribʳ-∧ x y z
+    ; ∨-distribʳ-∧ = λ x y z → to (∨-distribʳ-∧ x y z)
     })
   } where open module E {x y} = Equivalence (≈⇔≈′ {x} {y})
 {-# WARNING_ON_USAGE replace-equality
diff --git a/src/Algebra/Properties/Group.agda b/src/Algebra/Properties/Group.agda
index 469245b11c..bade624b3c 100644
--- a/src/Algebra/Properties/Group.agda
+++ b/src/Algebra/Properties/Group.agda
@@ -10,99 +10,161 @@ open import Algebra.Bundles
 
 module Algebra.Properties.Group {g₁ g₂} (G : Group g₁ g₂) where
 
+import Algebra.Properties.Loop as LoopProperties
+import Algebra.Properties.Quasigroup as QuasigroupProperties
+open import Data.Product.Base using (_,_)
+open import Function.Base using (_$_)
+open import Function.Definitions
+
 open Group G
+open import Algebra.Consequences.Setoid setoid
 open import Algebra.Definitions _≈_
+open import Algebra.Structures _≈_ using (IsLoop; IsQuasigroup)
 open import Relation.Binary.Reasoning.Setoid setoid
-open import Function
-open import Data.Product
 
-ε⁻¹≈ε : ε ⁻¹ ≈ ε
-ε⁻¹≈ε = begin
-  ε ⁻¹      ≈⟨ sym $ identityʳ (ε ⁻¹) ⟩
-  ε ⁻¹ ∙ ε  ≈⟨ inverseˡ ε ⟩
-  ε         ∎
-
-private
-
-  left-helper : ∀ x y → x ≈ (x ∙ y) ∙ y ⁻¹
-  left-helper x y = begin
-    x              ≈⟨ sym (identityʳ x) ⟩
-    x ∙ ε          ≈⟨ ∙-congˡ $ sym (inverseʳ y) ⟩
-    x ∙ (y ∙ y ⁻¹) ≈⟨ sym (assoc x y (y ⁻¹)) ⟩
-    (x ∙ y) ∙ y ⁻¹ ∎
-
-  right-helper : ∀ x y → y ≈ x ⁻¹ ∙ (x ∙ y)
-  right-helper x y = begin
-    y              ≈⟨ sym (identityˡ y) ⟩
-    ε          ∙ y ≈⟨ ∙-congʳ $ sym (inverseˡ x) ⟩
-    (x ⁻¹ ∙ x) ∙ y ≈⟨ assoc (x ⁻¹) x y ⟩
-    x ⁻¹ ∙ (x ∙ y) ∎
-
-∙-cancelˡ : LeftCancellative _∙_
-∙-cancelˡ x y z eq = begin
-              y  ≈⟨ right-helper x y ⟩
-  x ⁻¹ ∙ (x ∙ y) ≈⟨ ∙-congˡ eq ⟩
-  x ⁻¹ ∙ (x ∙ z) ≈˘⟨ right-helper x z ⟩
-              z  ∎
-
-∙-cancelʳ : RightCancellative _∙_
-∙-cancelʳ x y z eq = begin
-  y            ≈⟨ left-helper y x ⟩
-  y ∙ x ∙ x ⁻¹ ≈⟨ ∙-congʳ eq ⟩
-  z ∙ x ∙ x ⁻¹ ≈˘⟨ left-helper z x ⟩
-  z            ∎
-
-∙-cancel : Cancellative _∙_
-∙-cancel = ∙-cancelˡ , ∙-cancelʳ
-
-⁻¹-involutive : ∀ x → x ⁻¹ ⁻¹ ≈ x
-⁻¹-involutive x = begin
-  x ⁻¹ ⁻¹              ≈˘⟨ identityʳ _ ⟩
-  x ⁻¹ ⁻¹ ∙ ε          ≈˘⟨ ∙-congˡ $ inverseˡ _ ⟩
-  x ⁻¹ ⁻¹ ∙ (x ⁻¹ ∙ x) ≈˘⟨ right-helper (x ⁻¹) x ⟩
-  x                    ∎
-
-⁻¹-injective : ∀ {x y} → x ⁻¹ ≈ y ⁻¹ → x ≈ y
-⁻¹-injective {x} {y} eq = ∙-cancelʳ _ _ _ ( begin
-  x ∙ x ⁻¹ ≈⟨ inverseʳ x ⟩
-  ε        ≈˘⟨ inverseʳ y ⟩
-  y ∙ y ⁻¹ ≈˘⟨ ∙-congˡ eq ⟩
-  y ∙ x ⁻¹ ∎ )
+\\-cong₂ : Congruent₂ _\\_
+\\-cong₂ x≈y u≈v = ∙-cong (⁻¹-cong x≈y) u≈v
 
-⁻¹-anti-homo-∙ : ∀ x y → (x ∙ y) ⁻¹ ≈ y ⁻¹ ∙ x ⁻¹
-⁻¹-anti-homo-∙ x y = ∙-cancelˡ _ _ _ ( begin
-  x ∙ y ∙ (x ∙ y) ⁻¹    ≈⟨ inverseʳ _ ⟩
-  ε                     ≈˘⟨ inverseʳ _ ⟩
-  x ∙ x ⁻¹              ≈⟨ ∙-congʳ (left-helper x y) ⟩
-  (x ∙ y) ∙ y ⁻¹ ∙ x ⁻¹ ≈⟨ assoc (x ∙ y) (y ⁻¹) (x ⁻¹) ⟩
-  x ∙ y ∙ (y ⁻¹ ∙ x ⁻¹) ∎ )
+//-cong₂ : Congruent₂ _//_
+//-cong₂ x≈y u≈v = ∙-cong x≈y (⁻¹-cong u≈v)
 
-identityˡ-unique : ∀ x y → x ∙ y ≈ y → x ≈ ε
-identityˡ-unique x y eq = begin
-  x              ≈⟨ left-helper x y ⟩
-  (x ∙ y) ∙ y ⁻¹ ≈⟨ ∙-congʳ eq ⟩
-       y  ∙ y ⁻¹ ≈⟨ inverseʳ y ⟩
-  ε              ∎
+------------------------------------------------------------------------
+-- Groups are quasi-groups
+
+\\-leftDividesˡ : LeftDividesˡ _∙_ _\\_
+\\-leftDividesˡ x y = begin
+  x  ∙ (x \\ y)  ≈⟨ assoc x (x ⁻¹) y ⟨
+  x ∙ x ⁻¹ ∙ y   ≈⟨ ∙-congʳ (inverseʳ x) ⟩
+  ε ∙ y          ≈⟨ identityˡ y ⟩
+  y              ∎
+
+\\-leftDividesʳ : LeftDividesʳ _∙_ _\\_
+\\-leftDividesʳ x y = begin
+  x \\ x ∙ y     ≈⟨ assoc (x ⁻¹) x y ⟨
+  x ⁻¹ ∙ x ∙ y   ≈⟨ ∙-congʳ (inverseˡ x) ⟩
+  ε ∙ y          ≈⟨ identityˡ y ⟩
+  y              ∎
+
+
+\\-leftDivides : LeftDivides _∙_ _\\_
+\\-leftDivides = \\-leftDividesˡ , \\-leftDividesʳ
+
+//-rightDividesˡ : RightDividesˡ _∙_ _//_
+//-rightDividesˡ x y = begin
+  (y // x) ∙ x    ≈⟨ assoc y (x ⁻¹) x ⟩
+  y ∙ (x ⁻¹ ∙ x)  ≈⟨ ∙-congˡ (inverseˡ x) ⟩
+  y ∙ ε           ≈⟨ identityʳ y ⟩
+  y               ∎
+
+//-rightDividesʳ : RightDividesʳ _∙_ _//_
+//-rightDividesʳ x y = begin
+  y ∙ x // x    ≈⟨ assoc y x (x ⁻¹) ⟩
+  y ∙ (x // x)  ≈⟨ ∙-congˡ (inverseʳ x) ⟩
+  y ∙ ε         ≈⟨ identityʳ y ⟩
+  y             ∎
+
+//-rightDivides : RightDivides _∙_ _//_
+//-rightDivides = //-rightDividesˡ , //-rightDividesʳ
+
+isQuasigroup : IsQuasigroup _∙_ _\\_ _//_
+isQuasigroup = record
+  { isMagma = isMagma
+  ; \\-cong = \\-cong₂
+  ; //-cong = //-cong₂
+  ; leftDivides = \\-leftDivides
+  ; rightDivides = //-rightDivides
+  }
+
+quasigroup : Quasigroup _ _
+quasigroup = record { isQuasigroup = isQuasigroup }
+
+open QuasigroupProperties quasigroup public
+  using (x≈z//y; y≈x\\z)
+  renaming (cancelˡ to ∙-cancelˡ; cancelʳ to ∙-cancelʳ; cancel to ∙-cancel)
 
-identityʳ-unique : ∀ x y → x ∙ y ≈ x → y ≈ ε
-identityʳ-unique x y eq = begin
-  y              ≈⟨ right-helper x y ⟩
-  x ⁻¹ ∙ (x ∙ y) ≈⟨ refl ⟨ ∙-cong ⟩ eq ⟩
-  x ⁻¹ ∙  x      ≈⟨ inverseˡ x ⟩
-  ε              ∎
+------------------------------------------------------------------------
+-- Groups are loops
+
+isLoop : IsLoop _∙_ _\\_ _//_ ε
+isLoop = record { isQuasigroup = isQuasigroup ; identity = identity }
+
+loop : Loop _ _
+loop = record { isLoop = isLoop }
 
-identity-unique : ∀ {x} → Identity x _∙_ → x ≈ ε
-identity-unique {x} id = identityˡ-unique x x (proj₂ id x)
+open LoopProperties loop public
+  using (identityˡ-unique; identityʳ-unique; identity-unique)
+
+------------------------------------------------------------------------
+-- Other properties
 
 inverseˡ-unique : ∀ x y → x ∙ y ≈ ε → x ≈ y ⁻¹
-inverseˡ-unique x y eq = begin
-  x              ≈⟨ left-helper x y ⟩
-  (x ∙ y) ∙ y ⁻¹ ≈⟨ ∙-congʳ eq ⟩
-       ε  ∙ y ⁻¹ ≈⟨ identityˡ (y ⁻¹) ⟩
-            y ⁻¹ ∎
+inverseˡ-unique x y eq = trans (x≈z//y x y ε eq) (identityˡ _)
 
 inverseʳ-unique : ∀ x y → x ∙ y ≈ ε → y ≈ x ⁻¹
-inverseʳ-unique x y eq = begin
-  y       ≈⟨ sym (⁻¹-involutive y) ⟩
-  y ⁻¹ ⁻¹ ≈⟨ ⁻¹-cong (sym (inverseˡ-unique x y eq)) ⟩
-  x ⁻¹    ∎
+inverseʳ-unique x y eq = trans (y≈x\\z x y ε eq) (identityʳ _)
+
+ε⁻¹≈ε : ε ⁻¹ ≈ ε
+ε⁻¹≈ε = sym $ inverseˡ-unique _ _ (identityˡ ε)
+
+⁻¹-selfInverse : SelfInverse _⁻¹
+⁻¹-selfInverse {x} {y} eq = sym $ inverseˡ-unique x y $ begin
+  x ∙ y    ≈⟨ ∙-congˡ eq ⟨
+  x ∙ x ⁻¹ ≈⟨ inverseʳ x  ⟩
+  ε        ∎
+
+⁻¹-involutive : Involutive _⁻¹
+⁻¹-involutive = selfInverse⇒involutive ⁻¹-selfInverse
+
+x∙y⁻¹≈ε⇒x≈y : ∀ x y → (x ∙ y ⁻¹) ≈ ε → x ≈ y
+x∙y⁻¹≈ε⇒x≈y x y x∙y⁻¹≈ε = begin
+  x         ≈⟨ inverseˡ-unique x (y ⁻¹) x∙y⁻¹≈ε ⟩
+  y ⁻¹ ⁻¹   ≈⟨ ⁻¹-involutive y ⟩
+  y         ∎
+
+x≈y⇒x∙y⁻¹≈ε : ∀ {x y} → x ≈ y → (x ∙ y ⁻¹) ≈ ε
+x≈y⇒x∙y⁻¹≈ε {x} {y} x≈y = begin
+  x ∙ y ⁻¹ ≈⟨ ∙-congʳ x≈y ⟩
+  y ∙ y ⁻¹ ≈⟨ inverseʳ y ⟩
+  ε        ∎
+
+⁻¹-injective : Injective _≈_ _≈_ _⁻¹
+⁻¹-injective = selfInverse⇒injective ⁻¹-selfInverse
+
+⁻¹-anti-homo-∙ : ∀ x y → (x ∙ y) ⁻¹ ≈ y ⁻¹ ∙ x ⁻¹
+⁻¹-anti-homo-∙ x y = ∙-cancelˡ _ _ _ $ begin
+  x ∙ y ∙ (x ∙ y) ⁻¹    ≈⟨ inverseʳ _ ⟩
+  ε                     ≈⟨ inverseʳ _ ⟨
+  x ∙ x ⁻¹              ≈⟨ ∙-congʳ (//-rightDividesʳ y x) ⟨
+  (x ∙ y) ∙ y ⁻¹ ∙ x ⁻¹ ≈⟨ assoc (x ∙ y) (y ⁻¹) (x ⁻¹) ⟩
+  x ∙ y ∙ (y ⁻¹ ∙ x ⁻¹) ∎
+
+⁻¹-anti-homo-// : ∀ x y → (x // y) ⁻¹ ≈ y // x
+⁻¹-anti-homo-// x y = begin
+  (x // y) ⁻¹      ≡⟨⟩
+  (x ∙ y ⁻¹) ⁻¹    ≈⟨ ⁻¹-anti-homo-∙ x (y ⁻¹) ⟩
+  (y ⁻¹) ⁻¹ ∙ x ⁻¹ ≈⟨ ∙-congʳ (⁻¹-involutive y) ⟩
+  y ∙ x ⁻¹         ≡⟨⟩
+  y // x ∎
+
+⁻¹-anti-homo-\\ : ∀ x y → (x \\ y) ⁻¹ ≈ y \\ x
+⁻¹-anti-homo-\\ x y = begin
+  (x \\ y) ⁻¹      ≡⟨⟩
+  (x ⁻¹ ∙ y) ⁻¹    ≈⟨ ⁻¹-anti-homo-∙ (x ⁻¹) y ⟩
+  y ⁻¹ ∙ (x ⁻¹) ⁻¹ ≈⟨ ∙-congˡ (⁻¹-involutive x) ⟩
+  y ⁻¹ ∙ x         ≡⟨⟩
+  y \\ x ∎
+
+\\≗flip-//⇒comm : (∀ x y → x \\ y ≈ y // x) → Commutative _∙_
+\\≗flip-//⇒comm \\≗//ᵒ x y = begin
+  x ∙ y                ≈⟨ ∙-congˡ (//-rightDividesˡ x y) ⟨
+  x ∙ ((y // x) ∙ x)   ≈⟨ ∙-congˡ (∙-congʳ (\\≗//ᵒ x y)) ⟨
+  x ∙ ((x \\ y) ∙ x)   ≈⟨ assoc x (x \\ y) x ⟨
+  x ∙ (x \\ y) ∙ x     ≈⟨ ∙-congʳ (\\-leftDividesˡ x y) ⟩
+  y ∙ x                ∎
+
+comm⇒\\≗flip-// : Commutative _∙_ → ∀ x y → x \\ y ≈ y // x
+comm⇒\\≗flip-// comm x y = begin
+  x \\ y    ≡⟨⟩
+  x ⁻¹ ∙ y  ≈⟨ comm _ _ ⟩
+  y ∙ x ⁻¹  ≡⟨⟩
+  y // x    ∎
diff --git a/src/Algebra/Properties/Lattice.agda b/src/Algebra/Properties/Lattice.agda
index 3e9e078f3f..57037296f6 100644
--- a/src/Algebra/Properties/Lattice.agda
+++ b/src/Algebra/Properties/Lattice.agda
@@ -8,10 +8,10 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra.Lattice.Bundles
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
 open import Function.Base
 open import Function.Bundles using (module Equivalence; _⇔_)
-open import Data.Product using (_,_; swap)
+open import Data.Product.Base using (_,_; swap)
 
 module Algebra.Properties.Lattice {l₁ l₂} (L : Lattice l₁ l₂) where
 
diff --git a/src/Algebra/Properties/Loop.agda b/src/Algebra/Properties/Loop.agda
index 26bf6f4ce6..46ed1e7f7c 100644
--- a/src/Algebra/Properties/Loop.agda
+++ b/src/Algebra/Properties/Loop.agda
@@ -1,7 +1,7 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Some basic properties of Quasigroup
+-- Some basic properties of Loop
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
@@ -12,30 +12,46 @@ module Algebra.Properties.Loop {l₁ l₂} (L : Loop l₁ l₂) where
 
 open Loop L
 open import Algebra.Definitions _≈_
+open import Algebra.Properties.Quasigroup quasigroup
+open import Data.Product.Base using (proj₂)
 open import Relation.Binary.Reasoning.Setoid setoid
-open import Data.Product
-open import Algebra.Properties.Quasigroup
 
 x//x≈ε : ∀ x → x // x ≈ ε
 x//x≈ε x = begin
-  x // x       ≈⟨ //-congʳ (sym (identityˡ x)) ⟩
+  x // x       ≈⟨ //-congʳ (identityˡ x) ⟨
   (ε ∙ x) // x ≈⟨ rightDividesʳ x ε ⟩
   ε            ∎
 
-x\\x≈ε : ∀ x → x \\ x ≈ ε
+x\\x≈ε : ∀ x → x \\ x ≈ ε
 x\\x≈ε x = begin
-  x \\ x       ≈⟨ \\-congˡ (sym (identityʳ x )) ⟩
+  x \\ x       ≈⟨ \\-congˡ (identityʳ x ) ⟨
   x \\ (x ∙ ε) ≈⟨ leftDividesʳ x ε ⟩
   ε            ∎
 
 ε\\x≈x : ∀ x → ε \\ x ≈ x
 ε\\x≈x x = begin
-  ε \\ x       ≈⟨ sym (identityˡ (ε \\ x)) ⟩
+  ε \\ x       ≈⟨ identityˡ (ε \\ x) ⟨
   ε ∙ (ε \\ x) ≈⟨ leftDividesˡ ε x ⟩
   x            ∎
 
 x//ε≈x : ∀ x → x // ε ≈ x
 x//ε≈x x = begin
- x // ε       ≈⟨ sym (identityʳ (x // ε)) ⟩
+ x // ε       ≈⟨ identityʳ (x // ε) ⟨
  (x // ε) ∙ ε ≈⟨ rightDividesˡ ε x ⟩
  x            ∎
+
+identityˡ-unique : ∀ x y → x ∙ y ≈ y → x ≈ ε
+identityˡ-unique x y eq = begin
+  x      ≈⟨ x≈z//y x y y eq ⟩
+  y // y ≈⟨ x//x≈ε y ⟩
+  ε      ∎
+
+identityʳ-unique : ∀ x y → x ∙ y ≈ x → y ≈ ε
+identityʳ-unique x y eq = begin
+  y       ≈⟨ y≈x\\z x y x eq ⟩
+  x \\ x  ≈⟨ x\\x≈ε x ⟩
+  ε       ∎
+
+identity-unique : ∀ {x} → Identity x _∙_ → x ≈ ε
+identity-unique {x} id = identityˡ-unique x x (proj₂ id x)
+
diff --git a/src/Algebra/Properties/Magma/Divisibility.agda b/src/Algebra/Properties/Magma/Divisibility.agda
index 72907929df..629406faa1 100644
--- a/src/Algebra/Properties/Magma/Divisibility.agda
+++ b/src/Algebra/Properties/Magma/Divisibility.agda
@@ -7,7 +7,7 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra using (Magma)
-open import Data.Product using (_×_; _,_; ∃; map; swap)
+open import Data.Product.Base using (_×_; _,_; ∃; map; swap)
 open import Relation.Binary.Definitions
 
 module Algebra.Properties.Magma.Divisibility {a ℓ} (M : Magma a ℓ) where
@@ -18,7 +18,7 @@ open Magma M
 -- Re-export divisibility relations publicly
 
 open import Algebra.Definitions.RawMagma rawMagma public
-  using (_∣_; _∤_; _∣∣_; _∤∤_; _∣ˡ_; _∤ˡ_; _∣ʳ_; _∤ʳ_)
+  using (_∣_; _∤_; _∣∣_; _∤∤_; _∣ˡ_; _∤ˡ_; _∣ʳ_; _∤ʳ_; _,_)
 
 ------------------------------------------------------------------------
 -- Properties of divisibility
diff --git a/src/Algebra/Properties/MiddleBolLoop.agda b/src/Algebra/Properties/MiddleBolLoop.agda
index a50ce3b0d5..60f2898496 100644
--- a/src/Algebra/Properties/MiddleBolLoop.agda
+++ b/src/Algebra/Properties/MiddleBolLoop.agda
@@ -13,7 +13,6 @@ module Algebra.Properties.MiddleBolLoop {m₁ m₂} (M : MiddleBolLoop m₁ m₂
 open MiddleBolLoop M
 open import Algebra.Definitions _≈_
 open import Relation.Binary.Reasoning.Setoid setoid
-open import Data.Product
 import Algebra.Properties.Loop as LoopProperties
 open LoopProperties loop public
 
diff --git a/src/Algebra/Properties/Monoid/Divisibility.agda b/src/Algebra/Properties/Monoid/Divisibility.agda
index 5653312fd8..c0f4c40af9 100644
--- a/src/Algebra/Properties/Monoid/Divisibility.agda
+++ b/src/Algebra/Properties/Monoid/Divisibility.agda
@@ -7,8 +7,11 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra using (Monoid)
-open import Data.Product using (_,_)
-open import Relation.Binary
+open import Data.Product.Base using (_,_)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Bundles using (Preorder)
+open import Relation.Binary.Structures using (IsPreorder; IsEquivalence)
+open import Relation.Binary.Definitions using (Reflexive)
 
 module Algebra.Properties.Monoid.Divisibility
   {a ℓ} (M : Monoid a ℓ) where
@@ -23,6 +26,8 @@ open import Algebra.Properties.Semigroup.Divisibility semigroup public
 ------------------------------------------------------------------------
 -- Additional properties
 
+infix 4 ε∣_
+
 ε∣_ : ∀ x → ε ∣ x
 ε∣ x = x , identityʳ x
 
diff --git a/src/Algebra/Properties/Monoid/Mult.agda b/src/Algebra/Properties/Monoid/Mult.agda
index f74404e886..ce837c8134 100644
--- a/src/Algebra/Properties/Monoid/Mult.agda
+++ b/src/Algebra/Properties/Monoid/Mult.agda
@@ -8,8 +8,8 @@
 
 open import Algebra.Bundles using (Monoid)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc; NonZero)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (_Preserves_⟶_; _Preserves₂_⟶_⟶_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 module Algebra.Properties.Monoid.Mult {a ℓ} (M : Monoid a ℓ) where
 
@@ -44,13 +44,19 @@ open import Algebra.Definitions.RawMonoid rawMonoid public
 ×-congʳ (suc n) x≈x′ = +-cong x≈x′ (×-congʳ n x≈x′)
 
 ×-cong : _×_ Preserves₂ _≡_ ⟶ _≈_ ⟶ _≈_
-×-cong {n} P.refl x≈x′ = ×-congʳ n x≈x′
+×-cong {n} ≡.refl x≈x′ = ×-congʳ n x≈x′
 
 ×-congˡ : ∀ {x} → (_× x) Preserves _≡_ ⟶ _≈_
 ×-congˡ m≡n = ×-cong m≡n refl
 
 -- _×_ is homomorphic with respect to _ℕ+_/_+_.
 
+×-homo-0 : ∀ x → 0 × x ≈ 0#
+×-homo-0 x = refl
+
+×-homo-1 : ∀ x → 1 × x ≈ x
+×-homo-1 = +-identityʳ
+
 ×-homo-+ : ∀ x m n → (m ℕ.+ n) × x ≈ m × x + n × x
 ×-homo-+ x 0       n = sym (+-identityˡ (n × x))
 ×-homo-+ x (suc m) n = begin
@@ -70,5 +76,5 @@ open import Algebra.Definitions.RawMonoid rawMonoid public
 ×-assocˡ x zero    n = refl
 ×-assocˡ x (suc m) n = begin
   n × x + m × n × x     ≈⟨ +-congˡ (×-assocˡ x m n) ⟩
-  n × x + (m ℕ.* n) × x ≈˘⟨ ×-homo-+ x n (m ℕ.* n) ⟩
+  n × x + (m ℕ.* n) × x ≈⟨ ×-homo-+ x n (m ℕ.* n) ⟨
   (suc m ℕ.* n) × x     ∎
diff --git a/src/Algebra/Properties/Monoid/Mult/TCOptimised.agda b/src/Algebra/Properties/Monoid/Mult/TCOptimised.agda
index 86c4ac566c..a147954cb0 100644
--- a/src/Algebra/Properties/Monoid/Mult/TCOptimised.agda
+++ b/src/Algebra/Properties/Monoid/Mult/TCOptimised.agda
@@ -10,7 +10,7 @@
 open import Algebra.Bundles using (Monoid)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
 open import Relation.Binary.Core using (_Preserves_⟶_; _Preserves₂_⟶_⟶_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 module Algebra.Properties.Monoid.Mult.TCOptimised
   {a ℓ} (M : Monoid a ℓ) where
@@ -55,14 +55,14 @@ open import Algebra.Definitions.RawMonoid rawMonoid public
 ×ᵤ≈× 0       x = refl
 ×ᵤ≈× (suc n) x = begin
   x + n ×ᵤ x  ≈⟨ +-congˡ (×ᵤ≈× n x) ⟩
-  x + n ×  x  ≈˘⟨ 1+× n x ⟩
+  x + n ×  x  ≈⟨ 1+× n x ⟨
   suc n ×  x  ∎
 
 -- _×_ is homomorphic with respect to _ℕ.+_/_+_.
 
 ×-homo-+ : ∀ c m n → (m ℕ.+ n) × c ≈ m × c + n × c
 ×-homo-+ c m n = begin
-  (m ℕ.+ n) ×  c   ≈˘⟨ ×ᵤ≈× (m ℕ.+ n) c ⟩
+  (m ℕ.+ n) ×  c   ≈⟨ ×ᵤ≈× (m ℕ.+ n) c ⟨
   (m ℕ.+ n) ×ᵤ c   ≈⟨ U.×-homo-+ c m n ⟩
   m ×ᵤ c + n ×ᵤ c  ≈⟨ +-cong (×ᵤ≈× m c) (×ᵤ≈× n c) ⟩
   m ×  c + n ×  c  ∎
@@ -75,12 +75,12 @@ open import Algebra.Definitions.RawMonoid rawMonoid public
 ×-congʳ (suc n@(suc _)) x≈y = +-cong (×-congʳ n x≈y) x≈y
 
 ×-cong : _×_ Preserves₂ _≡_ ⟶ _≈_ ⟶ _≈_
-×-cong {n} P.refl x≈y = ×-congʳ n x≈y
+×-cong {n} ≡.refl x≈y = ×-congʳ n x≈y
 
 ×-assocˡ : ∀ x m n → m × (n × x) ≈ (m ℕ.* n) × x
 ×-assocˡ x m n = begin
-  m ×  (n ×  x)  ≈˘⟨ ×-congʳ m (×ᵤ≈× n x) ⟩
-  m ×  (n ×ᵤ x)  ≈˘⟨ ×ᵤ≈× m (n ×ᵤ x) ⟩
+  m ×  (n ×  x)  ≈⟨ ×-congʳ m (×ᵤ≈× n x) ⟨
+  m ×  (n ×ᵤ x)  ≈⟨ ×ᵤ≈× m (n ×ᵤ x) ⟨
   m ×ᵤ (n ×ᵤ x)  ≈⟨  U.×-assocˡ x m n ⟩
   (m ℕ.* n) ×ᵤ x ≈⟨  ×ᵤ≈× (m ℕ.* n) x ⟩
   (m ℕ.* n) ×  x ∎
diff --git a/src/Algebra/Properties/Monoid/Sum.agda b/src/Algebra/Properties/Monoid/Sum.agda
index 1f522ca678..78a8d3b205 100644
--- a/src/Algebra/Properties/Monoid/Sum.agda
+++ b/src/Algebra/Properties/Monoid/Sum.agda
@@ -7,15 +7,16 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra.Bundles using (Monoid)
+
+module Algebra.Properties.Monoid.Sum {a ℓ} (M : Monoid a ℓ) where
+
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc; NonZero)
-open import Data.Vec.Functional as Vector
+open import Data.Vec.Functional as Vector using (Vector; replicate; init;
+  last; head; tail)
 open import Data.Fin.Base using (zero; suc)
-open import Data.Unit using (tt)
 open import Function.Base using (_∘_)
-open import Relation.Binary as B using (_Preserves_⟶_)
-open import Relation.Binary.PropositionalEquality as P using (_≗_; _≡_)
-
-module Algebra.Properties.Monoid.Sum {a ℓ} (M : Monoid a ℓ) where
+open import Relation.Binary.Core using (_Preserves_⟶_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≗_; _≡_)
 
 open Monoid M
   renaming
@@ -42,13 +43,17 @@ open import Algebra.Definitions.RawMonoid rawMonoid public
 ------------------------------------------------------------------------
 -- An alternative mathematical-style syntax for sumₜ
 
-infixl 10 sum-syntax
+infixl 10 sum-syntax sum⁺-syntax
 
 sum-syntax : ∀ n → Vector Carrier n → Carrier
 sum-syntax _ = sum
 
 syntax sum-syntax n (λ i → x) = ∑[ i < n ] x
 
+sum⁺-syntax = sum-syntax ∘ suc
+
+syntax sum⁺-syntax n (λ i → x) = ∑[ i ≤ n ] x
+
 ------------------------------------------------------------------------
 -- Properties
 
@@ -57,18 +62,18 @@ sum-cong-≋ {zero}  xs≋ys = refl
 sum-cong-≋ {suc n} xs≋ys = +-cong (xs≋ys zero) (sum-cong-≋ (xs≋ys ∘ suc))
 
 sum-cong-≗ : ∀ {n} → sum {n} Preserves _≗_ ⟶ _≡_
-sum-cong-≗ {zero}  xs≗ys = P.refl
-sum-cong-≗ {suc n} xs≗ys = P.cong₂ _+_ (xs≗ys zero) (sum-cong-≗ (xs≗ys ∘ suc))
+sum-cong-≗ {zero}  xs≗ys = ≡.refl
+sum-cong-≗ {suc n} xs≗ys = ≡.cong₂ _+_ (xs≗ys zero) (sum-cong-≗ (xs≗ys ∘ suc))
 
-sum-replicate : ∀ n {x} → sum {n} (replicate x) ≈ n × x
+sum-replicate : ∀ n {x} → sum (replicate n x) ≈ n × x
 sum-replicate zero    = refl
 sum-replicate (suc n) = +-congˡ (sum-replicate n)
 
 sum-replicate-idem : ∀ {x} → _+_ IdempotentOn x →
-                     ∀ n → .{{_ : NonZero n}} → sum {n} (replicate x) ≈ x
+                     ∀ n → .{{_ : NonZero n}} → sum (replicate n x) ≈ x
 sum-replicate-idem idem n = trans (sum-replicate n) (×-idem idem n)
 
-sum-replicate-zero : ∀ n → sum {n} (replicate 0#) ≈ 0#
+sum-replicate-zero : ∀ n → sum (replicate n 0#) ≈ 0#
 sum-replicate-zero zero    = refl
 sum-replicate-zero (suc n) = sum-replicate-idem (+-identityˡ 0#) (suc n)
 
@@ -77,11 +82,11 @@ sum-replicate-zero (suc n) = sum-replicate-idem (+-identityˡ 0#) (suc n)
 sum-init-last : ∀ {n} (t : Vector Carrier (suc n)) → sum t ≈ sum (init t) + last t
 sum-init-last {zero} t  = begin
   t₀ + 0# ≈⟨ +-identityʳ t₀ ⟩
-  t₀      ≈˘⟨ +-identityˡ t₀ ⟩
+  t₀      ≈⟨ +-identityˡ t₀ ⟨
   0# + t₀ ∎ where t₀ = t zero
 sum-init-last {suc n} t = begin
   t₀ + ∑t             ≈⟨ +-congˡ (sum-init-last (tail t)) ⟩
-  t₀ + (∑t′ + tₗ)     ≈˘⟨ +-assoc _ _ _ ⟩
+  t₀ + (∑t′ + tₗ)     ≈⟨ +-assoc _ _ _ ⟨
   (t₀ + ∑t′) + tₗ     ∎
   where
     t₀ = head t
diff --git a/src/Algebra/Properties/MoufangLoop.agda b/src/Algebra/Properties/MoufangLoop.agda
index 4740bc19b6..9b0e5ac94b 100644
--- a/src/Algebra/Properties/MoufangLoop.agda
+++ b/src/Algebra/Properties/MoufangLoop.agda
@@ -13,7 +13,7 @@ module Algebra.Properties.MoufangLoop {a ℓ} (M : MoufangLoop a ℓ) where
 open MoufangLoop M
 open import Algebra.Definitions _≈_
 open import Relation.Binary.Reasoning.Setoid setoid
-open import Data.Product
+open import Data.Product.Base using (_,_)
 
 alternativeˡ : LeftAlternative _∙_
 alternativeˡ x y = begin
diff --git a/src/Algebra/Properties/Quasigroup.agda b/src/Algebra/Properties/Quasigroup.agda
index a583ae34f5..e8c7516978 100644
--- a/src/Algebra/Properties/Quasigroup.agda
+++ b/src/Algebra/Properties/Quasigroup.agda
@@ -13,18 +13,18 @@ module Algebra.Properties.Quasigroup {q₁ q₂} (Q : Quasigroup q₁ q₂) wher
 open Quasigroup Q
 open import Algebra.Definitions _≈_
 open import Relation.Binary.Reasoning.Setoid setoid
-open import Data.Product
+open import Data.Product.Base using (_,_)
 
 cancelˡ : LeftCancellative _∙_
 cancelˡ x y z eq = begin
-  y             ≈⟨ sym( leftDividesʳ x y) ⟩
+  y             ≈⟨ leftDividesʳ x y ⟨
   x \\ (x ∙ y)  ≈⟨ \\-congˡ eq ⟩
   x \\ (x ∙ z)  ≈⟨ leftDividesʳ x z ⟩
   z             ∎
 
 cancelʳ : RightCancellative _∙_
 cancelʳ x y z eq = begin
-  y             ≈⟨ sym( rightDividesʳ x y) ⟩
+  y             ≈⟨ rightDividesʳ x y ⟨
   (y ∙ x) // x  ≈⟨ //-congʳ eq ⟩
   (z ∙ x) // x  ≈⟨ rightDividesʳ x z ⟩
   z             ∎
@@ -34,12 +34,12 @@ cancel = cancelˡ , cancelʳ
 
 y≈x\\z : ∀ x y z → x ∙ y ≈ z → y ≈ x \\ z
 y≈x\\z x y z eq = begin
-  y            ≈⟨ sym (leftDividesʳ x y) ⟩
+  y            ≈⟨ leftDividesʳ x y ⟨
   x \\ (x ∙ y) ≈⟨ \\-congˡ eq ⟩
   x \\ z       ∎
 
 x≈z//y : ∀ x y z → x ∙ y ≈ z → x ≈ z // y
 x≈z//y x y z eq = begin
-  x            ≈⟨ sym (rightDividesʳ y x) ⟩
+  x            ≈⟨ rightDividesʳ y x ⟨
   (x ∙ y) // y ≈⟨ //-congʳ eq ⟩
   z // y       ∎
diff --git a/src/Algebra/Properties/Ring.agda b/src/Algebra/Properties/Ring.agda
index e310202a37..461a9a040b 100644
--- a/src/Algebra/Properties/Ring.agda
+++ b/src/Algebra/Properties/Ring.agda
@@ -12,74 +12,21 @@ module Algebra.Properties.Ring {r₁ r₂} (R : Ring r₁ r₂) where
 
 open Ring R
 
-import Algebra.Properties.AbelianGroup as AbelianGroupProperties
+import Algebra.Properties.RingWithoutOne as RingWithoutOneProperties
 open import Function.Base using (_$_)
 open import Relation.Binary.Reasoning.Setoid setoid
 open import Algebra.Definitions _≈_
-open import Data.Product
 
 ------------------------------------------------------------------------
--- Export properties of abelian groups
+-- Export properties of rings without a 1#.
 
-open AbelianGroupProperties +-abelianGroup public
-  renaming
-  ( ε⁻¹≈ε            to -0#≈0#
-  ; ∙-cancelˡ        to +-cancelˡ
-  ; ∙-cancelʳ        to +-cancelʳ
-  ; ∙-cancel         to +-cancel
-  ; ⁻¹-involutive    to -‿involutive
-  ; ⁻¹-injective     to -‿injective
-  ; ⁻¹-anti-homo-∙   to -‿anti-homo-+
-  ; identityˡ-unique to +-identityˡ-unique
-  ; identityʳ-unique to +-identityʳ-unique
-  ; identity-unique  to +-identity-unique
-  ; inverseˡ-unique  to +-inverseˡ-unique
-  ; inverseʳ-unique  to +-inverseʳ-unique
-  ; ⁻¹-∙-comm        to -‿+-comm
-  )
+open RingWithoutOneProperties ringWithoutOne public
 
 ------------------------------------------------------------------------
--- Properties of -_
-
--‿distribˡ-* : ∀ x y → - (x * y) ≈ - x * y
--‿distribˡ-* x y = sym $ begin
-  - x * y                        ≈⟨ sym $ +-identityʳ _ ⟩
-  - x * y + 0#                   ≈⟨ +-congˡ $ sym (-‿inverseʳ _) ⟩
-  - x * y + (x * y + - (x * y))  ≈⟨ sym $ +-assoc _ _ _  ⟩
-  - x * y + x * y + - (x * y)    ≈⟨ +-congʳ $ sym (distribʳ _ _ _) ⟩
-  (- x + x) * y + - (x * y)      ≈⟨ +-congʳ $ *-congʳ $ -‿inverseˡ _ ⟩
-  0# * y + - (x * y)             ≈⟨ +-congʳ $ zeroˡ _ ⟩
-  0# + - (x * y)                 ≈⟨ +-identityˡ _ ⟩
-  - (x * y)                      ∎
-
--‿distribʳ-* : ∀ x y → - (x * y) ≈ x * - y
--‿distribʳ-* x y = sym $ begin
-  x * - y                        ≈⟨ sym $ +-identityˡ _ ⟩
-  0# + x * - y                   ≈⟨ +-congʳ $ sym (-‿inverseˡ _) ⟩
-  - (x * y) + x * y + x * - y    ≈⟨ +-assoc _ _ _  ⟩
-  - (x * y) + (x * y + x * - y)  ≈⟨ +-congˡ $ sym (distribˡ _ _ _)  ⟩
-  - (x * y) + x * (y + - y)      ≈⟨ +-congˡ $ *-congˡ $ -‿inverseʳ _ ⟩
-  - (x * y) + x * 0#             ≈⟨ +-congˡ $ zeroʳ _ ⟩
-  - (x * y) + 0#                 ≈⟨ +-identityʳ _ ⟩
-  - (x * y)                      ∎
+-- Extra properties of 1#
 
 -1*x≈-x : ∀ x → - 1# * x ≈ - x
 -1*x≈-x x = begin
-  - 1# * x    ≈⟨ sym (-‿distribˡ-* 1# x ) ⟩
+  - 1# * x    ≈⟨ -‿distribˡ-* 1# x ⟨
   - (1# * x)  ≈⟨ -‿cong ( *-identityˡ x ) ⟩
   - x         ∎
-
-x+x≈x⇒x≈0 : ∀ x → x + x ≈ x → x ≈ 0#
-x+x≈x⇒x≈0 x eq = +-identityˡ-unique x x eq
-
-x[y-z]≈xy-xz : ∀ x y z → x * (y - z) ≈ x * y - x * z
-x[y-z]≈xy-xz x y z = begin
-  x * (y - z)      ≈⟨ distribˡ x y (- z) ⟩
-  x * y + x * - z  ≈⟨ +-congˡ (sym (-‿distribʳ-* x z)) ⟩
-  x * y - x * z    ∎
-
-[y-z]x≈yx-zx : ∀ x y z → (y - z) * x ≈ (y * x) - (z * x)
-[y-z]x≈yx-zx x y z = begin
-  (y - z) * x      ≈⟨ distribʳ x y (- z) ⟩
-  y * x + - z * x  ≈⟨ +-congˡ (sym (-‿distribˡ-* z x)) ⟩
-  y * x - z * x    ∎
diff --git a/src/Algebra/Properties/RingWithoutOne.agda b/src/Algebra/Properties/RingWithoutOne.agda
index cab4d405cb..d81ef58477 100644
--- a/src/Algebra/Properties/RingWithoutOne.agda
+++ b/src/Algebra/Properties/RingWithoutOne.agda
@@ -38,10 +38,10 @@ open AbelianGroupProperties +-abelianGroup public
 
 -‿distribˡ-* : ∀ x y → - (x * y) ≈ - x * y
 -‿distribˡ-* x y = sym $ begin
-  - x * y                        ≈⟨ sym $ +-identityʳ (- x * y) ⟩
-  - x * y + 0#                   ≈⟨ +-congˡ $ sym ( -‿inverseʳ (x * y) ) ⟩
-  - x * y + (x * y + - (x * y))  ≈⟨ sym $ +-assoc (- x * y) (x * y) (- (x * y))  ⟩
-  - x * y + x * y + - (x * y)    ≈⟨ +-congʳ $ sym ( distribʳ y (- x) x ) ⟩
+  - x * y                        ≈⟨ +-identityʳ (- x * y) ⟨
+  - x * y + 0#                   ≈⟨ +-congˡ $ -‿inverseʳ (x * y) ⟨
+  - x * y + (x * y + - (x * y))  ≈⟨ +-assoc (- x * y) (x * y) (- (x * y)) ⟨
+  - x * y + x * y + - (x * y)    ≈⟨ +-congʳ $ distribʳ y (- x) x ⟨
   (- x + x) * y + - (x * y)      ≈⟨ +-congʳ $ *-congʳ $ -‿inverseˡ x ⟩
   0# * y + - (x * y)             ≈⟨ +-congʳ $ zeroˡ y ⟩
   0# + - (x * y)                 ≈⟨ +-identityˡ (- (x * y)) ⟩
@@ -49,11 +49,26 @@ open AbelianGroupProperties +-abelianGroup public
 
 -‿distribʳ-* : ∀ x y → - (x * y) ≈ x * - y
 -‿distribʳ-* x y = sym $ begin
-  x * - y                        ≈⟨ sym $ +-identityˡ (x * (- y)) ⟩
-  0# + x * - y                   ≈⟨ +-congʳ $ sym ( -‿inverseˡ (x * y) ) ⟩
-  - (x * y) + x * y + x * - y    ≈⟨ +-assoc (- (x * y)) (x * y) (x * (- y)) ⟩
-  - (x * y) + (x * y + x * - y)  ≈⟨ +-congˡ $ sym ( distribˡ x y ( - y) )  ⟩
+  x * - y                        ≈⟨ +-identityˡ (x * - y) ⟨
+  0# + x * - y                   ≈⟨ +-congʳ $ -‿inverseˡ (x * y) ⟨
+  - (x * y) + x * y + x * - y    ≈⟨ +-assoc (- (x * y)) (x * y) (x * - y) ⟩
+  - (x * y) + (x * y + x * - y)  ≈⟨ +-congˡ $ distribˡ x y (- y) ⟨
   - (x * y) + x * (y + - y)      ≈⟨ +-congˡ $ *-congˡ $ -‿inverseʳ y ⟩
   - (x * y) + x * 0#             ≈⟨ +-congˡ $ zeroʳ x ⟩
   - (x * y) + 0#                 ≈⟨ +-identityʳ (- (x * y)) ⟩
   - (x * y)                      ∎
+
+x+x≈x⇒x≈0 : ∀ x → x + x ≈ x → x ≈ 0#
+x+x≈x⇒x≈0 x eq = +-identityˡ-unique x x eq
+
+x[y-z]≈xy-xz : ∀ x y z → x * (y - z) ≈ x * y - x * z
+x[y-z]≈xy-xz x y z = begin
+  x * (y - z)      ≈⟨ distribˡ x y (- z) ⟩
+  x * y + x * - z  ≈⟨ +-congˡ (sym (-‿distribʳ-* x z)) ⟩
+  x * y - x * z    ∎
+
+[y-z]x≈yx-zx : ∀ x y z → (y - z) * x ≈ (y * x) - (z * x)
+[y-z]x≈yx-zx x y z = begin
+  (y - z) * x      ≈⟨ distribʳ x y (- z) ⟩
+  y * x + - z * x  ≈⟨ +-congˡ (sym (-‿distribˡ-* z x)) ⟩
+  y * x - z * x    ∎
diff --git a/src/Algebra/Properties/Semigroup.agda b/src/Algebra/Properties/Semigroup.agda
index 4147b612e2..22aab4e66e 100644
--- a/src/Algebra/Properties/Semigroup.agda
+++ b/src/Algebra/Properties/Semigroup.agda
@@ -12,7 +12,7 @@ module Algebra.Properties.Semigroup {a ℓ} (S : Semigroup a ℓ) where
 
 open Semigroup S
 open import Algebra.Definitions _≈_
-open import Data.Product
+open import Data.Product.Base using (_,_)
 
 x∙yz≈xy∙z : ∀ x y z → x ∙ (y ∙ z) ≈ (x ∙ y) ∙ z
 x∙yz≈xy∙z x y z = sym (assoc x y z)
diff --git a/src/Algebra/Properties/Semigroup/Divisibility.agda b/src/Algebra/Properties/Semigroup/Divisibility.agda
index d7a6154a32..76eaaa6edf 100644
--- a/src/Algebra/Properties/Semigroup/Divisibility.agda
+++ b/src/Algebra/Properties/Semigroup/Divisibility.agda
@@ -7,7 +7,7 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra using (Semigroup)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Relation.Binary.Definitions using (Transitive)
 
 module Algebra.Properties.Semigroup.Divisibility
diff --git a/src/Algebra/Properties/Semiring/Binomial.agda b/src/Algebra/Properties/Semiring/Binomial.agda
new file mode 100644
index 0000000000..bbd9adce21
--- /dev/null
+++ b/src/Algebra/Properties/Semiring/Binomial.agda
@@ -0,0 +1,235 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- The Binomial Theorem for *-commuting elements in a Semiring
+--
+-- Freely adapted from PR #1287 by Maciej Piechotka (@uzytkownik)
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Algebra.Bundles using (Semiring)
+open import Data.Bool.Base using (true)
+open import Data.Nat.Base as ℕ hiding (_+_; _*_; _^_)
+open import Data.Nat.Combinatorics
+  using (_C_; nCn≡1; nC1≡n; nCk+nC[k+1]≡[n+1]C[k+1])
+open import Data.Nat.Properties as ℕ
+  using (<⇒<ᵇ; n<1+n; n∸n≡0; +-∸-assoc)
+open import Data.Fin.Base as Fin
+  using (Fin; zero; suc; toℕ; fromℕ; inject₁)
+open import Data.Fin.Patterns using (0F)
+open import Data.Fin.Properties as Fin
+  using (toℕ<n; toℕ-fromℕ; toℕ-inject₁)
+open import Data.Fin.Relation.Unary.Top
+  using (view; ‵fromℕ; ‵inject₁; view-fromℕ; view-inject₁)
+open import Function.Base using (_∘_)
+open import Relation.Binary.PropositionalEquality.Core as ≡
+  using (_≡_; _≢_; cong)
+
+module Algebra.Properties.Semiring.Binomial
+  {a ℓ} (S : Semiring a ℓ)
+  (open Semiring S)
+  (x y : Carrier)
+  where
+
+open import Algebra.Definitions _≈_
+open import Algebra.Properties.Semiring.Sum S
+open import Algebra.Properties.Semiring.Mult S
+open import Algebra.Properties.Semiring.Exp S
+open import Relation.Binary.Reasoning.Setoid setoid
+
+------------------------------------------------------------------------
+-- Definitions
+
+-- Note - `n` could be implicit in many of these definitions, but the
+-- code is more readable if left explicit.
+
+binomial : (n : ℕ) → Fin (suc n) → Carrier
+binomial n k = (x ^ toℕ k) * (y ^ (n ∸ toℕ k))
+
+binomialTerm : (n : ℕ) → Fin (suc n) → Carrier
+binomialTerm n k = (n C toℕ k) × binomial n k
+
+binomialExpansion : ℕ → Carrier
+binomialExpansion n = ∑[ k ≤ n ] (binomialTerm n k)
+
+term₁ : (n : ℕ) → Fin (suc (suc n)) → Carrier
+term₁ n zero    = 0#
+term₁ n (suc k) = x * (binomialTerm n k)
+
+term₂ : (n : ℕ) → Fin (suc (suc n)) → Carrier
+term₂ n k with view k
+... | ‵fromℕ     = 0#
+... | ‵inject₁ j = y * binomialTerm n j
+
+sum₁ : ℕ → Carrier
+sum₁ n = ∑[ k ≤ suc n ] term₁ n k
+
+sum₂ : ℕ → Carrier
+sum₂ n = ∑[ k ≤ suc n ] term₂ n k
+
+------------------------------------------------------------------------
+-- Properties
+
+term₂[n,n+1]≈0# : ∀ n → term₂ n (fromℕ (suc n)) ≈ 0#
+term₂[n,n+1]≈0# n rewrite view-fromℕ (suc n) = refl
+
+lemma₁ : ∀ n → x * binomialExpansion n ≈ sum₁ n
+lemma₁ n = begin
+  x * binomialExpansion n                ≈⟨ *-distribˡ-sum x (binomialTerm n) ⟩
+  ∑[ i ≤ n ] (x * binomialTerm n i)      ≈⟨ +-identityˡ _ ⟨
+  0# + ∑[ i ≤ n ] (x * binomialTerm n i) ≡⟨⟩
+  0# + ∑[ i ≤ n ] term₁ n (suc i)        ≡⟨⟩
+  sum₁ n                                 ∎
+
+lemma₂ : ∀ n → y * binomialExpansion n ≈ sum₂ n
+lemma₂ n = begin
+  y * binomialExpansion n                       ≈⟨ *-distribˡ-sum y (binomialTerm n) ⟩
+  ∑[ i ≤ n ] (y * binomialTerm n i)             ≈⟨ +-identityʳ _ ⟨
+  ∑[ i ≤ n ] (y * binomialTerm n i) + 0#        ≈⟨ +-cong (sum-cong-≋ lemma₂-inject₁) (sym (term₂[n,n+1]≈0# n)) ⟩
+  (∑[ i ≤ n ] term₂-inject₁ i) + term₂ n [n+1]  ≈⟨ sum-init-last (term₂ n) ⟨
+  sum (term₂ n)                                 ≡⟨⟩
+  sum₂ n                                        ∎
+  where
+    [n+1] = fromℕ (suc n)
+
+    term₂-inject₁ : (i : Fin (suc n)) → Carrier
+    term₂-inject₁ i = term₂ n (inject₁ i)
+
+    lemma₂-inject₁ : ∀ i → y * binomialTerm n i ≈ term₂-inject₁ i
+    lemma₂-inject₁ i rewrite view-inject₁ i = refl
+
+------------------------------------------------------------------------
+-- Next, a lemma which is independent of commutativity
+
+x*lemma : ∀ {n} (i : Fin (suc n)) →
+          x * binomialTerm n i ≈ (n C toℕ i) × binomial (suc n) (suc i)
+x*lemma {n} i = begin
+  x * binomialTerm n i                        ≡⟨⟩
+  x * ((n C k) × (x ^ k * y ^ (n ∸ k)))       ≈⟨ *-congˡ (×-assoc-* (n C k) _ _) ⟨
+  x * ((n C k) × x ^ k * y ^ (n ∸ k))         ≈⟨ *-assoc x ((n C k) × x ^ k) _ ⟨
+  (x * (n C k) × x ^ k) * y ^ (n ∸ k)         ≈⟨ *-congʳ (×-comm-* (n C k) _ _) ⟩
+  (n C k) × x ^ (suc k) * y ^ (n ∸ k)         ≡⟨⟩
+  (n C k) × x ^ (suc k) * y ^ (suc n ∸ suc k) ≈⟨ ×-assoc-* (n C k) _ _ ⟩
+  (n C k) × binomial (suc n) (suc i)          ∎
+  where k = toℕ i
+
+------------------------------------------------------------------------
+-- Next, a lemma which does require commutativity
+
+y*lemma : x * y ≈ y * x → ∀ {n : ℕ} (j : Fin n) →
+          y * binomialTerm n (suc j) ≈ (n C toℕ (suc j)) × binomial (suc n) (suc (inject₁ j))
+y*lemma x*y≈y*x {n} j = begin
+  y * binomialTerm n (suc j)
+    ≈⟨ ×-comm-* nC[j+1] y (binomial n (suc j)) ⟩
+  nC[j+1] × (y * binomial n (suc j))
+    ≈⟨ ×-congʳ nC[j+1] (y*x^m*y^n≈x^m*y^[n+1] x*y≈y*x [j+1] [n-j-1]) ⟩
+  nC[j+1] × (x ^ [j+1] * y ^ [n-j])
+    ≈⟨ ×-congʳ nC[j+1] (*-congʳ (^-congʳ x (cong suc k≡j))) ⟨
+  nC[j+1] × (x ^ [k+1] * y ^ [n-j])
+    ≈⟨ ×-congʳ nC[j+1] (*-congˡ (^-congʳ y [n-k]≡[n-j])) ⟨
+  nC[j+1] × (x ^ [k+1] * y ^ [n-k])
+    ≡⟨⟩
+  nC[j+1] × (x ^ [k+1] * y ^ [n+1]-[k+1])
+    ≡⟨⟩
+  (n C toℕ (suc j)) × binomial (suc n) (suc i) ∎
+  where
+    i           = inject₁ j
+    k           = toℕ i
+    [k+1]       = ℕ.suc k
+    [j+1]       = toℕ (suc j)
+    [n-k]       = n ∸ k
+    [n+1]-[k+1] = [n-k]
+    [n-j-1]     = n ∸ [j+1]
+    [n-j]       = ℕ.suc [n-j-1]
+    nC[j+1]     = n C [j+1]
+
+    k≡j : k ≡ toℕ j
+    k≡j = toℕ-inject₁ j
+
+    [n-k]≡[n-j] : [n-k] ≡ [n-j]
+    [n-k]≡[n-j] = ≡.trans (cong (n ∸_) k≡j) (+-∸-assoc 1 (toℕ<n j))
+
+------------------------------------------------------------------------
+-- Now, a lemma characterising the sum of the term₁ and term₂ expressions
+
+private
+  n<ᵇ1+n : ∀ n → (n ℕ.<ᵇ suc n) ≡ true
+  n<ᵇ1+n n with true ← n ℕ.<ᵇ suc n | _ ← <⇒<ᵇ (n<1+n n) = ≡.refl
+
+term₁+term₂≈term : x * y ≈ y * x → ∀ n i → term₁ n i + term₂ n i ≈ binomialTerm (suc n) i
+
+term₁+term₂≈term x*y≈y*x n 0F = begin
+  term₁ n 0F + term₂ n 0F      ≡⟨⟩
+  0# + y * (1 × (1# * y ^ n))  ≈⟨ +-identityˡ _ ⟩
+  y * (1 × (1# * y ^ n))       ≈⟨ *-congˡ (+-identityʳ (1# * y ^ n)) ⟩
+  y * (1# * y ^ n)             ≈⟨ *-congˡ (*-identityˡ (y ^ n)) ⟩
+  y * y ^ n                    ≡⟨⟩
+  y ^ suc n                    ≈⟨ *-identityˡ (y ^ suc n) ⟨
+  1# * y ^ suc n               ≈⟨ +-identityʳ (1# * y ^ suc n) ⟨
+  1 × (1# * y ^ suc n)         ≡⟨⟩
+  binomialTerm (suc n) 0F      ∎
+
+term₁+term₂≈term x*y≈y*x n (suc i) with view i
+... | ‵fromℕ {n}
+{- remembering that i = fromℕ n, definitionally -}
+  rewrite toℕ-fromℕ n
+    | nCn≡1 n
+    | n∸n≡0 n
+    | n<ᵇ1+n n
+    = begin
+  x * ((x ^ n * 1#) + 0#) + 0# ≈⟨ +-identityʳ _ ⟩
+  x * ((x ^ n * 1#) + 0#)      ≈⟨ *-congˡ (+-identityʳ _) ⟩
+  x * (x ^ n * 1#)             ≈⟨ *-assoc _ _ _ ⟨
+  x * x ^ n * 1#               ≈⟨ +-identityʳ _ ⟨
+  1 × (x * x ^ n * 1#)         ∎
+
+... | ‵inject₁ j
+{- remembering that i = inject₁ j, definitionally -}
+    = begin
+  (x * binomialTerm n i) + (y * binomialTerm n (suc j))
+    ≈⟨ +-cong (x*lemma i) (y*lemma x*y≈y*x j) ⟩
+  (nCk × [x^k+1]*[y^n-k]) + (nC[j+1] × [x^k+1]*[y^n-k])
+    ≈⟨ +-congˡ (×-congˡ nC[k+1]≡nC[j+1]) ⟨
+  (nCk × [x^k+1]*[y^n-k]) + (nC[k+1] × [x^k+1]*[y^n-k])
+    ≈⟨ ×-homo-+ [x^k+1]*[y^n-k] nCk nC[k+1] ⟨
+  (nCk ℕ.+ nC[k+1]) × [x^k+1]*[y^n-k]
+    ≡⟨ cong (_× [x^k+1]*[y^n-k]) (nCk+nC[k+1]≡[n+1]C[k+1] n k) ⟩
+  ((suc n) C (suc k)) × [x^k+1]*[y^n-k]
+    ≡⟨⟩
+  binomialTerm (suc n) (suc i) ∎
+  where
+    k               = toℕ i
+    [k+1]           = ℕ.suc k
+    [j+1]           = toℕ (suc j)
+    nCk             = n C k
+    nC[k+1]         = n C [k+1]
+    nC[j+1]         = n C [j+1]
+    [x^k+1]*[y^n-k] = binomial (suc n) (suc i)
+
+    nC[k+1]≡nC[j+1] : nC[k+1] ≡ nC[j+1]
+    nC[k+1]≡nC[j+1] = cong ((n C_) ∘ suc) (toℕ-inject₁ j)
+
+------------------------------------------------------------------------
+-- Finally, the main result
+
+theorem : x * y ≈ y * x → ∀ n → (x + y) ^ n ≈ binomialExpansion n
+theorem x*y≈y*x zero    = begin
+  (x + y) ^ 0                     ≡⟨⟩
+  1#                              ≈⟨ ×-homo-1 1# ⟨
+  1 × 1#                          ≈⟨ *-identityʳ (1 × 1#) ⟨
+  (1 × 1#) * 1#                   ≈⟨ ×-assoc-* 1 1# 1# ⟩
+  1 × (1# * 1#)                   ≡⟨⟩
+  1 × (x ^ 0 * y ^ 0)             ≈⟨ +-identityʳ _ ⟨
+  1 × (x ^ 0 * y ^ 0) + 0#        ≡⟨⟩
+  (0 C 0) × (x ^ 0 * y ^ 0) + 0#  ≡⟨⟩
+  binomialExpansion 0             ∎
+theorem x*y≈y*x n+1@(suc n) = begin
+  (x + y) ^ n+1                                     ≡⟨⟩
+  (x + y) * (x + y) ^ n                             ≈⟨ *-congˡ (theorem x*y≈y*x n) ⟩
+  (x + y) * binomialExpansion n                     ≈⟨ distribʳ _ _ _ ⟩
+  x * binomialExpansion n + y * binomialExpansion n ≈⟨ +-cong (lemma₁ n) (lemma₂ n) ⟩
+  sum₁ n + sum₂ n                                   ≈⟨ ∑-distrib-+ (term₁ n) (term₂ n) ⟨
+  ∑[ i ≤ n+1 ] (term₁ n i + term₂ n i)              ≈⟨ sum-cong-≋ (term₁+term₂≈term x*y≈y*x n) ⟩
+  ∑[ i ≤ n+1 ] binomialTerm n+1 i                   ≡⟨⟩
+  binomialExpansion n+1                             ∎
diff --git a/src/Algebra/Properties/Semiring/Divisibility.agda b/src/Algebra/Properties/Semiring/Divisibility.agda
index a1b2ff2e9b..8cdcbe7e62 100644
--- a/src/Algebra/Properties/Semiring/Divisibility.agda
+++ b/src/Algebra/Properties/Semiring/Divisibility.agda
@@ -8,7 +8,7 @@
 
 open import Algebra using (Semiring)
 import Algebra.Properties.Monoid.Divisibility as MonoidDivisibility
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 
 module Algebra.Properties.Semiring.Divisibility
@@ -25,6 +25,8 @@ open MonoidDivisibility *-monoid public
 ------------------------------------------------------------------------
 -- Divisibility properties specific to semirings.
 
+infixr 8 _∣0
+
 _∣0 : ∀ x → x ∣ 0#
 x ∣0 = 0# , zeroˡ x
 
diff --git a/src/Algebra/Properties/Semiring/Exp.agda b/src/Algebra/Properties/Semiring/Exp.agda
index df467b1f66..f4adeee842 100644
--- a/src/Algebra/Properties/Semiring/Exp.agda
+++ b/src/Algebra/Properties/Semiring/Exp.agda
@@ -8,8 +8,8 @@
 
 open import Algebra
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (_Preserves_⟶_; _Preserves₂_⟶_⟶_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 import Data.Nat.Properties as ℕ
 
 module Algebra.Properties.Semiring.Exp
@@ -57,16 +57,16 @@ y*x^m*y^n≈x^m*y^[n+1] {x} {y} x*y≈y*x = helper
       y * (x ^ ℕ.zero * y ^ n)  ≡⟨⟩
       y * (1# * y ^ n)          ≈⟨ *-congˡ (*-identityˡ (y ^ n)) ⟩
       y * (y ^ n)               ≡⟨⟩
-      y ^ (suc n)               ≈˘⟨ *-identityˡ (y ^ suc n) ⟩
+      y ^ (suc n)               ≈⟨ *-identityˡ (y ^ suc n) ⟨
       1# * y ^ (suc n)          ≡⟨⟩
       x ^ ℕ.zero * y ^ (suc n)  ∎
     helper (suc m) n = begin
       y * (x ^ suc m * y ^ n)    ≡⟨⟩
       y * ((x * x ^ m) * y ^ n)  ≈⟨ *-congˡ (*-assoc x (x ^ m) (y ^ n)) ⟩
-      y * (x * (x ^ m * y ^ n))  ≈˘⟨ *-assoc y x (x ^ m * y ^ n) ⟩
-      y * x * (x ^ m * y ^ n)    ≈˘⟨ *-congʳ x*y≈y*x ⟩
+      y * (x * (x ^ m * y ^ n))  ≈⟨ *-assoc y x (x ^ m * y ^ n) ⟨
+      y * x * (x ^ m * y ^ n)    ≈⟨ *-congʳ x*y≈y*x ⟨
       x * y * (x ^ m * y ^ n)    ≈⟨ *-assoc x y _ ⟩
       x * (y * (x ^ m * y ^ n))  ≈⟨ *-congˡ (helper m n) ⟩
-      x * (x ^ m * y ^ suc n)    ≈˘⟨ *-assoc x (x ^ m) (y ^ suc n) ⟩
+      x * (x ^ m * y ^ suc n)    ≈⟨ *-assoc x (x ^ m) (y ^ suc n) ⟨
       (x * x ^ m) * y ^ suc n    ≡⟨⟩
       x ^ suc m * y ^ suc n      ∎
diff --git a/src/Algebra/Properties/Semiring/Exp/TCOptimised.agda b/src/Algebra/Properties/Semiring/Exp/TCOptimised.agda
index 23a11524cb..5642bde51c 100644
--- a/src/Algebra/Properties/Semiring/Exp/TCOptimised.agda
+++ b/src/Algebra/Properties/Semiring/Exp/TCOptimised.agda
@@ -9,7 +9,7 @@
 open import Algebra
 open import Data.Nat.Base as ℕ using (zero; suc)
 import Data.Nat.Properties as ℕ
-open import Relation.Binary
+open import Relation.Binary.Core using (_Preserves_⟶_; _Preserves₂_⟶_⟶_)
 open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 module Algebra.Properties.Semiring.Exp.TCOptimised
diff --git a/src/Algebra/Properties/Semiring/Exp/TailRecursiveOptimised.agda b/src/Algebra/Properties/Semiring/Exp/TailRecursiveOptimised.agda
index 836c794e10..1ad573866d 100644
--- a/src/Algebra/Properties/Semiring/Exp/TailRecursiveOptimised.agda
+++ b/src/Algebra/Properties/Semiring/Exp/TailRecursiveOptimised.agda
@@ -9,7 +9,7 @@
 open import Algebra
 open import Data.Nat.Base as ℕ using (zero; suc)
 import Data.Nat.Properties as ℕ
-open import Relation.Binary
+open import Relation.Binary.Core using (_Preserves_⟶_; _Preserves₂_⟶_⟶_)
 
 module Algebra.Properties.Semiring.Exp.TailRecursiveOptimised
   {a ℓ} (S : Semiring a ℓ) where
@@ -72,7 +72,7 @@ x^[m+1]≈x*[x^m] x m = x^[m]*[x*y]≈x*x^[m]*y x m 1#
 x^[m+n]≈[x^m]*[x^n] : ∀ x m n → x ^ (m ℕ.+ n) ≈ x ^ m * x ^ n
 x^[m+n]≈[x^m]*[x^n] x m n = begin
   x ^ (m  ℕ.+ n)   ≈⟨ x^[m+n]*y≈x^[m]*x^[n]*y x m n 1# ⟩
-  x ^[ m ]* (x ^ n) ≈˘⟨ x^m*y≈x^[m]*y x m (x ^ n) ⟩
+  x ^[ m ]* (x ^ n) ≈⟨ x^m*y≈x^[m]*y x m (x ^ n) ⟨
   x ^ m * x ^ n    ∎
 
 ^≈^ᵘ : ∀ x m → x ^ m ≈ x ^ᵘ m
diff --git a/src/Algebra/Properties/Semiring/Mult.agda b/src/Algebra/Properties/Semiring/Mult.agda
index 3121e8a8e8..6301d274c6 100644
--- a/src/Algebra/Properties/Semiring/Mult.agda
+++ b/src/Algebra/Properties/Semiring/Mult.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Algebra
+open import Algebra.Bundles using (Semiring)
 open import Data.Nat.Base as ℕ using (zero; suc)
 
 module Algebra.Properties.Semiring.Mult
@@ -14,6 +14,7 @@ module Algebra.Properties.Semiring.Mult
 
 open Semiring S renaming (zero to *-zero)
 open import Relation.Binary.Reasoning.Setoid setoid
+open import Algebra.Definitions _≈_ using (_IdempotentOn_)
 
 ------------------------------------------------------------------------
 -- Re-export definition from the monoid
@@ -23,21 +24,15 @@ open import Algebra.Properties.Monoid.Mult +-monoid public
 ------------------------------------------------------------------------
 -- Properties of _×_
 
--- (_× 1#) is homomorphic with respect to _ℕ.*_/_*_.
+-- (0 ×_) is (0# *_)
 
-×1-homo-* : ∀ m n → (m ℕ.* n) × 1# ≈ (m × 1#) * (n × 1#)
-×1-homo-* 0       n = sym (zeroˡ (n × 1#))
-×1-homo-* (suc m) n = begin
-  (n ℕ.+ m ℕ.* n) × 1#                ≈⟨  ×-homo-+ 1# n (m ℕ.* n) ⟩
-  n × 1# + (m ℕ.* n) × 1#             ≈⟨  +-congˡ (×1-homo-* m n) ⟩
-  n × 1# + (m × 1#) * (n × 1#)        ≈˘⟨ +-congʳ (*-identityˡ _) ⟩
-  1# * (n × 1#) + (m × 1#) * (n × 1#) ≈˘⟨ distribʳ (n × 1#) 1# (m × 1#) ⟩
-  (1# + m × 1#) * (n × 1#)            ∎
+×-homo-0# : ∀ x → 0 × x ≈ 0# * x
+×-homo-0# x = sym (zeroˡ x)
 
--- (1 ×_) is the identity
+-- (1 ×_) is (1# *_)
 
-1×-identityʳ : ∀ x → 1 × x ≈ x
-1×-identityʳ = +-identityʳ
+×-homo-1# : ∀ x → 1 × x ≈ 1# * x
+×-homo-1# x = trans (×-homo-1 x) (sym (*-identityˡ x))
 
 -- (n ×_) commutes with _*_
 
@@ -60,3 +55,32 @@ open import Algebra.Properties.Monoid.Mult +-monoid public
   x * y + (n × x) * y   ≈⟨ +-congˡ (×-assoc-* n _ _) ⟩
   x * y + n × (x * y)   ≡⟨⟩
   suc n × (x * y)       ∎
+
+-- (_× x) is homomorphic with respect to _ℕ.*_/_*_ for idempotent x.
+
+idem-×-homo-* : ∀ m n {x} → (_*_ IdempotentOn x) → (m × x) * (n × x) ≈ (m ℕ.* n) × x
+idem-×-homo-* m n {x} idem = begin
+  (m × x) * (n × x)   ≈⟨ ×-assoc-* m x (n × x) ⟩
+  m × (x * (n × x))   ≈⟨ ×-congʳ m (×-comm-* n x x) ⟩
+  m × (n × (x * x))   ≈⟨ ×-assocˡ _ m n ⟩
+  (m ℕ.* n) × (x * x) ≈⟨ ×-congʳ (m ℕ.* n) idem ⟩
+  (m ℕ.* n) × x       ∎
+
+-- (_× 1#) is homomorphic with respect to _ℕ.*_/_*_.
+
+×1-homo-* : ∀ m n → (m ℕ.* n) × 1# ≈ (m × 1#) * (n × 1#)
+×1-homo-* m n = sym (idem-×-homo-* m n (*-identityʳ 1#))
+
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.1
+
+1×-identityʳ = ×-homo-1
+{-# WARNING_ON_USAGE 1×-identityʳ
+"Warning: 1×-identityʳ was deprecated in v2.1.
+Please use ×-homo-1 instead. "
+#-}
diff --git a/src/Algebra/Properties/Semiring/Mult/TCOptimised.agda b/src/Algebra/Properties/Semiring/Mult/TCOptimised.agda
index 4ea0e2939b..6f1e538e7d 100644
--- a/src/Algebra/Properties/Semiring/Mult/TCOptimised.agda
+++ b/src/Algebra/Properties/Semiring/Mult/TCOptimised.agda
@@ -30,7 +30,7 @@ open import Algebra.Properties.Monoid.Mult.TCOptimised +-monoid public
 
 ×1-homo-* : ∀ m n → (m ℕ.* n) × 1# ≈ (m × 1#) * (n × 1#)
 ×1-homo-* m n = begin
-  (m ℕ.* n) ×  1#        ≈˘⟨ ×ᵤ≈× (m ℕ.* n) 1# ⟩
+  (m ℕ.* n) ×  1#        ≈⟨ ×ᵤ≈× (m ℕ.* n) 1# ⟨
   (m ℕ.* n) ×ᵤ 1#        ≈⟨  U.×1-homo-* m n ⟩
   (m ×ᵤ 1#) * (n ×ᵤ 1#)  ≈⟨  *-cong (×ᵤ≈× m 1#) (×ᵤ≈× n 1#) ⟩
   (m ×  1#) * (n ×  1#)  ∎
diff --git a/src/Algebra/Properties/Semiring/Primality.agda b/src/Algebra/Properties/Semiring/Primality.agda
index 2b0d226491..210d9fb1a0 100644
--- a/src/Algebra/Properties/Semiring/Primality.agda
+++ b/src/Algebra/Properties/Semiring/Primality.agda
@@ -9,7 +9,7 @@
 open import Algebra using (Semiring)
 open import Data.Sum.Base using (reduce)
 open import Function.Base using (flip)
-open import Relation.Binary using (Symmetric)
+open import Relation.Binary.Definitions using (Symmetric)
 
 module Algebra.Properties.Semiring.Primality
   {a ℓ} (R : Semiring a ℓ)
diff --git a/src/Algebra/Solver/CommutativeMonoid.agda b/src/Algebra/Solver/CommutativeMonoid.agda
index 69d1a67b0b..04d4d372e6 100644
--- a/src/Algebra/Solver/CommutativeMonoid.agda
+++ b/src/Algebra/Solver/CommutativeMonoid.agda
@@ -14,24 +14,29 @@ module Algebra.Solver.CommutativeMonoid {m₁ m₂} (M : CommutativeMonoid m₁
 
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.Maybe.Base as Maybe
-  using (Maybe; decToMaybe; From-just; from-just)
+  using (Maybe; From-just; from-just)
 open import Data.Nat as ℕ using (ℕ; zero; suc; _+_)
 open import Data.Nat.GeneralisedArithmetic using (fold)
-open import Data.Product using (_×_; uncurry)
+open import Data.Product.Base using (_×_; uncurry)
 open import Data.Vec.Base using (Vec; []; _∷_; lookup; replicate)
 
 open import Function.Base using (_∘_)
 
-import Relation.Binary.Reasoning.Setoid as EqReasoning
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 import Relation.Binary.Reflection as Reflection
 import Relation.Nullary.Decidable as Dec
 import Data.Vec.Relation.Binary.Pointwise.Inductive as Pointwise
 
-open import Relation.Binary.PropositionalEquality as P using (_≡_; decSetoid)
-open import Relation.Nullary.Decidable using (Dec)
+open import Relation.Binary.Consequences using (dec⇒weaklyDec)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Nullary.Decidable as Dec using (Dec)
 
 open CommutativeMonoid M
-open EqReasoning setoid
+open ≈-Reasoning setoid
+
+private
+  variable
+    n : ℕ
 
 ------------------------------------------------------------------------
 -- Monoid expressions
@@ -55,7 +60,7 @@ Env n = Vec Carrier n
 -- The semantics of an expression is a function from an environment to
 -- a value.
 
-⟦_⟧ : ∀ {n} → Expr n → Env n → Carrier
+⟦_⟧ : Expr n → Env n → Carrier
 ⟦ var x   ⟧ ρ = lookup ρ x
 ⟦ id      ⟧ ρ = ε
 ⟦ e₁ ⊕ e₂ ⟧ ρ = ⟦ e₁ ⟧ ρ ∙ ⟦ e₂ ⟧ ρ
@@ -70,27 +75,27 @@ Normal n = Vec ℕ n
 
 -- The semantics of a normal form.
 
-⟦_⟧⇓ : ∀ {n} → Normal n → Env n → Carrier
+⟦_⟧⇓ : Normal n → Env n → Carrier
 ⟦ []    ⟧⇓ _ = ε
-⟦ n ∷ v ⟧⇓ (a ∷ ρ) = fold (⟦ v ⟧⇓ ρ) (λ b → a ∙ b) n
+⟦ n ∷ v ⟧⇓ (a ∷ ρ) = fold (⟦ v ⟧⇓ ρ) (a ∙_) n
 
 ------------------------------------------------------------------------
 -- Constructions on normal forms
 
 -- The empty bag.
 
-empty : ∀{n} → Normal n
-empty = replicate 0
+empty : Normal n
+empty = replicate _ 0
 
 -- A singleton bag.
 
-sg : ∀{n} (i : Fin n) → Normal n
+sg : (i : Fin n) → Normal n
 sg zero    = 1 ∷ empty
 sg (suc i) = 0 ∷ sg i
 
 -- The composition of normal forms.
 
-_•_  : ∀{n} (v w : Normal n) → Normal n
+_•_  : (v w : Normal n) → Normal n
 []      • []      = []
 (l ∷ v) • (m ∷ w) = l + m ∷ v • w
 
@@ -99,13 +104,13 @@ _•_  : ∀{n} (v w : Normal n) → Normal n
 
 -- The empty bag stands for the unit ε.
 
-empty-correct : ∀{n} (ρ : Env n) → ⟦ empty ⟧⇓ ρ ≈ ε
+empty-correct : (ρ : Env n) → ⟦ empty ⟧⇓ ρ ≈ ε
 empty-correct [] = refl
 empty-correct (a ∷ ρ) = empty-correct ρ
 
 -- The singleton bag stands for a single variable.
 
-sg-correct : ∀{n} (x : Fin n) (ρ : Env n) →  ⟦ sg x ⟧⇓ ρ ≈ lookup ρ x
+sg-correct : (x : Fin n) (ρ : Env n) →  ⟦ sg x ⟧⇓ ρ ≈ lookup ρ x
 sg-correct zero (x ∷ ρ) = begin
     x ∙ ⟦ empty ⟧⇓ ρ   ≈⟨ ∙-congˡ (empty-correct ρ) ⟩
     x ∙ ε              ≈⟨ identityʳ _ ⟩
@@ -114,7 +119,7 @@ sg-correct (suc x) (m ∷ ρ) = sg-correct x ρ
 
 -- Normal form composition corresponds to the composition of the monoid.
 
-comp-correct : ∀ {n} (v w : Normal n) (ρ : Env n) →
+comp-correct : (v w : Normal n) (ρ : Env n) →
               ⟦ v • w ⟧⇓ ρ ≈ (⟦ v ⟧⇓ ρ ∙ ⟦ w ⟧⇓ ρ)
 comp-correct [] [] ρ =  sym (identityˡ _)
 comp-correct (l ∷ v) (m ∷ w) (a ∷ ρ) = lemma l m (comp-correct v w ρ)
@@ -136,14 +141,14 @@ comp-correct (l ∷ v) (m ∷ w) (a ∷ ρ) = lemma l m (comp-correct v w ρ)
 
 -- A normaliser.
 
-normalise : ∀ {n} → Expr n → Normal n
+normalise : Expr n → Normal n
 normalise (var x)   = sg x
 normalise id        = empty
 normalise (e₁ ⊕ e₂) = normalise e₁ • normalise e₂
 
 -- The normaliser preserves the semantics of the expression.
 
-normalise-correct : ∀ {n} (e : Expr n) (ρ : Env n) →
+normalise-correct : (e : Expr n) (ρ : Env n) →
     ⟦ normalise e ⟧⇓ ρ ≈ ⟦ e ⟧ ρ
 normalise-correct (var x)   ρ = sg-correct x ρ
 normalise-correct id        ρ = empty-correct ρ
@@ -171,21 +176,21 @@ open module R = Reflection
 
 infix 5 _≟_
 
-_≟_ : ∀ {n} (nf₁ nf₂ : Normal n) → Dec (nf₁ ≡ nf₂)
+_≟_ : (nf₁ nf₂ : Normal n) → Dec (nf₁ ≡ nf₂)
 nf₁ ≟ nf₂ = Dec.map Pointwise-≡↔≡ (decidable ℕ._≟_ nf₁ nf₂)
   where open Pointwise
 
 -- We can also give a sound, but not necessarily complete, procedure
 -- for determining if two expressions have the same semantics.
 
-prove′ : ∀ {n} (e₁ e₂ : Expr n) → Maybe (∀ ρ → ⟦ e₁ ⟧ ρ ≈ ⟦ e₂ ⟧ ρ)
+prove′ : (e₁ e₂ : Expr n) → Maybe (∀ ρ → ⟦ e₁ ⟧ ρ ≈ ⟦ e₂ ⟧ ρ)
 prove′ e₁ e₂ =
-  Maybe.map lemma (decToMaybe (normalise e₁ ≟ normalise e₂))
+  Maybe.map lemma (dec⇒weaklyDec _≟_ (normalise e₁) (normalise e₂))
   where
   lemma : normalise e₁ ≡ normalise e₂ → ∀ ρ → ⟦ e₁ ⟧ ρ ≈ ⟦ e₂ ⟧ ρ
   lemma eq ρ =
     R.prove ρ e₁ e₂ (begin
-      ⟦ normalise e₁ ⟧⇓ ρ  ≡⟨ P.cong (λ e → ⟦ e ⟧⇓ ρ) eq ⟩
+      ⟦ normalise e₁ ⟧⇓ ρ  ≡⟨ ≡.cong (λ e → ⟦ e ⟧⇓ ρ) eq ⟩
       ⟦ normalise e₂ ⟧⇓ ρ  ∎)
 
 -- This procedure can be combined with from-just.
diff --git a/src/Algebra/Solver/CommutativeMonoid/Example.agda b/src/Algebra/Solver/CommutativeMonoid/Example.agda
index 83351df044..e59f5b1e1f 100644
--- a/src/Algebra/Solver/CommutativeMonoid/Example.agda
+++ b/src/Algebra/Solver/CommutativeMonoid/Example.agda
@@ -8,7 +8,7 @@
 
 module Algebra.Solver.CommutativeMonoid.Example where
 
-open import Relation.Binary.PropositionalEquality using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 open import Data.Bool.Base using (_∨_)
 open import Data.Bool.Properties using (∨-commutativeMonoid)
diff --git a/src/Algebra/Solver/IdempotentCommutativeMonoid.agda b/src/Algebra/Solver/IdempotentCommutativeMonoid.agda
index a0704ba95b..00b8824975 100644
--- a/src/Algebra/Solver/IdempotentCommutativeMonoid.agda
+++ b/src/Algebra/Solver/IdempotentCommutativeMonoid.agda
@@ -8,31 +8,37 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Algebra
+open import Algebra.Bundles using (IdempotentCommutativeMonoid)
 
 open import Data.Bool as Bool using (Bool; true; false; if_then_else_; _∨_)
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.Maybe.Base as Maybe
-  using (Maybe; decToMaybe; From-just; from-just)
+  using (Maybe; From-just; from-just)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc; _+_)
-open import Data.Product using (_×_; uncurry)
+open import Data.Product.Base using (_×_; uncurry)
 open import Data.Vec.Base using (Vec; []; _∷_; lookup; replicate)
 
 open import Function.Base using (_∘_)
 
-import Relation.Binary.Reasoning.Setoid  as EqReasoning
+import Relation.Binary.Reasoning.Setoid  as ≈-Reasoning
 import Relation.Binary.Reflection            as Reflection
-import Relation.Nullary.Decidable            as Dec
 import Data.Vec.Relation.Binary.Pointwise.Inductive as Pointwise
 
-open import Relation.Binary.PropositionalEquality as P using (_≡_; decSetoid)
-open import Relation.Nullary.Decidable using (Dec)
+open import Relation.Binary.Consequences using (dec⇒weaklyDec)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
+open import Relation.Nullary.Decidable as Dec using (Dec)
+
 
 module Algebra.Solver.IdempotentCommutativeMonoid
   {m₁ m₂} (M : IdempotentCommutativeMonoid m₁ m₂) where
 
 open IdempotentCommutativeMonoid M
-open EqReasoning setoid
+open ≈-Reasoning setoid
+
+private
+  variable
+    n : ℕ
 
 ------------------------------------------------------------------------
 -- Monoid expressions
@@ -71,7 +77,7 @@ Normal n = Vec Bool n
 
 -- The semantics of a normal form.
 
-⟦_⟧⇓ : ∀ {n} → Normal n → Env n → Carrier
+⟦_⟧⇓ : Normal n → Env n → Carrier
 ⟦ []    ⟧⇓ _ = ε
 ⟦ b ∷ v ⟧⇓ (a ∷ ρ) = if b then a ∙ (⟦ v ⟧⇓ ρ) else (⟦ v ⟧⇓ ρ)
 
@@ -80,18 +86,18 @@ Normal n = Vec Bool n
 
 -- The empty set.
 
-empty : ∀{n} → Normal n
-empty = replicate false
+empty : Normal n
+empty = replicate _ false
 
 -- A singleton set.
 
-sg : ∀{n} (i : Fin n) → Normal n
+sg : (i : Fin n) → Normal n
 sg zero    = true ∷ empty
 sg (suc i) = false ∷ sg i
 
 -- The composition of normal forms.
 
-_•_  : ∀{n} (v w : Normal n) → Normal n
+_•_ : (v w : Normal n) → Normal n
 []      • []      = []
 (l ∷ v) • (m ∷ w) = (l ∨ m) ∷ v • w
 
@@ -100,13 +106,13 @@ _•_  : ∀{n} (v w : Normal n) → Normal n
 
 -- The empty set stands for the unit ε.
 
-empty-correct : ∀{n} (ρ : Env n) → ⟦ empty ⟧⇓ ρ ≈ ε
+empty-correct : (ρ : Env n) → ⟦ empty ⟧⇓ ρ ≈ ε
 empty-correct []      = refl
 empty-correct (a ∷ ρ) = empty-correct ρ
 
 -- The singleton set stands for a single variable.
 
-sg-correct : ∀{n} (x : Fin n) (ρ : Env n) →  ⟦ sg x ⟧⇓ ρ ≈ lookup ρ x
+sg-correct : (x : Fin n) (ρ : Env n) → ⟦ sg x ⟧⇓ ρ ≈ lookup ρ x
 sg-correct zero (x ∷ ρ) = begin
     x ∙ ⟦ empty ⟧⇓ ρ   ≈⟨ ∙-congˡ (empty-correct ρ) ⟩
     x ∙ ε              ≈⟨ identityʳ _ ⟩
@@ -132,7 +138,7 @@ distr a b c = begin
     a ∙ (b ∙ (a ∙ c))  ≈⟨ sym (assoc _ _ _) ⟩
     (a ∙ b) ∙ (a ∙ c)  ∎
 
-comp-correct : ∀ {n} (v w : Normal n) (ρ : Env n) →
+comp-correct : ∀ (v w : Normal n) (ρ : Env n) →
               ⟦ v • w ⟧⇓ ρ ≈ (⟦ v ⟧⇓ ρ ∙ ⟦ w ⟧⇓ ρ)
 comp-correct [] [] ρ = sym (identityˡ _)
 comp-correct (true ∷ v) (true ∷ w) (a ∷ ρ) =
@@ -149,14 +155,14 @@ comp-correct (false ∷ v) (false ∷ w) (a ∷ ρ) =
 
 -- A normaliser.
 
-normalise : ∀ {n} → Expr n → Normal n
+normalise : Expr n → Normal n
 normalise (var x)   = sg x
 normalise id        = empty
 normalise (e₁ ⊕ e₂) = normalise e₁ • normalise e₂
 
 -- The normaliser preserves the semantics of the expression.
 
-normalise-correct : ∀ {n} (e : Expr n) (ρ : Env n) →
+normalise-correct : (e : Expr n) (ρ : Env n) →
     ⟦ normalise e ⟧⇓ ρ ≈ ⟦ e ⟧ ρ
 normalise-correct (var x)   ρ = sg-correct x ρ
 normalise-correct id        ρ = empty-correct ρ
@@ -184,21 +190,21 @@ open module R = Reflection
 
 infix 5 _≟_
 
-_≟_ : ∀ {n} (nf₁ nf₂ : Normal n) → Dec (nf₁ ≡ nf₂)
+_≟_ : (nf₁ nf₂ : Normal n) → Dec (nf₁ ≡ nf₂)
 nf₁ ≟ nf₂ = Dec.map Pointwise-≡↔≡ (decidable Bool._≟_ nf₁ nf₂)
   where open Pointwise
 
 -- We can also give a sound, but not necessarily complete, procedure
 -- for determining if two expressions have the same semantics.
 
-prove′ : ∀ {n} (e₁ e₂ : Expr n) → Maybe (∀ ρ → ⟦ e₁ ⟧ ρ ≈ ⟦ e₂ ⟧ ρ)
+prove′ : (e₁ e₂ : Expr n) → Maybe (∀ ρ → ⟦ e₁ ⟧ ρ ≈ ⟦ e₂ ⟧ ρ)
 prove′ e₁ e₂ =
-  Maybe.map lemma (decToMaybe (normalise e₁ ≟ normalise e₂))
+  Maybe.map lemma (dec⇒weaklyDec _≟_ (normalise e₁) (normalise e₂))
   where
   lemma : normalise e₁ ≡ normalise e₂ → ∀ ρ → ⟦ e₁ ⟧ ρ ≈ ⟦ e₂ ⟧ ρ
   lemma eq ρ =
     R.prove ρ e₁ e₂ (begin
-      ⟦ normalise e₁ ⟧⇓ ρ  ≡⟨ P.cong (λ e → ⟦ e ⟧⇓ ρ) eq ⟩
+      ⟦ normalise e₁ ⟧⇓ ρ  ≡⟨ ≡.cong (λ e → ⟦ e ⟧⇓ ρ) eq ⟩
       ⟦ normalise e₂ ⟧⇓ ρ  ∎)
 
 -- This procedure can be combined with from-just.
diff --git a/src/Algebra/Solver/IdempotentCommutativeMonoid/Example.agda b/src/Algebra/Solver/IdempotentCommutativeMonoid/Example.agda
index 7a70fb8cfc..962abd6ebc 100644
--- a/src/Algebra/Solver/IdempotentCommutativeMonoid/Example.agda
+++ b/src/Algebra/Solver/IdempotentCommutativeMonoid/Example.agda
@@ -9,7 +9,7 @@
 
 module Algebra.Solver.IdempotentCommutativeMonoid.Example where
 
-open import Relation.Binary.PropositionalEquality using (_≡_)
+import Algebra.Solver.IdempotentCommutativeMonoid as ICM-Solver
 
 open import Data.Bool.Base using (_∨_)
 open import Data.Bool.Properties using (∨-idempotentCommutativeMonoid)
@@ -17,8 +17,9 @@ open import Data.Bool.Properties using (∨-idempotentCommutativeMonoid)
 open import Data.Fin.Base using (zero; suc)
 open import Data.Vec.Base using ([]; _∷_)
 
-open import Algebra.Solver.IdempotentCommutativeMonoid
-  ∨-idempotentCommutativeMonoid
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+
+open ICM-Solver ∨-idempotentCommutativeMonoid
 
 test : ∀ x y z → (x ∨ y) ∨ (x ∨ z) ≡ (z ∨ y) ∨ x
 test a b c = let _∨_ = _⊕_ in
diff --git a/src/Algebra/Solver/Monoid.agda b/src/Algebra/Solver/Monoid.agda
index 3006374347..7debc4e1aa 100644
--- a/src/Algebra/Solver/Monoid.agda
+++ b/src/Algebra/Solver/Monoid.agda
@@ -15,17 +15,17 @@ import Data.Fin.Properties as Fin
 open import Data.List.Base hiding (lookup)
 import Data.List.Relation.Binary.Equality.DecPropositional as ListEq
 open import Data.Maybe.Base as Maybe
-  using (Maybe; decToMaybe; From-just; from-just)
+  using (Maybe; From-just; from-just)
 open import Data.Nat.Base using (ℕ)
-open import Data.Product
+open import Data.Product.Base using (_×_; uncurry)
 open import Data.Vec.Base using (Vec; lookup)
 open import Function.Base using (_∘_; _$_)
-open import Relation.Binary using (Decidable)
+open import Relation.Binary.Consequences using (dec⇒weaklyDec)
+open import Relation.Binary.Definitions using (DecidableEquality)
 
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong)
 import Relation.Binary.Reflection
-open import Relation.Nullary
-import Relation.Nullary.Decidable as Dec
+import Relation.Nullary.Decidable.Core as Dec
 
 open Monoid M
 open import Relation.Binary.Reasoning.Setoid setoid
@@ -114,7 +114,7 @@ open module R = Relation.Binary.Reflection
 
 infix 5 _≟_
 
-_≟_ : ∀ {n} → Decidable {A = Normal n} _≡_
+_≟_ : ∀ {n} → DecidableEquality (Normal n)
 nf₁ ≟ nf₂ = Dec.map′ ≋⇒≡ ≡⇒≋ (nf₁ ≋? nf₂)
   where open ListEq Fin._≟_
 
@@ -123,12 +123,12 @@ nf₁ ≟ nf₂ = Dec.map′ ≋⇒≡ ≡⇒≋ (nf₁ ≋? nf₂)
 
 prove′ : ∀ {n} (e₁ e₂ : Expr n) → Maybe (∀ ρ → ⟦ e₁ ⟧ ρ ≈ ⟦ e₂ ⟧ ρ)
 prove′ e₁ e₂ =
-  Maybe.map lemma $ decToMaybe (normalise e₁ ≟ normalise e₂)
+  Maybe.map lemma $ dec⇒weaklyDec _≟_ (normalise e₁) (normalise e₂)
   where
   lemma : normalise e₁ ≡ normalise e₂ → ∀ ρ → ⟦ e₁ ⟧ ρ ≈ ⟦ e₂ ⟧ ρ
   lemma eq ρ =
     R.prove ρ e₁ e₂ (begin
-      ⟦ normalise e₁ ⟧⇓ ρ  ≡⟨ P.cong (λ e → ⟦ e ⟧⇓ ρ) eq ⟩
+      ⟦ normalise e₁ ⟧⇓ ρ  ≡⟨ cong (λ e → ⟦ e ⟧⇓ ρ) eq ⟩
       ⟦ normalise e₂ ⟧⇓ ρ  ∎)
 
 -- This procedure can be combined with from-just.
diff --git a/src/Algebra/Solver/Ring.agda b/src/Algebra/Solver/Ring.agda
index 669cbe8d25..a2a982d5c2 100644
--- a/src/Algebra/Solver/Ring.agda
+++ b/src/Algebra/Solver/Ring.agda
@@ -39,17 +39,16 @@ open import Algebra.Morphism
 open _-Raw-AlmostCommutative⟶_ morphism renaming (⟦_⟧ to ⟦_⟧′)
 open import Algebra.Properties.Semiring.Exp semiring
 
-open import Relation.Binary
 open import Relation.Nullary.Decidable using (yes; no)
 open import Relation.Binary.Reasoning.Setoid setoid
-import Relation.Binary.PropositionalEquality as PropEq
+import Relation.Binary.PropositionalEquality.Core as ≡
 import Relation.Binary.Reflection as Reflection
 
 open import Data.Nat.Base using (ℕ; suc; zero)
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.Vec.Base using (Vec; []; _∷_; lookup)
 open import Data.Maybe.Base using (just; nothing)
-open import Function
+open import Function.Base using (_⟨_⟩_; _$_)
 open import Level using (_⊔_)
 
 infix  9 :-_ -H_ -N_
@@ -176,6 +175,8 @@ mutual
 
   -- Equality is weakly decidable.
 
+  infix 4 _≟H_ _≟N_
+
   _≟H_ : ∀ {n} → WeaklyDecidable (_≈H_ {n = n})
   ∅           ≟H ∅           = just ∅
   ∅           ≟H (_ *x+ _)   = nothing
@@ -533,7 +534,7 @@ correct (con c)  ρ = correct-con c ρ
 correct (var i)  ρ = correct-var i ρ
 correct (p :^ k) ρ = begin
   ⟦ normalise p ^N k ⟧N ρ  ≈⟨ ^N-homo (normalise p) k ρ ⟩
-  ⟦ p ⟧↓ ρ ^ k             ≈⟨ correct p ρ ⟨ ^-cong ⟩ PropEq.refl {x = k} ⟩
+  ⟦ p ⟧↓ ρ ^ k             ≈⟨ correct p ρ ⟨ ^-cong ⟩ ≡.refl {x = k} ⟩
   ⟦ p ⟧ ρ ^ k              ∎
 correct (:- p) ρ = begin
   ⟦ -N normalise p ⟧N ρ  ≈⟨ -N‿-homo (normalise p) ρ ⟩
diff --git a/src/Algebra/Solver/Ring/AlmostCommutativeRing.agda b/src/Algebra/Solver/Ring/AlmostCommutativeRing.agda
index 47cda5c4f9..9659dfc6ca 100644
--- a/src/Algebra/Solver/Ring/AlmostCommutativeRing.agda
+++ b/src/Algebra/Solver/Ring/AlmostCommutativeRing.agda
@@ -14,9 +14,9 @@ open import Algebra.Structures
 open import Algebra.Definitions
 import Algebra.Morphism as Morphism
 import Algebra.Morphism.Definitions as MorphismDefinitions
-open import Function hiding (Morphism)
+open import Function.Base using (id)
 open import Level
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
 
 
 record IsAlmostCommutativeRing {a ℓ} {A : Set a} (_≈_ : Rel A ℓ)
@@ -76,6 +76,8 @@ record AlmostCommutativeRing c ℓ : Set (suc (c ⊔ ℓ)) where
 ------------------------------------------------------------------------
 -- Homomorphisms
 
+infix 4 _-Raw-AlmostCommutative⟶_
+
 record _-Raw-AlmostCommutative⟶_
   {r₁ r₂ r₃ r₄}
   (From : RawRing r₁ r₄)
diff --git a/src/Algebra/Solver/Ring/Lemmas.agda b/src/Algebra/Solver/Ring/Lemmas.agda
index 0a9cd7ac73..944e30dfb7 100644
--- a/src/Algebra/Solver/Ring/Lemmas.agda
+++ b/src/Algebra/Solver/Ring/Lemmas.agda
@@ -24,7 +24,7 @@ open AlmostCommutativeRing r
 open import Algebra.Morphism
 open _-Raw-AlmostCommutative⟶_ morphism
 open import Relation.Binary.Reasoning.Setoid setoid
-open import Function
+open import Function.Base using (_⟨_⟩_; _$_)
 
 lemma₀ : ∀ a b c x →
          (a + b) * x + c ≈ a * x + (b * x + c)
diff --git a/src/Algebra/Solver/Ring/NaturalCoefficients.agda b/src/Algebra/Solver/Ring/NaturalCoefficients.agda
index 495e8cfa66..0c5f807042 100644
--- a/src/Algebra/Solver/Ring/NaturalCoefficients.agda
+++ b/src/Algebra/Solver/Ring/NaturalCoefficients.agda
@@ -12,9 +12,9 @@ import Algebra.Properties.Semiring.Mult as SemiringMultiplication
 open import Data.Maybe.Base using (Maybe; just; nothing; map)
 open import Algebra.Solver.Ring.AlmostCommutativeRing
 open import Data.Nat.Base as ℕ
-open import Data.Product using (module Σ)
+open import Data.Product.Base using (module Σ)
 open import Function.Base using (id)
-open import Relation.Binary.PropositionalEquality using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 module Algebra.Solver.Ring.NaturalCoefficients
   {r₁ r₂} (R : CommutativeSemiring r₁ r₂)
@@ -44,8 +44,8 @@ private
   -- There is a homomorphism from ℕ to R.
   --
   -- Note that the optimised _×_ is used rather than unoptimised _×ᵤ_.
-  -- If _×ᵤ_ were used, then Function.Related.TypeIsomorphisms.test would fail
-  -- to type-check.
+  -- If _×ᵤ_ were used, then Function.Related.TypeIsomorphisms.test
+  -- would fail to type-check.
 
   homomorphism : ℕ-ring -Raw-AlmostCommutative⟶ fromCommutativeSemiring R
   homomorphism = record
@@ -64,7 +64,7 @@ private
     where
     to : m ×ᵤ 1# ≈ n ×ᵤ 1# → m × 1# ≈ n × 1#
     to m≈n = begin
-      m ×  1#  ≈˘⟨ ×ᵤ≈× m 1# ⟩
+      m ×  1#  ≈⟨ ×ᵤ≈× m 1# ⟨
       m ×ᵤ 1#  ≈⟨  m≈n ⟩
       n ×ᵤ 1#  ≈⟨  ×ᵤ≈× n 1# ⟩
       n ×  1#  ∎
diff --git a/src/Algebra/Solver/Ring/NaturalCoefficients/Default.agda b/src/Algebra/Solver/Ring/NaturalCoefficients/Default.agda
index df01719174..da1b56b93f 100644
--- a/src/Algebra/Solver/Ring/NaturalCoefficients/Default.agda
+++ b/src/Algebra/Solver/Ring/NaturalCoefficients/Default.agda
@@ -5,8 +5,8 @@
 -- equality induced by ℕ.
 --
 -- This is sufficient for proving equalities that are independent of the
--- characteristic.  In particular, this is enough for equalities in rings of
--- characteristic 0.
+-- characteristic.  In particular, this is enough for equalities in
+-- rings of characteristic 0.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
@@ -20,13 +20,13 @@ import Algebra.Properties.Semiring.Mult as SemiringMultiplication
 open import Data.Maybe.Base using (Maybe; map)
 open import Data.Nat using (_≟_)
 open import Relation.Binary.Consequences using (dec⇒weaklyDec)
-import Relation.Binary.PropositionalEquality as P
+import Relation.Binary.PropositionalEquality.Core as ≡
 
 open CommutativeSemiring R
 open SemiringMultiplication semiring
 
 private
   dec : ∀ m n → Maybe (m × 1# ≈ n × 1#)
-  dec m n = map (λ { P.refl → refl }) (dec⇒weaklyDec _≟_ m n)
+  dec m n = map (λ { ≡.refl → refl }) (dec⇒weaklyDec _≟_ m n)
 
 open import Algebra.Solver.Ring.NaturalCoefficients R dec public
diff --git a/src/Algebra/Solver/Ring/Simple.agda b/src/Algebra/Solver/Ring/Simple.agda
index 86a7d1ca04..93bcc1a7fa 100644
--- a/src/Algebra/Solver/Ring/Simple.agda
+++ b/src/Algebra/Solver/Ring/Simple.agda
@@ -8,7 +8,7 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra.Solver.Ring.AlmostCommutativeRing
-open import Relation.Binary
+open import Relation.Binary.Definitions using (Decidable)
 open import Relation.Binary.Consequences using (dec⇒weaklyDec)
 
 module Algebra.Solver.Ring.Simple
diff --git a/src/Algebra/Structures.agda b/src/Algebra/Structures.agda
index 0a904276db..b58245e6df 100644
--- a/src/Algebra/Structures.agda
+++ b/src/Algebra/Structures.agda
@@ -9,7 +9,9 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; Setoid; IsEquivalence)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
 
 module Algebra.Structures
   {a ℓ} {A : Set a}  -- The underlying set
@@ -19,12 +21,26 @@ module Algebra.Structures
 -- The file is divided into sections depending on the arities of the
 -- components of the algebraic structure.
 
-open import Algebra.Core
+open import Algebra.Core using (Op₁; Op₂)
 open import Algebra.Definitions _≈_
 import Algebra.Consequences.Setoid as Consequences
-open import Data.Product using (_,_; proj₁; proj₂)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Level using (_⊔_)
 
+------------------------------------------------------------------------
+-- Structures with 1 unary operation & 1 element
+------------------------------------------------------------------------
+
+record IsSuccessorSet (suc# : Op₁ A) (zero# : A) : Set (a ⊔ ℓ) where
+  field
+    isEquivalence : IsEquivalence _≈_
+    suc#-cong     : Congruent₁ suc#
+
+  open IsEquivalence isEquivalence public
+
+  setoid : Setoid a ℓ
+  setoid = record { isEquivalence = isEquivalence }
+
 ------------------------------------------------------------------------
 -- Structures with 1 binary operation
 ------------------------------------------------------------------------
@@ -137,6 +153,20 @@ record IsCommutativeSemigroup (∙ : Op₂ A) : Set (a ⊔ ℓ) where
     ; comm    = comm
     }
 
+
+record IsCommutativeBand (∙ : Op₂ A) : Set (a ⊔ ℓ) where
+  field
+    isBand : IsBand ∙
+    comm   : Commutative ∙
+
+  open IsBand isBand public
+
+  isCommutativeSemigroup : IsCommutativeSemigroup ∙
+  isCommutativeSemigroup = record { isSemigroup = isSemigroup ; comm = comm }
+
+  open IsCommutativeSemigroup isCommutativeSemigroup public
+    using (isCommutativeMagma)
+
 ------------------------------------------------------------------------
 -- Structures with 1 binary operation & 1 element
 ------------------------------------------------------------------------
@@ -192,6 +222,17 @@ record IsCommutativeMonoid (∙ : Op₂ A) (ε : A) : Set (a ⊔ ℓ) where
     using (isCommutativeMagma)
 
 
+record IsIdempotentMonoid (∙ : Op₂ A) (ε : A) : Set (a ⊔ ℓ) where
+  field
+    isMonoid : IsMonoid ∙ ε
+    idem     : Idempotent ∙
+
+  open IsMonoid isMonoid public
+
+  isBand : IsBand ∙
+  isBand = record { isSemigroup = isSemigroup ; idem = idem }
+
+
 record IsIdempotentCommutativeMonoid (∙ : Op₂ A)
                                      (ε : A) : Set (a ⊔ ℓ) where
   field
@@ -200,9 +241,14 @@ record IsIdempotentCommutativeMonoid (∙ : Op₂ A)
 
   open IsCommutativeMonoid isCommutativeMonoid public
 
-  isBand : IsBand ∙
-  isBand = record { isSemigroup = isSemigroup ; idem = idem }
+  isIdempotentMonoid : IsIdempotentMonoid ∙ ε
+  isIdempotentMonoid = record { isMonoid = isMonoid ; idem = idem }
 
+  open IsIdempotentMonoid isIdempotentMonoid public
+    using (isBand)
+
+  isCommutativeBand : IsCommutativeBand ∙
+  isCommutativeBand = record { isBand = isBand ; comm = comm }
 
 ------------------------------------------------------------------------
 -- Structures with 1 binary operation, 1 unary operation & 1 element
@@ -251,9 +297,22 @@ record IsGroup (_∙_ : Op₂ A) (ε : A) (_⁻¹ : Op₁ A) : Set (a ⊔ ℓ) w
 
   open IsMonoid isMonoid public
 
+  infixr 6 _\\_
+  _\\_ : Op₂ A
+  x \\ y = (x ⁻¹) ∙ y
+
+  infixl 6 _//_
+  _//_ : Op₂ A
+  x // y = x ∙ (y ⁻¹)
+
+  -- Deprecated.
   infixl 6 _-_
   _-_ : Op₂ A
-  x - y = x ∙ (y ⁻¹)
+  _-_ = _//_
+  {-# WARNING_ON_USAGE _-_
+  "Warning: _-_ was deprecated in v2.1.
+  Please use _//_ instead. "
+  #-}
 
   inverseˡ : LeftInverse ε _⁻¹ _∙_
   inverseˡ = proj₁ inverse
@@ -262,11 +321,11 @@ record IsGroup (_∙_ : Op₂ A) (ε : A) (_⁻¹ : Op₁ A) : Set (a ⊔ ℓ) w
   inverseʳ = proj₂ inverse
 
   uniqueˡ-⁻¹ : ∀ x y → (x ∙ y) ≈ ε → x ≈ (y ⁻¹)
-  uniqueˡ-⁻¹ = Consequences.assoc+id+invʳ⇒invˡ-unique
+  uniqueˡ-⁻¹ = Consequences.assoc∧id∧invʳ⇒invˡ-unique
                 setoid ∙-cong assoc identity inverseʳ
 
   uniqueʳ-⁻¹ : ∀ x y → (x ∙ y) ≈ ε → y ≈ (x ⁻¹)
-  uniqueʳ-⁻¹ = Consequences.assoc+id+invˡ⇒invʳ-unique
+  uniqueʳ-⁻¹ = Consequences.assoc∧id∧invˡ⇒invʳ-unique
                 setoid ∙-cong assoc identity inverseˡ
 
   isInvertibleMagma : IsInvertibleMagma _∙_ ε _⁻¹
@@ -289,7 +348,7 @@ record IsAbelianGroup (∙ : Op₂ A)
     isGroup : IsGroup ∙ ε ⁻¹
     comm    : Commutative ∙
 
-  open IsGroup isGroup public
+  open IsGroup isGroup public renaming (_//_ to _-_) hiding (_\\_; _-_)
 
   isCommutativeMonoid : IsCommutativeMonoid ∙ ε
   isCommutativeMonoid = record
@@ -356,7 +415,7 @@ record IsSemiringWithoutOne (+ * : Op₂ A) (0# : A) : Set (a ⊔ ℓ) where
     zero                  : Zero 0# *
 
   open IsCommutativeMonoid +-isCommutativeMonoid public
-    using (isEquivalence)
+    using (setoid)
     renaming
     ( comm                   to +-comm
     ; isMonoid               to +-isMonoid
@@ -364,6 +423,8 @@ record IsSemiringWithoutOne (+ * : Op₂ A) (0# : A) : Set (a ⊔ ℓ) where
     ; isCommutativeSemigroup to +-isCommutativeSemigroup
     )
 
+  open Setoid setoid public
+
   *-isMagma : IsMagma *
   *-isMagma = record
     { isEquivalence = isEquivalence
@@ -542,6 +603,10 @@ record IsCancellativeCommutativeSemiring (+ * : Op₂ A) (0# 1# : A) : Set (a 
 
   open IsCommutativeSemiring isCommutativeSemiring public
 
+  *-cancelʳ-nonZero : AlmostRightCancellative 0# *
+  *-cancelʳ-nonZero = Consequences.comm∧almostCancelˡ⇒almostCancelʳ setoid
+      *-comm *-cancelˡ-nonZero
+
 record IsIdempotentSemiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ) where
   field
     isSemiring     : IsSemiring + * 0# 1#
@@ -549,6 +614,20 @@ record IsIdempotentSemiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ) where
 
   open IsSemiring isSemiring public
 
+  +-isIdempotentCommutativeMonoid : IsIdempotentCommutativeMonoid + 0#
+  +-isIdempotentCommutativeMonoid = record
+    { isCommutativeMonoid = +-isCommutativeMonoid
+    ; idem = +-idem
+    }
+
+  open IsIdempotentCommutativeMonoid +-isIdempotentCommutativeMonoid public
+    using ()
+    renaming ( isCommutativeBand to +-isCommutativeBand
+             ; isBand to +-isBand
+             ; isIdempotentMonoid to +-isIdempotentMonoid
+             )
+
+
 record IsKleeneAlgebra (+ * : Op₂ A) (⋆ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ) where
   field
     isIdempotentSemiring  : IsIdempotentSemiring + * 0# 1#
@@ -592,6 +671,24 @@ record IsQuasiring (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ) where
     ; isSemigroup   to +-isSemigroup
     )
 
+  distribˡ : * DistributesOverˡ +
+  distribˡ = proj₁ distrib
+
+  distribʳ : * DistributesOverʳ +
+  distribʳ = proj₂ distrib
+
+  zeroˡ : LeftZero 0# *
+  zeroˡ = proj₁ zero
+
+  zeroʳ : RightZero 0# *
+  zeroʳ = proj₂ zero
+
+  identityˡ : LeftIdentity 1# *
+  identityˡ = proj₁ *-identity
+
+  identityʳ : RightIdentity 1# *
+  identityʳ = proj₂ *-identity
+
   *-isMagma : IsMagma *
   *-isMagma = record
     { isEquivalence = isEquivalence
@@ -629,7 +726,6 @@ record IsRingWithoutOne (+ * : Op₂ A) (-_ : Op₁ A) (0# : A) : Set (a ⊔ ℓ
     *-cong           : Congruent₂ *
     *-assoc          : Associative *
     distrib          : * DistributesOver +
-    zero             : Zero 0# *
 
   open IsAbelianGroup +-isAbelianGroup public
     renaming
@@ -657,23 +753,28 @@ record IsRingWithoutOne (+ * : Op₂ A) (-_ : Op₁ A) (0# : A) : Set (a ⊔ ℓ
     ; isGroup                 to +-isGroup
     )
 
-  *-isMagma : IsMagma *
-  *-isMagma = record
-    { isEquivalence = isEquivalence
-    ; ∙-cong        = *-cong
-    }
+  distribˡ : * DistributesOverˡ +
+  distribˡ = proj₁ distrib
+
+  distribʳ : * DistributesOverʳ +
+  distribʳ = proj₂ distrib
 
   zeroˡ : LeftZero 0# *
-  zeroˡ = proj₁ zero
+  zeroˡ = Consequences.assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ setoid
+    +-cong *-cong +-assoc distribʳ +-identityʳ -‿inverseʳ
 
   zeroʳ : RightZero 0# *
-  zeroʳ = proj₂ zero
+  zeroʳ = Consequences.assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ setoid
+    +-cong *-cong +-assoc distribˡ +-identityʳ -‿inverseʳ
 
-  distribˡ : * DistributesOverˡ +
-  distribˡ = proj₁ distrib
+  zero : Zero 0# *
+  zero = zeroˡ , zeroʳ
 
-  distribʳ : * DistributesOverʳ +
-  distribʳ = proj₂ distrib
+  *-isMagma : IsMagma *
+  *-isMagma = record
+    { isEquivalence = isEquivalence
+    ; ∙-cong        = *-cong
+    }
 
   *-isSemigroup : IsSemigroup *
   *-isSemigroup = record
@@ -681,11 +782,11 @@ record IsRingWithoutOne (+ * : Op₂ A) (-_ : Op₁ A) (0# : A) : Set (a ⊔ ℓ
     ; assoc   = *-assoc
     }
 
-  open IsMagma *-isMagma public
+  open IsSemigroup *-isSemigroup public
     using ()
     renaming
-    ( ∙-congˡ  to *-congˡ
-    ; ∙-congʳ  to *-congʳ
+    ( ∙-congˡ   to *-congˡ
+    ; ∙-congʳ   to *-congʳ
     )
 
 ------------------------------------------------------------------------
@@ -696,7 +797,7 @@ record IsNonAssociativeRing (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A) : Set (a
   field
     +-isAbelianGroup : IsAbelianGroup + 0# -_
     *-cong           : Congruent₂ *
-    identity         : Identity 1# *
+    *-identity       : Identity 1# *
     distrib          : * DistributesOver +
     zero             : Zero 0# *
 
@@ -726,6 +827,18 @@ record IsNonAssociativeRing (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A) : Set (a
     ; isGroup                 to +-isGroup
     )
 
+  zeroˡ : LeftZero 0# *
+  zeroˡ = proj₁ zero
+
+  zeroʳ : RightZero 0# *
+  zeroʳ = proj₂ zero
+
+  distribˡ : * DistributesOverˡ +
+  distribˡ = proj₁ distrib
+
+  distribʳ : * DistributesOverʳ +
+  distribʳ = proj₂ distrib
+
   *-isMagma : IsMagma *
   *-isMagma = record
     { isEquivalence = isEquivalence
@@ -733,10 +846,23 @@ record IsNonAssociativeRing (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A) : Set (a
     }
 
   *-identityˡ : LeftIdentity 1# *
-  *-identityˡ = proj₁ identity
+  *-identityˡ = proj₁ *-identity
 
   *-identityʳ : RightIdentity 1# *
-  *-identityʳ = proj₂ identity
+  *-identityʳ = proj₂ *-identity
+
+  *-isUnitalMagma : IsUnitalMagma * 1#
+  *-isUnitalMagma = record
+    { isMagma = *-isMagma
+    ; identity = *-identity
+    }
+
+  open IsUnitalMagma *-isUnitalMagma public
+    using ()
+    renaming
+    ( ∙-congˡ   to *-congˡ
+    ; ∙-congʳ   to *-congʳ
+    )
 
 record IsNearring (+ * : Op₂ A) (0# 1# : A) (_⁻¹ : Op₁ A) : Set (a ⊔ ℓ) where
   field
@@ -759,45 +885,17 @@ record IsRing (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ) where
     *-assoc          : Associative *
     *-identity       : Identity 1# *
     distrib          : * DistributesOver +
-    zero             : Zero 0# *
-
-  open IsAbelianGroup +-isAbelianGroup public
-    renaming
-    ( assoc                   to +-assoc
-    ; ∙-cong                  to +-cong
-    ; ∙-congˡ                 to +-congˡ
-    ; ∙-congʳ                 to +-congʳ
-    ; identity                to +-identity
-    ; identityˡ               to +-identityˡ
-    ; identityʳ               to +-identityʳ
-    ; inverse                 to -‿inverse
-    ; inverseˡ                to -‿inverseˡ
-    ; inverseʳ                to -‿inverseʳ
-    ; ⁻¹-cong                 to -‿cong
-    ; comm                    to +-comm
-    ; isMagma                 to +-isMagma
-    ; isSemigroup             to +-isSemigroup
-    ; isMonoid                to +-isMonoid
-    ; isUnitalMagma           to +-isUnitalMagma
-    ; isCommutativeMagma      to +-isCommutativeMagma
-    ; isCommutativeMonoid     to +-isCommutativeMonoid
-    ; isCommutativeSemigroup  to +-isCommutativeSemigroup
-    ; isInvertibleMagma       to +-isInvertibleMagma
-    ; isInvertibleUnitalMagma to +-isInvertibleUnitalMagma
-    ; isGroup                 to +-isGroup
-    )
 
-  *-isMagma : IsMagma *
-  *-isMagma = record
-    { isEquivalence = isEquivalence
-    ; ∙-cong        = *-cong
+  isRingWithoutOne : IsRingWithoutOne + * -_ 0#
+  isRingWithoutOne = record
+    { +-isAbelianGroup = +-isAbelianGroup
+    ; *-cong  = *-cong
+    ; *-assoc = *-assoc
+    ; distrib = distrib
     }
 
-  *-isSemigroup : IsSemigroup *
-  *-isSemigroup = record
-    { isMagma = *-isMagma
-    ; assoc   = *-assoc
-    }
+  open IsRingWithoutOne isRingWithoutOne public
+    hiding (+-isAbelianGroup; *-cong; *-assoc; distrib)
 
   *-isMonoid : IsMonoid * 1#
   *-isMonoid = record
@@ -808,18 +906,10 @@ record IsRing (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ) where
   open IsMonoid *-isMonoid public
     using ()
     renaming
-    ( ∙-congˡ     to *-congˡ
-    ; ∙-congʳ     to *-congʳ
-    ; identityˡ   to *-identityˡ
+    ( identityˡ   to *-identityˡ
     ; identityʳ   to *-identityʳ
     )
 
-  zeroˡ : LeftZero 0# *
-  zeroˡ = proj₁ zero
-
-  zeroʳ : RightZero 0# *
-  zeroʳ = proj₂ zero
-
   isSemiringWithoutAnnihilatingZero
     : IsSemiringWithoutAnnihilatingZero + * 0# 1#
   isSemiringWithoutAnnihilatingZero = record
@@ -838,7 +928,7 @@ record IsRing (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ) where
     }
 
   open IsSemiring isSemiring public
-    using (distribˡ; distribʳ; isNearSemiring; isSemiringWithoutOne)
+    using (isNearSemiring; isSemiringWithoutOne)
 
 
 record IsCommutativeRing
diff --git a/src/Algebra/Structures/Biased.agda b/src/Algebra/Structures/Biased.agda
index c03e1236eb..59e47da553 100644
--- a/src/Algebra/Structures/Biased.agda
+++ b/src/Algebra/Structures/Biased.agda
@@ -2,16 +2,18 @@
 -- The Agda standard library
 --
 -- Ways to give instances of certain structures where some fields can
--- be given in terms of others
+-- be given in terms of others. Re-exported via `Algebra`.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra.Core
 open import Algebra.Consequences.Setoid
-open import Data.Product using (_,_; proj₁; proj₂)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Level using (_⊔_)
-open import Relation.Binary using (Rel; Setoid; IsEquivalence)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
 
 module Algebra.Structures.Biased
   {a ℓ} {A : Set a}  -- The underlying set
@@ -34,7 +36,7 @@ record IsCommutativeMonoidˡ (∙ : Op₂ A) (ε : A) : Set (a ⊔ ℓ) where
   isCommutativeMonoid = record
     { isMonoid = record
       { isSemigroup = isSemigroup
-      ; identity    = comm+idˡ⇒id setoid comm identityˡ
+      ; identity    = comm∧idˡ⇒id setoid comm identityˡ
       }
     ; comm = comm
     } where open IsSemigroup isSemigroup
@@ -53,7 +55,7 @@ record IsCommutativeMonoidʳ (∙ : Op₂ A) (ε : A) : Set (a ⊔ ℓ) where
   isCommutativeMonoid = record
     { isMonoid = record
       { isSemigroup = isSemigroup
-      ; identity    = comm+idʳ⇒id setoid comm identityʳ
+      ; identity    = comm∧idʳ⇒id setoid comm identityʳ
       }
     ; comm = comm
     } where open IsSemigroup isSemigroup
@@ -144,9 +146,9 @@ record IsCommutativeSemiringˡ (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ) whe
         ; *-cong                = *.∙-cong
         ; *-assoc               = *.assoc
         ; *-identity            = *.identity
-        ; distrib               = comm+distrʳ⇒distr +.setoid +.∙-cong *.comm distribʳ
+        ; distrib               = comm∧distrʳ⇒distr +.setoid +.∙-cong *.comm distribʳ
         }
-      ; zero = comm+zeˡ⇒ze +.setoid *.comm zeroˡ
+      ; zero = comm∧zeˡ⇒ze +.setoid *.comm zeroˡ
       }
     ; *-comm = *.comm
     }
@@ -173,9 +175,9 @@ record IsCommutativeSemiringʳ (+ * : Op₂ A) (0# 1# : A) : Set (a ⊔ ℓ) whe
         ; *-cong                = *.∙-cong
         ; *-assoc               = *.assoc
         ; *-identity            = *.identity
-        ; distrib               = comm+distrˡ⇒distr +.setoid +.∙-cong *.comm distribˡ
+        ; distrib               = comm∧distrˡ⇒distr +.setoid +.∙-cong *.comm distribˡ
         }
-      ; zero = comm+zeʳ⇒ze +.setoid *.comm zeroʳ
+      ; zero = comm∧zeʳ⇒ze +.setoid *.comm zeroʳ
       }
     ; *-comm = *.comm
     }
@@ -190,6 +192,33 @@ open IsCommutativeSemiringʳ public
 ------------------------------------------------------------------------
 -- IsRing
 
+record IsRing* (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ) where
+  field
+    +-isAbelianGroup : IsAbelianGroup + 0# -_
+    *-isMonoid       : IsMonoid * 1#
+    distrib          : * DistributesOver +
+    zero             : Zero 0# *
+
+  isRing : IsRing + * -_ 0# 1#
+  isRing = record
+    { +-isAbelianGroup = +-isAbelianGroup
+    ; *-cong = ∙-cong
+    ; *-assoc = assoc
+    ; *-identity = identity
+    ; distrib = distrib
+    } where open IsMonoid *-isMonoid
+
+open IsRing* public
+  using () renaming (isRing to isRing*)
+
+
+
+------------------------------------------------------------------------
+-- Deprecated
+------------------------------------------------------------------------
+
+-- Version 2.0
+
 -- We can recover a ring without proving that 0# annihilates *.
 record IsRingWithoutAnnihilatingZero (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A)
                                      : Set (a ⊔ ℓ) where
@@ -205,11 +234,11 @@ record IsRingWithoutAnnihilatingZero (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A)
   open * using ()       renaming (∙-cong to *-cong)
 
   zeroˡ : LeftZero 0# *
-  zeroˡ = assoc+distribʳ+idʳ+invʳ⇒zeˡ setoid
+  zeroˡ = assoc∧distribʳ∧idʳ∧invʳ⇒zeˡ setoid
             +-cong *-cong +.assoc (proj₂ distrib) +.identityʳ +.inverseʳ
 
   zeroʳ : RightZero 0# *
-  zeroʳ = assoc+distribˡ+idʳ+invʳ⇒zeʳ setoid
+  zeroʳ = assoc∧distribˡ∧idʳ∧invʳ⇒zeʳ setoid
             +-cong *-cong +.assoc (proj₁ distrib) +.identityʳ +.inverseʳ
 
   zero : Zero 0# *
@@ -222,28 +251,28 @@ record IsRingWithoutAnnihilatingZero (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A)
     ; *-assoc          = *.assoc
     ; *-identity       = *.identity
     ; distrib          = distrib
-    ; zero             = zero
     }
 
 open IsRingWithoutAnnihilatingZero public
   using () renaming (isRing to isRingWithoutAnnihilatingZero)
 
-record IsRing* (+ * : Op₂ A) (-_ : Op₁ A) (0# 1# : A) : Set (a ⊔ ℓ) where
-  field
-    +-isAbelianGroup : IsAbelianGroup + 0# -_
-    *-isMonoid       : IsMonoid * 1#
-    distrib          : * DistributesOver +
-    zero             : Zero 0# *
-
-  isRing : IsRing + * -_ 0# 1#
-  isRing = record
-    { +-isAbelianGroup = +-isAbelianGroup
-    ; *-cong = ∙-cong
-    ; *-assoc = assoc
-    ; *-identity = identity
-    ; distrib = distrib
-    ; zero = zero
-    } where open IsMonoid *-isMonoid
-
-open IsRing* public
-  using () renaming (isRing to isRing*)
+{-# WARNING_ON_USAGE IsRingWithoutAnnihilatingZero
+"Warning: IsRingWithoutAnnihilatingZero was deprecated in v2.0.
+Please use the standard `IsRing` instead."
+#-}
+{-# WARNING_ON_USAGE isRingWithoutAnnihilatingZero
+"Warning: isRingWithoutAnnihilatingZero was deprecated in v2.0.
+Please use the standard `isRing` instead."
+#-}
+
+-- Version 2.1
+
+-- issue #2253
+{-# WARNING_ON_USAGE IsRing*
+"Warning: IsRing* was deprecated in v2.1.
+Please use the standard `IsRing` instead."
+#-}
+{-# WARNING_ON_USAGE isRing*
+"Warning: isRing* was deprecated in v2.1.
+Please use the standard `isRing` instead."
+#-}
diff --git a/src/Axiom/DoubleNegationElimination.agda b/src/Axiom/DoubleNegationElimination.agda
index 49e8b01eaa..777f08c017 100644
--- a/src/Axiom/DoubleNegationElimination.agda
+++ b/src/Axiom/DoubleNegationElimination.agda
@@ -32,4 +32,4 @@ em⇒dne : ∀ {ℓ} → ExcludedMiddle ℓ → DoubleNegationElimination ℓ
 em⇒dne em = decidable-stable em
 
 dne⇒em : ∀ {ℓ} → DoubleNegationElimination ℓ → ExcludedMiddle ℓ
-dne⇒em dne = dne excluded-middle
+dne⇒em dne = dne ¬¬-excluded-middle
diff --git a/src/Axiom/Extensionality/Heterogeneous.agda b/src/Axiom/Extensionality/Heterogeneous.agda
index 0b10affb61..ed1be68791 100644
--- a/src/Axiom/Extensionality/Heterogeneous.agda
+++ b/src/Axiom/Extensionality/Heterogeneous.agda
@@ -9,7 +9,7 @@
 module Axiom.Extensionality.Heterogeneous where
 
 import Axiom.Extensionality.Propositional as P
-open import Function
+open import Function.Base using (_$_; _∘_)
 open import Level
 open import Relation.Binary.HeterogeneousEquality.Core
 open import Relation.Binary.PropositionalEquality.Core
diff --git a/src/Axiom/UniquenessOfIdentityProofs.agda b/src/Axiom/UniquenessOfIdentityProofs.agda
index 1cefc1a6a1..670941afb1 100644
--- a/src/Axiom/UniquenessOfIdentityProofs.agda
+++ b/src/Axiom/UniquenessOfIdentityProofs.agda
@@ -8,15 +8,19 @@
 
 module Axiom.UniquenessOfIdentityProofs where
 
-open import Data.Bool.Base using (true; false)
-open import Data.Empty
-open import Relation.Nullary.Reflects using (invert)
-open import Relation.Nullary hiding (Irrelevant)
+open import Level using (Level)
+open import Relation.Nullary.Decidable.Core using (recompute; recompute-constant)
 open import Relation.Binary.Core
 open import Relation.Binary.Definitions
 open import Relation.Binary.PropositionalEquality.Core
 open import Relation.Binary.PropositionalEquality.Properties
 
+private
+  variable
+    a : Level
+    A : Set a
+    x y : A
+
 ------------------------------------------------------------------------
 -- Definition
 --
@@ -24,7 +28,7 @@ open import Relation.Binary.PropositionalEquality.Properties
 -- equality are themselves equal. In other words, the equality relation
 -- is irrelevant. Here we define UIP relative to a given type.
 
-UIP : ∀ {a} (A : Set a) → Set a
+UIP : (A : Set a) → Set a
 UIP A = Irrelevant {A = A} _≡_
 
 ------------------------------------------------------------------------
@@ -39,11 +43,11 @@ UIP A = Irrelevant {A = A} _≡_
 -- the image of any other proof.
 
 module Constant⇒UIP
-  {a} {A : Set a} (f : _≡_ {A = A} ⇒ _≡_)
-  (f-constant : ∀ {a b} (p q : a ≡ b) → f p ≡ f q)
+  (f : _≡_ {A = A} ⇒ _≡_)
+  (f-constant : ∀ {x y} (p q : x ≡ y) → f p ≡ f q)
   where
 
-  ≡-canonical : ∀ {a b} (p : a ≡ b) → trans (sym (f refl)) (f p) ≡ p
+  ≡-canonical : (p : x ≡ y) → trans (sym (f refl)) (f p) ≡ p
   ≡-canonical refl = trans-symˡ (f refl)
 
   ≡-irrelevant : UIP A
@@ -59,19 +63,14 @@ module Constant⇒UIP
 -- function over proofs of equality which is constant: it returns the
 -- proof produced by the decision procedure.
 
-module Decidable⇒UIP
-  {a} {A : Set a} (_≟_ : Decidable {A = A} _≡_)
+module Decidable⇒UIP (_≟_ : DecidableEquality A)
   where
 
   ≡-normalise : _≡_ {A = A} ⇒ _≡_
-  ≡-normalise {a} {b} a≡b with a ≟ b
-  ... | true  because  [p] = invert [p]
-  ... | false because [¬p] = ⊥-elim (invert [¬p] a≡b)
-
-  ≡-normalise-constant : ∀ {a b} (p q : a ≡ b) → ≡-normalise p ≡ ≡-normalise q
-  ≡-normalise-constant {a} {b} p q with a ≟ b
-  ... | true  because   _  = refl
-  ... | false because [¬p] = ⊥-elim (invert [¬p] p)
+  ≡-normalise {x} {y} x≡y = recompute (x ≟ y) x≡y
+
+  ≡-normalise-constant : (p q : x ≡ y) → ≡-normalise p ≡ ≡-normalise q
+  ≡-normalise-constant {x = x} {y = y} = recompute-constant (x ≟ y)
 
   ≡-irrelevant : UIP A
   ≡-irrelevant = Constant⇒UIP.≡-irrelevant ≡-normalise ≡-normalise-constant
diff --git a/src/Codata/Guarded/M.agda b/src/Codata/Guarded/M.agda
index eaf2e0eadd..876fde8031 100644
--- a/src/Codata/Guarded/M.agda
+++ b/src/Codata/Guarded/M.agda
@@ -11,7 +11,7 @@ module Codata.Guarded.M where
 open import Level
 open import Data.Container.Core hiding (map; Shape; Position)
 open import Function.Base
-open import Data.Product hiding (map)
+open import Data.Product.Base hiding (map)
 
 -- The family of M-types
 
diff --git a/src/Codata/Guarded/Stream.agda b/src/Codata/Guarded/Stream.agda
index 88c5c5fec5..6036158463 100644
--- a/src/Codata/Guarded/Stream.agda
+++ b/src/Codata/Guarded/Stream.agda
@@ -12,7 +12,7 @@ open import Level hiding (suc)
 open import Data.Nat.Base
 open import Function.Base
 open import Data.List.Base as List using (List; []; _∷_)
-open import Data.Product hiding (map)
+open import Data.Product.Base hiding (map)
 open import Data.Vec.Base using (Vec; []; _∷_)
 open import Data.List.NonEmpty.Base as List⁺ using (List⁺; _∷_)
 open import Algebra.Core
@@ -28,6 +28,8 @@ private
 ------------------------------------------------------------------------
 -- Type
 
+infixr 5 _∷_
+
 record Stream (A : Set a) : Set a where
   coinductive
   constructor _∷_
@@ -69,6 +71,8 @@ lookup : Stream A → ℕ → A
 lookup xs zero    = head xs
 lookup xs (suc n) = lookup (tail xs) n
 
+infix 4 _[_]
+
 _[_] : Stream A → ℕ → A
 _[_] = lookup
 
diff --git a/src/Codata/Guarded/Stream/Properties.agda b/src/Codata/Guarded/Stream/Properties.agda
index 3e4bd83dcb..c5f8e6b0cc 100644
--- a/src/Codata/Guarded/Stream/Properties.agda
+++ b/src/Codata/Guarded/Stream/Properties.agda
@@ -16,11 +16,13 @@ open import Data.List.Base as List using (List; []; _∷_)
 open import Data.List.NonEmpty as List⁺ using (List⁺; _∷_)
 open import Data.Nat.Base using (ℕ; zero; suc; _+_; _*_)
 import Data.Nat.GeneralisedArithmetic as ℕ
-open import Data.Product as Prod using (_×_; _,_; proj₁; proj₂)
+open import Data.Product.Base as Prod using (_×_; _,_; proj₁; proj₂)
 open import Data.Vec.Base as Vec using (Vec; _∷_)
 open import Function.Base using (const; flip; id; _∘′_; _$′_; _⟨_⟩_; _∘₂′_)
 open import Level using (Level)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; cong; cong₂)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong; cong₂)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 
 private
   variable
@@ -37,7 +39,7 @@ cong-lookup : ∀ {as bs : Stream A} → as ≈ bs → ∀ n → lookup as n ≡
 cong-lookup = B.lookup⁺
 
 cong-take : ∀ n {as bs : Stream A} → as ≈ bs → take n as ≡ take n bs
-cong-take zero    as≈bs = P.refl
+cong-take zero    as≈bs = refl
 cong-take (suc n) as≈bs = cong₂ _∷_ (as≈bs .head) (cong-take n (as≈bs .tail))
 
 cong-drop : ∀ n {as bs : Stream A} → as ≈ bs → drop n as ≈ drop n bs
@@ -61,7 +63,7 @@ cong-concat ass≈bss = cong-++-concat [] ass≈bss
     cong-++-concat : ∀ (as : List A) {ass bss} → ass ≈ bss → ++-concat as ass ≈ ++-concat as bss
     cong-++-concat [] ass≈bss .head = cong List⁺.head (ass≈bss .head)
     cong-++-concat [] ass≈bss .tail rewrite ass≈bss .head = cong-++-concat _ (ass≈bss .tail)
-    cong-++-concat (a ∷ as) ass≈bss .head = P.refl
+    cong-++-concat (a ∷ as) ass≈bss .head = refl
     cong-++-concat (a ∷ as) ass≈bss .tail = cong-++-concat as ass≈bss
 
 cong-interleave : {as bs cs ds : Stream A} → as ≈ bs → cs ≈ ds →
@@ -77,88 +79,88 @@ cong-chunksOf n as≈bs .tail = cong-chunksOf n (cong-drop n as≈bs)
 -- Properties of repeat
 
 lookup-repeat : ∀ n (a : A) → lookup (repeat a) n ≡ a
-lookup-repeat zero    a = P.refl
+lookup-repeat zero    a = refl
 lookup-repeat (suc n) a = lookup-repeat n a
 
-splitAt-repeat : ∀ n (a : A) → splitAt n (repeat a) ≡ (Vec.replicate a , repeat a)
-splitAt-repeat zero    a = P.refl
+splitAt-repeat : ∀ n (a : A) → splitAt n (repeat a) ≡ (Vec.replicate n a , repeat a)
+splitAt-repeat zero    a = refl
 splitAt-repeat (suc n) a = cong (Prod.map₁ (a ∷_)) (splitAt-repeat n a)
 
-take-repeat : ∀ n (a : A) → take n (repeat a) ≡ Vec.replicate a
+take-repeat : ∀ n (a : A) → take n (repeat a) ≡ Vec.replicate n a
 take-repeat n a = cong proj₁ (splitAt-repeat n a)
 
 drop-repeat : ∀ n (a : A) → drop n (repeat a) ≡ repeat a
 drop-repeat n a = cong proj₂ (splitAt-repeat n a)
 
 map-repeat : ∀ (f : A → B) a → map f (repeat a) ≈ repeat (f a)
-map-repeat f a .head = P.refl
+map-repeat f a .head = refl
 map-repeat f a .tail = map-repeat f a
 
 ap-repeat : ∀ (f : A → B) a → ap (repeat f) (repeat a) ≈ repeat (f a)
-ap-repeat f a .head = P.refl
+ap-repeat f a .head = refl
 ap-repeat f a .tail = ap-repeat f a
 
 ap-repeatˡ : ∀ (f : A → B) as → ap (repeat f) as ≈ map f as
-ap-repeatˡ f as .head = P.refl
+ap-repeatˡ f as .head = refl
 ap-repeatˡ f as .tail = ap-repeatˡ f (as .tail)
 
 ap-repeatʳ : ∀ (fs : Stream (A → B)) a → ap fs (repeat a) ≈ map (_$′ a) fs
-ap-repeatʳ fs a .head = P.refl
+ap-repeatʳ fs a .head = refl
 ap-repeatʳ fs a .tail = ap-repeatʳ (fs .tail) a
 
 interleave-repeat : (a : A) → interleave (repeat a) (repeat a) ≈ repeat a
-interleave-repeat a .head = P.refl
+interleave-repeat a .head = refl
 interleave-repeat a .tail = interleave-repeat a
 
 zipWith-repeat : ∀ (f : A → B → C) a b →
                  zipWith f (repeat a) (repeat b) ≈ repeat (f a b)
-zipWith-repeat f a b .head = P.refl
+zipWith-repeat f a b .head = refl
 zipWith-repeat f a b .tail = zipWith-repeat f a b
 
-chunksOf-repeat : ∀ n (a : A) → chunksOf n (repeat a) ≈ repeat (Vec.replicate a)
+chunksOf-repeat : ∀ n (a : A) → chunksOf n (repeat a) ≈ repeat (Vec.replicate n a)
 chunksOf-repeat n a = begin go where
 
   open ≈-Reasoning
 
-  go : chunksOf n (repeat a) ≈∞ repeat (Vec.replicate a)
+  go : chunksOf n (repeat a) ≈∞ repeat (Vec.replicate n a)
   go .head = take-repeat n a
   go .tail =
-    chunksOf n (drop n (repeat a)) ≡⟨ P.cong (chunksOf n) (drop-repeat n a) ⟩
+    chunksOf n (drop n (repeat a)) ≡⟨ cong (chunksOf n) (drop-repeat n a) ⟩
     chunksOf n (repeat a)          ↺⟨ go ⟩
-    repeat (Vec.replicate a)       ∎
+    repeat (Vec.replicate n a)     ∎
 
 ------------------------------------------------------------------------
 -- Properties of map
 
 map-const : (a : A) (bs : Stream B) → map (const a) bs ≈ repeat a
-map-const a bs .head = P.refl
+map-const a bs .head = refl
 map-const a bs .tail = map-const a (bs .tail)
 
 map-id : (as : Stream A) → map id as ≈ as
-map-id as .head = P.refl
+map-id as .head = refl
 map-id as .tail = map-id (as .tail)
 
 map-∘ : ∀ (g : B → C) (f : A → B) as → map g (map f as) ≈ map (g ∘′ f) as
-map-∘ g f as .head = P.refl
+map-∘ g f as .head = refl
 map-∘ g f as .tail = map-∘ g f (as .tail)
 
 map-unfold : ∀ (g : B → C) (f : A → A × B) a →
              map g (unfold f a) ≈ unfold (Prod.map₂ g ∘′ f) a
-map-unfold g f a .head = P.refl
+map-unfold g f a .head = refl
 map-unfold g f a .tail = map-unfold g f (proj₁ (f a))
 
 map-drop : ∀ (f : A → B) n as → map f (drop n as) ≡ drop n (map f as)
-map-drop f zero    as = P.refl
+map-drop f zero    as = refl
 map-drop f (suc n) as = map-drop f n (as .tail)
 
 map-zipWith : ∀ (g : C → D) (f : A → B → C) as bs →
               map g (zipWith f as bs) ≈ zipWith (g ∘₂′ f) as bs
-map-zipWith g f as bs .head = P.refl
+map-zipWith g f as bs .head = refl
 map-zipWith g f as bs .tail = map-zipWith g f (as .tail) (bs .tail)
 
 map-interleave : ∀ (f : A → B) as bs →
                  map f (interleave as bs) ≈ interleave (map f as) (map f bs)
-map-interleave f as bs .head = P.refl
+map-interleave f as bs .head = refl
 map-interleave f as bs .tail = map-interleave f bs (as .tail)
 
 map-concat : ∀ (f : A → B) ass → map f (concat ass) ≈ concat (map (List⁺.map f) ass)
@@ -166,9 +168,9 @@ map-concat f ass = map-++-concat [] ass
   where
     open Concat
     map-++-concat : ∀ acc ass → map f (++-concat acc ass) ≈ ++-concat (List.map f acc) (map (List⁺.map f) ass)
-    map-++-concat [] ass .head = P.refl
+    map-++-concat [] ass .head = refl
     map-++-concat [] ass .tail = map-++-concat (ass .head .List⁺.tail) (ass .tail)
-    map-++-concat (a ∷ as) ass .head = P.refl
+    map-++-concat (a ∷ as) ass .head = refl
     map-++-concat (a ∷ as) ass .tail = map-++-concat as ass
 
 map-cycle : ∀ (f : A → B) as → map f (cycle as) ≈ cycle (List⁺.map f as)
@@ -184,29 +186,29 @@ map-cycle f as = run
 -- Properties of lookup
 
 lookup-drop : ∀ m (as : Stream A) n → lookup (drop m as) n ≡ lookup as (m + n)
-lookup-drop zero    as n = P.refl
+lookup-drop zero    as n = refl
 lookup-drop (suc m) as n = lookup-drop m (as .tail) n
 
 lookup-map : ∀ n (f : A → B) as → lookup (map f as) n ≡ f (lookup as n)
-lookup-map zero    f as = P.refl
+lookup-map zero    f as = refl
 lookup-map (suc n) f as = lookup-map n f (as . tail)
 
 lookup-iterate : ∀ n f (x : A) → lookup (iterate f x) n ≡ ℕ.iterate f x n
-lookup-iterate zero    f x = P.refl
+lookup-iterate zero    f x = refl
 lookup-iterate (suc n) f x = lookup-iterate n f (f x)
 
 lookup-zipWith : ∀ n (f : A → B → C) as bs →
                  lookup (zipWith f as bs) n ≡ f (lookup as n) (lookup bs n)
-lookup-zipWith zero f as bs = P.refl
+lookup-zipWith zero f as bs = refl
 lookup-zipWith (suc n) f as bs = lookup-zipWith n f (as .tail) (bs .tail)
 
 lookup-unfold : ∀ n (f : A → A × B) a →
                 lookup (unfold f a) n ≡ proj₂ (f (ℕ.iterate (proj₁ ∘′ f) a n))
-lookup-unfold zero    f a = P.refl
+lookup-unfold zero    f a = refl
 lookup-unfold (suc n) f a = lookup-unfold n f (proj₁ (f a))
 
 lookup-tabulate : ∀ n (f : ℕ → A) → lookup (tabulate f) n ≡ f n
-lookup-tabulate zero f = P.refl
+lookup-tabulate zero f = refl
 lookup-tabulate (suc n) f = lookup-tabulate n (f ∘′ suc)
 
 lookup-transpose : ∀ n (ass : List (Stream A)) →
@@ -218,7 +220,7 @@ lookup-transpose n (as ∷ ass) = begin
   lookup as n ∷ lookup (transpose ass) n     ≡⟨ cong (lookup as n ∷_) (lookup-transpose n ass) ⟩
   lookup as n ∷ List.map (flip lookup n) ass ≡⟨⟩
   List.map (flip lookup n) (as ∷ ass)        ∎
-  where open P.≡-Reasoning
+  where open ≡-Reasoning
 
 lookup-transpose⁺ : ∀ n (ass : List⁺ (Stream A)) →
                     lookup (transpose⁺ ass) n ≡ List⁺.map (flip lookup n) ass
@@ -228,62 +230,62 @@ lookup-transpose⁺ n (as ∷ ass) = begin
   lookup as n ∷ lookup (transpose ass) n     ≡⟨ cong (lookup as n ∷_) (lookup-transpose n ass) ⟩
   lookup as n ∷ List.map (flip lookup n) ass ≡⟨⟩
   List⁺.map (flip lookup n) (as ∷ ass)       ∎
-  where open P.≡-Reasoning
+  where open ≡-Reasoning
 
 lookup-tails : ∀ n (as : Stream A) → lookup (tails as) n ≈ ℕ.iterate tail as n
 lookup-tails zero    as = B.refl
 lookup-tails (suc n) as = lookup-tails n (as .tail)
 
 lookup-evens : ∀ n (as : Stream A) → lookup (evens as) n ≡ lookup as (n * 2)
-lookup-evens zero    as = P.refl
+lookup-evens zero    as = refl
 lookup-evens (suc n) as = lookup-evens n (as .tail .tail)
 
 lookup-odds : ∀ n (as : Stream A) → lookup (odds as) n ≡ lookup as (suc (n * 2))
-lookup-odds zero    as = P.refl
+lookup-odds zero    as = refl
 lookup-odds (suc n) as = lookup-odds n (as .tail .tail)
 
 lookup-interleave-even : ∀ n (as bs : Stream A) →
                          lookup (interleave as bs) (n * 2) ≡ lookup as n
-lookup-interleave-even zero    as bs = P.refl
+lookup-interleave-even zero    as bs = refl
 lookup-interleave-even (suc n) as bs = lookup-interleave-even n (as .tail) (bs .tail)
 
 lookup-interleave-odd : ∀ n (as bs : Stream A) →
                         lookup (interleave as bs) (suc (n * 2)) ≡ lookup bs n
-lookup-interleave-odd zero    as bs = P.refl
+lookup-interleave-odd zero    as bs = refl
 lookup-interleave-odd (suc n) as bs = lookup-interleave-odd n (as .tail) (bs .tail)
 
 ------------------------------------------------------------------------
 -- Properties of take
 
-take-iterate : ∀ n f (x : A) → take n (iterate f x) ≡ Vec.iterate f x
-take-iterate zero    f x = P.refl
+take-iterate : ∀ n f (x : A) → take n (iterate f x) ≡ Vec.iterate f x n
+take-iterate zero    f x = refl
 take-iterate (suc n) f x = cong (x ∷_) (take-iterate n f (f x))
 
 take-zipWith : ∀ n (f : A → B → C) as bs →
                take n (zipWith f as bs) ≡ Vec.zipWith f (take n as) (take n bs)
-take-zipWith zero    f as bs = P.refl
+take-zipWith zero    f as bs = refl
 take-zipWith (suc n) f as bs =
   cong (f (as .head) (bs .head) ∷_) (take-zipWith n f (as .tail) (bs . tail))
 
 ------------------------------------------------------------------------
 -- Properties of drop
 
-drop-fusion : ∀ m n (as : Stream A) → drop n (drop m as) ≡ drop (m + n) as
-drop-fusion zero    n as = P.refl
-drop-fusion (suc m) n as = drop-fusion m n (as .tail)
+drop-drop : ∀ m n (as : Stream A) → drop n (drop m as) ≡ drop (m + n) as
+drop-drop zero    n as = refl
+drop-drop (suc m) n as = drop-drop m n (as .tail)
 
 drop-zipWith : ∀ n (f : A → B → C) as bs →
                drop n (zipWith f as bs) ≡ zipWith f (drop n as) (drop n bs)
-drop-zipWith zero    f as bs = P.refl
+drop-zipWith zero    f as bs = refl
 drop-zipWith (suc n) f as bs = drop-zipWith n f (as .tail) (bs .tail)
 
 drop-ap : ∀ n (fs : Stream (A → B)) as →
           drop n (ap fs as) ≡ ap (drop n fs) (drop n as)
-drop-ap zero    fs as = P.refl
+drop-ap zero    fs as = refl
 drop-ap (suc n) fs as = drop-ap n (fs .tail) (as .tail)
 
 drop-iterate : ∀ n f (x : A) → drop n (iterate f x) ≡ iterate f (ℕ.iterate f x n)
-drop-iterate zero    f x = P.refl
+drop-iterate zero    f x = refl
 drop-iterate (suc n) f x = drop-iterate n f (f x)
 
 ------------------------------------------------------------------------
@@ -291,25 +293,25 @@ drop-iterate (suc n) f x = drop-iterate n f (f x)
 
 zipWith-defn : ∀ (f : A → B → C) as bs →
                zipWith f as bs ≈ (repeat f ⟨ ap ⟩ as ⟨ ap ⟩ bs)
-zipWith-defn f as bs .head = P.refl
+zipWith-defn f as bs .head = refl
 zipWith-defn f as bs .tail = zipWith-defn f (as .tail) (bs .tail)
 
 zipWith-const : (as : Stream A) (bs : Stream B) →
                 zipWith const as bs ≈ as
-zipWith-const as bs .head = P.refl
+zipWith-const as bs .head = refl
 zipWith-const as bs .tail = zipWith-const (as .tail) (bs .tail)
 
 zipWith-flip : ∀ (f : A → B → C) as bs →
                zipWith (flip f) as bs ≈ zipWith f bs as
-zipWith-flip f as bs .head = P.refl
+zipWith-flip f as bs .head = refl
 zipWith-flip f as bs .tail = zipWith-flip f (as .tail) (bs. tail)
 
 ------------------------------------------------------------------------
 -- Properties of interleave
 
 interleave-evens-odds : (as : Stream A) → interleave (evens as) (odds as) ≈ as
-interleave-evens-odds as .head       = P.refl
-interleave-evens-odds as .tail .head = P.refl
+interleave-evens-odds as .head       = refl
+interleave-evens-odds as .tail .head = refl
 interleave-evens-odds as .tail .tail = interleave-evens-odds (as .tail .tail)
 
 ------------------------------------------------------------------------
@@ -331,3 +333,9 @@ map-fusion = map-∘
 "Warning: map-fusion was deprecated in v2.0.
 Please use map-∘ instead."
 #-}
+
+drop-fusion = drop-drop
+{-# WARNING_ON_USAGE drop-fusion
+"Warning: drop-fusion was deprecated in v2.0.
+Please use drop-drop instead."
+#-}
diff --git a/src/Codata/Guarded/Stream/Relation/Binary/Pointwise.agda b/src/Codata/Guarded/Stream/Relation/Binary/Pointwise.agda
index 8f829297a0..0ba8d9539c 100644
--- a/src/Codata/Guarded/Stream/Relation/Binary/Pointwise.agda
+++ b/src/Codata/Guarded/Stream/Relation/Binary/Pointwise.agda
@@ -12,8 +12,13 @@ open import Codata.Guarded.Stream as Stream using (Stream; head; tail)
 open import Data.Nat.Base using (ℕ; zero; suc)
 open import Function.Base using (_∘_; _on_)
 open import Level using (Level; _⊔_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (REL; _⇒_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions
+  using (Reflexive; Sym; Trans; Antisym; Symmetric; Transitive)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 private
   variable
@@ -25,6 +30,8 @@ private
 ------------------------------------------------------------------------
 -- Bisimilarity
 
+infixr 5 _∷_
+
 record Pointwise (_∼_ : REL A B ℓ) (as : Stream A) (bs : Stream B) : Set ℓ where
   coinductive
   constructor _∷_
@@ -107,23 +114,27 @@ module _ {A : Set a} where
  _≈_ = Pointwise _≡_
 
  refl : Reflexive _≈_
- refl = reflexive P.refl
+ refl = reflexive ≡.refl
 
  sym : Symmetric _≈_
- sym = symmetric P.sym
+ sym = symmetric ≡.sym
 
  trans : Transitive _≈_
- trans = transitive P.trans
+ trans = transitive ≡.trans
 
  ≈-setoid : Setoid _ _
- ≈-setoid = setoid (P.setoid A)
+ ≈-setoid = setoid (≡.setoid A)
 
 ------------------------------------------------------------------------
 -- Pointwise DSL
+--
 -- A guardedness check does not play well with compositional proofs.
 -- Luckily we can learn from Nils Anders Danielsson's
 -- Beating the Productivity Checker Using Embedded Languages
 -- and design a little compositional DSL to define such proofs
+--
+-- NOTE: also because of the guardedness check we can't use the standard
+-- `Relation.Binary.Reasoning.Syntax` approach.
 
 module pw-Reasoning (S : Setoid a ℓ) where
   private module S = Setoid S
@@ -150,7 +161,7 @@ module pw-Reasoning (S : Setoid a ℓ) where
 
   `head : ∀ {as bs} → `Pointwise as bs → as .head ∼ bs .head
   `head (`lift rs)         = rs .head
-  `head (`refl eq)         = S.reflexive (P.cong head eq)
+  `head (`refl eq)         = S.reflexive (≡.cong head eq)
   `head (`bisim rs)        = S.reflexive (rs .head)
   `head (`step `rs)        = `rs .head
   `head (`sym `rs)         = S.sym (`head `rs)
@@ -158,7 +169,7 @@ module pw-Reasoning (S : Setoid a ℓ) where
 
   `tail : ∀ {as bs} → `Pointwise as bs → `Pointwise (as .tail)  (bs .tail)
   `tail (`lift rs)         = `lift (rs .tail)
-  `tail (`refl eq)         = `refl (P.cong tail eq)
+  `tail (`refl eq)         = `refl (≡.cong tail eq)
   `tail (`bisim rs)        = `bisim (rs .tail)
   `tail (`step `rs)        = `rs .tail
   `tail (`sym `rs)         = `sym (`tail `rs)
@@ -169,7 +180,7 @@ module pw-Reasoning (S : Setoid a ℓ) where
   run `rs .tail = run (`tail `rs)
 
   infix  1 begin_
-  infixr 2 _↺⟨_⟩_ _↺˘⟨_⟩_ _∼⟨_⟩_ _∼˘⟨_⟩_ _≈⟨_⟩_ _≈˘⟨_⟩_ _≡⟨_⟩_ _≡˘⟨_⟩_ _≡⟨⟩_
+  infixr 2 _↺⟨_⟩_ _↺⟨_⟨_ _∼⟨_⟩_ _∼⟨_⟨_ _≈⟨_⟩_ _≈⟨_⟨_ _≡⟨_⟩_ _≡⟨_⟨_ _≡⟨⟩_
   infix  3 _∎
 
   -- Beginning of a proof
@@ -178,17 +189,44 @@ module pw-Reasoning (S : Setoid a ℓ) where
   (begin `rs) .tail = run (`rs .tail)
 
   pattern _↺⟨_⟩_  as as∼bs bs∼cs = `trans {as = as} (`step as∼bs) bs∼cs
-  pattern _↺˘⟨_⟩_ as bs∼as bs∼cs = `trans {as = as} (`sym (`step bs∼as)) bs∼cs
+  pattern _↺⟨_⟨_ as bs∼as bs∼cs = `trans {as = as} (`sym (`step bs∼as)) bs∼cs
   pattern _∼⟨_⟩_  as as∼bs bs∼cs = `trans {as = as} (`lift as∼bs) bs∼cs
-  pattern _∼˘⟨_⟩_ as bs∼as bs∼cs = `trans {as = as} (`sym (`lift bs∼as)) bs∼cs
+  pattern _∼⟨_⟨_ as bs∼as bs∼cs = `trans {as = as} (`sym (`lift bs∼as)) bs∼cs
   pattern _≈⟨_⟩_  as as∼bs bs∼cs = `trans {as = as} (`bisim as∼bs) bs∼cs
-  pattern _≈˘⟨_⟩_ as bs∼as bs∼cs = `trans {as = as} (`sym (`bisim bs∼as)) bs∼cs
+  pattern _≈⟨_⟨_ as bs∼as bs∼cs = `trans {as = as} (`sym (`bisim bs∼as)) bs∼cs
   pattern _≡⟨_⟩_  as as∼bs bs∼cs = `trans {as = as} (`refl as∼bs) bs∼cs
+  pattern _≡⟨_⟨_ as bs∼as bs∼cs = `trans {as = as} (`sym (`refl bs∼as)) bs∼cs
+  pattern _≡⟨⟩_   as as∼bs       = `trans {as = as} (`refl ≡.refl) as∼bs
+  pattern _∎      as             = `refl  {as = as} ≡.refl
+
+
+  -- Deprecated v2.0
+  infixr 2 _↺˘⟨_⟩_ _∼˘⟨_⟩_ _≈˘⟨_⟩_ _≡˘⟨_⟩_
+  pattern _↺˘⟨_⟩_ as bs∼as bs∼cs = `trans {as = as} (`sym (`step bs∼as)) bs∼cs
+  pattern _∼˘⟨_⟩_ as bs∼as bs∼cs = `trans {as = as} (`sym (`lift bs∼as)) bs∼cs
+  pattern _≈˘⟨_⟩_ as bs∼as bs∼cs = `trans {as = as} (`sym (`bisim bs∼as)) bs∼cs
   pattern _≡˘⟨_⟩_ as bs∼as bs∼cs = `trans {as = as} (`sym (`refl bs∼as)) bs∼cs
-  pattern _≡⟨⟩_   as as∼bs       = `trans {as = as} (`refl P.refl) as∼bs
-  pattern _∎      as             = `refl  {as = as} P.refl
+  {-# WARNING_ON_USAGE _↺˘⟨_⟩_
+  "Warning: _↺˘⟨_⟩_ was deprecated in v2.0.
+  Please use _↺⟨_⟨_ instead."
+  #-}
+  {-# WARNING_ON_USAGE _∼˘⟨_⟩_
+  "Warning: _∼˘⟨_⟩_ was deprecated in v2.0.
+  Please use _∼⟨_⟨_ instead."
+  #-}
+  {-# WARNING_ON_USAGE _≈˘⟨_⟩_
+  "Warning: _≈˘⟨_⟩_ was deprecated in v2.0.
+  Please use _≈⟨_⟨_ instead."
+  #-}
+  {-# WARNING_ON_USAGE _≡˘⟨_⟩_
+  "Warning: _≡˘⟨_⟩_ was deprecated in v2.0.
+  Please use _≡⟨_⟨_ instead."
+  #-}
+
 
 module ≈-Reasoning {a} {A : Set a} where
 
-  open pw-Reasoning (P.setoid A) public
+  open pw-Reasoning (≡.setoid A) public
+
+  infix 4 _≈∞_
   _≈∞_ = `Pointwise∞
diff --git a/src/Codata/Guarded/Stream/Relation/Unary/All.agda b/src/Codata/Guarded/Stream/Relation/Unary/All.agda
index c69ff9124b..69171a8960 100644
--- a/src/Codata/Guarded/Stream/Relation/Unary/All.agda
+++ b/src/Codata/Guarded/Stream/Relation/Unary/All.agda
@@ -9,7 +9,7 @@
 module Codata.Guarded.Stream.Relation.Unary.All where
 
 open import Codata.Guarded.Stream using (Stream; head; tail)
-open import Data.Product using (_,_; proj₁; proj₂)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Level
 open import Relation.Unary
 
@@ -20,6 +20,8 @@ private
     P Q R : Pred A p
     xs : Stream A
 
+infixr 5 _∷_
+
 record All (P : Pred A ℓ) (as : Stream A) : Set ℓ where
   coinductive
   constructor _∷_
diff --git a/src/Codata/Musical/Cofin.agda b/src/Codata/Musical/Cofin.agda
index 082a6848dd..bc901ef194 100644
--- a/src/Codata/Musical/Cofin.agda
+++ b/src/Codata/Musical/Cofin.agda
@@ -12,7 +12,7 @@ open import Codata.Musical.Notation
 open import Codata.Musical.Conat as Conat using (Coℕ; suc; ∞ℕ)
 open import Data.Nat.Base using (ℕ; zero; suc)
 open import Data.Fin.Base using (Fin; zero; suc)
-open import Relation.Binary.PropositionalEquality using (_≡_ ; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_ ; refl)
 open import Function.Base using (_∋_)
 
 ------------------------------------------------------------------------
diff --git a/src/Codata/Musical/Colist.agda b/src/Codata/Musical/Colist.agda
index c218a7f023..74bd2a2aa4 100644
--- a/src/Codata/Musical/Colist.agda
+++ b/src/Codata/Musical/Colist.agda
@@ -21,22 +21,24 @@ open import Data.Maybe.Relation.Unary.Any using (just)
 open import Data.Nat.Base using (ℕ; zero; suc)
 open import Data.List.Base using (List; []; _∷_)
 open import Data.List.NonEmpty using (List⁺; _∷_)
-open import Data.Product as Prod using (∃; _×_; _,_)
+open import Data.Product.Base as Product using (∃; _×_; _,_)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_]′)
 open import Data.Vec.Bounded as Vec≤ using (Vec≤)
 open import Function.Base
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Inverse as Inv using (_↔_; _↔̇_; Inverse; inverse)
+open import Function.Bundles
 open import Level using (_⊔_)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles using (Poset; Setoid; Preorder)
+open import Relation.Binary.Definitions using (Transitive; Antisymmetric)
 import Relation.Binary.Construct.FromRel as Ind
-import Relation.Binary.Reasoning.Preorder as PreR
-import Relation.Binary.Reasoning.PartialOrder as POR
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+import Relation.Binary.Reasoning.Preorder as ≲-Reasoning
+import Relation.Binary.Reasoning.PartialOrder as ≤-Reasoning
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
+open import Relation.Binary.Reasoning.Syntax
 open import Relation.Nullary.Reflects using (invert)
 open import Relation.Nullary
 open import Relation.Nullary.Negation
-open import Relation.Nullary.Decidable using (excluded-middle)
+open import Relation.Nullary.Decidable using (¬¬-excluded-middle)
 open import Relation.Unary using (Pred)
 
 private
@@ -66,8 +68,8 @@ take (suc n) []       = Vec≤.[]
 take (suc n) (x ∷ xs) = x Vec≤.∷ take n (♭ xs)
 
 
-module ¬¬Monad {p} where
-  open RawMonad (¬¬-Monad {p}) public
+module ¬¬Monad {a} where
+  open RawMonad (¬¬-Monad {a}) public
 open ¬¬Monad  -- we don't want the RawMonad content to be opened publicly
 
 ------------------------------------------------------------------------
@@ -98,33 +100,30 @@ data _⊑_ {A : Set a} : Rel (Colist A) a where
 -- Any can be expressed using _∈_ (and vice versa).
 
 Any-∈ : ∀ {xs} → Any P xs ↔ ∃ λ x → x ∈ xs × P x
-Any-∈ {P = P} = record
-  { to         = P.→-to-⟶ to
-  ; from       = P.→-to-⟶ (λ { (x , x∈xs , p) → from x∈xs p })
-  ; inverse-of = record
-    { left-inverse-of  = from∘to
-    ; right-inverse-of = λ { (x , x∈xs , p) → to∘from x∈xs p }
-    }
-  }
+Any-∈ {P = P} = mk↔ₛ′
+  to
+  (λ { (x , x∈xs , p) → from x∈xs p })
+  (λ { (x , x∈xs , p) → to∘from x∈xs p })
+  from∘to
   where
   to : ∀ {xs} → Any P xs → ∃ λ x → x ∈ xs × P x
-  to (here  p) = _ , here P.refl , p
-  to (there p) = Prod.map id (Prod.map there id) (to p)
+  to (here  p) = _ , here refl , p
+  to (there p) = Product.map id (Product.map there id) (to p)
 
   from : ∀ {x xs} → x ∈ xs → P x → Any P xs
-  from (here P.refl) p = here p
+  from (here refl) p = here p
   from (there x∈xs)  p = there (from x∈xs p)
 
   to∘from : ∀ {x xs} (x∈xs : x ∈ xs) (p : P x) →
             to (from x∈xs p) ≡ (x , x∈xs , p)
-  to∘from (here P.refl) p = P.refl
+  to∘from (here refl) p = refl
   to∘from (there x∈xs)  p =
-    P.cong (Prod.map id (Prod.map there id)) (to∘from x∈xs p)
+    cong (Product.map id (Product.map there id)) (to∘from x∈xs p)
 
   from∘to : ∀ {xs} (p : Any P xs) →
             let (x , x∈xs , px) = to p in from x∈xs px ≡ p
-  from∘to (here _)  = P.refl
-  from∘to (there p) = P.cong there (from∘to p)
+  from∘to (here _)  = refl
+  from∘to (there p) = cong there (from∘to p)
 
 -- Prefixes are subsets.
 
@@ -165,38 +164,39 @@ Any-∈ {P = P} = record
   antisym (x ∷ p₁) p₂ = x ∷ ♯ antisym (♭ p₁) (tail p₂)
 
 module ⊑-Reasoning {a} {A : Set a} where
-  private module Base = POR (⊑-Poset A)
+  private module Base = ≤-Reasoning (⊑-Poset A)
 
-  open Base public
-    hiding (step-<; begin-strict_; step-≤)
+  open Base public hiding (step-<; step-≤)
+
+  open ⊑-syntax _IsRelatedTo_ _IsRelatedTo_ Base.≤-go public
+  open ⊏-syntax _IsRelatedTo_ _IsRelatedTo_ Base.<-go public
 
-  infixr 2 step-⊑
-  step-⊑ = Base.step-≤
-  syntax step-⊑ x ys⊑zs xs⊑ys = x ⊑⟨ xs⊑ys ⟩ ys⊑zs
 
 -- The subset relation forms a preorder.
 
 ⊆-Preorder : ∀ {ℓ} → Set ℓ → Preorder _ _ _
 ⊆-Preorder A = Ind.preorder (setoid A) _∈_
-                 (λ xs≈ys → ⊑⇒⊆ (⊑P.reflexive xs≈ys))
-  where module ⊑P = Poset (⊑-Poset A)
+                 (λ xs≈ys → ⊑⇒⊆ (⊑A.reflexive xs≈ys))
+  where module ⊑A = Poset (⊑-Poset A)
 
+-- Example uses:
+--
+--    x∈zs : x ∈ zs
+--    x∈zs =
+--      x  ∈⟨ x∈xs ⟩
+--      xs ⊆⟨ xs⊆ys ⟩
+--      ys ≡⟨ ys≡zs ⟩
+--      zs  ∎
 module ⊆-Reasoning {A : Set a} where
-  private module Base = PreR (⊆-Preorder A)
+  private module Base = ≲-Reasoning (⊆-Preorder A)
 
   open Base public
-    hiding (step-∼)
-
-  infixr 2 step-⊆
-  infix  1 step-∈
+    hiding (step-≲; step-∼)
+    renaming (≲-go to ⊆-go)
 
-  step-⊆ = Base.step-∼
+  open begin-membership-syntax _IsRelatedTo_ _∈_ (λ x → begin x)
+  open ⊆-syntax _IsRelatedTo_ _IsRelatedTo_ ⊆-go public
 
-  step-∈ : ∀ (x : A) {xs ys} → xs IsRelatedTo ys → x ∈ xs → x ∈ ys
-  step-∈ x xs⊆ys x∈xs = (begin xs⊆ys) x∈xs
-
-  syntax step-⊆ xs ys⊆zs xs⊆ys = xs ⊆⟨ xs⊆ys ⟩ ys⊆zs
-  syntax step-∈ x  xs⊆ys x∈xs  = x  ∈⟨ x∈xs  ⟩ xs⊆ys
 
 -- take returns a prefix.
 take-⊑ : ∀ n (xs : Colist A) →
@@ -215,10 +215,12 @@ data Finite {A : Set a} : Colist A → Set a where
   []  : Finite []
   _∷_ : ∀ x {xs} (fin : Finite (♭ xs)) → Finite (x ∷ xs)
 
+infixr 5 _∷_
+
 module Finite-injective where
 
  ∷-injective : ∀ {x : A} {xs p q} → (Finite (x ∷ xs) ∋ x ∷ p) ≡ x ∷ q → p ≡ q
- ∷-injective P.refl = P.refl
+ ∷-injective refl = refl
 
 -- Infinite xs means that xs has infinite length.
 
@@ -228,7 +230,7 @@ data Infinite {A : Set a} : Colist A → Set a where
 module Infinite-injective where
 
  ∷-injective : ∀ {x : A} {xs p q} → (Infinite (x ∷ xs) ∋ x ∷ p) ≡ x ∷ q → p ≡ q
- ∷-injective P.refl = P.refl
+ ∷-injective refl = refl
 
 -- Colists which are not finite are infinite.
 
@@ -242,7 +244,7 @@ not-finite-is-infinite (x ∷ xs) hyp =
 
 finite-or-infinite :
   (xs : Colist A) → ¬ ¬ (Finite xs ⊎ Infinite xs)
-finite-or-infinite xs = helper <$> excluded-middle
+finite-or-infinite xs = helper <$> ¬¬-excluded-middle
   where
   helper : Dec (Finite xs) → Finite xs ⊎ Infinite xs
   helper ( true because  [fin]) = inj₁ (invert [fin])
diff --git a/src/Codata/Musical/Colist/Bisimilarity.agda b/src/Codata/Musical/Colist/Bisimilarity.agda
index 8bcf5e5169..304e20db4b 100644
--- a/src/Codata/Musical/Colist/Bisimilarity.agda
+++ b/src/Codata/Musical/Colist/Bisimilarity.agda
@@ -11,7 +11,10 @@ module Codata.Musical.Colist.Bisimilarity where
 open import Codata.Musical.Colist.Base
 open import Codata.Musical.Notation
 open import Level using (Level)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _=[_]⇒_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
 
 private
   variable
@@ -27,6 +30,8 @@ data _≈_ {A : Set a} : Rel (Colist A) a where
   []  :                                       []     ≈ []
   _∷_ : ∀ x {xs ys} (xs≈ : ∞ (♭ xs ≈ ♭ ys)) → x ∷ xs ≈ x ∷ ys
 
+infixr 5 _∷_
+
 -- The equality relation forms a setoid.
 
 setoid : Set a → Setoid _ _
diff --git a/src/Codata/Musical/Colist/Infinite-merge.agda b/src/Codata/Musical/Colist/Infinite-merge.agda
index 9c859bcf26..c4343bd9e5 100644
--- a/src/Codata/Musical/Colist/Infinite-merge.agda
+++ b/src/Codata/Musical/Colist/Infinite-merge.agda
@@ -13,19 +13,29 @@ open import Codata.Musical.Colist as Colist hiding (_⋎_)
 open import Data.Nat.Base
 open import Data.Nat.Induction using (<′-wellFounded)
 open import Data.Nat.Properties
-open import Data.Product as Prod
+open import Data.Product.Base as Product using (_×_; _,_; ∃; ∃₂; proj₁; proj₂)
 open import Data.Sum.Base
 open import Data.Sum.Properties
 open import Data.Sum.Function.Propositional using (_⊎-cong_)
 open import Function.Base
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Inverse as Inv using (_↔_; Inverse; inverse)
-import Function.Related as Related
+open import Function.Bundles
+open import Function.Properties.Inverse using (↔-refl; ↔-sym; ↔⇒↣)
+import Function.Related.Propositional as Related
 open import Function.Related.TypeIsomorphisms
+open import Level
+open import Relation.Unary using (Pred)
 import Induction.WellFounded as WF
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 import Relation.Binary.Construct.On as On
 
+private
+  variable
+    a p : Level
+    A : Set a
+    P : Pred A p
+
 ------------------------------------------------------------------------
 -- Some code that is used to work around Agda's syntactic guardedness
 -- checker.
@@ -34,74 +44,70 @@ private
 
   infixr 5 _∷_ _⋎_
 
-  data ColistP {a} (A : Set a) : Set a where
+  data ColistP (A : Set a) : Set a where
     []  : ColistP A
     _∷_ : A → ∞ (ColistP A) → ColistP A
     _⋎_ : ColistP A → ColistP A → ColistP A
 
-  data ColistW {a} (A : Set a) : Set a where
+  data ColistW (A : Set a) : Set a where
     []  : ColistW A
     _∷_ : A → ColistP A → ColistW A
 
-  program : ∀ {a} {A : Set a} → Colist A → ColistP A
+  program : Colist A → ColistP A
   program []       = []
   program (x ∷ xs) = x ∷ ♯ program (♭ xs)
 
   mutual
 
-    _⋎W_ : ∀ {a} {A : Set a} → ColistW A → ColistP A → ColistW A
+    _⋎W_ : ColistW A → ColistP A → ColistW A
     []       ⋎W ys = whnf ys
     (x ∷ xs) ⋎W ys = x ∷ (ys ⋎ xs)
 
-    whnf : ∀ {a} {A : Set a} → ColistP A → ColistW A
+    whnf : ColistP A → ColistW A
     whnf []        = []
     whnf (x ∷ xs)  = x ∷ ♭ xs
     whnf (xs ⋎ ys) = whnf xs ⋎W ys
 
   mutual
 
-    ⟦_⟧P : ∀ {a} {A : Set a} → ColistP A → Colist A
+    ⟦_⟧P : ColistP A → Colist A
     ⟦ xs ⟧P = ⟦ whnf xs ⟧W
 
-    ⟦_⟧W : ∀ {a} {A : Set a} → ColistW A → Colist A
+    ⟦_⟧W : ColistW A → Colist A
     ⟦ [] ⟧W     = []
     ⟦ x ∷ xs ⟧W = x ∷ ♯ ⟦ xs ⟧P
 
   mutual
 
-    ⋎-homP : ∀ {a} {A : Set a} (xs : ColistP A) {ys} →
-             ⟦ xs ⋎ ys ⟧P ≈ ⟦ xs ⟧P Colist.⋎ ⟦ ys ⟧P
+    ⋎-homP : ∀ (xs : ColistP A) {ys} → ⟦ xs ⋎ ys ⟧P ≈ ⟦ xs ⟧P Colist.⋎ ⟦ ys ⟧P
     ⋎-homP xs = ⋎-homW (whnf xs) _
 
-    ⋎-homW : ∀ {a} {A : Set a} (xs : ColistW A) ys →
-             ⟦ xs ⋎W ys ⟧W ≈ ⟦ xs ⟧W Colist.⋎ ⟦ ys ⟧P
+    ⋎-homW : ∀ (xs : ColistW A) ys → ⟦ xs ⋎W ys ⟧W ≈ ⟦ xs ⟧W Colist.⋎ ⟦ ys ⟧P
     ⋎-homW (x ∷ xs) ys = x ∷ ♯ ⋎-homP ys
     ⋎-homW []       ys = begin ⟦ ys ⟧P ∎
       where open ≈-Reasoning
 
-  ⟦program⟧P : ∀ {a} {A : Set a} (xs : Colist A) →
-               ⟦ program xs ⟧P ≈ xs
+  ⟦program⟧P : ∀ (xs : Colist A) → ⟦ program xs ⟧P ≈ xs
   ⟦program⟧P []       = []
   ⟦program⟧P (x ∷ xs) = x ∷ ♯ ⟦program⟧P (♭ xs)
 
-  Any-⋎P : ∀ {a p} {A : Set a} {P : A → Set p} xs {ys} →
+  Any-⋎P : ∀ xs {ys} →
            Any P ⟦ program xs ⋎ ys ⟧P ↔ (Any P xs ⊎ Any P ⟦ ys ⟧P)
   Any-⋎P {P = P} xs {ys} =
-    Any P ⟦ program xs ⋎ ys ⟧P                ↔⟨ Any-cong Inv.id (⋎-homP (program xs)) ⟩
+    Any P ⟦ program xs ⋎ ys ⟧P                ↔⟨ Any-cong ↔-refl (⋎-homP (program xs)) ⟩
     Any P (⟦ program xs ⟧P Colist.⋎ ⟦ ys ⟧P)  ↔⟨ Any-⋎ _ ⟩
-    (Any P ⟦ program xs ⟧P ⊎ Any P ⟦ ys ⟧P)   ↔⟨ Any-cong Inv.id (⟦program⟧P _) ⊎-cong (_ ∎) ⟩
+    (Any P ⟦ program xs ⟧P ⊎ Any P ⟦ ys ⟧P)   ↔⟨ Any-cong ↔-refl (⟦program⟧P _) ⊎-cong (_ ∎) ⟩
     (Any P xs ⊎ Any P ⟦ ys ⟧P)                ∎
     where open Related.EquationalReasoning
 
   index-Any-⋎P :
-    ∀ {a p} {A : Set a} {P : A → Set p} xs {ys}
-    (p : Any P ⟦ program xs ⋎ ys ⟧P) →
-    index p ≥′ [ index , index ]′ (Inverse.to (Any-⋎P xs) ⟨$⟩ p)
+    ∀ xs {ys} (p : Any P ⟦ program xs ⋎ ys ⟧P) →
+    index p ≥′ [ index , index ]′ (Inverse.to (Any-⋎P xs) p)
   index-Any-⋎P xs p
     with       Any-resp      id  (⋎-homW (whnf (program xs)) _) p
        | index-Any-resp {f = id} (⋎-homW (whnf (program xs)) _) p
   index-Any-⋎P xs p | q | q≡p
-    with Inverse.to (Any-⋎ ⟦ program xs ⟧P) ⟨$⟩ q
+    with Inverse.to (Any-⋎ ⟦ program xs ⟧P)  q
        |       index-Any-⋎ ⟦ program xs ⟧P      q
   index-Any-⋎P xs p | q | q≡p | inj₂ r | r≤q rewrite q≡p = r≤q
   index-Any-⋎P xs p | q | q≡p | inj₁ r | r≤q
@@ -115,95 +121,90 @@ private
 
 private
 
-  merge′ : ∀ {a} {A : Set a} → Colist (A × Colist A) → ColistP A
+  merge′ : Colist (A × Colist A) → ColistP A
   merge′ []               = []
   merge′ ((x , xs) ∷ xss) = x ∷ ♯ (program xs ⋎ merge′ (♭ xss))
 
-merge : ∀ {a} {A : Set a} → Colist (A × Colist A) → Colist A
+merge : Colist (A × Colist A) → Colist A
 merge xss = ⟦ merge′ xss ⟧P
 
 ------------------------------------------------------------------------
 -- Any lemma for merge.
 
-module _ {a p} {A : Set a} {P : A → Set p} where
-
-  Any-merge : ∀ xss → Any P (merge xss) ↔ Any (λ { (x , xs) → P x ⊎ Any P xs }) xss
-  Any-merge xss = inverse (proj₁ ∘ to xss) from (proj₂ ∘ to xss) to∘from
+Any-merge : ∀ xss → Any P (merge xss) ↔ Any (λ { (x , xs) → P x ⊎ Any P xs }) xss
+Any-merge {P = P} xss = mk↔ₛ′ (proj₁ ∘ to xss) from to∘from (proj₂ ∘ to xss)
+  where
+  open ≡-Reasoning
+
+  -- The from function.
+
+  Q = λ { (x , xs) → P x ⊎ Any P xs }
+
+  from : ∀ {xss} → Any Q xss → Any P (merge xss)
+  from (here (inj₁ p))        = here p
+  from (here (inj₂ p))        = there (Inverse.from (Any-⋎P _)  (inj₁ p))
+  from (there {x = _ , xs} p) = there (Inverse.from (Any-⋎P xs) (inj₂ (from p)))
+
+  -- The from function is injective.
+
+  from-injective : ∀ {xss} (p₁ p₂ : Any Q xss) →
+                   from p₁ ≡ from p₂ → p₁ ≡ p₂
+  from-injective (here (inj₁ p))  (here (inj₁ .p)) refl = refl
+  from-injective (here (inj₂ p₁)) (here (inj₂ p₂)) eq     =
+    cong (here ∘ inj₂) $
+    inj₁-injective $
+    Injection.injective (↔⇒↣ (↔-sym (Any-⋎P _))) $
+    there-injective eq
+  from-injective (here (inj₂ p₁)) (there p₂) eq with
+    Injection.injective (↔⇒↣ (↔-sym (Any-⋎P _)))
+                        {x = inj₁ p₁} {y = inj₂ (from p₂)}
+                        (there-injective eq)
+  ... | ()
+  from-injective (there p₁) (here (inj₂ p₂)) eq with
+    Injection.injective (↔⇒↣ (↔-sym (Any-⋎P _)))
+                           {x = inj₂ (from p₁)} {y = inj₁ p₂}
+                           (there-injective eq)
+  ... | ()
+  from-injective (there {x = _ , xs} p₁) (there p₂) eq =
+    cong there $
+    from-injective p₁ p₂ $
+    inj₂-injective $
+    Injection.injective (↔⇒↣ (↔-sym (Any-⋎P xs))) $
+    there-injective eq
+  -- The to function (defined as a right inverse of from).
+
+  Input = ∃ λ xss → Any P (merge xss)
+
+  InputPred : Input → Set _
+  InputPred (xss , p) = ∃ λ (q : Any Q xss) → from q ≡ p
+
+  to : ∀ xss p → InputPred (xss , p)
+  to xss p =
+    WF.All.wfRec (On.wellFounded size <′-wellFounded) _
+                 InputPred step (xss , p)
     where
-    open P.≡-Reasoning
-
-    -- The from function.
-
-    Q = λ { (x , xs) → P x ⊎ Any P xs }
-
-    from : ∀ {xss} → Any Q xss → Any P (merge xss)
-    from (here (inj₁ p))        = here p
-    from (here (inj₂ p))        = there (Inverse.from (Any-⋎P _)  ⟨$⟩ inj₁ p)
-    from (there {x = _ , xs} p) = there (Inverse.from (Any-⋎P xs) ⟨$⟩ inj₂ (from p))
-
-    -- The from function is injective.
-
-    from-injective : ∀ {xss} (p₁ p₂ : Any Q xss) →
-                     from p₁ ≡ from p₂ → p₁ ≡ p₂
-    from-injective (here (inj₁ p))  (here (inj₁ .p)) P.refl = P.refl
-    from-injective (here (inj₂ p₁)) (here (inj₂ p₂)) eq     =
-      P.cong (here ∘ inj₂) $
-      inj₁-injective $
-      Inverse.injective (Inv.sym (Any-⋎P _)) {x = inj₁ p₁} {y = inj₁ p₂} $
-      there-injective eq
-    from-injective (here (inj₂ p₁)) (there p₂) eq
-      with Inverse.injective (Inv.sym (Any-⋎P _))
-                             {x = inj₁ p₁} {y = inj₂ (from p₂)}
-                             (there-injective eq)
-    ... | ()
-    from-injective (there p₁) (here (inj₂ p₂)) eq
-      with Inverse.injective (Inv.sym (Any-⋎P _))
-                             {x = inj₂ (from p₁)} {y = inj₁ p₂}
-                             (there-injective eq)
-    ... | ()
-    from-injective (there {x = _ , xs} p₁) (there p₂) eq =
-      P.cong there $
-      from-injective p₁ p₂ $
-      inj₂-injective $
-      Inverse.injective (Inv.sym (Any-⋎P xs))
-                        {x = inj₂ (from p₁)} {y = inj₂ (from p₂)} $
-      there-injective eq
-
-    -- The to function (defined as a right inverse of from).
-
-    Input = ∃ λ xss → Any P (merge xss)
-
-    Pred : Input → Set _
-    Pred (xss , p) = ∃ λ (q : Any Q xss) → from q ≡ p
-
-    to : ∀ xss p → Pred (xss , p)
-    to = λ xss p →
-      WF.All.wfRec (On.wellFounded size <′-wellFounded) _
-                   Pred step (xss , p)
-      where
-      size : Input → ℕ
-      size (_ , p) = index p
-
-      step : ∀ p → WF.WfRec (_<′_ on size) Pred p → Pred p
-      step ([]             , ())      rec
-      step ((x , xs) ∷ xss , here  p) rec = here (inj₁ p) , P.refl
-      step ((x , xs) ∷ xss , there p) rec
-        with Inverse.to (Any-⋎P xs) ⟨$⟩ p
-           | Inverse.left-inverse-of (Any-⋎P xs) p
-           | index-Any-⋎P xs p
-      ... | inj₁ q | P.refl | _   = here (inj₂ q) , P.refl
-      ... | inj₂ q | P.refl | q≤p =
-        Prod.map there
-                 (P.cong (there ∘ _⟨$⟩_ (Inverse.from (Any-⋎P xs)) ∘ inj₂))
-                 (rec (♭ xss , q) (s≤′s q≤p))
-
-    to∘from = λ p → from-injective _ _ (proj₂ (to xss (from p)))
+    size : Input → ℕ
+    size (_ , p) = index p
+
+    step : ∀ p → WF.WfRec (_<′_ on size) InputPred p → InputPred p
+    step ([]             , ())      rec
+    step ((x , xs) ∷ xss , here  p) rec = here (inj₁ p) , refl
+    step ((x , xs) ∷ xss , there p) rec
+      with Inverse.to (Any-⋎P xs) p
+         | Inverse.strictlyInverseʳ (Any-⋎P xs) p
+         | index-Any-⋎P xs p
+    ... | inj₁ q | refl | _   = here (inj₂ q) , refl
+    ... | inj₂ q | refl | q≤p =
+      Product.map there
+               (cong (there ∘ (Inverse.from (Any-⋎P xs)) ∘ inj₂))
+               (rec (s≤′s q≤p))
+
+  to∘from = λ p → from-injective _ _ (proj₂ (to xss (from p)))
 
 -- Every member of xss is a member of merge xss, and vice versa (with
 -- equal multiplicities).
 
-∈-merge : ∀ {a} {A : Set a} {y : A} xss →
-          y ∈ merge xss ↔ ∃₂ λ x xs → (x , xs) ∈ xss × (y ≡ x ⊎ y ∈ xs)
+∈-merge : ∀ {y : A} xss → y ∈ merge xss ↔ ∃₂ λ x xs → (x , xs) ∈ xss × (y ≡ x ⊎ y ∈ xs)
 ∈-merge {y = y} xss =
   y ∈ merge xss                                           ↔⟨ Any-merge _ ⟩
   Any (λ { (x , xs) → y ≡ x ⊎ y ∈ xs }) xss               ↔⟨ Any-∈ ⟩
diff --git a/src/Codata/Musical/Colist/Relation/Unary/All.agda b/src/Codata/Musical/Colist/Relation/Unary/All.agda
index df997252c3..ce937dc2b6 100644
--- a/src/Codata/Musical/Colist/Relation/Unary/All.agda
+++ b/src/Codata/Musical/Colist/Relation/Unary/All.agda
@@ -23,3 +23,5 @@ private
 data All {A : Set a} (P : Pred A p) : Pred (Colist A) (a ⊔ p) where
   []  : All P []
   _∷_ : ∀ {x xs} (px : P x) (pxs : ∞ (All P (♭ xs))) → All P (x ∷ xs)
+
+infixr 5 _∷_
diff --git a/src/Codata/Musical/Colist/Relation/Unary/Any/Properties.agda b/src/Codata/Musical/Colist/Relation/Unary/Any/Properties.agda
index 8ea859f4a7..438922dc42 100644
--- a/src/Codata/Musical/Colist/Relation/Unary/Any/Properties.agda
+++ b/src/Codata/Musical/Colist/Relation/Unary/Any/Properties.agda
@@ -18,11 +18,10 @@ open import Data.Nat.Base using (suc; _≥′_; ≤′-refl; ≤′-step)
 open import Data.Nat.Properties using (s≤′s)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_]′; [_,_])
 open import Function.Base using (_∋_; _∘_)
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Inverse as Inv using (_↔_; _↔̇_; Inverse; inverse)
+open import Function.Bundles
 open import Level using (Level; _⊔_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Core
   using (_≡_; refl; cong)
 open import Relation.Unary using (Pred)
 
@@ -53,35 +52,29 @@ Any-resp f (x ∷ xs≈) (there p) = there (Any-resp f (♭ xs≈) p)
 -- isomorphic types.
 
 Any-cong : ∀ {a p q} {A : Set a} {P : A → Set p} {Q : A → Set q}
-           {xs ys} → P ↔̇ Q → xs ≈ ys → Any P xs ↔ Any Q ys
-Any-cong {A = A} {P} {Q} {xs} {ys} P↔Q = λ xs≈ys → record
-  { to         = P.→-to-⟶ (to xs≈ys)
-  ; from       = P.→-to-⟶ (from xs≈ys)
-  ; inverse-of = record
-    { left-inverse-of  = from∘to _
-    ; right-inverse-of = to∘from _
-    }
-  }
+           {xs ys} → (∀ {i} → P i ↔ Q i) → xs ≈ ys → Any P xs ↔ Any Q ys
+Any-cong {A = A} {P} {Q} {xs} {ys} P↔Q xs≈ys =
+  mk↔ₛ′ (to xs≈ys) (from xs≈ys) (to∘from _) (from∘to _)
   where
   open Setoid (setoid _) using (sym)
 
   to : ∀ {xs ys} → xs ≈ ys → Any P xs → Any Q ys
-  to xs≈ys = Any-resp (Inverse.to P↔Q ⟨$⟩_) xs≈ys
+  to xs≈ys = Any-resp (Inverse.to P↔Q) xs≈ys
 
   from : ∀ {xs ys} → xs ≈ ys → Any Q ys → Any P xs
-  from xs≈ys = Any-resp (Inverse.from P↔Q ⟨$⟩_) (sym xs≈ys)
+  from xs≈ys = Any-resp (Inverse.from P↔Q) (sym xs≈ys)
 
   to∘from : ∀ {xs ys} (xs≈ys : xs ≈ ys) (q : Any Q ys) →
             to xs≈ys (from xs≈ys q) ≡ q
-  to∘from (x ∷ xs≈) (there q) = P.cong there (to∘from (♭ xs≈) q)
+  to∘from (x ∷ xs≈) (there q) = cong there (to∘from (♭ xs≈) q)
   to∘from (x ∷ xs≈) (here qx) =
-    P.cong here (Inverse.right-inverse-of P↔Q qx)
+    cong here (Inverse.strictlyInverseˡ P↔Q qx)
 
   from∘to : ∀ {xs ys} (xs≈ys : xs ≈ ys) (p : Any P xs) →
             from xs≈ys (to xs≈ys p) ≡ p
-  from∘to (x ∷ xs≈) (there p) = P.cong there (from∘to (♭ xs≈) p)
+  from∘to (x ∷ xs≈) (there p) = cong there (from∘to (♭ xs≈) p)
   from∘to (x ∷ xs≈) (here px) =
-    P.cong here (Inverse.left-inverse-of P↔Q px)
+    cong here (Inverse.strictlyInverseʳ P↔Q px)
 
 ------------------------------------------------------------------------
 -- map
@@ -97,8 +90,8 @@ module _ {f : A → B} where
   map⁺ (there p) = there (map⁺ p)
 
   Any-map : ∀ {xs} → Any P (map f xs) ↔ Any (P ∘ f) xs
-  Any-map {xs = xs} = inverse map⁻ map⁺ from∘to to∘from where
-
+  Any-map {xs = xs} = mk↔ₛ′ map⁻ map⁺ to∘from from∘to
+    where
     from∘to : ∀ {xs} (p : Any P (map f xs)) → map⁺ (map⁻ p) ≡ p
     from∘to {xs = x ∷ xs} (here px) = refl
     from∘to {xs = x ∷ xs} (there p) = cong there (from∘to p)
@@ -130,14 +123,7 @@ mutual
 
 Any-⋎ : ∀ {a p} {A : Set a} {P : A → Set p} xs {ys} →
         Any P (xs ⋎ ys) ↔ (Any P xs ⊎ Any P ys)
-Any-⋎ {P = P} = λ xs → record
-  { to         = P.→-to-⟶ (⋎⁻ xs)
-  ; from       = P.→-to-⟶ (⋎⁺ xs)
-  ; inverse-of = record
-    { left-inverse-of  = from∘to xs
-    ; right-inverse-of = to∘from xs
-    }
-  }
+Any-⋎ {P = P} xs = mk↔ₛ′ (⋎⁻ xs) (⋎⁺ xs) (to∘from xs) (from∘to xs)
   where
 
   from∘to : ∀ xs {ys} (p : Any P (xs ⋎ ys)) → ⋎⁺ xs (⋎⁻ xs p) ≡ p
@@ -178,7 +164,7 @@ lookup-index (there p) = lookup-index p
 index-Any-resp : ∀ {f : ∀ {x} → P x → Q x} {xs ys}
                  (xs≈ys : xs ≈ ys) (p : Any P xs) →
                  index (Any-resp f xs≈ys p) ≡ index p
-index-Any-resp (x ∷ xs≈) (here px) = P.refl
+index-Any-resp (x ∷ xs≈) (here px) = refl
 index-Any-resp (x ∷ xs≈) (there p) =
   cong suc (index-Any-resp (♭ xs≈) p)
 
@@ -186,10 +172,10 @@ index-Any-resp (x ∷ xs≈) (there p) =
 -- no larger than that of the input proof.
 
 index-Any-⋎ : ∀ xs {ys} (p : Any P (xs ⋎ ys)) →
-              index p ≥′ [ index , index ]′ (Inverse.to (Any-⋎ xs) ⟨$⟩ p)
+              index p ≥′ [ index , index ]′ (Inverse.to (Any-⋎ xs) p)
 index-Any-⋎ []                 p         = ≤′-refl
 index-Any-⋎ (x ∷ xs)           (here px) = ≤′-refl
 index-Any-⋎ (x ∷ xs) {ys = ys} (there p)
-  with Inverse.to (Any-⋎ ys) ⟨$⟩ p | index-Any-⋎ ys p
+  with Inverse.to (Any-⋎ ys) p | index-Any-⋎ ys p
 ... | inj₁ q | q≤p = ≤′-step q≤p
 ... | inj₂ q | q≤p = s≤′s    q≤p
diff --git a/src/Codata/Musical/Conat.agda b/src/Codata/Musical/Conat.agda
index 2d598fd75c..760d733a20 100644
--- a/src/Codata/Musical/Conat.agda
+++ b/src/Codata/Musical/Conat.agda
@@ -11,8 +11,10 @@ module Codata.Musical.Conat where
 open import Codata.Musical.Notation
 open import Data.Nat.Base using (ℕ; zero; suc)
 open import Function.Base using (_∋_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 ------------------------------------------------------------------------
 -- Re-exporting the type and basic operations
@@ -25,15 +27,17 @@ open import Codata.Musical.Conat.Base public
 module Coℕ-injective where
 
  suc-injective : ∀ {m n} → (Coℕ ∋ suc m) ≡ suc n → m ≡ n
- suc-injective P.refl = P.refl
+ suc-injective ≡.refl = ≡.refl
 
 fromℕ-injective : ∀ {m n} → fromℕ m ≡ fromℕ n → m ≡ n
-fromℕ-injective {zero}  {zero}  eq = P.refl
-fromℕ-injective {suc m} {suc n} eq = P.cong suc (fromℕ-injective (P.cong pred eq))
+fromℕ-injective {zero}  {zero}  eq = ≡.refl
+fromℕ-injective {suc m} {suc n} eq = ≡.cong suc (fromℕ-injective (≡.cong pred eq))
 
 ------------------------------------------------------------------------
 -- Equality
 
+infix 4 _≈_
+
 data _≈_ : Coℕ → Coℕ → Set where
   zero :                                 zero  ≈ zero
   suc  : ∀ {m n} (m≈n : ∞ (♭ m ≈ ♭ n)) → suc m ≈ suc n
@@ -41,7 +45,7 @@ data _≈_ : Coℕ → Coℕ → Set where
 module ≈-injective where
 
  suc-injective : ∀ {m n p q} → (suc m ≈ suc n ∋ suc p) ≡ suc q → p ≡ q
- suc-injective P.refl = P.refl
+ suc-injective ≡.refl = ≡.refl
 
 setoid : Setoid _ _
 setoid = record
diff --git a/src/Codata/Musical/Conversion.agda b/src/Codata/Musical/Conversion.agda
index d7213daba9..4e5886e000 100644
--- a/src/Codata/Musical/Conversion.agda
+++ b/src/Codata/Musical/Conversion.agda
@@ -27,7 +27,7 @@ open import Codata.Musical.Covec hiding (module Covec)
 open import Codata.Musical.M hiding (module M)
 open import Codata.Musical.Notation
 open import Codata.Musical.Stream hiding (module Stream)
-open import Data.Product
+open import Data.Product.Base using (_,_)
 open import Data.Container.Core as C using (Container)
 import Size
 
diff --git a/src/Codata/Musical/Covec.agda b/src/Codata/Musical/Covec.agda
index 48cc1910e8..64156344d9 100644
--- a/src/Codata/Musical/Covec.agda
+++ b/src/Codata/Musical/Covec.agda
@@ -14,11 +14,14 @@ open import Codata.Musical.Cofin using (Cofin; zero; suc)
 open import Codata.Musical.Colist as Colist using (Colist; []; _∷_)
 open import Data.Nat.Base using (ℕ; zero; suc)
 open import Data.Vec.Base using (Vec; []; _∷_)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (_∋_)
 open import Level using (Level)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (_⇒_; _=[_]⇒_)
+open import Relation.Binary.Bundles using (Setoid; Poset)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Antisymmetric)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 private
   variable
@@ -35,10 +38,10 @@ data Covec (A : Set a) : Coℕ → Set a where
   _∷_ : ∀ {n} (x : A) (xs : ∞ (Covec A (♭ n))) → Covec A (suc n)
 
 ∷-injectiveˡ : ∀ {a b} {n} {as bs} → (Covec A (suc n) ∋ a ∷ as) ≡ b ∷ bs → a ≡ b
-∷-injectiveˡ P.refl = P.refl
+∷-injectiveˡ ≡.refl = ≡.refl
 
 ∷-injectiveʳ : ∀ {a b} {n} {as bs} → (Covec A (suc n) ∋ a ∷ as) ≡ b ∷ bs → as ≡ bs
-∷-injectiveʳ P.refl = P.refl
+∷-injectiveʳ ≡.refl = ≡.refl
 
 ------------------------------------------------------------------------
 -- Some operations
diff --git a/src/Codata/Musical/M.agda b/src/Codata/Musical/M.agda
index 6c63de7ea2..5c724015bb 100644
--- a/src/Codata/Musical/M.agda
+++ b/src/Codata/Musical/M.agda
@@ -10,7 +10,7 @@ module Codata.Musical.M where
 
 open import Codata.Musical.Notation
 open import Level
-open import Data.Product hiding (map)
+open import Data.Product.Base hiding (map)
 open import Data.Container.Core as C hiding (map)
 
 -- The family of M-types.
diff --git a/src/Codata/Musical/M/Indexed.agda b/src/Codata/Musical/M/Indexed.agda
index 964aca0695..3eefda55e6 100644
--- a/src/Codata/Musical/M/Indexed.agda
+++ b/src/Codata/Musical/M/Indexed.agda
@@ -11,7 +11,7 @@ module Codata.Musical.M.Indexed where
 
 open import Level
 open import Codata.Musical.Notation
-open import Data.Product
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Data.Container.Indexed.Core
 open import Function.Base using (_∘_)
 open import Relation.Unary
diff --git a/src/Codata/Musical/Stream.agda b/src/Codata/Musical/Stream.agda
index 9b00ba510f..12bf3b5fb7 100644
--- a/src/Codata/Musical/Stream.agda
+++ b/src/Codata/Musical/Stream.agda
@@ -13,8 +13,10 @@ open import Codata.Musical.Notation
 open import Codata.Musical.Colist using (Colist; []; _∷_)
 open import Data.Vec.Base using (Vec; []; _∷_)
 open import Data.Nat.Base using (ℕ; zero; suc)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 private
   variable
@@ -142,13 +144,13 @@ setoid A = record
   }
   where
   refl : Reflexive _≈_
-  refl {_ ∷ _} = P.refl ∷ ♯ refl
+  refl {_ ∷ _} = ≡.refl ∷ ♯ refl
 
   sym : Symmetric _≈_
-  sym (x≡ ∷ xs≈) = P.sym x≡ ∷ ♯ sym (♭ xs≈)
+  sym (x≡ ∷ xs≈) = ≡.sym x≡ ∷ ♯ sym (♭ xs≈)
 
   trans : Transitive _≈_
-  trans (x≡ ∷ xs≈) (y≡ ∷ ys≈) = P.trans x≡ y≡ ∷ ♯ trans (♭ xs≈) (♭ ys≈)
+  trans (x≡ ∷ xs≈) (y≡ ∷ ys≈) = ≡.trans x≡ y≡ ∷ ♯ trans (♭ xs≈) (♭ ys≈)
 
 head-cong : {xs ys : Stream A} → xs ≈ ys → head xs ≡ head ys
 head-cong (x≡ ∷ _) = x≡
@@ -158,13 +160,13 @@ tail-cong (_ ∷ xs≈) = ♭ xs≈
 
 map-cong : ∀ (f : A → B) {xs ys} →
            xs ≈ ys → map f xs ≈ map f ys
-map-cong f (x≡ ∷ xs≈) = P.cong f x≡ ∷ ♯ map-cong f (♭ xs≈)
+map-cong f (x≡ ∷ xs≈) = ≡.cong f x≡ ∷ ♯ map-cong f (♭ xs≈)
 
 zipWith-cong : ∀ (_∙_ : A → B → C) {xs xs′ ys ys′} →
                xs ≈ xs′ → ys ≈ ys′ →
                zipWith _∙_ xs ys ≈ zipWith _∙_ xs′ ys′
 zipWith-cong _∙_ (x≡ ∷ xs≈) (y≡ ∷ ys≈) =
-  P.cong₂ _∙_ x≡ y≡ ∷ ♯ zipWith-cong _∙_ (♭ xs≈) (♭ ys≈)
+  ≡.cong₂ _∙_ x≡ y≡ ∷ ♯ zipWith-cong _∙_ (♭ xs≈) (♭ ys≈)
 
 infixr 5 _⋎-cong_
 
diff --git a/src/Codata/Sized/Cofin.agda b/src/Codata/Sized/Cofin.agda
index a7f74afb5f..e04be324de 100644
--- a/src/Codata/Sized/Cofin.agda
+++ b/src/Codata/Sized/Cofin.agda
@@ -8,15 +8,15 @@
 
 module Codata.Sized.Cofin where
 
-open import Size
-open import Codata.Sized.Thunk
+open import Size using (∞)
+open import Codata.Sized.Thunk using (force)
 open import Codata.Sized.Conat as Conat
   using (Conat; zero; suc; infinity; _ℕ<_; sℕ≤s; _ℕ≤infinity)
 open import Codata.Sized.Conat.Bisimilarity as Bisim using (_⊢_≲_ ; s≲s)
-open import Data.Nat.Base
-open import Data.Fin.Base as Fin hiding (fromℕ; fromℕ<; toℕ)
+open import Data.Nat.Base using (ℕ; zero; suc)
+open import Data.Fin.Base using (Fin; zero; suc)
 open import Function.Base using (_∋_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 ------------------------------------------------------------------------
 -- The type
diff --git a/src/Codata/Sized/Colist.agda b/src/Codata/Sized/Colist.agda
index c090565c33..0675721bab 100644
--- a/src/Codata/Sized/Colist.agda
+++ b/src/Codata/Sized/Colist.agda
@@ -12,7 +12,7 @@ open import Level using (Level)
 open import Size
 open import Data.Unit.Base
 open import Data.Nat.Base
-open import Data.Product using (_×_ ; _,_)
+open import Data.Product.Base using (_×_ ; _,_)
 open import Data.These.Base using (These; this; that; these)
 open import Data.Maybe.Base using (Maybe; nothing; just)
 open import Data.List.Base using (List; []; _∷_)
@@ -27,7 +27,7 @@ open import Codata.Sized.Cowriter as CW using (Cowriter; _∷_)
 open import Codata.Sized.Delay as Delay using (Delay ; now ; later)
 open import Codata.Sized.Stream using (Stream ; _∷_)
 
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 private
   variable
@@ -42,6 +42,8 @@ data Colist (A : Set a) (i : Size) : Set a where
   []  : Colist A i
   _∷_ : A → Thunk (Colist A) i → Colist A i
 
+infixr 5 _∷_
+
 ------------------------------------------------------------------------
 -- Relationship to Cowriter.
 
diff --git a/src/Codata/Sized/Colist/Bisimilarity.agda b/src/Codata/Sized/Colist/Bisimilarity.agda
index 9e626a5315..94370a7fc2 100644
--- a/src/Codata/Sized/Colist/Bisimilarity.agda
+++ b/src/Codata/Sized/Colist/Bisimilarity.agda
@@ -13,10 +13,15 @@ open import Size
 open import Codata.Sized.Thunk
 open import Codata.Sized.Colist
 open import Data.List.Base using (List; []; _∷_)
-open import Data.List.Relation.Binary.Pointwise using (Pointwise; []; _∷_)
+open import Data.List.Relation.Binary.Pointwise.Base using (Pointwise; []; _∷_)
 open import Data.List.NonEmpty as List⁺  using (List⁺; _∷_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as Eq using (_≡_)
+open import Relation.Binary.Core using (REL; Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Sym; Trans)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 private
   variable
@@ -32,6 +37,8 @@ data Bisim {A : Set a} {B : Set b} (R : REL A B r) (i : Size) :
   _∷_ : ∀ {x y xs ys} → R x y → Thunk^R (Bisim R) i xs ys →
         Bisim R i (x ∷ xs) (y ∷ ys)
 
+infixr 5 _∷_
+
 module _ {R : Rel A r} where
 
  reflexive : Reflexive R → Reflexive (Bisim R i)
@@ -75,16 +82,16 @@ module _ {A : Set a} where
   _⊢_≈_ = Bisim _≡_
 
   refl : Reflexive (i ⊢_≈_)
-  refl = reflexive Eq.refl
+  refl = reflexive ≡.refl
 
   fromEq : ∀ {as bs} → as ≡ bs → i ⊢ as ≈ bs
-  fromEq Eq.refl = refl
+  fromEq ≡.refl = refl
 
   sym : Symmetric (i ⊢_≈_)
-  sym = symmetric Eq.sym
+  sym = symmetric ≡.sym
 
   trans : Transitive (i ⊢_≈_)
-  trans = transitive Eq.trans
+  trans = transitive ≡.trans
 
 isEquivalence : {R : Rel A r} → IsEquivalence R → IsEquivalence (Bisim R i)
 isEquivalence equiv^R = record
@@ -100,4 +107,4 @@ setoid S i = record
 
 module ≈-Reasoning {a} {A : Set a} {i} where
 
-  open import Relation.Binary.Reasoning.Setoid (setoid (Eq.setoid A) i) public
+  open import Relation.Binary.Reasoning.Setoid (setoid (≡.setoid A) i) public
diff --git a/src/Codata/Sized/Colist/Categorical.agda b/src/Codata/Sized/Colist/Categorical.agda
new file mode 100644
index 0000000000..6cee36ca22
--- /dev/null
+++ b/src/Codata/Sized/Colist/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Codata.Sized.Colist.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --sized-types #-}
+
+module Codata.Sized.Colist.Categorical where
+
+open import Codata.Sized.Colist.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Codata.Sized.Colist.Categorical was deprecated in v2.0.
+Use Codata.Sized.Colist.Effectful instead."
+#-}
diff --git a/src/Codata/Sized/Colist/Properties.agda b/src/Codata/Sized/Colist/Properties.agda
index 3de56a756a..3a9958b715 100644
--- a/src/Codata/Sized/Colist/Properties.agda
+++ b/src/Codata/Sized/Colist/Properties.agda
@@ -14,24 +14,25 @@ open import Codata.Sized.Thunk as Thunk using (Thunk; force)
 open import Codata.Sized.Colist
 open import Codata.Sized.Colist.Bisimilarity
 open import Codata.Sized.Conat
-open import Codata.Sized.Conat.Bisimilarity as coℕᵇ using (zero; suc)
-import Codata.Sized.Conat.Properties as coℕₚ
+open import Codata.Sized.Conat.Bisimilarity as Conat using (zero; suc)
+import Codata.Sized.Conat.Properties as Conat
 open import Codata.Sized.Cowriter as Cowriter using ([_]; _∷_)
-open import Codata.Sized.Cowriter.Bisimilarity as coWriterᵇ using ([_]; _∷_)
+open import Codata.Sized.Cowriter.Bisimilarity as Cowriter using ([_]; _∷_)
 open import Codata.Sized.Stream as Stream using (Stream; _∷_)
 open import Data.Vec.Bounded as Vec≤ using (Vec≤)
 open import Data.List.Base as List using (List; []; _∷_)
 open import Data.List.NonEmpty as List⁺ using (List⁺; _∷_)
+import Data.List.Scans.Base as Scans
 open import Data.List.Relation.Binary.Equality.Propositional using (≋-refl)
 open import Data.Maybe.Base as Maybe using (Maybe; nothing; just)
-import Data.Maybe.Properties as Maybeₚ
+import Data.Maybe.Properties as Maybe
 open import Data.Maybe.Relation.Unary.All using (All; nothing; just)
 open import Data.Nat.Base as ℕ using (zero; suc; z≤n; s≤s)
-open import Data.Product as Prod using (_×_; _,_; uncurry)
+open import Data.Product.Base as Product using (_×_; _,_; uncurry)
 open import Data.These.Base as These using (These; this; that; these)
 open import Data.Vec.Base as Vec using (Vec; []; _∷_)
 open import Function.Base
-open import Relation.Binary.PropositionalEquality as Eq using (_≡_; [_])
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 private
   variable
@@ -47,13 +48,13 @@ private
 
 map-id : ∀ (as : Colist A ∞) → i ⊢ map id as ≈ as
 map-id []       = []
-map-id (a ∷ as) = Eq.refl ∷ λ where .force → map-id (as .force)
+map-id (a ∷ as) = ≡.refl ∷ λ where .force → map-id (as .force)
 
 map-∘ : ∀ (f : A → B) (g : B → C) as {i} →
                  i ⊢ map g (map f as) ≈ map (g ∘ f) as
 map-∘ f g []       = []
 map-∘ f g (a ∷ as) =
-  Eq.refl ∷ λ where .force → map-∘ f g (as .force)
+  ≡.refl ∷ λ where .force → map-∘ f g (as .force)
 
 ------------------------------------------------------------------------
 -- Relation to Cowriter
@@ -62,24 +63,24 @@ fromCowriter∘toCowriter≗id : ∀ (as : Colist A ∞) →
   i ⊢ fromCowriter (toCowriter as) ≈ as
 fromCowriter∘toCowriter≗id []       = []
 fromCowriter∘toCowriter≗id (a ∷ as) =
-  Eq.refl ∷ λ where .force → fromCowriter∘toCowriter≗id (as .force)
+  ≡.refl ∷ λ where .force → fromCowriter∘toCowriter≗id (as .force)
 
 ------------------------------------------------------------------------
 -- Properties of length
 
-length-∷ : ∀ (a : A) as → i coℕᵇ.⊢ length (a ∷ as) ≈ 1 ℕ+ length (as .force)
-length-∷ a as = suc (λ where .force → coℕᵇ.refl)
+length-∷ : ∀ (a : A) as → i Conat.⊢ length (a ∷ as) ≈ 1 ℕ+ length (as .force)
+length-∷ a as = suc (λ where .force → Conat.refl)
 
-length-replicate : ∀ n (a : A) → i coℕᵇ.⊢ length (replicate n a) ≈ n
+length-replicate : ∀ n (a : A) → i Conat.⊢ length (replicate n a) ≈ n
 length-replicate zero    a = zero
 length-replicate (suc n) a = suc λ where .force → length-replicate (n .force) a
 
 length-++ : (as bs : Colist A ∞) →
-            i coℕᵇ.⊢ length (as ++ bs) ≈ length as + length bs
-length-++ []       bs = coℕᵇ.refl
+            i Conat.⊢ length (as ++ bs) ≈ length as + length bs
+length-++ []       bs = Conat.refl
 length-++ (a ∷ as) bs = suc λ where .force → length-++ (as .force) bs
 
-length-map : ∀ (f : A → B) as → i coℕᵇ.⊢ length (map f as) ≈ length as
+length-map : ∀ (f : A → B) as → i Conat.⊢ length (map f as) ≈ length as
 length-map f []       = zero
 length-map f (a ∷ as) = suc λ where .force → length-map f (as .force)
 
@@ -89,51 +90,51 @@ length-map f (a ∷ as) = suc λ where .force → length-map f (as .force)
 replicate-+ : ∀ m n (a : A) →
               i ⊢ replicate (m + n) a ≈ replicate m a ++ replicate n a
 replicate-+ zero    n a = refl
-replicate-+ (suc m) n a = Eq.refl ∷ λ where .force → replicate-+ (m .force) n a
+replicate-+ (suc m) n a = ≡.refl ∷ λ where .force → replicate-+ (m .force) n a
 
 map-replicate : ∀ (f : A → B) n a →
                 i ⊢ map f (replicate n a) ≈ replicate n (f a)
 map-replicate f zero    a = []
 map-replicate f (suc n) a =
-  Eq.refl ∷ λ where .force → map-replicate f (n .force) a
+  ≡.refl ∷ λ where .force → map-replicate f (n .force) a
 
 lookup-replicate : ∀ k n (a : A) → All (a ≡_) (lookup (replicate n a) k)
 lookup-replicate k zero          a = nothing
-lookup-replicate zero    (suc n) a = just Eq.refl
+lookup-replicate zero    (suc n) a = just ≡.refl
 lookup-replicate (suc k) (suc n) a = lookup-replicate k (n .force) a
 
 ------------------------------------------------------------------------
 -- Properties of unfold
 
 map-unfold : ∀ (f : B → C) (alg : A → Maybe (A × B)) a →
-             i ⊢ map f (unfold alg a) ≈ unfold (Maybe.map (Prod.map₂ f) ∘ alg) a
+             i ⊢ map f (unfold alg a) ≈ unfold (Maybe.map (Product.map₂ f) ∘ alg) a
 map-unfold f alg a with alg a
 ... | nothing       = []
-... | just (a′ , b) = Eq.refl ∷ λ where .force → map-unfold f alg a′
+... | just (a′ , b) = ≡.refl ∷ λ where .force → map-unfold f alg a′
 
 module _ {alg : A → Maybe (A × B)} {a} where
 
   unfold-nothing : alg a ≡ nothing → unfold alg a ≡ []
   unfold-nothing eq with alg a
-  ... | nothing = Eq.refl
+  ... | nothing = ≡.refl
 
   unfold-just : ∀ {a′ b} → alg a ≡ just (a′ , b) →
                 i ⊢ unfold alg a ≈ b ∷ λ where .force → unfold alg a′
   unfold-just eq with alg a
-  unfold-just Eq.refl | just (a′ , b) = Eq.refl ∷ λ where .force → refl
+  unfold-just ≡.refl | just (a′ , b) = ≡.refl ∷ λ where .force → refl
 
 ------------------------------------------------------------------------
 -- Properties of scanl
 
 length-scanl : ∀ (c : B → A → B) n as →
-               i coℕᵇ.⊢ length (scanl c n as) ≈ 1 ℕ+ length as
+               i Conat.⊢ length (scanl c n as) ≈ 1 ℕ+ length as
 length-scanl c n []       = suc λ where .force → zero
 length-scanl c n (a ∷ as) = suc λ { .force → begin
   length (scanl c (c n a) (as .force))
     ≈⟨ length-scanl c (c n a) (as .force) ⟩
   1 ℕ+ length (as .force)
-    ≈˘⟨ length-∷ a as ⟩
-  length (a ∷ as) ∎ } where open coℕᵇ.≈-Reasoning
+    ≈⟨ length-∷ a as ⟨
+  length (a ∷ as) ∎ } where open Conat.≈-Reasoning
 
 module _ (cons : C → B → C) (alg : A → Maybe (A × B)) where
 
@@ -144,16 +145,16 @@ module _ (cons : C → B → C) (alg : A → Maybe (A × B)) where
 
   scanl-unfold : ∀ nil a → i ⊢ scanl cons nil (unfold alg a)
                              ≈ nil ∷ (λ where .force → unfold alg′ (a , nil))
-  scanl-unfold nil a with alg a | Eq.inspect alg a
-  ... | nothing       | [ eq ] = Eq.refl ∷ λ { .force →
-    sym (fromEq (unfold-nothing (Maybeₚ.map-nothing eq))) }
-  ... | just (a′ , b) | [ eq ] = Eq.refl ∷ λ { .force → begin
+  scanl-unfold nil a with alg a in eq
+  ... | nothing      = ≡.refl ∷ λ { .force →
+    sym (fromEq (unfold-nothing (Maybe.map-nothing eq))) }
+  ... | just (a′ , b) = ≡.refl ∷ λ { .force → begin
     scanl cons (cons nil b) (unfold alg a′)
      ≈⟨ scanl-unfold (cons nil b) a′ ⟩
     (cons nil b ∷ _)
-     ≈⟨ Eq.refl ∷ (λ where .force → refl) ⟩
+     ≈⟨ ≡.refl ∷ (λ where .force → refl) ⟩
     (cons nil b ∷ _)
-     ≈˘⟨ unfold-just (Maybeₚ.map-just eq) ⟩
+     ≈⟨ unfold-just (Maybe.map-just eq) ⟨
     unfold alg′ (a , nil) ∎ } where open ≈-Reasoning
 
 ------------------------------------------------------------------------
@@ -164,10 +165,10 @@ map-alignWith : ∀ (f : C → D) (al : These A B → C) as bs →
 map-alignWith f al []         bs       = map-∘ (al ∘′ that) f bs
 map-alignWith f al as@(_ ∷ _) []       = map-∘ (al ∘′ this) f as
 map-alignWith f al (a ∷ as)   (b ∷ bs) =
-  Eq.refl ∷ λ where .force → map-alignWith f al (as .force) (bs .force)
+  ≡.refl ∷ λ where .force → map-alignWith f al (as .force) (bs .force)
 
 length-alignWith : ∀ (al : These A B → C) as bs →
-                   i coℕᵇ.⊢ length (alignWith al as bs) ≈ length as ⊔ length bs
+                   i Conat.⊢ length (alignWith al as bs) ≈ length as ⊔ length bs
 length-alignWith al []         bs       = length-map (al ∘ that) bs
 length-alignWith al as@(_ ∷ _) []       = length-map (al ∘ this) as
 length-alignWith al (a ∷ as)   (b ∷ bs) =
@@ -181,10 +182,10 @@ map-zipWith : ∀ (f : C → D) (zp : A → B → C) as bs →
 map-zipWith f zp []       _        = []
 map-zipWith f zp (_ ∷ _)  []       = []
 map-zipWith f zp (a ∷ as) (b ∷ bs) =
-  Eq.refl ∷ λ where .force → map-zipWith f zp (as .force) (bs .force)
+  ≡.refl ∷ λ where .force → map-zipWith f zp (as .force) (bs .force)
 
 length-zipWith : ∀ (zp : A → B → C) as bs →
-                 i coℕᵇ.⊢ length (zipWith zp as bs) ≈ length as ⊓ length bs
+                 i Conat.⊢ length (zipWith zp as bs) ≈ length as ⊓ length bs
 length-zipWith zp []         bs       = zero
 length-zipWith zp as@(_ ∷ _) []       = zero
 length-zipWith zp (a ∷ as)   (b ∷ bs) =
@@ -197,36 +198,36 @@ drop-nil : ∀ m → i ⊢ drop {A = A} m [] ≈ []
 drop-nil zero    = []
 drop-nil (suc m) = []
 
-drop-drop-fusion : ∀ m n (as : Colist A ∞) →
+drop-drop : ∀ m n (as : Colist A ∞) →
                    i ⊢ drop n (drop m as) ≈ drop (m ℕ.+ n) as
-drop-drop-fusion zero    n as       = refl
-drop-drop-fusion (suc m) n []       = drop-nil n
-drop-drop-fusion (suc m) n (a ∷ as) = drop-drop-fusion m n (as .force)
+drop-drop zero    n as       = refl
+drop-drop (suc m) n []       = drop-nil n
+drop-drop (suc m) n (a ∷ as) = drop-drop m n (as .force)
 
 map-drop : ∀ (f : A → B) m as → i ⊢ map f (drop m as) ≈ drop m (map f as)
 map-drop f zero    as       = refl
 map-drop f (suc m) []       = []
 map-drop f (suc m) (a ∷ as) = map-drop f m (as .force)
 
-length-drop : ∀ m (as : Colist A ∞) → i coℕᵇ.⊢ length (drop m as) ≈ length as ∸ m
-length-drop zero    as       = coℕᵇ.refl
-length-drop (suc m) []       = coℕᵇ.sym (coℕₚ.0∸m≈0 m)
+length-drop : ∀ m (as : Colist A ∞) → i Conat.⊢ length (drop m as) ≈ length as ∸ m
+length-drop zero    as       = Conat.refl
+length-drop (suc m) []       = Conat.sym (Conat.0∸m≈0 m)
 length-drop (suc m) (a ∷ as) = length-drop m (as .force)
 
 drop-fromList-++-identity : ∀ (as : List A) bs →
                             drop (List.length as) (fromList as ++ bs) ≡ bs
-drop-fromList-++-identity []       bs = Eq.refl
+drop-fromList-++-identity []       bs = ≡.refl
 drop-fromList-++-identity (a ∷ as) bs = drop-fromList-++-identity as bs
 
 drop-fromList-++-≤ : ∀ (as : List A) bs {m} → m ℕ.≤ List.length as →
                      drop m (fromList as ++ bs) ≡ fromList (List.drop m as) ++ bs
-drop-fromList-++-≤ []       bs z≤n     = Eq.refl
-drop-fromList-++-≤ (a ∷ as) bs z≤n     = Eq.refl
+drop-fromList-++-≤ []       bs z≤n     = ≡.refl
+drop-fromList-++-≤ (a ∷ as) bs z≤n     = ≡.refl
 drop-fromList-++-≤ (a ∷ as) bs (s≤s p) = drop-fromList-++-≤ as bs p
 
 drop-fromList-++-≥ : ∀ (as : List A) bs {m} → m ℕ.≥ List.length as →
                      drop m (fromList as ++ bs) ≡ drop (m ℕ.∸ List.length as) bs
-drop-fromList-++-≥ []       bs z≤n     = Eq.refl
+drop-fromList-++-≥ []       bs z≤n     = ≡.refl
 drop-fromList-++-≥ (a ∷ as) bs (s≤s p) = drop-fromList-++-≥ as bs p
 
 drop-⁺++-identity : ∀ (as : List⁺ A) bs →
@@ -236,7 +237,7 @@ drop-⁺++-identity (a ∷ as) bs = drop-fromList-++-identity as (bs .force)
 ------------------------------------------------------------------------
 -- Properties of cotake
 
-length-cotake : ∀ n (as : Stream A ∞) → i coℕᵇ.⊢ length (cotake n as) ≈ n
+length-cotake : ∀ n (as : Stream A ∞) → i Conat.⊢ length (cotake n as) ≈ n
 length-cotake zero    as       = zero
 length-cotake (suc n) (a ∷ as) =
   suc λ where .force → length-cotake (n .force) (as .force)
@@ -245,7 +246,7 @@ map-cotake : ∀ (f : A → B) n as →
              i ⊢ map f (cotake n as) ≈ cotake n (Stream.map f as)
 map-cotake f zero    as       = []
 map-cotake f (suc n) (a ∷ as) =
-  Eq.refl ∷ λ where .force → map-cotake f (n .force) (as .force)
+  ≡.refl ∷ λ where .force → map-cotake f (n .force) (as .force)
 
 ------------------------------------------------------------------------
 -- Properties of chunksOf
@@ -255,20 +256,20 @@ module Map-ChunksOf (f : A → B) n where
   open ChunksOf n using (chunksOfAcc)
 
   map-chunksOf : ∀ as →
-    i coWriterᵇ.⊢ Cowriter.map (Vec.map f) (Vec≤.map f) (chunksOf n as)
+    i Cowriter.⊢ Cowriter.map (Vec.map f) (Vec≤.map f) (chunksOf n as)
                 ≈ chunksOf n (map f as)
   map-chunksOfAcc : ∀ m as {k≤ k≡ k≤′ k≡′} →
                     (∀ vs → Vec≤.map f (k≤ vs) ≡ k≤′ (Vec≤.map f vs)) →
                     (∀ vs → Vec.map f (k≡ vs) ≡ k≡′ (Vec.map f vs)) →
-                    i coWriterᵇ.⊢ Cowriter.map (Vec.map f) (Vec≤.map f)
+                    i Cowriter.⊢ Cowriter.map (Vec.map f) (Vec≤.map f)
                                         (chunksOfAcc m k≤ k≡ as)
                                 ≈ chunksOfAcc m k≤′ k≡′ (map f as)
 
-  map-chunksOf as = map-chunksOfAcc n as (λ vs → Eq.refl) (λ vs → Eq.refl)
+  map-chunksOf as = map-chunksOfAcc n as (λ vs → ≡.refl) (λ vs → ≡.refl)
 
   map-chunksOfAcc zero    as       eq-≤ eq-≡ =
       eq-≡ [] ∷ λ where .force → map-chunksOf as
-  map-chunksOfAcc (suc m) []       eq-≤ eq-≡ = coWriterᵇ.[ eq-≤ Vec≤.[] ]
+  map-chunksOfAcc (suc m) []       eq-≤ eq-≡ = Cowriter.[ eq-≤ Vec≤.[] ]
   map-chunksOfAcc (suc m) (a ∷ as) eq-≤ eq-≡ =
     map-chunksOfAcc m (as .force) (eq-≤ ∘ (a Vec≤.∷_)) (eq-≡ ∘ (a Vec.∷_))
 
@@ -280,21 +281,21 @@ open Map-ChunksOf using (map-chunksOf) public
 fromList-++ : (as bs : List A) →
               i ⊢ fromList (as List.++ bs) ≈ fromList as ++ fromList bs
 fromList-++ []       bs = refl
-fromList-++ (a ∷ as) bs = Eq.refl ∷ λ where .force → fromList-++ as bs
+fromList-++ (a ∷ as) bs = ≡.refl ∷ λ where .force → fromList-++ as bs
 
 fromList-scanl : ∀ (c : B → A → B) n as →
-                 i ⊢ fromList (List.scanl c n as) ≈ scanl c n (fromList as)
-fromList-scanl c n []       = Eq.refl ∷ λ where .force → refl
+                 i ⊢ fromList (Scans.scanl c n as) ≈ scanl c n (fromList as)
+fromList-scanl c n []       = ≡.refl ∷ λ where .force → refl
 fromList-scanl c n (a ∷ as) =
-  Eq.refl ∷ λ where .force → fromList-scanl c (c n a) as
+  ≡.refl ∷ λ where .force → fromList-scanl c (c n a) as
 
 map-fromList : ∀ (f : A → B) as →
                i ⊢ map f (fromList as) ≈ fromList (List.map f as)
 map-fromList f []       = []
-map-fromList f (a ∷ as) = Eq.refl ∷ λ where .force → map-fromList f as
+map-fromList f (a ∷ as) = ≡.refl ∷ λ where .force → map-fromList f as
 
 length-fromList : (as : List A) →
-                  i coℕᵇ.⊢ length (fromList as) ≈ fromℕ (List.length as)
+                  i Conat.⊢ length (fromList as) ≈ fromℕ (List.length as)
 length-fromList []       = zero
 length-fromList (a ∷ as) = suc (λ where .force → length-fromList as)
 
@@ -304,19 +305,19 @@ length-fromList (a ∷ as) = suc (λ where .force → length-fromList as)
 fromStream-++ : ∀ (as : List A) bs →
                 i ⊢ fromStream (as Stream.++ bs) ≈ fromList as ++ fromStream bs
 fromStream-++ []       bs = refl
-fromStream-++ (a ∷ as) bs = Eq.refl ∷ λ where .force → fromStream-++ as bs
+fromStream-++ (a ∷ as) bs = ≡.refl ∷ λ where .force → fromStream-++ as bs
 
 fromStream-⁺++ : ∀ (as : List⁺ A) bs →
                  i ⊢ fromStream (as Stream.⁺++ bs)
                    ≈ fromList⁺ as ++ fromStream (bs .force)
 fromStream-⁺++ (a ∷ as) bs =
-  Eq.refl ∷ λ where .force → fromStream-++ as (bs .force)
+  ≡.refl ∷ λ where .force → fromStream-++ as (bs .force)
 
 fromStream-concat : (ass : Stream (List⁺ A) ∞) →
                     i ⊢ concat (fromStream ass) ≈ fromStream (Stream.concat ass)
 fromStream-concat (as@(a ∷ _) ∷ ass) = begin
   concat (fromStream (as ∷ ass))
-    ≈⟨ Eq.refl ∷ (λ { .force → ++⁺ ≋-refl (fromStream-concat (ass .force))}) ⟩
+    ≈⟨ ≡.refl ∷ (λ { .force → ++⁺ ≋-refl (fromStream-concat (ass .force))}) ⟩
   a ∷ _
     ≈⟨ sym (fromStream-⁺++ as _) ⟩
   fromStream (Stream.concat (as ∷ ass)) ∎ where open ≈-Reasoning
@@ -325,12 +326,12 @@ fromStream-scanl : ∀ (c : B → A → B) n as →
                    i ⊢ scanl c n (fromStream as)
                      ≈ fromStream (Stream.scanl c n as)
 fromStream-scanl c n (a ∷ as) =
-  Eq.refl ∷ λ where .force → fromStream-scanl c (c n a) (as .force)
+  ≡.refl ∷ λ where .force → fromStream-scanl c (c n a) (as .force)
 
 map-fromStream : ∀ (f : A → B) as →
                  i ⊢ map f (fromStream as) ≈ fromStream (Stream.map f as)
 map-fromStream f (a ∷ as) =
-  Eq.refl ∷ λ where .force → map-fromStream f (as .force)
+  ≡.refl ∷ λ where .force → map-fromStream f (as .force)
 
 ------------------------------------------------------------------------
 -- DEPRECATED
@@ -351,3 +352,9 @@ map-map-fusion = map-∘
 "Warning: map-map-fusion was deprecated in v2.0.
 Please use map-∘ instead."
 #-}
+
+drop-drop-fusion = drop-drop
+{-# WARNING_ON_USAGE drop-drop-fusion
+"Warning: drop-drop-fusion was deprecated in v2.0.
+Please use drop-drop instead."
+#-}
diff --git a/src/Codata/Sized/Conat.agda b/src/Codata/Sized/Conat.agda
index 8711e26199..d57e3e56e7 100644
--- a/src/Codata/Sized/Conat.agda
+++ b/src/Codata/Sized/Conat.agda
@@ -35,7 +35,7 @@ pred : ∀ {i} {j : Size< i} → Conat i → Conat j
 pred zero    = zero
 pred (suc n) = n .force
 
-infixl 6 _∸_ _+_
+infixl 6 _∸_ _+_ _ℕ+_ _+ℕ_
 infixl 7 _*_
 
 _∸_ : Conat ∞ → ℕ → Conat ∞
@@ -91,6 +91,8 @@ toℕ (suc n) = suc (toℕ n)
 ------------------------------------------------------------------------
 -- Order wrt to Nat
 
+infix 4 _ℕ<_ _ℕ≤infinity _ℕ≤_
+
 data _ℕ≤_ : ℕ → Conat ∞ → Set where
   zℕ≤n : ∀ {n} → zero ℕ≤ n
   sℕ≤s : ∀ {k n} → k ℕ≤ n .force → suc k ℕ≤ suc n
diff --git a/src/Codata/Sized/Conat/Bisimilarity.agda b/src/Codata/Sized/Conat/Bisimilarity.agda
index ae3e306aca..1b5aaea922 100644
--- a/src/Codata/Sized/Conat/Bisimilarity.agda
+++ b/src/Codata/Sized/Conat/Bisimilarity.agda
@@ -12,7 +12,8 @@ open import Level using (0ℓ)
 open import Size
 open import Codata.Sized.Thunk
 open import Codata.Sized.Conat
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
 
 infix 1 _⊢_≈_
 data _⊢_≈_ i : (m n : Conat ∞) → Set where
diff --git a/src/Codata/Sized/Conat/Literals.agda b/src/Codata/Sized/Conat/Literals.agda
index 7f0cccb26b..932fd4ab88 100644
--- a/src/Codata/Sized/Conat/Literals.agda
+++ b/src/Codata/Sized/Conat/Literals.agda
@@ -8,9 +8,9 @@
 
 module Codata.Sized.Conat.Literals where
 
-open import Agda.Builtin.FromNat
-open import Data.Unit
-open import Codata.Sized.Conat
+open import Agda.Builtin.FromNat using (Number)
+open import Data.Unit.Base using (⊤)
+open import Codata.Sized.Conat using (Conat; fromℕ)
 
 number : ∀ {i} → Number (Conat i)
 number = record
diff --git a/src/Codata/Sized/Conat/Properties.agda b/src/Codata/Sized/Conat/Properties.agda
index b2649fb38a..54e211dc1f 100644
--- a/src/Codata/Sized/Conat/Properties.agda
+++ b/src/Codata/Sized/Conat/Properties.agda
@@ -16,7 +16,7 @@ open import Codata.Sized.Conat.Bisimilarity
 open import Function.Base using (_∋_)
 open import Relation.Nullary
 open import Relation.Nullary.Decidable using (map′)
-open import Relation.Binary
+open import Relation.Binary.Definitions using (Decidable)
 
 private
   variable
@@ -29,6 +29,8 @@ private
 sℕ≤s⁻¹ : ∀ {m n} → suc m ℕ≤ suc n → m ℕ≤ n .force
 sℕ≤s⁻¹ (sℕ≤s p) = p
 
+infix 4 _ℕ≤?_
+
 _ℕ≤?_ : Decidable _ℕ≤_
 zero  ℕ≤? n     = yes zℕ≤n
 suc m ℕ≤? zero  = no (λ ())
diff --git a/src/Codata/Sized/Covec.agda b/src/Codata/Sized/Covec.agda
index 85b7a9e63e..01e01f2df0 100644
--- a/src/Codata/Sized/Covec.agda
+++ b/src/Codata/Sized/Covec.agda
@@ -29,6 +29,8 @@ data Covec (A : Set a) (i : Size) : Conat ∞ → Set a where
   []  : Covec A i zero
   _∷_ : ∀ {n} → A → Thunk (λ i → Covec A i (n .force)) i → Covec A i (suc n)
 
+infixr 5 _∷_
+
 head : ∀ {n i} → Covec A i (suc n) → A
 head (x ∷ _) = x
 
diff --git a/src/Codata/Sized/Covec/Bisimilarity.agda b/src/Codata/Sized/Covec/Bisimilarity.agda
index 3047816b44..f50e249bfa 100644
--- a/src/Codata/Sized/Covec/Bisimilarity.agda
+++ b/src/Codata/Sized/Covec/Bisimilarity.agda
@@ -13,8 +13,9 @@ open import Size
 open import Codata.Sized.Thunk
 open import Codata.Sized.Conat hiding (_⊔_)
 open import Codata.Sized.Covec
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as Eq using (_≡_)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Sym; Trans)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 data Bisim {a b r} {A : Set a} {B : Set b} (R : A → B → Set r) (i : Size) :
            ∀ m n (xs : Covec A ∞ m) (ys : Covec B ∞ n) → Set (r ⊔ a ⊔ b) where
@@ -22,6 +23,7 @@ data Bisim {a b r} {A : Set a} {B : Set b} (R : A → B → Set r) (i : Size) :
   _∷_ : ∀ {x y m n xs ys} → R x y → Thunk^R (λ i → Bisim R i (m .force) (n .force)) i xs ys →
         Bisim R i (suc m) (suc n) (x ∷ xs) (y ∷ ys)
 
+infixr 5 _∷_
 
 module _ {a r} {A : Set a} {R : A → A → Set r} where
 
@@ -54,10 +56,10 @@ module _ {ℓ} {A : Set ℓ} where
  _,_⊢_≈_ i m = Bisim _≡_ i m m
 
  refl : ∀ {i m} → Reflexive (i , m ⊢_≈_)
- refl = reflexive Eq.refl
+ refl = reflexive ≡.refl
 
  sym : ∀ {i m} → Symmetric (i , m ⊢_≈_)
- sym = symmetric Eq.sym
+ sym = symmetric ≡.sym
 
  trans : ∀ {i m} → Transitive (i , m ⊢_≈_)
- trans = transitive Eq.trans
+ trans = transitive ≡.trans
diff --git a/src/Codata/Sized/Covec/Categorical.agda b/src/Codata/Sized/Covec/Categorical.agda
new file mode 100644
index 0000000000..0da702ff2c
--- /dev/null
+++ b/src/Codata/Sized/Covec/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Codata.Sized.Covec.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --sized-types #-}
+
+module Codata.Sized.Covec.Categorical where
+
+open import Codata.Sized.Covec.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Codata.Sized.Covec.Categorical was deprecated in v2.0.
+Use Codata.Sized.Covec.Effectful instead."
+#-}
diff --git a/src/Codata/Sized/Covec/Properties.agda b/src/Codata/Sized/Covec/Properties.agda
index 139eba6029..7d45bad63c 100644
--- a/src/Codata/Sized/Covec/Properties.agda
+++ b/src/Codata/Sized/Covec/Properties.agda
@@ -14,7 +14,7 @@ open import Codata.Sized.Conat
 open import Codata.Sized.Covec
 open import Codata.Sized.Covec.Bisimilarity
 open import Function.Base using (id; _∘_)
-open import Relation.Binary.PropositionalEquality as Eq
+open import Relation.Binary.PropositionalEquality.Core as ≡
 
 -- Functor laws
 
@@ -22,13 +22,13 @@ module _ {a} {A : Set a} where
 
  map-id : ∀ {m} (as : Covec A ∞ m) {i} → i , m ⊢ map id as ≈ as
  map-id []       = []
- map-id (a ∷ as) = Eq.refl ∷ λ where .force → map-id (as .force)
+ map-id (a ∷ as) = ≡.refl ∷ λ where .force → map-id (as .force)
 
 module _ {a b c} {A : Set a} {B : Set b} {C : Set c} where
 
  map-∘ : ∀ (f : A → B) (g : B → C) {m} as {i} → i , m ⊢ map g (map f as) ≈ map (g ∘ f) as
  map-∘ f g []       = []
- map-∘ f g (a ∷ as) = Eq.refl ∷ λ where .force → map-∘ f g (as .force)
+ map-∘ f g (a ∷ as) = ≡.refl ∷ λ where .force → map-∘ f g (as .force)
 
 ------------------------------------------------------------------------
 -- DEPRECATED
diff --git a/src/Codata/Sized/Cowriter.agda b/src/Codata/Sized/Cowriter.agda
index 409fbe1f71..fd4ba91787 100644
--- a/src/Codata/Sized/Cowriter.agda
+++ b/src/Codata/Sized/Cowriter.agda
@@ -16,9 +16,9 @@ open import Codata.Sized.Delay using (Delay; later; now)
 open import Codata.Sized.Stream as Stream using (Stream; _∷_)
 open import Data.Unit.Base
 open import Data.List.Base using (List; []; _∷_)
-open import Data.List.NonEmpty using (List⁺; _∷_)
-open import Data.Nat.Base as Nat using (ℕ; zero; suc)
-open import Data.Product as Prod using (_×_; _,_)
+open import Data.List.NonEmpty.Base using (List⁺; _∷_)
+open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
+open import Data.Product.Base as Product using (_×_; _,_)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
 open import Data.Vec.Base using (Vec; []; _∷_)
 open import Data.Vec.Bounded.Base as Vec≤ using (Vec≤; _,_)
@@ -39,6 +39,8 @@ data Cowriter (W : Set w) (A : Set a) (i : Size) : Set (a L.⊔ w) where
   [_] : A → Cowriter W A i
   _∷_ : W → Thunk (Cowriter W A) i → Cowriter W A i
 
+infixr 5 _∷_
+
 ------------------------------------------------------------------------
 -- Relationship to Delay.
 
@@ -66,11 +68,11 @@ length (w ∷ cw) = suc λ where .force → length (cw .force)
 splitAt : ∀ (n : ℕ) → Cowriter W A ∞ → (Vec W n × Cowriter W A ∞) ⊎ (Vec≤ W n × A)
 splitAt zero    cw       = inj₁ ([] , cw)
 splitAt (suc n) [ a ]    = inj₂ (Vec≤.[] , a)
-splitAt (suc n) (w ∷ cw) = Sum.map (Prod.map₁ (w ∷_)) (Prod.map₁ (w Vec≤.∷_))
+splitAt (suc n) (w ∷ cw) = Sum.map (Product.map₁ (w ∷_)) (Product.map₁ (w Vec≤.∷_))
                          $ splitAt n (cw .force)
 
 take : ∀ (n : ℕ) → Cowriter W A ∞ → Vec W n ⊎ (Vec≤ W n × A)
-take n = Sum.map₁ Prod.proj₁ ∘′ splitAt n
+take n = Sum.map₁ Product.proj₁ ∘′ splitAt n
 
 infixr 5 _++_ _⁺++_
 _++_ : ∀ {i} → List W → Cowriter W A i → Cowriter W A i
@@ -101,6 +103,8 @@ ap : ∀ {i} → Cowriter W (A → X) i → Cowriter W A i → Cowriter W X i
 ap [ f ]    ca = map₂ f ca
 ap (w ∷ cf) ca = w ∷ λ where .force → ap (cf .force) ca
 
+infixl 1 _>>=_
+
 _>>=_ : ∀ {i} → Cowriter W A i → (A → Cowriter W X i) → Cowriter W X i
 [ a ]    >>= f = f a
 (w ∷ ca) >>= f = w ∷ λ where .force → ca .force >>= f
@@ -109,6 +113,7 @@ _>>=_ : ∀ {i} → Cowriter W A i → (A → Cowriter W X i) → Cowriter W X i
 -- Construction.
 
 unfold : ∀ {i} → (X → (W × X) ⊎ A) → X → Cowriter W A i
-unfold next seed with next seed
-... | inj₁ (w , seed′) = w ∷ λ where .force → unfold next seed′
-... | inj₂ a           = [ a ]
+unfold next seed =
+  Sum.[ (λ where (w , seed′) → w ∷ λ where .force → unfold next seed′)
+      , [_]
+      ] (next seed)
diff --git a/src/Codata/Sized/Cowriter/Bisimilarity.agda b/src/Codata/Sized/Cowriter/Bisimilarity.agda
index 823b7897ae..c38ef8180b 100644
--- a/src/Codata/Sized/Cowriter/Bisimilarity.agda
+++ b/src/Codata/Sized/Cowriter/Bisimilarity.agda
@@ -12,8 +12,13 @@ open import Level using (Level; _⊔_)
 open import Size
 open import Codata.Sized.Thunk
 open import Codata.Sized.Cowriter
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as Eq using (_≡_)
+open import Relation.Binary.Core using (REL; Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Sym; Trans)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 private
   variable
@@ -33,6 +38,8 @@ data Bisim {V : Set v} {W : Set w} {A : Set a} {B : Set b}
   _∷_ : ∀ {x y xs ys} → R x y → Thunk^R (Bisim R S) i xs ys →
         Bisim R S i (x ∷ xs) (y ∷ ys)
 
+infixr 5 _∷_
+
 module _ {R : Rel W r} {S : Rel A s}
          (refl^R : Reflexive R) (refl^S : Reflexive S) where
 
@@ -67,16 +74,16 @@ module _ {W : Set w} {A : Set a} where
   _⊢_≈_ = Bisim _≡_ _≡_
 
   refl : Reflexive (i ⊢_≈_)
-  refl = reflexive Eq.refl Eq.refl
+  refl = reflexive ≡.refl ≡.refl
 
   fromEq : ∀ {as bs} → as ≡ bs → i ⊢ as ≈ bs
-  fromEq Eq.refl = refl
+  fromEq ≡.refl = refl
 
   sym : Symmetric (i ⊢_≈_)
-  sym = symmetric Eq.sym Eq.sym
+  sym = symmetric ≡.sym ≡.sym
 
   trans : Transitive (i ⊢_≈_)
-  trans = transitive Eq.trans Eq.trans
+  trans = transitive ≡.trans ≡.trans
 
 module _ {R : Rel W r} {S : Rel A s}
          (equiv^R : IsEquivalence R) (equiv^S : IsEquivalence S) where
@@ -101,4 +108,4 @@ setoid R S i = record
 module ≈-Reasoning {W : Set w} {A : Set a} {i} where
 
   open import Relation.Binary.Reasoning.Setoid
-              (setoid (Eq.setoid W) (Eq.setoid A) i) public
+              (setoid (≡.setoid W) (≡.setoid A) i) public
diff --git a/src/Codata/Sized/Delay.agda b/src/Codata/Sized/Delay.agda
index 0bb9c3470b..4219bae341 100644
--- a/src/Codata/Sized/Delay.agda
+++ b/src/Codata/Sized/Delay.agda
@@ -16,9 +16,9 @@ open import Data.Empty
 open import Relation.Nullary
 open import Data.Nat.Base
 open import Data.Maybe.Base hiding (map ; fromMaybe ; zipWith ; alignWith ; zip ; align)
-open import Data.Product as P hiding (map ; zip)
-open import Data.Sum.Base as S hiding (map)
-open import Data.These.Base as T using (These; this; that; these)
+open import Data.Product.Base hiding (map ; zip)
+open import Data.Sum.Base hiding (map)
+open import Data.These.Base using (These; this; that; these)
 open import Function.Base using (id)
 
 ------------------------------------------------------------------------
diff --git a/src/Codata/Sized/Delay/Bisimilarity.agda b/src/Codata/Sized/Delay/Bisimilarity.agda
index 1143f15263..fb01d94ebc 100644
--- a/src/Codata/Sized/Delay/Bisimilarity.agda
+++ b/src/Codata/Sized/Delay/Bisimilarity.agda
@@ -12,8 +12,9 @@ open import Size
 open import Codata.Sized.Thunk
 open import Codata.Sized.Delay
 open import Level
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as Eq using (_≡_)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Sym; Trans)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 data Bisim {a b r} {A : Set a} {B : Set b} (R : A → B → Set r) i :
            (xs : Delay A ∞) (ys : Delay B ∞) → Set (a ⊔ b ⊔ r) where
@@ -52,10 +53,10 @@ module _ {ℓ} {A : Set ℓ} where
  _⊢_≈_ = Bisim _≡_
 
  refl : ∀ {i} → Reflexive (i ⊢_≈_)
- refl = reflexive Eq.refl
+ refl = reflexive ≡.refl
 
  sym : ∀ {i} → Symmetric (i ⊢_≈_)
- sym = symmetric Eq.sym
+ sym = symmetric ≡.sym
 
  trans : ∀ {i} → Transitive (i ⊢_≈_)
- trans = transitive Eq.trans
+ trans = transitive ≡.trans
diff --git a/src/Codata/Sized/Delay/Categorical.agda b/src/Codata/Sized/Delay/Categorical.agda
new file mode 100644
index 0000000000..2aa88bb896
--- /dev/null
+++ b/src/Codata/Sized/Delay/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Codata.Sized.Delay.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --sized-types #-}
+
+module Codata.Sized.Delay.Categorical where
+
+open import Codata.Sized.Delay.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Codata.Sized.Delay.Categorical was deprecated in v2.0.
+Use Codata.Sized.Delay.Effectful instead."
+#-}
diff --git a/src/Codata/Sized/Delay/Effectful.agda b/src/Codata/Sized/Delay/Effectful.agda
index 95254c3a13..2724c67d47 100644
--- a/src/Codata/Sized/Delay/Effectful.agda
+++ b/src/Codata/Sized/Delay/Effectful.agda
@@ -9,7 +9,7 @@
 module Codata.Sized.Delay.Effectful where
 
 open import Codata.Sized.Delay
-open import Function
+open import Function.Base using (id)
 open import Effect.Choice
 open import Effect.Empty
 open import Effect.Functor
diff --git a/src/Codata/Sized/Delay/Properties.agda b/src/Codata/Sized/Delay/Properties.agda
index 5db7bafe7f..2936660718 100644
--- a/src/Codata/Sized/Delay/Properties.agda
+++ b/src/Codata/Sized/Delay/Properties.agda
@@ -10,14 +10,14 @@ module Codata.Sized.Delay.Properties where
 
 open import Size
 import Data.Sum.Base as Sum
-import Data.Nat as ℕ
+import Data.Nat.Base as ℕ
 open import Codata.Sized.Thunk using (Thunk; force)
 open import Codata.Sized.Conat
 open import Codata.Sized.Conat.Bisimilarity as Coℕ using (zero ; suc)
 open import Codata.Sized.Delay
 open import Codata.Sized.Delay.Bisimilarity
 open import Function.Base using (id; _∘′_)
-open import Relation.Binary.PropositionalEquality as Eq using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 module _ {a} {A : Set a} where
 
@@ -40,19 +40,19 @@ module _ {a b c} {A : Set a} {B : Set b} {C : Set c} where
    suc λ where .force →  length-zipWith f (da .force) (db .force)
 
  map-id : ∀ da {i} → i ⊢ map (id {A = A}) da ≈ da
- map-id (now a)    = now Eq.refl
+ map-id (now a)    = now ≡.refl
  map-id (later da) = later λ where .force → map-id (da .force)
 
  map-∘ : ∀ (f : A → B) (g : B → C) da {i}  →
    i ⊢ map g (map f da) ≈ map (g ∘′ f) da
- map-∘ f g (now a)    = now Eq.refl
+ map-∘ f g (now a)    = now ≡.refl
  map-∘ f g (later da) = later λ where .force → map-∘ f g (da .force)
 
  map-unfold : ∀ (f : B → C) n (s : A) {i} →
    i ⊢ map f (unfold n s) ≈ unfold (Sum.map id f ∘′ n) s
  map-unfold f n s with n s
  ... | Sum.inj₁ s′ = later λ where .force → map-unfold f n s′
- ... | Sum.inj₂ b = now Eq.refl
+ ... | Sum.inj₂ b = now ≡.refl
 
 
 ------------------------------------------------------------------------
@@ -62,9 +62,9 @@ module _ {a b c} {A : Set a} {B : Set b} {C : Set c} where
            {d : Delay A ∞} →
            (d⇓₁ : d ⇓) → (d⇓₂ : d ⇓) →
            d⇓₁ ≡ d⇓₂
-⇓-unique {d = now s} (now s) (now s) = Eq.refl
+⇓-unique {d = now s} (now s) (now s) = ≡.refl
 ⇓-unique {d = later d'} (later l) (later r) =
-  Eq.cong later (⇓-unique {d = force d'} l r)
+  ≡.cong later (⇓-unique {d = force d'} l r)
 
 module _ {a} {A B : Set a} where
 
@@ -80,35 +80,35 @@ module _ {a} {A B : Set a} where
   bind̅₂ (later s) {f} (later foo) =
     bind̅₂ (force s) foo
 
-  -- The extracted value of a bind is equivalent to the extracted value of its
-  -- second element
+  -- The extracted value of a bind is equivalent to the extracted value
+  -- of its second element
   extract-bind-⇓ : {d : Delay A Size.∞} → {f : A → Delay B Size.∞} →
                    (d⇓ : d ⇓) → (f⇓ : f (extract d⇓) ⇓) →
                    extract (bind-⇓ d⇓ {f} f⇓) ≡ extract f⇓
-  extract-bind-⇓ (now a) f⇓ = Eq.refl
+  extract-bind-⇓ (now a) f⇓ = ≡.refl
   extract-bind-⇓ (later t) f⇓ = extract-bind-⇓ t f⇓
 
-  -- If the right element of a bind returns a certain value so does the entire
-  -- bind
+  -- If the right element of a bind returns a certain value so does the
+  -- entire bind
   extract-bind̅₂-bind⇓ :
     (d : Delay A ∞) {f : A → Delay B ∞} →
     (bind⇓ : bind d f ⇓) →
     extract (bind̅₂ d bind⇓) ≡ extract bind⇓
-  extract-bind̅₂-bind⇓ (now s) bind⇓ = Eq.refl
+  extract-bind̅₂-bind⇓ (now s) bind⇓ = ≡.refl
   extract-bind̅₂-bind⇓ (later s) (later bind⇓) =
     extract-bind̅₂-bind⇓ (force s) bind⇓
 
-  -- Proof that the length of a bind-⇓ is equal to the sum of the length of its
-  -- components.
+  -- Proof that the length of a bind-⇓ is equal to the sum of the length
+  -- of its components.
   bind⇓-length :
       {d : Delay A ∞} {f : A → Delay B ∞} →
       (bind⇓ : bind d f ⇓) →
       (d⇓ : d ⇓) → (f⇓ : f (extract d⇓) ⇓) →
       toℕ (length-⇓ bind⇓) ≡ toℕ (length-⇓ d⇓) ℕ.+ toℕ (length-⇓ f⇓)
   bind⇓-length {f = f} bind⇓ d⇓@(now s') f⇓ =
-    Eq.cong (toℕ ∘′ length-⇓) (⇓-unique bind⇓ f⇓)
+    ≡.cong (toℕ ∘′ length-⇓) (⇓-unique bind⇓ f⇓)
   bind⇓-length {d = d@(later dt)} {f = f} bind⇓@(later bind'⇓) d⇓@(later r) f⇓ =
-    Eq.cong ℕ.suc (bind⇓-length bind'⇓ r f⇓)
+    ≡.cong ℕ.suc (bind⇓-length bind'⇓ r f⇓)
 
 ------------------------------------------------------------------------
 -- DEPRECATED
diff --git a/src/Codata/Sized/M.agda b/src/Codata/Sized/M.agda
index 063c276a95..844f2e3219 100644
--- a/src/Codata/Sized/M.agda
+++ b/src/Codata/Sized/M.agda
@@ -11,7 +11,7 @@ module Codata.Sized.M where
 open import Size
 open import Level
 open import Codata.Sized.Thunk using (Thunk; force)
-open import Data.Product hiding (map)
+open import Data.Product.Base hiding (map)
 open import Data.Container.Core as C hiding (map)
 
 data M {s p} (C : Container s p) (i : Size) : Set (s ⊔ p) where
diff --git a/src/Codata/Sized/M/Bisimilarity.agda b/src/Codata/Sized/M/Bisimilarity.agda
index 1b8cbd3188..cc0b934990 100644
--- a/src/Codata/Sized/M/Bisimilarity.agda
+++ b/src/Codata/Sized/M/Bisimilarity.agda
@@ -14,28 +14,32 @@ open import Codata.Sized.Thunk
 open import Codata.Sized.M
 open import Data.Container.Core
 open import Data.Container.Relation.Binary.Pointwise using (Pointwise; _,_)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (_∋_)
-open import Relation.Binary
-import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
+import Relation.Binary.PropositionalEquality.Core as ≡
 
 data Bisim {s p} (C : Container s p) (i : Size) : Rel (M C ∞) (s ⊔ p) where
   inf : ∀ {t u} → Pointwise C (Thunk^R (Bisim C) i) t u → Bisim C i (inf t) (inf u)
 
 module _ {s p} {C : Container s p} where
 
-  -- unfortunately the proofs are a lot nicer if we do not use the combinators
-  -- C.refl, C.sym and C.trans
+  -- unfortunately the proofs are a lot nicer if we do not use the
+  -- combinators C.refl, C.sym and C.trans
 
   refl : ∀ {i} → Reflexive (Bisim C i)
-  refl {x = inf t} = inf (P.refl , λ where p .force → refl)
+  refl {x = inf t} = inf (≡.refl , λ where p .force → refl)
 
   sym : ∀ {i} → Symmetric (Bisim C i)
-  sym  (inf (P.refl , f)) = inf (P.refl , λ where p .force → sym (f p .force))
+  sym  (inf (≡.refl , f)) = inf (≡.refl , λ where p .force → sym (f p .force))
 
   trans : ∀ {i} → Transitive (Bisim C i)
-  trans (inf (P.refl , f)) (inf (P.refl , g)) =
-    inf (P.refl , λ where p .force → trans (f p .force) (g p .force))
+  trans (inf (≡.refl , f)) (inf (≡.refl , g)) =
+    inf (≡.refl , λ where p .force → trans (f p .force) (g p .force))
 
   isEquivalence : ∀ {i} → IsEquivalence (Bisim C i)
   isEquivalence = record
diff --git a/src/Codata/Sized/M/Properties.agda b/src/Codata/Sized/M/Properties.agda
index 3b26955e60..8d9724f9a7 100644
--- a/src/Codata/Sized/M/Properties.agda
+++ b/src/Codata/Sized/M/Properties.agda
@@ -15,21 +15,22 @@ open import Codata.Sized.M
 open import Codata.Sized.M.Bisimilarity
 open import Data.Container.Core as C hiding (map)
 import Data.Container.Morphism as Mp
-open import Data.Product as Prod using (_,_)
+open import Data.Product.Base as Product using (_,_)
 open import Data.Product.Properties hiding (map-cong)
 open import Function.Base using (_$′_; _∘′_)
-import Relation.Binary.PropositionalEquality as P
+import Relation.Binary.PropositionalEquality.Core as ≡
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 open import Data.Container.Relation.Binary.Pointwise using (_,_)
 import Data.Container.Relation.Binary.Equality.Setoid as EqSetoid
 
-private module Eq {a} (A : Set a) = EqSetoid (P.setoid A)
+private module Eq {a} (A : Set a) = EqSetoid (≡.setoid A)
 open Eq using (Eq)
 
 module _ {s p} {C : Container s p} where
 
   map-id : ∀ {i} c → Bisim C i (map (Mp.id C) c) c
-  map-id (inf (s , f)) = inf (P.refl , λ where p .force → map-id (f p .force))
+  map-id (inf (s , f)) = inf (≡.refl , λ where p .force → map-id (f p .force))
 
 module _ {s₁ s₂ p₁ p₂} {C₁ : Container s₁ p₁} {C₂ : Container s₂ p₂} where
 
@@ -38,7 +39,7 @@ module _ {s₁ s₂ p₁ p₂} {C₁ : Container s₁ p₁} {C₂ : Container s
              ∀ c₁ → Bisim C₂ i (map f c₁) (map g c₁)
   map-cong {f = f} {g} f≗g (inf t@(s , n)) with f≗g t
   ... | eqs , eqf = inf (eqs , λ where
-     p .force {j} → P.subst (λ t → Bisim C₂ j (map f (n (position f p) .force))
+     p .force {j} → ≡.subst (λ t → Bisim C₂ j (map f (n (position f p) .force))
                                               (map g (t .force)))
                     (eqf p)
                     (map-cong f≗g (n (position f p) .force)))
@@ -48,7 +49,7 @@ module _ {s₁ s₂ s₃ p₁ p₂ p₃} {C₁ : Container s₁ p₁}
 
   map-∘ : ∀ {i} {g : C₂ ⇒ C₃} {f : C₁ ⇒ C₂} c₁ →
                 Bisim C₃ i (map (g Mp.∘ f) c₁) (map g $′ map f c₁)
-  map-∘ (inf (s , f)) = inf (P.refl , λ where p .force → map-∘ (f _ .force))
+  map-∘ (inf (s , f)) = inf (≡.refl , λ where p .force → map-∘ (f _ .force))
 
 
 module _ {s₁ s₂ p₁ p₂ s} {C₁ : Container s₁ p₁} {C₂ : Container s₂ p₂}
@@ -56,7 +57,7 @@ module _ {s₁ s₂ p₁ p₂ s} {C₁ : Container s₁ p₁} {C₂ : Container
 
   map-unfold : ∀ {i} s → Bisim C₂ i (map f (unfold alg s))
                                     (unfold (⟪ f ⟫ ∘′ alg) s)
-  map-unfold s = inf (P.refl , λ where p .force → map-unfold _)
+  map-unfold s = inf (≡.refl , λ where p .force → map-unfold _)
 
 ------------------------------------------------------------------------
 -- DEPRECATED
diff --git a/src/Codata/Sized/Stream.agda b/src/Codata/Sized/Stream.agda
index 53e42aa87d..34a9583448 100644
--- a/src/Codata/Sized/Stream.agda
+++ b/src/Codata/Sized/Stream.agda
@@ -15,10 +15,10 @@ open import Data.Nat.Base
 open import Data.List.Base using (List; []; _∷_)
 open import Data.List.NonEmpty as List⁺ using (List⁺; _∷_; _∷⁺_)
 open import Data.Vec.Base using (Vec; []; _∷_)
-open import Data.Product as P hiding (map)
-open import Function.Base
+open import Data.Product.Base as P using (Σ; _×_; _,_; <_,_>; proj₁; proj₂)
+open import Function.Base using (id; _∘_)
 open import Level using (Level)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 private
   variable
@@ -34,6 +34,8 @@ private
 data Stream (A : Set a) (i : Size) : Set a where
   _∷_ : A → Thunk (Stream A) i → Stream A i
 
+infixr 5 _∷_
+
 ------------------------------------------------------------------------
 -- Creating streams
 
@@ -125,8 +127,8 @@ chunksOf n = chunksOfAcc n id module ChunksOf where
 interleave : Stream A i → Thunk (Stream A) i → Stream A i
 interleave (x ∷ xs) ys = x ∷ λ where .force → interleave (ys .force) xs
 
--- This interleaving strategy can be generalised to an arbitrary non-empty
--- list of streams
+-- This interleaving strategy can be generalised to an arbitrary
+-- non-empty list of streams
 interleave⁺ : List⁺ (Stream A i) → Stream A i
 interleave⁺ xss =
   List⁺.map head xss
@@ -153,8 +155,8 @@ cantor (l ∷ ls) = zig (l ∷ []) (ls .force) module Cantor where
   zag (x ∷ []) zs (l ∷ ls) = x ∷ λ where .force → zig (l ∷⁺ zs) (ls .force)
   zag (x ∷ (y ∷ xs)) zs ls = x ∷ λ where .force → zag (y ∷ xs) zs ls
 
--- We can use the Cantor zig zag function to define a form of `bind' that
--- reaches any point of the plane in a finite amount of time.
+-- We can use the Cantor zig zag function to define a form of `bind'
+-- that reaches any point of the plane in a finite amount of time.
 plane : {B : A → Set b} → Stream A ∞ → ((a : A) → Stream (B a) ∞) →
         Stream (Σ A B) ∞
 plane as bs = cantor (map (λ a → map (a ,_) (bs a)) as)
diff --git a/src/Codata/Sized/Stream/Bisimilarity.agda b/src/Codata/Sized/Stream/Bisimilarity.agda
index 1675ec016a..57516709df 100644
--- a/src/Codata/Sized/Stream/Bisimilarity.agda
+++ b/src/Codata/Sized/Stream/Bisimilarity.agda
@@ -13,9 +13,14 @@ open import Codata.Sized.Thunk
 open import Codata.Sized.Stream
 open import Level
 open import Data.List.NonEmpty as List⁺ using (_∷_)
-open import Data.List.Relation.Binary.Pointwise using (Pointwise; []; _∷_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as Eq using (_≡_)
+open import Data.List.Relation.Binary.Pointwise.Base using (Pointwise; []; _∷_)
+open import Relation.Binary.Core using (Rel; REL)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Sym; Trans)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 private
   variable
@@ -30,6 +35,8 @@ data Bisim {A : Set a} {B : Set b} (R : REL A B r) i :
   _∷_ : ∀ {x y xs ys} → R x y → Thunk^R (Bisim R) i xs ys →
         Bisim R i (x ∷ xs) (y ∷ ys)
 
+infixr 5 _∷_
+
 module _ {R : Rel A r} where
 
  reflexive : Reflexive R → Reflexive (Bisim R i)
@@ -80,14 +87,14 @@ module _ {A : Set a} where
  _⊢_≈_ = Bisim _≡_
 
  refl : ∀ {i} → Reflexive (i ⊢_≈_)
- refl = reflexive Eq.refl
+ refl = reflexive ≡.refl
 
  sym : ∀ {i} → Symmetric (i ⊢_≈_)
- sym = symmetric Eq.sym
+ sym = symmetric ≡.sym
 
  trans : ∀ {i} → Transitive (i ⊢_≈_)
- trans = transitive Eq.trans
+ trans = transitive ≡.trans
 
 module ≈-Reasoning {a} {A : Set a} {i} where
 
-  open import Relation.Binary.Reasoning.Setoid (setoid (Eq.setoid A) i) public
+  open import Relation.Binary.Reasoning.Setoid (setoid (≡.setoid A) i) public
diff --git a/src/Codata/Sized/Stream/Categorical.agda b/src/Codata/Sized/Stream/Categorical.agda
new file mode 100644
index 0000000000..597d7b7bfc
--- /dev/null
+++ b/src/Codata/Sized/Stream/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Codata.Sized.Stream.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --sized-types #-}
+
+module Codata.Sized.Stream.Categorical where
+
+open import Codata.Sized.Stream.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Codata.Sized.Stream.Categorical was deprecated in v2.0.
+Use Codata.Sized.Stream.Effectful instead."
+#-}
diff --git a/src/Codata/Sized/Stream/Effectful.agda b/src/Codata/Sized/Stream/Effectful.agda
index 00fe7eb2b1..a9636ad027 100644
--- a/src/Codata/Sized/Stream/Effectful.agda
+++ b/src/Codata/Sized/Stream/Effectful.agda
@@ -8,7 +8,7 @@
 
 module Codata.Sized.Stream.Effectful where
 
-open import Data.Product using (<_,_>)
+open import Data.Product.Base using (<_,_>)
 open import Codata.Sized.Stream
 open import Effect.Functor
 open import Effect.Applicative
diff --git a/src/Codata/Sized/Stream/Properties.agda b/src/Codata/Sized/Stream/Properties.agda
index 539a6b7b20..913b84edae 100644
--- a/src/Codata/Sized/Stream/Properties.agda
+++ b/src/Codata/Sized/Stream/Properties.agda
@@ -19,12 +19,14 @@ open import Data.Nat.GeneralisedArithmetic using (fold; fold-pull)
 
 open import Data.List.Base as List using ([]; _∷_)
 open import Data.List.NonEmpty as List⁺ using (List⁺; _∷_)
-import Data.List.Relation.Binary.Equality.Propositional as Eq
-open import Data.Product as Prod using (_,_)
+import Data.List.Relation.Binary.Equality.Propositional as ≋
+open import Data.Product.Base as Product using (_,_)
 open import Data.Vec.Base as Vec using (_∷_)
 
 open import Function.Base using (id; _$_; _∘′_; const)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; _≢_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_; _≢_)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 
 private
   variable
@@ -38,85 +40,85 @@ private
 -- repeat
 
 lookup-repeat-identity : (n : ℕ) (a : A) → lookup (repeat a) n ≡ a
-lookup-repeat-identity zero    a = P.refl
+lookup-repeat-identity zero    a = ≡.refl
 lookup-repeat-identity (suc n) a = lookup-repeat-identity n a
 
-take-repeat-identity : (n : ℕ) (a : A) → take n (repeat a) ≡ Vec.replicate a
-take-repeat-identity zero    a = P.refl
-take-repeat-identity (suc n) a = P.cong (a Vec.∷_) (take-repeat-identity n a)
+take-repeat-identity : (n : ℕ) (a : A) → take n (repeat a) ≡ Vec.replicate n a
+take-repeat-identity zero    a = ≡.refl
+take-repeat-identity (suc n) a = ≡.cong (a Vec.∷_) (take-repeat-identity n a)
 
-splitAt-repeat-identity : (n : ℕ) (a : A) → splitAt n (repeat a) ≡ (Vec.replicate a , repeat a)
-splitAt-repeat-identity zero    a = P.refl
-splitAt-repeat-identity (suc n) a = P.cong (Prod.map₁ (a ∷_)) (splitAt-repeat-identity n a)
+splitAt-repeat-identity : (n : ℕ) (a : A) → splitAt n (repeat a) ≡ (Vec.replicate n a , repeat a)
+splitAt-repeat-identity zero    a = ≡.refl
+splitAt-repeat-identity (suc n) a = ≡.cong (Product.map₁ (a ∷_)) (splitAt-repeat-identity n a)
 
 replicate-repeat : ∀ {i} (n : ℕ) (a : A) → i ⊢ List.replicate n a ++ repeat a ≈ repeat a
 replicate-repeat zero    a = refl
-replicate-repeat (suc n) a = P.refl ∷ λ where .force → replicate-repeat n a
+replicate-repeat (suc n) a = ≡.refl ∷ λ where .force → replicate-repeat n a
 
 cycle-replicate : ∀ {i} (n : ℕ) (n≢0 : n ≢ 0) (a : A) → i ⊢ cycle (List⁺.replicate n n≢0 a) ≈ repeat a
 cycle-replicate {i} n n≢0 a = let as = List⁺.replicate n n≢0 a in begin
   cycle as                           ≡⟨⟩
-  as ⁺++ _                           ≈⟨ ⁺++⁺ Eq.≋-refl (λ where .force → cycle-replicate n n≢0 a) ⟩
-  as ⁺++ (λ where .force → repeat a) ≈⟨ P.refl ∷ (λ where .force → replicate-repeat (pred n) a) ⟩
+  as ⁺++ _                           ≈⟨ ⁺++⁺ ≋.≋-refl (λ where .force → cycle-replicate n n≢0 a) ⟩
+  as ⁺++ (λ where .force → repeat a) ≈⟨ ≡.refl ∷ (λ where .force → replicate-repeat (pred n) a) ⟩
   repeat a                           ∎ where open ≈-Reasoning
 
 module _ {a b} {A : Set a} {B : Set b} where
 
   map-repeat : ∀ (f : A → B) a {i} → i ⊢ map f (repeat a) ≈ repeat (f a)
-  map-repeat f a = P.refl ∷ λ where .force → map-repeat f a
+  map-repeat f a = ≡.refl ∷ λ where .force → map-repeat f a
 
   ap-repeat : ∀ (f : A → B) a {i} → i ⊢ ap (repeat f) (repeat a) ≈ repeat (f a)
-  ap-repeat f a = P.refl ∷ λ where .force → ap-repeat f a
+  ap-repeat f a = ≡.refl ∷ λ where .force → ap-repeat f a
 
   ap-repeatˡ : ∀ (f : A → B) as {i} → i ⊢ ap (repeat f) as ≈ map f as
-  ap-repeatˡ f (a ∷ as) = P.refl ∷ λ where .force → ap-repeatˡ f (as .force)
+  ap-repeatˡ f (a ∷ as) = ≡.refl ∷ λ where .force → ap-repeatˡ f (as .force)
 
   ap-repeatʳ : ∀ (fs : Stream (A → B) ∞) (a : A) {i} → i ⊢ ap fs (repeat a) ≈ map (_$ a) fs
-  ap-repeatʳ (f ∷ fs) a = P.refl ∷ λ where .force → ap-repeatʳ (fs .force) a
+  ap-repeatʳ (f ∷ fs) a = ≡.refl ∷ λ where .force → ap-repeatʳ (fs .force) a
 
   map-++ : ∀ {i} (f : A → B) as xs → i ⊢ map f (as ++ xs) ≈ List.map f as ++ map f xs
   map-++ f []       xs = refl
-  map-++ f (a ∷ as) xs = P.refl ∷ λ where .force → map-++ f as xs
+  map-++ f (a ∷ as) xs = ≡.refl ∷ λ where .force → map-++ f as xs
 
   map-⁺++ : ∀ {i} (f : A → B) as xs → i ⊢ map f (as ⁺++ xs) ≈ List⁺.map f as ⁺++ Thunk.map (map f) xs
-  map-⁺++ f (a ∷ as) xs = P.refl ∷ (λ where .force → map-++ f as (xs .force))
+  map-⁺++ f (a ∷ as) xs = ≡.refl ∷ (λ where .force → map-++ f as (xs .force))
 
   map-cycle : ∀ {i} (f : A → B) as → i ⊢ map f (cycle as) ≈ cycle (List⁺.map f as)
   map-cycle f as = begin
     map f (cycle as)       ≈⟨ map-⁺++ f as _ ⟩
-    List⁺.map f as ⁺++ _   ≈⟨ ⁺++⁺ Eq.≋-refl (λ where .force → map-cycle f as) ⟩
+    List⁺.map f as ⁺++ _   ≈⟨ ⁺++⁺ ≋.≋-refl (λ where .force → map-cycle f as) ⟩
     cycle (List⁺.map f as) ∎ where open ≈-Reasoning
 
 ------------------------------------------------------------------------
 -- Functor laws
 
 map-id : ∀ (as : Stream A ∞) → i ⊢ map id as ≈ as
-map-id (a ∷ as) = P.refl ∷ λ where .force → map-id (as .force)
+map-id (a ∷ as) = ≡.refl ∷ λ where .force → map-id (as .force)
 
 map-∘ : ∀ (f : A → B) (g : B → C) as → i ⊢ map g (map f as) ≈ map (g ∘′ f) as
-map-∘ f g (a ∷ as) = P.refl ∷ λ where .force → map-∘ f g (as .force)
+map-∘ f g (a ∷ as) = ≡.refl ∷ λ where .force → map-∘ f g (as .force)
 
 
 ------------------------------------------------------------------------
 -- splitAt
 
 splitAt-map : ∀ n (f : A → B) xs →
-  splitAt n (map f xs) ≡ Prod.map (Vec.map f) (map f) (splitAt n xs)
-splitAt-map zero    f xs       = P.refl
+  splitAt n (map f xs) ≡ Product.map (Vec.map f) (map f) (splitAt n xs)
+splitAt-map zero    f xs       = ≡.refl
 splitAt-map (suc n) f (x ∷ xs) =
-  P.cong (Prod.map₁ (f x Vec.∷_)) (splitAt-map n f (xs .force))
+  ≡.cong (Product.map₁ (f x Vec.∷_)) (splitAt-map n f (xs .force))
 
 ------------------------------------------------------------------------
 -- iterate
 
 lookup-iterate-identity : ∀ n f (a : A) → lookup (iterate f a) n ≡ fold a f n
-lookup-iterate-identity zero     f a = P.refl
+lookup-iterate-identity zero     f a = ≡.refl
 lookup-iterate-identity (suc n)  f a = begin
   lookup (iterate f a) (suc n) ≡⟨⟩
   lookup (iterate f (f a)) n   ≡⟨ lookup-iterate-identity n f (f a) ⟩
-  fold (f a) f n               ≡⟨ fold-pull a f (const ∘′ f) (f a) P.refl (λ _ → P.refl) n ⟩
+  fold (f a) f n               ≡⟨ fold-pull a f (const ∘′ f) (f a) ≡.refl (λ _ → ≡.refl) n ⟩
   f (fold a f n)               ≡⟨⟩
-  fold a f (suc n)             ∎ where open P.≡-Reasoning
+  fold a f (suc n)             ∎ where open ≡-Reasoning
 
 ------------------------------------------------------------------------
 -- DEPRECATED
diff --git a/src/Data/AVL.agda b/src/Data/AVL.agda
index ca0015925b..14c695d0d4 100644
--- a/src/Data/AVL.agda
+++ b/src/Data/AVL.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.AVL
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
diff --git a/src/Data/AVL/Indexed.agda b/src/Data/AVL/Indexed.agda
index a4ee4a1d96..9efe5e7500 100644
--- a/src/Data/AVL/Indexed.agda
+++ b/src/Data/AVL/Indexed.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.AVL.Indexed
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂) where
diff --git a/src/Data/AVL/Indexed/WithK.agda b/src/Data/AVL/Indexed/WithK.agda
index 4a5de070f0..609fb7b45d 100644
--- a/src/Data/AVL/Indexed/WithK.agda
+++ b/src/Data/AVL/Indexed/WithK.agda
@@ -6,8 +6,9 @@
 
 {-# OPTIONS --with-K --safe #-}
 
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; subst)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsStrictTotalOrder)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; subst)
 
 module Data.AVL.Indexed.WithK
        {k r} (Key : Set k) {_<_ : Rel Key r}
diff --git a/src/Data/AVL/IndexedMap.agda b/src/Data/AVL/IndexedMap.agda
index 64a0d5c36a..fad21c14c2 100644
--- a/src/Data/AVL/IndexedMap.agda
+++ b/src/Data/AVL/IndexedMap.agda
@@ -6,9 +6,10 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Product as Prod
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality using (_≡_; cong; subst)
+open import Data.Product.Base using (∃)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsStrictTotalOrder)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong; subst)
 import Data.Tree.AVL.Value
 
 module Data.AVL.IndexedMap
diff --git a/src/Data/AVL/Key.agda b/src/Data/AVL/Key.agda
index 30eaf2f5aa..f1ca15bacd 100644
--- a/src/Data/AVL/Key.agda
+++ b/src/Data/AVL/Key.agda
@@ -2,11 +2,11 @@
 -- The Agda standard library
 --
 -- This module is DEPRECATED.
------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.AVL.Key
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
diff --git a/src/Data/AVL/Map.agda b/src/Data/AVL/Map.agda
index 9950a1299b..d4768bb19e 100644
--- a/src/Data/AVL/Map.agda
+++ b/src/Data/AVL/Map.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.AVL.Map
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
diff --git a/src/Data/AVL/NonEmpty.agda b/src/Data/AVL/NonEmpty.agda
index 57b0c83ac2..26398cb553 100644
--- a/src/Data/AVL/NonEmpty.agda
+++ b/src/Data/AVL/NonEmpty.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.AVL.NonEmpty
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂) where
diff --git a/src/Data/AVL/NonEmpty/Propositional.agda b/src/Data/AVL/NonEmpty/Propositional.agda
index 70087c1f88..0318537f0e 100644
--- a/src/Data/AVL/NonEmpty/Propositional.agda
+++ b/src/Data/AVL/NonEmpty/Propositional.agda
@@ -6,7 +6,9 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; IsStrictTotalOrder; StrictTotalOrder)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsStrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 open import Relation.Binary.PropositionalEquality using (_≡_; refl; subst)
 
 module Data.AVL.NonEmpty.Propositional
diff --git a/src/Data/AVL/Sets.agda b/src/Data/AVL/Sets.agda
index 7a3d05a177..5d216695db 100644
--- a/src/Data/AVL/Sets.agda
+++ b/src/Data/AVL/Sets.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.AVL.Sets
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
diff --git a/src/Data/AVL/Value.agda b/src/Data/AVL/Value.agda
index 4ddbc30003..6338a876d8 100644
--- a/src/Data/AVL/Value.agda
+++ b/src/Data/AVL/Value.agda
@@ -2,11 +2,11 @@
 -- The Agda standard library
 --
 -- This module is DEPRECATED.
------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Setoid)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.AVL.Value {a ℓ} (S : Setoid a ℓ) where
 
diff --git a/src/Data/Bool.agda b/src/Data/Bool.agda
index 909b659f22..55ed146e2c 100644
--- a/src/Data/Bool.agda
+++ b/src/Data/Bool.agda
@@ -8,11 +8,6 @@
 
 module Data.Bool where
 
-open import Relation.Nullary
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as PropEq
-  using (_≡_; refl)
-
 ------------------------------------------------------------------------
 -- The boolean type and some operations
 
diff --git a/src/Data/Bool/Base.agda b/src/Data/Bool/Base.agda
index bc2e67644b..ea99ee880d 100644
--- a/src/Data/Bool/Base.agda
+++ b/src/Data/Bool/Base.agda
@@ -57,17 +57,19 @@ true  xor b = not b
 false xor b = b
 
 ------------------------------------------------------------------------
--- Other operations
-
-infix  0 if_then_else_
-
-if_then_else_ : Bool → A → A → A
-if true  then t else f = t
-if false then t else f = f
+-- Conversion to Set
 
 -- A function mapping true to an inhabited type and false to an empty
 -- type.
-
 T : Bool → Set
 T true  = ⊤
 T false = ⊥
+
+------------------------------------------------------------------------
+-- Other operations
+
+infix 0 if_then_else_
+
+if_then_else_ : Bool → A → A → A
+if true  then t else f = t
+if false then t else f = f
diff --git a/src/Data/Bool/Properties.agda b/src/Data/Bool/Properties.agda
index beb99befd8..eb7ffb3869 100644
--- a/src/Data/Bool/Properties.agda
+++ b/src/Data/Bool/Properties.agda
@@ -13,18 +13,22 @@ open import Algebra.Lattice.Bundles
 import Algebra.Lattice.Properties.BooleanAlgebra as BooleanAlgebraProperties
 open import Data.Bool.Base
 open import Data.Empty
-open import Data.Product
-open import Data.Sum.Base
-open import Function.Base
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Equivalence
-  using (_⇔_; equivalence; module Equivalence)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂)
+open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_])
+open import Function.Base using (_⟨_⟩_; const; id)
+open import Function.Bundles hiding (LeftInverse; RightInverse; Inverse)
 open import Induction.WellFounded using (WellFounded; Acc; acc)
 open import Level using (Level; 0ℓ)
-open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality hiding ([_])
-open import Relation.Nullary using (ofʸ; ofⁿ; does; proof; yes; no)
-open import Relation.Nullary.Decidable using (True)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsTotalOrder; IsDecTotalOrder; IsStrictPartialOrder; IsStrictTotalOrder)
+open import Relation.Binary.Bundles
+  using (Setoid; DecSetoid; Poset; Preorder; TotalOrder; DecTotalOrder; StrictPartialOrder; StrictTotalOrder)
+open import Relation.Binary.Definitions
+  using (Decidable; DecidableEquality; Reflexive; Transitive; Antisymmetric; Minimum; Maximum; Total; Irrelevant; Irreflexive; Asymmetric; Trans; Trichotomous; tri≈; tri<; tri>; _Respects₂_)
+open import Relation.Binary.PropositionalEquality.Core
+open import Relation.Binary.PropositionalEquality.Properties
+open import Relation.Nullary.Decidable.Core using (True; yes; no; fromWitness)
 import Relation.Unary as U
 
 open import Algebra.Definitions {A = Bool} _≡_
@@ -44,7 +48,7 @@ private
 
 infix 4 _≟_
 
-_≟_ : Decidable {A = Bool} _≡_
+_≟_ : DecidableEquality Bool
 true  ≟ true  = yes refl
 false ≟ false = yes refl
 true  ≟ false = no λ()
@@ -190,8 +194,8 @@ true  <? _     = no  (λ())
 <-wellFounded : WellFounded _<_
 <-wellFounded _ = acc <-acc
   where
-    <-acc : ∀ {x} y → y < x → Acc _<_ y
-    <-acc false f<t = acc (λ _ → λ())
+    <-acc : ∀ {x y} → y < x → Acc _<_ y
+    <-acc f<t = acc λ ()
 
 -- Structures
 
@@ -205,9 +209,8 @@ true  <? _     = no  (λ())
 
 <-isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_
 <-isStrictTotalOrder = record
-  { isEquivalence = isEquivalence
-  ; trans         = <-trans
-  ; compare       = <-cmp
+  { isStrictPartialOrder = <-isStrictPartialOrder
+  ; compare              = <-cmp
   }
 
 -- Bundles
@@ -273,6 +276,15 @@ true  <? _     = no  (λ())
 ∨-sel false y = inj₂ refl
 ∨-sel true y  = inj₁ refl
 
+∨-conicalˡ : LeftConical false _∨_
+∨-conicalˡ false false _ = refl
+
+∨-conicalʳ : RightConical false _∨_
+∨-conicalʳ false false _ = refl
+
+∨-conical : Conical false _∨_
+∨-conical = ∨-conicalˡ , ∨-conicalʳ
+
 ∨-isMagma : IsMagma _∨_
 ∨-isMagma = record
   { isEquivalence = isEquivalence
@@ -397,6 +409,15 @@ true  <? _     = no  (λ())
 ∧-sel false y = inj₁ refl
 ∧-sel true y  = inj₂ refl
 
+∧-conicalˡ : LeftConical true _∧_
+∧-conicalˡ true true _ = refl
+
+∧-conicalʳ : RightConical true _∧_
+∧-conicalʳ true true _ = refl
+
+∧-conical : Conical true _∧_
+∧-conical = ∧-conicalˡ , ∧-conicalʳ
+
 ∧-distribˡ-∨ : _∧_ DistributesOverˡ _∨_
 ∧-distribˡ-∨ true  y z = refl
 ∧-distribˡ-∨ false y z = refl
@@ -608,20 +629,7 @@ true  <? _     = no  (λ())
   }
 
 ------------------------------------------------------------------------
--- Properties of _xor_
-
-xor-is-ok : ∀ x y → x xor y ≡ (x ∨ y) ∧ not (x ∧ y)
-xor-is-ok true  y = refl
-xor-is-ok false y = sym (∧-identityʳ _)
-
-xor-∧-commutativeRing : CommutativeRing 0ℓ 0ℓ
-xor-∧-commutativeRing = ⊕-∧-commutativeRing
-  where
-  open BooleanAlgebraProperties ∨-∧-booleanAlgebra
-  open XorRing _xor_ xor-is-ok
-
-------------------------------------------------------------------------
--- Miscellaneous other properties
+-- Properties of not
 
 not-involutive : Involutive not
 not-involutive true  = refl
@@ -641,44 +649,140 @@ not-¬ {false} refl ()
 ¬-not {false} {true}  _   = refl
 ¬-not {false} {false} x≢y = ⊥-elim (x≢y refl)
 
-⇔→≡ : {x y z : Bool} → x ≡ z ⇔ y ≡ z → x ≡ y
-⇔→≡ {true } {true }         hyp = refl
-⇔→≡ {true } {false} {true } hyp = sym (Equivalence.to hyp ⟨$⟩ refl)
-⇔→≡ {true } {false} {false} hyp = Equivalence.from hyp ⟨$⟩ refl
-⇔→≡ {false} {true } {true } hyp = Equivalence.from hyp ⟨$⟩ refl
-⇔→≡ {false} {true } {false} hyp = sym (Equivalence.to hyp ⟨$⟩ refl)
-⇔→≡ {false} {false}         hyp = refl
+------------------------------------------------------------------------
+-- Properties of _xor_
+
+xor-is-ok : ∀ x y → x xor y ≡ (x ∨ y) ∧ not (x ∧ y)
+xor-is-ok true  y = refl
+xor-is-ok false y = sym (∧-identityʳ _)
+
+true-xor : ∀ x → true xor x ≡ not x
+true-xor false = refl
+true-xor true  = refl
+
+xor-same : ∀ x → x xor x ≡ false
+xor-same false = refl
+xor-same true  = refl
+
+not-distribˡ-xor : ∀ x y → not (x xor y) ≡ (not x) xor y
+not-distribˡ-xor false y = refl
+not-distribˡ-xor true  y = not-involutive _
+
+not-distribʳ-xor : ∀ x y → not (x xor y) ≡ x xor (not y)
+not-distribʳ-xor false y = refl
+not-distribʳ-xor true  y = refl
+
+xor-assoc : Associative _xor_
+xor-assoc true  y z = sym (not-distribˡ-xor y z)
+xor-assoc false y z = refl
+
+xor-comm : Commutative _xor_
+xor-comm false false = refl
+xor-comm false true  = refl
+xor-comm true  false = refl
+xor-comm true  true  = refl
+
+xor-identityˡ : LeftIdentity false _xor_
+xor-identityˡ _ = refl
+
+xor-identityʳ : RightIdentity false _xor_
+xor-identityʳ false = refl
+xor-identityʳ true  = refl
+
+xor-identity : Identity false _xor_
+xor-identity = xor-identityˡ , xor-identityʳ
+
+xor-inverseˡ : LeftInverse true not _xor_
+xor-inverseˡ false = refl
+xor-inverseˡ true = refl
+
+xor-inverseʳ : RightInverse true not _xor_
+xor-inverseʳ x = xor-comm x (not x) ⟨ trans ⟩ xor-inverseˡ x
+
+xor-inverse : Inverse true not _xor_
+xor-inverse = xor-inverseˡ , xor-inverseʳ
+
+∧-distribˡ-xor : _∧_ DistributesOverˡ _xor_
+∧-distribˡ-xor false y z = refl
+∧-distribˡ-xor true  y z = refl
+
+∧-distribʳ-xor : _∧_ DistributesOverʳ _xor_
+∧-distribʳ-xor x false z    = refl
+∧-distribʳ-xor x true false = sym (xor-identityʳ x)
+∧-distribʳ-xor x true true  = sym (xor-same x)
+
+∧-distrib-xor : _∧_ DistributesOver _xor_
+∧-distrib-xor = ∧-distribˡ-xor , ∧-distribʳ-xor
+
+xor-annihilates-not : ∀ x y → (not x) xor (not y) ≡ x xor y
+xor-annihilates-not false y = not-involutive _
+xor-annihilates-not true  y = refl
+
+xor-∧-commutativeRing : CommutativeRing 0ℓ 0ℓ
+xor-∧-commutativeRing = ⊕-∧-commutativeRing
+  where
+  open BooleanAlgebraProperties ∨-∧-booleanAlgebra
+  open XorRing _xor_ xor-is-ok
+
+------------------------------------------------------------------------
+-- Properties of if_then_else_
+
+if-float : ∀ (f : A → B) b {x y} →
+           f (if b then x else y) ≡ (if b then f x else f y)
+if-float _ true  = refl
+if-float _ false = refl
+
+------------------------------------------------------------------------
+-- Properties of T
+
+open Relation.Nullary.Decidable.Core public using (T?)
 
 T-≡ : ∀ {x} → T x ⇔ x ≡ true
-T-≡ {false} = equivalence (λ ())       (λ ())
-T-≡ {true}  = equivalence (const refl) (const _)
+T-≡ {false} = mk⇔ (λ ())       (λ ())
+T-≡ {true}  = mk⇔ (const refl) (const _)
 
 T-not-≡ : ∀ {x} → T (not x) ⇔ x ≡ false
-T-not-≡ {false} = equivalence (const refl) (const _)
-T-not-≡ {true}  = equivalence (λ ())       (λ ())
+T-not-≡ {false} = mk⇔ (const refl) (const _)
+T-not-≡ {true}  = mk⇔ (λ ())       (λ ())
 
 T-∧ : ∀ {x y} → T (x ∧ y) ⇔ (T x × T y)
-T-∧ {true}  {true}  = equivalence (const (_ , _)) (const _)
-T-∧ {true}  {false} = equivalence (λ ())          proj₂
-T-∧ {false} {_}     = equivalence (λ ())          proj₁
+T-∧ {true}  {true}  = mk⇔ (const (_ , _)) (const _)
+T-∧ {true}  {false} = mk⇔ (λ ())          proj₂
+T-∧ {false} {_}     = mk⇔ (λ ())          proj₁
 
 T-∨ : ∀ {x y} → T (x ∨ y) ⇔ (T x ⊎ T y)
-T-∨ {true}  {_}     = equivalence inj₁ (const _)
-T-∨ {false} {true}  = equivalence inj₂ (const _)
-T-∨ {false} {false} = equivalence inj₁ [ id , id ]
+T-∨ {true}  {_}     = mk⇔ inj₁ (const _)
+T-∨ {false} {true}  = mk⇔ inj₂ (const _)
+T-∨ {false} {false} = mk⇔ inj₁ [ id , id ]
 
 T-irrelevant : U.Irrelevant T
 T-irrelevant {true}  _  _  = refl
 
-T? : U.Decidable T
-does  (T? b) = b
-proof (T? true ) = ofʸ _
-proof (T? false) = ofⁿ λ()
-
 T?-diag : ∀ b → T b → True (T? b)
-T?-diag true  _ = _
+T?-diag b = fromWitness
+
+------------------------------------------------------------------------
+-- Miscellaneous other properties
+
+⇔→≡ : {x y z : Bool} → x ≡ z ⇔ y ≡ z → x ≡ y
+⇔→≡ {true } {true }         hyp = refl
+⇔→≡ {true } {false} {true } hyp = sym (Equivalence.to hyp refl)
+⇔→≡ {true } {false} {false} hyp = Equivalence.from hyp refl
+⇔→≡ {false} {true } {true } hyp = Equivalence.from hyp refl
+⇔→≡ {false} {true } {false} hyp = sym (Equivalence.to hyp refl)
+⇔→≡ {false} {false}         hyp = refl
+
+
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
 
-push-function-into-if : ∀ (f : A → B) x {y z} →
-                        f (if x then y else z) ≡ (if x then f y else f z)
-push-function-into-if _ true  = refl
-push-function-into-if _ false = refl
+push-function-into-if = if-float
+{-# WARNING_ON_USAGE push-function-into-if
+"Warning: push-function-into-if was deprecated in v2.0.
+Please use if-float instead."
+#-}
diff --git a/src/Data/Bool/Show.agda b/src/Data/Bool/Show.agda
index 21f2ec1a55..075efaa63b 100644
--- a/src/Data/Bool/Show.agda
+++ b/src/Data/Bool/Show.agda
@@ -9,8 +9,13 @@
 module Data.Bool.Show where
 
 open import Data.Bool.Base using (Bool; false; true)
+open import Data.Char.Base using (Char)
 open import Data.String.Base using (String)
 
 show : Bool → String
 show true  = "true"
 show false = "false"
+
+showBit : Bool → Char
+showBit true = '1'
+showBit false = '0'
diff --git a/src/Data/Bool/Solver.agda b/src/Data/Bool/Solver.agda
index 8de769b42f..6a1cc83b03 100644
--- a/src/Data/Bool/Solver.agda
+++ b/src/Data/Bool/Solver.agda
@@ -4,7 +4,7 @@
 -- Automatic solvers for equations over booleans
 ------------------------------------------------------------------------
 
--- See README.Nat for examples of how to use similar solvers
+-- See README.Data.Nat for examples of how to use similar solvers
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
diff --git a/src/Data/Bytestring/Base.agda b/src/Data/Bytestring/Base.agda
new file mode 100644
index 0000000000..69bdb23db4
--- /dev/null
+++ b/src/Data/Bytestring/Base.agda
@@ -0,0 +1,73 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Bytestrings: simple types and functions
+-- Note that these functions do not perform bound checks.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Bytestring.Base where
+
+open import Data.Nat.Base using (ℕ; _+_; _*_; _^_)
+open import Agda.Builtin.String using (String)
+import Data.Fin.Base as Fin
+open import Data.Vec.Base as Vec using (Vec)
+open import Data.Word8.Base as Word8 using (Word8)
+open import Data.Word64.Base as Word64 using (Word64)
+
+open import Function.Base using (const; _$_)
+
+------------------------------------------------------------------------------
+-- Re-export type and operations
+
+open import Data.Bytestring.Primitive as Prim public
+  using ( Bytestring
+        ; length
+        ; take
+        ; drop
+        ; show
+        )
+  renaming (index to getWord8)
+
+------------------------------------------------------------------------------
+-- Operations
+
+slice : Word64 → Word64 → Bytestring → Bytestring
+slice start chunk buf = take chunk (drop start buf)
+
+------------------------------------------------------------------------------
+-- Generic combinators for fixed-size encodings
+
+getWord8s : (n : ℕ) → Bytestring → Word64 → Vec Word8 n
+getWord8s n buf idx
+  = let idx = Word64.toℕ idx in
+  Vec.map (λ k → getWord8 buf (Word64.fromℕ (idx + Fin.toℕ k)))
+  $ Vec.allFin n
+
+-- Little endian representation:
+-- Low place values first
+fromWord8sLE : ∀ {n w} {W : Set w} → (fromℕ : ℕ → W) → Vec Word8 n → W
+fromWord8sLE f ws = f (Vec.foldr′ (λ w acc → Word8.toℕ w + acc * (2 ^ 8)) 0 ws)
+
+-- Big endian representation
+-- Big place values first
+fromWord8sBE : ∀ {n w} {W : Set w} → (fromℕ : ℕ → W) → Vec Word8 n → W
+fromWord8sBE f ws = f (Vec.foldl′ (λ acc w → acc * (2 ^ 8) + Word8.toℕ w) 0 ws)
+
+------------------------------------------------------------------------------
+-- Decoding to a vector of bytes
+
+toWord8s : (b : Bytestring) → Vec Word8 (length b)
+toWord8s b = getWord8s _ b (Word64.fromℕ 0)
+
+------------------------------------------------------------------------------
+-- Getting Word64
+
+getWord64LE : Bytestring → Word64 → Word64
+getWord64LE buf idx
+  = fromWord8sLE Word64.fromℕ (getWord8s 8 buf idx)
+
+getWord64BE : Bytestring → Word64 → Word64
+getWord64BE buf idx
+  = fromWord8sBE Word64.fromℕ (getWord8s 8 buf idx)
diff --git a/src/Data/Bytestring/Builder/Base.agda b/src/Data/Bytestring/Builder/Base.agda
new file mode 100644
index 0000000000..728ceb3896
--- /dev/null
+++ b/src/Data/Bytestring/Builder/Base.agda
@@ -0,0 +1,72 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Bytestrings: builder type and functions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Bytestring.Builder.Base where
+
+open import Data.Nat.Base using (ℕ; zero; suc; _/_; _%_; _^_)
+open import Data.Word8.Base as Word8 using (Word8)
+open import Data.Word64.Base as Word64 using (Word64)
+open import Function.Base using (_∘′_)
+
+------------------------------------------------------------------------------
+-- Re-export type and operations
+
+open import Data.Bytestring.Builder.Primitive as Prim public
+  using ( Builder
+        ; toBytestring
+        ; bytestring
+        ; word8
+        ; empty
+        ; _<>_
+        )
+
+------------------------------------------------------------------------------
+-- High-level combinators
+
+module List where
+
+  open import Data.List.Base as List using (List)
+
+  concat : List Builder → Builder
+  concat = List.foldr _<>_ empty
+
+module Vec where
+
+  open import Data.Vec.Base as Vec using (Vec)
+
+  concat : ∀ {n} → Vec Builder n → Builder
+  concat = Vec.foldr′ _<>_ empty
+open Vec
+
+------------------------------------------------------------------------------
+-- Generic word-specific combinators
+
+open import Data.Vec.Base as Vec using (Vec; []; _∷_)
+
+wordN : ∀ {n} → Vec Word8 n → Builder
+wordN = concat ∘′ Vec.map word8
+
+toWord8sLE : ∀ {w} {W : Set w} (n : ℕ) (toℕ : W → ℕ) → W → Vec Word8 n
+toWord8sLE n toℕ w = loop (toℕ w) n where
+
+  loop : ℕ → (n : ℕ) → Vec Word8 n
+  loop acc 0 = []
+  loop acc 1 = Word8.fromℕ acc ∷ []
+  loop acc (suc n) = Word8.fromℕ (acc % 2 ^ 8) ∷ loop (acc / 2 ^ 8) n
+
+toWord8sBE : ∀ {w} {W : Set w} (n : ℕ) (toℕ : W → ℕ) → W → Vec Word8 n
+toWord8sBE n toℕ w = Vec.reverse (toWord8sLE n toℕ w)
+
+------------------------------------------------------------------------------
+-- Builders for Word64
+
+word64LE : Word64 → Builder
+word64LE w = wordN (toWord8sLE 8 Word64.toℕ w)
+
+word64BE : Word64 → Builder
+word64BE w = wordN (toWord8sBE 8 Word64.toℕ w)
diff --git a/src/Data/Bytestring/Builder/Primitive.agda b/src/Data/Bytestring/Builder/Primitive.agda
new file mode 100644
index 0000000000..b9f2bd8937
--- /dev/null
+++ b/src/Data/Bytestring/Builder/Primitive.agda
@@ -0,0 +1,38 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Primitive Bytestrings: builder type and functions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Bytestring.Builder.Primitive where
+
+open import Agda.Builtin.Nat
+open import Agda.Builtin.String
+
+open import Data.Word8.Primitive
+open import Data.Bytestring.Primitive using (Bytestring)
+
+infixr 6 _<>_
+
+postulate
+  -- Builder and execution
+  Builder : Set
+  toBytestring : Builder → Bytestring
+
+  -- Assembling a builder
+  bytestring : Bytestring → Builder
+  word8 : Word8 → Builder
+  empty : Builder
+  _<>_ : Builder → Builder → Builder
+
+{-# FOREIGN GHC import qualified Data.ByteString.Builder as Builder #-}
+{-# FOREIGN GHC import qualified Data.ByteString.Lazy as Lazy #-}
+{-# FOREIGN GHC import qualified Data.Text as T #-}
+{-# COMPILE GHC Builder = type Builder.Builder #-}
+{-# COMPILE GHC toBytestring = Lazy.toStrict . Builder.toLazyByteString #-}
+{-# COMPILE GHC bytestring = Builder.byteString #-}
+{-# COMPILE GHC word8 = Builder.word8 #-}
+{-# COMPILE GHC empty = mempty #-}
+{-# COMPILE GHC _<>_ = mappend #-}
diff --git a/src/Data/Bytestring/IO.agda b/src/Data/Bytestring/IO.agda
new file mode 100644
index 0000000000..e79bc2c8a6
--- /dev/null
+++ b/src/Data/Bytestring/IO.agda
@@ -0,0 +1,22 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Bytestrings: IO operations
+------------------------------------------------------------------------
+
+{-# OPTIONS --guardedness --cubical-compatible #-}
+
+module Data.Bytestring.IO where
+
+open import Agda.Builtin.String
+open import IO using (IO; lift)
+open import Data.Bytestring.Base using (Bytestring)
+open import Data.Unit.Base using (⊤)
+
+import Data.Bytestring.IO.Primitive as Prim
+
+readFile : String → IO Bytestring
+readFile fp = lift (Prim.readFile fp)
+
+writeFile : String → Bytestring → IO ⊤
+writeFile fp str = lift (Prim.writeFile fp str)
diff --git a/src/Data/Bytestring/IO/Primitive.agda b/src/Data/Bytestring/IO/Primitive.agda
new file mode 100644
index 0000000000..113ef19e86
--- /dev/null
+++ b/src/Data/Bytestring/IO/Primitive.agda
@@ -0,0 +1,24 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Primitive Bytestrings: IO operations
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Bytestring.IO.Primitive where
+
+open import Agda.Builtin.String using (String)
+open import Agda.Builtin.Unit using (⊤)
+open import IO.Primitive.Core using (IO)
+
+open import Data.Bytestring.Primitive
+
+postulate
+  readFile : String → IO Bytestring
+  writeFile : String → Bytestring → IO ⊤
+
+{-# FOREIGN GHC import qualified Data.Text as T #-}
+{-# FOREIGN GHC import Data.ByteString #-}
+{-# COMPILE GHC readFile = Data.ByteString.readFile . T.unpack #-}
+{-# COMPILE GHC writeFile = Data.ByteString.writeFile . T.unpack #-}
diff --git a/src/Data/Bytestring/Primitive.agda b/src/Data/Bytestring/Primitive.agda
new file mode 100644
index 0000000000..94e0d64b2c
--- /dev/null
+++ b/src/Data/Bytestring/Primitive.agda
@@ -0,0 +1,44 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Primitive bytestrings: simple bindings to Haskell types and functions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Bytestring.Primitive where
+
+open import Agda.Builtin.Nat using (Nat)
+open import Agda.Builtin.String using (String)
+open import Agda.Builtin.Word using (Word64)
+open import Data.Word8.Primitive using (Word8)
+
+-- NB: the bytestring package uses `Int` as the indexing type which
+-- Haskell's base specifies as:
+--
+-- > A fixed-precision integer type with at least the range
+-- > [-2^29 .. 2^29-1]. The exact range for a given implementation
+-- > can be determined by using minBound and maxBound from the
+-- > Bounded class.
+--
+-- There is no ergonomic way to encode that in a type-safe manner.
+-- For now we use `Word64` with the understanding that using indices
+-- greater than 2^29-1 may lead to undefined behaviours...
+
+postulate
+  Bytestring : Set
+  index : Bytestring → Word64 → Word8
+  length : Bytestring → Nat
+  take : Word64 → Bytestring → Bytestring
+  drop : Word64 → Bytestring → Bytestring
+  show : Bytestring → String
+
+{-# FOREIGN GHC import qualified Data.ByteString as B #-}
+{-# FOREIGN GHC import qualified Data.Text as T #-}
+
+{-# COMPILE GHC Bytestring = type B.ByteString #-}
+{-# COMPILE GHC index = \ buf idx -> B.index buf (fromIntegral idx) #-}
+{-# COMPILE GHC length = \ buf -> fromIntegral (B.length buf) #-}
+{-# COMPILE GHC take = B.take . fromIntegral #-}
+{-# COMPILE GHC drop = B.drop . fromIntegral #-}
+{-# COMPILE GHC show = T.pack . Prelude.show #-}
diff --git a/src/Data/Char/Properties.agda b/src/Data/Char/Properties.agda
index 1db34c4f0b..36e6d37d3c 100644
--- a/src/Data/Char/Properties.agda
+++ b/src/Data/Char/Properties.agda
@@ -11,19 +11,26 @@ module Data.Char.Properties where
 open import Data.Bool.Base using (Bool)
 open import Data.Char.Base
 import Data.Nat.Base as ℕ
-import Data.Nat.Properties as ℕₚ
-open import Data.Product using (_,_)
+import Data.Nat.Properties as ℕ
+open import Data.Product.Base using (_,_)
 
 open import Function.Base
 open import Relation.Nullary using (¬_; yes; no)
 open import Relation.Nullary.Decidable using (map′; isYes)
-open import Relation.Binary
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Bundles
+  using (Setoid; DecSetoid; StrictPartialOrder; StrictTotalOrder; Preorder; Poset; DecPoset)
+open import Relation.Binary.Structures
+  using (IsDecEquivalence; IsStrictPartialOrder; IsStrictTotalOrder; IsPreorder; IsPartialOrder; IsDecPartialOrder; IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Decidable; DecidableEquality; Trichotomous; Irreflexive; Transitive; Asymmetric; Antisymmetric; Symmetric; Substitutive; Reflexive; tri<; tri≈; tri>)
 import Relation.Binary.Construct.On as On
 import Relation.Binary.Construct.Subst.Equality as Subst
 import Relation.Binary.Construct.Closure.Reflexive as Refl
-import Relation.Binary.Construct.Closure.Reflexive.Properties as Reflₚ
-open import Relation.Binary.PropositionalEquality as PropEq
+import Relation.Binary.Construct.Closure.Reflexive.Properties as Refl
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; _≢_; refl; cong; sym; trans; subst)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 ------------------------------------------------------------------------
 -- Primitive properties
@@ -48,17 +55,17 @@ open import Agda.Builtin.Char.Properties
 -- Properties of _≡_
 
 infix 4 _≟_
-_≟_ : Decidable {A = Char} _≡_
-x ≟ y = map′ ≈⇒≡ ≈-reflexive (toℕ x ℕₚ.≟ toℕ y)
+_≟_ : DecidableEquality Char
+x ≟ y = map′ ≈⇒≡ ≈-reflexive (toℕ x ℕ.≟ toℕ y)
 
 setoid : Setoid _ _
-setoid = PropEq.setoid Char
+setoid = ≡.setoid Char
 
 decSetoid : DecSetoid _ _
-decSetoid = PropEq.decSetoid _≟_
+decSetoid = ≡.decSetoid _≟_
 
 isDecEquivalence : IsDecEquivalence _≡_
-isDecEquivalence = PropEq.isDecEquivalence _≟_
+isDecEquivalence = ≡.isDecEquivalence _≟_
 
 ------------------------------------------------------------------------
 -- Boolean equality test.
@@ -88,37 +95,36 @@ private
 
 infix 4 _<?_
 _<?_ : Decidable _<_
-_<?_ = On.decidable toℕ ℕ._<_ ℕₚ._<?_
+_<?_ = On.decidable toℕ ℕ._<_ ℕ._<?_
 
 <-cmp : Trichotomous _≡_ _<_
-<-cmp c d with ℕₚ.<-cmp (toℕ c) (toℕ d)
+<-cmp c d with ℕ.<-cmp (toℕ c) (toℕ d)
 ... | tri< lt ¬eq ¬gt = tri< lt (≉⇒≢ ¬eq) ¬gt
 ... | tri≈ ¬lt eq ¬gt = tri≈ ¬lt (≈⇒≡ eq) ¬gt
 ... | tri> ¬lt ¬eq gt = tri> ¬lt (≉⇒≢ ¬eq) gt
 
 <-irrefl : Irreflexive _≡_ _<_
-<-irrefl = ℕₚ.<-irrefl ∘′ cong toℕ
+<-irrefl = ℕ.<-irrefl ∘′ cong toℕ
 
 <-trans : Transitive _<_
-<-trans {c} {d} {e} = On.transitive toℕ ℕ._<_ ℕₚ.<-trans {c} {d} {e}
+<-trans {c} {d} {e} = On.transitive toℕ ℕ._<_ ℕ.<-trans {c} {d} {e}
 
 <-asym : Asymmetric _<_
-<-asym {c} {d} = On.asymmetric toℕ ℕ._<_ ℕₚ.<-asym {c} {d}
+<-asym {c} {d} = On.asymmetric toℕ ℕ._<_ ℕ.<-asym {c} {d}
 
 <-isStrictPartialOrder : IsStrictPartialOrder _≡_ _<_
 <-isStrictPartialOrder = record
-  { isEquivalence = PropEq.isEquivalence
+  { isEquivalence = ≡.isEquivalence
   ; irrefl        = <-irrefl
   ; trans         = λ {a} {b} {c} → <-trans {a} {b} {c}
-  ; <-resp-≈      = (λ {c} → PropEq.subst (c <_))
-                  , (λ {c} → PropEq.subst (_< c))
+  ; <-resp-≈      = (λ {c} → ≡.subst (c <_))
+                  , (λ {c} → ≡.subst (_< c))
   }
 
 <-isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_
 <-isStrictTotalOrder = record
-  { isEquivalence = PropEq.isEquivalence
-  ; trans         = λ {a} {b} {c} → <-trans {a} {b} {c}
-  ; compare       = <-cmp
+  { isStrictPartialOrder = <-isStrictPartialOrder
+  ; compare              = <-cmp
   }
 
 <-strictPartialOrder : StrictPartialOrder _ _ _
@@ -136,20 +142,20 @@ _<?_ = On.decidable toℕ ℕ._<_ ℕₚ._<?_
 
 infix 4 _≤?_
 _≤?_ : Decidable _≤_
-_≤?_ = Reflₚ.decidable <-cmp
+_≤?_ = Refl.decidable <-cmp
 
 ≤-reflexive : _≡_ ⇒ _≤_
 ≤-reflexive = Refl.reflexive
 
 ≤-trans : Transitive _≤_
-≤-trans = Reflₚ.trans (λ {a} {b} {c} → <-trans {a} {b} {c})
+≤-trans = Refl.trans (λ {a} {b} {c} → <-trans {a} {b} {c})
 
 ≤-antisym : Antisymmetric _≡_ _≤_
-≤-antisym = Reflₚ.antisym _≡_ refl ℕₚ.<-asym
+≤-antisym = Refl.antisym _≡_ refl ℕ.<-asym
 
 ≤-isPreorder : IsPreorder _≡_ _≤_
 ≤-isPreorder = record
-  { isEquivalence = PropEq.isEquivalence
+  { isEquivalence = ≡.isEquivalence
   ; reflexive     = ≤-reflexive
   ; trans         = ≤-trans
   }
@@ -214,7 +220,7 @@ Please use Propositional Equality's subst instead."
 
 infix 4 _≈?_
 _≈?_ : Decidable _≈_
-x ≈? y = toℕ x ℕₚ.≟ toℕ y
+x ≈? y = toℕ x ℕ.≟ toℕ y
 
 ≈-isEquivalence : IsEquivalence _≈_
 ≈-isEquivalence = record
@@ -271,28 +277,28 @@ Please use decSetoid instead."
 #-}
 
 <-isStrictPartialOrder-≈ : IsStrictPartialOrder _≈_ _<_
-<-isStrictPartialOrder-≈ = On.isStrictPartialOrder toℕ ℕₚ.<-isStrictPartialOrder
+<-isStrictPartialOrder-≈ = On.isStrictPartialOrder toℕ ℕ.<-isStrictPartialOrder
 {-# WARNING_ON_USAGE <-isStrictPartialOrder-≈
 "Warning: <-isStrictPartialOrder-≈ was deprecated in v1.5.
 Please use <-isStrictPartialOrder instead."
 #-}
 
 <-isStrictTotalOrder-≈ : IsStrictTotalOrder _≈_ _<_
-<-isStrictTotalOrder-≈ = On.isStrictTotalOrder toℕ ℕₚ.<-isStrictTotalOrder
+<-isStrictTotalOrder-≈ = On.isStrictTotalOrder toℕ ℕ.<-isStrictTotalOrder
 {-# WARNING_ON_USAGE <-isStrictTotalOrder-≈
 "Warning: <-isStrictTotalOrder-≈ was deprecated in v1.5.
 Please use <-isStrictTotalOrder instead."
 #-}
 
 <-strictPartialOrder-≈ : StrictPartialOrder _ _ _
-<-strictPartialOrder-≈ = On.strictPartialOrder ℕₚ.<-strictPartialOrder toℕ
+<-strictPartialOrder-≈ = On.strictPartialOrder ℕ.<-strictPartialOrder toℕ
 {-# WARNING_ON_USAGE <-strictPartialOrder-≈
 "Warning: <-strictPartialOrder-≈ was deprecated in v1.5.
 Please use <-strictPartialOrder instead."
 #-}
 
 <-strictTotalOrder-≈ : StrictTotalOrder _ _ _
-<-strictTotalOrder-≈ = On.strictTotalOrder ℕₚ.<-strictTotalOrder toℕ
+<-strictTotalOrder-≈ = On.strictTotalOrder ℕ.<-strictTotalOrder toℕ
 {-# WARNING_ON_USAGE <-strictTotalOrder-≈
 "Warning: <-strictTotalOrder-≈ was deprecated in v1.5.
 Please use <-strictTotalOrder instead."
diff --git a/src/Data/Container/Combinator.agda b/src/Data/Container/Combinator.agda
index e70d3e5ef4..3d73977470 100644
--- a/src/Data/Container/Combinator.agda
+++ b/src/Data/Container/Combinator.agda
@@ -10,10 +10,10 @@ module Data.Container.Combinator where
 
 open import Level using (Level; _⊔_; lower)
 open import Data.Empty.Polymorphic using (⊥; ⊥-elim)
-open import Data.Product as P using (_,_; <_,_>; proj₁; proj₂; ∃)
-open import Data.Sum.Base as S using ([_,_]′)
+open import Data.Product.Base as Product using (_,_; <_,_>; proj₁; proj₂; ∃)
+open import Data.Sum.Base as Sum using ([_,_]′)
 open import Data.Unit.Polymorphic.Base using (⊤)
-import Function as F
+import Function.Base as F
 
 open import Data.Container.Core
 open import Data.Container.Relation.Unary.Any
@@ -58,10 +58,10 @@ module _ {s₁ s₂ p₁ p₂} (C₁ : Container s₁ p₁) (C₂ : Container s
   _∘_ .Position = ◇ C₁ (Position C₂)
 
   to-∘ : ∀ {a} {A : Set a} → ⟦ C₁ ⟧ (⟦ C₂ ⟧ A) → ⟦ _∘_ ⟧ A
-  to-∘ (s , f) = ((s , proj₁ F.∘ f) , P.uncurry (proj₂ F.∘ f) F.∘′ ◇.proof)
+  to-∘ (s , f) = ((s , proj₁ F.∘ f) , Product.uncurry (proj₂ F.∘ f) F.∘′ ◇.proof)
 
   from-∘ : ∀ {a} {A : Set a} → ⟦ _∘_ ⟧ A → ⟦ C₁ ⟧ (⟦ C₂ ⟧ A)
-  from-∘ ((s , f) , g) = (s , < f , P.curry (g F.∘′ any) >)
+  from-∘ ((s , f) , g) = (s , < f , Product.curry (g F.∘′ any) >)
 
 -- Product. (Note that, up to isomorphism, this is a special case of
 -- indexed product.)
@@ -69,14 +69,14 @@ module _ {s₁ s₂ p₁ p₂} (C₁ : Container s₁ p₁) (C₂ : Container s
   infixr 2 _×_
 
   _×_ : Container (s₁ ⊔ s₂) (p₁ ⊔ p₂)
-  _×_ .Shape    = Shape C₁ P.× Shape C₂
-  _×_ .Position = P.uncurry λ s₁ s₂ → (Position C₁ s₁) S.⊎ (Position C₂ s₂)
+  _×_ .Shape    = Shape C₁ Product.× Shape C₂
+  _×_ .Position = Product.uncurry λ s₁ s₂ → (Position C₁ s₁) Sum.⊎ (Position C₂ s₂)
 
-  to-× : ∀ {a} {A : Set a} → ⟦ C₁ ⟧ A P.× ⟦ C₂ ⟧ A → ⟦ _×_ ⟧ A
+  to-× : ∀ {a} {A : Set a} → ⟦ C₁ ⟧ A Product.× ⟦ C₂ ⟧ A → ⟦ _×_ ⟧ A
   to-× ((s₁ , f₁) , (s₂ , f₂)) = ((s₁ , s₂) , [ f₁ , f₂ ]′)
 
-  from-× : ∀ {a} {A : Set a} → ⟦ _×_ ⟧ A → ⟦ C₁ ⟧ A P.× ⟦ C₂ ⟧ A
-  from-× ((s₁ , s₂) , f) = ((s₁ , f F.∘ S.inj₁) , (s₂ , f F.∘ S.inj₂))
+  from-× : ∀ {a} {A : Set a} → ⟦ _×_ ⟧ A → ⟦ C₁ ⟧ A Product.× ⟦ C₂ ⟧ A
+  from-× ((s₁ , s₂) , f) = ((s₁ , f F.∘ Sum.inj₁) , (s₂ , f F.∘ Sum.inj₂))
 
 -- Indexed product.
 
@@ -87,7 +87,7 @@ module _ {i s p} (I : Set i) (Cᵢ : I → Container s p) where
   Π .Position = λ s → ∃ λ i → Position (Cᵢ i) (s i)
 
   to-Π : ∀ {a} {A : Set a} → (∀ i → ⟦ Cᵢ i ⟧ A) → ⟦ Π ⟧ A
-  to-Π f = (proj₁ F.∘ f , P.uncurry (proj₂ F.∘ f))
+  to-Π f = (proj₁ F.∘ f , Product.uncurry (proj₂ F.∘ f))
 
   from-Π : ∀ {a} {A : Set a} → ⟦ Π ⟧ A → ∀ i → ⟦ Cᵢ i ⟧ A
   from-Π (s , f) = λ i → (s i , λ p → f (i , p))
@@ -108,15 +108,15 @@ module _ {s₁ s₂ p} (C₁ : Container s₁ p) (C₂ : Container s₂ p) where
   infixr 1 _⊎_
 
   _⊎_ : Container (s₁ ⊔ s₂) p
-  _⊎_ .Shape    = (Shape C₁ S.⊎ Shape C₂)
+  _⊎_ .Shape    = (Shape C₁ Sum.⊎ Shape C₂)
   _⊎_ .Position = [ Position C₁ , Position C₂ ]′
 
-  to-⊎ : ∀ {a} {A : Set a} → ⟦ C₁ ⟧ A S.⊎ ⟦ C₂ ⟧ A → ⟦ _⊎_ ⟧ A
-  to-⊎ = [ P.map S.inj₁ F.id , P.map S.inj₂ F.id ]′
+  to-⊎ : ∀ {a} {A : Set a} → ⟦ C₁ ⟧ A Sum.⊎ ⟦ C₂ ⟧ A → ⟦ _⊎_ ⟧ A
+  to-⊎ = [ Product.map Sum.inj₁ F.id , Product.map Sum.inj₂ F.id ]′
 
-  from-⊎ : ∀ {a} {A : Set a} → ⟦ _⊎_ ⟧ A → ⟦ C₁ ⟧ A S.⊎ ⟦ C₂ ⟧ A
-  from-⊎ (S.inj₁ s₁ , f) = S.inj₁ (s₁ , f)
-  from-⊎ (S.inj₂ s₂ , f) = S.inj₂ (s₂ , f)
+  from-⊎ : ∀ {a} {A : Set a} → ⟦ _⊎_ ⟧ A → ⟦ C₁ ⟧ A Sum.⊎ ⟦ C₂ ⟧ A
+  from-⊎ (Sum.inj₁ s₁ , f) = Sum.inj₁ (s₁ , f)
+  from-⊎ (Sum.inj₂ s₂ , f) = Sum.inj₂ (s₂ , f)
 
 -- Indexed sum.
 
diff --git a/src/Data/Container/Combinator/Properties.agda b/src/Data/Container/Combinator/Properties.agda
index 5799b857f8..4a91a903a2 100644
--- a/src/Data/Container/Combinator/Properties.agda
+++ b/src/Data/Container/Combinator/Properties.agda
@@ -9,16 +9,15 @@
 module Data.Container.Combinator.Properties where
 
 open import Axiom.Extensionality.Propositional using (Extensionality)
-open import Data.Container.Core
+open import Data.Container.Core using (Container; ⟦_⟧)
 open import Data.Container.Combinator
-open import Data.Container.Relation.Unary.Any
 open import Data.Empty using (⊥-elim)
-open import Data.Product as Prod using (∃; _,_; proj₁; proj₂; <_,_>; uncurry; curry)
+open import Data.Product.Base as P using (∃; _,_; proj₁; proj₂; <_,_>; uncurry; curry)
 open import Data.Sum.Base as S using (inj₁; inj₂; [_,_]′; [_,_])
-open import Function as F using (_∘′_)
-open import Function.Inverse as Inv using (_↔_; inverse; module Inverse)
+open import Function.Base as F using (_∘′_)
+open import Function.Bundles using (_↔_; mk↔ₛ′)
 open import Level using (_⊔_; lower)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; _≗_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; _≗_; refl; cong)
 
 -- I have proved some of the correctness statements under the
 -- assumption of functional extensionality. I could have reformulated
@@ -27,52 +26,52 @@ open import Relation.Binary.PropositionalEquality as P using (_≡_; _≗_)
 module Identity where
 
   correct : ∀ {s p x} {X : Set x} → ⟦ id {s} {p} ⟧ X ↔ F.id X
-  correct {X = X} = inverse from-id to-id (λ _ → P.refl) (λ _ → P.refl)
+  correct {X = X} = mk↔ₛ′ from-id to-id (λ _ → refl) (λ _ → refl)
 
 module Constant (ext : ∀ {ℓ ℓ′} → Extensionality ℓ ℓ′) where
 
   correct : ∀ {x p y} (X : Set x) {Y : Set y} → ⟦ const {x} {p ⊔ y} X ⟧ Y ↔ F.const X Y
-  correct {x} {y} X {Y} = inverse (from-const X) (to-const X) from∘to λ _ → P.refl
+  correct {x} {y} X {Y} = mk↔ₛ′ (from-const X) (to-const X) (λ _ → refl) from∘to
     where
     from∘to : (x : ⟦ const X ⟧ Y) → to-const X (proj₁ x) ≡ x
-    from∘to xs = P.cong (proj₁ xs ,_) (ext (λ x → ⊥-elim (lower x)))
+    from∘to xs = cong (proj₁ xs ,_) (ext (λ x → ⊥-elim (lower x)))
 
 module Composition {s₁ s₂ p₁ p₂} (C₁ : Container s₁ p₁) (C₂ : Container s₂ p₂) where
 
   correct : ∀ {x} {X : Set x} → ⟦ C₁ ∘ C₂ ⟧ X ↔ (⟦ C₁ ⟧ F.∘ ⟦ C₂ ⟧) X
-  correct {X = X} = inverse (from-∘ C₁ C₂) (to-∘ C₁ C₂) (λ _ → P.refl) (λ _ → P.refl)
+  correct {X = X} = mk↔ₛ′ (from-∘ C₁ C₂) (to-∘ C₁ C₂) (λ _ → refl) (λ _ → refl)
 
 module Product (ext : ∀ {ℓ ℓ′} → Extensionality ℓ ℓ′)
        {s₁ s₂ p₁ p₂} (C₁ : Container s₁ p₁) (C₂ : Container s₂ p₂) where
 
-  correct : ∀ {x} {X : Set x} →  ⟦ C₁ × C₂ ⟧ X ↔ (⟦ C₁ ⟧ X Prod.× ⟦ C₂ ⟧ X)
-  correct {X = X} = inverse (from-× C₁ C₂) (to-× C₁ C₂) from∘to (λ _ → P.refl)
+  correct : ∀ {x} {X : Set x} →  ⟦ C₁ × C₂ ⟧ X ↔ (⟦ C₁ ⟧ X P.× ⟦ C₂ ⟧ X)
+  correct {X = X} = mk↔ₛ′ (from-× C₁ C₂) (to-× C₁ C₂) (λ _ → refl) from∘to
     where
     from∘to : (to-× C₁ C₂) F.∘ (from-× C₁ C₂) ≗ F.id
     from∘to (s , f) =
-      P.cong (s ,_) (ext [ (λ _ → P.refl) , (λ _ → P.refl) ])
+      cong (s ,_) (ext [ (λ _ → refl) , (λ _ → refl) ])
 
 module IndexedProduct {i s p} {I : Set i} (Cᵢ : I → Container s p) where
 
   correct : ∀ {x} {X : Set x} → ⟦ Π I Cᵢ ⟧ X ↔ (∀ i → ⟦ Cᵢ i ⟧ X)
-  correct {X = X} = inverse (from-Π I Cᵢ) (to-Π I Cᵢ) (λ _ → P.refl) (λ _ → P.refl)
+  correct {X = X} = mk↔ₛ′ (from-Π I Cᵢ) (to-Π I Cᵢ) (λ _ → refl) (λ _ → refl)
 
 module Sum {s₁ s₂ p} (C₁ : Container s₁ p) (C₂ : Container s₂ p) where
 
   correct : ∀ {x} {X : Set x} → ⟦ C₁ ⊎ C₂ ⟧ X ↔ (⟦ C₁ ⟧ X S.⊎ ⟦ C₂ ⟧ X)
-  correct {X = X} = inverse (from-⊎ C₁ C₂) (to-⊎ C₁ C₂) from∘to to∘from
+  correct {X = X} = mk↔ₛ′ (from-⊎ C₁ C₂) (to-⊎ C₁ C₂) to∘from from∘to
     where
     from∘to : (to-⊎ C₁ C₂) F.∘ (from-⊎ C₁ C₂) ≗ F.id
-    from∘to (inj₁ s₁ , f) = P.refl
-    from∘to (inj₂ s₂ , f) = P.refl
+    from∘to (inj₁ s₁ , f) = refl
+    from∘to (inj₂ s₂ , f) = refl
 
     to∘from : (from-⊎ C₁ C₂) F.∘ (to-⊎ C₁ C₂) ≗ F.id
-    to∘from = [ (λ _ → P.refl) , (λ _ → P.refl) ]
+    to∘from = [ (λ _ → refl) , (λ _ → refl) ]
 
 module IndexedSum {i s p} {I : Set i} (C : I → Container s p) where
 
   correct : ∀ {x} {X : Set x} → ⟦ Σ I C ⟧ X ↔ (∃ λ i → ⟦ C i ⟧ X)
-  correct {X = X} = inverse (from-Σ I C) (to-Σ I C) (λ _ → P.refl) (λ _ → P.refl)
+  correct {X = X} = mk↔ₛ′ (from-Σ I C) (to-Σ I C) (λ _ → refl) (λ _ → refl)
 
 module ConstantExponentiation {i s p} {I : Set i} (C : Container s p) where
 
diff --git a/src/Data/Container/Core.agda b/src/Data/Container/Core.agda
index 9d07031d20..07afabe2eb 100644
--- a/src/Data/Container/Core.agda
+++ b/src/Data/Container/Core.agda
@@ -8,11 +8,10 @@
 
 module Data.Container.Core where
 
-open import Level
-open import Data.Product as Prod using (Σ-syntax)
-open import Function.Base
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Inverse using (_↔_; module Inverse)
+open import Level using (Level; _⊔_; suc)
+open import Data.Product.Base as Product using (Σ-syntax)
+open import Function.Base using (_∘_; _∘′_)
+open import Function.Bundles using (Inverse; _↔_)
 open import Relation.Unary using (Pred; _⊆_)
 
 -- Definition of Containers
@@ -34,10 +33,12 @@ open Container public
 
 map : ∀ {s p x y} {C : Container s p} {X : Set x} {Y : Set y} →
       (X → Y) → ⟦ C ⟧ X → ⟦ C ⟧ Y
-map f = Prod.map₂ (f ∘_)
+map f = Product.map₂ (f ∘_)
 
 -- Representation of container morphisms.
 
+infixr 8 _⇒_ _⊸_
+
 record _⇒_ {s₁ s₂ p₁ p₂} (C₁ : Container s₁ p₁) (C₂ : Container s₂ p₂)
            : Set (s₁ ⊔ s₂ ⊔ p₁ ⊔ p₂) where
   constructor _▷_
@@ -46,7 +47,7 @@ record _⇒_ {s₁ s₂ p₁ p₂} (C₁ : Container s₁ p₁) (C₂ : Containe
     position : ∀ {s} → Position C₂ (shape s) → Position C₁ s
 
   ⟪_⟫ : ∀ {x} {X : Set x} → ⟦ C₁ ⟧ X → ⟦ C₂ ⟧ X
-  ⟪_⟫ = Prod.map shape (_∘′ position)
+  ⟪_⟫ = Product.map shape (_∘′ position)
 
 open _⇒_ public
 
@@ -61,7 +62,7 @@ record _⊸_ {s₁ s₂ p₁ p₂} (C₁ : Container s₁ p₁) (C₂ : Containe
   morphism : C₁ ⇒ C₂
   morphism = record
     { shape    = shape⊸
-    ; position = _⟨$⟩_ (Inverse.to position⊸)
+    ; position = Inverse.to position⊸
     }
 
   ⟪_⟫⊸ : ∀ {x} {X : Set x} → ⟦ C₁ ⟧ X → ⟦ C₂ ⟧ X
diff --git a/src/Data/Container/Fixpoints/Sized.agda b/src/Data/Container/Fixpoints/Sized.agda
index abfb877e00..47655af29a 100644
--- a/src/Data/Container/Fixpoints/Sized.agda
+++ b/src/Data/Container/Fixpoints/Sized.agda
@@ -8,10 +8,10 @@
 
 module Data.Container.Fixpoints.Sized where
 
-open import Level
-open import Size
-open import Codata.Sized.M
-open import Data.W.Sized
+open import Level using (Level; _⊔_)
+open import Size using (Size)
+open import Codata.Sized.M using (M)
+open import Data.W.Sized using (W)
 open import Data.Container hiding (μ) public
 
 private
diff --git a/src/Data/Container/FreeMonad.agda b/src/Data/Container/FreeMonad.agda
index d1853782c9..2bbce4a7f7 100644
--- a/src/Data/Container/FreeMonad.agda
+++ b/src/Data/Container/FreeMonad.agda
@@ -10,7 +10,7 @@ module Data.Container.FreeMonad where
 
 open import Level using (Level; _⊔_)
 open import Data.Sum.Base using (inj₁; inj₂ ; [_,_]′)
-open import Data.Product using (_,_; -,_)
+open import Data.Product.Base using (_,_; -,_)
 open import Data.Container using (Container; ⟦_⟧; μ)
 open import Data.Container.Relation.Unary.All using (□; all)
 open import Data.Container.Combinator using (const; _⊎_)
@@ -20,11 +20,12 @@ open import Effect.Applicative using (RawApplicative)
 open import Effect.Monad using (RawMonad)
 open import Function.Base as Function using (_$_; _∘_)
 
-variable
-  x y s p ℓ : Level
-  C : Container s p
-  X : Set x
-  Y : Set y
+private
+  variable
+    x y s p ℓ : Level
+    C : Container s p
+    X : Set x
+    Y : Set y
 
 infixl 1 _⋆C_
 infix  1 _⋆_
@@ -47,7 +48,7 @@ infix  1 _⋆_
 ------------------------------------------------------------------------
 -- Type definition
 
--- The free moand can be defined as the least fixpoint `μ (C ⋆C X)`
+-- The free monad can be defined as the least fixpoint `μ (C ⋆C X)`
 
 _⋆C_ : ∀ {x s p} → Container s p → Set x → Container (s ⊔ x) p
 C ⋆C X = const X ⊎ C
@@ -103,6 +104,9 @@ module _ {P : Set ℓ}
  foldr : C ⋆ X → P
  foldr = induction (Function.const P) algP (algI ∘ -,_ ∘ □.proof)
 
+infixr -1 _<$>_ _<*>_
+infixl 1 _>>=_
+
 _<$>_ : (X → Y) → C ⋆ X → C ⋆ Y
 f <$> t = foldr (pure ∘ f) impure t
 
diff --git a/src/Data/Container/Indexed.agda b/src/Data/Container/Indexed.agda
index 752f55c2a7..f99fef80dc 100644
--- a/src/Data/Container/Indexed.agda
+++ b/src/Data/Container/Indexed.agda
@@ -11,15 +11,14 @@
 
 module Data.Container.Indexed where
 
-open import Level
-open import Data.Product as Prod hiding (map)
-open import Data.W.Indexed
+open import Level using (Level; zero; _⊔_)
+open import Data.Product.Base as Prod hiding (map)
+open import Data.W.Indexed using (W)
 open import Function.Base renaming (id to ⟨id⟩; _∘_ to _⟨∘⟩_)
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Inverse using (_↔_; module Inverse)
+open import Function.Bundles using (_↔_; Inverse)
 open import Relation.Unary using (Pred; _⊆_)
-import Relation.Binary as B
-open import Relation.Binary.PropositionalEquality as P using (_≡_; _≗_; refl)
+open import Relation.Binary.Core using (Rel; REL)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; _≗_; refl; trans; subst)
 
 ------------------------------------------------------------------------
 
@@ -31,6 +30,8 @@ open Container public
 -- Abbreviation for the commonly used level one version of indexed
 -- containers.
 
+infix 5 _▷_
+
 _▷_ : Set → Set → Set₁
 I ▷ O = Container I O zero zero
 
@@ -64,7 +65,7 @@ module _ {i₁ i₂ o₁ o₂}
   record ContainerMorphism {c₁ c₂ r₁ r₂ ℓ₁ ℓ₂}
          (C₁ : Container I₁ O₁ c₁ r₁) (C₂ : Container I₂ O₂ c₂ r₂)
          (f : I₁ → I₂) (g : O₁ → O₂)
-         (_∼_ : B.Rel I₂ ℓ₁) (_≈_ : B.REL (Set r₂) (Set r₁) ℓ₂)
+         (_∼_ : Rel I₂ ℓ₁) (_≈_ : REL (Set r₂) (Set r₁) ℓ₂)
          (_·_ : ∀ {A B} → A ≈ B → A → B) :
          Set (i₁ ⊔ i₂ ⊔ o₁ ⊔ o₂ ⊔ c₁ ⊔ c₂ ⊔ r₁ ⊔ r₂ ⊔ ℓ₁ ⊔ ℓ₂) where
     field
@@ -89,7 +90,7 @@ module _ {i₁ i₂ o₁ o₂}
              Container I₁ O₁ c₁ r₁ → (I₁ → I₂) → (O₁ → O₂) →
              Container I₂ O₂ c₂ r₂ → Set _
   C₁ ⊸[ f / g ] C₂ = ContainerMorphism C₁ C₂ f g _≡_ _↔_
-                                       (λ r₂↔r₁ r₂ → Inverse.to r₂↔r₁ ⟨$⟩ r₂)
+                                       (λ r₂↔r₁ r₂ → Inverse.to r₂↔r₁ r₂)
 
   -- Cartesian container morphism.
 
@@ -97,19 +98,21 @@ module _ {i₁ i₂ o₁ o₂}
               Container I₁ O₁ c₁ r → (I₁ → I₂) → (O₁ → O₂) →
               Container I₂ O₂ c₂ r → Set _
   C₁ ⇒C[ f / g ] C₂ = ContainerMorphism C₁ C₂ f g _≡_ (λ R₂ R₁ → R₂ ≡ R₁)
-                                        (λ r₂≡r₁ r₂ → P.subst ⟨id⟩ r₂≡r₁ r₂)
+                                        (λ r₂≡r₁ r₂ → subst ⟨id⟩ r₂≡r₁ r₂)
 
 -- Degenerate cases where no reindexing is performed.
 
 module _ {i o c r} {I : Set i} {O : Set o} where
 
-  _⇒_ : B.Rel (Container I O c r) _
+  infixr 8 _⇒_ _⊸_ _⇒C_
+
+  _⇒_ : Rel (Container I O c r) _
   C₁ ⇒ C₂ = C₁ ⇒[ ⟨id⟩ / ⟨id⟩ ] C₂
 
-  _⊸_ : B.Rel (Container I O c r) _
+  _⊸_ : Rel (Container I O c r) _
   C₁ ⊸ C₂ = C₁ ⊸[ ⟨id⟩ / ⟨id⟩ ] C₂
 
-  _⇒C_ : B.Rel (Container I O c r) _
+  _⇒C_ : Rel (Container I O c r) _
   C₁ ⇒C C₂ = C₁ ⇒C[ ⟨id⟩ / ⟨id⟩ ] C₂
 
 ------------------------------------------------------------------------
@@ -120,7 +123,7 @@ module _ {i o c r} {I : Set i} {O : Set o} where
 ⟪_⟫ : ∀ {i o c r ℓ} {I : Set i} {O : Set o} {C₁ C₂ : Container I O c r} →
       C₁ ⇒ C₂ → (X : Pred I ℓ) → ⟦ C₁ ⟧ X ⊆ ⟦ C₂ ⟧ X
 ⟪ m ⟫ X (c , k) = command m c , λ r₂ →
-  P.subst X (coherent m) (k (response m r₂))
+  subst X (coherent m) (k (response m r₂))
 
 module PlainMorphism {i o c r} {I : Set i} {O : Set o} where
 
@@ -142,7 +145,7 @@ module PlainMorphism {i o c r} {I : Set i} {O : Set o} where
   f ∘ g = record
     { command  = command  f ⟨∘⟩ command g
     ; response = response g ⟨∘⟩ response f
-    ; coherent = coherent g ⟨ P.trans ⟩ coherent f
+    ; coherent = coherent g ⟨ trans ⟩ coherent f
     }
 
   -- Identity commutes with ⟪_⟫.
@@ -164,7 +167,7 @@ module LinearMorphism
   morphism : C₁ ⇒ C₂
   morphism = record
     { command  = command m
-    ; response = _⟨$⟩_ (Inverse.to (response m))
+    ; response = Inverse.to (response m)
     ; coherent = coherent m
     }
 
@@ -184,7 +187,7 @@ module CartesianMorphism
   morphism : C₁ ⇒ C₂
   morphism = record
     { command  = command m
-    ; response = P.subst ⟨id⟩ (response m)
+    ; response = subst ⟨id⟩ (response m)
     ; coherent = coherent m
     }
 
diff --git a/src/Data/Container/Indexed/Combinator.agda b/src/Data/Container/Indexed/Combinator.agda
index 78e5d213d2..bc5bd194c7 100644
--- a/src/Data/Container/Indexed/Combinator.agda
+++ b/src/Data/Container/Indexed/Combinator.agda
@@ -9,19 +9,21 @@
 module Data.Container.Indexed.Combinator where
 
 open import Axiom.Extensionality.Propositional using (Extensionality)
-open import Data.Container.Indexed
+open import Data.Container.Indexed using (Container; _◃_/_; ⟦_⟧;
+  Command; Response; ◇; next)
 open import Data.Empty.Polymorphic using (⊥; ⊥-elim)
 open import Data.Unit.Polymorphic.Base using (⊤)
-open import Data.Product as Prod hiding (Σ) renaming (_×_ to _⟨×⟩_)
-open import Data.Sum renaming (_⊎_ to _⟨⊎⟩_)
+open import Data.Product.Base as Prod hiding (Σ) renaming (_×_ to _⟨×⟩_)
+open import Data.Sum.Base renaming (_⊎_ to _⟨⊎⟩_)
 open import Data.Sum.Relation.Unary.All as All using (All)
-open import Function as F hiding (id; const) renaming (_∘_ to _⟨∘⟩_)
-open import Function.Inverse using (_↔̇_; inverse)
-open import Level
+open import Function.Base as F hiding (id; const) renaming (_∘_ to _⟨∘⟩_)
+open import Function.Bundles using (mk↔ₛ′)
+open import Function.Indexed.Bundles using (_↔ᵢ_)
+open import Level using (Level; _⊔_)
 open import Relation.Unary using (Pred; _⊆_; _∪_; _∩_; ⋃; ⋂)
   renaming (_⟨×⟩_ to _⟪×⟫_; _⟨⊙⟩_ to _⟪⊙⟫_; _⟨⊎⟩_ to _⟪⊎⟫_)
-open import Relation.Binary.PropositionalEquality as P
-  using (_≗_; refl)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≗_; refl; cong)
 
 private
   variable
@@ -145,8 +147,8 @@ const[ X ]⟶ C = Π {X = X} (F.const C)
 
 module Identity where
 
-  correct : {X : Pred O ℓ} → ⟦ id {c = c}{r} ⟧ X ↔̇ F.id X
-  correct {X = X} = inverse to from (λ _ → refl) (λ _ → refl)
+  correct : {X : Pred O ℓ} → ⟦ id {c = c}{r} ⟧ X ↔ᵢ F.id X
+  correct {X = X} = mk↔ₛ′ to from (λ _ → refl) (λ _ → refl)
     where
     to : ∀ {x} → ⟦ id ⟧ X x → F.id X x
     to xs = proj₂ xs _
@@ -156,15 +158,8 @@ module Identity where
 
 module Constant (ext : ∀ {ℓ} → Extensionality ℓ ℓ) where
 
-  correct : (X : Pred O ℓ₁) {Y : Pred O ℓ₂} → ⟦ const X ⟧ Y ↔̇ F.const X Y
-  correct X {Y} = record
-    { to         = P.→-to-⟶ to
-    ; from       = P.→-to-⟶ from
-    ; inverse-of = record
-      { right-inverse-of = λ _ → refl
-      ; left-inverse-of  = to∘from
-      }
-    }
+  correct : (X : Pred O ℓ₁) {Y : Pred O ℓ₂} → ⟦ const X ⟧ Y ↔ᵢ F.const X Y
+  correct X {Y} = mk↔ₛ′ to from (λ _ → refl) to∘from
     where
     to : ⟦ const X ⟧ Y ⊆ X
     to = proj₁
@@ -173,20 +168,20 @@ module Constant (ext : ∀ {ℓ} → Extensionality ℓ ℓ) where
     from = < F.id , F.const ⊥-elim >
 
     to∘from : _
-    to∘from xs = P.cong (proj₁ xs ,_) (ext ⊥-elim)
+    to∘from xs = cong (proj₁ xs ,_) (ext ⊥-elim)
 
 module Duality where
 
   correct : (C : Container I O c r) (X : Pred I ℓ) →
-            ⟦ C ^⊥ ⟧ X ↔̇ (λ o → (c : Command C o) → ∃ λ r → X (next C c r))
-  correct C X = inverse (λ { (f , g) → < f , g > }) (λ f → proj₁ ⟨∘⟩ f , proj₂ ⟨∘⟩ f)
+            ⟦ C ^⊥ ⟧ X ↔ᵢ (λ o → (c : Command C o) → ∃ λ r → X (next C c r))
+  correct C X = mk↔ₛ′ (λ { (f , g) → < f , g > }) (λ f → proj₁ ⟨∘⟩ f , proj₂ ⟨∘⟩ f)
                         (λ _ → refl) (λ _ → refl)
 
 module Composition where
 
   correct : (C₁ : Container J K c r) (C₂ : Container I J c r) →
-            {X : Pred I ℓ} → ⟦ C₁ ∘ C₂ ⟧ X ↔̇ (⟦ C₁ ⟧ ⟨∘⟩ ⟦ C₂ ⟧) X
-  correct C₁ C₂ {X} = inverse to from (λ _ → refl) (λ _ → refl)
+            {X : Pred I ℓ} → ⟦ C₁ ∘ C₂ ⟧ X ↔ᵢ (⟦ C₁ ⟧ ⟨∘⟩ ⟦ C₂ ⟧) X
+  correct C₁ C₂ {X} = mk↔ₛ′ to from (λ _ → refl) (λ _ → refl)
     where
     to : ⟦ C₁ ∘ C₂ ⟧ X ⊆ ⟦ C₁ ⟧ (⟦ C₂ ⟧ X)
     to ((c , f) , g) = (c , < f , curry g >)
@@ -197,8 +192,8 @@ module Composition where
 module Product (ext : ∀ {ℓ} → Extensionality ℓ ℓ) where
 
   correct : (C₁ C₂ : Container I O c r) {X : Pred I _} →
-            ⟦ C₁ × C₂ ⟧ X ↔̇ (⟦ C₁ ⟧ X ∩ ⟦ C₂ ⟧ X)
-  correct C₁ C₂ {X} = inverse to from from∘to (λ _ → refl)
+            ⟦ C₁ × C₂ ⟧ X ↔ᵢ (⟦ C₁ ⟧ X ∩ ⟦ C₂ ⟧ X)
+  correct C₁ C₂ {X} = mk↔ₛ′ to from (λ _ → refl) from∘to
     where
     to : ⟦ C₁ × C₂ ⟧ X ⊆ ⟦ C₁ ⟧ X ∩ ⟦ C₂ ⟧ X
     to ((c₁ , c₂) , k) = ((c₁ , k ⟨∘⟩ inj₁) , (c₂ , k ⟨∘⟩ inj₂))
@@ -208,13 +203,13 @@ module Product (ext : ∀ {ℓ} → Extensionality ℓ ℓ) where
 
     from∘to : from ⟨∘⟩ to ≗ F.id
     from∘to (c , _) =
-      P.cong (c ,_) (ext [ (λ _ → refl) , (λ _ → refl) ])
+      cong (c ,_) (ext [ (λ _ → refl) , (λ _ → refl) ])
 
 module IndexedProduct where
 
   correct : (C : X → Container I O c r) {Y : Pred I ℓ} →
-            ⟦ Π C ⟧ Y ↔̇ ⋂[ x ∶ X ] ⟦ C x ⟧ Y
-  correct {X = X} C {Y} = inverse to from (λ _ → refl) (λ _ → refl)
+            ⟦ Π C ⟧ Y ↔ᵢ ⋂[ x ∶ X ] ⟦ C x ⟧ Y
+  correct {X = X} C {Y} = mk↔ₛ′ to from (λ _ → refl) (λ _ → refl)
     where
     to : ⟦ Π C ⟧ Y ⊆ ⋂[ x ∶ X ] ⟦ C x ⟧ Y
     to (c , k) = λ x → (c x , λ r → k (x , r))
@@ -225,8 +220,8 @@ module IndexedProduct where
 module Sum (ext : ∀ {ℓ₁ ℓ₂} → Extensionality ℓ₁ ℓ₂) where
 
   correct : (C₁ C₂ : Container I O c r) {X : Pred I ℓ} →
-            ⟦ C₁ ⊎ C₂ ⟧ X ↔̇ (⟦ C₁ ⟧ X ∪ ⟦ C₂ ⟧ X)
-  correct C₁ C₂ {X} = inverse to from from∘to to∘from
+            ⟦ C₁ ⊎ C₂ ⟧ X ↔ᵢ (⟦ C₁ ⟧ X ∪ ⟦ C₂ ⟧ X)
+  correct C₁ C₂ {X} = mk↔ₛ′ to from to∘from from∘to
     where
     to : ⟦ C₁ ⊎ C₂ ⟧ X ⊆ ⟦ C₁ ⟧ X ∪ ⟦ C₂ ⟧ X
     to (inj₁ c₁ , k) = inj₁ (c₁ , λ r → k (All.inj₁ r))
@@ -237,8 +232,8 @@ module Sum (ext : ∀ {ℓ₁ ℓ₂} → Extensionality ℓ₁ ℓ₂) where
     from (inj₂ (c , f)) = inj₂ c , λ{ (All.inj₂ r) → f r}
 
     from∘to : from ⟨∘⟩ to ≗ F.id
-    from∘to (inj₁ _ , _) = P.cong (inj₁ _ ,_) (ext λ{ (All.inj₁ r) → refl})
-    from∘to (inj₂ _ , _) = P.cong (inj₂ _ ,_) (ext λ{ (All.inj₂ r) → refl})
+    from∘to (inj₁ _ , _) = cong (inj₁ _ ,_) (ext λ{ (All.inj₁ r) → refl})
+    from∘to (inj₂ _ , _) = cong (inj₂ _ ,_) (ext λ{ (All.inj₂ r) → refl})
 
     to∘from : to ⟨∘⟩ from ≗ F.id
     to∘from =  [ (λ _ → refl) , (λ _ → refl) ]
@@ -246,8 +241,8 @@ module Sum (ext : ∀ {ℓ₁ ℓ₂} → Extensionality ℓ₁ ℓ₂) where
 module Sum′ where
 
   correct : (C₁ C₂ : Container I O c r) {X : Pred I ℓ} →
-            ⟦ C₁ ⊎′ C₂ ⟧ X ↔̇ (⟦ C₁ ⟧ X ∪ ⟦ C₂ ⟧ X)
-  correct C₁ C₂ {X} = inverse to from from∘to to∘from
+            ⟦ C₁ ⊎′ C₂ ⟧ X ↔ᵢ (⟦ C₁ ⟧ X ∪ ⟦ C₂ ⟧ X)
+  correct C₁ C₂ {X} = mk↔ₛ′ to from to∘from from∘to
     where
     to : ⟦ C₁ ⊎′ C₂ ⟧ X ⊆ ⟦ C₁ ⟧ X ∪ ⟦ C₂ ⟧ X
     to (inj₁ c₁ , k) = inj₁ (c₁ , k)
@@ -266,8 +261,8 @@ module Sum′ where
 module IndexedSum where
 
   correct : (C : X → Container I O c r) {Y : Pred I ℓ} →
-            ⟦ Σ C ⟧ Y ↔̇ ⋃[ x ∶ X ] ⟦ C x ⟧ Y
-  correct {X = X} C {Y} = inverse to from (λ _ → refl) (λ _ → refl)
+            ⟦ Σ C ⟧ Y ↔ᵢ ⋃[ x ∶ X ] ⟦ C x ⟧ Y
+  correct {X = X} C {Y} = mk↔ₛ′ to from (λ _ → refl) (λ _ → refl)
     where
     to : ⟦ Σ C ⟧ Y ⊆ ⋃[ x ∶ X ] ⟦ C x ⟧ Y
     to ((x , c) , k) = (x , (c , k))
@@ -278,5 +273,5 @@ module IndexedSum where
 module ConstantExponentiation where
 
   correct : (C : Container I O c r) {Y : Pred I ℓ} →
-            ⟦ const[ X ]⟶ C ⟧ Y ↔̇ (⋂ X (F.const (⟦ C ⟧ Y)))
+            ⟦ const[ X ]⟶ C ⟧ Y ↔ᵢ (⋂ X (F.const (⟦ C ⟧ Y)))
   correct C {Y} = IndexedProduct.correct (F.const C) {Y}
diff --git a/src/Data/Container/Indexed/Core.agda b/src/Data/Container/Indexed/Core.agda
index 91fb4b2e21..04175781d9 100644
--- a/src/Data/Container/Indexed/Core.agda
+++ b/src/Data/Container/Indexed/Core.agda
@@ -9,37 +9,49 @@
 module Data.Container.Indexed.Core where
 
 open import Level
-open import Data.Product
+open import Data.Product.Base using (Σ; Σ-syntax; _,_; ∃)
 open import Relation.Unary
 
+private variable
+  i o c r ℓ ℓ′ : Level
+  I : Set i
+  O : Set o
+
+------------------------------------------------------------------------
+-- Definition
+
 infix 5 _◃_/_
 
-record Container {i o} (I : Set i) (O : Set o) (c r : Level) :
-                 Set (i ⊔ o ⊔ suc c ⊔ suc r) where
+record Container (I : Set i) (O : Set o) c r : Set (i ⊔ o ⊔ suc c ⊔ suc r) where
   constructor _◃_/_
   field
     Command  : (o : O) → Set c
     Response : ∀ {o} → Command o → Set r
     next     : ∀ {o} (c : Command o) → Response c → I
 
+------------------------------------------------------------------------
 -- The semantics ("extension") of an indexed container.
 
-⟦_⟧ : ∀ {i o c r ℓ} {I : Set i} {O : Set o} → Container I O c r →
-      Pred I ℓ → Pred O _
-⟦ C ◃ R / n ⟧ X o = Σ[ c ∈ C o ] ((r : R c) → X (n c r))
+module _ (C : Container I O c r) (X : Pred I ℓ) where
+  open Container C
+
+  Subtrees : ∀ o → Command o → Set _
+  Subtrees o c = (r : Response c) → X (next c r)
+
+  ⟦_⟧ : Pred O _
+  ⟦_⟧ o = Σ (Command o) (Subtrees o)
 
 ------------------------------------------------------------------------
 -- All and any
 
-module _ {i o c r ℓ} {I : Set i} {O : Set o}
-         (C : Container I O c r) {X : Pred I ℓ} where
+module _ (C : Container I O c r) {X : Pred I ℓ} where
 
   -- All.
 
-  □ : ∀ {ℓ′} → Pred (Σ I X) ℓ′ → Pred (Σ O (⟦ C ⟧ X)) _
+  □ : Pred (Σ I X) ℓ′ → Pred (Σ O (⟦ C ⟧ X)) _
   □ P (_ , _ , k) = ∀ r → P (_ , k r)
 
   -- Any.
 
-  ◇ : ∀ {ℓ′} → Pred (Σ I X) ℓ′ → Pred (Σ O (⟦ C ⟧ X)) _
+  ◇ : Pred (Σ I X) ℓ′ → Pred (Σ O (⟦ C ⟧ X)) _
   ◇ P (_ , _ , k) = ∃ λ r → P (_ , k r)
diff --git a/src/Data/Container/Indexed/FreeMonad.agda b/src/Data/Container/Indexed/FreeMonad.agda
index 1f7d63428d..294ab0bd34 100644
--- a/src/Data/Container/Indexed/FreeMonad.agda
+++ b/src/Data/Container/Indexed/FreeMonad.agda
@@ -9,17 +9,17 @@
 module Data.Container.Indexed.FreeMonad where
 
 open import Level
-open import Function hiding (const)
+open import Function.Base hiding (const)
 open import Effect.Monad.Predicate
 open import Data.Container.Indexed
 open import Data.Container.Indexed.Combinator hiding (id; _∘_)
 open import Data.Empty
 open import Data.Sum.Base using (inj₁; inj₂)
-open import Data.Product
+open import Data.Product.Base using (_,_)
 open import Data.W.Indexed
 open import Relation.Unary
 open import Relation.Unary.PredicateTransformer
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core using (refl)
 
 ------------------------------------------------------------------------
 
diff --git a/src/Data/Container/Indexed/Relation/Binary/Equality/Setoid.agda b/src/Data/Container/Indexed/Relation/Binary/Equality/Setoid.agda
new file mode 100644
index 0000000000..8e259e90f7
--- /dev/null
+++ b/src/Data/Container/Indexed/Relation/Binary/Equality/Setoid.agda
@@ -0,0 +1,60 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Equality over indexed container extensions parametrised by a setoid
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary using (Setoid)
+
+module Data.Container.Indexed.Relation.Binary.Equality.Setoid
+  {ℓⁱ ℓᶜ ℓᵉ} {I : Set ℓⁱ} (S : I → Setoid ℓᶜ ℓᵉ)
+  where
+
+open import Function
+open import Level using (Level; _⊔_; suc)
+open import Relation.Binary
+
+open import Data.Container.Indexed.Core
+open import Data.Container.Indexed.Relation.Binary.Pointwise
+import Data.Container.Indexed.Relation.Binary.Pointwise.Properties
+  as Pointwise
+
+open Setoid using (Carrier; _≈_)
+
+private variable
+  ℓˢ ℓᵖ : Level
+  O : Set _
+
+------------------------------------------------------------------------
+-- Definition of equality
+
+module _ (C : Container I O ℓˢ ℓᵖ) (o : O) where
+
+  Eq : Rel (⟦ C ⟧ (Carrier ∘ S) o) (ℓᵉ ⊔ ℓˢ ⊔ ℓᵖ)
+  Eq = Pointwise C (_≈_ ∘ S) o
+
+------------------------------------------------------------------------
+-- Relational properties
+
+  refl : Reflexive Eq
+  refl = Pointwise.refl C _ (Setoid.refl ∘ S)
+
+  sym : Symmetric Eq
+  sym = Pointwise.sym C _ (Setoid.sym ∘ S)
+
+  trans : Transitive Eq
+  trans = Pointwise.trans C _ (Setoid.trans ∘ S)
+
+  isEquivalence : IsEquivalence Eq
+  isEquivalence = record
+    { refl  = refl
+    ; sym   = sym
+    ; trans = trans
+    }
+
+  setoid : Setoid (ℓˢ ⊔ ℓᵖ ⊔ ℓᶜ) (ℓˢ ⊔ ℓᵖ ⊔ ℓᵉ)
+  setoid = record
+    { isEquivalence = isEquivalence
+    }
diff --git a/src/Data/Container/Indexed/Relation/Binary/Pointwise.agda b/src/Data/Container/Indexed/Relation/Binary/Pointwise.agda
new file mode 100644
index 0000000000..4afafefbb9
--- /dev/null
+++ b/src/Data/Container/Indexed/Relation/Binary/Pointwise.agda
@@ -0,0 +1,58 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Pointwise equality for indexed containers
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Container.Indexed.Relation.Binary.Pointwise where
+
+open import Data.Product.Base using (_,_; Σ-syntax)
+open import Function.Base using (_∘_)
+open import Level using (Level; _⊔_)
+open import Relation.Binary using (REL; _⇒_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
+
+open import Data.Container.Indexed.Core using (Container; Subtrees; ⟦_⟧)
+
+private variable
+  ℓᵉ ℓᵉ′ ℓᵖ ℓˢ ℓˣ ℓʸ : Level
+  I O : Set _
+
+------------------------------------------------------------------------
+-- Equality, parametrised on an underlying relation.
+
+-- Since ⟦_⟧ is a Σ-type, not a record, I'd say Pointwise should also be
+-- a Σ-type, not a record. Maybe we need to update module
+-- `Data.Container.Relation.Binary.Pointwise` accordingly...
+--
+-- record Pointwise  : Set (ℓˢ ⊔ ℓᵖ ⊔ ℓᵉ) where
+--   constructor _,_
+--   field shape    : c ≡ c'
+--         position : Eqs shape xs ys
+
+module _ (C : Container I O ℓˢ ℓᵖ)
+         {X : I → Set ℓˣ} {Y : I → Set ℓʸ} (R : (i : I) → REL (X i) (Y i) ℓᵉ)
+         (o : O)
+         ((c  , xs) : ⟦ C ⟧ X o)
+         ((c' , ys) : ⟦ C ⟧ Y o)
+  where
+  open Container C
+
+  Eqs : c ≡ c' → Subtrees C X o c → Subtrees C Y o c' → Set _
+  Eqs refl xs ys = (r : Response c) → R (next c r) (xs r) (ys r)
+
+  Pointwise = Σ[ eq ∈ c ≡ c' ] Eqs eq xs ys
+
+------------------------------------------------------------------------
+-- Operations
+
+module _ {C : Container I O ℓˢ ℓᵖ}
+         {X : I → Set ℓˣ} {Y : I → Set ℓʸ}
+         {R  : (i : I) → REL (X i) (Y i) ℓᵉ}
+         {R′ : (i : I) → REL (X i) (Y i) ℓᵉ′}
+         where
+
+  map : (R⇒R′ : ∀ i → R i ⇒ R′ i) {o : O} → Pointwise C R o ⇒ Pointwise C R′ o
+  map R⇒R′ (refl , f) = refl , R⇒R′ _ ∘ f
diff --git a/src/Data/Container/Indexed/Relation/Binary/Pointwise/Properties.agda b/src/Data/Container/Indexed/Relation/Binary/Pointwise/Properties.agda
new file mode 100644
index 0000000000..eecd3af3d3
--- /dev/null
+++ b/src/Data/Container/Indexed/Relation/Binary/Pointwise/Properties.agda
@@ -0,0 +1,47 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Properties of pointwise equality for indexed containers
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Container.Indexed.Relation.Binary.Pointwise.Properties where
+
+open import Axiom.Extensionality.Propositional using (Extensionality)
+open import Data.Container.Indexed.Core using (Container; ⟦_⟧)
+open import Data.Container.Indexed.Relation.Binary.Pointwise
+  using (Pointwise)
+open import Data.Product.Base using (_,_; Σ-syntax; -,_)
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Reflexive; Symmetric; Transitive)
+open import Relation.Binary.PropositionalEquality.Core as ≡
+  using (_≡_; subst; cong)
+
+private variable
+  ℓᵉ ℓᵖ ℓˢ ℓˣ : Level
+  I O : Set _
+
+module _
+  (C : Container I O ℓˢ ℓᵖ) {X : I → Set ℓˣ}
+  (R : (i : I) → Rel (X i) ℓᵉ)
+  {o : O}
+  where
+
+  refl : (∀ i → Reflexive (R i)) → Reflexive (Pointwise C R o)
+  refl R-refl = ≡.refl , λ p → R-refl _
+
+  sym : (∀ i → Symmetric (R i)) → Symmetric (Pointwise C R o)
+  sym R-sym (≡.refl , f) = ≡.refl , λ p → R-sym _ (f p)
+
+  trans : (∀ i → Transitive (R i)) → Transitive (Pointwise C R o)
+  trans R-trans (≡.refl , f) (≡.refl , g) = ≡.refl , λ p → R-trans _ (f p) (g p)
+
+-- If propositional equality is extensional, then `Eq _≡_` and `_≡_` coincide.
+Eq⇒≡ : {C : Container I O ℓˢ ℓᵖ} {X : I → Set ℓˣ} {R : (i : I) → Rel (X i) ℓᵉ}
+       {o : O} {xs ys : ⟦ C ⟧ X o} →
+       Extensionality ℓᵖ ℓˣ →
+       Pointwise C (λ (i : I) → _≡_ {A = X i}) o xs ys →
+       xs ≡ ys
+Eq⇒≡ ext (≡.refl , f≈f′) = cong -,_ (ext f≈f′)
diff --git a/src/Data/Container/Indexed/WithK.agda b/src/Data/Container/Indexed/WithK.agda
index 2e1a7b7426..bda5a15e34 100644
--- a/src/Data/Container/Indexed/WithK.agda
+++ b/src/Data/Container/Indexed/WithK.agda
@@ -15,12 +15,13 @@ module Data.Container.Indexed.WithK where
 
 open import Axiom.Extensionality.Heterogeneous using (Extensionality)
 open import Data.Container.Indexed hiding (module PlainMorphism)
-open import Data.Product as Prod hiding (map)
-open import Function renaming (id to ⟨id⟩; _∘_ to _⟨∘⟩_)
+open import Data.Product.Base
+  using (_,_; -,_; _×_; ∃; proj₁; proj₂; Σ-syntax)
+open import Function.Base renaming (id to ⟨id⟩; _∘_ to _⟨∘⟩_)
 open import Level
 open import Relation.Unary using (Pred; _⊆_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; refl)
-open import Relation.Binary.HeterogeneousEquality as H using (_≅_; refl)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_; refl)
+open import Relation.Binary.HeterogeneousEquality as ≅ using (_≅_; refl)
 open import Relation.Binary.Indexed.Heterogeneous
 
 ------------------------------------------------------------------------
@@ -42,7 +43,7 @@ private
          {xs : ⟦ C ⟧ X o₁} {ys : ⟦ C ⟧ X o₂} → Extensionality r ℓ →
          Eq C X X (λ x₁ x₂ → x₁ ≅ x₂) xs ys → xs ≅ ys
   Eq⇒≅ {xs = c , k} {.c , k′} ext (refl , refl , k≈k′) =
-    H.cong (_,_ c) (ext (λ _ → refl) (λ r → k≈k′ r r refl))
+    ≅.cong (_,_ c) (ext (λ _ → refl) (λ r → k≈k′ r r refl))
 
 setoid : ∀ {i o c r s} {I : Set i} {O : Set o} →
          Container I O c r → IndexedSetoid I s _ → IndexedSetoid O _ _
@@ -121,7 +122,7 @@ module PlainMorphism {i o c r} {I : Set i} {O : Set o} where
     module Y = IndexedSetoid Y
 
     lemma : ∀ {i j} (eq : i ≡ j) {x} →
-            P.subst Y.Carrier eq (f x) Y.≈ f (P.subst X eq x)
+            ≡.subst Y.Carrier eq (f x) Y.≈ f (≡.subst X eq x)
     lemma refl = Y.refl
 
   -- In fact, all natural functions of the right type are container
@@ -134,7 +135,7 @@ module PlainMorphism {i o c r} {I : Set i} {O : Set o} where
                      Eq C₂ X.Carrier X.Carrier X._≈_
                        (proj₁ nt X.Carrier xs) (⟪ m ⟫ X.Carrier {o} xs)
   complete {C₁} {C₂} (nt , nat) = m , (λ X xs → nat X
-    (λ { (r , eq) → P.subst (IndexedSetoid.Carrier X) eq (proj₂ xs r) })
+    (λ { (r , eq) → ≡.subst (IndexedSetoid.Carrier X) eq (proj₂ xs r) })
     (proj₁ xs , (λ r → r , refl)))
     where
 
@@ -166,9 +167,9 @@ module PlainMorphism {i o c r} {I : Set i} {O : Set o} where
     module X = IndexedSetoid X
 
     lemma : ∀ {i j k} (eq₁ : i ≡ j) (eq₂ : j ≡ k) {x} →
-      P.subst X.Carrier (P.trans eq₁ eq₂) x
+      ≡.subst X.Carrier (≡.trans eq₁ eq₂) x
       X.≈
-      P.subst X.Carrier eq₂ (P.subst X.Carrier eq₁ x)
+      ≡.subst X.Carrier eq₂ (≡.subst X.Carrier eq₁ x)
     lemma refl refl = X.refl
 
 ------------------------------------------------------------------------
diff --git a/src/Data/Container/Membership.agda b/src/Data/Container/Membership.agda
index 3ace9cdc06..6a04f397e8 100644
--- a/src/Data/Container/Membership.agda
+++ b/src/Data/Container/Membership.agda
@@ -10,10 +10,10 @@ module Data.Container.Membership where
 
 open import Level using (_⊔_)
 open import Relation.Unary using (Pred)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
-open import Data.Container.Core
-open import Data.Container.Relation.Unary.Any
+open import Data.Container.Core using (Container; ⟦_⟧)
+open import Data.Container.Relation.Unary.Any using (◇)
 
 module _ {s p} {C : Container s p} {x} {X : Set x} where
 
diff --git a/src/Data/Container/Morphism.agda b/src/Data/Container/Morphism.agda
index 6494e5a3b8..0e26d48199 100644
--- a/src/Data/Container/Morphism.agda
+++ b/src/Data/Container/Morphism.agda
@@ -9,7 +9,7 @@
 module Data.Container.Morphism where
 
 open import Data.Container.Core
-import Function as F
+import Function.Base as F
 
 module _ {s p} (C : Container s p) where
 
diff --git a/src/Data/Container/Morphism/Properties.agda b/src/Data/Container/Morphism/Properties.agda
index 16b3dd9333..ca2e4e5b55 100644
--- a/src/Data/Container/Morphism/Properties.agda
+++ b/src/Data/Container/Morphism/Properties.agda
@@ -9,10 +9,10 @@
 module Data.Container.Morphism.Properties where
 
 open import Level using (_⊔_; suc)
-open import Function as F using (_$_)
-open import Data.Product using (∃; proj₁; proj₂; _,_)
-open import Relation.Binary using (Setoid)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; _≗_)
+open import Function.Base as F using (_$_)
+open import Data.Product.Base using (∃; proj₁; proj₂; _,_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_; _≗_)
 
 open import Data.Container.Core
 open import Data.Container.Morphism
@@ -23,7 +23,7 @@ open import Data.Container.Relation.Binary.Equality.Setoid
 module _ {s p} (C : Container s p) where
 
   id-correct : ∀ {x} {X : Set x} → ⟪ id C ⟫ {X = X} ≗ F.id
-  id-correct x = P.refl
+  id-correct x = ≡.refl
 
 -- Composition.
 
@@ -33,7 +33,7 @@ module _ {s₁ s₂ s₃ p₁ p₂ p₃}
 
   ∘-correct : (f : C₂ ⇒ C₃) (g : C₁ ⇒ C₂) → ∀ {x} {X : Set x} →
               ⟪ f ∘ g ⟫ {X = X} ≗ (⟪ f ⟫ F.∘ ⟪ g ⟫)
-  ∘-correct f g xs = P.refl
+  ∘-correct f g xs = ≡.refl
 
 module _ {s₁ s₂ p₁ p₂} {C₁ : Container s₁ p₁} {C₂ : Container s₂ p₂} where
 
diff --git a/src/Data/Container/Properties.agda b/src/Data/Container/Properties.agda
index 193f7cf702..720455fefa 100644
--- a/src/Data/Container/Properties.agda
+++ b/src/Data/Container/Properties.agda
@@ -8,8 +8,8 @@
 
 module Data.Container.Properties where
 
-import Function as F
-open import Relation.Binary
+import Function.Base as F
+open import Relation.Binary.Bundles using (Setoid)
 
 open import Data.Container.Core
 open import Data.Container.Relation.Binary.Equality.Setoid
diff --git a/src/Data/Container/Related.agda b/src/Data/Container/Related.agda
index a62603ac49..1fc9dc5665 100644
--- a/src/Data/Container/Related.agda
+++ b/src/Data/Container/Related.agda
@@ -11,17 +11,17 @@ module Data.Container.Related where
 
 open import Level using (_⊔_)
 open import Data.Container.Core
-import Function.Related as Related
-open import Relation.Binary
+import Function.Related.Propositional as Related
+open import Relation.Binary.Bundles using (Preorder; Setoid)
 open import Data.Container.Membership
 
 open Related public
-  using (Kind; Symmetric-kind)
+  using (Kind; SymmetricKind)
   renaming ( implication         to subset
-           ; reverse-implication to superset
+           ; reverseImplication  to superset
            ; equivalence         to set
            ; injection           to subbag
-           ; reverse-injection   to superbag
+           ; reverseInjection    to superbag
            ; bijection           to bag
            )
 
@@ -29,11 +29,27 @@ open Related public
             Preorder (s ⊔ p ⊔ ℓ) (s ⊔ p ⊔ ℓ) (p ⊔ ℓ)
 [ k ]-Order C X = Related.InducedPreorder₂ k (_∈_ {C = C} {X = X})
 
-[_]-Equality : ∀ {s p ℓ} → Symmetric-kind → Container s p → Set ℓ →
+[_]-Equality : ∀ {s p ℓ} → SymmetricKind → Container s p → Set ℓ →
                Setoid (s ⊔ p ⊔ ℓ) (p ⊔ ℓ)
 [ k ]-Equality C X = Related.InducedEquivalence₂ k (_∈_ {C = C} {X = X})
 
-infix 4 _∼[_]_
-_∼[_]_ : ∀ {s p x} {C : Container s p} {X : Set x} →
+infix 4 _≲[_]_
+_≲[_]_ : ∀ {s p x} {C : Container s p} {X : Set x} →
          ⟦ C ⟧ X → Kind → ⟦ C ⟧ X → Set (p ⊔ x)
-_∼[_]_ {C = C} {X} xs k ys = Preorder._∼_ ([ k ]-Order C X) xs ys
+_≲[_]_ {C = C} {X} xs k ys = Preorder._≲_ ([ k ]-Order C X) xs ys
+
+
+
+------------------------------------------------------------------------
+-- DEPRECATED
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
+
+infix 4 _∼[_]_
+_∼[_]_ = _≲[_]_
+{-# WARNING_ON_USAGE _∼[_]_
+"Warning: _∼[_]_ was deprecated in v2.0. Please use _≲[_]_ instead. "
+#-}
diff --git a/src/Data/Container/Relation/Binary/Equality/Setoid.agda b/src/Data/Container/Relation/Binary/Equality/Setoid.agda
index f970218f10..c530413939 100644
--- a/src/Data/Container/Relation/Binary/Equality/Setoid.agda
+++ b/src/Data/Container/Relation/Binary/Equality/Setoid.agda
@@ -6,12 +6,15 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Setoid)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.Container.Relation.Binary.Equality.Setoid {c e} (S : Setoid c e) where
 
 open import Level using (_⊔_; suc)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
 
 open import Data.Container.Core
 open import Data.Container.Relation.Binary.Pointwise
diff --git a/src/Data/Container/Relation/Binary/Pointwise.agda b/src/Data/Container/Relation/Binary/Pointwise.agda
index 8a022a072c..0e2df66f78 100644
--- a/src/Data/Container/Relation/Binary/Pointwise.agda
+++ b/src/Data/Container/Relation/Binary/Pointwise.agda
@@ -8,12 +8,11 @@
 
 module Data.Container.Relation.Binary.Pointwise where
 
-open import Data.Product using (_,_; Σ-syntax; -,_; proj₁; proj₂)
-open import Function
+open import Data.Product.Base using (_,_; Σ-syntax; -,_; proj₁; proj₂)
+open import Function.Base using (_∘_)
 open import Level using (_⊔_)
-open import Relation.Binary using (REL; _⇒_)
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; subst; cong)
+open import Relation.Binary.Core using (REL; _⇒_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; subst)
 
 open import Data.Container.Core using (Container; ⟦_⟧)
 
@@ -26,6 +25,7 @@ module _ {s p} (C : Container s p) where
     constructor _,_
     field shape    : proj₁ cx ≡ proj₁ cy
           position : ∀ p → R (proj₂ cx p) (proj₂ cy (subst _ shape p))
+  infixr 4 _,_
 
 module _ {s p} {C : Container s p} {x y} {X : Set x} {Y : Set y}
          {ℓ ℓ′} {R : REL X Y ℓ} {R′ : REL X Y ℓ′}
diff --git a/src/Data/Container/Relation/Binary/Pointwise/Properties.agda b/src/Data/Container/Relation/Binary/Pointwise/Properties.agda
index 24e48a74a3..9bdf815092 100644
--- a/src/Data/Container/Relation/Binary/Pointwise/Properties.agda
+++ b/src/Data/Container/Relation/Binary/Pointwise/Properties.agda
@@ -8,25 +8,29 @@
 
 module Data.Container.Relation.Binary.Pointwise.Properties where
 
-open import Axiom.Extensionality.Propositional
-open import Data.Container.Core
+open import Axiom.Extensionality.Propositional using (Extensionality)
+open import Data.Container.Core using (Container; ⟦_⟧)
 open import Data.Container.Relation.Binary.Pointwise
-open import Data.Product using (_,_; Σ-syntax; -,_)
+  using (Pointwise; _,_)
+open import Data.Product.Base using (_,_; Σ-syntax; -,_)
 open import Level using (_⊔_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; subst; cong)
 
 module _ {s p x r} {X : Set x} (C : Container s p) (R : Rel X r) where
 
   refl : Reflexive R → Reflexive (Pointwise C R)
-  refl R-refl = P.refl , λ p → R-refl
+  refl R-refl = ≡.refl , λ p → R-refl
 
   sym : Symmetric R → Symmetric (Pointwise C R)
-  sym R-sym (P.refl , f) = P.refl , λ p → R-sym (f p)
+  sym R-sym (≡.refl , f) = ≡.refl , λ p → R-sym (f p)
 
   trans : Transitive R → Transitive (Pointwise C R)
-  trans R-trans (P.refl , f) (P.refl , g) = P.refl , λ p → R-trans (f p) (g p)
+  trans R-trans (≡.refl , f) (≡.refl , g) = ≡.refl , λ p → R-trans (f p) (g p)
 
 private
 
@@ -35,4 +39,4 @@ private
 
   Eq⇒≡ : ∀ {s p x} {C : Container s p} {X : Set x} {xs ys : ⟦ C ⟧ X} →
          Extensionality p x → Pointwise C _≡_ xs ys → xs ≡ ys
-  Eq⇒≡ ext (P.refl , f≈f′) = cong -,_ (ext f≈f′)
+  Eq⇒≡ ext (≡.refl , f≈f′) = cong -,_ (ext f≈f′)
diff --git a/src/Data/Container/Relation/Unary/All.agda b/src/Data/Container/Relation/Unary/All.agda
index 2a6f858c87..829bd3a0c9 100644
--- a/src/Data/Container/Relation/Unary/All.agda
+++ b/src/Data/Container/Relation/Unary/All.agda
@@ -10,8 +10,8 @@ module Data.Container.Relation.Unary.All where
 
 open import Level using (_⊔_)
 open import Relation.Unary using (Pred; _⊆_)
-open import Data.Product as Prod using (_,_; proj₁; proj₂; ∃)
-open import Function as F
+open import Data.Product.Base using (_,_; proj₁; proj₂; ∃)
+open import Function.Base using (_∘′_; id)
 
 open import Data.Container.Core hiding (map)
 import Data.Container.Morphism as M
diff --git a/src/Data/Container/Relation/Unary/Any.agda b/src/Data/Container/Relation/Unary/Any.agda
index 944734af3d..121391f4d6 100644
--- a/src/Data/Container/Relation/Unary/Any.agda
+++ b/src/Data/Container/Relation/Unary/Any.agda
@@ -10,8 +10,8 @@ module Data.Container.Relation.Unary.Any where
 
 open import Level using (_⊔_)
 open import Relation.Unary using (Pred; _⊆_)
-open import Data.Product as Prod using (_,_; proj₂; ∃)
-open import Function
+open import Data.Product.Base using (_,_; proj₂; ∃)
+open import Function.Base using (_∘′_; id)
 
 open import Data.Container.Core hiding (map)
 import Data.Container.Morphism as M
diff --git a/src/Data/Container/Relation/Unary/Any/Properties.agda b/src/Data/Container/Relation/Unary/Any/Properties.agda
index e0398eff8f..6e643a6031 100644
--- a/src/Data/Container/Relation/Unary/Any/Properties.agda
+++ b/src/Data/Container/Relation/Unary/Any/Properties.agda
@@ -8,25 +8,26 @@
 
 module Data.Container.Relation.Unary.Any.Properties where
 
-open import Level
-open import Algebra
-open import Data.Product as Prod using (∃; _×_; ∃₂; _,_; proj₂)
+open import Algebra.Bundles using (CommutativeSemiring)
+open import Data.Product.Base using (∃; _×_; ∃₂; _,_; proj₂)
+open import Data.Product.Properties using (Σ-≡,≡→≡)
 open import Data.Product.Function.NonDependent.Propositional using (_×-cong_)
 import Data.Product.Function.Dependent.Propositional as Σ
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_])
-open import Function.Base
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Equivalence using (equivalence)
-open import Function.HalfAdjointEquivalence using (_≃_; ↔→≃)
-open import Function.Inverse as Inv using (_↔_; inverse; module Inverse)
-open import Function.Related as Related using (Related; SK-sym)
+open import Function.Base using (_∘_; _∘′_; id; flip; _$_)
+open import Function.Bundles using (_↔_; mk↔ₛ′; Inverse)
+open import Function.Properties.Inverse using (↔-refl)
+open import Function.Properties.Inverse.HalfAdjointEquivalence using (_≃_; ↔⇒≃)
+open import Function.Related.Propositional as Related using (Related; SK-sym)
 open import Function.Related.TypeIsomorphisms
+  using (×-⊎-commutativeSemiring; ∃∃↔∃∃; Σ-assoc; ×-comm)
+open import Level using (Level; _⊔_)
 open import Relation.Unary using (Pred ; _∪_ ; _∩_)
-open import Relation.Binary using (REL)
-open import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; _≗_; refl)
+open import Relation.Binary.PropositionalEquality.Properties as ≡
 
-open Related.EquationalReasoning hiding (_≡⟨_⟩_)
 private
   module ×⊎ {k ℓ} = CommutativeSemiring (×-⊎-commutativeSemiring k ℓ)
 
@@ -43,34 +44,35 @@ module _ {s p} (C : Container s p) {x} {X : Set x} {ℓ} {P : Pred X ℓ} where
 -- ◇ can be unwrapped to reveal the Σ type
 
   ↔Σ : ∀ {xs : ⟦ C ⟧ X} → ◇ C P xs ↔ ∃ λ p → P (proj₂ xs p)
-  ↔Σ {xs} = inverse ◇.proof any (λ _ → P.refl) (λ _ → P.refl)
+  ↔Σ {xs} = mk↔ₛ′ ◇.proof any (λ _ → refl) (λ _ → refl)
 
 -- ◇ can be expressed using _∈_.
 
   ↔∈ : ∀ {xs : ⟦ C ⟧ X} → ◇ C P xs ↔ (∃ λ x → x ∈ xs × P x)
-  ↔∈ {xs} = inverse to from (λ _ → P.refl) (to∘from) where
+  ↔∈ {xs} = mk↔ₛ′ to from to∘from (λ _ → refl) where
 
     to : ◇ C P xs → ∃ λ x → x ∈ xs × P x
-    to (any (p , Px)) = (proj₂ xs p , (any (p , P.refl)) , Px)
+    to (any (p , Px)) = (proj₂ xs p , (any (p , refl)) , Px)
 
     from : (∃ λ x → x ∈ xs × P x) → ◇ C P xs
     from (.(proj₂ xs p) , (any (p , refl)) , Px) = any (p , Px)
 
     to∘from : to ∘ from ≗ id
-    to∘from (.(proj₂ xs p) , any (p , refl) , Px) = P.refl
+    to∘from (.(proj₂ xs p) , any (p , refl) , Px) = refl
 
 module _ {s p} {C : Container s p} {x} {X : Set x}
          {ℓ₁ ℓ₂} {P₁ : Pred X ℓ₁} {P₂ : Pred X ℓ₂} where
 -- ◇ is a congruence for bag and set equality and related preorders.
 
   cong : ∀ {k} {xs₁ xs₂ : ⟦ C ⟧ X} →
-         (∀ x → Related k (P₁ x) (P₂ x)) → xs₁ ∼[ k ] xs₂ →
+         (∀ x → Related k (P₁ x) (P₂ x)) → xs₁ ≲[ k ] xs₂ →
          Related k (◇ C P₁ xs₁) (◇ C P₂ xs₂)
   cong {k} {xs₁} {xs₂} P₁↔P₂ xs₁≈xs₂ =
     ◇ C P₁ xs₁               ↔⟨ ↔∈ C ⟩
-    (∃ λ x → x ∈ xs₁ × P₁ x) ∼⟨ Σ.cong Inv.id (xs₁≈xs₂ ×-cong P₁↔P₂ _) ⟩
+    (∃ λ x → x ∈ xs₁ × P₁ x) ∼⟨ Σ.cong ↔-refl (xs₁≈xs₂ ×-cong P₁↔P₂ _) ⟩
     (∃ λ x → x ∈ xs₂ × P₂ x) ↔⟨ SK-sym (↔∈ C) ⟩
     ◇ C P₂ xs₂               ∎
+    where open Related.EquationalReasoning
 
 -- Nested occurrences of ◇ can sometimes be swapped.
 
@@ -83,18 +85,19 @@ module _ {s₁ s₂ p₁ p₂} {C₁ : Container s₁ p₁} {C₂ : Container s
          ◈ xs (◈ ys ∘ P) ↔ ◈ ys (◈ xs ∘ flip P)
   swap {xs} {ys} =
     ◇ _ (λ x → ◇ _ (P x) ys) xs                ↔⟨ ↔∈ C₁ ⟩
-    (∃ λ x → x ∈ xs × ◇ _ (P x) ys)            ↔⟨ Σ.cong Inv.id $ Σ.cong Inv.id $ ↔∈ C₂ ⟩
-    (∃ λ x → x ∈ xs × ∃ λ y → y ∈ ys × P x y)  ↔⟨ Σ.cong Inv.id (λ {x} → ∃∃↔∃∃ (λ _ y → y ∈ ys × P x y)) ⟩
+    (∃ λ x → x ∈ xs × ◇ _ (P x) ys)            ↔⟨ Σ.cong ↔-refl $ Σ.cong ↔-refl $ ↔∈ C₂ ⟩
+    (∃ λ x → x ∈ xs × ∃ λ y → y ∈ ys × P x y)  ↔⟨ Σ.cong ↔-refl (λ {x} → ∃∃↔∃∃ (λ _ y → y ∈ ys × P x y)) ⟩
     (∃₂ λ x y → x ∈ xs × y ∈ ys × P x y)       ↔⟨ ∃∃↔∃∃ (λ x y → x ∈ xs × y ∈ ys × P x y) ⟩
-    (∃₂ λ y x → x ∈ xs × y ∈ ys × P x y)       ↔⟨ Σ.cong Inv.id (λ {y} → Σ.cong Inv.id (λ {x} →
+    (∃₂ λ y x → x ∈ xs × y ∈ ys × P x y)       ↔⟨ Σ.cong ↔-refl (λ {y} → Σ.cong ↔-refl (λ {x} →
       (x ∈ xs × y ∈ ys × P x y)                     ↔⟨ SK-sym Σ-assoc ⟩
-      ((x ∈ xs × y ∈ ys) × P x y)                   ↔⟨ Σ.cong (×-comm _ _) Inv.id ⟩
+      ((x ∈ xs × y ∈ ys) × P x y)                   ↔⟨ Σ.cong (×-comm _ _) ↔-refl ⟩
       ((y ∈ ys × x ∈ xs) × P x y)                   ↔⟨ Σ-assoc ⟩
       (y ∈ ys × x ∈ xs × P x y)                     ∎)) ⟩
-    (∃₂ λ y x → y ∈ ys × x ∈ xs × P x y)       ↔⟨ Σ.cong Inv.id (λ {y} → ∃∃↔∃∃ {B = y ∈ ys} (λ x _ → x ∈ xs × P x y)) ⟩
-    (∃ λ y → y ∈ ys × ∃ λ x → x ∈ xs × P x y)  ↔⟨ Σ.cong Inv.id (Σ.cong Inv.id (SK-sym (↔∈ C₁))) ⟩
+    (∃₂ λ y x → y ∈ ys × x ∈ xs × P x y)       ↔⟨ Σ.cong ↔-refl (λ {y} → ∃∃↔∃∃ {B = y ∈ ys} (λ x _ → x ∈ xs × P x y)) ⟩
+    (∃ λ y → y ∈ ys × ∃ λ x → x ∈ xs × P x y)  ↔⟨ Σ.cong ↔-refl (Σ.cong ↔-refl (SK-sym (↔∈ C₁))) ⟩
     (∃ λ y → y ∈ ys × ◇ _ (flip P y) xs)       ↔⟨ SK-sym (↔∈ C₂) ⟩
     ◇ _ (λ y → ◇ _ (flip P y) xs) ys           ∎
+    where open Related.EquationalReasoning
 
 -- Nested occurrences of ◇ can sometimes be flattened.
 
@@ -103,16 +106,16 @@ module _ {s₁ s₂ p₁ p₂} {C₁ : Container s₁ p₁} {C₂ : Container s
 
   flatten : ∀ (xss : ⟦ C₁ ⟧ (⟦ C₂ ⟧ X)) →
             ◇ C₁ (◇ C₂ P) xss ↔
-            ◇ (C₁ C.∘ C₂) P (Inverse.from (Composition.correct C₁ C₂) ⟨$⟩ xss)
-  flatten xss = inverse t f (λ _ → P.refl) (λ _ → P.refl) where
+            ◇ (C₁ C.∘ C₂) P (Inverse.from (Composition.correct C₁ C₂) xss)
+  flatten xss = mk↔ₛ′ t f (λ _ → refl) (λ _ → refl) where
 
     ◇₁ = ◇ C₁; ◇₂ = ◇ C₂; ◇₁₂ = ◇ (C₁ C.∘ C₂)
     open Inverse
 
-    t : ◇₁ (◇₂ P) xss → ◇₁₂ P (from (Composition.correct C₁ C₂) ⟨$⟩ xss)
+    t : ◇₁ (◇₂ P) xss → ◇₁₂ P (from (Composition.correct C₁ C₂) xss)
     t (any (p₁ , (any (p₂ , p)))) = any (any (p₁ , p₂) , p)
 
-    f : ◇₁₂ P (from (Composition.correct C₁ C₂) ⟨$⟩ xss) → ◇₁ (◇₂ P) xss
+    f : ◇₁₂ P (from (Composition.correct C₁ C₂) xss) → ◇₁ (◇₂ P) xss
     f (any (any (p₁ , p₂) , p)) = any (p₁ , any (p₂ , p))
 
 -- Sums commute with ◇ (for a fixed instance of a given container).
@@ -121,7 +124,7 @@ module _ {s p} {C : Container s p} {x} {X : Set x}
          {ℓ ℓ′} {P : Pred X ℓ} {Q : Pred X ℓ′} where
 
   ◇⊎↔⊎◇ : ∀ {xs : ⟦ C ⟧ X} → ◇ C (P ∪ Q) xs ↔ (◇ C P xs ⊎ ◇ C Q xs)
-  ◇⊎↔⊎◇ {xs} = inverse to from from∘to to∘from
+  ◇⊎↔⊎◇ {xs} = mk↔ₛ′ to from to∘from from∘to
     where
     to : ◇ C (λ x → P x ⊎ Q x) xs → ◇ C P xs ⊎ ◇ C Q xs
     to (any (pos , inj₁ p)) = inj₁ (any (pos , p))
@@ -131,11 +134,11 @@ module _ {s p} {C : Container s p} {x} {X : Set x}
     from = [ Any.map₂ inj₁ , Any.map₂ inj₂ ]
 
     from∘to : from ∘ to ≗ id
-    from∘to (any (pos , inj₁ p)) = P.refl
-    from∘to (any (pos , inj₂ q)) = P.refl
+    from∘to (any (pos , inj₁ p)) = refl
+    from∘to (any (pos , inj₂ q)) = refl
 
     to∘from : to ∘ from ≗ id
-    to∘from = [ (λ _ → P.refl) , (λ _ → P.refl) ]
+    to∘from = [ (λ _ → refl) , (λ _ → refl) ]
 
 -- Products "commute" with ◇.
 
@@ -144,7 +147,7 @@ module _ {s₁ s₂ p₁ p₂} {C₁ : Container s₁ p₁} {C₂ : Container s
 
   ×◇↔◇◇× : ∀ {xs : ⟦ C₁ ⟧ X} {ys : ⟦ C₂ ⟧ Y} →
            ◇ C₁ (λ x → ◇ C₂ (λ y → P x × Q y) ys) xs ↔ (◇ C₁ P xs × ◇ C₂ Q ys)
-  ×◇↔◇◇× {xs} {ys} = inverse to from (λ _ → P.refl) (λ _ → P.refl)
+  ×◇↔◇◇× {xs} {ys} = mk↔ₛ′ to from (λ _ → refl) (λ _ → refl)
     where
     ◇₁ = ◇ C₁; ◇₂ = ◇ C₂
 
@@ -162,9 +165,10 @@ module _ {s p} (C : Container s p) {x y} {X : Set x} {Y : Set y}
   map↔∘ : ∀ {xs : ⟦ C ⟧ X} (f : X → Y) → ◇ C P (map f xs) ↔ ◇ C (P ∘′ f) xs
   map↔∘ {xs} f =
    ◇ C P (map f xs)          ↔⟨ ↔Σ C ⟩
-   ∃ (P ∘′ proj₂ (map f xs)) ↔⟨⟩
+   ∃ (P ∘′ proj₂ (map f xs)) ≡⟨⟩
    ∃ (P ∘′ f ∘′ proj₂ xs)    ↔⟨ SK-sym (↔Σ C) ⟩
    ◇ C (P ∘′ f) xs           ∎
+   where open Related.EquationalReasoning
 
 -- Membership in a mapped container can be expressed without reference
 -- to map.
@@ -178,6 +182,7 @@ module _ {s p} (C : Container s p) {x y} {X : Set x} {Y : Set y}
     y ∈ map f xs               ↔⟨ map↔∘ C (y ≡_) f ⟩
     ◇ C (λ x → y ≡ f x) xs     ↔⟨ ↔∈ C ⟩
     ∃ (λ x → x ∈ xs × y ≡ f x) ∎
+    where open Related.EquationalReasoning
 
 -- map is a congruence for bag and set equality and related preorders.
 
@@ -185,16 +190,17 @@ module _ {s p} (C : Container s p) {x y} {X : Set x} {Y : Set y}
          {ℓ} (P : Pred Y ℓ) where
 
   map-cong : ∀ {k} {f₁ f₂ : X → Y} {xs₁ xs₂ : ⟦ C ⟧ X} →
-             f₁ ≗ f₂ → xs₁ ∼[ k ] xs₂ →
-             map f₁ xs₁ ∼[ k ] map f₂ xs₂
+             f₁ ≗ f₂ → xs₁ ≲[ k ] xs₂ →
+             map f₁ xs₁ ≲[ k ] map f₂ xs₂
   map-cong {f₁ = f₁} {f₂} {xs₁} {xs₂} f₁≗f₂ xs₁≈xs₂ {x} =
     x ∈ map f₁ xs₁           ↔⟨ map↔∘ C (_≡_ x) f₁ ⟩
     ◇ C (λ y → x ≡ f₁ y) xs₁ ∼⟨ cong (Related.↔⇒ ∘ helper) xs₁≈xs₂ ⟩
     ◇ C (λ y → x ≡ f₂ y) xs₂ ↔⟨ SK-sym (map↔∘ C (_≡_ x) f₂) ⟩
     x ∈ map f₂ xs₂           ∎
     where
+    open Related.EquationalReasoning
     helper : ∀ y → (x ≡ f₁ y) ↔ (x ≡ f₂ y)
-    helper y rewrite f₁≗f₂ y = Inv.id
+    helper y rewrite f₁≗f₂ y = ↔-refl
 
 -- Uses of linear morphisms can be removed.
 
@@ -202,13 +208,13 @@ module _ {s₁ s₂ p₁ p₂} {C₁ : Container s₁ p₁} {C₂ : Container s
          {x} {X : Set x} {ℓ} (P : Pred X ℓ) where
 
   remove-linear : ∀ {xs : ⟦ C₁ ⟧ X} (m : C₁ ⊸ C₂) → ◇ C₂ P (⟪ m ⟫⊸ xs) ↔ ◇ C₁ P xs
-  remove-linear {xs} m = Inv.inverse t f f∘t t∘f
+  remove-linear {xs} m = mk↔ₛ′ t f t∘f f∘t
     where
     open _≃_
-    open P.≡-Reasoning renaming (_∎ to _∎′)
+    open ≡.≡-Reasoning
 
     position⊸m : ∀ {s} → Position C₂ (shape⊸ m s) ≃ Position C₁ s
-    position⊸m = ↔→≃ (position⊸ m)
+    position⊸m = ↔⇒≃ (position⊸ m)
 
     ◇₁ = ◇ C₁; ◇₂ = ◇ C₂
 
@@ -218,78 +224,79 @@ module _ {s₁ s₂ p₁ p₂} {C₁ : Container s₁ p₁} {C₂ : Container s
     f : ◇₁ P xs → ◇₂ P (⟪ m ⟫⊸ xs)
     f (any (x , p)) =
       any $ from position⊸m x
-          , P.subst (P ∘′ proj₂ xs) (P.sym (right-inverse-of position⊸m _)) p
+          , ≡.subst (P ∘′ proj₂ xs) (≡.sym (right-inverse-of position⊸m _)) p
 
     f∘t : f ∘ t ≗ id
-    f∘t (any (p₂ , p)) = P.cong any $ Σ-≡,≡→≡
+    f∘t (any (p₂ , p)) = ≡.cong any $ Σ-≡,≡→≡
       ( left-inverse-of position⊸m p₂
-      , (P.subst (P ∘ proj₂ xs ∘ to position⊸m)
+      , (≡.subst (P ∘ proj₂ xs ∘ to position⊸m)
            (left-inverse-of position⊸m p₂)
-           (P.subst (P ∘ proj₂ xs)
-              (P.sym (right-inverse-of position⊸m
+           (≡.subst (P ∘ proj₂ xs)
+              (≡.sym (right-inverse-of position⊸m
                         (to position⊸m p₂)))
-              p)                                                ≡⟨ P.subst-∘ (left-inverse-of position⊸m _) ⟩
+              p)                                                ≡⟨ ≡.subst-∘ (left-inverse-of position⊸m _) ⟩
 
-         P.subst (P ∘ proj₂ xs)
-           (P.cong (to position⊸m)
+         ≡.subst (P ∘ proj₂ xs)
+           (≡.cong (to position⊸m)
               (left-inverse-of position⊸m p₂))
-           (P.subst (P ∘ proj₂ xs)
-              (P.sym (right-inverse-of position⊸m
+           (≡.subst (P ∘ proj₂ xs)
+              (≡.sym (right-inverse-of position⊸m
                         (to position⊸m p₂)))
-              p)                                                ≡⟨ P.cong (λ eq → P.subst (P ∘ proj₂ xs) eq
-                                                                                    (P.subst (P ∘ proj₂ xs)
-                                                                                       (P.sym (right-inverse-of position⊸m _)) _))
+              p)                                                ≡⟨ ≡.cong (λ eq → ≡.subst (P ∘ proj₂ xs) eq
+                                                                                    (≡.subst (P ∘ proj₂ xs)
+                                                                                       (≡.sym (right-inverse-of position⊸m _)) _))
                                                                      (_≃_.left-right position⊸m _) ⟩
-         P.subst (P ∘ proj₂ xs)
+         ≡.subst (P ∘ proj₂ xs)
            (right-inverse-of position⊸m
               (to position⊸m p₂))
-           (P.subst (P ∘ proj₂ xs)
-              (P.sym (right-inverse-of position⊸m
+           (≡.subst (P ∘ proj₂ xs)
+              (≡.sym (right-inverse-of position⊸m
                         (to position⊸m p₂)))
-              p)                                                ≡⟨ P.subst-subst (P.sym (right-inverse-of position⊸m _)) ⟩
+              p)                                                ≡⟨ ≡.subst-subst (≡.sym (right-inverse-of position⊸m _)) ⟩
 
-         P.subst (P ∘ proj₂ xs)
-           (P.trans
-              (P.sym (right-inverse-of position⊸m
+         ≡.subst (P ∘ proj₂ xs)
+           (≡.trans
+              (≡.sym (right-inverse-of position⊸m
                         (to position⊸m p₂)))
               (right-inverse-of position⊸m
                  (to position⊸m p₂)))
-           p                                                    ≡⟨ P.cong (λ eq → P.subst (P ∘ proj₂ xs) eq p)
-                                                                     (P.trans-symˡ (right-inverse-of position⊸m _)) ⟩
+           p                                                    ≡⟨ ≡.cong (λ eq → ≡.subst (P ∘ proj₂ xs) eq p)
+                                                                     (≡.trans-symˡ (right-inverse-of position⊸m _)) ⟩
 
-         P.subst (P ∘ proj₂ xs) P.refl p                        ≡⟨⟩
+         ≡.subst (P ∘ proj₂ xs) ≡.refl p                        ≡⟨⟩
 
-        p                                                       ∎′)
+        p                                                       ∎)
       )
 
     t∘f : t ∘ f ≗ id
-    t∘f (any (p₁ , p)) = P.cong any $ Σ-≡,≡→≡
+    t∘f (any (p₁ , p)) = ≡.cong any $ Σ-≡,≡→≡
       ( right-inverse-of position⊸m p₁
-      , (P.subst (P ∘ proj₂ xs)
+      , (≡.subst (P ∘ proj₂ xs)
            (right-inverse-of position⊸m p₁)
-           (P.subst (P ∘ proj₂ xs)
-              (P.sym (right-inverse-of position⊸m p₁))
-              p)                                                ≡⟨ P.subst-subst (P.sym (right-inverse-of position⊸m _)) ⟩
+           (≡.subst (P ∘ proj₂ xs)
+              (≡.sym (right-inverse-of position⊸m p₁))
+              p)                                                ≡⟨ ≡.subst-subst (≡.sym (right-inverse-of position⊸m _)) ⟩
 
-         P.subst (P ∘ proj₂ xs)
-           (P.trans
-              (P.sym (right-inverse-of position⊸m p₁))
+         ≡.subst (P ∘ proj₂ xs)
+           (≡.trans
+              (≡.sym (right-inverse-of position⊸m p₁))
               (right-inverse-of position⊸m p₁))
-           p                                                    ≡⟨ P.cong (λ eq → P.subst (P ∘ proj₂ xs) eq p)
-                                                                     (P.trans-symˡ (right-inverse-of position⊸m _)) ⟩
-         P.subst (P ∘ proj₂ xs) P.refl p                        ≡⟨⟩
+           p                                                    ≡⟨ ≡.cong (λ eq → ≡.subst (P ∘ proj₂ xs) eq p)
+                                                                     (≡.trans-symˡ (right-inverse-of position⊸m _)) ⟩
+         ≡.subst (P ∘ proj₂ xs) ≡.refl p                        ≡⟨⟩
 
-        p                                                       ∎′)
+        p                                                       ∎)
       )
 
 -- Linear endomorphisms are identity functions if bag equality is used.
 
 module _ {s p} {C : Container s p} {x} {X : Set x} where
 
-  linear-identity : ∀ {xs : ⟦ C ⟧ X} (m : C ⊸ C) → ⟪ m ⟫⊸ xs ∼[ bag ] xs
+  linear-identity : ∀ {xs : ⟦ C ⟧ X} (m : C ⊸ C) → ⟪ m ⟫⊸ xs ≲[ bag ] xs
   linear-identity {xs} m {x} =
     x ∈ ⟪ m ⟫⊸ xs  ↔⟨ remove-linear (_≡_ x) m ⟩
     x ∈        xs  ∎
+    where open Related.EquationalReasoning
 
 -- If join can be expressed using a linear morphism (in a certain
 -- way), then it can be absorbed by the predicate.
@@ -301,10 +308,12 @@ module _ {s₁ s₂ s₃ p₁ p₂ p₃}
   join↔◇ : (join′ : (C₁ C.∘ C₂) ⊸ C₃) (xss : ⟦ C₁ ⟧ (⟦ C₂ ⟧ X)) →
            let join : ∀ {X} → ⟦ C₁ ⟧ (⟦ C₂ ⟧ X) → ⟦ C₃ ⟧ X
                join = λ {_} → ⟪ join′ ⟫⊸ ∘
-                      _⟨$⟩_ (Inverse.from (Composition.correct C₁ C₂)) in
+                      (Inverse.from (Composition.correct C₁ C₂)) in
            ◇ C₃ P (join xss) ↔ ◇ C₁ (◇ C₂ P) xss
   join↔◇ join xss =
     ◇ C₃ P (⟪ join ⟫⊸ xss′) ↔⟨ remove-linear P join ⟩
     ◇ (C₁ C.∘ C₂) P xss′    ↔⟨ SK-sym $ flatten P xss ⟩
     ◇ C₁ (◇ C₂ P) xss       ∎
-    where xss′ = Inverse.from (Composition.correct C₁ C₂) ⟨$⟩ xss
+    where
+    open Related.EquationalReasoning
+    xss′ = Inverse.from (Composition.correct C₁ C₂) xss
diff --git a/src/Data/DifferenceList.agda b/src/Data/DifferenceList.agda
index dc62baf000..3227e6ed8e 100644
--- a/src/Data/DifferenceList.agda
+++ b/src/Data/DifferenceList.agda
@@ -10,7 +10,7 @@ module Data.DifferenceList where
 
 open import Level using (Level)
 open import Data.List.Base as List using (List)
-open import Function
+open import Function.Base using (_⟨_⟩_)
 open import Data.Nat.Base
 
 private
diff --git a/src/Data/DifferenceNat.agda b/src/Data/DifferenceNat.agda
index 0d6c024e51..5e23cc5030 100644
--- a/src/Data/DifferenceNat.agda
+++ b/src/Data/DifferenceNat.agda
@@ -9,8 +9,8 @@
 
 module Data.DifferenceNat where
 
-open import Data.Nat.Base as N using (ℕ)
-open import Function
+open import Data.Nat.Base as ℕ using (ℕ)
+open import Function.Base using (_⟨_⟩_)
 
 infixl 6 _+_
 
@@ -21,7 +21,7 @@ Diffℕ = ℕ → ℕ
 0# = λ k → k
 
 suc : Diffℕ → Diffℕ
-suc n = λ k → N.suc (n k)
+suc n = λ k → ℕ.suc (n k)
 
 1# : Diffℕ
 1# = suc 0#
@@ -35,4 +35,4 @@ toℕ n = n 0
 -- fromℕ n is linear in the size of n.
 
 fromℕ : ℕ → Diffℕ
-fromℕ n = λ k → n ⟨ N._+_ ⟩ k
+fromℕ n = λ k → n ⟨ ℕ._+_ ⟩ k
diff --git a/src/Data/DifferenceVec.agda b/src/Data/DifferenceVec.agda
index acb50ffde0..22af2a6247 100644
--- a/src/Data/DifferenceVec.agda
+++ b/src/Data/DifferenceVec.agda
@@ -9,9 +9,9 @@
 module Data.DifferenceVec where
 
 open import Data.DifferenceNat
-open import Data.Vec.Base as V using (Vec)
-open import Function
-import Data.Nat.Base as N
+open import Data.Vec.Base as Vec using (Vec)
+open import Function.Base using (_⟨_⟩_)
+import Data.Nat.Base as ℕ
 
 infixr 5 _∷_ _++_
 
@@ -22,7 +22,7 @@ DiffVec A m = ∀ {n} → Vec A n → Vec A (m n)
 [] = λ k → k
 
 _∷_ : ∀ {a} {A : Set a} {n} → A → DiffVec A n → DiffVec A (suc n)
-x ∷ xs = λ k → V._∷_ x (xs k)
+x ∷ xs = λ k → Vec._∷_ x (xs k)
 
 [_] : ∀ {a} {A : Set a} → A → DiffVec A 1#
 [ x ] = x ∷ []
@@ -32,25 +32,25 @@ _++_ : ∀ {a} {A : Set a} {m n} →
 xs ++ ys = λ k → xs (ys k)
 
 toVec : ∀ {a} {A : Set a} {n} → DiffVec A n → Vec A (toℕ n)
-toVec xs = xs V.[]
+toVec xs = xs Vec.[]
 
 -- fromVec xs is linear in the length of xs.
 
 fromVec : ∀ {a} {A : Set a} {n} → Vec A n → DiffVec A (fromℕ n)
-fromVec xs = λ k → xs ⟨ V._++_ ⟩ k
+fromVec xs = λ k → xs ⟨ Vec._++_ ⟩ k
 
 head : ∀ {a} {A : Set a} {n} → DiffVec A (suc n) → A
-head xs = V.head (toVec xs)
+head xs = Vec.head (toVec xs)
 
 tail : ∀ {a} {A : Set a} {n} → DiffVec A (suc n) → DiffVec A n
-tail xs = λ k → V.tail (xs k)
+tail xs = λ k → Vec.tail (xs k)
 
 take : ∀ {a} {A : Set a} m {n} →
        DiffVec A (fromℕ m + n) → DiffVec A (fromℕ m)
-take N.zero    xs = []
-take (N.suc m) xs = head xs ∷ take m (tail xs)
+take ℕ.zero    xs = []
+take (ℕ.suc m) xs = head xs ∷ take m (tail xs)
 
 drop : ∀ {a} {A : Set a} m {n} →
        DiffVec A (fromℕ m + n) → DiffVec A n
-drop N.zero    xs = xs
-drop (N.suc m) xs = drop m (tail xs)
+drop ℕ.zero    xs = xs
+drop (ℕ.suc m) xs = drop m (tail xs)
diff --git a/src/Data/Digit.agda b/src/Data/Digit.agda
index 9c47fd544b..1fde8d22d4 100644
--- a/src/Data/Digit.agda
+++ b/src/Data/Digit.agda
@@ -9,21 +9,24 @@
 module Data.Digit where
 
 open import Data.Nat.Base
+  using (ℕ; zero; suc; _<_; _/_; _%_; sz<ss; _+_; _*_; 2+; _≤′_)
 open import Data.Nat.Properties
-open import Data.Nat.Solver
+  using (_≤?_; _<?_; ≤⇒≤′; module ≤-Reasoning; m≤m+n; +-comm; +-assoc;
+    *-distribˡ-+; *-identityʳ)
 open import Data.Fin.Base as Fin using (Fin; zero; suc; toℕ)
 open import Data.Bool.Base using (Bool; true; false)
-open import Data.Char using (Char)
-open import Data.List.Base
-open import Data.Product
+open import Data.Char.Base using (Char)
+open import Data.List.Base using (List; replicate; [_]; _∷_; [])
+open import Data.Product.Base using (∃; _,_)
 open import Data.Vec.Base as Vec using (Vec; _∷_; [])
-open import Data.Nat.DivMod
+open import Data.Nat.DivMod using (m/n<m; _divMod_; result)
 open import Data.Nat.Induction
-open import Relation.Nullary.Decidable using (does)
-open import Relation.Nullary.Decidable
-open import Relation.Binary using (Decidable)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; refl)
-open import Function
+  using (Acc; acc; <-wellFounded-fast; <′-Rec; <′-rec)
+open import Function.Base using (_$_)
+open import Relation.Nullary.Decidable using (True; does; toWitness)
+open import Relation.Binary.Definitions using (Decidable)
+open import Relation.Binary.PropositionalEquality
+  using (_≡_; refl; sym; cong; cong₂; module ≡-Reasoning)
 
 ------------------------------------------------------------------------
 -- Digits
@@ -56,11 +59,8 @@ toNatDigits base@(suc (suc _)) n = aux (<-wellFounded-fast n) []
   aux : {n : ℕ} → Acc _<_ n → List ℕ → List ℕ
   aux {zero}        _      xs =  (0 ∷ xs)
   aux {n@(suc _)} (acc wf) xs with does (0 <? n / base)
-  ... | false = (n % base) ∷ xs
-  ... | true  = aux (wf (n / base) q<n) ((n % base) ∷ xs)
-    where
-    q<n : n / base < n
-    q<n = m/n<m n base (s<s z<s)
+  ... | false = (n % base) ∷ xs -- Could this more simply be n ∷ xs here?
+  ... | true  = aux (wf (m/n<m n base sz<ss)) ((n % base) ∷ xs)
 
 ------------------------------------------------------------------------
 -- Converting between `ℕ` and expansions of `Digit base`
@@ -89,28 +89,39 @@ toDigits base@(suc (suc k)) n = <′-rec Pred helper n
   Pred = λ n → ∃ λ ds → fromDigits ds ≡ n
 
   cons : ∀ {m} (r : Digit base) → Pred m → Pred (toℕ r + m * base)
-  cons r (ds , eq) = (r ∷ ds , P.cong (λ i → toℕ r + i * base) eq)
-
-  open ≤-Reasoning
-  open +-*-Solver
+  cons r (ds , eq) = (r ∷ ds , cong (λ i → toℕ r + i * base) eq)
+
+  lem′ : ∀ x k → x + x + (k + x * k) ≡ k + x * 2+ k
+  lem′ x k = begin
+    x + x + (k + x * k)   ≡⟨ +-assoc (x + x) k _ ⟨
+    x + x + k + x * k     ≡⟨ cong (_+ x * k) (+-comm _ k) ⟩
+    k + (x + x) + x * k   ≡⟨ +-assoc k (x + x) _ ⟩
+    k + ((x + x) + x * k) ≡⟨ cong (k +_) (begin
+      (x + x) + x * k       ≡⟨ +-assoc x x _ ⟩
+      x + (x + x * k)       ≡⟨ cong (x +_) (cong (_+ x * k) (*-identityʳ x)) ⟨
+      x + (x * 1 + x * k)   ≡⟨ cong₂ _+_ (*-identityʳ x) (*-distribˡ-+ x 1 k ) ⟨
+      x * 1 + (x * suc k)   ≡⟨ *-distribˡ-+ x 1 (1 + k) ⟨
+      x * 2+ k              ∎) ⟩
+    k + x * 2+ k          ∎
+    where open ≡-Reasoning
 
   lem : ∀ x k r → 2 + x ≤′ r + (1 + x) * (2 + k)
   lem x k r = ≤⇒≤′ $ begin
-    2 + x
-      ≤⟨ m≤m+n _ _ ⟩
-    2 + x + (x + (1 + x) * k + r)
-      ≡⟨ solve 3 (λ x r k → con 2 :+ x :+ (x :+ (con 1 :+ x) :* k :+ r)
-                              :=
-                            r :+ (con 1 :+ x) :* (con 2 :+ k))
-                 refl x r k ⟩
-    r + (1 + x) * (2 + k)
-      ∎
+    2 + x                             ≤⟨ m≤m+n _ _ ⟩
+    2 + x + (x + (1 + x) * k + r)     ≡⟨ cong ((2 + x) +_) (+-comm _ r) ⟩
+    2 + x + (r + (x + (1 + x) * k))   ≡⟨ +-assoc (2 + x) r _ ⟨
+    2 + x + r + (x + (1 + x) * k)     ≡⟨ cong (_+ (x + (1 + x) * k)) (+-comm (2 + x) r) ⟩
+    r + (2 + x) + (x + (1 + x) * k)   ≡⟨ +-assoc r (2 + x) _ ⟩
+    r + ((2 + x) + (x + (1 + x) * k)) ≡⟨ cong (r +_) (cong 2+ (+-assoc x x _)) ⟨
+    r + (2 + (x + x + (1 + x) * k))   ≡⟨ cong (λ z → r + (2+ z)) (lem′ x k) ⟩
+    r + (2 + (k + x * (2 + k)))       ≡⟨⟩
+    r + (1 + x) * (2 + k)             ∎
+    where open ≤-Reasoning
 
   helper : ∀ n → <′-Rec Pred n → Pred n
   helper n                       rec with n divMod base
-  helper .(toℕ r + 0     * base) rec | result zero    r refl = ([ r ] , refl)
-  helper .(toℕ r + suc x * base) rec | result (suc x) r refl =
-    cons r (rec (suc x) (lem x k (toℕ r)))
+  ... | result zero    r eq = ([ r ] , sym eq)
+  ... | result (suc x) r refl = cons r (rec (lem x k (toℕ r)))
 
 ------------------------------------------------------------------------
 -- Showing digits
diff --git a/src/Data/Digit/Properties.agda b/src/Data/Digit/Properties.agda
index 0ba2cab34f..98810d4e27 100644
--- a/src/Data/Digit/Properties.agda
+++ b/src/Data/Digit/Properties.agda
@@ -7,22 +7,22 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Data.Digit
-import Data.Char.Properties as Charₚ
+import Data.Char.Properties as Char
 open import Data.Nat.Base using (ℕ)
 open import Data.Nat.Properties using (_≤?_)
 open import Data.Fin.Properties using (inject≤-injective)
-open import Data.Product using (_,_; proj₁)
+open import Data.Product.Base using (_,_; proj₁)
 open import Data.Vec.Relation.Unary.Unique.Propositional using (Unique)
-import Data.Vec.Relation.Unary.Unique.Propositional.Properties as Uniqueₚ
+import Data.Vec.Relation.Unary.Unique.Propositional.Properties as Unique
 open import Data.Vec.Relation.Unary.AllPairs using (allPairs?)
-open import Relation.Nullary.Decidable using (True; from-yes; ¬?)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; refl)
-open import Function using (_∘_)
+open import Relation.Nullary.Decidable.Core using (True; from-yes; ¬?)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
+open import Function.Base using (_∘_)
 
 module Data.Digit.Properties where
 
 digitCharsUnique : Unique digitChars
-digitCharsUnique = from-yes (allPairs? (λ x y → ¬? (x Charₚ.≟ y)) digitChars)
+digitCharsUnique = from-yes (allPairs? (λ x y → ¬? (x Char.≟ y)) digitChars)
 
 module _ (base : ℕ) where
   module _ {base≥2 base≥2′ : True (2 ≤? base)} where
@@ -32,4 +32,4 @@ module _ (base : ℕ) where
 
   module _ {base≤16 base≤16′ : True (base ≤? 16)} where
     showDigit-injective : (n m : Digit base) → showDigit {base} {base≤16} n ≡ showDigit {base} {base≤16′} m → n ≡ m
-    showDigit-injective n m = inject≤-injective _ _ n m ∘ Uniqueₚ.lookup-injective digitCharsUnique _ _
+    showDigit-injective n m = inject≤-injective _ _ n m ∘ Unique.lookup-injective digitCharsUnique _ _
diff --git a/src/Data/Empty.agda b/src/Data/Empty.agda
index ff98565038..d2647a1f18 100644
--- a/src/Data/Empty.agda
+++ b/src/Data/Empty.agda
@@ -1,7 +1,7 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Empty type, judgementally proof irrelevant
+-- Empty type, judgementally proof irrelevant, Level-monomorphic
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
@@ -20,10 +20,10 @@ open import Data.Irrelevant using (Irrelevant)
 private
   data Empty : Set where
 
--- ⊥ is defined via Data.Irrelevant (a record with a single irrelevant field)
--- so that Agda can judgementally declare that all proofs of ⊥ are equal
--- to each other. In particular this means that all functions returning a
--- proof of ⊥ are equal.
+-- ⊥ is defined via Data.Irrelevant (a record with a single irrelevant
+-- field) so that Agda can judgementally declare that all proofs of ⊥
+-- are equal to each other. In particular this means that all functions
+-- returning a proof of ⊥ are equal.
 
 ⊥ : Set
 ⊥ = Irrelevant Empty
@@ -35,3 +35,6 @@ private
 
 ⊥-elim : ∀ {w} {Whatever : Set w} → ⊥ → Whatever
 ⊥-elim ()
+
+⊥-elim-irr : ∀ {w} {Whatever : Set w} → .⊥ → Whatever
+⊥-elim-irr ()
diff --git a/src/Data/Fin.agda b/src/Data/Fin.agda
index e9b6a865ba..d0c0e12c5c 100644
--- a/src/Data/Fin.agda
+++ b/src/Data/Fin.agda
@@ -9,8 +9,7 @@
 module Data.Fin where
 
 open import Relation.Nullary.Decidable.Core
-open import Data.Nat.Base using (suc)
-import Data.Nat.Properties as ℕₚ
+import Data.Nat.Properties as ℕ
 
 ------------------------------------------------------------------------
 -- Publicly re-export the contents of the base module
@@ -27,5 +26,5 @@ open import Data.Fin.Properties public
 
 infix 10 #_
 
-#_ : ∀ m {n} {m<n : True (suc m ℕₚ.≤? n)} → Fin n
+#_ : ∀ m {n} {m<n : True (m ℕ.<? n)} → Fin n
 #_ _ {m<n = m<n} = fromℕ< (toWitness m<n)
diff --git a/src/Data/Fin/Base.agda b/src/Data/Fin/Base.agda
index 20a2636216..a328a85a57 100644
--- a/src/Data/Fin/Base.agda
+++ b/src/Data/Fin/Base.agda
@@ -11,18 +11,16 @@
 
 module Data.Fin.Base where
 
-open import Data.Bool.Base using (Bool; true; false; T; not)
-open import Data.Empty using (⊥-elim)
-open import Data.Nat.Base as ℕ using (ℕ; zero; suc; z≤n; s≤s; z<s; s<s; _^_)
-open import Data.Product as Product using (_×_; _,_; proj₁; proj₂)
+open import Data.Bool.Base using (Bool; T)
+open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
+open import Data.Product.Base as Product using (_×_; _,_; proj₁; proj₂)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_]′)
-open import Function.Base using (id; _∘_; _on_; flip)
+open import Function.Base using (id; _∘_; _on_; flip; _$_)
 open import Level using (0ℓ)
-open import Relation.Nullary.Negation.Core using (contradiction)
-open import Relation.Nullary.Decidable.Core using (yes; no; True; toWitness)
 open import Relation.Binary.Core
 open import Relation.Binary.PropositionalEquality.Core using (_≡_; _≢_; refl; cong)
 open import Relation.Binary.Indexed.Heterogeneous.Core using (IRel)
+open import Relation.Nullary.Negation.Core using (contradiction)
 
 private
   variable
@@ -69,16 +67,15 @@ fromℕ (suc n) = suc (fromℕ n)
 
 -- fromℕ< {m} _ = "m".
 
-fromℕ< : m ℕ.< n → Fin n
-fromℕ< {zero}  {suc n} z<s = zero
-fromℕ< {suc m} {suc n} (s<s m<n) = suc (fromℕ< m<n)
+fromℕ< : .(m ℕ.< n) → Fin n
+fromℕ< {zero}  {suc _} _   = zero
+fromℕ< {suc m} {suc _} m<n = suc (fromℕ< (ℕ.s<s⁻¹ m<n))
 
 -- fromℕ<″ m _ = "m".
 
-fromℕ<″ : ∀ m {n} → m ℕ.<″ n → Fin n
-fromℕ<″ zero    (ℕ.less-than-or-equal refl) = zero
-fromℕ<″ (suc m) (ℕ.less-than-or-equal refl) =
-  suc (fromℕ<″ m (ℕ.less-than-or-equal refl))
+fromℕ<″ : ∀ m {n} → .(m ℕ.<″ n) → Fin n
+fromℕ<″ zero    {suc _} _    = zero
+fromℕ<″ (suc m) {suc _} m<″n = suc (fromℕ<″ m (ℕ.s<″s⁻¹ m<″n))
 
 -- canonical liftings of i:Fin m to larger index
 
@@ -96,9 +93,9 @@ zero    ↑ʳ i = i
 
 -- reduce≥ "m + i" _ = "i".
 
-reduce≥ : ∀ (i : Fin (m ℕ.+ n)) (i≥m : toℕ i ℕ.≥ m) → Fin n
-reduce≥ {zero}  i       i≥m       = i
-reduce≥ {suc m} (suc i) (s≤s i≥m) = reduce≥ i i≥m
+reduce≥ : ∀ (i : Fin (m ℕ.+ n)) → .(m ℕ.≤ toℕ i) → Fin n
+reduce≥ {zero}  i       _   = i
+reduce≥ {suc _} (suc i) m≤i = reduce≥ i (ℕ.s≤s⁻¹ m≤i)
 
 -- inject⋆ m "i" = "i".
 
@@ -107,21 +104,21 @@ inject {i = suc i} zero    = zero
 inject {i = suc i} (suc j) = suc (inject j)
 
 inject! : ∀ {i : Fin (suc n)} → Fin′ i → Fin n
-inject! {n = suc _} {i = suc _}  zero    = zero
-inject! {n = suc _} {i = suc _}  (suc j) = suc (inject! j)
+inject! {n = suc _} {i = suc _} zero    = zero
+inject! {n = suc _} {i = suc _} (suc j) = suc (inject! j)
 
 inject₁ : Fin n → Fin (suc n)
 inject₁ zero    = zero
 inject₁ (suc i) = suc (inject₁ i)
 
-inject≤ : Fin m → m ℕ.≤ n → Fin n
-inject≤ {_} {suc n} zero    _        = zero
-inject≤ {_} {suc n} (suc i) (s≤s m≤n) = suc (inject≤ i m≤n)
+inject≤ : Fin m → .(m ℕ.≤ n) → Fin n
+inject≤ {n = suc _} zero    _   = zero
+inject≤ {n = suc _} (suc i) m≤n = suc (inject≤ i (ℕ.s≤s⁻¹ m≤n))
 
 -- lower₁ "i" _ = "i".
 
 lower₁ : ∀ (i : Fin (suc n)) → n ≢ toℕ i → Fin n
-lower₁ {zero}  zero    ne = ⊥-elim (ne refl)
+lower₁ {zero}  zero    ne = contradiction refl ne
 lower₁ {suc n} zero    _  = zero
 lower₁ {suc n} (suc i) ne = suc (lower₁ i (ne ∘ cong suc))
 
@@ -137,7 +134,7 @@ strengthen (suc i) = suc (strengthen i)
 splitAt : ∀ m {n} → Fin (m ℕ.+ n) → Fin m ⊎ Fin n
 splitAt zero    i       = inj₂ i
 splitAt (suc m) zero    = inj₁ zero
-splitAt (suc m) (suc i) = Sum.map suc id (splitAt m i)
+splitAt (suc m) (suc i) = Sum.map₁ suc (splitAt m i)
 
 -- inverse of above function
 join : ∀ m n → Fin m ⊎ Fin n → Fin (m ℕ.+ n)
@@ -147,9 +144,10 @@ join m n = [ _↑ˡ n , m ↑ʳ_ ]′
 -- This is dual to group from Data.Vec.
 
 quotRem : ∀ n → Fin (m ℕ.* n) → Fin n × Fin m
-quotRem {suc m} n i with splitAt n i
-... | inj₁ j = j , zero
-... | inj₂ j = Product.map₂ suc (quotRem {m} n j)
+quotRem {suc m} n i =
+  [ (_, zero)
+  , Product.map₂ suc ∘ quotRem {m} n
+  ]′ $ splitAt n i
 
 -- a variant of quotRem the type of whose result matches the order of multiplication
 remQuot : ∀ n → Fin (m ℕ.* n) → Fin m × Fin n
@@ -167,12 +165,12 @@ combine {suc m} {n} zero    j = j ↑ˡ (m ℕ.* n)
 combine {suc m} {n} (suc i) j = n ↑ʳ (combine i j)
 
 -- Next in progression after splitAt and remQuot
-finToFun : Fin (m ^ n) → (Fin n → Fin m)
-finToFun {m} {suc n} i zero    = quotient (m ^ n) i
-finToFun {m} {suc n} i (suc j) = finToFun (remainder {m} (m ^ n) i) j
+finToFun : Fin (m ℕ.^ n) → (Fin n → Fin m)
+finToFun {m} {suc n} i zero    = quotient (m ℕ.^ n) i
+finToFun {m} {suc n} i (suc j) = finToFun (remainder {m} (m ℕ.^ n) i) j
 
 -- inverse of above function
-funToFin : (Fin m → Fin n) → Fin (n ^ m)
+funToFin : (Fin m → Fin n) → Fin (n ℕ.^ m)
 funToFin {zero}  f = zero
 funToFin {suc m} f = combine (f zero) (funToFin (f ∘ suc))
 
@@ -252,7 +250,7 @@ opposite {suc n} (suc i) = inject₁ (opposite i)
 -- McBride's "First-order unification by structural recursion".
 
 punchOut : ∀ {i j : Fin (suc n)} → i ≢ j → Fin n
-punchOut {_}     {zero}   {zero}  i≢j = ⊥-elim (i≢j refl)
+punchOut {_}     {zero}   {zero}  i≢j = contradiction refl i≢j
 punchOut {_}     {zero}   {suc j} _   = j
 punchOut {suc _} {suc i}  {zero}  _   = zero
 punchOut {suc _} {suc i}  {suc j} i≢j = suc (punchOut (i≢j ∘ cong suc))
@@ -320,7 +318,7 @@ compare (suc i) (suc j) with compare i j
 raise = _↑ʳ_
 {-# WARNING_ON_USAGE raise
 "Warning: raise was deprecated in v2.0.
-Please use _↑_ʳ instead."
+Please use _↑ʳ_ instead."
 #-}
 inject+ : ∀ {m} n → Fin m → Fin (m ℕ.+ n)
 inject+ n i = i ↑ˡ n
diff --git a/src/Data/Fin/Induction.agda b/src/Data/Fin/Induction.agda
index acd098be75..398c1a3966 100644
--- a/src/Data/Fin/Induction.agda
+++ b/src/Data/Fin/Induction.agda
@@ -7,34 +7,41 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 {-# OPTIONS --warn=noUserWarning #-} -- for deprecated _≺_ (issue #1726)
 
-open import Data.Fin.Base
-open import Data.Fin.Properties
+module Data.Fin.Induction where
+
+open import Data.Fin.Base using (Fin; zero; suc; _<_; toℕ; inject₁;
+  _≥_; _>_; fromℕ; _≺_)
+open import Data.Fin.Properties using (toℕ-inject₁; ≤-refl; <-cmp;
+  toℕ≤n; toℕ-injective; toℕ-fromℕ; toℕ-lower₁; inject₁-lower₁;
+  pigeonhole; ≺⇒<′)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc; _∸_; s≤s)
 open import Data.Nat.Properties using (n<1+n; ≤⇒≯)
 import Data.Nat.Induction as ℕ
 import Data.Nat.Properties as ℕ
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Data.Vec.Base as Vec using (Vec; []; _∷_)
 open import Data.Vec.Relation.Unary.Linked as Linked using (Linked; [-]; _∷_)
-import Data.Vec.Relation.Unary.Linked.Properties as Linkedₚ
+import Data.Vec.Relation.Unary.Linked.Properties as Linked
 open import Function.Base using (flip; _$_)
-open import Induction
-open import Induction.WellFounded as WF
+open import Induction using (RecStruct)
+open import Induction.WellFounded as WF using (WellFounded; WfRec;
+  module Subrelation)
 open import Level using (Level)
-open import Relation.Binary
-  using (Rel; Decidable; IsPartialOrder; IsStrictPartialOrder; StrictPartialOrder)
-import Relation.Binary.Construct.Converse as Converse
-import Relation.Binary.Construct.Flip as Flip
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (StrictPartialOrder)
+open import Relation.Binary.Structures using (IsPartialOrder; IsStrictPartialOrder)
+open import Relation.Binary.Definitions using (Decidable)
+import Relation.Binary.Construct.Flip.EqAndOrd as EqAndOrd
+import Relation.Binary.Construct.Flip.Ord as Ord
 import Relation.Binary.Construct.NonStrictToStrict as ToStrict
 import Relation.Binary.Construct.On as On
 open import Relation.Binary.Definitions using (Tri; tri<; tri≈; tri>)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; sym; subst; trans; cong)
 open import Relation.Nullary.Decidable using (yes; no)
 open import Relation.Nullary.Negation using (contradiction)
 open import Relation.Unary using (Pred)
 
-module Data.Fin.Induction where
-
 private
   variable
     ℓ : Level
@@ -63,7 +70,7 @@ open WF public using (Acc; acc)
   induct {suc j} (acc rs) (tri< (s≤s i≤j) _ _) _ = Pᵢ⇒Pᵢ₊₁ j P[1+j]
     where
     toℕj≡toℕinjJ = sym $ toℕ-inject₁ j
-    P[1+j] = induct (rs _ (s≤s (subst (ℕ._≤ toℕ j) toℕj≡toℕinjJ ≤-refl)))
+    P[1+j] = induct (rs (s≤s (subst (ℕ._≤ toℕ j) toℕj≡toℕinjJ ≤-refl)))
       (<-cmp i $ inject₁ j) (subst (toℕ i ℕ.≤_) toℕj≡toℕinjJ i≤j)
 
 <-weakInduction : (P : Pred (Fin (suc n)) ℓ) →
@@ -78,8 +85,7 @@ open WF public using (Acc; acc)
 
 private
   acc-map : ∀ {x : Fin n} → Acc ℕ._<_ (n ∸ toℕ x) → Acc _>_ x
-  acc-map {n} (acc rs) = acc λ y y>x →
-    acc-map (rs (n ∸ toℕ y) (ℕ.∸-monoʳ-< y>x (toℕ≤n y)))
+  acc-map (acc rs) = acc λ y>x → acc-map (rs (ℕ.∸-monoʳ-< y>x (toℕ≤n _)))
 
 >-wellFounded : WellFounded {A = Fin n} _>_
 >-wellFounded {n} x = acc-map (ℕ.<-wellFounded (n ∸ toℕ x))
@@ -94,7 +100,7 @@ private
   induct {i} (acc rec) with n ℕ.≟ toℕ i
   ... | yes n≡i = subst P (toℕ-injective (trans (toℕ-fromℕ n) n≡i)) Pₙ
   ... | no  n≢i = subst P (inject₁-lower₁ i n≢i) (Pᵢ₊₁⇒Pᵢ _ Pᵢ₊₁)
-    where Pᵢ₊₁ = induct (rec _ (ℕ.≤-reflexive (cong suc (sym (toℕ-lower₁ i n≢i)))))
+    where Pᵢ₊₁ = induct (rec (ℕ.≤-reflexive (cong suc (sym (toℕ-lower₁ i n≢i)))))
 
 ------------------------------------------------------------------------
 -- Well-foundedness of other (strict) partial orders on Fin
@@ -110,20 +116,20 @@ module _ {_≈_ : Rel (Fin n) ℓ} where
 
   spo-wellFounded : ∀ {r} {_⊏_ : Rel (Fin n) r} →
                     IsStrictPartialOrder _≈_ _⊏_ → WellFounded _⊏_
-  spo-wellFounded {_} {_⊏_} isSPO i = go n i pigeon where
+  spo-wellFounded {_} {_⊏_} isSPO i = go n pigeon where
 
     module ⊏ = IsStrictPartialOrder isSPO
 
-    go : ∀ m i →
-         ((xs : Vec (Fin n) m) → Linked (flip _⊏_) (i ∷ xs) → WellFounded _⊏_) →
+    go : ∀ m {i} →
+         ({xs : Vec (Fin n) m} → Linked (flip _⊏_) (i ∷ xs) → WellFounded _⊏_) →
          Acc _⊏_ i
-    go zero    i k = k [] [-] i
-    go (suc m) i k = acc $ λ j j⊏i → go m j (λ xs i∷xs↑ → k (j ∷ xs) (j⊏i ∷ i∷xs↑))
+    go zero    k = k [-] _
+    go (suc m) k = acc λ j⊏i → go m λ i∷xs↑ → k (j⊏i ∷ i∷xs↑)
 
-    pigeon : (xs : Vec (Fin n) n) → Linked (flip _⊏_) (i ∷ xs) → WellFounded _⊏_
-    pigeon xs i∷xs↑ =
+    pigeon : {xs : Vec (Fin n) n} → Linked (flip _⊏_) (i ∷ xs) → WellFounded _⊏_
+    pigeon {xs} i∷xs↑ =
       let (i₁ , i₂ , i₁<i₂ , xs[i₁]≡xs[i₂]) = pigeonhole (n<1+n n) (Vec.lookup (i ∷ xs)) in
-      let xs[i₁]⊏xs[i₂] = Linkedₚ.lookup⁺ (Flip.transitive _⊏_ ⊏.trans) {xs = i ∷ xs} i∷xs↑ i₁<i₂ in
+      let xs[i₁]⊏xs[i₂] = Linked.lookup⁺ (Ord.transitive _⊏_ ⊏.trans) i∷xs↑ i₁<i₂ in
       let xs[i₁]⊏xs[i₁] = ⊏.<-respʳ-≈ (⊏.Eq.reflexive xs[i₁]≡xs[i₂]) xs[i₁]⊏xs[i₂] in
       contradiction xs[i₁]⊏xs[i₁] (⊏.irrefl ⊏.Eq.refl)
 
@@ -137,7 +143,7 @@ module _ {_≈_ : Rel (Fin n) ℓ} where
 
   spo-noetherian : ∀ {r} {_⊏_ : Rel (Fin n) r} →
                    IsStrictPartialOrder _≈_ _⊏_ → WellFounded (flip _⊏_)
-  spo-noetherian isSPO = spo-wellFounded (Converse.isStrictPartialOrder isSPO)
+  spo-noetherian isSPO = spo-wellFounded (EqAndOrd.isStrictPartialOrder isSPO)
 
   po-noetherian : ∀ {r} {_⊑_ : Rel (Fin n) r} → IsPartialOrder _≈_ _⊑_ →
                   WellFounded (flip (ToStrict._<_ _≈_ _⊑_))
diff --git a/src/Data/Fin/Permutation.agda b/src/Data/Fin/Permutation.agda
index f6a7820b52..794b93f76b 100644
--- a/src/Data/Fin/Permutation.agda
+++ b/src/Data/Fin/Permutation.agda
@@ -8,30 +8,31 @@
 
 module Data.Fin.Permutation where
 
-open import Data.Bool using (true; false)
-open import Data.Empty using (⊥-elim)
-open import Data.Fin.Base
-open import Data.Fin.Patterns
-open import Data.Fin.Properties
+open import Data.Bool.Base using (true; false)
+open import Data.Fin.Base using (Fin; suc; opposite; punchIn; punchOut)
+open import Data.Fin.Patterns using (0F)
+open import Data.Fin.Properties using (punchInᵢ≢i; punchOut-punchIn;
+  punchOut-cong; punchOut-cong′; punchIn-punchOut; _≟_; ¬Fin0)
 import Data.Fin.Permutation.Components as PC
 open import Data.Nat.Base using (ℕ; suc; zero)
-open import Data.Product using (_,_; proj₂)
-open import Function.Bundles using (_↔_; Injection; Inverse; mk↔′)
+open import Data.Product.Base using (_,_; proj₂)
+open import Function.Bundles using (_↔_; Injection; Inverse; mk↔ₛ′)
 open import Function.Construct.Composition using (_↔-∘_)
 open import Function.Construct.Identity using (↔-id)
 open import Function.Construct.Symmetry using (↔-sym)
-open import Function.Definitions using (Inverseˡ; Inverseʳ)
-open import Function.Equality using (_⟨$⟩_)
+open import Function.Definitions using (StrictlyInverseˡ; StrictlyInverseʳ)
 open import Function.Properties.Inverse using (↔⇒↣)
 open import Function.Base using (_∘_)
 open import Level using (0ℓ)
-open import Relation.Binary using (Rel)
+open import Relation.Binary.Core using (Rel)
 open import Relation.Nullary using (does; ¬_; yes; no)
 open import Relation.Nullary.Decidable using (dec-yes; dec-no)
 open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; _≢_; refl; trans; sym; →-to-⟶; cong; cong₂)
-open P.≡-Reasoning
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≢_; refl; sym; trans; subst; cong; cong₂)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
+open ≡-Reasoning
 
 private
   variable
@@ -57,8 +58,8 @@ Permutation′ n = Permutation n n
 -- Helper functions
 
 permutation : ∀ (f : Fin m → Fin n) (g : Fin n → Fin m) →
-              Inverseˡ _≡_ _≡_ f g → Inverseʳ _≡_ _≡_ f g → Permutation m n
-permutation = mk↔′
+              StrictlyInverseˡ _≡_ f g → StrictlyInverseʳ _≡_ f g → Permutation m n
+permutation = mk↔ₛ′
 
 infixl 5 _⟨$⟩ʳ_ _⟨$⟩ˡ_
 _⟨$⟩ʳ_ : Permutation m n → Fin m → Fin n
@@ -68,10 +69,10 @@ _⟨$⟩ˡ_ : Permutation m n → Fin n → Fin m
 _⟨$⟩ˡ_ = Inverse.from
 
 inverseˡ : ∀ (π : Permutation m n) {i} → π ⟨$⟩ˡ (π ⟨$⟩ʳ i) ≡ i
-inverseˡ π = Inverse.inverseʳ π _
+inverseˡ π = Inverse.inverseʳ π refl
 
 inverseʳ : ∀ (π : Permutation m n) {i} → π ⟨$⟩ʳ (π ⟨$⟩ˡ i) ≡ i
-inverseʳ π = Inverse.inverseˡ π _
+inverseʳ π = Inverse.inverseˡ π refl
 
 ------------------------------------------------------------------------
 -- Equality
@@ -105,7 +106,7 @@ reverse = permutation opposite opposite PC.reverse-involutive PC.reverse-involut
 
 infixr 9 _∘ₚ_
 _∘ₚ_ : Permutation m n → Permutation n o → Permutation m o
-π₁ ∘ₚ π₂ = π₁ ↔-∘ π₂
+π₁ ∘ₚ π₂ = π₂ ↔-∘ π₁
 
 -- Flip
 
@@ -142,7 +143,7 @@ remove {m} {n} i π = permutation to from inverseˡ′ inverseʳ′
   from : Fin n → Fin m
   from j = punchOut {j = πˡ (punchIn (πʳ i) j)} from-punchOut
 
-  inverseʳ′ : Inverseʳ _≡_ _≡_ to from
+  inverseʳ′ : StrictlyInverseʳ _≡_ to from
   inverseʳ′ j = begin
     from (to j)                                                      ≡⟨⟩
     punchOut {i = i} {πˡ (punchIn (πʳ i) (punchOut to-punchOut))} _  ≡⟨ punchOut-cong′ i (cong πˡ (punchIn-punchOut _)) ⟩
@@ -150,7 +151,7 @@ remove {m} {n} i π = permutation to from inverseˡ′ inverseʳ′
     punchOut {i = i} {punchIn i j}                                _  ≡⟨ punchOut-punchIn i ⟩
     j                                                                ∎
 
-  inverseˡ′ : Inverseˡ _≡_ _≡_ to from
+  inverseˡ′ : StrictlyInverseˡ _≡_ to from
   inverseˡ′ j = begin
     to (from j)                                                       ≡⟨⟩
     punchOut {i = πʳ i} {πʳ (punchIn i (punchOut from-punchOut))}  _  ≡⟨ punchOut-cong′ (πʳ i) (cong πʳ (punchIn-punchOut _)) ⟩
@@ -171,11 +172,11 @@ lift₀ {m} {n} π = permutation to from inverseˡ′ inverseʳ′
   from 0F      = 0F
   from (suc i) = suc (π ⟨$⟩ˡ i)
 
-  inverseʳ′ : Inverseʳ _≡_ _≡_ to from
+  inverseʳ′ : StrictlyInverseʳ _≡_ to from
   inverseʳ′ 0F      = refl
   inverseʳ′ (suc j) = cong suc (inverseˡ π)
 
-  inverseˡ′ : Inverseˡ _≡_ _≡_ to from
+  inverseˡ′ : StrictlyInverseˡ _≡_ to from
   inverseˡ′ 0F      = refl
   inverseˡ′ (suc j) = cong suc (inverseʳ π)
 
@@ -194,7 +195,7 @@ insert {m} {n} i j π = permutation to from inverseˡ′ inverseʳ′
   ... | yes j≡k = i
   ... | no  j≢k = punchIn i (π ⟨$⟩ˡ punchOut j≢k)
 
-  inverseʳ′ : Inverseʳ _≡_ _≡_ to from
+  inverseʳ′ : StrictlyInverseʳ _≡_ to from
   inverseʳ′ k with i ≟ k
   ... | yes i≡k rewrite proj₂ (dec-yes (j ≟ j) refl) = i≡k
   ... | no  i≢k
@@ -207,7 +208,7 @@ insert {m} {n} i j π = permutation to from inverseˡ′ inverseʳ′
     punchIn i (punchOut i≢k)                                              ≡⟨ punchIn-punchOut i≢k ⟩
     k                                                                     ∎
 
-  inverseˡ′ : Inverseˡ _≡_ _≡_ to from
+  inverseˡ′ : StrictlyInverseˡ _≡_ to from
   inverseˡ′ k with j ≟ k
   ... | yes j≡k rewrite proj₂ (dec-yes (i ≟ i) refl) = j≡k
   ... | no  j≢k
@@ -242,7 +243,7 @@ module _ (π : Permutation (suc m) (suc n)) where
   lift₀-remove p (suc i) = punchOut-zero (πʳ (suc i)) p
     where
     punchOut-zero : ∀ {i} (j : Fin (suc n)) {neq} → i ≡ 0F → suc (punchOut {i = i} {j} neq) ≡ j
-    punchOut-zero 0F {neq} p = ⊥-elim (neq p)
+    punchOut-zero 0F {neq} p = contradiction p neq
     punchOut-zero (suc j) refl = refl
 
 ↔⇒≡ : Permutation m n → m ≡ n
@@ -252,7 +253,7 @@ module _ (π : Permutation (suc m) (suc n)) where
 ↔⇒≡ {suc m} {suc n} π = cong suc (↔⇒≡ (remove 0F π))
 
 fromPermutation : Permutation m n → Permutation′ m
-fromPermutation π = P.subst (Permutation _) (sym (↔⇒≡ π)) π
+fromPermutation π = subst (Permutation _) (sym (↔⇒≡ π)) π
 
 refute : m ≢ n → ¬ Permutation m n
 refute m≢n π = contradiction (↔⇒≡ π) m≢n
diff --git a/src/Data/Fin/Permutation/Components.agda b/src/Data/Fin/Permutation/Components.agda
index b053cee86b..2d2f34deb7 100644
--- a/src/Data/Fin/Permutation/Components.agda
+++ b/src/Data/Fin/Permutation/Components.agda
@@ -9,22 +9,25 @@
 module Data.Fin.Permutation.Components where
 
 open import Data.Bool.Base using (Bool; true; false)
-open import Data.Fin.Base
+open import Data.Fin.Base using (Fin; suc; opposite; toℕ)
 open import Data.Fin.Properties
+  using (_≟_; opposite-prop; opposite-involutive; opposite-suc)
 open import Data.Nat.Base as ℕ using (zero; suc; _∸_)
-import Data.Nat.Properties as ℕₚ
-open import Data.Product using (proj₂)
+open import Data.Product.Base using (proj₂)
 open import Function.Base using (_∘_)
 open import Relation.Nullary.Reflects using (invert)
 open import Relation.Nullary using (does; _because_; yes; no)
 open import Relation.Nullary.Decidable using (dec-true; dec-false)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; sym; trans)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Algebra.Definitions using (Involutive)
 open ≡-Reasoning
 
---------------------------------------------------------------------------------
+------------------------------------------------------------------------
 --  Functions
---------------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 -- 'tranpose i j' swaps the places of 'i' and 'j'.
 
@@ -35,9 +38,9 @@ transpose i j k with does (k ≟ i)
 ...   | true  = i
 ...   | false = k
 
---------------------------------------------------------------------------------
+------------------------------------------------------------------------
 --  Properties
---------------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 transpose-inverse : ∀ {n} (i j : Fin n) {k} →
                     transpose i j (transpose j i k) ≡ k
diff --git a/src/Data/Fin/Permutation/Transposition/List.agda b/src/Data/Fin/Permutation/Transposition/List.agda
index 42505de541..3d14d36b05 100644
--- a/src/Data/Fin/Permutation/Transposition/List.agda
+++ b/src/Data/Fin/Permutation/Transposition/List.agda
@@ -8,16 +8,18 @@
 
 module Data.Fin.Permutation.Transposition.List where
 
-open import Data.Fin.Base
+open import Data.Fin.Base using (Fin; suc)
 open import Data.Fin.Patterns using (0F)
 open import Data.Fin.Permutation as P hiding (lift₀)
 import Data.Fin.Permutation.Components as PC
-open import Data.List using (List; []; _∷_; map)
+open import Data.List.Base using (List; []; _∷_; map)
 open import Data.Nat.Base using (ℕ; suc; zero)
-open import Data.Product using (_×_; _,_)
-open import Function using (_∘_)
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; sym; cong; module ≡-Reasoning)
+open import Data.Product.Base using (_×_; _,_)
+open import Function.Base using (_∘_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; sym; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open ≡-Reasoning
 
 private
diff --git a/src/Data/Fin/Properties.agda b/src/Data/Fin/Properties.agda
index 2f6e36eabd..e1f2d25d24 100644
--- a/src/Data/Fin/Properties.agda
+++ b/src/Data/Fin/Properties.agda
@@ -5,7 +5,8 @@
 -- properties (or other properties not available in Data.Fin)
 ------------------------------------------------------------------------
 
-{-# OPTIONS --warn=noUserWarning #-} -- for deprecated _≺_ (issue #1726)
+{-# OPTIONS --cubical-compatible --safe #-}
+{-# OPTIONS --warn=noUserWarning #-} -- for deprecated _≺_ and _≻toℕ_ (issue #1726)
 
 module Data.Fin.Properties where
 
@@ -17,29 +18,36 @@ open import Data.Bool.Base using (Bool; true; false; not; _∧_; _∨_)
 open import Data.Empty using (⊥; ⊥-elim)
 open import Data.Fin.Base
 open import Data.Fin.Patterns
-open import Data.Nat.Base as ℕ using (ℕ; zero; suc; s≤s; z≤n; z<s; s<s; _∸_; _^_)
-import Data.Nat.Properties as ℕₚ
-open import Data.Nat.Solver
-open import Data.Unit using (⊤; tt)
-open import Data.Product using (Σ-syntax; ∃; ∃₂; ∄; _×_; _,_; map; proj₁; proj₂; uncurry; <_,_>)
+open import Data.Nat.Base as ℕ
+  using (ℕ; zero; suc; s≤s; z≤n; z<s; s<s; s<s⁻¹; _∸_; _^_)
+import Data.Nat.Properties as ℕ
+open import Data.Unit.Base using (⊤; tt)
+open import Data.Product.Base as Product
+  using (∃; ∃₂; _×_; _,_; map; proj₁; proj₂; uncurry; <_,_>)
 open import Data.Product.Properties using (,-injective)
 open import Data.Product.Algebra using (×-cong)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_]; [_,_]′)
 open import Data.Sum.Properties using ([,]-map; [,]-∘)
 open import Function.Base using (_∘_; id; _$_; flip)
-open import Function.Bundles using (Injection; _↣_; _⇔_; _↔_; mk⇔; mk↔′)
-open import Function.Definitions using (Injective)
-open import Function.Definitions.Core2 using (Surjective)
-open import Function.Consequences using (contraInjective)
+open import Function.Bundles using (Injection; _↣_; _⇔_; _↔_; mk⇔; mk↔ₛ′)
+open import Function.Definitions using (Injective; Surjective)
+open import Function.Consequences.Propositional using (contraInjective)
 open import Function.Construct.Composition as Comp hiding (injective)
 open import Level using (Level)
-open import Relation.Binary as B hiding (Decidable; _⇔_)
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; _≢_; refl; sym; trans; cong; cong₂; subst; _≗_; module ≡-Reasoning)
-open import Relation.Nullary
-  using (Reflects; ofʸ; ofⁿ; Dec; _because_; does; proof; yes; no; ¬_; _×-dec_; _⊎-dec_; contradiction)
-open import Relation.Nullary.Reflects
-open import Relation.Nullary.Decidable as Dec using (map′)
+open import Relation.Binary.Definitions as B hiding (Decidable)
+open import Relation.Binary.Core using (_⇒_; _Preserves_⟶_)
+open import Relation.Binary.Bundles
+  using (Preorder; Setoid; DecSetoid; Poset; TotalOrder; DecTotalOrder; StrictPartialOrder; StrictTotalOrder)
+open import Relation.Binary.Structures
+  using (IsDecEquivalence; IsPreorder; IsPartialOrder; IsTotalOrder; IsDecTotalOrder; IsStrictPartialOrder; IsStrictTotalOrder)
+open import Relation.Binary.PropositionalEquality.Core as ≡
+  using (_≡_; _≢_; refl; sym; trans; cong; cong₂; subst; _≗_)
+open import Relation.Binary.PropositionalEquality.Properties as ≡
+  using (module ≡-Reasoning)
+open import Relation.Nullary.Decidable as Dec
+  using (Dec; _because_; yes; no; _×-dec_; _⊎-dec_; map′)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
+open import Relation.Nullary.Reflects using (Reflects; invert)
 open import Relation.Unary as U
   using (U; Pred; Decidable; _⊆_; Satisfiable; Universal)
 open import Relation.Unary.Properties using (U?)
@@ -58,17 +66,20 @@ private
 ¬Fin0 : ¬ Fin 0
 ¬Fin0 ()
 
+nonZeroIndex : Fin n → ℕ.NonZero n
+nonZeroIndex {n = suc _} _ = _
+
 ------------------------------------------------------------------------
 -- Bundles
 
 0↔⊥ : Fin 0 ↔ ⊥
-0↔⊥ = mk↔′ ¬Fin0 (λ ()) (λ ()) (λ ())
+0↔⊥ = mk↔ₛ′ ¬Fin0 (λ ()) (λ ()) (λ ())
 
 1↔⊤ : Fin 1 ↔ ⊤
-1↔⊤ = mk↔′ (λ { 0F → tt }) (λ { tt → 0F }) (λ { tt → refl }) λ { 0F → refl }
+1↔⊤ = mk↔ₛ′ (λ { 0F → tt }) (λ { tt → 0F }) (λ { tt → refl }) λ { 0F → refl }
 
 2↔Bool : Fin 2 ↔ Bool
-2↔Bool = mk↔′ (λ { 0F → false; 1F → true }) (λ { false → 0F ; true → 1F })
+2↔Bool = mk↔ₛ′ (λ { 0F → false; 1F → true }) (λ { false → 0F ; true → 1F })
   (λ { false → refl ; true → refl }) (λ { 0F → refl ; 1F → refl })
 
 ------------------------------------------------------------------------
@@ -94,7 +105,7 @@ suc x ≟ suc y = map′ (cong suc) suc-injective (x ≟ y)
 
 ≡-isDecEquivalence : IsDecEquivalence {A = Fin n} _≡_
 ≡-isDecEquivalence = record
-  { isEquivalence = P.isEquivalence
+  { isEquivalence = ≡.isEquivalence
   ; _≟_           = _≟_
   }
 
@@ -102,10 +113,10 @@ suc x ≟ suc y = map′ (cong suc) suc-injective (x ≟ y)
 -- Bundles
 
 ≡-preorder : ℕ → Preorder _ _ _
-≡-preorder n = P.preorder (Fin n)
+≡-preorder n = ≡.preorder (Fin n)
 
 ≡-setoid : ℕ → Setoid _ _
-≡-setoid n = P.setoid (Fin n)
+≡-setoid n = ≡.setoid (Fin n)
 
 ≡-decSetoid : ℕ → DecSetoid _ _
 ≡-decSetoid n = record
@@ -155,22 +166,23 @@ toℕ-↑ʳ (suc n) i = cong suc (toℕ-↑ʳ n i)
 -- toℕ and the ordering relations
 ------------------------------------------------------------------------
 
+toℕ<n : ∀ (i : Fin n) → toℕ i ℕ.< n
+toℕ<n {n = suc _} zero    = z<s
+toℕ<n {n = suc _} (suc i) = s<s (toℕ<n i)
+
 toℕ≤pred[n] : ∀ (i : Fin n) → toℕ i ℕ.≤ ℕ.pred n
 toℕ≤pred[n] zero                 = z≤n
 toℕ≤pred[n] (suc {n = suc n} i)  = s≤s (toℕ≤pred[n] i)
 
 toℕ≤n : ∀ (i : Fin n) → toℕ i ℕ.≤ n
-toℕ≤n {suc n} i = ℕₚ.m≤n⇒m≤1+n (toℕ≤pred[n] i)
-
-toℕ<n : ∀ (i : Fin n) → toℕ i ℕ.< n
-toℕ<n {suc n} i = s<s (toℕ≤pred[n] i)
+toℕ≤n {suc n} i = ℕ.m≤n⇒m≤1+n (toℕ≤pred[n] i)
 
 -- A simpler implementation of toℕ≤pred[n],
 -- however, with a different reduction behavior.
 -- If no one needs the reduction behavior of toℕ≤pred[n],
 -- it can be removed in favor of toℕ≤pred[n]′.
 toℕ≤pred[n]′ : ∀ (i : Fin n) → toℕ i ℕ.≤ ℕ.pred n
-toℕ≤pred[n]′ i = ℕₚ.<⇒≤pred (toℕ<n i)
+toℕ≤pred[n]′ i = ℕ.<⇒≤pred (toℕ<n i)
 
 toℕ-mono-< : i < j → toℕ i ℕ.< toℕ j
 toℕ-mono-< i<j = i<j
@@ -196,37 +208,38 @@ fromℕ-toℕ : ∀ (i : Fin n) → fromℕ (toℕ i) ≡ strengthen i
 fromℕ-toℕ zero    = refl
 fromℕ-toℕ (suc i) = cong suc (fromℕ-toℕ i)
 
-≤fromℕ : ∀ (i : Fin (ℕ.suc n)) → i ≤ fromℕ n
-≤fromℕ i = subst (toℕ i ℕ.≤_) (sym (toℕ-fromℕ _)) (toℕ≤pred[n] i)
+≤fromℕ : ∀ (i : Fin (suc n)) → i ≤ fromℕ n
+≤fromℕ {n = n} i rewrite toℕ-fromℕ n = ℕ.s≤s⁻¹ (toℕ<n i)
 
 ------------------------------------------------------------------------
 -- fromℕ<
 ------------------------------------------------------------------------
 
-fromℕ<-toℕ : ∀ (i : Fin n) (i<n : toℕ i ℕ.< n) → fromℕ< i<n ≡ i
-fromℕ<-toℕ zero    z<s       = refl
-fromℕ<-toℕ (suc i) (s<s i<n) = cong suc (fromℕ<-toℕ i i<n)
+fromℕ<-toℕ : ∀ (i : Fin n) .(i<n : toℕ i ℕ.< n) → fromℕ< i<n ≡ i
+fromℕ<-toℕ zero    _   = refl
+fromℕ<-toℕ (suc i) i<n = cong suc (fromℕ<-toℕ i (ℕ.s<s⁻¹ i<n))
 
-toℕ-fromℕ< : ∀ (m<n : m ℕ.< n) → toℕ (fromℕ< m<n) ≡ m
-toℕ-fromℕ< z<s               = refl
-toℕ-fromℕ< (s<s m<n@(s≤s _)) = cong suc (toℕ-fromℕ< m<n)
+toℕ-fromℕ< : ∀ .(m<n : m ℕ.< n) → toℕ (fromℕ< m<n) ≡ m
+toℕ-fromℕ< {m = zero}  {n = suc _} _   = refl
+toℕ-fromℕ< {m = suc m} {n = suc _} m<n = cong suc (toℕ-fromℕ< (ℕ.s<s⁻¹ m<n))
 
 -- fromℕ is a special case of fromℕ<.
-fromℕ-def : ∀ n → fromℕ n ≡ fromℕ< ℕₚ.≤-refl
+fromℕ-def : ∀ n → fromℕ n ≡ fromℕ< ℕ.≤-refl
 fromℕ-def zero    = refl
 fromℕ-def (suc n) = cong suc (fromℕ-def n)
 
-fromℕ<-cong : ∀ m n {o} → m ≡ n → (m<o : m ℕ.< o) (n<o : n ℕ.< o) →
+fromℕ<-cong : ∀ m n {o} → m ≡ n → .(m<o : m ℕ.< o) .(n<o : n ℕ.< o) →
               fromℕ< m<o ≡ fromℕ< n<o
-fromℕ<-cong 0       0       r z<s       z<s  = refl
-fromℕ<-cong (suc _) (suc _) r (s<s m<n) (s<s n<o)
-  = cong suc (fromℕ<-cong _ _ (ℕₚ.suc-injective r) m<n n<o)
+fromℕ<-cong 0       0                   _ _   _   = refl
+fromℕ<-cong (suc _) (suc _) {o = suc _} r m<n n<o
+  = cong suc (fromℕ<-cong _ _ (ℕ.suc-injective r) (ℕ.s<s⁻¹ m<n) (ℕ.s<s⁻¹ n<o))
 
-fromℕ<-injective : ∀ m n {o} → (m<o : m ℕ.< o) (n<o : n ℕ.< o) →
+fromℕ<-injective : ∀ m n {o} → .(m<o : m ℕ.< o) .(n<o : n ℕ.< o) →
                    fromℕ< m<o ≡ fromℕ< n<o → m ≡ n
-fromℕ<-injective 0       0       z<s               z<s r = refl
-fromℕ<-injective (suc _) (suc _) (s<s m<n@(s≤s _)) (s<s n<o@(s≤s _)) r
-  = cong suc (fromℕ<-injective _ _ m<n n<o (suc-injective r))
+fromℕ<-injective 0       0                   _   _   _  = refl
+fromℕ<-injective 0       (suc _) {o = suc _} _ _ ()
+fromℕ<-injective (suc _) (suc _) {o = suc _} m<n n<o r
+  = cong suc (fromℕ<-injective _ _ (ℕ.s<s⁻¹ m<n) (ℕ.s<s⁻¹ n<o) (suc-injective r))
 
 ------------------------------------------------------------------------
 -- fromℕ<″
@@ -234,14 +247,14 @@ fromℕ<-injective (suc _) (suc _) (s<s m<n@(s≤s _)) (s<s n<o@(s≤s _)) r
 
 fromℕ<≡fromℕ<″ : ∀ (m<n : m ℕ.< n) (m<″n : m ℕ.<″ n) →
                  fromℕ< m<n ≡ fromℕ<″ m m<″n
-fromℕ<≡fromℕ<″ z<s               (ℕ.less-than-or-equal refl) = refl
-fromℕ<≡fromℕ<″ (s<s m<n@(s≤s _)) (ℕ.less-than-or-equal refl) =
-  cong suc (fromℕ<≡fromℕ<″ m<n (ℕ.less-than-or-equal refl))
+fromℕ<≡fromℕ<″ {m = zero}  {n = suc _} _ _ = refl
+fromℕ<≡fromℕ<″ {m = suc m} {n = suc _} m<n m<″n
+  = cong suc (fromℕ<≡fromℕ<″ (ℕ.s<s⁻¹ m<n) (ℕ.s<″s⁻¹ m<″n))
 
 toℕ-fromℕ<″ : ∀ (m<n : m ℕ.<″ n) → toℕ (fromℕ<″ m m<n) ≡ m
 toℕ-fromℕ<″ {m} {n} m<n = begin
-  toℕ (fromℕ<″ m m<n)  ≡⟨ cong toℕ (sym (fromℕ<≡fromℕ<″ (ℕₚ.≤″⇒≤ m<n) m<n)) ⟩
-  toℕ (fromℕ< _)       ≡⟨ toℕ-fromℕ< (ℕₚ.≤″⇒≤ m<n) ⟩
+  toℕ (fromℕ<″ m m<n)  ≡⟨ cong toℕ (sym (fromℕ<≡fromℕ<″ (ℕ.≤″⇒≤ m<n) m<n)) ⟩
+  toℕ (fromℕ< _)       ≡⟨ toℕ-fromℕ< (ℕ.≤″⇒≤ m<n) ⟩
   m                    ∎
   where open ≡-Reasoning
 
@@ -255,16 +268,16 @@ toℕ-cast {n = suc n} eq (suc k) = cong suc (toℕ-cast (cong ℕ.pred eq) k)
 
 cast-is-id : .(eq : m ≡ m) (k : Fin m) → cast eq k ≡ k
 cast-is-id eq zero    = refl
-cast-is-id eq (suc k) = cong suc (cast-is-id (ℕₚ.suc-injective eq) k)
+cast-is-id eq (suc k) = cong suc (cast-is-id (ℕ.suc-injective eq) k)
 
 subst-is-cast : (eq : m ≡ n) (k : Fin m) → subst Fin eq k ≡ cast eq k
 subst-is-cast refl k = sym (cast-is-id refl k)
 
-cast-trans : .(eq₁ : m ≡ n) (eq₂ : n ≡ o) (k : Fin m) →
+cast-trans : .(eq₁ : m ≡ n) .(eq₂ : n ≡ o) (k : Fin m) →
              cast eq₂ (cast eq₁ k) ≡ cast (trans eq₁ eq₂) k
 cast-trans {m = suc _} {n = suc _} {o = suc _} eq₁ eq₂ zero = refl
 cast-trans {m = suc _} {n = suc _} {o = suc _} eq₁ eq₂ (suc k) =
-  cong suc (cast-trans (ℕₚ.suc-injective eq₁) (ℕₚ.suc-injective eq₂) k)
+  cong suc (cast-trans (ℕ.suc-injective eq₁) (ℕ.suc-injective eq₂) k)
 
 ------------------------------------------------------------------------
 -- Properties of _≤_
@@ -272,37 +285,37 @@ cast-trans {m = suc _} {n = suc _} {o = suc _} eq₁ eq₂ (suc k) =
 -- Relational properties
 
 ≤-reflexive : _≡_ ⇒ (_≤_ {n})
-≤-reflexive refl = ℕₚ.≤-refl
+≤-reflexive refl = ℕ.≤-refl
 
 ≤-refl : Reflexive (_≤_ {n})
 ≤-refl = ≤-reflexive refl
 
 ≤-trans : Transitive (_≤_ {n})
-≤-trans = ℕₚ.≤-trans
+≤-trans = ℕ.≤-trans
 
 ≤-antisym : Antisymmetric _≡_ (_≤_ {n})
-≤-antisym x≤y y≤x = toℕ-injective (ℕₚ.≤-antisym x≤y y≤x)
+≤-antisym x≤y y≤x = toℕ-injective (ℕ.≤-antisym x≤y y≤x)
 
 ≤-total : Total (_≤_ {n})
-≤-total x y = ℕₚ.≤-total (toℕ x) (toℕ y)
+≤-total x y = ℕ.≤-total (toℕ x) (toℕ y)
 
 ≤-irrelevant : Irrelevant (_≤_ {m} {n})
-≤-irrelevant = ℕₚ.≤-irrelevant
+≤-irrelevant = ℕ.≤-irrelevant
 
 infix 4 _≤?_ _<?_
 
 _≤?_ : B.Decidable (_≤_ {m} {n})
-a ≤? b = toℕ a ℕₚ.≤? toℕ b
+a ≤? b = toℕ a ℕ.≤? toℕ b
 
 _<?_ : B.Decidable (_<_ {m} {n})
-m <? n = suc (toℕ m) ℕₚ.≤? toℕ n
+m <? n = suc (toℕ m) ℕ.≤? toℕ n
 
 ------------------------------------------------------------------------
 -- Structures
 
 ≤-isPreorder : IsPreorder {A = Fin n} _≡_ _≤_
 ≤-isPreorder = record
-  { isEquivalence = P.isEquivalence
+  { isEquivalence = ≡.isEquivalence
   ; reflexive     = ≤-reflexive
   ; trans         = ≤-trans
   }
@@ -355,22 +368,22 @@ m <? n = suc (toℕ m) ℕₚ.≤? toℕ n
 -- Relational properties
 
 <-irrefl : Irreflexive _≡_ (_<_ {n})
-<-irrefl refl = ℕₚ.<-irrefl refl
+<-irrefl refl = ℕ.<-irrefl refl
 
 <-asym : Asymmetric (_<_ {n})
-<-asym = ℕₚ.<-asym
+<-asym = ℕ.<-asym
 
 <-trans : Transitive (_<_ {n})
-<-trans = ℕₚ.<-trans
+<-trans = ℕ.<-trans
 
 <-cmp : Trichotomous _≡_ (_<_ {n})
 <-cmp zero    zero    = tri≈ (λ()) refl  (λ())
 <-cmp zero    (suc j) = tri< z<s   (λ()) (λ())
 <-cmp (suc i) zero    = tri> (λ()) (λ()) z<s
 <-cmp (suc i) (suc j) with <-cmp i j
-... | tri< i<j i≢j j≮i = tri< (s<s i<j)         (i≢j ∘ suc-injective) (j≮i ∘ ℕₚ.≤-pred)
-... | tri> i≮j i≢j j<i = tri> (i≮j ∘ ℕₚ.≤-pred) (i≢j ∘ suc-injective) (s<s j<i)
-... | tri≈ i≮j i≡j j≮i = tri≈ (i≮j ∘ ℕₚ.≤-pred) (cong suc i≡j)        (j≮i ∘ ℕₚ.≤-pred)
+... | tri< i<j i≢j j≮i = tri< (s<s i<j)     (i≢j ∘ suc-injective) (j≮i ∘ s<s⁻¹)
+... | tri> i≮j i≢j j<i = tri> (i≮j ∘ s<s⁻¹) (i≢j ∘ suc-injective) (s<s j<i)
+... | tri≈ i≮j i≡j j≮i = tri≈ (i≮j ∘ s<s⁻¹) (cong suc i≡j)        (j≮i ∘ s<s⁻¹)
 
 <-respˡ-≡ : (_<_ {m} {n}) Respectsˡ _≡_
 <-respˡ-≡ refl x≤y = x≤y
@@ -382,14 +395,14 @@ m <? n = suc (toℕ m) ℕₚ.≤? toℕ n
 <-resp₂-≡ = <-respʳ-≡ , <-respˡ-≡
 
 <-irrelevant : Irrelevant (_<_ {m} {n})
-<-irrelevant = ℕₚ.<-irrelevant
+<-irrelevant = ℕ.<-irrelevant
 
 ------------------------------------------------------------------------
 -- Structures
 
 <-isStrictPartialOrder : IsStrictPartialOrder {A = Fin n} _≡_ _<_
 <-isStrictPartialOrder = record
-  { isEquivalence = P.isEquivalence
+  { isEquivalence = ≡.isEquivalence
   ; irrefl        = <-irrefl
   ; trans         = <-trans
   ; <-resp-≈      = <-resp₂-≡
@@ -397,9 +410,8 @@ m <? n = suc (toℕ m) ℕₚ.≤? toℕ n
 
 <-isStrictTotalOrder : IsStrictTotalOrder {A = Fin n} _≡_ _<_
 <-isStrictTotalOrder = record
-  { isEquivalence = P.isEquivalence
-  ; trans         = <-trans
-  ; compare       = <-cmp
+  { isStrictPartialOrder = <-isStrictPartialOrder
+  ; compare              = <-cmp
   }
 
 ------------------------------------------------------------------------
@@ -419,16 +431,16 @@ m <? n = suc (toℕ m) ℕₚ.≤? toℕ n
 -- Other properties
 
 i<1+i : ∀ (i : Fin n) → i < suc i
-i<1+i = ℕₚ.n<1+n ∘ toℕ
+i<1+i = ℕ.n<1+n ∘ toℕ
 
 <⇒≢ : i < j → i ≢ j
-<⇒≢ i<i refl = ℕₚ.n≮n _ i<i
+<⇒≢ i<i refl = ℕ.n≮n _ i<i
 
 ≤∧≢⇒< : i ≤ j → i ≢ j → i < j
-≤∧≢⇒< {i = zero}  {zero}  _         0≢0     = contradiction refl 0≢0
-≤∧≢⇒< {i = zero}  {suc j} _         _       = z<s
-≤∧≢⇒< {i = suc i} {suc j} (s≤s i≤j) 1+i≢1+j =
-  s<s (≤∧≢⇒< i≤j (1+i≢1+j ∘ (cong suc)))
+≤∧≢⇒< {i = zero}  {zero}  _         0≢0   = contradiction refl 0≢0
+≤∧≢⇒< {i = zero}  {suc j} _         _     = z<s
+≤∧≢⇒< {i = suc i} {suc j} 1+i≤1+j 1+i≢1+j =
+  s<s (≤∧≢⇒< (ℕ.s≤s⁻¹ 1+i≤1+j) (1+i≢1+j ∘ (cong suc)))
 
 ------------------------------------------------------------------------
 -- inject
@@ -442,6 +454,9 @@ toℕ-inject {i = suc i} (suc j) = cong suc (toℕ-inject j)
 -- inject₁
 ------------------------------------------------------------------------
 
+fromℕ≢inject₁ : fromℕ n ≢ inject₁ i
+fromℕ≢inject₁ {i = suc i} eq = fromℕ≢inject₁ {i = i} (suc-injective eq)
+
 inject₁-injective : inject₁ i ≡ inject₁ j → i ≡ j
 inject₁-injective {i = zero}  {zero}  i≡j = refl
 inject₁-injective {i = suc i} {suc j} i≡j =
@@ -452,23 +467,23 @@ toℕ-inject₁ zero    = refl
 toℕ-inject₁ (suc i) = cong suc (toℕ-inject₁ i)
 
 toℕ-inject₁-≢ : ∀ (i : Fin n) → n ≢ toℕ (inject₁ i)
-toℕ-inject₁-≢ (suc i) = toℕ-inject₁-≢ i ∘ ℕₚ.suc-injective
+toℕ-inject₁-≢ (suc i) = toℕ-inject₁-≢ i ∘ ℕ.suc-injective
 
 inject₁ℕ< : ∀ (i : Fin n) → toℕ (inject₁ i) ℕ.< n
 inject₁ℕ< i rewrite toℕ-inject₁ i = toℕ<n i
 
 inject₁ℕ≤ : ∀ (i : Fin n) → toℕ (inject₁ i) ℕ.≤ n
-inject₁ℕ≤ = ℕₚ.<⇒≤ ∘ inject₁ℕ<
+inject₁ℕ≤ = ℕ.<⇒≤ ∘ inject₁ℕ<
 
 ≤̄⇒inject₁< : i ≤ j → inject₁ i < suc j
 ≤̄⇒inject₁< {i = i} i≤j rewrite sym (toℕ-inject₁ i) = s<s i≤j
 
 ℕ<⇒inject₁< : ∀ {i : Fin (ℕ.suc n)} {j : Fin n} → j < i → inject₁ j < i
-ℕ<⇒inject₁< {i = suc i} (s≤s j≤i) = ≤̄⇒inject₁< j≤i
+ℕ<⇒inject₁< {i = suc i} j≤i = ≤̄⇒inject₁< (ℕ.s≤s⁻¹ j≤i)
 
 i≤inject₁[j]⇒i≤1+j : i ≤ inject₁ j → i ≤ suc j
-i≤inject₁[j]⇒i≤1+j {i = zero} i≤j = z≤n
-i≤inject₁[j]⇒i≤1+j {i = suc i} {j = suc j} (s≤s i≤j) = s≤s (ℕₚ.m≤n⇒m≤1+n (subst (toℕ i ℕ.≤_) (toℕ-inject₁ j) i≤j))
+i≤inject₁[j]⇒i≤1+j {i = zero}              _   = z≤n
+i≤inject₁[j]⇒i≤1+j {i = suc i} {j = suc j} i≤j = s≤s (ℕ.m≤n⇒m≤1+n (subst (toℕ i ℕ.≤_) (toℕ-inject₁ j) (ℕ.s≤s⁻¹ i≤j)))
 
 ------------------------------------------------------------------------
 -- lower₁
@@ -481,8 +496,8 @@ toℕ-lower₁ {ℕ.suc m} (suc i) p = cong ℕ.suc (toℕ-lower₁ i (p ∘ con
 
 lower₁-injective : ∀ {n≢i : n ≢ toℕ i} {n≢j : n ≢ toℕ j} →
                    lower₁ i n≢i ≡ lower₁ j n≢j → i ≡ j
-lower₁-injective {zero}  {zero}  {_}     {n≢i} {_}   _    = ⊥-elim (n≢i refl)
-lower₁-injective {zero}  {_}     {zero}  {_}   {n≢j} _    = ⊥-elim (n≢j refl)
+lower₁-injective {zero}  {zero}  {_}     {n≢i} {_}   _    = contradiction refl n≢i
+lower₁-injective {zero}  {_}     {zero}  {_}   {n≢j} _    = contradiction refl n≢j
 lower₁-injective {suc n} {zero}  {zero}  {_}   {_}   refl = refl
 lower₁-injective {suc n} {suc i} {suc j} {n≢i} {n≢j} eq   =
   cong suc (lower₁-injective (suc-injective eq))
@@ -522,26 +537,34 @@ inject₁≡⇒lower₁≡ n≢j i≡j = inject₁-injective (trans (inject₁-l
 -- inject≤
 ------------------------------------------------------------------------
 
-toℕ-inject≤ : ∀ i (m≤n : m ℕ.≤ n) → toℕ (inject≤ i m≤n) ≡ toℕ i
-toℕ-inject≤ {_} {suc n} zero    _         = refl
-toℕ-inject≤ {_} {suc n} (suc i) (s≤s m≤n) = cong suc (toℕ-inject≤ i m≤n)
+toℕ-inject≤ : ∀ i .(m≤n : m ℕ.≤ n) → toℕ (inject≤ i m≤n) ≡ toℕ i
+toℕ-inject≤ {_} {suc n} zero    _ = refl
+toℕ-inject≤ {_} {suc n} (suc i) _ = cong suc (toℕ-inject≤ i _)
 
-inject≤-refl : ∀ i (n≤n : n ℕ.≤ n) → inject≤ i n≤n ≡ i
-inject≤-refl {suc n} zero    _         = refl
-inject≤-refl {suc n} (suc i) (s≤s n≤n) = cong suc (inject≤-refl i n≤n)
+inject≤-refl : ∀ i .(n≤n : n ℕ.≤ n) → inject≤ i n≤n ≡ i
+inject≤-refl {suc n} zero    _   = refl
+inject≤-refl {suc n} (suc i) _ = cong suc (inject≤-refl i _)
 
 inject≤-idempotent : ∀ (i : Fin m)
-                     (m≤n : m ℕ.≤ n) (n≤o : n ℕ.≤ o) (m≤o : m ℕ.≤ o) →
+                     .(m≤n : m ℕ.≤ n) .(n≤o : n ℕ.≤ o) .(m≤o : m ℕ.≤ o) →
                      inject≤ (inject≤ i m≤n) n≤o ≡ inject≤ i m≤o
-inject≤-idempotent {_} {suc n} {suc o} zero    _   _   _ = refl
-inject≤-idempotent {_} {suc n} {suc o} (suc i) (s≤s m≤n) (s≤s n≤o) (s≤s m≤o) =
-  cong suc (inject≤-idempotent i m≤n n≤o m≤o)
+inject≤-idempotent {_} {suc n} {suc o} zero    _ _ _ = refl
+inject≤-idempotent {_} {suc n} {suc o} (suc i) _ _ _ =
+  cong suc (inject≤-idempotent i _ _ _)
+
+inject≤-trans : ∀ (i : Fin m) .(m≤n : m ℕ.≤ n) .(n≤o : n ℕ.≤ o) →
+                inject≤ (inject≤ i m≤n) n≤o ≡ inject≤ i (ℕ.≤-trans m≤n n≤o)
+inject≤-trans i _ _ = inject≤-idempotent i _ _ _
 
-inject≤-injective : ∀ (m≤n m≤n′ : m ℕ.≤ n) i j →
+inject≤-injective : ∀ .(m≤n m≤n′ : m ℕ.≤ n) i j →
                     inject≤ i m≤n ≡ inject≤ j m≤n′ → i ≡ j
-inject≤-injective (s≤s p) (s≤s q) zero    zero    eq = refl
-inject≤-injective (s≤s p) (s≤s q) (suc i) (suc j) eq =
-  cong suc (inject≤-injective p q i j (suc-injective eq))
+inject≤-injective {n = suc _} _ _ zero    zero    eq = refl
+inject≤-injective {n = suc _} _ _ (suc i) (suc j) eq =
+  cong suc (inject≤-injective _ _ i j (suc-injective eq))
+
+inject≤-irrelevant : ∀ .(m≤n m≤n′ : m ℕ.≤ n) i →
+                    inject≤ i m≤n ≡ inject≤ i m≤n′
+inject≤-irrelevant _ _ i = refl
 
 ------------------------------------------------------------------------
 -- pred
@@ -549,7 +572,7 @@ inject≤-injective (s≤s p) (s≤s q) (suc i) (suc j) eq =
 
 pred< : ∀ (i : Fin (suc n)) → i ≢ zero → pred i < i
 pred< zero    i≢0 = contradiction refl i≢0
-pred< (suc i) _   = ≤̄⇒inject₁< ℕₚ.≤-refl
+pred< (suc i) _   = ≤̄⇒inject₁< ℕ.≤-refl
 
 ------------------------------------------------------------------------
 -- splitAt
@@ -561,10 +584,24 @@ splitAt-↑ˡ : ∀ m i n → splitAt m (i ↑ˡ n) ≡ inj₁ i
 splitAt-↑ˡ (suc m) zero    n = refl
 splitAt-↑ˡ (suc m) (suc i) n rewrite splitAt-↑ˡ m i n = refl
 
+splitAt⁻¹-↑ˡ : ∀ {m} {n} {i} {j} → splitAt m {n} i ≡ inj₁ j → j ↑ˡ n ≡ i
+splitAt⁻¹-↑ˡ {suc m} {n} {0F} {.0F} refl = refl
+splitAt⁻¹-↑ˡ {suc m} {n} {suc i} {j} eq
+  with inj₁ k ← splitAt m i in splitAt[m][i]≡inj₁[j]
+  with refl ← eq
+  = cong suc (splitAt⁻¹-↑ˡ {i = i} {j = k} splitAt[m][i]≡inj₁[j])
+
 splitAt-↑ʳ : ∀ m n i → splitAt m (m ↑ʳ i) ≡ inj₂ {B = Fin n} i
 splitAt-↑ʳ zero    n i = refl
 splitAt-↑ʳ (suc m) n i rewrite splitAt-↑ʳ m n i = refl
 
+splitAt⁻¹-↑ʳ : ∀ {m} {n} {i} {j} → splitAt m {n} i ≡ inj₂ j → m ↑ʳ j ≡ i
+splitAt⁻¹-↑ʳ {zero}  {n} {i} {j} refl = refl
+splitAt⁻¹-↑ʳ {suc m} {n} {suc i} {j} eq
+  with inj₂ k ← splitAt m i in splitAt[m][i]≡inj₂[k]
+  with refl ← eq
+  = cong suc (splitAt⁻¹-↑ʳ {i = i} {j = k} splitAt[m][i]≡inj₂[k])
+
 splitAt-join : ∀ m n i → splitAt m (join m n i) ≡ i
 splitAt-join m n (inj₁ x) = splitAt-↑ˡ m x n
 splitAt-join m n (inj₂ y) = splitAt-↑ʳ m n y
@@ -574,30 +611,30 @@ join-splitAt zero    n i       = refl
 join-splitAt (suc m) n zero    = refl
 join-splitAt (suc m) n (suc i) = begin
   [ _↑ˡ n , (suc m) ↑ʳ_ ]′ (splitAt (suc m) (suc i)) ≡⟨ [,]-map (splitAt m i) ⟩
-  [ suc ∘ (_↑ˡ n) , suc ∘ (m ↑ʳ_) ]′ (splitAt m i)   ≡˘⟨ [,]-∘ suc (splitAt m i) ⟩
+  [ suc ∘ (_↑ˡ n) , suc ∘ (m ↑ʳ_) ]′ (splitAt m i)   ≡⟨ [,]-∘ suc (splitAt m i) ⟨
   suc ([ _↑ˡ n , m ↑ʳ_ ]′ (splitAt m i))             ≡⟨ cong suc (join-splitAt m n i) ⟩
   suc i                                                         ∎
   where open ≡-Reasoning
 
 -- splitAt "m" "i" ≡ inj₁ "i" if i < m
 
-splitAt-< : ∀ m {n} (i : Fin (m ℕ.+ n)) (i<m : toℕ i ℕ.< m) →
+splitAt-< : ∀ m {n} (i : Fin (m ℕ.+ n)) .(i<m : toℕ i ℕ.< m) →
             splitAt m i ≡ inj₁ (fromℕ< i<m)
-splitAt-< (suc m) zero    z<s               = refl
-splitAt-< (suc m) (suc i) (s<s i<m) = cong (Sum.map suc id) (splitAt-< m i i<m)
+splitAt-< (suc m) zero    _   = refl
+splitAt-< (suc m) (suc i) i<m = cong (Sum.map suc id) (splitAt-< m i (ℕ.s<s⁻¹ i<m))
 
 -- splitAt "m" "i" ≡ inj₂ "i - m" if i ≥ m
 
-splitAt-≥ : ∀ m {n} (i : Fin (m ℕ.+ n)) (i≥m : toℕ i ℕ.≥ m) →
+splitAt-≥ : ∀ m {n} (i : Fin (m ℕ.+ n)) .(i≥m : toℕ i ℕ.≥ m) →
             splitAt m i ≡ inj₂ (reduce≥ i i≥m)
-splitAt-≥ zero    i       _         = refl
-splitAt-≥ (suc m) (suc i) (s≤s i≥m) = cong (Sum.map suc id) (splitAt-≥ m i i≥m)
+splitAt-≥ zero    i       _   = refl
+splitAt-≥ (suc m) (suc i) i≥m = cong (Sum.map suc id) (splitAt-≥ m i (ℕ.s≤s⁻¹ i≥m))
 
 ------------------------------------------------------------------------
 -- Bundles
 
 +↔⊎ : Fin (m ℕ.+ n) ↔ (Fin m ⊎ Fin n)
-+↔⊎ {m} {n} = mk↔′ (splitAt m {n}) (join m n) (splitAt-join m n) (join-splitAt m n)
++↔⊎ {m} {n} = mk↔ₛ′ (splitAt m {n}) (join m n) (splitAt-join m n) (join-splitAt m n)
 
 ------------------------------------------------------------------------
 -- remQuot
@@ -608,18 +645,18 @@ splitAt-≥ (suc m) (suc i) (s≤s i≥m) = cong (Sum.map suc id) (splitAt-≥ m
 remQuot-combine : ∀ {n k} (i : Fin n) j → remQuot k (combine i j) ≡ (i , j)
 remQuot-combine {suc n} {k} zero    j rewrite splitAt-↑ˡ k j (n ℕ.* k) = refl
 remQuot-combine {suc n} {k} (suc i) j rewrite splitAt-↑ʳ k   (n ℕ.* k) (combine i j) =
-  cong (Data.Product.map₁ suc) (remQuot-combine i j)
+  cong (Product.map₁ suc) (remQuot-combine i j)
 
 combine-remQuot : ∀ {n} k (i : Fin (n ℕ.* k)) → uncurry combine (remQuot {n} k i) ≡ i
-combine-remQuot {suc n} k i with splitAt k i | P.inspect (splitAt k) i
-... | inj₁ j | P.[ eq ] = begin
-  join k (n ℕ.* k) (inj₁ j)      ≡˘⟨ cong (join k (n ℕ.* k)) eq ⟩
+combine-remQuot {suc n} k i with splitAt k i in eq
+... | inj₁ j = begin
+  join k (n ℕ.* k) (inj₁ j)      ≡⟨ cong (join k (n ℕ.* k)) eq ⟨
   join k (n ℕ.* k) (splitAt k i) ≡⟨ join-splitAt k (n ℕ.* k) i ⟩
   i                              ∎
   where open ≡-Reasoning
-... | inj₂ j | P.[ eq ] = begin
+... | inj₂ j = begin
   k ↑ʳ (uncurry combine (remQuot {n} k j)) ≡⟨ cong (k ↑ʳ_) (combine-remQuot {n} k j) ⟩
-  join k (n ℕ.* k) (inj₂ j)                ≡˘⟨ cong (join k (n ℕ.* k)) eq ⟩
+  join k (n ℕ.* k) (inj₂ j)                ≡⟨ cong (join k (n ℕ.* k)) eq ⟨
   join k (n ℕ.* k) (splitAt k i)           ≡⟨ join-splitAt k (n ℕ.* k) i ⟩
   i                                        ∎
   where open ≡-Reasoning
@@ -629,30 +666,32 @@ toℕ-combine {suc m} {n} i@0F j = begin
   toℕ (combine i j)          ≡⟨⟩
   toℕ (j ↑ˡ (m ℕ.* n))       ≡⟨ toℕ-↑ˡ j (m ℕ.* n) ⟩
   toℕ j                      ≡⟨⟩
-  0 ℕ.+ toℕ j                ≡˘⟨ cong (ℕ._+ toℕ j) (ℕₚ.*-zeroʳ n) ⟩
+  0 ℕ.+ toℕ j                ≡⟨ cong (ℕ._+ toℕ j) (ℕ.*-zeroʳ n) ⟨
   n ℕ.* toℕ i ℕ.+ toℕ j      ∎
   where open ≡-Reasoning
 toℕ-combine {suc m} {n} (suc i) j = begin
-  toℕ (combine (suc i) j)        ≡⟨⟩
-  toℕ (n ↑ʳ combine i j)         ≡⟨ toℕ-↑ʳ n (combine i j) ⟩
-  n ℕ.+ toℕ (combine i j)        ≡⟨ cong (n ℕ.+_) (toℕ-combine i j) ⟩
-  n ℕ.+ (n ℕ.* toℕ i ℕ.+ toℕ j)  ≡⟨ solve 3 (λ n i j → n :+ (n :* i :+ j) := n :* (con 1 :+ i) :+ j) refl n (toℕ i) (toℕ j) ⟩
-  n ℕ.* toℕ (suc i) ℕ.+ toℕ j    ∎
-  where open ≡-Reasoning; open +-*-Solver
+  toℕ (combine (suc i) j)            ≡⟨⟩
+  toℕ (n ↑ʳ combine i j)             ≡⟨ toℕ-↑ʳ n (combine i j) ⟩
+  n ℕ.+ toℕ (combine i j)            ≡⟨ cong (n ℕ.+_) (toℕ-combine i j) ⟩
+  n ℕ.+ (n ℕ.* toℕ i ℕ.+ toℕ j)     ≡⟨ ℕ.+-assoc n _ (toℕ j) ⟨
+  n ℕ.+ n ℕ.* toℕ i ℕ.+ toℕ j       ≡⟨ cong (λ z → z ℕ.+ n ℕ.* toℕ i ℕ.+ toℕ j) (ℕ.*-identityʳ n) ⟨
+  n ℕ.* 1 ℕ.+ n ℕ.* toℕ i ℕ.+ toℕ j ≡⟨ cong (ℕ._+ toℕ j) (ℕ.*-distribˡ-+ n 1 (toℕ i) ) ⟨
+  n ℕ.* toℕ (suc i) ℕ.+ toℕ j       ∎
+  where open ≡-Reasoning
 
 combine-monoˡ-< : ∀ {i j : Fin m} (k l : Fin n) →
                   i < j → combine i k < combine j l
 combine-monoˡ-< {m} {n} {i} {j} k l i<j = begin-strict
   toℕ (combine i k)      ≡⟨ toℕ-combine i k ⟩
-  n ℕ.* toℕ i ℕ.+ toℕ k  <⟨ ℕₚ.+-monoʳ-< (n ℕ.* toℕ i) (toℕ<n k) ⟩
-  n ℕ.* toℕ i ℕ.+ n      ≡⟨ ℕₚ.+-comm _ n ⟩
-  n ℕ.+ n ℕ.* toℕ i      ≡⟨ cong (n ℕ.+_) (ℕₚ.*-comm n _) ⟩
-  n ℕ.+ toℕ i ℕ.* n      ≡⟨ ℕₚ.*-comm (suc (toℕ i)) n ⟩
-  n ℕ.* suc (toℕ i)      ≤⟨ ℕₚ.*-monoʳ-≤ n (toℕ-mono-< i<j) ⟩
-  n ℕ.* toℕ j            ≤⟨ ℕₚ.m≤m+n (n ℕ.* toℕ j) (toℕ l) ⟩
-  n ℕ.* toℕ j ℕ.+ toℕ l  ≡˘⟨ toℕ-combine j l ⟩
+  n ℕ.* toℕ i ℕ.+ toℕ k  <⟨ ℕ.+-monoʳ-< (n ℕ.* toℕ i) (toℕ<n k) ⟩
+  n ℕ.* toℕ i ℕ.+ n      ≡⟨ ℕ.+-comm _ n ⟩
+  n ℕ.+ n ℕ.* toℕ i      ≡⟨ cong (n ℕ.+_) (ℕ.*-comm n _) ⟩
+  n ℕ.+ toℕ i ℕ.* n      ≡⟨ ℕ.*-comm (suc (toℕ i)) n ⟩
+  n ℕ.* suc (toℕ i)      ≤⟨ ℕ.*-monoʳ-≤ n (toℕ-mono-< i<j) ⟩
+  n ℕ.* toℕ j            ≤⟨ ℕ.m≤m+n (n ℕ.* toℕ j) (toℕ l) ⟩
+  n ℕ.* toℕ j ℕ.+ toℕ l  ≡⟨ toℕ-combine j l ⟨
   toℕ (combine j l)      ∎
-  where open ℕₚ.≤-Reasoning; open +-*-Solver
+  where open ℕ.≤-Reasoning
 
 combine-injectiveˡ : ∀ (i : Fin m) (j : Fin n) (k : Fin m) (l : Fin n) →
                      combine i j ≡ combine k l → i ≡ k
@@ -663,9 +702,10 @@ combine-injectiveˡ i j k l cᵢⱼ≡cₖₗ with <-cmp i k
 
 combine-injectiveʳ : ∀ (i : Fin m) (j : Fin n) (k : Fin m) (l : Fin n) →
                      combine i j ≡ combine k l → j ≡ l
-combine-injectiveʳ {m} {n} i j k l cᵢⱼ≡cₖₗ with combine-injectiveˡ i j k l cᵢⱼ≡cₖₗ
-... | refl = toℕ-injective (ℕₚ.+-cancelˡ-≡ (n ℕ.* toℕ i) _ _ (begin
-  n ℕ.* toℕ i ℕ.+ toℕ j ≡˘⟨ toℕ-combine i j ⟩
+combine-injectiveʳ {m} {n} i j k l cᵢⱼ≡cₖₗ
+  with refl ← combine-injectiveˡ i j k l cᵢⱼ≡cₖₗ
+  = toℕ-injective (ℕ.+-cancelˡ-≡ (n ℕ.* toℕ i) _ _ (begin
+  n ℕ.* toℕ i ℕ.+ toℕ j ≡⟨ toℕ-combine i j ⟨
   toℕ (combine i j)     ≡⟨ cong toℕ cᵢⱼ≡cₖₗ ⟩
   toℕ (combine i l)     ≡⟨ toℕ-combine i l ⟩
   n ℕ.* toℕ i ℕ.+ toℕ l ∎))
@@ -678,9 +718,9 @@ combine-injective i j k l cᵢⱼ≡cₖₗ =
   combine-injectiveʳ i j k l cᵢⱼ≡cₖₗ
 
 combine-surjective : ∀ (i : Fin (m ℕ.* n)) → ∃₂ λ j k → combine j k ≡ i
-combine-surjective {m} {n} i with remQuot {m} n i | P.inspect (remQuot {m} n) i
-... | j , k | P.[ eq ] = j , k , (begin
-  combine j k                       ≡˘⟨ uncurry (cong₂ combine) (,-injective eq) ⟩
+combine-surjective {m} {n} i with j , k ← remQuot {m} n i in eq
+  = j , k , (begin
+  combine j k                       ≡⟨ uncurry (cong₂ combine) (,-injective eq) ⟨
   uncurry combine (remQuot {m} n i) ≡⟨ combine-remQuot {m} n i ⟩
   i                                 ∎)
   where open ≡-Reasoning
@@ -689,7 +729,7 @@ combine-surjective {m} {n} i with remQuot {m} n i | P.inspect (remQuot {m} n) i
 -- Bundles
 
 *↔× : Fin (m ℕ.* n) ↔ (Fin m × Fin n)
-*↔× {m} {n} = mk↔′ (remQuot {m} n) (uncurry combine)
+*↔× {m} {n} = mk↔ₛ′ (remQuot {m} n) (uncurry combine)
   (uncurry remQuot-combine)
   (combine-remQuot {m} n)
 
@@ -740,7 +780,7 @@ finToFun-funToFin {suc m} {n} f (suc i) =
 -- Bundles
 
 ^↔→ : Extensionality _ _ → Fin (m ^ n) ↔ (Fin n → Fin m)
-^↔→ {m} {n} ext = mk↔′ finToFun funToFin
+^↔→ {m} {n} ext = mk↔ₛ′ finToFun funToFin
   (ext ∘ finToFun-funToFin)
   (funToFin-finToFin {n} {m})
 
@@ -780,12 +820,12 @@ toℕ‿ℕ- (suc n) (suc i)  = toℕ‿ℕ- n i
 ℕ-ℕ≡toℕ‿ℕ- (suc n) (suc i) = ℕ-ℕ≡toℕ‿ℕ- n i
 
 nℕ-ℕi≤n : ∀ n i → n ℕ-ℕ i ℕ.≤ n
-nℕ-ℕi≤n n       zero     = ℕₚ.≤-refl
+nℕ-ℕi≤n n       zero     = ℕ.≤-refl
 nℕ-ℕi≤n (suc n) (suc i)  = begin
   n ℕ-ℕ i  ≤⟨ nℕ-ℕi≤n n i ⟩
-  n        ≤⟨ ℕₚ.n≤1+n n ⟩
+  n        ≤⟨ ℕ.n≤1+n n ⟩
   suc n    ∎
-  where open ℕₚ.≤-Reasoning
+  where open ℕ.≤-Reasoning
 
 ------------------------------------------------------------------------
 -- punchIn
@@ -801,22 +841,13 @@ punchIn-injective (suc i) (suc j) (suc k) ↑j+1≡↑k+1 =
 punchInᵢ≢i : ∀ i (j : Fin n) → punchIn i j ≢ i
 punchInᵢ≢i (suc i) (suc j) = punchInᵢ≢i i j ∘ suc-injective
 
-punchIn-mono-≤ : ∀ i (j k : Fin n) → j ≤ k → punchIn i j ≤ punchIn i k
-punchIn-mono-≤ zero    _        _      j≤k       = s≤s j≤k
-punchIn-mono-≤ (suc _) zero    _       z≤n       = z≤n
-punchIn-mono-≤ (suc i) (suc j) (suc k) (s≤s j≤k) = s≤s (punchIn-mono-≤ i j k j≤k)
-
-punchIn-cancel-≤ : ∀ i (j k : Fin n) → punchIn i j ≤ punchIn i k → j ≤ k
-punchIn-cancel-≤ zero    _       _       (s≤s j≤k)   = j≤k
-punchIn-cancel-≤ (suc _) zero    _       z≤n         = z≤n
-punchIn-cancel-≤ (suc i) (suc j) (suc k) (s≤s ↑j≤↑k) = s≤s (punchIn-cancel-≤ i j k ↑j≤↑k)
-
 ------------------------------------------------------------------------
 -- punchOut
 ------------------------------------------------------------------------
 
--- A version of 'cong' for 'punchOut' in which the inequality argument can be
--- changed out arbitrarily (reflecting the proof-irrelevance of that argument).
+-- A version of 'cong' for 'punchOut' in which the inequality argument
+-- can be changed out arbitrarily (reflecting the proof-irrelevance of
+-- that argument).
 
 punchOut-cong : ∀ (i : Fin (suc n)) {j k} {i≢j : i ≢ j} {i≢k : i ≢ k} →
                 j ≡ k → punchOut i≢j ≡ punchOut i≢k
@@ -826,9 +857,9 @@ punchOut-cong {_}     zero    {suc j} {suc k}            = suc-injective
 punchOut-cong {suc n} (suc i) {zero}  {zero}   _ = refl
 punchOut-cong {suc n} (suc i) {suc j} {suc k}    = cong suc ∘ punchOut-cong i ∘ suc-injective
 
--- An alternative to 'punchOut-cong' in the which the new inequality argument is
--- specific. Useful for enabling the omission of that argument during equational
--- reasoning.
+-- An alternative to 'punchOut-cong' in the which the new inequality
+-- argument is specific. Useful for enabling the omission of that
+-- argument during equational reasoning.
 
 punchOut-cong′ : ∀ (i : Fin (suc n)) {j k} {p : i ≢ j} (q : j ≡ k) →
                  punchOut p ≡ punchOut (p ∘ sym ∘ trans q ∘ sym)
@@ -844,22 +875,6 @@ punchOut-injective {suc n} {suc i}  {zero}  {zero}  _   _    _    = refl
 punchOut-injective {suc n} {suc i}  {suc j} {suc k} i≢j i≢k pⱼ≡pₖ =
   cong suc (punchOut-injective (i≢j ∘ cong suc) (i≢k ∘ cong suc) (suc-injective pⱼ≡pₖ))
 
-punchOut-mono-≤ : ∀ {i j k : Fin (suc n)} (i≢j : i ≢ j) (i≢k : i ≢ k) →
-                  j ≤ k → punchOut i≢j ≤ punchOut i≢k
-punchOut-mono-≤ {_    } {zero } {zero } {_    } 0≢0 _   z≤n       = contradiction refl 0≢0
-punchOut-mono-≤ {_    } {zero } {suc _} {suc _} _   _   (s≤s j≤k) = j≤k
-punchOut-mono-≤ {suc _} {suc _} {zero } {_    } _   _   z≤n       = z≤n
-punchOut-mono-≤ {suc _} {suc _} {suc _} {suc _} i≢j i≢k (s≤s j≤k) = s≤s (punchOut-mono-≤ (i≢j ∘ cong suc) (i≢k ∘ cong suc) j≤k)
-
-punchOut-cancel-≤ : ∀ {i j k : Fin (suc n)} (i≢j : i ≢ j) (i≢k : i ≢ k) →
-                    punchOut i≢j ≤ punchOut i≢k → j ≤ k
-punchOut-cancel-≤ {_    } {zero } {zero } {_    } 0≢0 _   _           = contradiction refl 0≢0
-punchOut-cancel-≤ {_    } {zero } {suc _} {zero } _   0≢0 _           = contradiction refl 0≢0
-punchOut-cancel-≤ {suc _} {zero } {suc _} {suc _} _   _   pⱼ≤pₖ       = s≤s pⱼ≤pₖ
-punchOut-cancel-≤ {_    } {suc _} {zero } {_    } _   _   _           = z≤n
-punchOut-cancel-≤ {suc _} {suc _} {suc _} {zero } _   _   ()
-punchOut-cancel-≤ {suc _} {suc _} {suc _} {suc _} i≢j i≢k (s≤s pⱼ≤pₖ) = s≤s (punchOut-cancel-≤ (i≢j ∘ cong suc) (i≢k ∘ cong suc) pⱼ≤pₖ)
-
 punchIn-punchOut : ∀ {i j : Fin (suc n)} (i≢j : i ≢ j) →
                    punchIn i (punchOut i≢j) ≡ j
 punchIn-punchOut {_}     {zero}   {zero}  0≢0 = contradiction refl 0≢0
@@ -882,16 +897,16 @@ punchOut-punchIn (suc i) {suc j} = cong suc (begin
 -- pinch
 ------------------------------------------------------------------------
 
-pinch-surjective : ∀ (i : Fin n) → Surjective _≡_ (pinch i)
-pinch-surjective _       zero    = zero , refl
-pinch-surjective zero    (suc j) = suc (suc j) , refl
-pinch-surjective (suc i) (suc j) = map suc (cong suc) (pinch-surjective i j)
+pinch-surjective : ∀ (i : Fin n) → Surjective _≡_ _≡_ (pinch i)
+pinch-surjective _       zero    = zero , λ { refl → refl }
+pinch-surjective zero    (suc j) = suc (suc j) , λ { refl → refl }
+pinch-surjective (suc i) (suc j) = map suc (λ {f refl → cong suc (f refl)}) (pinch-surjective i j)
 
 pinch-mono-≤ : ∀ (i : Fin n) → (pinch i) Preserves _≤_ ⟶ _≤_
-pinch-mono-≤ 0F      {0F}    {k}     0≤n       = z≤n
-pinch-mono-≤ 0F      {suc j} {suc k} (s≤s j≤k) = j≤k
-pinch-mono-≤ (suc i) {0F}    {k}     0≤n       = z≤n
-pinch-mono-≤ (suc i) {suc j} {suc k} (s≤s j≤k) = s≤s (pinch-mono-≤ i j≤k)
+pinch-mono-≤ 0F      {0F}    {k}     0≤n = z≤n
+pinch-mono-≤ 0F      {suc j} {suc k} j≤k = ℕ.s≤s⁻¹ j≤k
+pinch-mono-≤ (suc i) {0F}    {k}     0≤n = z≤n
+pinch-mono-≤ (suc i) {suc j} {suc k} j≤k = s≤s (pinch-mono-≤ i (ℕ.s≤s⁻¹ j≤k))
 
 pinch-injective : ∀ {i : Fin n} {j k : Fin (ℕ.suc n)} →
                   suc i ≢ j → suc i ≢ k → pinch i j ≡ pinch i k → j ≡ k
@@ -960,8 +975,8 @@ private
   -- The boolean component of the result is exactly the
   -- obvious fold of boolean tests (`foldr _∧_ true`).
   note : ∀ {p} {P : Pred (Fin 3) p} (P? : Decidable P) →
-         ∃ λ z → does (all? P?) ≡ z
-  note P? = does (P? 0F) ∧ does (P? 1F) ∧ does (P? 2F) ∧ true
+         ∃ λ z → Dec.does (all? P?) ≡ z
+  note P? = Dec.does (P? 0F) ∧ Dec.does (P? 1F) ∧ Dec.does (P? 2F) ∧ true
           , refl
 
 -- If a decidable predicate P over a finite set is sometimes false,
@@ -992,24 +1007,23 @@ pigeonhole : m ℕ.< n → (f : Fin n → Fin m) → ∃₂ λ i j → i < j ×
 pigeonhole z<s               f = contradiction (f zero) λ()
 pigeonhole (s<s m<n@(s≤s _)) f with any? (λ k → f zero ≟ f (suc k))
 ... | yes (j , f₀≡fⱼ) = zero , suc j , z<s , f₀≡fⱼ
-... | no  f₀≢fₖ with pigeonhole m<n (λ j → punchOut (f₀≢fₖ ∘ (j ,_ )))
-...   | (i , j , i<j , fᵢ≡fⱼ) =
-  suc i , suc j , s<s i<j ,
-  punchOut-injective (f₀≢fₖ ∘ (i ,_)) _ fᵢ≡fⱼ
+... | no  f₀≢fₖ
+  with i , j , i<j , fᵢ≡fⱼ ← pigeonhole m<n (λ j → punchOut (f₀≢fₖ ∘ (j ,_ )))
+  = suc i , suc j , s<s i<j , punchOut-injective (f₀≢fₖ ∘ (i ,_)) _ fᵢ≡fⱼ
 
 injective⇒≤ : ∀ {f : Fin m → Fin n} → Injective _≡_ _≡_ f → m ℕ.≤ n
 injective⇒≤ {zero}  {_}     {f} _   = z≤n
 injective⇒≤ {suc _} {zero}  {f} _   = contradiction (f zero) ¬Fin0
 injective⇒≤ {suc _} {suc _} {f} inj = s≤s (injective⇒≤ (λ eq →
   suc-injective (inj (punchOut-injective
-    (contraInjective _≡_ _≡_ inj 0≢1+n)
-    (contraInjective _≡_ _≡_ inj 0≢1+n) eq))))
+    (contraInjective inj 0≢1+n)
+    (contraInjective inj 0≢1+n) eq))))
 
 <⇒notInjective : ∀ {f : Fin m → Fin n} → n ℕ.< m → ¬ (Injective _≡_ _≡_ f)
-<⇒notInjective n<m inj = ℕₚ.≤⇒≯ (injective⇒≤ inj) n<m
+<⇒notInjective n<m inj = ℕ.≤⇒≯ (injective⇒≤ inj) n<m
 
 ℕ→Fin-notInjective : ∀ (f : ℕ → Fin n) → ¬ (Injective _≡_ _≡_ f)
-ℕ→Fin-notInjective f inj = ℕₚ.<-irrefl refl
+ℕ→Fin-notInjective f inj = ℕ.<-irrefl refl
   (injective⇒≤ (Comp.injective _≡_ _≡_ _≡_ toℕ-injective inj))
 
 -- Cantor-Schröder-Bernstein for finite sets
@@ -1017,7 +1031,7 @@ injective⇒≤ {suc _} {suc _} {f} inj = s≤s (injective⇒≤ (λ eq →
 cantor-schröder-bernstein : ∀ {f : Fin m → Fin n} {g : Fin n → Fin m} →
                             Injective _≡_ _≡_ f → Injective _≡_ _≡_ g →
                             m ≡ n
-cantor-schröder-bernstein f-inj g-inj = ℕₚ.≤-antisym
+cantor-schröder-bernstein f-inj g-inj = ℕ.≤-antisym
   (injective⇒≤ f-inj) (injective⇒≤ g-inj)
 
 ------------------------------------------------------------------------
@@ -1075,7 +1089,7 @@ opposite-involutive : Involutive {A = Fin n} _≡_ opposite
 opposite-involutive {suc n} i = toℕ-injective (begin
   toℕ (opposite (opposite i)) ≡⟨ opposite-prop (opposite i) ⟩
   n ∸ (toℕ (opposite i))      ≡⟨ cong (n ∸_) (opposite-prop i) ⟩
-  n ∸ (n ∸ (toℕ i))           ≡⟨ ℕₚ.m∸[m∸n]≡n (toℕ≤pred[n] i) ⟩
+  n ∸ (n ∸ (toℕ i))           ≡⟨ ℕ.m∸[m∸n]≡n (toℕ≤pred[n] i) ⟩
   toℕ i                       ∎)
   where open ≡-Reasoning
 
@@ -1084,7 +1098,7 @@ opposite-suc {n} i = begin
   toℕ (opposite (suc i))     ≡⟨ opposite-prop (suc i) ⟩
   suc n ∸ suc (toℕ (suc i))  ≡⟨⟩
   n ∸ toℕ (suc i)            ≡⟨⟩
-  n ∸ suc (toℕ i)            ≡⟨ sym (opposite-prop i) ⟩
+  n ∸ suc (toℕ i)            ≡⟨ opposite-prop i ⟨
   toℕ (opposite i)           ∎
   where open ≡-Reasoning
 
@@ -1161,16 +1175,15 @@ private
   ≺⇒< (n ≻toℕ i) = toℕ<n i
 
 ≺⇒<′ : _≺_ ⇒ ℕ._<′_
-≺⇒<′ lt = ℕₚ.<⇒<′ (≺⇒< lt)
+≺⇒<′ lt = ℕ.<⇒<′ (≺⇒< lt)
 {-# WARNING_ON_USAGE ≺⇒<′
 "Warning: ≺⇒<′ was deprecated in v2.0.
 Please use <⇒<′ instead."
 #-}
 
 <′⇒≺ : ℕ._<′_ ⇒ _≺_
-<′⇒≺ lt = <⇒≺ (ℕₚ.<′⇒< lt)
+<′⇒≺ lt = <⇒≺ (ℕ.<′⇒< lt)
 {-# WARNING_ON_USAGE <′⇒≺
 "Warning: <′⇒≺ was deprecated in v2.0.
 Please use <′⇒< instead."
 #-}
-
diff --git a/src/Data/Fin/Relation/Unary/Top.agda b/src/Data/Fin/Relation/Unary/Top.agda
new file mode 100644
index 0000000000..a884a09243
--- /dev/null
+++ b/src/Data/Fin/Relation/Unary/Top.agda
@@ -0,0 +1,81 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- The 'top' view of Fin.
+--
+-- This is an example of a view of (elements of) a datatype,
+-- here i : Fin (suc n), which exhibits every such i as
+-- * either, i = fromℕ n
+-- * or, i = inject₁ j for a unique j : Fin n
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Fin.Relation.Unary.Top where
+
+open import Data.Nat.Base using (ℕ; zero; suc)
+open import Data.Fin.Base using (Fin; zero; suc; fromℕ; inject₁)
+open import Relation.Binary.PropositionalEquality.Core
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
+
+private
+  variable
+    n : ℕ
+    i : Fin n
+
+------------------------------------------------------------------------
+-- The View, considered as a unary relation on Fin n
+
+-- NB `Data.Fin.Properties.fromℕ≢inject₁` establishes that the following
+-- inductively defined family on `Fin n` has constructors which target
+-- *disjoint* instances of the family (moreover at indices `n = suc _`);
+-- hence the interpretations of the View constructors will also be disjoint.
+
+data View : (i : Fin n) → Set where
+  ‵fromℕ : View (fromℕ n)
+  ‵inj₁ : View i → View (inject₁ i)
+
+pattern ‵inject₁ i = ‵inj₁ {i = i} _
+
+-- The view covering function, witnessing soundness of the view
+
+view : (i : Fin n) → View i
+view zero = view-zero where
+  view-zero : View (zero {n})
+  view-zero {n = zero}  = ‵fromℕ
+  view-zero {n = suc _} = ‵inj₁ view-zero
+view (suc i) with view i
+... | ‵fromℕ     = ‵fromℕ
+... | ‵inject₁ i = ‵inj₁ (view (suc i))
+
+-- Interpretation of the view constructors
+
+⟦_⟧ : {i : Fin n} → View i → Fin n
+⟦ ‵fromℕ ⟧     = fromℕ _
+⟦ ‵inject₁ i ⟧ = inject₁ i
+
+-- Completeness of the view
+
+view-complete : (v : View i) → ⟦ v ⟧ ≡ i
+view-complete ‵fromℕ    = refl
+view-complete (‵inj₁ _) = refl
+
+-- 'Computational' behaviour of the covering function
+
+view-fromℕ : ∀ n → view (fromℕ n) ≡ ‵fromℕ
+view-fromℕ zero                         = refl
+view-fromℕ (suc n) rewrite view-fromℕ n = refl
+
+view-inject₁ : (i : Fin n) → view (inject₁ i) ≡ ‵inj₁ (view i)
+view-inject₁ zero                           = refl
+view-inject₁ (suc i) rewrite view-inject₁ i = refl
+
+-- Uniqueness of the view
+
+view-unique : (v : View i) → view i ≡ v
+view-unique ‵fromℕ            = view-fromℕ _
+view-unique (‵inj₁ {i = i} v) = begin
+  view (inject₁ i) ≡⟨ view-inject₁ i ⟩
+  ‵inj₁ (view i)   ≡⟨ cong ‵inj₁ (view-unique v) ⟩
+  ‵inj₁ v          ∎ where open ≡-Reasoning
diff --git a/src/Data/Fin/Show.agda b/src/Data/Fin/Show.agda
index 360cc8b1fc..8f9ae0583b 100644
--- a/src/Data/Fin/Show.agda
+++ b/src/Data/Fin/Show.agda
@@ -11,7 +11,7 @@ module Data.Fin.Show where
 open import Data.Fin.Base using (Fin; toℕ; fromℕ<)
 open import Data.Maybe.Base using (Maybe; nothing; just; _>>=_)
 open import Data.Nat as ℕ using (ℕ; _≤?_; _<?_)
-import Data.Nat.Show as ℕ
+import Data.Nat.Show as ℕ using (show; readMaybe)
 open import Data.String.Base using (String)
 open import Function.Base
 open import Relation.Nullary.Decidable using (yes; no)
diff --git a/src/Data/Fin/Subset.agda b/src/Data/Fin/Subset.agda
index 01926df438..2e44f69762 100644
--- a/src/Data/Fin/Subset.agda
+++ b/src/Data/Fin/Subset.agda
@@ -13,7 +13,7 @@ open import Data.Bool using (not; _∧_; _∨_; _≟_)
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.List.Base using (List; foldr; foldl)
 open import Data.Nat.Base using (ℕ)
-open import Data.Product using (∃; _×_)
+open import Data.Product.Base using (∃; _×_)
 open import Data.Vec.Base hiding (foldr; foldl)
 open import Relation.Nullary
 
@@ -43,11 +43,11 @@ Subset = Vec Side
 
 -- The empty subset
 ⊥ : Subset n
-⊥ = replicate outside
+⊥ = replicate _ outside
 
 -- The full subset
 ⊤ : Subset n
-⊤ = replicate inside
+⊤ = replicate _ inside
 
 -- A singleton subset, containing just the given element.
 ⁅_⁆ : Fin n → Subset n
diff --git a/src/Data/Fin/Subset/Properties.agda b/src/Data/Fin/Subset/Properties.agda
index 1cc8bd19f9..03467dcee7 100644
--- a/src/Data/Fin/Subset/Properties.agda
+++ b/src/Data/Fin/Subset/Properties.agda
@@ -11,8 +11,10 @@ module Data.Fin.Subset.Properties where
 import Algebra.Definitions as AlgebraicDefinitions
 import Algebra.Structures as AlgebraicStructures
 import Algebra.Lattice.Structures as AlgebraicLatticeStructures
-open import Algebra.Bundles
-open import Algebra.Lattice.Bundles
+open import Algebra.Bundles using (Magma; Semigroup; Monoid; Band;
+  CommutativeMonoid; IdempotentCommutativeMonoid)
+open import Algebra.Lattice.Bundles using (Semilattice; Lattice;
+  DistributiveLattice; BooleanAlgebra)
 import Algebra.Lattice.Properties.Lattice as L
 import Algebra.Lattice.Properties.DistributiveLattice as DL
 import Algebra.Lattice.Properties.BooleanAlgebra as BA
@@ -22,16 +24,24 @@ open import Data.Fin.Base using (Fin; suc; zero)
 open import Data.Fin.Subset
 open import Data.Fin.Properties using (any?; decFinSubset)
 open import Data.Nat.Base hiding (∣_-_∣)
-import Data.Nat.Properties as ℕₚ
+import Data.Nat.Properties as ℕ
 open import Data.Product as Product using (∃; ∄; _×_; _,_; proj₁)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_]′)
-open import Data.Vec.Base
+open import Data.Vec.Base using (Vec; []; _∷_; here; there)
 open import Data.Vec.Properties
 open import Function.Base using (_∘_; const; id; case_of_)
 open import Function.Bundles using (_⇔_; mk⇔)
 open import Level using (Level)
-open import Relation.Binary as B hiding (Decidable; _⇔_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsStrictPartialOrder; IsDecStrictPartialOrder)
+open import Relation.Binary.Bundles
+  using (Preorder; Poset; StrictPartialOrder; DecStrictPartialOrder)
+open import Relation.Binary.Definitions as B hiding (Decidable; Empty)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂; subst; _≢_; sym)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning; isEquivalence)
 open import Relation.Nullary.Decidable as Dec using (Dec; yes; no; _⊎-dec_)
 open import Relation.Nullary.Negation using (contradiction)
 open import Relation.Unary using (Pred; Decidable; Satisfiable)
@@ -129,8 +139,8 @@ nonempty? p = any? (_∈? p)
 ∣p∣≤n = count≤n (_≟ inside)
 
 ∣p∣≤∣x∷p∣ : ∀ x (p : Subset n)  → ∣ p ∣ ≤ ∣ x ∷ p ∣
-∣p∣≤∣x∷p∣ outside p = ℕₚ.≤-refl
-∣p∣≤∣x∷p∣ inside  p = ℕₚ.n≤1+n ∣ p ∣
+∣p∣≤∣x∷p∣ outside p = ℕ.≤-refl
+∣p∣≤∣x∷p∣ inside  p = ℕ.n≤1+n ∣ p ∣
 
 ------------------------------------------------------------------------
 -- ⊥
@@ -161,8 +171,8 @@ nonempty? p = any? (_∈? p)
 
 ∣p∣≡n⇒p≡⊤ : ∣ p ∣ ≡ n → p ≡ ⊤ {n}
 ∣p∣≡n⇒p≡⊤ {p = []}          _     = refl
-∣p∣≡n⇒p≡⊤ {p = outside ∷ p} |p|≡n = contradiction |p|≡n (ℕₚ.<⇒≢ (s≤s (∣p∣≤n p)))
-∣p∣≡n⇒p≡⊤ {p = inside  ∷ p} |p|≡n = cong (inside ∷_) (∣p∣≡n⇒p≡⊤ (ℕₚ.suc-injective |p|≡n))
+∣p∣≡n⇒p≡⊤ {p = outside ∷ p} |p|≡n = contradiction |p|≡n (ℕ.<⇒≢ (s≤s (∣p∣≤n p)))
+∣p∣≡n⇒p≡⊤ {p = inside  ∷ p} |p|≡n = cong (inside ∷_) (∣p∣≡n⇒p≡⊤ (ℕ.suc-injective |p|≡n))
 
 ------------------------------------------------------------------------
 -- ⁅_⁆
@@ -252,7 +262,7 @@ module _ (n : ℕ) where
 p⊆q⇒∣p∣≤∣q∣ : p ⊆ q → ∣ p ∣ ≤ ∣ q ∣
 p⊆q⇒∣p∣≤∣q∣ {p = []}          {[]}          p⊆q = z≤n
 p⊆q⇒∣p∣≤∣q∣ {p = outside ∷ p} {outside ∷ q} p⊆q = p⊆q⇒∣p∣≤∣q∣ (drop-∷-⊆ p⊆q)
-p⊆q⇒∣p∣≤∣q∣ {p = outside ∷ p} {inside  ∷ q} p⊆q = ℕₚ.m≤n⇒m≤1+n (p⊆q⇒∣p∣≤∣q∣ (drop-∷-⊆ p⊆q))
+p⊆q⇒∣p∣≤∣q∣ {p = outside ∷ p} {inside  ∷ q} p⊆q = ℕ.m≤n⇒m≤1+n (p⊆q⇒∣p∣≤∣q∣ (drop-∷-⊆ p⊆q))
 p⊆q⇒∣p∣≤∣q∣ {p = inside  ∷ p} {outside ∷ q} p⊆q = contradiction (p⊆q here) λ()
 p⊆q⇒∣p∣≤∣q∣ {p = inside  ∷ p} {inside  ∷ q} p⊆q = s≤s (p⊆q⇒∣p∣≤∣q∣ (drop-∷-⊆ p⊆q))
 
@@ -353,7 +363,7 @@ p∪∁p≡⊤ (inside  ∷ p) = cong (inside ∷_) (p∪∁p≡⊤ p)
 ∣∁p∣≡n∸∣p∣ (inside  ∷ p) = ∣∁p∣≡n∸∣p∣ p
 ∣∁p∣≡n∸∣p∣ (outside ∷ p) = begin
   suc ∣ ∁ p ∣     ≡⟨ cong suc (∣∁p∣≡n∸∣p∣ p) ⟩
-  suc (_ ∸ ∣ p ∣) ≡⟨ sym (ℕₚ.+-∸-assoc 1 (∣p∣≤n p)) ⟩
+  suc (_ ∸ ∣ p ∣) ≡⟨ sym (ℕ.+-∸-assoc 1 (∣p∣≤n p)) ⟩
   suc  _ ∸ ∣ p ∣  ∎
   where open ≡-Reasoning
 
@@ -510,7 +520,7 @@ x∈p∩q⁻ (s      ∷ p) (t      ∷ q) (there x∈p∩q) =
 ∣p∩q∣≤∣q∣ p q = p⊆q⇒∣p∣≤∣q∣ (p∩q⊆q p q)
 
 ∣p∩q∣≤∣p∣⊓∣q∣ : ∀ (p q : Subset n) → ∣ p ∩ q ∣ ≤ ∣ p ∣ ⊓ ∣ q ∣
-∣p∩q∣≤∣p∣⊓∣q∣ p q = ℕₚ.⊓-glb (∣p∩q∣≤∣p∣ p q) (∣p∩q∣≤∣q∣ p q)
+∣p∩q∣≤∣p∣⊓∣q∣ p q = ℕ.⊓-glb (∣p∩q∣≤∣p∣ p q) (∣p∩q∣≤∣q∣ p q)
 
 ------------------------------------------------------------------------
 -- _∪_
@@ -748,7 +758,7 @@ x∈p∪q⁺ (inj₂ x∈q) = q⊆p∪q _ _ x∈q
 ∣q∣≤∣p∪q∣ p q = p⊆q⇒∣p∣≤∣q∣ (q⊆p∪q p q)
 
 ∣p∣⊔∣q∣≤∣p∪q∣ : ∀ (p q : Subset n) → ∣ p ∣ ⊔ ∣ q ∣ ≤ ∣ p ∪ q ∣
-∣p∣⊔∣q∣≤∣p∪q∣ p q = ℕₚ.⊔-lub (∣p∣≤∣p∪q∣ p q) (∣q∣≤∣p∪q∣ p q)
+∣p∣⊔∣q∣≤∣p∪q∣ p q = ℕ.⊔-lub (∣p∣≤∣p∪q∣ p q) (∣q∣≤∣p∪q∣ p q)
 
 ------------------------------------------------------------------------
 -- Properties of _─_
@@ -779,7 +789,7 @@ p─q─r≡p─r─q : ∀ (p q r : Subset n) → p ─ q ─ r ≡ p ─ r ─
 p─q─r≡p─r─q p q r = begin
   (p ─ q) ─ r  ≡⟨  p─q─r≡p─q∪r p q r ⟩
   p ─ (q ∪ r)  ≡⟨  cong (p ─_) (∪-comm q r) ⟩
-  p ─ (r ∪ q)  ≡˘⟨ p─q─r≡p─q∪r p r q ⟩
+  p ─ (r ∪ q)  ≡⟨ p─q─r≡p─q∪r p r q ⟨
   (p ─ r) ─ q  ∎
   where open ≡-Reasoning
 
diff --git a/src/Data/Fin/Substitution.agda b/src/Data/Fin/Substitution.agda
index 18769dde37..84a4484715 100644
--- a/src/Data/Fin/Substitution.agda
+++ b/src/Data/Fin/Substitution.agda
@@ -4,12 +4,12 @@
 -- Substitutions
 ------------------------------------------------------------------------
 
--- Uses a variant of Conor McBride's technique from "Type-Preserving
--- Renaming and Substitution".
+-- Uses a variant of Conor McBride's technique from his paper
+-- "Type-Preserving Renaming and Substitution".
 
--- See Data.Fin.Substitution.Example for an example of how this module
--- can be used: a definition of substitution for the untyped
--- λ-calculus.
+-- See README.Data.Fin.Substitution.UntypedLambda for an example
+-- of how this module can be used: a definition of substitution for
+-- the untyped λ-calculus.
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
@@ -24,23 +24,29 @@ open import Relation.Binary.Construct.Closure.ReflexiveTransitive
 open import Level using (Level; _⊔_; 0ℓ)
 open import Relation.Unary using (Pred)
 
+private
+  variable
+    ℓ ℓ₁ ℓ₂ : Level
+    k m n o : ℕ
+
+
 ------------------------------------------------------------------------
 -- General functionality
 
 -- A Sub T m n is a substitution which, when applied to something with
 -- at most m variables, yields something with at most n variables.
 
-Sub : ∀ {ℓ} → Pred ℕ ℓ → ℕ → ℕ → Set ℓ
+Sub : Pred ℕ ℓ → ℕ → ℕ → Set ℓ
 Sub T m n = Vec (T n) m
 
 -- A /reversed/ sequence of matching substitutions.
 
-Subs : ∀ {ℓ} → Pred ℕ ℓ → ℕ → ℕ → Set ℓ
+Subs : Pred ℕ ℓ → ℕ → ℕ → Set ℓ
 Subs T = flip (Star (flip (Sub T)))
 
 -- Some simple substitutions.
 
-record Simple {ℓ : Level} (T : Pred ℕ ℓ) : Set ℓ where
+record Simple (T : Pred ℕ ℓ) : Set ℓ where
   infix  10 _↑
   infixl 10 _↑⋆_ _↑✶_
 
@@ -50,40 +56,39 @@ record Simple {ℓ : Level} (T : Pred ℕ ℓ) : Set ℓ where
 
   -- Lifting.
 
-  _↑ : ∀ {m n} → Sub T m n → Sub T (suc m) (suc n)
+  _↑ : Sub T m n → Sub T (suc m) (suc n)
   ρ ↑ = var zero ∷ map weaken ρ
 
-  _↑⋆_ : ∀ {m n} → Sub T m n → ∀ k → Sub T (k + m) (k + n)
+  _↑⋆_ : Sub T m n → ∀ k → Sub T (k + m) (k + n)
   ρ ↑⋆ zero  = ρ
   ρ ↑⋆ suc k = (ρ ↑⋆ k) ↑
 
-  _↑✶_ : ∀ {m n} → Subs T m n → ∀ k → Subs T (k + m) (k + n)
+  _↑✶_ : Subs T m n → ∀ k → Subs T (k + m) (k + n)
   ρs ↑✶ k = Star.gmap (_+_ k) (λ ρ → ρ ↑⋆ k) ρs
 
   -- The identity substitution.
 
-  id : ∀ {n} → Sub T n n
+  id : Sub T n n
   id {zero}  = []
   id {suc n} = id ↑
 
   -- Weakening.
 
-  wk⋆ : ∀ k {n} → Sub T n (k + n)
+  wk⋆ : ∀ k → Sub T n (k + n)
   wk⋆ zero    = id
   wk⋆ (suc k) = map weaken (wk⋆ k)
 
-  wk : ∀ {n} → Sub T n (suc n)
+  wk : Sub T n (suc n)
   wk = wk⋆ 1
 
   -- A substitution which only replaces the first variable.
 
-  sub : ∀ {n} → T n → Sub T (suc n) n
+  sub : T n → Sub T (suc n) n
   sub t = t ∷ id
 
 -- Application of substitutions.
 
-record Application {ℓ₁ ℓ₂ : Level} (T₁ : Pred ℕ ℓ₁) (T₂ : Pred ℕ ℓ₂) :
-    Set (ℓ₁ ⊔ ℓ₂) where
+record Application (T₁ : Pred ℕ ℓ₁) (T₂ : Pred ℕ ℓ₂) : Set (ℓ₁ ⊔ ℓ₂) where
   infixl 8 _/_ _/✶_
   infixl 9 _⊙_
 
@@ -93,17 +98,17 @@ record Application {ℓ₁ ℓ₂ : Level} (T₁ : Pred ℕ ℓ₁) (T₂ : Pred
 
   -- Reverse composition. (Fits well with post-application.)
 
-  _⊙_ : ∀ {m n k} → Sub T₁ m n → Sub T₂ n k → Sub T₁ m k
-  ρ₁ ⊙ ρ₂ = map (λ t → t / ρ₂) ρ₁
+  _⊙_ : Sub T₁ m n → Sub T₂ n o → Sub T₁ m o
+  ρ₁ ⊙ ρ₂ = map (_/ ρ₂) ρ₁
 
   -- Application of multiple substitutions.
 
-  _/✶_ : ∀ {m n} → T₁ m → Subs T₂ m n → T₁ n
+  _/✶_ : T₁ m → Subs T₂ m n → T₁ n
   _/✶_ = Star.gfold Fun.id _ (flip _/_) {k = zero}
 
 -- A combination of the two records above.
 
-record Subst {ℓ : Level} (T : Pred ℕ ℓ) : Set ℓ where
+record Subst (T : Pred ℕ ℓ) : Set ℓ where
   field
     simple      : Simple      T
     application : Application T T
@@ -113,7 +118,7 @@ record Subst {ℓ : Level} (T : Pred ℕ ℓ) : Set ℓ where
 
   -- Composition of multiple substitutions.
 
-  ⨀ : ∀ {m n} → Subs T m n → Sub T m n
+  ⨀ : Subs T m n → Sub T m n
   ⨀ ε        = id
   ⨀ (ρ ◅ ε)  = ρ  -- Convenient optimisation; simplifies some proofs.
   ⨀ (ρ ◅ ρs) = ⨀ ρs ⊙ ρ
@@ -123,8 +128,7 @@ record Subst {ℓ : Level} (T : Pred ℕ ℓ) : Set ℓ where
 
 -- Liftings from T₁ to T₂.
 
-record Lift {ℓ₁ ℓ₂ : Level} (T₁ : Pred ℕ ℓ₁) (T₂ : Pred ℕ ℓ₂) :
-    Set (ℓ₁ ⊔ ℓ₂) where
+record Lift (T₁ : Pred ℕ ℓ₁) (T₂ : Pred ℕ ℓ₂) : Set (ℓ₁ ⊔ ℓ₂) where
   field
     simple : Simple T₁
     lift   : ∀ {n} → T₁ n → T₂ n
@@ -160,9 +164,9 @@ record TermSubst (T : Pred ℕ 0ℓ) : Set₁ where
   varLift : Lift Fin T
   varLift = record { simple = VarSubst.simple; lift = var }
 
-  infix 8 _/Var_
+  infixl 8 _/Var_
 
-  _/Var_ : ∀ {m n} → T m → Sub Fin m n → T n
+  _/Var_ : T m → Sub Fin m n → T n
   _/Var_ = app varLift
 
   simple : Simple T
diff --git a/src/Data/Fin/Substitution/Example.agda b/src/Data/Fin/Substitution/Example.agda
index f4b42438e5..7ac3061b11 100644
--- a/src/Data/Fin/Substitution/Example.agda
+++ b/src/Data/Fin/Substitution/Example.agda
@@ -1,22 +1,28 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- An example of how Data.Fin.Substitution can be used: a definition
--- of substitution for the untyped λ-calculus, along with some lemmas
+-- This module is DEPRECATED. Please see
+-- `README.Data.Nat.Fin.Substitution.UntypedLambda` instead.
+--
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Data.Fin.Substitution.Example where
 
+{-# WARNING_ON_IMPORT
+"Data.Fin.Substitution.Example was deprecated in v2.0.
+Please see README.Data.Fin.Substitution.UntypedLambda instead."
+#-}
+
 open import Data.Fin.Substitution
 open import Data.Fin.Substitution.Lemmas
 open import Data.Nat.Base hiding (_/_)
 open import Data.Fin.Base using (Fin)
 open import Data.Vec.Base
-open import Relation.Binary.PropositionalEquality as PropEq
-  using (_≡_; refl; sym; cong; cong₂)
-open PropEq.≡-Reasoning
+open import Relation.Binary.PropositionalEquality
+  using (_≡_; refl; sym; cong; cong₂; module ≡-Reasoning)
+open ≡-Reasoning
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive
   using (Star; ε; _◅_)
 
diff --git a/src/Data/Fin/Substitution/Lemmas.agda b/src/Data/Fin/Substitution/Lemmas.agda
index 018ed86f29..9dedec0ebb 100644
--- a/src/Data/Fin/Substitution/Lemmas.agda
+++ b/src/Data/Fin/Substitution/Lemmas.agda
@@ -8,40 +8,48 @@
 
 module Data.Fin.Substitution.Lemmas where
 
-import Effect.Applicative.Indexed as Applicative
 open import Data.Fin.Substitution
-open import Data.Nat hiding (_⊔_; _/_)
+open import Data.Nat.Base using (ℕ; zero; suc; _+_)
 open import Data.Fin.Base using (Fin; zero; suc; lift)
-open import Data.Vec.Base
-import Data.Vec.Properties as VecProp
-open import Function as Fun using (_∘_; _$_)
-open import Relation.Binary.PropositionalEquality as PropEq
+open import Data.Vec.Base using (lookup; []; _∷_; map)
+import Data.Vec.Properties as Vec
+open import Function.Base as Fun using (_∘_; _$_; flip)
+open import Level using (Level; _⊔_)
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; refl; sym; cong; cong₂)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive
   using (Star; ε; _◅_; _▻_)
-open PropEq.≡-Reasoning
-open import Level using (Level; _⊔_)
+open ≡-Reasoning
 open import Relation.Unary using (Pred)
 
+private
+  variable
+    ℓ ℓ₁ ℓ₂ : Level
+    m n o p : ℕ
+
+------------------------------------------------------------------------
 -- A lemma which does not refer to any substitutions.
 
-lift-commutes : ∀ {n} k j (x : Fin (j + (k + n))) →
+lift-commutes : ∀ k j (x : Fin (j + (k + n))) →
                 lift j suc (lift j (lift k suc) x) ≡
                 lift j (lift (suc k) suc) (lift j suc x)
 lift-commutes k zero    x       = refl
 lift-commutes k (suc j) zero    = refl
 lift-commutes k (suc j) (suc x) = cong suc (lift-commutes k j x)
 
+------------------------------------------------------------------------
 -- The modules below prove a number of substitution lemmas, on the
 -- assumption that the underlying substitution machinery satisfies
 -- certain properties.
 
-record Lemmas₀ {ℓ : Level} (T : Pred ℕ ℓ) : Set ℓ where
+record Lemmas₀ (T : Pred ℕ ℓ) : Set ℓ where
   field simple : Simple T
 
   open Simple simple
 
-  extensionality : ∀ {m n} {ρ₁ ρ₂ : Sub T m n} →
+  extensionality : {ρ₁ ρ₂ : Sub T m n} →
                    (∀ x → lookup ρ₁ x ≡ lookup ρ₂ x) → ρ₁ ≡ ρ₂
   extensionality {ρ₁ = []}      {[]}       hyp = refl
   extensionality {ρ₁ = t₁ ∷ ρ₁} { t₂ ∷ ρ₂} hyp with hyp zero
@@ -54,18 +62,18 @@ record Lemmas₀ {ℓ : Level} (T : Pred ℕ ℓ) : Set ℓ where
     (id ↑⋆ k) ↑ ≡⟨ cong _↑ (id-↑⋆ k) ⟩
     id        ↑ ∎
 
-  lookup-map-weaken-↑⋆ : ∀ {m n} k x {ρ : Sub T m n} →
+  lookup-map-weaken-↑⋆ : ∀ k x {ρ : Sub T m n} →
                          lookup (map weaken ρ ↑⋆ k) x ≡
                          lookup ((ρ ↑) ↑⋆ k) (lift k suc x)
   lookup-map-weaken-↑⋆ zero    x           = refl
   lookup-map-weaken-↑⋆ (suc k) zero        = refl
   lookup-map-weaken-↑⋆ (suc k) (suc x) {ρ} = begin
-    lookup (map weaken (map weaken ρ ↑⋆ k)) x        ≡⟨ VecProp.lookup-map x weaken (map weaken ρ ↑⋆ k) ⟩
+    lookup (map weaken (map weaken ρ ↑⋆ k)) x        ≡⟨ Vec.lookup-map x weaken (map weaken ρ ↑⋆ k) ⟩
     weaken (lookup (map weaken ρ ↑⋆ k) x)            ≡⟨ cong weaken (lookup-map-weaken-↑⋆ k x) ⟩
-    weaken (lookup ((ρ ↑) ↑⋆ k) (lift k suc x))      ≡⟨ sym $ VecProp.lookup-map (lift k suc x) weaken ((ρ ↑) ↑⋆ k) ⟩
+    weaken (lookup ((ρ ↑) ↑⋆ k) (lift k suc x))      ≡⟨ sym $ Vec.lookup-map (lift k suc x) weaken ((ρ ↑) ↑⋆ k) ⟩
     lookup (map weaken ((ρ ↑) ↑⋆ k)) (lift k suc x)  ∎
 
-record Lemmas₁ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
+record Lemmas₁ (T : Pred ℕ ℓ) : Set ℓ where
   field lemmas₀ : Lemmas₀ T
 
   open Lemmas₀ lemmas₀
@@ -73,25 +81,25 @@ record Lemmas₁ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
 
   field weaken-var : ∀ {n} {x : Fin n} → weaken (var x) ≡ var (suc x)
 
-  lookup-map-weaken : ∀ {m n} x {y} {ρ : Sub T m n} →
+  lookup-map-weaken : ∀ x {y} {ρ : Sub T m n} →
                       lookup             ρ  x ≡ var      y →
                       lookup (map weaken ρ) x ≡ var (suc y)
   lookup-map-weaken x {y} {ρ} hyp = begin
-    lookup (map weaken ρ) x  ≡⟨ VecProp.lookup-map x weaken ρ ⟩
+    lookup (map weaken ρ) x  ≡⟨ Vec.lookup-map x weaken ρ ⟩
     weaken (lookup ρ x)      ≡⟨ cong weaken hyp ⟩
     weaken (var y)           ≡⟨ weaken-var ⟩
     var (suc y)              ∎
 
   mutual
 
-    lookup-id : ∀ {n} (x : Fin n) → lookup id x ≡ var x
+    lookup-id : (x : Fin n) → lookup id x ≡ var x
     lookup-id zero    = refl
     lookup-id (suc x) = lookup-wk x
 
-    lookup-wk : ∀ {n} (x : Fin n) → lookup wk x ≡ var (suc x)
+    lookup-wk : (x : Fin n) → lookup wk x ≡ var (suc x)
     lookup-wk x = lookup-map-weaken x {ρ = id} (lookup-id x)
 
-  lookup-↑⋆ : ∀ {m n} (f : Fin m → Fin n) {ρ : Sub T m n} →
+  lookup-↑⋆ : (f : Fin m → Fin n) {ρ : Sub T m n} →
               (∀ x → lookup ρ x ≡ var (f x)) →
               ∀ k x → lookup (ρ ↑⋆ k) x ≡ var (lift k f x)
   lookup-↑⋆ f         hyp zero    x       = hyp x
@@ -99,7 +107,7 @@ record Lemmas₁ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
   lookup-↑⋆ f {ρ = ρ} hyp (suc k) (suc x) =
     lookup-map-weaken x {ρ = ρ ↑⋆ k} (lookup-↑⋆ f hyp k x)
 
-  lookup-lift-↑⋆ : ∀ {m n} (f : Fin n → Fin m) {ρ : Sub T m n} →
+  lookup-lift-↑⋆ : (f : Fin n → Fin m) {ρ : Sub T m n} →
                    (∀ x → lookup ρ (f x) ≡ var x) →
                    ∀ k x → lookup (ρ ↑⋆ k) (lift k f x) ≡ var x
   lookup-lift-↑⋆ f         hyp zero    x       = hyp x
@@ -107,22 +115,22 @@ record Lemmas₁ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
   lookup-lift-↑⋆ f {ρ = ρ} hyp (suc k) (suc x) =
     lookup-map-weaken (lift k f x) {ρ = ρ ↑⋆ k} (lookup-lift-↑⋆ f hyp k x)
 
-  lookup-wk-↑⋆ : ∀ {n} k (x : Fin (k + n)) →
+  lookup-wk-↑⋆ : ∀ k (x : Fin (k + n)) →
                  lookup (wk ↑⋆ k) x ≡ var (lift k suc x)
   lookup-wk-↑⋆ = lookup-↑⋆ suc lookup-wk
 
-  lookup-wk-↑⋆-↑⋆ : ∀ {n} k j (x : Fin (j + (k + n))) →
+  lookup-wk-↑⋆-↑⋆ : ∀ k j (x : Fin (j + (k + n))) →
                     lookup (wk ↑⋆ k ↑⋆ j) x ≡
                     var (lift j (lift k suc) x)
   lookup-wk-↑⋆-↑⋆ k = lookup-↑⋆ (lift k suc) (lookup-wk-↑⋆ k)
 
-  lookup-sub-↑⋆ : ∀ {n t} k (x : Fin (k + n)) →
+  lookup-sub-↑⋆ : ∀ {t} k (x : Fin (k + n)) →
                   lookup (sub t ↑⋆ k) (lift k suc x) ≡ var x
   lookup-sub-↑⋆ = lookup-lift-↑⋆ suc lookup-id
 
   open Lemmas₀ lemmas₀ public
 
-record Lemmas₂ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
+record Lemmas₂ (T : Pred ℕ ℓ) : Set ℓ where
   field
     lemmas₁     : Lemmas₁ T
     application : Application T T
@@ -136,18 +144,18 @@ record Lemmas₂ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
 
   field var-/ : ∀ {m n x} {ρ : Sub T m n} → var x / ρ ≡ lookup ρ x
 
-  suc-/-sub : ∀ {n x} {t : T n} → var (suc x) / sub t ≡ var x
+  suc-/-sub : ∀ {x} {t : T n} → var (suc x) / sub t ≡ var x
   suc-/-sub {x = x} {t} = begin
     var (suc x) / sub t     ≡⟨ var-/ ⟩
     lookup (sub t) (suc x)  ≡⟨ refl ⟩
     lookup id x             ≡⟨ lookup-id x ⟩
     var x                   ∎
 
-  lookup-⊙ : ∀ {m n k} x {ρ₁ : Sub T m n} {ρ₂ : Sub T n k} →
+  lookup-⊙ : ∀ x {ρ₁ : Sub T m n} {ρ₂ : Sub T n o} →
              lookup (ρ₁ ⊙ ρ₂) x ≡ lookup ρ₁ x / ρ₂
-  lookup-⊙ x {ρ₁} {ρ₂} = VecProp.lookup-map x (λ t → t / ρ₂) ρ₁
+  lookup-⊙ x {ρ₁} {ρ₂} = Vec.lookup-map x (λ t → t / ρ₂) ρ₁
 
-  lookup-⨀ : ∀ {m n} x (ρs : Subs T m n) →
+  lookup-⨀ : ∀ x (ρs : Subs T m n) →
              lookup (⨀ ρs) x ≡ var x /✶ ρs
   lookup-⨀ x ε                = lookup-id x
   lookup-⨀ x (ρ ◅ ε)          = sym var-/
@@ -158,14 +166,14 @@ record Lemmas₂ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
     var x /✶ ρs / ρ        ∎
     where ρs = ρ′ ◅ ρs′
 
-  id-⊙ : ∀ {m n} {ρ : Sub T m n} → id ⊙ ρ ≡ ρ
+  id-⊙ : {ρ : Sub T m n} → id ⊙ ρ ≡ ρ
   id-⊙ {ρ = ρ} = extensionality λ x → begin
     lookup (id ⊙ ρ) x  ≡⟨ lookup-⊙ x {ρ₁ = id} ⟩
     lookup  id x / ρ   ≡⟨ cong₂ _/_ (lookup-id x) refl ⟩
     var x        / ρ   ≡⟨ var-/ ⟩
     lookup ρ x         ∎
 
-  lookup-wk-↑⋆-⊙ : ∀ {m n} k {x} {ρ : Sub T (k + suc m) n} →
+  lookup-wk-↑⋆-⊙ : ∀ k {x} {ρ : Sub T (k + suc m) n} →
                    lookup (wk ↑⋆ k ⊙ ρ) x ≡ lookup ρ (lift k suc x)
   lookup-wk-↑⋆-⊙ k {x} {ρ} = begin
     lookup (wk ↑⋆ k ⊙ ρ) x   ≡⟨ lookup-⊙ x {ρ₁ = wk ↑⋆ k} ⟩
@@ -173,14 +181,14 @@ record Lemmas₂ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
     var (lift k suc x) / ρ   ≡⟨ var-/ ⟩
     lookup ρ (lift k suc x)  ∎
 
-  wk-⊙-sub′ : ∀ {n} {t : T n} k → wk ↑⋆ k ⊙ sub t ↑⋆ k ≡ id
+  wk-⊙-sub′ : ∀ {t : T n} k → wk ↑⋆ k ⊙ sub t ↑⋆ k ≡ id
   wk-⊙-sub′ {t = t} k = extensionality λ x → begin
     lookup (wk ↑⋆ k ⊙ sub t ↑⋆ k) x     ≡⟨ lookup-wk-↑⋆-⊙ k ⟩
     lookup (sub t ↑⋆ k) (lift k suc x)  ≡⟨ lookup-sub-↑⋆ k x ⟩
     var x                               ≡⟨ sym (lookup-id x) ⟩
     lookup id x                         ∎
 
-  wk-⊙-sub : ∀ {n} {t : T n} → wk ⊙ sub t ≡ id
+  wk-⊙-sub : {t : T n} → wk ⊙ sub t ≡ id
   wk-⊙-sub = wk-⊙-sub′ zero
 
   var-/-wk-↑⋆ : ∀ {n} k (x : Fin (k + n)) →
@@ -190,7 +198,7 @@ record Lemmas₂ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
     lookup (wk ↑⋆ k) x  ≡⟨ lookup-wk-↑⋆ k x ⟩
     var (lift k suc x)  ∎
 
-  wk-↑⋆-⊙-wk : ∀ {n} k j →
+  wk-↑⋆-⊙-wk : ∀ k j →
                wk {n} ↑⋆ k ↑⋆ j ⊙ wk ↑⋆ j ≡
                wk ↑⋆ j ⊙ wk ↑⋆ suc k ↑⋆ j
   wk-↑⋆-⊙-wk k j = extensionality λ x → begin
@@ -207,7 +215,7 @@ record Lemmas₂ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
   open Subst   subst   public hiding (simple; application)
   open Lemmas₁ lemmas₁ public
 
-record Lemmas₃ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
+record Lemmas₃ (T : Pred ℕ ℓ) : Set ℓ where
   field lemmas₂ : Lemmas₂ T
 
   open Lemmas₂ lemmas₂
@@ -217,27 +225,27 @@ record Lemmas₃ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
             (∀ k x → var x /✶ ρs₁ ↑✶ k ≡ var x /✶ ρs₂ ↑✶ k) →
             ∀ k t → t /✶ ρs₁ ↑✶ k ≡ t /✶ ρs₂ ↑✶ k
 
-  /✶-↑✶′ : ∀ {m n} (ρs₁ ρs₂ : Subs T m n) →
+  /✶-↑✶′ : (ρs₁ ρs₂ : Subs T m n) →
            (∀ k → ⨀ (ρs₁ ↑✶ k) ≡ ⨀ (ρs₂ ↑✶ k)) →
            ∀ k t → t /✶ ρs₁ ↑✶ k ≡ t /✶ ρs₂ ↑✶ k
   /✶-↑✶′ ρs₁ ρs₂ hyp = /✶-↑✶ ρs₁ ρs₂ (λ k x → begin
     var x /✶ ρs₁ ↑✶ k        ≡⟨ sym (lookup-⨀ x (ρs₁ ↑✶ k)) ⟩
-    lookup (⨀ (ρs₁ ↑✶ k)) x  ≡⟨ cong (Fun.flip lookup x) (hyp k) ⟩
+    lookup (⨀ (ρs₁ ↑✶ k)) x  ≡⟨ cong (flip lookup x) (hyp k) ⟩
     lookup (⨀ (ρs₂ ↑✶ k)) x  ≡⟨ lookup-⨀ x (ρs₂ ↑✶ k) ⟩
     var x /✶ ρs₂ ↑✶ k        ∎)
 
-  id-vanishes : ∀ {n} (t : T n) → t / id ≡ t
+  id-vanishes : (t : T n) → t / id ≡ t
   id-vanishes = /✶-↑✶′ (ε ▻ id) ε id-↑⋆ zero
 
-  ⊙-id : ∀ {m n} {ρ : Sub T m n} → ρ ⊙ id ≡ ρ
+  ⊙-id : {ρ : Sub T m n} → ρ ⊙ id ≡ ρ
   ⊙-id {ρ = ρ} = begin
-    map (λ t → t / id) ρ  ≡⟨ VecProp.map-cong id-vanishes ρ ⟩
-    map Fun.id         ρ  ≡⟨ VecProp.map-id ρ ⟩
+    map (λ t → t / id) ρ  ≡⟨ Vec.map-cong id-vanishes ρ ⟩
+    map Fun.id         ρ  ≡⟨ Vec.map-id ρ ⟩
     ρ                     ∎
 
   open Lemmas₂ lemmas₂ public hiding (wk-⊙-sub′)
 
-record Lemmas₄ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
+record Lemmas₄ (T : Pred ℕ ℓ) : Set ℓ where
   field lemmas₃ : Lemmas₃ T
 
   open Lemmas₃ lemmas₃
@@ -246,7 +254,7 @@ record Lemmas₄ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
 
   private
 
-    ↑-distrib′ : ∀ {m n k} {ρ₁ : Sub T m n} {ρ₂ : Sub T n k} →
+    ↑-distrib′ : {ρ₁ : Sub T m n} {ρ₂ : Sub T n o} →
                  (∀ t → t / ρ₂ / wk ≡ t / wk / ρ₂ ↑) →
                  (ρ₁ ⊙ ρ₂) ↑ ≡ ρ₁ ↑ ⊙ ρ₂ ↑
     ↑-distrib′ {ρ₁ = ρ₁} {ρ₂} hyp = begin
@@ -256,16 +264,16 @@ record Lemmas₄ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
       ρ₁ ↑ ⊙ ρ₂ ↑                             ∎
       where
       lemma = begin
-        map weaken (map (λ t → t / ρ₂) ρ₁)    ≡⟨ sym (VecProp.map-∘ _ _ _) ⟩
-        map (λ t → weaken (t / ρ₂)) ρ₁        ≡⟨ VecProp.map-cong (λ t → begin
+        map weaken (map (λ t → t / ρ₂) ρ₁)    ≡⟨ sym (Vec.map-∘ _ _ _) ⟩
+        map (λ t → weaken (t / ρ₂)) ρ₁        ≡⟨ Vec.map-cong (λ t → begin
                                                    weaken (t / ρ₂)  ≡⟨ sym /-wk ⟩
                                                    t / ρ₂ / wk      ≡⟨ hyp t ⟩
                                                    t / wk / ρ₂ ↑    ≡⟨ cong₂ _/_ /-wk refl ⟩
                                                    weaken t / ρ₂ ↑  ∎) ρ₁ ⟩
-        map (λ t → weaken t / ρ₂ ↑) ρ₁        ≡⟨ VecProp.map-∘ _ _ _ ⟩
+        map (λ t → weaken t / ρ₂ ↑) ρ₁        ≡⟨ Vec.map-∘ _ _ _ ⟩
         map (λ t → t / ρ₂ ↑) (map weaken ρ₁)  ∎
 
-    ↑⋆-distrib′ : ∀ {m n o} {ρ₁ : Sub T m n} {ρ₂ : Sub T n o} →
+    ↑⋆-distrib′ : {ρ₁ : Sub T m n} {ρ₂ : Sub T n o} →
                   (∀ k t → t / ρ₂ ↑⋆ k / wk ≡ t / wk / ρ₂ ↑⋆ suc k) →
                   ∀ k → (ρ₁ ⊙ ρ₂) ↑⋆ k ≡ ρ₁ ↑⋆ k ⊙ ρ₂ ↑⋆ k
     ↑⋆-distrib′                hyp zero    = refl
@@ -274,15 +282,15 @@ record Lemmas₄ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
       (ρ₁ ↑⋆ k ⊙ ρ₂ ↑⋆ k) ↑      ≡⟨ ↑-distrib′ (hyp k) ⟩
       ρ₁ ↑⋆ suc k ⊙ ρ₂ ↑⋆ suc k  ∎
 
-  map-weaken : ∀ {m n} {ρ : Sub T m n} → map weaken ρ ≡ ρ ⊙ wk
+  map-weaken : {ρ : Sub T m n} → map weaken ρ ≡ ρ ⊙ wk
   map-weaken {ρ = ρ} = begin
-    map weaken ρ          ≡⟨ VecProp.map-cong (λ _ → sym /-wk) ρ ⟩
+    map weaken ρ          ≡⟨ Vec.map-cong (λ _ → sym /-wk) ρ ⟩
     map (λ t → t / wk) ρ  ≡⟨ refl ⟩
     ρ ⊙ wk                ∎
 
   private
 
-    ⊙-wk′ : ∀ {m n} {ρ : Sub T m n} k →
+    ⊙-wk′ : ∀ {ρ : Sub T m n} k →
             ρ ↑⋆ k ⊙ wk ↑⋆ k ≡ wk ↑⋆ k ⊙ ρ ↑ ↑⋆ k
     ⊙-wk′ {ρ = ρ} k = sym (begin
       wk ↑⋆ k ⊙ ρ ↑ ↑⋆ k  ≡⟨ lemma ⟩
@@ -297,31 +305,30 @@ record Lemmas₄ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
         lookup (ρ ↑ ↑⋆ k) (lift k suc x)  ≡⟨ sym (lookup-map-weaken-↑⋆ k x) ⟩
         lookup (map weaken ρ ↑⋆ k) x      ∎
 
-  ⊙-wk : ∀ {m n} {ρ : Sub T m n} → ρ ⊙ wk ≡ wk ⊙ ρ ↑
+  ⊙-wk : {ρ : Sub T m n} → ρ ⊙ wk ≡ wk ⊙ ρ ↑
   ⊙-wk = ⊙-wk′ zero
 
-  wk-commutes : ∀ {m n} {ρ : Sub T m n} t →
+  wk-commutes : ∀ {ρ : Sub T m n} t →
                 t / ρ / wk ≡ t / wk / ρ ↑
   wk-commutes {ρ = ρ} = /✶-↑✶′ (ε ▻ ρ ▻ wk) (ε ▻ wk ▻ ρ ↑) ⊙-wk′ zero
 
-  ↑⋆-distrib : ∀ {m n o} {ρ₁ : Sub T m n} {ρ₂ : Sub T n o} →
+  ↑⋆-distrib : {ρ₁ : Sub T m n} {ρ₂ : Sub T n o} →
                ∀ k → (ρ₁ ⊙ ρ₂) ↑⋆ k ≡ ρ₁ ↑⋆ k ⊙ ρ₂ ↑⋆ k
   ↑⋆-distrib = ↑⋆-distrib′ (λ _ → wk-commutes)
 
-  /-⊙ : ∀ {m n k} {ρ₁ : Sub T m n} {ρ₂ : Sub T n k} t →
+  /-⊙ : ∀ {ρ₁ : Sub T m n} {ρ₂ : Sub T n o} t →
         t / ρ₁ ⊙ ρ₂ ≡ t / ρ₁ / ρ₂
   /-⊙ {ρ₁ = ρ₁} {ρ₂} t =
     /✶-↑✶′ (ε ▻ ρ₁ ⊙ ρ₂) (ε ▻ ρ₁ ▻ ρ₂) ↑⋆-distrib zero t
 
-  ⊙-assoc : ∀ {m n k o}
-              {ρ₁ : Sub T m n} {ρ₂ : Sub T n k} {ρ₃ : Sub T k o} →
+  ⊙-assoc : {ρ₁ : Sub T m n} {ρ₂ : Sub T n o} {ρ₃ : Sub T o p} →
             ρ₁ ⊙ (ρ₂ ⊙ ρ₃) ≡ (ρ₁ ⊙ ρ₂) ⊙ ρ₃
   ⊙-assoc {ρ₁ = ρ₁} {ρ₂} {ρ₃} = begin
-    map (λ t → t / ρ₂ ⊙ ρ₃) ρ₁                  ≡⟨ VecProp.map-cong /-⊙ ρ₁ ⟩
-    map (λ t → t / ρ₂ / ρ₃) ρ₁                  ≡⟨ VecProp.map-∘ _ _ _ ⟩
+    map (λ t → t / ρ₂ ⊙ ρ₃) ρ₁                  ≡⟨ Vec.map-cong /-⊙ ρ₁ ⟩
+    map (λ t → t / ρ₂ / ρ₃) ρ₁                  ≡⟨ Vec.map-∘ _ _ _ ⟩
     map (λ t → t / ρ₃) (map (λ t → t / ρ₂) ρ₁)  ∎
 
-  map-weaken-⊙-sub : ∀ {m n} {ρ : Sub T m n} {t} → map weaken ρ ⊙ sub t ≡ ρ
+  map-weaken-⊙-sub : ∀ {ρ : Sub T m n} {t} → map weaken ρ ⊙ sub t ≡ ρ
   map-weaken-⊙-sub {ρ = ρ} {t} = begin
     map weaken ρ ⊙ sub t  ≡⟨ cong₂ _⊙_ map-weaken refl ⟩
     ρ ⊙ wk ⊙ sub t        ≡⟨ sym ⊙-assoc ⟩
@@ -329,7 +336,7 @@ record Lemmas₄ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
     ρ ⊙ id                ≡⟨ ⊙-id ⟩
     ρ                     ∎
 
-  sub-⊙ : ∀ {m n} {ρ : Sub T m n} t → sub t ⊙ ρ ≡ ρ ↑ ⊙ sub (t / ρ)
+  sub-⊙ : ∀ {ρ : Sub T m n} t → sub t ⊙ ρ ≡ ρ ↑ ⊙ sub (t / ρ)
   sub-⊙ {ρ = ρ} t = begin
     sub t ⊙ ρ                           ≡⟨ refl ⟩
     t / ρ ∷ id ⊙ ρ                      ≡⟨ cong (_∷_ (t / ρ)) id-⊙ ⟩
@@ -337,16 +344,16 @@ record Lemmas₄ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
     t / ρ ∷ map weaken ρ ⊙ sub (t / ρ)  ≡⟨ cong₂ _∷_ (sym var-/) refl ⟩
     ρ ↑ ⊙ sub (t / ρ)                   ∎
 
-  suc-/-↑ : ∀ {m n} {ρ : Sub T m n} x →
+  suc-/-↑ : ∀ {ρ : Sub T m n} x →
             var (suc x) / ρ ↑ ≡ var x / ρ / wk
   suc-/-↑ {ρ = ρ} x = begin
     var (suc x) / ρ ↑        ≡⟨ var-/ ⟩
-    lookup (map weaken ρ) x  ≡⟨ cong (Fun.flip lookup x) (map-weaken {ρ = ρ}) ⟩
+    lookup (map weaken ρ) x  ≡⟨ cong (flip lookup x) (map-weaken {ρ = ρ}) ⟩
     lookup (ρ ⊙ wk)       x  ≡⟨ lookup-⊙ x {ρ₁ = ρ} ⟩
     lookup ρ x / wk          ≡⟨ cong₂ _/_ (sym var-/) refl ⟩
     var x / ρ / wk           ∎
 
-  weaken-↑ : ∀ {k n} t {ρ : Sub T k n} → weaken t / (ρ ↑) ≡ weaken (t / ρ)
+  weaken-↑ : ∀ t {ρ : Sub T m n} → weaken t / (ρ ↑) ≡ weaken (t / ρ)
   weaken-↑ t {ρ} = begin
     weaken t / (ρ ↑) ≡⟨ cong (_/ ρ ↑) (sym /-wk) ⟩
     t / wk / ρ ↑     ≡⟨ sym (wk-commutes t) ⟩
@@ -357,10 +364,11 @@ record Lemmas₄ {ℓ} (T : Pred ℕ ℓ) : Set ℓ where
     hiding (/✶-↑✶; /✶-↑✶′; wk-↑⋆-⊙-wk;
             lookup-wk-↑⋆-⊙; lookup-map-weaken-↑⋆)
 
+------------------------------------------------------------------------
 -- For an example of how AppLemmas can be used, see
 -- Data.Fin.Substitution.List.
 
-record AppLemmas {ℓ₁ ℓ₂} (T₁ : Pred ℕ ℓ₁) (T₂ : Pred ℕ ℓ₂) : Set (ℓ₁ ⊔ ℓ₂) where
+record AppLemmas (T₁ : Pred ℕ ℓ₁) (T₂ : Pred ℕ ℓ₂) : Set (ℓ₁ ⊔ ℓ₂) where
   field
     application : Application T₁ T₂
     lemmas₄     : Lemmas₄ T₂
@@ -376,7 +384,7 @@ record AppLemmas {ℓ₁ ℓ₂} (T₁ : Pred ℕ ℓ₁) (T₂ : Pred ℕ ℓ
 
   private module L₄ = Lemmas₄ lemmas₄
 
-  /-⨀ : ∀ {m n} t (ρs : Subs T₂ m n) → t / ⨀ ρs ≡ t /✶ ρs
+  /-⨀ : ∀ t (ρs : Subs T₂ m n) → t / ⨀ ρs ≡ t /✶ ρs
   /-⨀ t ε                = id-vanishes t
   /-⨀ t (ρ ◅ ε)          = refl
   /-⨀ t (ρ ◅ (ρ′ ◅ ρs′)) = begin
@@ -385,7 +393,7 @@ record AppLemmas {ℓ₁ ℓ₂} (T₁ : Pred ℕ ℓ₁) (T₂ : Pred ℕ ℓ
     t /✶ ρs / ρ   ∎
     where ρs = ρ′ ◅ ρs′
 
-  ⨀→/✶ : ∀ {m n} (ρs₁ ρs₂ : Subs T₂ m n) →
+  ⨀→/✶ : (ρs₁ ρs₂ : Subs T₂ m n) →
          ⨀ ρs₁ ≡ ⨀ ρs₂ → ∀ t → t /✶ ρs₁ ≡ t /✶ ρs₂
   ⨀→/✶ ρs₁ ρs₂ hyp t = begin
     t /✶ ρs₁   ≡⟨ sym (/-⨀ t ρs₁) ⟩
@@ -393,19 +401,19 @@ record AppLemmas {ℓ₁ ℓ₂} (T₁ : Pred ℕ ℓ₁) (T₂ : Pred ℕ ℓ
     t / ⨀ ρs₂  ≡⟨ /-⨀ t ρs₂ ⟩
     t /✶ ρs₂   ∎
 
-  wk-commutes : ∀ {m n} {ρ : Sub T₂ m n} t →
+  wk-commutes : ∀ {ρ : Sub T₂ m n} t →
                 t / ρ / wk ≡ t / wk / ρ ↑
   wk-commutes {ρ = ρ} = ⨀→/✶ (ε ▻ ρ ▻ wk) (ε ▻ wk ▻ ρ ↑) L₄.⊙-wk
 
-  sub-commutes : ∀ {m n} {t′} {ρ : Sub T₂ m n} t →
+  sub-commutes : ∀ {t′} {ρ : Sub T₂ m n} t →
                  t / sub t′ / ρ ≡ t / ρ ↑ / sub (t′ ⊘ ρ)
   sub-commutes {t′ = t′} {ρ} =
     ⨀→/✶ (ε ▻ sub t′ ▻ ρ) (ε ▻ ρ ↑ ▻ sub (t′ ⊘ ρ)) (L₄.sub-⊙ t′)
 
-  wk-sub-vanishes : ∀ {n t′} (t : T₁ n) → t / wk / sub t′ ≡ t
+  wk-sub-vanishes : ∀ {t′} (t : T₁ n) → t / wk / sub t′ ≡ t
   wk-sub-vanishes {t′ = t′} = ⨀→/✶ (ε ▻ wk ▻ sub t′) ε L₄.wk-⊙-sub
 
-  /-weaken : ∀ {m n} {ρ : Sub T₂ m n} t → t / map weaken ρ ≡ t / ρ / wk
+  /-weaken : ∀ {ρ : Sub T₂ m n} t → t / map weaken ρ ≡ t / ρ / wk
   /-weaken {ρ = ρ} = ⨀→/✶ (ε ▻ map weaken ρ) (ε ▻ ρ ▻ wk) L₄.map-weaken
 
   open Application application public
@@ -527,19 +535,75 @@ record TermLemmas (T : ℕ → Set) : Set₁ where
 
   open Lemmas₅ lemmas₅ public hiding (lemmas₃)
 
-  wk-⊙-∷ : ∀ {m n} (t : T n) (ρ : Sub T m n) → (T.wk T.⊙ (t ∷ ρ)) ≡ ρ
-  wk-⊙-∷ t ρ = extensionality (λ x → begin
+  wk-⊙-∷ : (t : T n) (ρ : Sub T m n) → (T.wk T.⊙ (t ∷ ρ)) ≡ ρ
+  wk-⊙-∷ t ρ = extensionality λ x → begin
     lookup (T.wk T.⊙ (t ∷ ρ)) x ≡⟨ L₃.lookup-wk-↑⋆-⊙ 0 {ρ = t ∷ ρ} ⟩
-    lookup ρ x                  ∎)
+    lookup ρ x                  ∎
 
-  weaken-∷ : ∀ {k n} (t₁ : T k) {t₂ : T n} {ρ : Sub T k n} → T.weaken t₁ T./ (t₂ ∷ ρ) ≡ t₁ T./ ρ
+  weaken-∷ : (t₁ : T m) {t₂ : T n} {ρ : Sub T m n} →
+    T.weaken t₁ T./ (t₂ ∷ ρ) ≡ t₁ T./ ρ
   weaken-∷ t₁ {t₂} {ρ} = begin
     T.weaken t₁ T./ (t₂ ∷ ρ)   ≡⟨ cong (T._/ (t₂ ∷ ρ)) (sym /-wk) ⟩
     (t₁ T./ T.wk) T./ (t₂ ∷ ρ) ≡⟨ ⨀→/✶ ((t₂ ∷ ρ) ◅ T.wk ◅ ε) (ρ ◅ ε) (wk-⊙-∷ t₂ ρ) t₁ ⟩
     t₁ T./ ρ                   ∎
 
-  weaken-sub : ∀ {n} (t₁ : T n) {t₂ : T n} → T.weaken t₁ T./ (T.sub t₂) ≡ t₁
+  weaken-sub : (t₁ : T n) {t₂ : T n} → T.weaken t₁ T./ (T.sub t₂) ≡ t₁
   weaken-sub t₁ {t₂} = begin
     T.weaken t₁ T./ (T.sub t₂) ≡⟨ weaken-∷ t₁ ⟩
     t₁ T./ T.id                ≡⟨ id-vanishes t₁ ⟩
     t₁                         ∎
+
+  -- Lemmas relating renamings to substitutions.
+
+  map-var≡ : {ρ₁ : Sub Fin m n} {ρ₂ : Sub T m n} {f : Fin m → Fin n} →
+             (∀ x → lookup ρ₁ x ≡ f x) →
+             (∀ x → lookup ρ₂ x ≡ T.var (f x)) →
+             map T.var ρ₁ ≡ ρ₂
+  map-var≡ {ρ₁ = ρ₁} {ρ₂ = ρ₂} {f = f} hyp₁ hyp₂ = extensionality λ x →
+    lookup (map T.var ρ₁) x  ≡⟨ Vec.lookup-map x _ ρ₁ ⟩
+    T.var (lookup ρ₁ x)      ≡⟨ cong T.var $ hyp₁ x ⟩
+    T.var (f x)              ≡⟨ sym $ hyp₂ x ⟩
+    lookup ρ₂ x              ∎
+
+  wk≡wk : map T.var VarSubst.wk ≡ T.wk {n = n}
+  wk≡wk = map-var≡ VarLemmas.lookup-wk lookup-wk
+
+  id≡id : map T.var VarSubst.id ≡ T.id {n = n}
+  id≡id = map-var≡ VarLemmas.lookup-id lookup-id
+
+  sub≡sub : {x : Fin n} → map T.var (VarSubst.sub x) ≡ T.sub (T.var x)
+  sub≡sub = cong (_ ∷_) id≡id
+
+  ↑≡↑ : {ρ : Sub Fin m n} → map T.var (ρ VarSubst.↑) ≡ map T.var ρ T.↑
+  ↑≡↑ {ρ = ρ} = map-var≡
+    (VarLemmas.lookup-↑⋆ (lookup ρ) (λ _ → refl) 1)
+    (lookup-↑⋆ (lookup ρ) (λ _ → Vec.lookup-map _ _ ρ) 1)
+
+  /Var≡/ : ∀ {ρ : Sub Fin m n} {t} → t /Var ρ ≡ t T./ map T.var ρ
+  /Var≡/ {ρ = ρ} {t = t} =
+    /✶-↑✶ (ε ▻ ρ) (ε ▻ map T.var ρ)
+      (λ k x →
+         T.var x /Var ρ VarSubst.↑⋆ k        ≡⟨ app-var ⟩
+         T.var (lookup (ρ VarSubst.↑⋆ k) x)  ≡⟨ cong T.var $ VarLemmas.lookup-↑⋆ _ (λ _ → refl) k _ ⟩
+         T.var (lift k (VarSubst._/ ρ) x)    ≡⟨ sym $ lookup-↑⋆ _ (λ _ → Vec.lookup-map _ _ ρ) k _ ⟩
+         lookup (map T.var ρ T.↑⋆ k) x       ≡⟨ sym app-var ⟩
+         T.var x T./ map T.var ρ T.↑⋆ k      ∎)
+      zero t
+
+  sub-renaming-commutes : ∀ {t x} {ρ : Sub T m n} →
+    t /Var VarSubst.sub x T./ ρ ≡ t T./ ρ T.↑ T./ T.sub (lookup ρ x)
+  sub-renaming-commutes {t = t} {x = x} {ρ = ρ} =
+    t /Var VarSubst.sub x T./ ρ             ≡⟨ cong (T._/ ρ) /Var≡/ ⟩
+    t T./ map T.var (VarSubst.sub x) T./ ρ  ≡⟨ cong (λ ρ′ → t T./ ρ′ T./ ρ) sub≡sub ⟩
+    t T./ T.sub (T.var x) T./ ρ             ≡⟨ sub-commutes _ ⟩
+    t T./ ρ T.↑ T./ T.sub (T.var x T./ ρ)   ≡⟨ cong (λ t′ → t T./ ρ T.↑ T./ T.sub t′) app-var ⟩
+    t T./ ρ T.↑ T./ T.sub (lookup ρ x)      ∎
+
+  sub-commutes-with-renaming : ∀ {t t′} {ρ : Sub Fin m n} →
+    t T./ T.sub t′ /Var ρ ≡ t /Var ρ VarSubst.↑ T./ T.sub (t′ /Var ρ)
+  sub-commutes-with-renaming {t = t} {t′ = t′} {ρ = ρ} =
+    t T./ T.sub t′ /Var ρ                                          ≡⟨ /Var≡/ ⟩
+    t T./ T.sub t′ T./ map T.var ρ                                 ≡⟨ sub-commutes _ ⟩
+    t T./ map T.var ρ T.↑ T./ T.sub (t′ T./ map T.var ρ)           ≡⟨ sym $ cong (λ ρ′ → t T./ ρ′ T./ T.sub (t′ T./ map T.var ρ)) ↑≡↑ ⟩
+    t T./ map T.var (ρ VarSubst.↑) T./ T.sub (t′ T./ map T.var ρ)  ≡⟨ sym $ cong₂ (λ t ρ → t T./ T.sub ρ) /Var≡/ /Var≡/ ⟩
+    t /Var ρ VarSubst.↑ T./ T.sub (t′ /Var ρ)                      ∎
diff --git a/src/Data/Fin/Substitution/List.agda b/src/Data/Fin/Substitution/List.agda
index 8927b3b21f..179f806a22 100644
--- a/src/Data/Fin/Substitution/List.agda
+++ b/src/Data/Fin/Substitution/List.agda
@@ -9,27 +9,36 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Fin.Substitution.Lemmas
+open import Data.Fin.Substitution.Lemmas using (Lemmas₄; AppLemmas)
 open import Data.Nat.Base using (ℕ)
 
 module Data.Fin.Substitution.List {ℓ} {T : ℕ → Set ℓ} (lemmas₄ : Lemmas₄ T) where
 
-open import Data.List.Base
-open import Data.List.Properties
-open import Data.Fin.Substitution
-import Function as Fun
-open import Relation.Binary.PropositionalEquality
-open ≡-Reasoning
+open import Data.List.Base using (List; map)
+open import Data.List.Properties using (map-id; map-cong; map-∘)
+open import Data.Fin.Substitution using (Sub)
+import Function.Base as Fun
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 
 private
+  variable
+    m n : ℕ
+
+  ListT : ℕ → Set ℓ
+  ListT = List Fun.∘ T
+
   open module L = Lemmas₄ lemmas₄ using (_/_; id; _⊙_)
 
+------------------------------------------------------------------------
+-- Listwise application of a substitution, plus lemmas about it
+
 infixl 8 _//_
 
-_//_ : ∀ {m n} → List (T m) → Sub T m n → List (T n)
+_//_ : ListT m → Sub T m n → ListT n
 ts // ρ = map (λ σ → σ / ρ) ts
 
-appLemmas : AppLemmas (λ n → List (T n)) T
+appLemmas : AppLemmas ListT T
 appLemmas = record
   { application = record { _/_ = _//_ }
   ; lemmas₄     = lemmas₄
@@ -41,7 +50,7 @@ appLemmas = record
       ts // ρ₁ ⊙ ρ₂               ≡⟨ map-cong L./-⊙ ts ⟩
       map (λ σ → σ / ρ₁ / ρ₂) ts  ≡⟨ map-∘ ts ⟩
       ts // ρ₁ // ρ₂              ∎
-  }
+  } where open ≡-Reasoning
 
 open AppLemmas appLemmas public
   hiding (_/_) renaming (_/✶_ to _//✶_)
diff --git a/src/Data/Float/Base.agda b/src/Data/Float/Base.agda
index edc8b4943f..a991c119a9 100644
--- a/src/Data/Float/Base.agda
+++ b/src/Data/Float/Base.agda
@@ -8,11 +8,12 @@
 
 module Data.Float.Base where
 
-open import Relation.Binary.Core using (Rel)
-import Data.Word.Base as Word
+open import Data.Bool.Base using (T)
+import Data.Word64.Base as Word64
 import Data.Maybe.Base as Maybe
 open import Function.Base using (_on_; _∘_)
 open import Agda.Builtin.Equality
+open import Relation.Binary.Core using (Rel)
 
 ------------------------------------------------------------------------
 -- Re-export built-ins publically
@@ -29,7 +30,7 @@ open import Agda.Builtin.Float public
   ; primFloatIsNegativeZero    to isNegativeZero
   ; primFloatIsSafeInteger     to isSafeInteger
   -- Conversions
-  ; primFloatToWord64          to toWord
+  ; primFloatToWord64          to toWord64
   ; primNatToFloat             to fromℕ
   ; primIntToFloat             to fromℤ
   ; primFloatRound             to round
@@ -65,5 +66,22 @@ open import Agda.Builtin.Float public
   ; primFloatATanh             to atanh
   )
 
+infix 4 _≈_
+
 _≈_ : Rel Float _
-_≈_ = _≡_ on Maybe.map Word.toℕ ∘ toWord
+_≈_ = _≡_ on Maybe.map Word64.toℕ ∘ toWord64
+
+
+infix 4 _≤_
+_≤_ : Rel Float _
+x ≤ y = T (x ≤ᵇ y)
+
+
+------------------------------------------------------------------------
+-- DEPRECATIONS
+
+toWord = toWord64
+{-# WARNING_ON_USAGE toWord
+"Warning: toWord was deprecated in v2.1.
+Please use toWord64 instead."
+#-}
diff --git a/src/Data/Float/Properties.agda b/src/Data/Float/Properties.agda
index b2b2fc2c9e..6975804193 100644
--- a/src/Data/Float/Properties.agda
+++ b/src/Data/Float/Properties.agda
@@ -10,32 +10,40 @@ module Data.Float.Properties where
 
 open import Data.Bool.Base as Bool using (Bool)
 open import Data.Float.Base
-import Data.Maybe.Base as M
-import Data.Maybe.Properties as Mₚ
-import Data.Nat.Properties as Nₚ
-import Data.Word.Base as Word
-import Data.Word.Properties as Wₚ
-open import Function using (_∘_)
+import Data.Maybe.Base as Maybe
+import Data.Maybe.Properties as Maybe
+import Data.Nat.Properties as ℕ
+import Data.Word64.Base as Word64
+import Data.Word64.Properties as Word64
+open import Function.Base using (_∘_)
 open import Relation.Nullary.Decidable as RN using (map′)
-open import Relation.Binary
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Bundles using (Setoid; DecSetoid)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Substitutive; Decidable; DecidableEquality)
 import Relation.Binary.Construct.On as On
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; sym; trans; subst)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (setoid; decSetoid)
 
 ------------------------------------------------------------------------
 -- Primitive properties
 
 open import Agda.Builtin.Float.Properties
-  renaming (primFloatToWord64Injective to toWord-injective)
+  renaming (primFloatToWord64Injective to toWord64-injective)
   public
 
 ------------------------------------------------------------------------
 -- Properties of _≈_
 
 ≈⇒≡ : _≈_ ⇒ _≡_
-≈⇒≡ eq = toWord-injective _ _ (Mₚ.map-injective Wₚ.≈⇒≡ eq)
+≈⇒≡ eq = toWord64-injective _ _ (Maybe.map-injective Word64.≈⇒≡ eq)
 
 ≈-reflexive : _≡_ ⇒ _≈_
-≈-reflexive eq = cong (M.map Word.toℕ ∘ toWord) eq
+≈-reflexive eq = cong (Maybe.map Word64.toℕ ∘ toWord64) eq
 
 ≈-refl : Reflexive _≈_
 ≈-refl = refl
@@ -51,7 +59,7 @@ open import Agda.Builtin.Float.Properties
 
 infix 4 _≈?_
 _≈?_ : Decidable _≈_
-_≈?_ = On.decidable (M.map Word.toℕ ∘ toWord) _≡_ (Mₚ.≡-dec Nₚ._≟_)
+_≈?_ = On.decidable (Maybe.map Word64.toℕ ∘ toWord64) _≡_ (Maybe.≡-dec ℕ._≟_)
 
 ≈-isEquivalence : IsEquivalence _≈_
 ≈-isEquivalence = record
@@ -87,3 +95,13 @@ x ≟ y = map′ ≈⇒≡ ≈-reflexive (x ≈? y)
 
 ≡-decSetoid : DecSetoid _ _
 ≡-decSetoid = decSetoid _≟_
+
+
+------------------------------------------------------------------------
+-- DEPRECATIONS
+
+toWord-injective = toWord64-injective
+{-# WARNING_ON_USAGE toWord-injective
+"Warning: toWord-injective was deprecated in v2.1.
+Please use toWord64-injective instead."
+#-}
diff --git a/src/Data/Graph/Acyclic.agda b/src/Data/Graph/Acyclic.agda
index 440424206a..451581bf4e 100644
--- a/src/Data/Graph/Acyclic.agda
+++ b/src/Data/Graph/Acyclic.agda
@@ -13,22 +13,21 @@
 module Data.Graph.Acyclic where
 
 open import Level using (_⊔_)
-open import Data.Nat.Base as Nat using (ℕ; zero; suc; _<′_)
+open import Data.Nat.Base as ℕ using (ℕ; zero; suc; _<′_)
 open import Data.Nat.Induction using (<′-rec; <′-Rec)
-import Data.Nat.Properties as Nat
+import Data.Nat.Properties as ℕ
 open import Data.Fin as Fin
   using (Fin; Fin′; zero; suc; #_; toℕ; _≟_; opposite) renaming (_ℕ-ℕ_ to _-_)
-import Data.Fin.Properties as FP
-import Data.Fin.Permutation.Components as PC
-open import Data.Product as Prod using (∃; _×_; _,_)
-open import Data.Maybe.Base as Maybe using (Maybe; nothing; just; decToMaybe)
-open import Data.Empty
+import Data.Fin.Properties as Fin
+open import Data.Product.Base as Prod using (∃; _×_; _,_)
+open import Data.Maybe.Base as Maybe using (Maybe)
+open import Data.Empty using (⊥)
 open import Data.Unit.Base using (⊤; tt)
 open import Data.Vec.Base as Vec using (Vec; []; _∷_)
 open import Data.List.Base as List using (List; []; _∷_)
-open import Function
-open import Relation.Nullary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Function.Base using (_$_; _∘′_; _∘_; id)
+open import Relation.Binary.Consequences using (dec⇒weaklyDec)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 ------------------------------------------------------------------------
 -- A lemma
@@ -36,7 +35,7 @@ open import Relation.Binary.PropositionalEquality as P using (_≡_)
 private
 
   lemma : ∀ n (i : Fin n) → n - suc i <′ n
-  lemma (suc n) i  = Nat.≤⇒≤′ $ Nat.s≤s $ FP.nℕ-ℕi≤n n i
+  lemma (suc n) i  = ℕ.≤⇒≤′ $ ℕ.s≤s $ Fin.nℕ-ℕi≤n n i
 
 ------------------------------------------------------------------------
 -- Node contexts
@@ -187,7 +186,7 @@ private
 
   test-nodes : nodes example ≡ (# 0 , 0) ∷ (# 1 , 1) ∷ (# 2 , 2) ∷
                                (# 3 , 3) ∷ (# 4 , 4) ∷ []
-  test-nodes = P.refl
+  test-nodes = refl
 
 
 module _ {ℓ e} {N : Set ℓ} {E : Set e} where
@@ -214,7 +213,7 @@ private
 
   test-edges : edges example ≡ (# 1 , 10 , # 1) ∷ (# 1 , 11 , # 1) ∷
                                (# 2 , 12 , # 0) ∷ []
-  test-edges = P.refl
+  test-edges = refl
 
 -- The successors of a given node i (edge label × node number relative
 -- to i).
@@ -226,7 +225,7 @@ sucs g i = successors $ head (g [ i ])
 private
 
   test-sucs : sucs example (# 1) ≡ (10 , # 1) ∷ (11 , # 1) ∷ []
-  test-sucs = P.refl
+  test-sucs = refl
 
 -- The predecessors of a given node i (node number relative to i ×
 -- edge label).
@@ -239,13 +238,13 @@ preds (c & g) (suc i) =
             (List.map (Prod.map suc id) $ preds g i)
   where
   p : ∀ {e} {E : Set e} {n} (i : Fin n) → E × Fin n → Maybe (Fin′ (suc i) × E)
-  p i (e , j) = Maybe.map (λ{ P.refl → zero , e }) (decToMaybe (i ≟ j))
+  p i (e , j) = Maybe.map (λ{ refl → zero , e }) (dec⇒weaklyDec _≟_ i j)
 
 private
 
   test-preds : preds example (# 3) ≡
                (# 1 , 10) ∷ (# 1 , 11) ∷ (# 2 , 12) ∷ []
-  test-preds = P.refl
+  test-preds = refl
 
 ------------------------------------------------------------------------
 -- Operations
@@ -253,7 +252,7 @@ private
 -- Weakens a node label.
 
 weaken : ∀ {n} {i : Fin n} → Fin (n - suc i) → Fin n
-weaken {n} {i} j = Fin.inject≤ j (FP.nℕ-ℕi≤n n (suc i))
+weaken {n} {i} j = Fin.inject≤ j (Fin.nℕ-ℕi≤n n (suc i))
 
 -- Labels each node with its node number.
 
@@ -273,7 +272,7 @@ private
                  context (# 3 , 3) [] &
                  context (# 4 , 4) [] &
                  ∅)
-  test-number = P.refl
+  test-number = refl
 
 -- Reverses all the edges in the graph.
 
@@ -291,7 +290,7 @@ reverse {N = N} {E} g =
 private
 
   test-reverse : reverse (reverse example) ≡ example
-  test-reverse = P.refl
+  test-reverse = refl
 
 ------------------------------------------------------------------------
 -- Views
@@ -313,7 +312,7 @@ module _ {ℓ e} {N : Set ℓ} {E : Set e} where
     expand n rec (c & g) =
       node (label c)
            (List.map
-              (Prod.map id (λ i → rec (n - suc i) (lemma n i) (g [ i ])))
+              (Prod.map id (λ i → rec (lemma n i) (g [ i ])))
               (successors c))
 
 -- Performs the toTree expansion once for each node.
@@ -331,4 +330,4 @@ private
                     node 3 [] ∷
                     node 4 [] ∷
                     []
-  test-toForest = P.refl
+  test-toForest = refl
diff --git a/src/Data/Integer.agda b/src/Data/Integer.agda
index ae8b8787ab..6e4976f3df 100644
--- a/src/Data/Integer.agda
+++ b/src/Data/Integer.agda
@@ -30,8 +30,8 @@ open import Data.Integer.Properties public
 -- Version 1.5
 -- Show
 
-import Data.Nat.Show as ℕ
-open import Data.Sign as Sign using (Sign)
+import Data.Nat.Show as ℕ using (show)
+open import Data.Sign.Base as Sign using (Sign)
 open import Data.String.Base using (String; _++_)
 
 show : ℤ → String
diff --git a/src/Data/Integer/Base.agda b/src/Data/Integer/Base.agda
index 338656956b..9d7e689db0 100644
--- a/src/Data/Integer/Base.agda
+++ b/src/Data/Integer/Base.agda
@@ -14,7 +14,7 @@ module Data.Integer.Base where
 open import Algebra.Bundles.Raw
   using (RawMagma; RawMonoid; RawGroup; RawNearSemiring; RawSemiring; RawRing)
 open import Data.Bool.Base using (Bool; T; true; false)
-open import Data.Nat.Base as ℕ using (ℕ; z≤n; s≤s)
+open import Data.Nat.Base as ℕ using (ℕ; z≤n; s≤s) hiding (module ℕ)
 open import Data.Sign.Base as Sign using (Sign)
 open import Level using (0ℓ)
 open import Relation.Binary.Core using (Rel)
@@ -140,6 +140,9 @@ record Negative (i : ℤ) : Set where
 
 -- Instances
 
+open ℕ public
+  using (nonZero)
+
 instance
   pos : ∀ {n} → Positive +[1+ n ]
   pos = _
diff --git a/src/Data/Integer/Coprimality.agda b/src/Data/Integer/Coprimality.agda
index 35df9a1457..36eb45e19e 100644
--- a/src/Data/Integer/Coprimality.agda
+++ b/src/Data/Integer/Coprimality.agda
@@ -15,8 +15,9 @@ import Data.Nat.Coprimality as ℕ
 import Data.Nat.Divisibility as ℕ
 open import Function.Base using (_on_)
 open import Level using (0ℓ)
-open import Relation.Binary using (Rel; Decidable; Symmetric)
-open import Relation.Binary.PropositionalEquality using (subst)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Decidable; Symmetric)
+open import Relation.Binary.PropositionalEquality.Core using (subst)
 
 ------------------------------------------------------------------------
 -- Definition
diff --git a/src/Data/Integer/DivMod.agda b/src/Data/Integer/DivMod.agda
index 87bbaabbe7..639188c180 100644
--- a/src/Data/Integer/DivMod.agda
+++ b/src/Data/Integer/DivMod.agda
@@ -8,16 +8,16 @@
 
 module Data.Integer.DivMod where
 
-open import Data.Integer.Base
+open import Data.Integer.Base using (+_; -[1+_]; +[1+_]; NonZero; _%_; ∣_∣;
+  _%ℕ_; _/ℕ_; _+_; _*_; -_; _-_; pred; -1ℤ; 0ℤ; _⊖_; _≤_; _<_; +≤+; suc;
+  +<+)
 open import Data.Integer.Properties
 open import Data.Nat.Base as ℕ using (ℕ; z≤n; s≤s; z<s; s<s)
 import Data.Nat.Properties as ℕ
 import Data.Nat.DivMod as ℕ
-import Data.Sign as S
 open import Function.Base using (_∘′_)
-open import Relation.Nullary.Decidable
-open import Relation.Binary.PropositionalEquality
-
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; cong; sym; subst)
 open ≤-Reasoning
 
 ------------------------------------------------------------------------
@@ -75,7 +75,7 @@ a≡a%ℕn+[a/ℕn]*n n@(-[1+ _ ]) d with ∣ n ∣ ℕ.% d in eq
 [n/ℕd]*d≤n : ∀ n d .{{_ : ℕ.NonZero d}} → (n /ℕ d) * + d ≤ n
 [n/ℕd]*d≤n n d = let q = n /ℕ d; r = n %ℕ d in begin
   q * + d        ≤⟨  i≤j+i _ (+ r) ⟩
-  + r + q * + d  ≡˘⟨ a≡a%ℕn+[a/ℕn]*n n d ⟩
+  + r + q * + d  ≡⟨ a≡a%ℕn+[a/ℕn]*n n d ⟨
   n              ∎
 
 div-pos-is-/ℕ : ∀ n d .{{_ : ℕ.NonZero d}} →
diff --git a/src/Data/Integer/Divisibility.agda b/src/Data/Integer/Divisibility.agda
index 44a97c6554..7cd8109fce 100644
--- a/src/Data/Integer/Divisibility.agda
+++ b/src/Data/Integer/Divisibility.agda
@@ -1,4 +1,4 @@
-------------------------------------------------------------------------
+-----------------------------------------------------------------------
 -- The Agda standard library
 --
 -- Unsigned divisibility
@@ -10,16 +10,14 @@
 
 module Data.Integer.Divisibility where
 
-open import Function
+open import Function.Base using (_on_; _$_)
 open import Data.Integer.Base
 open import Data.Integer.Properties
 import Data.Nat.Base as ℕ
-import Data.Nat.Properties as ℕᵖ
-import Data.Nat.Divisibility as ℕᵈ
-import Data.Nat.Coprimality as ℕᶜ
+import Data.Nat.Divisibility as ℕ
 open import Level
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Core using (Rel; _Preserves_⟶_)
+
 
 ------------------------------------------------------------------------
 -- Divisibility
@@ -27,9 +25,9 @@ open import Relation.Binary.PropositionalEquality
 infix 4 _∣_
 
 _∣_ : Rel ℤ 0ℓ
-_∣_ = ℕᵈ._∣_ on ∣_∣
+_∣_ = ℕ._∣_ on ∣_∣
 
-open ℕᵈ public using (divides)
+pattern divides k eq = ℕ.divides k eq
 
 ------------------------------------------------------------------------
 -- Properties of divisibility
@@ -37,21 +35,21 @@ open ℕᵈ public using (divides)
 *-monoʳ-∣ : ∀ k → (k *_) Preserves _∣_ ⟶ _∣_
 *-monoʳ-∣ k {i} {j} i∣j = begin
   ∣ k * i ∣       ≡⟨ abs-* k i ⟩
-  ∣ k ∣ ℕ.* ∣ i ∣ ∣⟨ ℕᵈ.*-monoʳ-∣ ∣ k ∣ i∣j ⟩
-  ∣ k ∣ ℕ.* ∣ j ∣ ≡⟨ sym (abs-* k j) ⟩
+  ∣ k ∣ ℕ.* ∣ i ∣ ∣⟨ ℕ.*-monoʳ-∣ ∣ k ∣ i∣j ⟩
+  ∣ k ∣ ℕ.* ∣ j ∣ ≡⟨ abs-* k j ⟨
   ∣ k * j ∣       ∎
-  where open ℕᵈ.∣-Reasoning
+  where open ℕ.∣-Reasoning
 
 *-monoˡ-∣ : ∀ k → (_* k) Preserves _∣_ ⟶ _∣_
 *-monoˡ-∣ k {i} {j} rewrite *-comm i k | *-comm j k = *-monoʳ-∣ k
 
 *-cancelˡ-∣ : ∀ k {i j} .{{_ : NonZero k}} → k * i ∣ k * j → i ∣ j
-*-cancelˡ-∣ k {i} {j} k*i∣k*j = ℕᵈ.*-cancelˡ-∣ ∣ k ∣ $ begin
-  ∣ k ∣ ℕ.* ∣ i ∣  ≡⟨ sym (abs-* k i) ⟩
+*-cancelˡ-∣ k {i} {j} k*i∣k*j = ℕ.*-cancelˡ-∣ ∣ k ∣ $ begin
+  ∣ k ∣ ℕ.* ∣ i ∣  ≡⟨ abs-* k i ⟨
   ∣ k * i ∣        ∣⟨ k*i∣k*j ⟩
   ∣ k * j ∣        ≡⟨ abs-* k j ⟩
   ∣ k ∣ ℕ.* ∣ j ∣  ∎
-  where open ℕᵈ.∣-Reasoning
+  where open ℕ.∣-Reasoning
 
 *-cancelʳ-∣ : ∀ k {i j} .{{_ : NonZero k}} → i * k ∣ j * k → i ∣ j
 *-cancelʳ-∣ k {i} {j} rewrite *-comm i k | *-comm j k = *-cancelˡ-∣ k
diff --git a/src/Data/Integer/Divisibility/Signed.agda b/src/Data/Integer/Divisibility/Signed.agda
index d4a22e420a..8272ded259 100644
--- a/src/Data/Integer/Divisibility/Signed.agda
+++ b/src/Data/Integer/Divisibility/Signed.agda
@@ -8,24 +8,30 @@
 
 module Data.Integer.Divisibility.Signed where
 
-open import Function
-open import Data.Integer.Base
+open import Function.Base using (_⟨_⟩_; _$_; _$′_; _∘_; _∘′_)
+open import Data.Integer.Base using (ℤ; _*_; +0; sign; _◃_; ≢-nonZero;
+  ∣_∣; 0ℤ; +_; _+_; _-_; -_; NonZero)
 open import Data.Integer.Properties
-open import Data.Integer.Divisibility as Unsigned
-  using (divides)
-  renaming (_∣_ to _∣ᵤ_)
+import Data.Integer.Divisibility as Unsigned
 import Data.Nat.Base as ℕ
 import Data.Nat.Divisibility as ℕ
 import Data.Nat.Coprimality as ℕ
 import Data.Nat.Properties as ℕ
-import Data.Sign as S
-import Data.Sign.Properties as SProp
-open import Level
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
-import Relation.Binary.Reasoning.Preorder as PreorderReasoning
-open import Relation.Nullary.Decidable using (yes; no)
-import Relation.Nullary.Decidable as DEC
+import Data.Sign.Base as Sign
+import Data.Sign.Properties as Sign
+open import Relation.Binary.Core using (_⇒_; _Preserves_⟶_)
+open import Relation.Binary.Bundles using (Preorder)
+open import Relation.Binary.Structures using (IsPreorder)
+open import Relation.Binary.Definitions
+  using (Reflexive; Transitive; Decidable)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; trans; sym; cong; refl)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning; isEquivalence)
+import Relation.Binary.Reasoning.Preorder as ≲-Reasoning
+open import Relation.Nullary.Decidable as Dec using (yes; no)
+open import Relation.Binary.Reasoning.Syntax
+
 
 ------------------------------------------------------------------------
 -- Type
@@ -41,48 +47,40 @@ open _∣_ using (quotient) public
 ------------------------------------------------------------------------
 -- Conversion between signed and unsigned divisibility
 
-∣ᵤ⇒∣ : ∀ {k i} → k ∣ᵤ i → k ∣ i
-∣ᵤ⇒∣ {k} {i} (divides 0           eq) = divides (+ 0) (∣i∣≡0⇒i≡0 eq)
-∣ᵤ⇒∣ {k} {i} (divides q@(ℕ.suc _) eq) with k ≟ +0
+∣ᵤ⇒∣ : ∀ {k i} → k Unsigned.∣ i → k ∣ i
+∣ᵤ⇒∣ {k} {i} (Unsigned.divides 0           eq) = divides +0 (∣i∣≡0⇒i≡0 eq)
+∣ᵤ⇒∣ {k} {i} (Unsigned.divides q@(ℕ.suc _) eq) with k ≟ +0
 ... | yes refl = divides +0 (∣i∣≡0⇒i≡0 (trans eq (ℕ.*-zeroʳ q)))
-... | no  neq  = divides (sign i S.* sign k ◃ q) (◃-cong sign-eq abs-eq)
+... | no  neq  = divides s[i*k]◃q (◃-cong sign-eq abs-eq)
   where
-  ikq = sign i S.* sign k ◃ q
-
-  *-nonZero : ∀ m n .{{_ : ℕ.NonZero m}} .{{_ : ℕ.NonZero n}} → ℕ.NonZero (m ℕ.* n)
-  *-nonZero (ℕ.suc _) (ℕ.suc _) = _
-
-  ◃-nonZero : ∀ s n .{{_ : ℕ.NonZero n}} → NonZero (s ◃ n)
-  ◃-nonZero S.- (ℕ.suc _) = _
-  ◃-nonZero S.+ (ℕ.suc _) = _
-
-  ikq≢0 : NonZero ikq
-  ikq≢0 = ◃-nonZero (sign i S.* sign k) q
+  s[i*k] = sign i Sign.* sign k
+  s[i*k]◃q = s[i*k] ◃ q
 
   instance
-    ikq*∣k∣≢0 : ℕ.NonZero (∣ ikq ∣ ℕ.* ∣ k ∣)
-    ikq*∣k∣≢0 = *-nonZero ∣ ikq ∣ ∣ k ∣ {{ikq≢0}} {{≢-nonZero neq}}
+    _ = ≢-nonZero neq
+    _ = ◃-nonZero s[i*k] q
+    _ = i*j≢0 s[i*k]◃q k
 
-  sign-eq : sign i ≡ sign (ikq * k)
+  sign-eq : sign i ≡ sign (s[i*k]◃q * k)
   sign-eq = sym $ begin
-    sign (ikq * k)                  ≡⟨ sign-◃ (sign ikq S.* sign k) (∣ ikq ∣ ℕ.* ∣ k ∣) ⟩
-    sign ikq S.* sign k             ≡⟨ cong (S._* sign k) (sign-◃ (sign i S.* sign k) q) ⟩
-    (sign i S.* sign k) S.* sign k  ≡⟨ SProp.*-assoc (sign i) (sign k) (sign k) ⟩
-    sign i S.* (sign k S.* sign k)  ≡⟨ cong (sign i S.*_) (SProp.s*s≡+ (sign k)) ⟩
-    sign i S.* S.+                  ≡⟨ SProp.*-identityʳ (sign i) ⟩
-    sign i                          ∎
+    sign (s[i*k]◃q * k)                   ≡⟨ sign-* s[i*k]◃q k ⟩
+    sign s[i*k]◃q Sign.* sign k           ≡⟨ cong (Sign._* _) (sign-◃ s[i*k] q) ⟩
+    s[i*k] Sign.* sign k                  ≡⟨ Sign.*-assoc (sign i) (sign k) (sign k) ⟩
+    sign i Sign.* (sign k Sign.* sign k)  ≡⟨ cong (sign i Sign.*_) (Sign.s*s≡+ (sign k)) ⟩
+    sign i Sign.* Sign.+                  ≡⟨ Sign.*-identityʳ (sign i) ⟩
+    sign i                                ∎
     where open ≡-Reasoning
 
-  abs-eq : ∣ i ∣ ≡ ∣ ikq * k ∣
+  abs-eq : ∣ i ∣ ≡ ∣ s[i*k]◃q * k ∣
   abs-eq = sym $ begin
-    ∣ ikq * k ∣        ≡⟨ ∣i*j∣≡∣i∣*∣j∣ ikq k ⟩
-    ∣ ikq ∣ ℕ.* ∣ k ∣  ≡⟨ cong (ℕ._* ∣ k ∣) (abs-◃ (sign i S.* sign k) q) ⟩
-    q ℕ.* ∣ k ∣        ≡⟨ sym eq ⟩
-    ∣ i ∣              ∎
+    ∣ s[i*k]◃q * k ∣        ≡⟨ abs-* s[i*k]◃q k ⟩
+    ∣ s[i*k]◃q ∣ ℕ.* ∣ k ∣  ≡⟨ cong (ℕ._* ∣ k ∣) (abs-◃ s[i*k] q) ⟩
+    q ℕ.* ∣ k ∣             ≡⟨ eq ⟨
+    ∣ i ∣                   ∎
     where open ≡-Reasoning
 
-∣⇒∣ᵤ : ∀ {k i} → k ∣ i → k ∣ᵤ i
-∣⇒∣ᵤ {k} {i} (divides q eq) = divides ∣ q ∣ $′ begin
+∣⇒∣ᵤ : ∀ {k i} → k ∣ i → k Unsigned.∣ i
+∣⇒∣ᵤ {k} {i} (divides q eq) = Unsigned.divides ∣ q ∣ $′ begin
   ∣ i ∣           ≡⟨ cong ∣_∣ eq ⟩
   ∣ q * k ∣       ≡⟨ abs-* q k ⟩
   ∣ q ∣ ℕ.* ∣ k ∣ ∎
@@ -114,15 +112,13 @@ open _∣_ using (quotient) public
 -- Divisibility reasoning
 
 module ∣-Reasoning where
-  private
-    module Base = PreorderReasoning ∣-preorder
+  private module Base = ≲-Reasoning ∣-preorder
 
   open Base public
-    hiding (step-∼; step-≈; step-≈˘)
+    hiding (step-≲; step-∼; step-≈; step-≈˘)
+    renaming (≲-go to ∣-go)
 
-  infixr 2 step-∣
-  step-∣ = Base.step-∼
-  syntax step-∣ x y∣z x∣y = x ∣⟨ x∣y ⟩ y∣z
+  open ∣-syntax _IsRelatedTo_ _IsRelatedTo_ ∣-go public
 
 ------------------------------------------------------------------------
 -- Other properties of _∣_
@@ -130,7 +126,7 @@ module ∣-Reasoning where
 infix 4 _∣?_
 
 _∣?_ : Decidable _∣_
-k ∣? m = DEC.map′ ∣ᵤ⇒∣ ∣⇒∣ᵤ (∣ k ∣ ℕ.∣? ∣ m ∣)
+k ∣? m = Dec.map′ ∣ᵤ⇒∣ ∣⇒∣ᵤ (∣ k ∣ ℕ.∣? ∣ m ∣)
 
 0∣⇒≡0 : ∀ {m} → 0ℤ ∣ m → m ≡ 0ℤ
 0∣⇒≡0 0|m = ∣i∣≡0⇒i≡0 (ℕ.0∣⇒≡0 (∣⇒∣ᵤ 0|m))
@@ -148,7 +144,7 @@ m∣∣m∣ = ∣ᵤ⇒∣ ℕ.∣-refl
 ∣m⇒∣-m : ∀ {i m} → i ∣ m → i ∣ - m
 ∣m⇒∣-m {i} {m} i∣m = ∣ᵤ⇒∣ $′ begin
   ∣ i ∣   ∣⟨ ∣⇒∣ᵤ i∣m ⟩
-  ∣ m ∣   ≡⟨ sym (∣-i∣≡∣i∣ m) ⟩
+  ∣ m ∣   ≡⟨ ∣-i∣≡∣i∣ m ⟨
   ∣ - m ∣ ∎
   where open ℕ.∣-Reasoning
 
@@ -159,7 +155,7 @@ m∣∣m∣ = ∣ᵤ⇒∣ ℕ.∣-refl
 ∣m+n∣m⇒∣n {i} {m} {n} i∣m+n i∣m = begin
   i             ∣⟨ ∣m∣n⇒∣m-n i∣m+n i∣m ⟩
   m + n - m     ≡⟨ +-comm (m + n) (- m) ⟩
-  - m + (m + n) ≡⟨ sym (+-assoc (- m) m n) ⟩
+  - m + (m + n) ≡⟨ +-assoc (- m) m n ⟨
   - m + m + n   ≡⟨ cong (_+ n) (+-inverseˡ m) ⟩
   + 0 + n       ≡⟨ +-identityˡ n ⟩
   n             ∎
@@ -171,7 +167,7 @@ m∣∣m∣ = ∣ᵤ⇒∣ ℕ.∣-refl
 ∣n⇒∣m*n : ∀ {i} m {n} → i ∣ n → i ∣ m * n
 ∣n⇒∣m*n {i} m {n} (divides q eq) = divides (m * q) $′ begin
   m * n       ≡⟨ cong (m *_) eq ⟩
-  m * (q * i) ≡⟨ sym (*-assoc m q i) ⟩
+  m * (q * i) ≡⟨ *-assoc m q i ⟨
   m * q * i   ∎
   where open ≡-Reasoning
 
diff --git a/src/Data/Integer/GCD.agda b/src/Data/Integer/GCD.agda
index e087da4763..d34529ae16 100644
--- a/src/Data/Integer/GCD.agda
+++ b/src/Data/Integer/GCD.agda
@@ -11,10 +11,9 @@ module Data.Integer.GCD where
 open import Data.Integer.Base
 open import Data.Integer.Divisibility
 open import Data.Integer.Properties
-open import Data.Nat.Base
 import Data.Nat.GCD as ℕ
-open import Data.Product
-open import Relation.Binary.PropositionalEquality
+open import Data.Product.Base using (_,_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong)
 
 open import Algebra.Definitions {A = ℤ} _≡_ as Algebra
   using (Associative; Commutative; LeftIdentity; RightIdentity; LeftZero; RightZero; Zero)
diff --git a/src/Data/Integer/LCM.agda b/src/Data/Integer/LCM.agda
index ebcbc8ed73..065e0613b2 100644
--- a/src/Data/Integer/LCM.agda
+++ b/src/Data/Integer/LCM.agda
@@ -11,9 +11,8 @@ module Data.Integer.LCM where
 open import Data.Integer.Base
 open import Data.Integer.Divisibility
 open import Data.Integer.GCD
-open import Data.Nat.Base using (ℕ)
 import Data.Nat.LCM as ℕ
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong)
 
 ------------------------------------------------------------------------
 -- Definition
diff --git a/src/Data/Integer/Literals.agda b/src/Data/Integer/Literals.agda
index 5794f1ceef..d06be38eea 100644
--- a/src/Data/Integer/Literals.agda
+++ b/src/Data/Integer/Literals.agda
@@ -8,9 +8,9 @@
 
 module Data.Integer.Literals where
 
-open import Agda.Builtin.FromNat
-open import Agda.Builtin.FromNeg
-open import Data.Unit using (⊤)
+open import Agda.Builtin.FromNat using (Number)
+open import Agda.Builtin.FromNeg using (Negative)
+open import Data.Unit.Base using (⊤)
 open import Data.Integer.Base using (ℤ; -_; +_)
 
 number : Number ℤ
diff --git a/src/Data/Integer/Properties.agda b/src/Data/Integer/Properties.agda
index 518c1456f4..f89d3164f6 100644
--- a/src/Data/Integer/Properties.agda
+++ b/src/Data/Integer/Properties.agda
@@ -16,23 +16,31 @@ import Algebra.Lattice.Construct.NaturalChoice.MinMaxOp as LatticeMinMaxOp
 import Algebra.Properties.AbelianGroup
 open import Data.Bool.Base using (T; true; false)
 open import Data.Integer.Base renaming (suc to sucℤ)
-open import Data.Nat as ℕ
-  using (ℕ; suc; zero; _∸_; s≤s; z≤n; s<s; z<s)
+open import Data.Integer.Properties.NatLemmas
+open import Data.Nat.Base as ℕ
+  using (ℕ; suc; zero; _∸_; s≤s; z≤n; s<s; z<s; s≤s⁻¹; s<s⁻¹)
   hiding (module ℕ)
 import Data.Nat.Properties as ℕ
-open import Data.Nat.Solver
-open import Data.Product using (proj₁; proj₂; _,_)
+open import Data.Product.Base using (proj₁; proj₂; _,_; _×_)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_]′)
-open import Data.Sign as Sign using (Sign) renaming (_*_ to _𝕊*_)
-import Data.Sign.Properties as 𝕊ₚ
-open import Data.Product using (_×_)
+open import Data.Sign.Base as Sign using (Sign)
+import Data.Sign.Properties as Sign
 open import Function.Base using (_∘_; _$_; id)
 open import Level using (0ℓ)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
-open import Relation.Nullary using (yes; no; ¬_)
+open import Relation.Binary.Core using (_⇒_; _Preserves_⟶_; _Preserves₂_⟶_⟶_)
+open import Relation.Binary.Bundles using
+  (Setoid; DecSetoid; Preorder; TotalPreorder; Poset; TotalOrder; DecTotalOrder; StrictPartialOrder; StrictTotalOrder)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsTotalPreorder; IsPartialOrder; IsTotalOrder; IsDecTotalOrder; IsStrictPartialOrder; IsStrictTotalOrder)
+open import Relation.Binary.Definitions
+  using (DecidableEquality; Reflexive; Transitive; Antisymmetric; Total; Decidable; Irrelevant; Irreflexive; Asymmetric; LeftTrans; RightTrans; Trichotomous; tri≈; tri<; tri>)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂; sym; _≢_; subst; resp₂; trans)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning; setoid; decSetoid; isEquivalence)
+open import Relation.Nullary.Decidable.Core using (yes; no)
 import Relation.Nullary.Reflects as Reflects
-open import Relation.Nullary.Negation using (contradiction)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
 import Relation.Nullary.Decidable as Dec
 
 open import Algebra.Definitions {A = ℤ} _≡_
@@ -40,7 +48,6 @@ open import Algebra.Consequences.Propositional
 open import Algebra.Structures {A = ℤ} _≡_
 module ℤtoℕ = Morphism.Definitions ℤ ℕ _≡_
 module ℕtoℤ = Morphism.Definitions ℕ ℤ _≡_
-open +-*-Solver
 
 private
   variable
@@ -271,17 +278,17 @@ drop‿-<- (-<- n<m) = n<m
 <-asym (-<- n<m) = ℕ.<-asym n<m ∘ drop‿-<-
 <-asym (+<+ m<n) = ℕ.<-asym m<n ∘ drop‿+<+
 
-≤-<-trans : Trans _≤_ _<_ _<_
-≤-<-trans (-≤- n≤m) (-<- o<n) = -<- (ℕ.<-transˡ o<n n≤m)
+≤-<-trans : LeftTrans _≤_ _<_
+≤-<-trans (-≤- n≤m) (-<- o<n) = -<- (ℕ.<-≤-trans o<n n≤m)
 ≤-<-trans (-≤- n≤m) -<+       = -<+
 ≤-<-trans -≤+       (+<+ m<o) = -<+
-≤-<-trans (+≤+ m≤n) (+<+ n<o) = +<+ (ℕ.<-transʳ m≤n n<o)
+≤-<-trans (+≤+ m≤n) (+<+ n<o) = +<+ (ℕ.≤-<-trans m≤n n<o)
 
-<-≤-trans : Trans _<_ _≤_ _<_
-<-≤-trans (-<- n<m) (-≤- o≤n) = -<- (ℕ.<-transʳ o≤n n<m)
+<-≤-trans : RightTrans _<_ _≤_
+<-≤-trans (-<- n<m) (-≤- o≤n) = -<- (ℕ.≤-<-trans o≤n n<m)
 <-≤-trans (-<- n<m) -≤+       = -<+
 <-≤-trans -<+       (+≤+ m≤n) = -<+
-<-≤-trans (+<+ m<n) (+≤+ n≤o) = +<+ (ℕ.<-transˡ m<n n≤o)
+<-≤-trans (+<+ m<n) (+≤+ n≤o) = +<+ (ℕ.<-≤-trans m<n n≤o)
 
 <-trans : Transitive _<_
 <-trans m<n n<p = ≤-<-trans (<⇒≤ m<n) n<p
@@ -297,9 +304,9 @@ drop‿-<- (-<- n<m) = n<m
 ... | tri≈ m≮n m≡n n≯m = tri≈ (n≯m ∘ drop‿-<-) (cong -[1+_] m≡n) (m≮n ∘ drop‿-<-)
 ... | tri> m≮n m≢n n>m = tri< (-<- n>m) (m≢n ∘ -[1+-injective) (m≮n ∘ drop‿-<-)
 <-cmp +[1+ m ] +[1+ n ] with ℕ.<-cmp m n
-... | tri< m<n m≢n n≯m = tri< (+<+ (s<s m<n))              (m≢n ∘ +[1+-injective) (n≯m ∘ ℕ.≤-pred ∘ drop‿+<+)
-... | tri≈ m≮n m≡n n≯m = tri≈ (m≮n ∘ ℕ.≤-pred ∘ drop‿+<+) (cong (+_ ∘ suc) m≡n)  (n≯m ∘ ℕ.≤-pred ∘ drop‿+<+)
-... | tri> m≮n m≢n n>m = tri> (m≮n ∘ ℕ.≤-pred ∘ drop‿+<+) (m≢n ∘ +[1+-injective) (+<+ (s<s n>m))
+... | tri< m<n m≢n n≯m = tri< (+<+ (s<s m<n))              (m≢n ∘ +[1+-injective) (n≯m ∘ s<s⁻¹ ∘ drop‿+<+)
+... | tri≈ m≮n m≡n n≯m = tri≈ (m≮n ∘ s<s⁻¹ ∘ drop‿+<+) (cong (+_ ∘ suc) m≡n)  (n≯m ∘ s<s⁻¹ ∘ drop‿+<+)
+... | tri> m≮n m≢n n>m = tri> (m≮n ∘ s<s⁻¹ ∘ drop‿+<+) (m≢n ∘ +[1+-injective) (+<+ (s<s n>m))
 
 infix 4 _<?_
 _<?_ : Decidable _<_
@@ -326,9 +333,8 @@ _<?_ : Decidable _<_
 
 <-isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_
 <-isStrictTotalOrder = record
-  { isEquivalence = isEquivalence
-  ; trans         = <-trans
-  ; compare       = <-cmp
+  { isStrictPartialOrder = <-isStrictPartialOrder
+  ; compare              = <-cmp
   }
 
 ------------------------------------------------------------------------
@@ -360,13 +366,14 @@ i≮i = <-irrefl refl
 module ≤-Reasoning where
   open import Relation.Binary.Reasoning.Base.Triple
     ≤-isPreorder
+    <-asym
     <-trans
     (resp₂ _<_)
     <⇒≤
     <-≤-trans
     ≤-<-trans
     public
-    hiding (step-≈; step-≈˘)
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨)
 
 ------------------------------------------------------------------------
 -- Properties of Positive/NonPositive/Negative/NonNegative and _≤_/_<_
@@ -398,7 +405,7 @@ neg-involutive +[1+ n ] = refl
 
 neg-injective : - i ≡ - j → i ≡ j
 neg-injective {i} {j} -i≡-j = begin
-  i     ≡˘⟨ neg-involutive i ⟩
+  i     ≡⟨ neg-involutive i ⟨
   - - i ≡⟨  cong -_ -i≡-j ⟩
   - - j ≡⟨  neg-involutive j ⟩
   j     ∎ where open ≡-Reasoning
@@ -427,7 +434,7 @@ neg-mono-< { -[1+ _ ]} { -[1+ _ ]} (-<- n<m) = +<+ (s<s n<m)
 neg-mono-< { -[1+ _ ]} { +0}       -<+       = +<+ z<s
 neg-mono-< { -[1+ _ ]} { +[1+ n ]} -<+       = -<+
 neg-mono-< { +0}       { +[1+ n ]} (+<+ _)   = -<+
-neg-mono-< { +[1+ m ]} { +[1+ n ]} (+<+ m<n) = -<- (ℕ.≤-pred m<n)
+neg-mono-< { +[1+ m ]} { +[1+ n ]} (+<+ m<n) = -<- (s<s⁻¹ m<n)
 
 neg-cancel-< : - i < - j → i > j
 neg-cancel-< { +[1+ m ]} { +[1+ n ]} (-<- n<m)       = +<+ (s<s n<m)
@@ -436,7 +443,7 @@ neg-cancel-< { +[1+ m ]} { -[1+ n ]}  -<+            = -<+
 neg-cancel-< { +0}       { +0}       (+<+ ())
 neg-cancel-< { +0}       { -[1+ n ]} _               = -<+
 neg-cancel-< { -[1+ m ]} { +0}       (+<+ ())
-neg-cancel-< { -[1+ m ]} { -[1+ n ]} (+<+ (s<s m<n)) = -<- m<n
+neg-cancel-< { -[1+ m ]} { -[1+ n ]} (+<+ m<n) = -<- (s<s⁻¹ m<n)
 
 ------------------------------------------------------------------------
 -- Properties of ∣_∣
@@ -503,6 +510,10 @@ neg-cancel-< { -[1+ m ]} { -[1+ n ]} (+<+ (s<s m<n)) = -<- m<n
 ------------------------------------------------------------------------
 -- Properties of sign and _◃_
 
+◃-nonZero : ∀ s n .{{_ : ℕ.NonZero n}} → NonZero (s ◃ n)
+◃-nonZero Sign.- (ℕ.suc _) = _
+◃-nonZero Sign.+ (ℕ.suc _) = _
+
 ◃-inverse : ∀ i → sign i ◃ ∣ i ∣ ≡ i
 ◃-inverse -[1+ n ] = refl
 ◃-inverse +0       = refl
@@ -536,7 +547,7 @@ signᵢ◃∣i∣≡i -[1+ n ] = refl
 sign-cong : .{{_ : ℕ.NonZero m}} .{{_ : ℕ.NonZero n}} →
             s ◃ m ≡ t ◃ n → s ≡ t
 sign-cong {n@(suc _)} {m@(suc _)} {s} {t} eq = begin
-  s             ≡˘⟨ sign-◃ s n ⟩
+  s             ≡⟨ sign-◃ s n ⟨
   sign (s ◃ n)  ≡⟨  cong sign eq ⟩
   sign (t ◃ m)  ≡⟨  sign-◃ t m ⟩
   t             ∎ where open ≡-Reasoning
@@ -551,7 +562,7 @@ sign-cong′ {s}       {suc m} {t}       {suc n} eq = inj₁ (sign-cong eq)
 
 abs-cong : s ◃ m ≡ t ◃ n → m ≡ n
 abs-cong {s} {m} {t} {n} eq = begin
-  m          ≡˘⟨ abs-◃ s m ⟩
+  m          ≡⟨ abs-◃ s m ⟨
   ∣ s ◃ m ∣  ≡⟨  cong ∣_∣ eq ⟩
   ∣ t ◃ n ∣  ≡⟨  abs-◃ t n ⟩
   n          ∎ where open ≡-Reasoning
@@ -603,12 +614,12 @@ n⊖n≡0 n with n ℕ.<ᵇ n in leq
 ⊖-swap (suc m) (suc n) = begin
   suc m ⊖ suc n     ≡⟨ [1+m]⊖[1+n]≡m⊖n m n ⟩
   m ⊖ n             ≡⟨ ⊖-swap m n ⟩
-  - (n ⊖ m)         ≡˘⟨ cong -_ ([1+m]⊖[1+n]≡m⊖n n m) ⟩
+  - (n ⊖ m)         ≡⟨ cong -_ ([1+m]⊖[1+n]≡m⊖n n m) ⟨
   - (suc n ⊖ suc m) ∎ where open ≡-Reasoning
 
 ⊖-≥ : m ℕ.≥ n → m ⊖ n ≡ + (m ∸ n)
 ⊖-≥ {m} {n} p with m ℕ.<ᵇ n | Reflects.invert (ℕ.<ᵇ-reflects-< m n)
-... | true  | q = contradiction (ℕ.<-transʳ p q) (ℕ.<-irrefl refl)
+... | true  | q = contradiction (ℕ.≤-<-trans p q) (ℕ.<-irrefl refl)
 ... | false | q = refl
 
 ≤-⊖ : m ℕ.≤ n → n ⊖ m ≡ + (n ∸ m)
@@ -661,12 +672,12 @@ m-n≡m⊖n (suc m) (suc n) = refl
 -[n⊖m]≡-m+n m n with m ℕ.<ᵇ n | Reflects.invert (ℕ.<ᵇ-reflects-< m n)
 ... | true  | p = begin
   - (- (+ (n ∸ m))) ≡⟨ neg-involutive (+ (n ∸ m)) ⟩
-  + (n ∸ m)         ≡˘⟨ ⊖-≥ (ℕ.≤-trans (ℕ.m≤n+m m 1) p) ⟩
-  n ⊖ m             ≡˘⟨ -m+n≡n⊖m m n ⟩
+  + (n ∸ m)         ≡⟨ ⊖-≥ (ℕ.≤-trans (ℕ.m≤n+m m 1) p) ⟨
+  n ⊖ m             ≡⟨ -m+n≡n⊖m m n ⟨
   - (+ m) + + n     ∎ where open ≡-Reasoning
 ... | false | p = begin
-  - (+ (m ∸ n))     ≡˘⟨ ⊖-≤ (ℕ.≮⇒≥ p) ⟩
-  n ⊖ m             ≡˘⟨ -m+n≡n⊖m m n ⟩
+  - (+ (m ∸ n))     ≡⟨ ⊖-≤ (ℕ.≮⇒≥ p) ⟨
+  n ⊖ m             ≡⟨ -m+n≡n⊖m m n ⟨
   - (+ m) + + n     ∎ where open ≡-Reasoning
 
 ∣m⊖n∣≡∣n⊖m∣ : ∀ m n → ∣ m ⊖ n ∣ ≡ ∣ n ⊖ m ∣
@@ -707,14 +718,14 @@ m⊖1+n<m (suc m) (suc n) = begin-strict
 -1+m<n⊖m (suc m) (suc n) = begin-strict
   -[1+ suc m ]  <⟨ -<- ℕ.≤-refl ⟩
   -[1+ m ]      <⟨ -1+m<n⊖m m n ⟩
-  n ⊖ m         ≡˘⟨ [1+m]⊖[1+n]≡m⊖n n m ⟩
+  n ⊖ m         ≡⟨ [1+m]⊖[1+n]≡m⊖n n m ⟨
   suc n ⊖ suc m ∎ where open ≤-Reasoning
 
 -[1+m]≤n⊖m+1 : ∀ m n → -[1+ m ] ≤ n ⊖ suc m
 -[1+m]≤n⊖m+1 m zero    = ≤-refl
 -[1+m]≤n⊖m+1 m (suc n) = begin
   -[1+ m ]      ≤⟨ <⇒≤ (-1+m<n⊖m m n) ⟩
-  n ⊖ m         ≡˘⟨ [1+m]⊖[1+n]≡m⊖n n m ⟩
+  n ⊖ m         ≡⟨ [1+m]⊖[1+n]≡m⊖n n m ⟨
   suc n ⊖ suc m ∎ where open ≤-Reasoning
 
 -1+m≤n⊖m : ∀ m n → -[1+ m ] ≤ n ⊖ m
@@ -745,7 +756,7 @@ sign-⊖-≰ = sign-⊖-< ∘ ℕ.≰⇒>
 ⊖-monoʳ-≥-≤ (suc n) {suc m} {suc o} (s≤s m≤o) = begin
   suc n ⊖ suc m ≡⟨  [1+m]⊖[1+n]≡m⊖n n m ⟩
   n ⊖ m         ≤⟨  ⊖-monoʳ-≥-≤ n m≤o ⟩
-  n ⊖ o         ≡˘⟨ [1+m]⊖[1+n]≡m⊖n n o ⟩
+  n ⊖ o         ≡⟨ [1+m]⊖[1+n]≡m⊖n n o ⟨
   suc n ⊖ suc o ∎ where open ≤-Reasoning
 
 ⊖-monoˡ-≤ : ∀ n → (_⊖ n) Preserves ℕ._≤_ ⟶ _≤_
@@ -754,12 +765,12 @@ sign-⊖-≰ = sign-⊖-< ∘ ℕ.≰⇒>
 ⊖-monoˡ-≤ (suc n) {_} {suc o} z≤n = begin
   zero ⊖ suc n  ≤⟨  ⊖-monoʳ-≥-≤ 0 (ℕ.n≤1+n n) ⟩
   zero ⊖ n      ≤⟨  ⊖-monoˡ-≤ n z≤n ⟩
-  o ⊖ n         ≡˘⟨ [1+m]⊖[1+n]≡m⊖n o n ⟩
+  o ⊖ n         ≡⟨ [1+m]⊖[1+n]≡m⊖n o n ⟨
   suc o ⊖ suc n ∎ where open ≤-Reasoning
 ⊖-monoˡ-≤ (suc n) {suc m} {suc o} (s≤s m≤o) = begin
   suc m ⊖ suc n ≡⟨  [1+m]⊖[1+n]≡m⊖n m n ⟩
   m ⊖ n         ≤⟨  ⊖-monoˡ-≤ n m≤o ⟩
-  o ⊖ n         ≡˘⟨ [1+m]⊖[1+n]≡m⊖n o n ⟩
+  o ⊖ n         ≡⟨ [1+m]⊖[1+n]≡m⊖n o n ⟨
   suc o ⊖ suc n ∎ where open ≤-Reasoning
 
 ⊖-monoʳ->-< : ∀ p → (p ⊖_) Preserves ℕ._>_ ⟶ _<_
@@ -772,19 +783,19 @@ sign-⊖-≰ = sign-⊖-< ∘ ℕ.≰⇒>
 ⊖-monoʳ->-< (suc p) {suc m} {suc n} (s<s m<n@(s≤s _)) = begin-strict
   suc p ⊖ suc m ≡⟨  [1+m]⊖[1+n]≡m⊖n p m ⟩
   p ⊖ m         <⟨  ⊖-monoʳ->-< p m<n ⟩
-  p ⊖ n         ≡˘⟨ [1+m]⊖[1+n]≡m⊖n p n ⟩
+  p ⊖ n         ≡⟨ [1+m]⊖[1+n]≡m⊖n p n ⟨
   suc p ⊖ suc n ∎ where open ≤-Reasoning
 
 ⊖-monoˡ-< : ∀ n → (_⊖ n) Preserves ℕ._<_ ⟶ _<_
 ⊖-monoˡ-< zero    m<o             = +<+ m<o
 ⊖-monoˡ-< (suc n) {_} {suc o} z<s = begin-strict
   -[1+ n ]      <⟨  -1+m<n⊖m n _ ⟩
-  o ⊖ n         ≡˘⟨ [1+m]⊖[1+n]≡m⊖n o n ⟩
+  o ⊖ n         ≡⟨ [1+m]⊖[1+n]≡m⊖n o n ⟨
   suc o ⊖ suc n ∎ where open ≤-Reasoning
 ⊖-monoˡ-< (suc n) {suc m} {suc (suc o)} (s<s m<o@(s≤s _)) = begin-strict
   suc m ⊖ suc n       ≡⟨  [1+m]⊖[1+n]≡m⊖n m n ⟩
   m ⊖ n               <⟨  ⊖-monoˡ-< n m<o ⟩
-  suc o ⊖ n           ≡˘⟨ [1+m]⊖[1+n]≡m⊖n (suc o) n ⟩
+  suc o ⊖ n           ≡⟨ [1+m]⊖[1+n]≡m⊖n (suc o) n ⟨
   suc (suc o) ⊖ suc n ∎ where open ≤-Reasoning
 
 ------------------------------------------------------------------------
@@ -805,7 +816,7 @@ sign-⊖-≰ = sign-⊖-< ∘ ℕ.≰⇒>
 +-identityˡ (+ _)    = refl
 
 +-identityʳ : RightIdentity +0 _+_
-+-identityʳ = comm+idˡ⇒idʳ +-comm +-identityˡ
++-identityʳ = comm∧idˡ⇒idʳ +-comm +-identityˡ
 
 +-identity : Identity +0 _+_
 +-identity = +-identityˡ , +-identityʳ
@@ -817,7 +828,7 @@ distribˡ-⊖-+-pos _ (suc _) zero    = refl
 distribˡ-⊖-+-pos m (suc n) (suc o) = begin
   suc n ⊖ suc o + + m   ≡⟨ cong (_+ + m) ([1+m]⊖[1+n]≡m⊖n n o) ⟩
   n ⊖ o + + m           ≡⟨ distribˡ-⊖-+-pos m n o ⟩
-  n ℕ.+ m ⊖ o           ≡˘⟨ [1+m]⊖[1+n]≡m⊖n (n ℕ.+ m) o ⟩
+  n ℕ.+ m ⊖ o           ≡⟨ [1+m]⊖[1+n]≡m⊖n (n ℕ.+ m) o ⟨
   suc (n ℕ.+ m) ⊖ suc o ∎ where open ≡-Reasoning
 
 distribˡ-⊖-+-neg : ∀ m n o → n ⊖ o + -[1+ m ] ≡ n ⊖ (suc o ℕ.+ m)
@@ -827,7 +838,7 @@ distribˡ-⊖-+-neg _ (suc _) zero    = refl
 distribˡ-⊖-+-neg m (suc n) (suc o) = begin
   suc n ⊖ suc o + -[1+ m ]    ≡⟨ cong (_+ -[1+ m ]) ([1+m]⊖[1+n]≡m⊖n n o) ⟩
   n ⊖ o + -[1+ m ]            ≡⟨ distribˡ-⊖-+-neg m n o ⟩
-  n ⊖ (suc o ℕ.+ m)           ≡˘⟨ [1+m]⊖[1+n]≡m⊖n n (suc o ℕ.+ m) ⟩
+  n ⊖ (suc o ℕ.+ m)           ≡⟨ [1+m]⊖[1+n]≡m⊖n n (suc o ℕ.+ m) ⟨
   suc n ⊖ (suc (suc o) ℕ.+ m) ∎ where open ≡-Reasoning
 
 distribʳ-⊖-+-pos : ∀ m n o → + m + (n ⊖ o) ≡ m ℕ.+ n ⊖ o
@@ -850,18 +861,18 @@ distribʳ-⊖-+-neg m n o = begin
 +-assoc i j +0 rewrite +-identityʳ (i + j) | +-identityʳ  j      = refl
 +-assoc -[1+ m ] -[1+ n ] +[1+ o ] = begin
   suc o ⊖ suc (suc (m ℕ.+ n)) ≡⟨ [1+m]⊖[1+n]≡m⊖n o (suc m ℕ.+ n) ⟩
-  o ⊖ (suc m ℕ.+ n)           ≡˘⟨ distribʳ-⊖-+-neg m o n ⟩
-  -[1+ m ] + (o ⊖ n)          ≡˘⟨ cong (λ z → -[1+ m ] + z) ([1+m]⊖[1+n]≡m⊖n o n) ⟩
+  o ⊖ (suc m ℕ.+ n)           ≡⟨ distribʳ-⊖-+-neg m o n ⟨
+  -[1+ m ] + (o ⊖ n)          ≡⟨ cong (λ z → -[1+ m ] + z) ([1+m]⊖[1+n]≡m⊖n o n) ⟨
   -[1+ m ] + (suc o ⊖ suc n)  ∎ where open ≡-Reasoning
 +-assoc -[1+ m ] +[1+ n ] +[1+ o ] = begin
   suc n ⊖ suc m + +[1+ o ]  ≡⟨ cong (_+ +[1+ o ]) ([1+m]⊖[1+n]≡m⊖n n m) ⟩
   (n ⊖ m) + +[1+ o ]        ≡⟨ distribˡ-⊖-+-pos (suc o) n m ⟩
-  n ℕ.+ suc o ⊖ m           ≡˘⟨ [1+m]⊖[1+n]≡m⊖n (n ℕ.+ suc o) m ⟩
+  n ℕ.+ suc o ⊖ m           ≡⟨ [1+m]⊖[1+n]≡m⊖n (n ℕ.+ suc o) m ⟨
   suc (n ℕ.+ suc o) ⊖ suc m ∎ where open ≡-Reasoning
 +-assoc +[1+ m ] -[1+ n ] -[1+ o ] = begin
   (suc m ⊖ suc n) + -[1+ o ]  ≡⟨ cong (_+ -[1+ o ]) ([1+m]⊖[1+n]≡m⊖n m n) ⟩
   (m ⊖ n) + -[1+ o ]          ≡⟨ distribˡ-⊖-+-neg o m n ⟩
-  m ⊖ suc (n ℕ.+ o)           ≡˘⟨ [1+m]⊖[1+n]≡m⊖n m (suc n ℕ.+ o) ⟩
+  m ⊖ suc (n ℕ.+ o)           ≡⟨ [1+m]⊖[1+n]≡m⊖n m (suc n ℕ.+ o) ⟨
   suc m ⊖ suc (suc (n ℕ.+ o)) ∎ where open ≡-Reasoning
 +-assoc +[1+ m ] -[1+ n ] +[1+ o ]
   rewrite [1+m]⊖[1+n]≡m⊖n m n
@@ -899,7 +910,7 @@ distribʳ-⊖-+-neg m n o = begin
 +-inverseˡ +[1+ n ] = n⊖n≡0 (suc n)
 
 +-inverseʳ : RightInverse +0 -_ _+_
-+-inverseʳ = comm+invˡ⇒invʳ +-comm +-inverseˡ
++-inverseʳ = comm∧invˡ⇒invʳ +-comm +-inverseˡ
 
 +-inverse : Inverse +0 -_ _+_
 +-inverse = +-inverseˡ , +-inverseʳ
@@ -1082,8 +1093,8 @@ neg-minus-pos (suc m) (suc n) = cong (-[1+_] ∘ suc) (ℕ.+-comm (suc m) n)
 +-minus-telescope : ∀ i j k → (i - j) + (j - k) ≡ i - k
 +-minus-telescope i j k = begin
   (i - j) + (j - k)   ≡⟨  +-assoc i (- j) (j - k) ⟩
-  i + (- j + (j - k)) ≡˘⟨ cong (λ v → i + v) (+-assoc (- j) j _) ⟩
-  i + ((- j + j) - k) ≡˘⟨ +-assoc i (- j + j) (- k) ⟩
+  i + (- j + (j - k)) ≡⟨ cong (λ v → i + v) (+-assoc (- j) j _) ⟨
+  i + ((- j + j) - k) ≡⟨ +-assoc i (- j + j) (- k) ⟨
   i + (- j + j) - k   ≡⟨  cong (λ a → i + a - k) (+-inverseˡ j) ⟩
   i + 0ℤ - k          ≡⟨  cong (_- k) (+-identityʳ i) ⟩
   i - k               ∎ where open ≡-Reasoning
@@ -1098,16 +1109,16 @@ neg-minus-pos (suc m) (suc n) = cong (-[1+_] ∘ suc) (ℕ.+-comm (suc m) n)
 ∣i-j∣≡∣j-i∣ -[1+ m ] -[1+ n ] = ∣m⊖n∣≡∣n⊖m∣ (suc n) (suc m)
 ∣i-j∣≡∣j-i∣ -[1+ m ] (+ n)    = begin
   ∣ -[1+ m ] - (+ n) ∣  ≡⟨  cong ∣_∣ (neg-minus-pos m n) ⟩
-  suc (n ℕ.+ m)         ≡˘⟨ ℕ.+-suc n m ⟩
+  suc (n ℕ.+ m)         ≡⟨ ℕ.+-suc n m ⟨
   n ℕ.+ suc m           ∎ where open ≡-Reasoning
 ∣i-j∣≡∣j-i∣ (+ m) -[1+ n ] = begin
   m ℕ.+ suc n          ≡⟨  ℕ.+-suc m n ⟩
-  suc (m ℕ.+ n)        ≡˘⟨ cong ∣_∣ (neg-minus-pos n m) ⟩
+  suc (m ℕ.+ n)        ≡⟨ cong ∣_∣ (neg-minus-pos n m) ⟨
   ∣ -[1+ n ] + - + m ∣ ∎ where open ≡-Reasoning
 ∣i-j∣≡∣j-i∣ (+ m) (+ n) = begin
   ∣ + m - + n ∣  ≡⟨  cong ∣_∣ ([+m]-[+n]≡m⊖n m n) ⟩
   ∣ m ⊖ n ∣      ≡⟨  ∣m⊖n∣≡∣n⊖m∣ m n ⟩
-  ∣ n ⊖ m ∣      ≡˘⟨ cong ∣_∣ ([+m]-[+n]≡m⊖n n m) ⟩
+  ∣ n ⊖ m ∣      ≡⟨ cong ∣_∣ ([+m]-[+n]≡m⊖n n m) ⟨
   ∣ + n - + m ∣  ∎ where open ≡-Reasoning
 
 ∣-∣-≤ : i ≤ j → + ∣ i - j ∣ ≡ j - i
@@ -1135,9 +1146,9 @@ i≡j⇒i-j≡0 {i} refl = +-inverseʳ i
 
 i-j≡0⇒i≡j : ∀ i j → i - j ≡ 0ℤ → i ≡ j
 i-j≡0⇒i≡j i j i-j≡0 = begin
-  i             ≡˘⟨ +-identityʳ i ⟩
-  i + 0ℤ        ≡˘⟨ cong (_+_ i) (+-inverseˡ j) ⟩
-  i + (- j + j) ≡˘⟨ +-assoc i (- j) j ⟩
+  i             ≡⟨ +-identityʳ i ⟨
+  i + 0ℤ        ≡⟨ cong (_+_ i) (+-inverseˡ j) ⟨
+  i + (- j + j) ≡⟨ +-assoc i (- j) j ⟨
   (i - j) + j   ≡⟨  cong (_+ j) i-j≡0 ⟩
   0ℤ + j        ≡⟨  +-identityˡ j ⟩
   j             ∎ where open ≡-Reasoning
@@ -1167,9 +1178,9 @@ i≤j⇒i-j≤0 {+[1+ m ]} {+[1+ n ]} (+≤+ (s≤s m≤n)) = begin
 
 i-j≤0⇒i≤j : i - j ≤ 0ℤ → i ≤ j
 i-j≤0⇒i≤j {i} {j} i-j≤0 = begin
-  i             ≡˘⟨ +-identityʳ i ⟩
-  i + 0ℤ        ≡˘⟨ cong (_+_ i) (+-inverseˡ j) ⟩
-  i + (- j + j) ≡˘⟨ +-assoc i (- j) j ⟩
+  i             ≡⟨ +-identityʳ i ⟨
+  i + 0ℤ        ≡⟨ cong (_+_ i) (+-inverseˡ j) ⟨
+  i + (- j + j) ≡⟨ +-assoc i (- j) j ⟨
   (i - j) + j   ≤⟨  +-monoˡ-≤ j i-j≤0 ⟩
   0ℤ + j        ≡⟨  +-identityˡ j ⟩
   j             ∎
@@ -1177,14 +1188,14 @@ i-j≤0⇒i≤j {i} {j} i-j≤0 = begin
 
 i≤j⇒0≤j-i : i ≤ j → 0ℤ ≤ j - i
 i≤j⇒0≤j-i {i} {j} i≤j = begin
-  0ℤ    ≡˘⟨ +-inverseʳ i ⟩
+  0ℤ    ≡⟨ +-inverseʳ i ⟨
   i - i ≤⟨  +-monoˡ-≤ (- i) i≤j ⟩
   j - i ∎
   where open ≤-Reasoning
 
 0≤i-j⇒j≤i : 0ℤ ≤ i - j → j ≤ i
 0≤i-j⇒j≤i {i} {j} 0≤i-j = begin
-  j             ≡˘⟨ +-identityˡ j ⟩
+  j             ≡⟨ +-identityˡ j ⟨
   0ℤ + j        ≤⟨  +-monoˡ-≤ j 0≤i-j ⟩
   i - j + j     ≡⟨  +-assoc i (- j) j ⟩
   i + (- j + j) ≡⟨  cong (_+_ i) (+-inverseˡ j) ⟩
@@ -1227,12 +1238,12 @@ suc[i]≤j⇒i<j : sucℤ i ≤ j → i < j
 suc[i]≤j⇒i<j {+ i}           {+ _}       (+≤+ i≤j) = +<+ i≤j
 suc[i]≤j⇒i<j { -[1+ 0 ]}     {+ j}       p         = -<+
 suc[i]≤j⇒i<j { -[1+ suc i ]} {+ j}       -≤+       = -<+
-suc[i]≤j⇒i<j { -[1+ suc i ]} { -[1+ j ]} (-≤- j≤i) = -<- (ℕ.s≤s j≤i)
+suc[i]≤j⇒i<j { -[1+ suc i ]} { -[1+ j ]} (-≤- j≤i) = -<- (s≤s j≤i)
 
 i<j⇒suc[i]≤j : i < j → sucℤ i ≤ j
 i<j⇒suc[i]≤j {+ _}           {+ _}       (+<+ i<j) = +≤+ i<j
 i<j⇒suc[i]≤j { -[1+ 0 ]}     {+ _}       -<+       = +≤+ z≤n
-i<j⇒suc[i]≤j { -[1+ suc i ]} { -[1+ _ ]} (-<- j<i) = -≤- (ℕ.≤-pred j<i)
+i<j⇒suc[i]≤j { -[1+ suc i ]} { -[1+ _ ]} (-<- j<i) = -≤- (s≤s⁻¹ j<i)
 i<j⇒suc[i]≤j { -[1+ suc i ]} {+ _}       -<+       = -≤+
 
 ------------------------------------------------------------------------
@@ -1241,19 +1252,19 @@ i<j⇒suc[i]≤j { -[1+ suc i ]} {+ _}       -<+       = -≤+
 
 suc-pred : ∀ i → sucℤ (pred i) ≡ i
 suc-pred i = begin
-  sucℤ (pred i) ≡˘⟨ +-assoc 1ℤ -1ℤ i ⟩
+  sucℤ (pred i) ≡⟨ +-assoc 1ℤ -1ℤ i ⟨
   0ℤ + i        ≡⟨  +-identityˡ i ⟩
   i             ∎ where open ≡-Reasoning
 
 pred-suc : ∀ i → pred (sucℤ i) ≡ i
 pred-suc i = begin
-  pred (sucℤ i) ≡˘⟨ +-assoc -1ℤ 1ℤ i ⟩
+  pred (sucℤ i) ≡⟨ +-assoc -1ℤ 1ℤ i ⟨
   0ℤ + i        ≡⟨  +-identityˡ i ⟩
   i             ∎ where open ≡-Reasoning
 
 +-pred : ∀ i j → i + pred j ≡ pred (i + j)
 +-pred i j = begin
-  i + (-1ℤ + j) ≡˘⟨ +-assoc i -1ℤ j ⟩
+  i + (-1ℤ + j) ≡⟨ +-assoc i -1ℤ j ⟨
   i + -1ℤ + j   ≡⟨  cong (_+ j) (+-comm i -1ℤ) ⟩
   -1ℤ + i + j   ≡⟨  +-assoc -1ℤ i j ⟩
   -1ℤ + (i + j) ∎ where open ≡-Reasoning
@@ -1282,7 +1293,7 @@ i≤pred[j]⇒i<j {_} { -[1+ n ]} leq = ≤-<-trans leq (-<- ℕ.≤-refl)
 i<j⇒i≤pred[j] : i < j → i ≤ pred j
 i<j⇒i≤pred[j] {_} { +0}       -<+       = -≤- z≤n
 i<j⇒i≤pred[j] {_} { +[1+ n ]} -<+       = -≤+
-i<j⇒i≤pred[j] {_} { +[1+ n ]} (+<+ m<n) = +≤+ (ℕ.≤-pred m<n)
+i<j⇒i≤pred[j] {_} { +[1+ n ]} (+<+ m<n) = +≤+ (s≤s⁻¹ m<n)
 i<j⇒i≤pred[j] {_} { -[1+ n ]} (-<- n<m) = -≤- n<m
 
 i≤j⇒pred[i]≤j : i ≤ j → pred i ≤ j
@@ -1314,7 +1325,7 @@ pred-mono (+≤+ m≤n)         = ⊖-monoˡ-≤ 1 m≤n
 *-identityˡ +[1+ n ] rewrite ℕ.+-identityʳ n = refl
 
 *-identityʳ : RightIdentity 1ℤ _*_
-*-identityʳ = comm+idˡ⇒idʳ *-comm *-identityˡ
+*-identityʳ = comm∧idˡ⇒idʳ *-comm *-identityˡ
 
 *-identity : Identity 1ℤ _*_
 *-identity = *-identityˡ , *-identityʳ
@@ -1323,36 +1334,27 @@ pred-mono (+≤+ m≤n)         = ⊖-monoˡ-≤ 1 m≤n
 *-zeroˡ _ = refl
 
 *-zeroʳ : RightZero 0ℤ _*_
-*-zeroʳ = comm+zeˡ⇒zeʳ *-comm *-zeroˡ
+*-zeroʳ = comm∧zeˡ⇒zeʳ *-comm *-zeroˡ
 
 *-zero : Zero 0ℤ _*_
 *-zero = *-zeroˡ , *-zeroʳ
 
-private
-  lemma : ∀ m n o → o ℕ.+ (n ℕ.+ m ℕ.* suc n) ℕ.* suc o
-                  ≡ o ℕ.+ n ℕ.* suc o ℕ.+ m ℕ.* suc (o ℕ.+ n ℕ.* suc o)
-  lemma =
-    solve 3 (λ m n o → o :+ (n :+ m :* (con 1 :+ n)) :* (con 1 :+ o)
-                    := o :+ n :* (con 1 :+ o) :+
-                       m :* (con 1 :+ (o :+ n :* (con 1 :+ o))))
-            refl
-
 *-assoc : Associative _*_
 *-assoc +0 _ _ = refl
 *-assoc i +0 _ rewrite ℕ.*-zeroʳ ∣ i ∣ = refl
 *-assoc i j +0 rewrite
     ℕ.*-zeroʳ ∣ j ∣
   | ℕ.*-zeroʳ ∣ i ∣
-  | ℕ.*-zeroʳ ∣ sign i 𝕊* sign j ◃ ∣ i ∣ ℕ.* ∣ j ∣ ∣
+  | ℕ.*-zeroʳ ∣ sign i Sign.* sign j ◃ ∣ i ∣ ℕ.* ∣ j ∣ ∣
   = refl
-*-assoc -[1+ m ] -[1+ n ] +[1+ o ] = cong (+_ ∘ suc) (lemma m n o)
-*-assoc -[1+ m ] +[1+ n ] -[1+ o ] = cong (+_ ∘ suc) (lemma m n o)
-*-assoc +[1+ m ] +[1+ n ] +[1+ o ] = cong (+_ ∘ suc) (lemma m n o)
-*-assoc +[1+ m ] -[1+ n ] -[1+ o ] = cong (+_ ∘ suc) (lemma m n o)
-*-assoc -[1+ m ] -[1+ n ] -[1+ o ] = cong -[1+_] (lemma m n o)
-*-assoc -[1+ m ] +[1+ n ] +[1+ o ] = cong -[1+_] (lemma m n o)
-*-assoc +[1+ m ] -[1+ n ] +[1+ o ] = cong -[1+_] (lemma m n o)
-*-assoc +[1+ m ] +[1+ n ] -[1+ o ] = cong -[1+_] (lemma m n o)
+*-assoc -[1+ m ] -[1+ n ] +[1+ o ] = cong (+_ ∘ suc) (inner-assoc m n o)
+*-assoc -[1+ m ] +[1+ n ] -[1+ o ] = cong (+_ ∘ suc) (inner-assoc m n o)
+*-assoc +[1+ m ] +[1+ n ] +[1+ o ] = cong (+_ ∘ suc) (inner-assoc m n o)
+*-assoc +[1+ m ] -[1+ n ] -[1+ o ] = cong (+_ ∘ suc) (inner-assoc m n o)
+*-assoc -[1+ m ] -[1+ n ] -[1+ o ] = cong -[1+_] (inner-assoc m n o)
+*-assoc -[1+ m ] +[1+ n ] +[1+ o ] = cong -[1+_] (inner-assoc m n o)
+*-assoc +[1+ m ] -[1+ n ] +[1+ o ] = cong -[1+_] (inner-assoc m n o)
+*-assoc +[1+ m ] +[1+ n ] -[1+ o ] = cong -[1+_] (inner-assoc m n o)
 
 private
 
@@ -1385,41 +1387,25 @@ private
         = refl
 *-distribʳ-+ x +0 z
   rewrite +-identityˡ z
-        | +-identityˡ (sign z 𝕊* sign x ◃ ∣ z ∣ ℕ.* ∣ x ∣)
+        | +-identityˡ (sign z Sign.* sign x ◃ ∣ z ∣ ℕ.* ∣ x ∣)
         = refl
 *-distribʳ-+ x y +0
   rewrite +-identityʳ y
-        | +-identityʳ (sign y 𝕊* sign x ◃ ∣ y ∣ ℕ.* ∣ x ∣)
+        | +-identityʳ (sign y Sign.* sign x ◃ ∣ y ∣ ℕ.* ∣ x ∣)
         = refl
-*-distribʳ-+ -[1+ m ] -[1+ n ] -[1+ o ] = cong (+_) $
-  solve 3 (λ m n o → (con 2 :+ n :+ o) :* (con 1 :+ m)
-                  := (con 1 :+ n) :* (con 1 :+ m) :+
-                     (con 1 :+ o) :* (con 1 :+ m))
-          refl m n o
-*-distribʳ-+ +[1+ m ] +[1+ n ] +[1+ o ] = cong (+_) $
-  solve 3 (λ m n o → (con 1 :+ n :+ (con 1 :+ o)) :* (con 1 :+ m)
-                  := (con 1 :+ n) :* (con 1 :+ m) :+
-                     (con 1 :+ o) :* (con 1 :+ m))
-        refl m n o
-*-distribʳ-+ -[1+ m ] +[1+ n ] +[1+ o ] = cong -[1+_] $
-  solve 3 (λ m n o → m :+ (n :+ (con 1 :+ o)) :* (con 1 :+ m)
-                   := (con 1 :+ n) :* (con 1 :+ m) :+
-                      (m :+ o :* (con 1 :+ m)))
-         refl m n o
-*-distribʳ-+ +[1+ m ] -[1+ n ] -[1+ o ] = cong -[1+_] $
-  solve 3 (λ m n o → m :+ (con 1 :+ m :+ (n :+ o) :* (con 1 :+ m))
-                  := (con 1 :+ n) :* (con 1 :+ m) :+
-                     (m :+ o :* (con 1 :+ m)))
-         refl m n o
+*-distribʳ-+ -[1+ m ] -[1+ n ] -[1+ o ] = cong (+_) $ assoc₁ m n o
+*-distribʳ-+ +[1+ m ] +[1+ n ] +[1+ o ] = cong +[1+_] $ ℕ.suc-injective (assoc₂ m n o)
+*-distribʳ-+ -[1+ m ] +[1+ n ] +[1+ o ] = cong -[1+_] $ assoc₃ m n o
+*-distribʳ-+ +[1+ m ] -[1+ n ] -[1+ o ] = cong -[1+_] $ assoc₄ m n o
 *-distribʳ-+ -[1+ m ] -[1+ n ] +[1+ o ] = begin
   (suc o ⊖ suc n) * -[1+ m ]                ≡⟨ cong (_* -[1+ m ]) ([1+m]⊖[1+n]≡m⊖n o n) ⟩
   (o ⊖ n) * -[1+ m ]                        ≡⟨ distrib-lemma m n o ⟩
-  m ℕ.+ n ℕ.* suc m ⊖ (m ℕ.+ o ℕ.* suc m)   ≡˘⟨ [1+m]⊖[1+n]≡m⊖n (m ℕ.+ n ℕ.* suc m) (m ℕ.+ o ℕ.* suc m) ⟩
+  m ℕ.+ n ℕ.* suc m ⊖ (m ℕ.+ o ℕ.* suc m)   ≡⟨ [1+m]⊖[1+n]≡m⊖n (m ℕ.+ n ℕ.* suc m) (m ℕ.+ o ℕ.* suc m) ⟨
   -[1+ n ] * -[1+ m ] + +[1+ o ] * -[1+ m ] ∎ where open ≡-Reasoning
 *-distribʳ-+ -[1+ m ] +[1+ n ] -[1+ o ] = begin
   (+[1+ n ] + -[1+ o ]) * -[1+ m ]          ≡⟨ cong (_* -[1+ m ]) ([1+m]⊖[1+n]≡m⊖n n o) ⟩
   (n ⊖ o) * -[1+ m ]                        ≡⟨ distrib-lemma m o n ⟩
-  m ℕ.+ o ℕ.* suc m ⊖ (m ℕ.+ n ℕ.* suc m)   ≡˘⟨ [1+m]⊖[1+n]≡m⊖n (m ℕ.+ o ℕ.* suc m) (m ℕ.+ n ℕ.* suc m) ⟩
+  m ℕ.+ o ℕ.* suc m ⊖ (m ℕ.+ n ℕ.* suc m)   ≡⟨ [1+m]⊖[1+n]≡m⊖n (m ℕ.+ o ℕ.* suc m) (m ℕ.+ n ℕ.* suc m) ⟨
   +[1+ n ] * -[1+ m ] + -[1+ o ] * -[1+ m ] ∎ where open ≡-Reasoning
 *-distribʳ-+ +[1+ m ] -[1+ n ] +[1+ o ] with n ℕ.≤? o
 ... | yes n≤o
@@ -1464,7 +1450,7 @@ private
         = refl
 
 *-distribˡ-+ : _*_ DistributesOverˡ _+_
-*-distribˡ-+ = comm+distrʳ⇒distrˡ *-comm *-distribʳ-+
+*-distribˡ-+ = comm∧distrʳ⇒distrˡ *-comm *-distribʳ-+
 
 *-distrib-+ : _*_ DistributesOver _+_
 *-distrib-+ = *-distribˡ-+ , *-distribʳ-+
@@ -1527,7 +1513,6 @@ private
   ; *-assoc          = *-assoc
   ; *-identity       = *-identity
   ; distrib          = *-distrib-+
-  ; zero             = *-zero
   }
 
 +-*-isCommutativeRing : IsCommutativeRing _+_ _*_ -_ 0ℤ 1ℤ
@@ -1590,10 +1575,13 @@ private
 abs-* : ℤtoℕ.Homomorphic₂ ∣_∣ _*_ ℕ._*_
 abs-* i j = abs-◃ _ _
 
+sign-* : ∀ i j → .{{NonZero (i * j)}} → sign (i * j) ≡ sign i Sign.* sign j
+sign-* i j rewrite abs-* i j = sign-◃ (sign i Sign.* sign j) (∣ i ∣ ℕ.* ∣ j ∣)
+
 *-cancelʳ-≡ : ∀ i j k .{{_ : NonZero k}} → i * k ≡ j * k → i ≡ j
 *-cancelʳ-≡ i j k eq with sign-cong′ eq
 ... | inj₁ s[ik]≡s[jk] = ◃-cong
-  (𝕊ₚ.*-cancelʳ-≡ (sign k) (sign i) (sign j) s[ik]≡s[jk])
+  (Sign.*-cancelʳ-≡ (sign k) (sign i) (sign j) s[ik]≡s[jk])
   (ℕ.*-cancelʳ-≡ ∣ i ∣ ∣ j ∣ _ (abs-cong eq))
 ... | inj₂ (∣ik∣≡0 , ∣jk∣≡0) = trans
   (∣i∣≡0⇒i≡0 (ℕ.m*n≡0⇒m≡0 _ _ ∣ik∣≡0))
@@ -1627,6 +1615,9 @@ i*j≡0⇒i≡0∨j≡0 i p with ℕ.m*n≡0⇒m≡0∨n≡0 ∣ i ∣ (abs-cong
 ... | inj₁ ∣i∣≡0 = inj₁ (∣i∣≡0⇒i≡0 ∣i∣≡0)
 ... | inj₂ ∣j∣≡0 = inj₂ (∣i∣≡0⇒i≡0 ∣j∣≡0)
 
+i*j≢0 : ∀ i j .{{_ : NonZero i}} .{{_ : NonZero j}} → NonZero (i * j)
+i*j≢0 i j rewrite abs-* i j = ℕ.m*n≢0 ∣ i ∣ ∣ j ∣
+
 ------------------------------------------------------------------------
 -- Properties of _^_
 ------------------------------------------------------------------------
@@ -1685,8 +1676,8 @@ pos-* (suc m) (suc n) = refl
 
 neg-distribˡ-* : ∀ i j → - (i * j) ≡ (- i) * j
 neg-distribˡ-* i j = begin
-  - (i * j)      ≡˘⟨ -1*i≡-i (i * j) ⟩
-  -1ℤ * (i * j)  ≡˘⟨ *-assoc -1ℤ i j ⟩
+  - (i * j)      ≡⟨ -1*i≡-i (i * j) ⟨
+  -1ℤ * (i * j)  ≡⟨ *-assoc -1ℤ i j ⟨
   -1ℤ * i * j    ≡⟨ cong (_* j) (-1*i≡-i i) ⟩
   - i * j        ∎ where open ≡-Reasoning
 
@@ -1700,16 +1691,16 @@ neg-distribʳ-* i j = begin
 ------------------------------------------------------------------------
 -- Properties of _*_ and _◃_
 
-◃-distrib-* :  ∀ s t m n → (s 𝕊* t) ◃ (m ℕ.* n) ≡ (s ◃ m) * (t ◃ n)
+◃-distrib-* :  ∀ s t m n → (s Sign.* t) ◃ (m ℕ.* n) ≡ (s ◃ m) * (t ◃ n)
 ◃-distrib-* s t zero    zero    = refl
 ◃-distrib-* s t zero    (suc n) = refl
 ◃-distrib-* s t (suc m) zero    =
   trans
-    (cong₂ _◃_ (𝕊ₚ.*-comm s t) (ℕ.*-comm m 0))
+    (cong₂ _◃_ (Sign.*-comm s t) (ℕ.*-comm m 0))
     (*-comm (t ◃ zero) (s ◃ suc m))
 ◃-distrib-* s t (suc m) (suc n) =
   sym (cong₂ _◃_
-    (cong₂ _𝕊*_ (sign-◃ s (suc m)) (sign-◃ t (suc n)))
+    (cong₂ Sign._*_ (sign-◃ s (suc m)) (sign-◃ t (suc n)))
     (∣s◃m∣*∣t◃n∣≡m*n s t (suc m) (suc n)))
 
 ------------------------------------------------------------------------
@@ -1717,7 +1708,7 @@ neg-distribʳ-* i j = begin
 
 *-cancelʳ-≤-pos : ∀ i j k .{{_ : Positive k}} → i * k ≤ j * k → i ≤ j
 *-cancelʳ-≤-pos -[1+ m ] -[1+ n ] +[1+ o ] (-≤- n≤m) =
-  -≤- (ℕ.≤-pred (ℕ.*-cancelʳ-≤ (suc n) (suc m) (suc o) (s≤s n≤m)))
+  -≤- (s≤s⁻¹ (ℕ.*-cancelʳ-≤ (suc n) (suc m) (suc o) (s≤s n≤m)))
 *-cancelʳ-≤-pos -[1+ _ ] (+ _)    +[1+ o ] _         = -≤+
 *-cancelʳ-≤-pos +0       +0       +[1+ o ] _         = +≤+ z≤n
 *-cancelʳ-≤-pos +0       +[1+ _ ] +[1+ o ] _         = +≤+ z≤n
@@ -1732,7 +1723,7 @@ neg-distribʳ-* i j = begin
 *-monoʳ-≤-nonNeg +0 {i} {j} i≤j rewrite *-zeroʳ i | *-zeroʳ j = +≤+ z≤n
 *-monoʳ-≤-nonNeg +[1+ n ] (-≤+ {n = 0})         = -≤+
 *-monoʳ-≤-nonNeg +[1+ n ] (-≤+ {n = suc _})     = -≤+
-*-monoʳ-≤-nonNeg +[1+ n ] (-≤- n≤m) = -≤- (ℕ.≤-pred (ℕ.*-mono-≤ (s≤s n≤m) (ℕ.≤-refl {x = suc n})))
+*-monoʳ-≤-nonNeg +[1+ n ] (-≤- n≤m) = -≤- (s≤s⁻¹ (ℕ.*-mono-≤ (s≤s n≤m) (ℕ.≤-refl {x = suc n})))
 *-monoʳ-≤-nonNeg +[1+ n ] {+0}       {+0}       (+≤+ m≤n) = +≤+ m≤n
 *-monoʳ-≤-nonNeg +[1+ n ] {+0}       {+[1+ _ ]} (+≤+ m≤n) = +≤+ z≤n
 *-monoʳ-≤-nonNeg +[1+ n ] {+[1+ _ ]} {+[1+ _ ]} (+≤+ m≤n) = +≤+ (ℕ.*-monoˡ-≤ (suc n) m≤n)
@@ -1742,10 +1733,10 @@ neg-distribʳ-* i j = begin
 
 *-cancelˡ-≤-neg : ∀ i j k .{{_ : Negative i}} → i * j ≤ i * k → j ≥ k
 *-cancelˡ-≤-neg i@(-[1+ _ ]) j k ij≤ik = neg-cancel-≤ (*-cancelˡ-≤-pos (- j) (- k) (- i) (begin
-  - i * - j   ≡˘⟨ neg-distribʳ-* (- i) j ⟩
+  - i * - j   ≡⟨ neg-distribʳ-* (- i) j ⟨
   -(- i * j)  ≡⟨  neg-distribˡ-* (- i) j ⟩
   i * j       ≤⟨  ij≤ik ⟩
-  i * k       ≡˘⟨ neg-distribˡ-* (- i) k ⟩
+  i * k       ≡⟨ neg-distribˡ-* (- i) k ⟨
   -(- i * k)  ≡⟨  neg-distribʳ-* (- i) k ⟩
   - i * - k   ∎))
   where open ≤-Reasoning
@@ -1756,10 +1747,10 @@ neg-distribʳ-* i j = begin
 *-monoˡ-≤-nonPos : ∀ i .{{_ : NonPositive i}} → (i *_) Preserves _≤_ ⟶ _≥_
 *-monoˡ-≤-nonPos +0           {j} {k} j≤k = +≤+ z≤n
 *-monoˡ-≤-nonPos i@(-[1+ m ]) {j} {k} j≤k = begin
-  i * k        ≡˘⟨ neg-distribˡ-* (- i) k ⟩
+  i * k        ≡⟨ neg-distribˡ-* (- i) k ⟨
   -(- i * k)   ≡⟨  neg-distribʳ-* (- i) k ⟩
   - i * - k    ≤⟨  *-monoˡ-≤-nonNeg (- i) (neg-mono-≤ j≤k) ⟩
-  - i * - j    ≡˘⟨ neg-distribʳ-* (- i) j ⟩
+  - i * - j    ≡⟨ neg-distribʳ-* (- i) j ⟨
   -(- i * j)   ≡⟨  neg-distribˡ-* (- i) j ⟩
   i * j        ∎
   where open ≤-Reasoning
@@ -1782,17 +1773,17 @@ neg-distribʳ-* i j = begin
 *-cancelˡ-<-nonNeg {+ i}       {+ j}       (+ n) leq = +<+ (ℕ.*-cancelˡ-< n _ _ (+◃-cancel-< leq))
 *-cancelˡ-<-nonNeg {+ i}       { -[1+ j ]} (+ n) leq = contradiction leq +◃≮-◃
 *-cancelˡ-<-nonNeg { -[1+ i ]} {+ j}       (+ n)leq = -<+
-*-cancelˡ-<-nonNeg { -[1+ i ]} { -[1+ j ]} (+ n) leq = -<- (ℕ.≤-pred (ℕ.*-cancelˡ-< n _ _ (neg◃-cancel-< leq)))
+*-cancelˡ-<-nonNeg { -[1+ i ]} { -[1+ j ]} (+ n) leq = -<- (s<s⁻¹ (ℕ.*-cancelˡ-< n _ _ (neg◃-cancel-< leq)))
 
 *-cancelʳ-<-nonNeg : ∀ k .{{_ : NonNegative k}} → i * k < j * k → i < j
 *-cancelʳ-<-nonNeg {i} {j} k rewrite *-comm i k | *-comm j k = *-cancelˡ-<-nonNeg k
 
 *-monoˡ-<-neg : ∀ i .{{_ : Negative i}} → (i *_) Preserves _<_ ⟶ _>_
 *-monoˡ-<-neg i@(-[1+ _ ]) {j} {k} j<k = begin-strict
-  i * k        ≡˘⟨ neg-distribˡ-* (- i) k ⟩
+  i * k        ≡⟨ neg-distribˡ-* (- i) k ⟨
   -(- i * k)   ≡⟨  neg-distribʳ-* (- i) k ⟩
   - i * - k    <⟨  *-monoˡ-<-pos (- i) (neg-mono-< j<k) ⟩
-  - i * - j    ≡˘⟨ neg-distribʳ-* (- i) j ⟩
+  - i * - j    ≡⟨ neg-distribʳ-* (- i) j ⟨
   - (- i * j)  ≡⟨  neg-distribˡ-* (- i) j ⟩
   i * j        ∎
   where open ≤-Reasoning
@@ -1803,10 +1794,10 @@ neg-distribʳ-* i j = begin
 *-cancelˡ-<-nonPos : ∀ k .{{_ : NonPositive k}} → k * i < k * j → i > j
 *-cancelˡ-<-nonPos {i} {j} +0           (+<+ ())
 *-cancelˡ-<-nonPos {i} {j} k@(-[1+ _ ]) ki<kj = neg-cancel-< (*-cancelˡ-<-nonNeg (- k) (begin-strict
-  - k * - i   ≡˘⟨ neg-distribʳ-* (- k) i ⟩
+  - k * - i   ≡⟨ neg-distribʳ-* (- k) i ⟨
   -(- k * i)  ≡⟨  neg-distribˡ-* (- k) i ⟩
   k * i       <⟨  ki<kj ⟩
-  k * j       ≡˘⟨ neg-distribˡ-* (- k) j ⟩
+  k * j       ≡⟨ neg-distribˡ-* (- k) j ⟨
   -(- k * j)  ≡⟨  neg-distribʳ-* (- k) j ⟩
   - k * - j   ∎))
   where open ≤-Reasoning
@@ -1824,7 +1815,7 @@ neg-distribʳ-* i j = begin
 -- Properties of _*_ and ∣_∣
 
 ∣i*j∣≡∣i∣*∣j∣ : ∀ i j → ∣ i * j ∣ ≡ ∣ i ∣ ℕ.* ∣ j ∣
-∣i*j∣≡∣i∣*∣j∣ i j = abs-◃ (sign i 𝕊* sign j) (∣ i ∣ ℕ.* ∣ j ∣)
+∣i*j∣≡∣i∣*∣j∣ = abs-*
 
 ------------------------------------------------------------------------
 -- Properties of _⊓_ and _⊔_
diff --git a/src/Data/Integer/Properties/NatLemmas.agda b/src/Data/Integer/Properties/NatLemmas.agda
new file mode 100644
index 0000000000..5aa44bb889
--- /dev/null
+++ b/src/Data/Integer/Properties/NatLemmas.agda
@@ -0,0 +1,69 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Some extra lemmas about natural numbers only needed for
+-- Data.Integer.Properties (for distributivity)
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Integer.Properties.NatLemmas where
+
+open import Data.Nat.Base using (ℕ; _+_; _*_; suc)
+open import Data.Nat.Properties
+  using (*-distribʳ-+; *-assoc; +-assoc; +-comm; +-suc)
+open import Function.Base using (_∘_)
+open import Relation.Binary.PropositionalEquality
+  using (_≡_; cong; cong₂; sym; module ≡-Reasoning)
+
+open ≡-Reasoning
+
+inner-assoc : ∀ m n o → o + (n + m * suc n) * suc o
+                ≡ o + n * suc o + m * suc (o + n * suc o)
+inner-assoc m n o = begin
+  o + (n + m * suc n) * suc o                ≡⟨ cong (o +_) (begin
+    (n + m * suc n) * suc o             ≡⟨ *-distribʳ-+ (suc o) n (m * suc n) ⟩
+    n * suc o + m * suc n * suc o       ≡⟨ cong (n * suc o +_) (*-assoc m (suc n) (suc o)) ⟩
+    n * suc o + m * suc (o + n * suc o) ∎) ⟩
+  o + (n * suc o + m * suc (o + n * suc o))  ≡⟨ +-assoc o _ _ ⟨
+  o + n * suc o + m * suc (o + n * suc o)    ∎
+
+private
+  assoc-comm : ∀ a b c d → a + b + c + d ≡ (a + c) + (b + d)
+  assoc-comm a b c d = begin
+    a + b + c + d     ≡⟨ cong (_+ d) (+-assoc a b c) ⟩
+    a + (b + c) + d   ≡⟨ cong (λ z → a + z + d) (+-comm b c) ⟩
+    a + (c + b) + d   ≡⟨ cong (_+ d) (+-assoc a c b) ⟨
+    (a + c) + b + d   ≡⟨ +-assoc (a + c) b d ⟩
+    (a + c) + (b + d) ∎
+
+  assoc-comm′ : ∀ a b c d → a + (b + (c + d)) ≡ a + c + (b + d)
+  assoc-comm′ a b c d = begin
+    a + (b + (c + d)) ≡⟨ cong (a +_) (+-assoc b c d) ⟨
+    a + (b + c + d)   ≡⟨ cong (λ z → a + (z + d)) (+-comm b c) ⟩
+    a + (c + b + d)   ≡⟨ cong (a +_) (+-assoc c b d) ⟩
+    a + (c + (b + d)) ≡⟨ +-assoc a c _ ⟨
+    a + c + (b + d)   ∎
+
+assoc₁ : ∀ m n o → (2 + n + o) * (1 + m) ≡ (1 + n) * (1 + m) + (1 + o) * (1 + m)
+assoc₁ m n o = begin
+  (2 + n + o) * (1 + m)                  ≡⟨ cong (_* (1 + m)) (assoc-comm 1 1 n o) ⟩
+  ((1 + n) + (1 + o)) * (1 + m)          ≡⟨ *-distribʳ-+ (1 + m) (1 + n) (1 + o) ⟩
+  (1 + n) * (1 + m) + (1 + o) * (1 + m)   ∎
+
+assoc₂ : ∀ m n o → (1 + n + (1 + o)) * (1 + m) ≡ (1 + n) * (1 + m) + (1 + o) * (1 + m)
+assoc₂ m n o = *-distribʳ-+ (1 + m) (1 + n) (1 + o)
+
+assoc₃ : ∀ m n o → m + (n + (1 + o)) * (1 + m) ≡ (1 + n) * (1 + m) + (m + o * (1 + m))
+assoc₃ m n o = begin
+  m + (n + (1 + o)) * (1 + m)           ≡⟨ cong (m +_) (*-distribʳ-+ (1 + m) n (1 + o)) ⟩
+  m + (n * (1 + m) + (1 + o) * (1 + m)) ≡⟨ +-assoc m _ _ ⟨
+  (m + n * (1 + m)) + (1 + o) * (1 + m) ≡⟨ +-suc _ _ ⟩
+  (1 + n) * (1 + m) + (m + o * (1 + m)) ∎
+
+assoc₄ : ∀ m n o → m + (1 + m + (n + o) * (1 + m)) ≡ (1 + n) * (1 + m) + (m + o * (1 + m))
+assoc₄ m n o = begin
+  m + (1 + m + (n + o) * (1 + m))           ≡⟨ +-suc _ _ ⟩
+  1 + m + (m + (n + o) * (1 + m))           ≡⟨ cong (λ z → suc (m + (m + z))) (*-distribʳ-+ (suc m) n o) ⟩
+  1 + m + (m + (n * (1 + m) + o * (1 + m))) ≡⟨ cong suc (assoc-comm′ m m _ _) ⟩
+  (1 + n) * (1 + m) + (m + o * (1 + m))     ∎
diff --git a/src/Data/Integer/Solver.agda b/src/Data/Integer/Solver.agda
index fcb3e411dc..46e9398677 100644
--- a/src/Data/Integer/Solver.agda
+++ b/src/Data/Integer/Solver.agda
@@ -4,7 +4,7 @@
 -- Automatic solvers for equations over integers
 ------------------------------------------------------------------------
 
--- See README.Integer for examples of how to use this solver
+-- See README.Data.Integer for examples of how to use this solver
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
diff --git a/src/Data/Integer/Tactic/RingSolver.agda b/src/Data/Integer/Tactic/RingSolver.agda
index ec812e3f0a..e673c0f3d7 100644
--- a/src/Data/Integer/Tactic/RingSolver.agda
+++ b/src/Data/Integer/Tactic/RingSolver.agda
@@ -4,7 +4,7 @@
 -- Automatic solvers for equations over integers
 ------------------------------------------------------------------------
 
--- See README.Integer for examples of how to use this solver
+-- See README.Tactic.RingSolver for examples of how to use this solver
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
@@ -13,11 +13,11 @@ module Data.Integer.Tactic.RingSolver where
 open import Agda.Builtin.Reflection
 
 open import Data.Maybe.Base using (just; nothing)
-open import Data.Integer.Base
-open import Data.Integer.Properties
+open import Data.Integer.Base using (+0)
+open import Data.Integer.Properties using (+-*-commutativeRing)
 open import Level using (0ℓ)
-open import Data.Unit using (⊤)
-open import Relation.Binary.PropositionalEquality
+open import Data.Unit.Base using (⊤)
+open import Relation.Binary.PropositionalEquality.Core using (refl)
 import Tactic.RingSolver as Solver
 import Tactic.RingSolver.Core.AlmostCommutativeRing as ACR
 
diff --git a/src/Data/List.agda b/src/Data/List.agda
index 7747cbbd74..70e8519440 100644
--- a/src/Data/List.agda
+++ b/src/Data/List.agda
@@ -8,6 +8,7 @@
 -- lists.
 
 {-# OPTIONS --cubical-compatible --safe #-}
+{-# OPTIONS --warn=noUserWarning #-} -- for deprecated scans
 
 module Data.List where
 
@@ -15,3 +16,6 @@ module Data.List where
 -- Types and basic operations
 
 open import Data.List.Base public
+  hiding (scanr; scanl)
+open import Data.List.Scans.Base public
+  using (scanr; scanl)
diff --git a/src/Data/List/Base.agda b/src/Data/List/Base.agda
index 48a5840bf4..0c63e34940 100644
--- a/src/Data/List/Base.agda
+++ b/src/Data/List/Base.agda
@@ -17,16 +17,17 @@ open import Data.Bool.Base as Bool
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.Maybe.Base as Maybe using (Maybe; nothing; just; maybe′)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc; _+_; _*_ ; _≤_ ; s≤s)
-open import Data.Product as Prod using (_×_; _,_; map₁; map₂′)
+open import Data.Product.Base as Product using (_×_; _,_; map₁; map₂′)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
 open import Data.These.Base as These using (These; this; that; these)
-open import Function.Base using (id; _∘_ ; _∘′_; _∘₂_; const; flip)
+open import Function.Base
+  using (id; _∘_ ; _∘′_; _∘₂_; _$_; const; flip)
 open import Level using (Level)
-open import Relation.Nullary.Decidable.Core using (does; ¬?)
 open import Relation.Unary using (Pred; Decidable)
 open import Relation.Binary.Core using (Rel)
 import Relation.Binary.Definitions as B
 open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+open import Relation.Nullary.Decidable.Core using (T?; does; ¬?)
 
 private
   variable
@@ -48,15 +49,6 @@ map : (A → B) → List A → List B
 map f []       = []
 map f (x ∷ xs) = f x ∷ map f xs
 
-mapMaybe : (A → Maybe B) → List A → List B
-mapMaybe p []       = []
-mapMaybe p (x ∷ xs) with p x
-... | just y  = y ∷ mapMaybe p xs
-... | nothing = mapMaybe p xs
-
-catMaybes : List (Maybe A) → List A
-catMaybes = mapMaybe id
-
 infixr 5 _++_
 
 _++_ : List A → List A → List A
@@ -95,13 +87,13 @@ zipWith f _        _        = []
 unalignWith : (A → These B C) → List A → List B × List C
 unalignWith f []       = [] , []
 unalignWith f (a ∷ as) with f a
-... | this b    = Prod.map₁ (b ∷_) (unalignWith f as)
-... | that c    = Prod.map₂ (c ∷_) (unalignWith f as)
-... | these b c = Prod.map (b ∷_) (c ∷_) (unalignWith f as)
+... | this b    = Product.map₁ (b ∷_) (unalignWith f as)
+... | that c    = Product.map₂ (c ∷_) (unalignWith f as)
+... | these b c = Product.map (b ∷_) (c ∷_) (unalignWith f as)
 
 unzipWith : (A → B × C) → List A → List B × List C
 unzipWith f []         = [] , []
-unzipWith f (xy ∷ xys) = Prod.zip _∷_ _∷_ (f xy) (unzipWith f xys)
+unzipWith f (xy ∷ xys) = Product.zip _∷_ _∷_ (f xy) (unzipWith f xys)
 
 partitionSumsWith : (A → B ⊎ C) → List A → List B × List C
 partitionSumsWith f = unalignWith (These.fromSum ∘′ f)
@@ -122,11 +114,11 @@ partitionSums : List (A ⊎ B) → List A × List B
 partitionSums = partitionSumsWith id
 
 merge : {R : Rel A ℓ} → B.Decidable R → List A → List A → List A
-merge R? []       ys       = ys
-merge R? xs       []       = xs
-merge R? (x ∷ xs) (y ∷ ys) = if does (R? x y)
-  then x ∷ merge R? xs (y ∷ ys)
-  else y ∷ merge R? (x ∷ xs) ys
+merge R? []           ys           = ys
+merge R? xs           []           = xs
+merge R? x∷xs@(x ∷ xs) y∷ys@(y ∷ ys) = if does (R? x y)
+  then x ∷ merge R? xs   y∷ys
+  else y ∷ merge R? x∷xs ys
 
 ------------------------------------------------------------------------
 -- Operations for reducing lists
@@ -148,6 +140,12 @@ concatMap f = concat ∘ map f
 ap : List (A → B) → List A → List B
 ap fs as = concatMap (flip map as) fs
 
+catMaybes : List (Maybe A) → List A
+catMaybes = foldr (maybe′ _∷_ id) []
+
+mapMaybe : (A → Maybe B) → List A → List B
+mapMaybe p = catMaybes ∘ map p
+
 null : List A → Bool
 null []       = true
 null (x ∷ xs) = false
@@ -187,25 +185,31 @@ replicate : ℕ → A → List A
 replicate zero    x = []
 replicate (suc n) x = x ∷ replicate n x
 
+iterate : (A → A) → A → ℕ → List A
+iterate f e zero    = []
+iterate f e (suc n) = e ∷ iterate f (f e) n
+
 inits : List A → List (List A)
-inits []       = [] ∷ []
-inits (x ∷ xs) = [] ∷ map (x ∷_) (inits xs)
+inits {A = A} = λ xs → [] ∷ tail xs
+  module Inits where
+    tail : List A → List (List A)
+    tail []       = []
+    tail (x ∷ xs) = [ x ] ∷ map (x ∷_) (tail xs)
 
 tails : List A → List (List A)
-tails []       = [] ∷ []
-tails (x ∷ xs) = (x ∷ xs) ∷ tails xs
+tails {A = A} = λ xs → xs ∷ tail xs
+  module Tails where
+    tail : List A → List (List A)
+    tail []       = []
+    tail (_ ∷ xs) = xs ∷ tail xs
 
--- Scans
-
-scanr : (A → B → B) → B → List A → List B
-scanr f e []       = e ∷ []
-scanr f e (x ∷ xs) with scanr f e xs
-... | []     = []                -- dead branch
-... | y ∷ ys = f x y ∷ y ∷ ys
+insertAt : (xs : List A) → Fin (suc (length xs)) → A → List A
+insertAt xs       zero    v = v ∷ xs
+insertAt (x ∷ xs) (suc i) v = x ∷ insertAt xs i v
 
-scanl : (A → B → A) → A → List B → List A
-scanl f e []       = e ∷ []
-scanl f e (x ∷ xs) = e ∷ scanl f (f e x) xs
+updateAt : (xs : List A) → Fin (length xs) → (A → A) → List A
+updateAt (x ∷ xs) zero    f = f x ∷ xs
+updateAt (x ∷ xs) (suc i) f = x ∷ updateAt xs i f
 
 -- Tabulation
 
@@ -240,9 +244,7 @@ unfold : ∀ (P : ℕ → Set b)
          (f : ∀ {n} → P (suc n) → Maybe (A × P n)) →
          ∀ {n} → P n → List A
 unfold P f {n = zero}  s = []
-unfold P f {n = suc n} s with f s
-... | nothing       = []
-... | just (x , s′) = x ∷ unfold P f s′
+unfold P f {n = suc n} s = maybe′ (λ (x , s′) → x ∷ unfold P f s′) [] (f s)
 
 ------------------------------------------------------------------------
 -- Operations for reversing lists
@@ -327,131 +329,183 @@ drop (suc n) (x ∷ xs) = drop n xs
 splitAt : ℕ → List A → List A × List A
 splitAt zero    xs       = ([] , xs)
 splitAt (suc n) []       = ([] , [])
-splitAt (suc n) (x ∷ xs) = Prod.map₁ (x ∷_) (splitAt n xs)
+splitAt (suc n) (x ∷ xs) = Product.map₁ (x ∷_) (splitAt n xs)
+
+removeAt : (xs : List A) → Fin (length xs) → List A
+removeAt (x ∷ xs) zero     = xs
+removeAt (x ∷ xs) (suc i)  = x ∷ removeAt xs i
+
+------------------------------------------------------------------------
+-- Operations for filtering lists
+
+-- The following are a variety of functions that can be used to
+-- construct sublists using a predicate.
+--
+-- Each function has two forms. The first main variant uses a
+-- proof-relevant decidable predicate, while the second variant uses
+-- a irrelevant boolean predicate and are suffixed with a `ᵇ` character,
+-- typed as \^b.
+--
+-- The decidable versions have several advantages: 1) easier to prove
+-- properties, 2) better meta-variable inference and 3) most of the rest
+-- of the library is set-up to work with decidable predicates. However,
+-- in rare cases the boolean versions can be useful, mainly when one
+-- wants to minimise dependencies.
+--
+-- In summary, in most cases you probably want to use the decidable
+-- versions over the boolean versions, e.g. use `takeWhile (_≤? 10) xs`
+-- rather than `takeWhileᵇ (_≤ᵇ 10) xs`.
 
--- The following are functions which split a list up using boolean
--- predicates. However, in practice they are difficult to use and
--- prove properties about, and are mainly provided for advanced use
--- cases where one wants to minimise dependencies. In most cases
--- you probably want to use the versions defined below based on
--- decidable predicates. e.g. use `takeWhile (_≤? 10) xs`
--- instead of `takeWhileᵇ (_≤ᵇ 10) xs`
+takeWhile : ∀ {P : Pred A p} → Decidable P → List A → List A
+takeWhile P? []       = []
+takeWhile P? (x ∷ xs) with does (P? x)
+... | true  = x ∷ takeWhile P? xs
+... | false = []
 
 takeWhileᵇ : (A → Bool) → List A → List A
-takeWhileᵇ p []       = []
-takeWhileᵇ p (x ∷ xs) = if p x then x ∷ takeWhileᵇ p xs else []
+takeWhileᵇ p = takeWhile (T? ∘ p)
+
+dropWhile : ∀ {P : Pred A p} → Decidable P → List A → List A
+dropWhile P? []       = []
+dropWhile P? (x ∷ xs) with does (P? x)
+... | true  = dropWhile P? xs
+... | false = x ∷ xs
 
 dropWhileᵇ : (A → Bool) → List A → List A
-dropWhileᵇ p []       = []
-dropWhileᵇ p (x ∷ xs) = if p x then dropWhileᵇ p xs else x ∷ xs
+dropWhileᵇ p = dropWhile (T? ∘ p)
+
+filter : ∀ {P : Pred A p} → Decidable P → List A → List A
+filter P? [] = []
+filter P? (x ∷ xs) with does (P? x)
+... | false = filter P? xs
+... | true  = x ∷ filter P? xs
 
 filterᵇ : (A → Bool) → List A → List A
-filterᵇ p []       = []
-filterᵇ p (x ∷ xs) = if p x then x ∷ filterᵇ p xs else filterᵇ p xs
+filterᵇ p = filter (T? ∘ p)
+
+partition : ∀ {P : Pred A p} → Decidable P → List A → (List A × List A)
+partition P? []       = ([] , [])
+partition P? (x ∷ xs) with does (P? x) | partition P? xs
+... | true  | (ys , zs) = (x ∷ ys , zs)
+... | false | (ys , zs) = (ys , x ∷ zs)
 
 partitionᵇ : (A → Bool) → List A → List A × List A
-partitionᵇ p []       = ([] , [])
-partitionᵇ p (x ∷ xs) = (if p x then Prod.map₁ else Prod.map₂′) (x ∷_) (partitionᵇ p xs)
+partitionᵇ p = partition (T? ∘ p)
+
+span : ∀ {P : Pred A p} → Decidable P → List A → (List A × List A)
+span P? []       = ([] , [])
+span P? ys@(x ∷ xs) with does (P? x)
+... | true  = Product.map (x ∷_) id (span P? xs)
+... | false = ([] , ys)
+
 
 spanᵇ : (A → Bool) → List A → List A × List A
-spanᵇ p []       = ([] , [])
-spanᵇ p (x ∷ xs) = if p x
-  then Prod.map₁ (x ∷_) (spanᵇ p xs)
-  else ([] , x ∷ xs)
+spanᵇ p = span (T? ∘ p)
+
+break : ∀ {P : Pred A p} → Decidable P → List A → (List A × List A)
+break P? = span (¬? ∘ P?)
 
 breakᵇ : (A → Bool) → List A → List A × List A
-breakᵇ p = spanᵇ (not ∘ p)
+breakᵇ p = break (T? ∘ p)
+
+-- The predicate `P` represents the notion of newline character for the
+-- type `A`. It is used to split the input list into a list of lines.
+-- Some lines may be empty if the input contains at least two
+-- consecutive newline characters.
+linesBy : ∀ {P : Pred A p} → Decidable P → List A → List (List A)
+linesBy {A = A} P? = go nothing where
 
-linesByᵇ : (A → Bool) → List A → List (List A)
-linesByᵇ {A = A} p = go nothing
-  where
   go : Maybe (List A) → List A → List (List A)
   go acc []       = maybe′ ([_] ∘′ reverse) [] acc
-  go acc (c ∷ cs) with p c
-  ... | true  = reverse (Maybe.fromMaybe [] acc) ∷ go nothing cs
-  ... | false = go (just (c ∷ Maybe.fromMaybe [] acc)) cs
+  go acc (c ∷ cs) = if does (P? c)
+    then reverse acc′ ∷ go nothing cs
+    else go (just (c ∷ acc′)) cs
+    where acc′ = Maybe.fromMaybe [] acc
+
+linesByᵇ : (A → Bool) → List A → List (List A)
+linesByᵇ p = linesBy (T? ∘ p)
+
+-- The predicate `P` represents the notion of space character for the
+-- type `A`. It is used to split the input list into a list of words.
+-- All the words are non empty and the output does not contain any space
+-- characters.
+wordsBy : ∀ {P : Pred A p} → Decidable P → List A → List (List A)
+wordsBy {A = A} P? = go [] where
 
-wordsByᵇ : (A → Bool) → List A → List (List A)
-wordsByᵇ {A = A} p = go []
-  where
   cons : List A → List (List A) → List (List A)
   cons [] ass = ass
   cons as ass = reverse as ∷ ass
 
   go : List A → List A → List (List A)
   go acc []       = cons acc []
-  go acc (c ∷ cs) with p c
-  ... | true  = cons acc (go [] cs)
-  ... | false = go (c ∷ acc) cs
+  go acc (c ∷ cs) = if does (P? c)
+    then cons acc (go [] cs)
+    else go (c ∷ acc) cs
 
-derunᵇ : (A → A → Bool) → List A → List A
-derunᵇ r []           = []
-derunᵇ r (x ∷ [])     = x ∷ []
-derunᵇ r (x ∷ y ∷ xs) = if r x y
-  then derunᵇ r (y ∷ xs)
-  else x ∷ derunᵇ r (y ∷ xs)
+wordsByᵇ : (A → Bool) → List A → List (List A)
+wordsByᵇ p = wordsBy (T? ∘ p)
 
-deduplicateᵇ : (A → A → Bool) → List A → List A
-deduplicateᵇ r [] = []
-deduplicateᵇ r (x ∷ xs) = x ∷ filterᵇ (not ∘ r x) (deduplicateᵇ r xs)
+derun : ∀ {R : Rel A p} → B.Decidable R → List A → List A
+derun R? [] = []
+derun R? (x ∷ []) = x ∷ []
+derun R? (x ∷ xs@(y ∷ _)) with does (R? x y) | derun R? xs
+... | true  | ys = ys
+... | false | ys = x ∷ ys
 
--- Equivalent functions that use a decidable predicate instead of a
--- boolean function.
+derunᵇ : (A → A → Bool) → List A → List A
+derunᵇ r = derun (T? ∘₂ r)
 
-takeWhile : ∀ {P : Pred A p} → Decidable P → List A → List A
-takeWhile P? = takeWhileᵇ (does ∘ P?)
+deduplicate : ∀ {R : Rel A p} → B.Decidable R → List A → List A
+deduplicate R? [] = []
+deduplicate R? (x ∷ xs) = x ∷ filter (¬? ∘ R? x) (deduplicate R? xs)
 
-dropWhile : ∀ {P : Pred A p} → Decidable P → List A → List A
-dropWhile P? = dropWhileᵇ (does ∘ P?)
+deduplicateᵇ : (A → A → Bool) → List A → List A
+deduplicateᵇ r = deduplicate (T? ∘₂ r)
 
-filter : ∀ {P : Pred A p} → Decidable P → List A → List A
-filter P? = filterᵇ (does ∘ P?)
+-- Finds the first element satisfying the boolean predicate
+find : ∀ {P : Pred A p} → Decidable P → List A → Maybe A
+find P? []       = nothing
+find P? (x ∷ xs) = if does (P? x) then just x else find P? xs
 
-partition : ∀ {P : Pred A p} → Decidable P → List A → (List A × List A)
-partition P? = partitionᵇ (does ∘ P?)
+findᵇ : (A → Bool) → List A → Maybe A
+findᵇ p = find (T? ∘ p)
 
-span : ∀ {P : Pred A p} → Decidable P → List A → (List A × List A)
-span P? = spanᵇ (does ∘ P?)
+-- Finds the index of the first element satisfying the boolean predicate
+findIndex : ∀ {P : Pred A p} → Decidable P → (xs : List A) → Maybe $ Fin (length xs)
+findIndex P? [] = nothing
+findIndex P? (x ∷ xs) = if does (P? x)
+  then just zero
+  else Maybe.map suc (findIndex P? xs)
 
-break : ∀ {P : Pred A p} → Decidable P → List A → (List A × List A)
-break P? = breakᵇ (does ∘ P?)
+findIndexᵇ : (A → Bool) → (xs : List A) → Maybe $ Fin (length xs)
+findIndexᵇ p = findIndex (T? ∘ p)
 
--- The predicate `P` represents the notion of newline character for the
--- type `A`. It is used to split the input list into a list of lines.
--- Some lines may be empty if the input contains at least two
--- consecutive newline characters.
-linesBy : ∀ {P : Pred A p} → Decidable P → List A → List (List A)
-linesBy P? = linesByᵇ (does ∘ P?)
+-- Finds indices of all the elements satisfying the boolean predicate
+findIndices : ∀ {P : Pred A p} → Decidable P → (xs : List A) → List $ Fin (length xs)
+findIndices P? []       = []
+findIndices P? (x ∷ xs) = if does (P? x)
+  then zero ∷ indices
+  else indices
+    where indices = map suc (findIndices P? xs)
 
--- The predicate `P` represents the notion of space character for the
--- type `A`. It is used to split the input list into a list of words.
--- All the words are non empty and the output does not contain any space
--- characters.
-wordsBy : ∀ {P : Pred A p} → Decidable P → List A → List (List A)
-wordsBy P? = wordsByᵇ (does ∘ P?)
-
-derun : ∀ {R : Rel A p} → B.Decidable R → List A → List A
-derun R? = derunᵇ (does ∘₂ R?)
-
-deduplicate : ∀ {R : Rel A p} → B.Decidable R → List A → List A
-deduplicate R? = deduplicateᵇ (does ∘₂ R?)
+findIndicesᵇ : (A → Bool) → (xs : List A) → List $ Fin (length xs)
+findIndicesᵇ p = findIndices (T? ∘ p)
 
 ------------------------------------------------------------------------
 -- Actions on single elements
 
-infixl 5 _[_]%=_ _[_]∷=_ _─_
+infixl 5 _[_]%=_ _[_]∷=_
+
+-- xs [ i ]%= f  modifies the i-th element of xs according to f
 
 _[_]%=_ : (xs : List A) → Fin (length xs) → (A → A) → List A
-(x ∷ xs) [ zero  ]%= f = f x ∷ xs
-(x ∷ xs) [ suc k ]%= f = x ∷ (xs [ k ]%= f)
+xs [ i ]%= f = updateAt xs i f
+
+-- xs [ i ]≔ y  overwrites the i-th element of xs with y
 
 _[_]∷=_ : (xs : List A) → Fin (length xs) → A → List A
 xs [ k ]∷= v = xs [ k ]%= const v
 
-_─_ : (xs : List A) → Fin (length xs) → List A
-(x ∷ xs) ─ zero  = xs
-(x ∷ xs) ─ suc k = x ∷ (xs ─ k)
-
 ------------------------------------------------------------------------
 -- Conditional versions of cons and snoc
 
@@ -497,3 +551,32 @@ _∷ʳ'_ = InitLast._∷ʳ′_
 "Warning: _∷ʳ'_ (ending in an apostrophe) was deprecated in v1.4.
 Please use _∷ʳ′_ (ending in a prime) instead."
 #-}
+
+-- Version 2.0
+
+infixl 5 _─_
+_─_ = removeAt
+{-# WARNING_ON_USAGE _─_
+"Warning: _─_ was deprecated in v2.0.
+Please use removeAt instead."
+#-}
+
+-- Version 2.1
+
+scanr : (A → B → B) → B → List A → List B
+scanr f e []       = e ∷ []
+scanr f e (x ∷ xs) with scanr f e xs
+... | []         = []                -- dead branch
+... | ys@(y ∷ _) = f x y ∷ ys
+{-# WARNING_ON_USAGE scanr
+"Warning: scanr was deprecated in v2.1.
+Please use Data.List.Scans.Base.scanr instead."
+#-}
+
+scanl : (A → B → A) → A → List B → List A
+scanl f e []       = e ∷ []
+scanl f e (x ∷ xs) = e ∷ scanl f (f e x) xs
+{-# WARNING_ON_USAGE scanl
+"Warning: scanl was deprecated in v2.1.
+Please use Data.List.Scans.Base.scanl instead."
+#-}
diff --git a/src/Data/List/Categorical.agda b/src/Data/List/Categorical.agda
new file mode 100644
index 0000000000..dc3391f1c4
--- /dev/null
+++ b/src/Data/List/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.List.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.List.Categorical where
+
+open import Data.List.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Data.List.Categorical was deprecated in v2.0.
+Use Data.List.Effectful instead."
+#-}
diff --git a/src/Data/List/Categorical/Transformer.agda b/src/Data/List/Categorical/Transformer.agda
new file mode 100644
index 0000000000..75b83f14f3
--- /dev/null
+++ b/src/Data/List/Categorical/Transformer.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.List.Effectful.Transformer` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.List.Categorical.Transformer where
+
+open import Data.List.Effectful.Transformer public
+
+{-# WARNING_ON_IMPORT
+"Data.List.Categorical.Transformer was deprecated in v2.0.
+Use Data.List.Effectful.Transformer instead."
+#-}
diff --git a/src/Data/List/Countdown.agda b/src/Data/List/Countdown.agda
index 1ae0efc9b8..dea756e108 100644
--- a/src/Data/List/Countdown.agda
+++ b/src/Data/List/Countdown.agda
@@ -8,7 +8,7 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Level using (0ℓ)
-open import Relation.Binary
+open import Relation.Binary.Bundles using (DecSetoid)
 
 module Data.List.Countdown (D : DecSetoid 0ℓ 0ℓ) where
 
@@ -20,18 +20,19 @@ open import Function.Base
 open import Function.Bundles
   using (Injection; module Injection)
 open import Data.Bool.Base using (true; false)
-open import Data.List hiding (lookup)
+open import Data.List.Base hiding (lookup)
 open import Data.List.Relation.Unary.Any as Any using (here; there)
 open import Data.Nat.Base using (ℕ; zero; suc)
-open import Data.Product
+open import Data.Product.Base using (∃; _,_; _×_)
 open import Data.Sum.Base
 open import Data.Sum.Properties
 open import Relation.Nullary.Reflects using (invert)
 open import Relation.Nullary
 open import Relation.Nullary.Decidable using (dec-true; dec-false)
-open import Relation.Binary.PropositionalEquality as PropEq
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; _≢_; refl; cong)
-open PropEq.≡-Reasoning
+import Relation.Binary.PropositionalEquality.Properties as ≡
+open ≡.≡-Reasoning
 
 private
   open module D = DecSetoid D
@@ -123,12 +124,12 @@ record _⊕_ (counted : List Elem) (n : ℕ) : Set where
 
 -- A countdown can be initialised by proving that Elem is finite.
 
-empty : ∀ {n} → Injection D.setoid (PropEq.setoid (Fin n)) → [] ⊕ n
+empty : ∀ {n} → Injection D.setoid (≡.setoid (Fin n)) → [] ⊕ n
 empty inj =
   record { kind      = inj₂ ∘ to
          ; injective = λ {x} {y} {i} eq₁ eq₂ → injective (begin
              to x ≡⟨ inj₂-injective eq₁ ⟩
-             i    ≡⟨ PropEq.sym $ inj₂-injective eq₂ ⟩
+             i    ≡⟨ ≡.sym $ inj₂-injective eq₂ ⟩
              to y ∎)
          }
   where open Injection inj
@@ -198,7 +199,7 @@ insert {counted} {n} counted⊕1+n x x∉counted =
   inj eq₁ eq₂ | no  _ | no  _ | inj₂ i         | inj₂ _ | inj₂ _ | _ | _ | hlp =
     hlp _ refl refl $
       punchOut-injective {i = i} _ _ $
-        (PropEq.trans (inj₂-injective eq₁) (PropEq.sym (inj₂-injective eq₂)))
+        (≡.trans (inj₂-injective eq₁) (≡.sym (inj₂-injective eq₂)))
 
 -- Counts an element if it has not already been counted.
 
diff --git a/src/Data/List/Effectful.agda b/src/Data/List/Effectful.agda
index fa7280f68f..0bbcad4973 100644
--- a/src/Data/List/Effectful.agda
+++ b/src/Data/List/Effectful.agda
@@ -10,21 +10,29 @@ module Data.List.Effectful where
 
 open import Data.Bool.Base using (false; true)
 open import Data.List.Base
+  using (List; map; [_]; ap; []; _∷_; _++_; concat; concatMap)
 open import Data.List.Properties
-open import Effect.Choice
-open import Effect.Empty
-open import Effect.Functor
+  using (++-identityʳ; ++-assoc; map-cong; concatMap-cong; map-concatMap;
+    concatMap-pure)
+open import Effect.Choice using (RawChoice)
+open import Effect.Empty using (RawEmpty)
+open import Effect.Functor using (RawFunctor)
 open import Effect.Applicative
+  using (RawApplicative; RawApplicativeZero; RawAlternative)
 open import Effect.Monad
-open import Function.Base
-open import Level
-open import Relation.Binary.PropositionalEquality as P
+  using (RawMonad; module Join; RawMonadZero; RawMonadPlus)
+open import Function.Base using (flip; _∘_; const; _$_; id; _∘′_; _$′_)
+open import Level using (Level)
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; _≢_; _≗_; refl)
-open P.≡-Reasoning
+open import Relation.Binary.PropositionalEquality.Properties as ≡
+
+open ≡.≡-Reasoning
 
 private
   variable
     ℓ : Level
+    A : Set ℓ
 
 ------------------------------------------------------------------------
 -- List applicative functor
@@ -66,6 +74,9 @@ monad = record
   ; _>>=_  = flip concatMap
   }
 
+join : List (List A) → List A
+join = Join.join monad
+
 monadZero : ∀ {ℓ} → RawMonadZero {ℓ} List
 monadZero = record
   { rawMonad = monad
@@ -121,7 +132,7 @@ module MonadProperties where
   right-identity : ∀ {ℓ} {A : Set ℓ} (xs : List A) →
                    (xs >>= pure) ≡ xs
   right-identity []       = refl
-  right-identity (x ∷ xs) = P.cong (x ∷_) (right-identity xs)
+  right-identity (x ∷ xs) = ≡.cong (x ∷_) (right-identity xs)
 
   left-zero : ∀ {ℓ} {A B : Set ℓ} (f : A → List B) → (∅ >>= f) ≡ ∅
   left-zero f = refl
@@ -143,8 +154,8 @@ module MonadProperties where
                        (xs ∣ ys >>= f) ≡ ((xs >>= f) ∣ (ys >>= f))
   right-distributive []       ys f = refl
   right-distributive (x ∷ xs) ys f = begin
-    f x ∣ (xs ∣ ys >>= f)              ≡⟨ P.cong (f x ∣_) $ right-distributive xs ys f ⟩
-    f x ∣ ((xs >>= f) ∣ (ys >>= f))    ≡⟨ P.sym $ ++-assoc (f x) _ _ ⟩
+    f x ∣ (xs ∣ ys >>= f)              ≡⟨ ≡.cong (f x ∣_) $ right-distributive xs ys f ⟩
+    f x ∣ ((xs >>= f) ∣ (ys >>= f))    ≡⟨ ≡.sym $ ++-assoc (f x) _ _ ⟩
     ((f x ∣ (xs >>= f)) ∣ (ys >>= f))  ∎
 
   associative : ∀ {ℓ} {A B C : Set ℓ}
@@ -152,13 +163,13 @@ module MonadProperties where
                 (xs >>= λ x → f x >>= g) ≡ (xs >>= f >>= g)
   associative []       f g = refl
   associative (x ∷ xs) f g = begin
-    (f x >>= g) ∣ (xs >>= λ x → f x >>= g)  ≡⟨ P.cong ((f x >>= g) ∣_) $ associative xs f g ⟩
-    (f x >>= g) ∣ (xs >>= f >>= g)          ≡⟨ P.sym $ right-distributive (f x) (xs >>= f) g ⟩
+    (f x >>= g) ∣ (xs >>= λ x → f x >>= g)  ≡⟨ ≡.cong ((f x >>= g) ∣_) $ associative xs f g ⟩
+    (f x >>= g) ∣ (xs >>= f >>= g)          ≡⟨ ≡.sym $ right-distributive (f x) (xs >>= f) g ⟩
     (f x ∣ (xs >>= f) >>= g)                ∎
 
   cong : ∀ {ℓ} {A B : Set ℓ} {xs₁ xs₂} {f₁ f₂ : A → List B} →
          xs₁ ≡ xs₂ → f₁ ≗ f₂ → (xs₁ >>= f₁) ≡ (xs₂ >>= f₂)
-  cong {xs₁ = xs} refl f₁≗f₂ = P.cong concat (map-cong f₁≗f₂ xs)
+  cong {xs₁ = xs} refl f₁≗f₂ = ≡.cong concat (map-cong f₁≗f₂ xs)
 
 ------------------------------------------------------------------------
 -- The applicative functor derived from the list monad.
@@ -198,14 +209,14 @@ module Applicative where
 
   unfold-<$> : ∀ {ℓ} {A B : Set ℓ} → (f : A → B) (as : List A) →
                (f <$> as) ≡ (pure f ⊛ as)
-  unfold-<$> f as = P.sym (++-identityʳ (f <$> as))
+  unfold-<$> f as = ≡.sym (++-identityʳ (f <$> as))
 
   -- _⊛_ unfolds to binds.
   unfold-⊛ : ∀ {ℓ} {A B : Set ℓ} → (fs : List (A → B)) (as : List A) →
              (fs ⊛ as) ≡ (fs >>= pam as)
   unfold-⊛ fs as = begin
     fs ⊛ as
-      ≡˘⟨ concatMap-cong (λ f → P.cong (map f) (concatMap-pure as)) fs ⟩
+      ≡⟨ concatMap-cong (λ f → ≡.cong (map f) (concatMap-pure as)) fs ⟨
     concatMap (λ f → map f (concatMap pure as)) fs
       ≡⟨ concatMap-cong (λ f → map-concatMap f pure as) fs ⟩
     concatMap (λ f → concatMap (λ x → pure (f x)) as) fs
@@ -220,7 +231,7 @@ module Applicative where
   right-distributive fs₁ fs₂ xs = begin
     (fs₁ ∣ fs₂) ⊛ xs                     ≡⟨ unfold-⊛ (fs₁ ∣ fs₂) xs ⟩
     (fs₁ ∣ fs₂ >>= pam xs)               ≡⟨ MonadProperties.right-distributive fs₁ fs₂ (pam xs) ⟩
-    (fs₁ >>= pam xs) ∣ (fs₂ >>= pam xs)  ≡˘⟨ P.cong₂ _∣_ (unfold-⊛ fs₁ xs) (unfold-⊛ fs₂ xs) ⟩
+    (fs₁ >>= pam xs) ∣ (fs₂ >>= pam xs)  ≡⟨ ≡.cong₂ _∣_ (unfold-⊛ fs₁ xs) (unfold-⊛ fs₂ xs) ⟨
     (fs₁ ⊛ xs ∣ fs₂ ⊛ xs)                ∎
 
   -- _⊛_ does not distribute over _∣_ from the left.
@@ -247,7 +258,7 @@ module Applicative where
                 (xs : List A) (f : A → B) (fs : B → List C) →
                 (pam xs f >>= fs) ≡ (xs >>= λ x → fs (f x))
     pam-lemma xs f fs = begin
-      (pam xs f >>= fs)                 ≡˘⟨ MP.associative xs (pure ∘ f) fs ⟩
+      (pam xs f >>= fs)                 ≡⟨ MP.associative xs (pure ∘ f) fs ⟨
       (xs >>= λ x → pure (f x) >>= fs)  ≡⟨ MP.cong (refl {x = xs}) (λ x → MP.left-identity (f x) fs) ⟩
       (xs >>= λ x → fs (f x))           ∎
 
@@ -258,9 +269,9 @@ module Applicative where
     pure _∘′_ ⊛ fs ⊛ gs ⊛ xs
       ≡⟨ unfold-⊛ (pure _∘′_ ⊛ fs ⊛ gs) xs ⟩
     (pure _∘′_ ⊛ fs ⊛ gs >>= pam xs)
-      ≡⟨ P.cong (_>>= pam xs) (unfold-⊛ (pure _∘′_ ⊛ fs) gs) ⟩
+      ≡⟨ ≡.cong (_>>= pam xs) (unfold-⊛ (pure _∘′_ ⊛ fs) gs) ⟩
     (pure _∘′_ ⊛ fs >>= pam gs >>= pam xs)
-      ≡⟨ P.cong (λ h → h >>= pam gs >>= pam xs) (unfold-⊛ (pure _∘′_) fs) ⟩
+      ≡⟨ ≡.cong (λ h → h >>= pam gs >>= pam xs) (unfold-⊛ (pure _∘′_) fs) ⟩
     (pure _∘′_ >>= pam fs >>= pam gs >>= pam xs)
       ≡⟨ MP.cong (MP.cong (MP.left-identity _∘′_ (pam fs))
                  (λ f → refl {x = pam gs f}))
@@ -268,19 +279,19 @@ module Applicative where
     (pam fs _∘′_ >>= pam gs >>= pam xs)
       ≡⟨ MP.cong (pam-lemma fs _∘′_ (pam gs)) (λ _ → refl) ⟩
     ((fs >>= λ f → pam gs (f ∘′_)) >>= pam xs)
-      ≡˘⟨ MP.associative fs (λ f → pam gs (_∘′_ f)) (pam xs) ⟩
+      ≡⟨ MP.associative fs (λ f → pam gs (_∘′_ f)) (pam xs) ⟨
     (fs >>= λ f → pam gs (f ∘′_) >>= pam xs)
       ≡⟨ MP.cong (refl {x = fs}) (λ f → pam-lemma gs (f ∘′_) (pam xs)) ⟩
     (fs >>= λ f → gs >>= λ g → pam xs (f ∘′ g))
       ≡⟨ (MP.cong (refl {x = fs}) λ f →
          MP.cong (refl {x = gs}) λ g →
-         P.sym $ pam-lemma xs g (pure ∘ f)) ⟩
+         ≡.sym $ pam-lemma xs g (pure ∘ f)) ⟩
     (fs >>= λ f → gs >>= λ g → pam (pam xs g) f)
       ≡⟨ MP.cong (refl {x = fs}) (λ f → MP.associative gs (pam xs) (pure ∘ f)) ⟩
     (fs >>= pam (gs >>= pam xs))
-      ≡˘⟨ unfold-⊛ fs (gs >>= pam xs) ⟩
+      ≡⟨ unfold-⊛ fs (gs >>= pam xs) ⟨
     fs ⊛ (gs >>= pam xs)
-      ≡˘⟨ P.cong (fs ⊛_) (unfold-⊛ gs xs) ⟩
+      ≡⟨ ≡.cong (fs ⊛_) (unfold-⊛ gs xs) ⟨
     fs ⊛ (gs ⊛ xs)
       ∎
 
@@ -299,6 +310,6 @@ module Applicative where
     (fs >>= pam (pure x))      ≡⟨ (MP.cong (refl {x = fs}) λ f →
                                       MP.left-identity x (pure ∘ f)) ⟩
     (fs >>= λ f → pure (f x))  ≡⟨⟩
-    (pam fs (_$′ x))           ≡⟨ P.sym $ MP.left-identity (_$′ x) (pam fs) ⟩
-    (pure (_$′ x) >>= pam fs)  ≡˘⟨ unfold-⊛ (pure (_$′ x)) fs ⟩
+    (pam fs (_$′ x))           ≡⟨ ≡.sym $ MP.left-identity (_$′ x) (pam fs) ⟩
+    (pure (_$′ x) >>= pam fs)  ≡⟨ unfold-⊛ (pure (_$′ x)) fs ⟨
     pure (_$′ x) ⊛ fs          ∎
diff --git a/src/Data/List/Extrema.agda b/src/Data/List/Extrema.agda
index 8d71aab6a7..16e38db5bb 100644
--- a/src/Data/List/Extrema.agda
+++ b/src/Data/List/Extrema.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (TotalOrder; Setoid)
+open import Relation.Binary.Bundles using (TotalOrder; Setoid)
 
 module Data.List.Extrema
   {b ℓ₁ ℓ₂} (totalOrder : TotalOrder b ℓ₁ ℓ₂) where
@@ -30,7 +30,7 @@ open import Relation.Binary.PropositionalEquality.Core
   using (_≡_; sym; subst) renaming (refl to ≡-refl)
 import Relation.Binary.Construct.On as On
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Setup
 
 open TotalOrder totalOrder renaming (Carrier to B)
@@ -43,7 +43,7 @@ private
     a p : Level
     A : Set a
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Functions
 
 argmin : (A → B) → A → List A → A
@@ -58,7 +58,7 @@ min = argmin id
 max : B → List B → B
 max = argmax id
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of argmin
 
 module _ {f : A → B} where
@@ -114,7 +114,7 @@ argmin-all f {⊤} {xs} {P = P}  p⊤ pxs with argmin-sel f ⊤ xs
 ... | inj₁ argmin≡⊤  = subst P (sym argmin≡⊤) p⊤
 ... | inj₂ argmin∈xs = lookup pxs argmin∈xs
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of argmax
 
 module _ {f : A → B} where
@@ -170,7 +170,7 @@ argmax-all f {P = P} {⊥} {xs} p⊥ pxs with argmax-sel f ⊥ xs
 ... | inj₁ argmax≡⊥  = subst P (sym argmax≡⊥) p⊥
 ... | inj₂ argmax∈xs = lookup pxs argmax∈xs
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of min
 
 min≤v⁺ : ∀ {v} ⊤ xs → ⊤ ≤ v ⊎ Any (_≤ v) xs → min ⊤ xs ≤ v
@@ -208,7 +208,7 @@ min-mono-⊆ : ∀ {⊥₁ ⊥₂ xs ys} → ⊥₁ ≤ ⊥₂ → xs ⊇ ys →
 min-mono-⊆ ⊥₁≤⊥₂ ys⊆xs = min[xs]≤min[ys]⁺ _ _ (inj₁ ⊥₁≤⊥₂)
   (tabulate (inj₂ ∘ Any.map (λ {≡-refl → refl}) ∘ ys⊆xs))
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of max
 
 max≤v⁺ : ∀ {v ⊥ xs} → ⊥ ≤ v → All (_≤ v) xs → max ⊥ xs ≤ v
diff --git a/src/Data/List/Extrema/Core.agda b/src/Data/List/Extrema/Core.agda
index aa0b3f8da9..674e359136 100644
--- a/src/Data/List/Extrema/Core.agda
+++ b/src/Data/List/Extrema/Core.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Trans; TotalOrder; Setoid)
+open import Relation.Binary.Definitions using (Trans)
+open import Relation.Binary.Bundles using (TotalOrder; Setoid)
 
 module Data.List.Extrema.Core
   {b ℓ₁ ℓ₂} (totalOrder : TotalOrder b ℓ₁ ℓ₂) where
@@ -15,10 +16,10 @@ open import Algebra.Core
 open import Algebra.Definitions
 import Algebra.Construct.NaturalChoice.Min as Min
 import Algebra.Construct.NaturalChoice.Max as Max
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 open import Level using (Level)
-open import Relation.Binary.PropositionalEquality using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 open import Algebra.Construct.LiftedChoice
 
diff --git a/src/Data/List/Extrema/Nat.agda b/src/Data/List/Extrema/Nat.agda
index d1d8f3f4ac..28b75e922c 100644
--- a/src/Data/List/Extrema/Nat.agda
+++ b/src/Data/List/Extrema/Nat.agda
@@ -12,15 +12,15 @@
 module Data.List.Extrema.Nat where
 
 open import Data.Nat.Base using (ℕ; _≤_; _<_)
-open import Data.Nat.Properties as ℕₚ using (≤∧≢⇒<; <⇒≤; <⇒≢)
+open import Data.Nat.Properties as ℕ using (≤∧≢⇒<; <⇒≤; <⇒≢)
 open import Data.Sum.Base as Sum using (_⊎_)
 open import Data.List.Base using (List)
 import Data.List.Extrema
 open import Data.List.Relation.Unary.Any as Any using (Any)
 open import Data.List.Relation.Unary.All as All using (All)
-open import Data.Product using (_×_; _,_; uncurry′)
+open import Data.Product.Base using (_×_; _,_; uncurry′)
 open import Level using (Level)
-open import Relation.Binary.PropositionalEquality using (_≢_)
+open import Relation.Binary.PropositionalEquality.Core using (_≢_)
 
 private
   variable
@@ -33,7 +33,7 @@ private
   <×⇒< : ∀ {x y} → x ≤ y × x ≢ y → x < y
   <×⇒< (x≤y , x≢y) = ≤∧≢⇒< x≤y x≢y
 
-  module Extrema = Data.List.Extrema ℕₚ.≤-totalOrder
+  module Extrema = Data.List.Extrema ℕ.≤-totalOrder
 
 ------------------------------------------------------------------------
 -- Re-export the contents of Extrema
diff --git a/src/Data/List/Fresh.agda b/src/Data/List/Fresh.agda
index 8665267dd5..028e186567 100644
--- a/src/Data/List/Fresh.agda
+++ b/src/Data/List/Fresh.agda
@@ -1,9 +1,9 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Fresh lists, a proof relevant variant of Catarina Coquand's contexts in
--- "A Formalised Proof of the Soundness and Completeness of a Simply Typed
--- Lambda-Calculus with Explicit Substitutions"
+-- Fresh lists, a proof relevant variant of Catarina Coquand's contexts
+-- in "A Formalised Proof of the Soundness and Completeness of a Simply
+-- Typed Lambda-Calculus with Explicit Substitutions"
 ------------------------------------------------------------------------
 
 -- See README.Data.List.Fresh and README.Data.Trie.NonDependent for
@@ -14,17 +14,18 @@
 module Data.List.Fresh where
 
 open import Level using (Level; _⊔_)
-open import Data.Bool.Base using (true; false)
+open import Data.Bool.Base using (true; false; if_then_else_)
 open import Data.Unit.Polymorphic.Base using (⊤)
-open import Data.Product using (∃; _×_; _,_; -,_; proj₁; proj₂)
+open import Data.Product.Base using (∃; _×_; _,_; -,_; proj₁; proj₂)
 open import Data.List.Relation.Unary.All using (All; []; _∷_)
 open import Data.List.Relation.Unary.AllPairs using (AllPairs; []; _∷_)
 open import Data.Maybe.Base as Maybe using (Maybe; just; nothing)
 open import Data.Nat.Base using (ℕ; zero; suc)
 open import Function.Base using (_∘′_; flip; id; _on_)
-open import Relation.Nullary      using (does)
-open import Relation.Unary   as U using (Pred)
-open import Relation.Binary  as B using (Rel)
+open import Relation.Nullary using (does)
+open import Relation.Unary as U using (Pred)
+open import Relation.Binary.Core using (Rel)
+import Relation.Binary.Definitions as B
 open import Relation.Nary
 
 private
@@ -52,8 +53,8 @@ module _ {a} (A : Set a) (R : Rel A r) where
   -- the erasure ⌊_⌋ of a decidable predicate, cf. Relation.Nary) or we
   -- do not care about the proof, it is convenient to get back list syntax.
 
-  -- We use a different symbol to avoid conflict when importing both Data.List
-  -- and Data.List.Fresh.
+  -- We use a different symbol to avoid conflict when importing both
+  -- Data.List and Data.List.Fresh.
   infixr 5 _∷#_
   pattern _∷#_ x xs = cons x xs _
 
@@ -160,10 +161,10 @@ module _ {P : Pred A p} (P? : U.Decidable P) where
   takeWhile-# : ∀ {R : Rel A r} a (as : List# A R) → a # as → a # takeWhile as
 
   takeWhile []             = []
-  takeWhile (cons a as ps) with does (P? a)
-  ... | true  = cons a (takeWhile as) (takeWhile-# a as ps)
-  ... | false = []
+  takeWhile (cons a as ps) =
+    if does (P? a) then cons a (takeWhile as) (takeWhile-# a as ps) else []
 
+  -- this 'with' is needed to cause reduction in the type of 'takeWhile (a ∷# as)'
   takeWhile-# a []        _        = _
   takeWhile-# a (x ∷# xs) (p , ps) with does (P? x)
   ... | true  = p , takeWhile-# a xs ps
@@ -171,18 +172,17 @@ module _ {P : Pred A p} (P? : U.Decidable P) where
 
   dropWhile : {R : Rel A r} → List# A R → List# A R
   dropWhile []            = []
-  dropWhile aas@(a ∷# as) with does (P? a)
-  ... | true  = dropWhile as
-  ... | false = aas
+  dropWhile aas@(a ∷# as)  = if does (P? a) then dropWhile as else aas
 
   filter   : {R : Rel A r} → List# A R → List# A R
   filter-# : ∀ {R : Rel A r} a (as : List# A R) → a # as → a # filter as
 
   filter []             = []
-  filter (cons a as ps) with does (P? a)
-  ... | true  = cons a (filter as) (filter-# a as ps)
-  ... | false = filter as
+  filter (cons a as ps) =
+    let l = filter as in
+    if does (P? a) then cons a l (filter-# a as ps) else l
 
+  -- this 'with' is needed to cause reduction in the type of 'filter-# a (x ∷# xs)'
   filter-# a []        _        = _
   filter-# a (x ∷# xs) (p , ps) with does (P? x)
   ... | true  = p , filter-# a xs ps
diff --git a/src/Data/List/Fresh/Membership/Setoid.agda b/src/Data/List/Fresh/Membership/Setoid.agda
index 6ef9ef4836..5e0b3fdc15 100644
--- a/src/Data/List/Fresh/Membership/Setoid.agda
+++ b/src/Data/List/Fresh/Membership/Setoid.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Fresh.Membership.Setoid {c ℓ} (S : Setoid c ℓ) where
 
diff --git a/src/Data/List/Fresh/Membership/Setoid/Properties.agda b/src/Data/List/Fresh/Membership/Setoid/Properties.agda
index 52be3b0d60..72bdc6c0ba 100644
--- a/src/Data/List/Fresh/Membership/Setoid/Properties.agda
+++ b/src/Data/List/Fresh/Membership/Setoid/Properties.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; Setoid)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Fresh.Membership.Setoid.Properties {c ℓ} (S : Setoid c ℓ) where
 
@@ -14,22 +15,21 @@ open import Level using (Level; _⊔_)
 open import Data.Empty
 open import Data.Nat.Base
 open import Data.Nat.Properties
-open import Data.Product using (∃; _×_; _,_)
+open import Data.Product.Base using (∃; _×_; _,_)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; fromInj₂)
 
 open import Function.Base using (id; _∘′_; _$_)
 open import Relation.Nullary
-open import Relation.Unary as U using (Pred)
-import Relation.Binary as B
-import Relation.Binary.PropositionalEquality as P
+open import Relation.Unary as Unary using (Pred)
+import Relation.Binary.Definitions as Binary
+import Relation.Binary.PropositionalEquality.Core as ≡
 open import Relation.Nary
 
 open import Data.List.Fresh
 open import Data.List.Fresh.Properties
 open import Data.List.Fresh.Membership.Setoid S
 open import Data.List.Fresh.Relation.Unary.Any using (Any; here; there; _─_)
-import Data.List.Fresh.Relation.Unary.Any.Properties as Anyₚ
-import Data.List.Fresh.Relation.Unary.All.Properties as Allₚ
+import Data.List.Fresh.Relation.Unary.Any.Properties as List#
 
 open Setoid S renaming (Carrier to A)
 
@@ -81,7 +81,7 @@ module _ {R : Rel A r} where
 module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) (≉⇒R : ∀[ _≉_ ⇒ R ]) where
 
   private
-    R≈ : R B.Respectsˡ _≈_
+    R≈ : R Binary.Respectsˡ _≈_
     R≈ x≈y Rxz = ≉⇒R (R⇒≉ Rxz ∘′ trans x≈y)
 
   fresh-remove : ∀ {x} {xs : List# A R} (x∈xs : x ∈ xs) → x # (xs ─ x∈xs)
@@ -102,7 +102,7 @@ module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) where
   injection {[]}                 {ys} inj = z≤n
   injection {xxs@(cons x xs pr)} {ys} inj = begin
     length xxs               ≤⟨ s≤s (injection step) ⟩
-    suc (length (ys ─ x∈ys)) ≡⟨ P.sym (Anyₚ.length-remove x∈ys) ⟩
+    suc (length (ys ─ x∈ys)) ≡⟨ ≡.sym (List#.length-remove x∈ys) ⟩
     length ys                ∎
 
     where
@@ -122,7 +122,7 @@ module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) where
    (∃ λ x → x ∈ ys × x ∉ xs) → length xs < length ys
   strict-injection {xs} {ys} inj (x , x∈ys , x∉xs) = begin
     suc (length xs)          ≤⟨ s≤s (injection step) ⟩
-    suc (length (ys ─ x∈ys)) ≡⟨ P.sym (Anyₚ.length-remove x∈ys) ⟩
+    suc (length (ys ─ x∈ys)) ≡⟨ ≡.sym (List#.length-remove x∈ys) ⟩
     length ys                ∎
 
     where
@@ -137,12 +137,12 @@ module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) where
 ------------------------------------------------------------------------
 -- proof irrelevance
 
-module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) (≈-irrelevant : B.Irrelevant _≈_) where
+module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) (≈-irrelevant : Binary.Irrelevant _≈_) where
 
   ∈-irrelevant : ∀ {x} {xs : List# A R} → Irrelevant (x ∈ xs)
   -- positive cases
-  ∈-irrelevant (here x≈y₁)   (here x≈y₂)   = P.cong here (≈-irrelevant x≈y₁ x≈y₂)
-  ∈-irrelevant (there x∈xs₁) (there x∈xs₂) = P.cong there (∈-irrelevant x∈xs₁ x∈xs₂)
+  ∈-irrelevant (here x≈y₁)   (here x≈y₂)   = ≡.cong here (≈-irrelevant x≈y₁ x≈y₂)
+  ∈-irrelevant (there x∈xs₁) (there x∈xs₂) = ≡.cong there (∈-irrelevant x∈xs₁ x∈xs₂)
   -- absurd cases
   ∈-irrelevant {xs = cons x xs pr} (here x≈y)    (there x∈xs₂) =
     ⊥-elim (distinct x∈xs₂ (fresh⇒∉ R⇒≉ pr) x≈y)
diff --git a/src/Data/List/Fresh/NonEmpty.agda b/src/Data/List/Fresh/NonEmpty.agda
index 1ed72bd9d4..e4b55cb11b 100644
--- a/src/Data/List/Fresh/NonEmpty.agda
+++ b/src/Data/List/Fresh/NonEmpty.agda
@@ -11,9 +11,9 @@ module Data.List.Fresh.NonEmpty where
 open import Level using (Level; _⊔_)
 open import Data.List.Fresh as List# using (List#; []; cons; fresh)
 open import Data.Maybe.Base using (Maybe; nothing; just)
-open import Data.Nat using (ℕ; suc)
-open import Data.Product using (_×_; _,_)
-open import Relation.Binary as B using (Rel)
+open import Data.Nat.Base using (ℕ; suc)
+open import Data.Product.Base using (_×_; _,_)
+open import Relation.Binary.Core using (Rel)
 
 private
   variable
diff --git a/src/Data/List/Fresh/Properties.agda b/src/Data/List/Fresh/Properties.agda
index cc8925eca6..49452e08ee 100644
--- a/src/Data/List/Fresh/Properties.agda
+++ b/src/Data/List/Fresh/Properties.agda
@@ -8,11 +8,12 @@
 
 module Data.List.Fresh.Properties where
 
-open import Level using (Level; _⊔_; Lift)
-open import Data.Product using (_,_)
+open import Level using (Level; _⊔_)
+open import Data.Product.Base using (_,_)
 open import Relation.Nullary
 open import Relation.Unary as U using (Pred)
-open import Relation.Binary as B using (Rel)
+import Relation.Binary.Definitions as B
+open import Relation.Binary.Core using (Rel)
 
 open import Data.List.Fresh
 
diff --git a/src/Data/List/Fresh/Relation/Unary/All.agda b/src/Data/List/Fresh/Relation/Unary/All.agda
index c013f934bb..365bbf1a70 100644
--- a/src/Data/List/Fresh/Relation/Unary/All.agda
+++ b/src/Data/List/Fresh/Relation/Unary/All.agda
@@ -9,11 +9,12 @@
 module Data.List.Fresh.Relation.Unary.All where
 
 open import Level using (Level; _⊔_; Lift)
-open import Data.Product using (_×_; _,_; proj₁; uncurry)
-open import Data.Sum.Base as Sum using (inj₁; inj₂)
+open import Data.Product.Base using (_×_; _,_; proj₁; uncurry)
+open import Data.Sum.Base as Sum using (inj₁; inj₂; [_,_]′)
+open import Function.Base using (_∘_; _$_)
 open import Relation.Nullary.Decidable as Dec using (Dec; yes; no; _×-dec_)
 open import Relation.Unary  as U
-open import Relation.Binary as B using (Rel)
+open import Relation.Binary.Core using (Rel)
 
 open import Data.List.Fresh using (List#; []; cons; _∷#_; _#_)
 open import Data.List.Fresh.Relation.Unary.Any as Any using (Any; here; there)
@@ -74,6 +75,7 @@ module _ {R : Rel A r} {P : Pred A p} {Q : Pred A q} where
 
   decide :  Π[ P ∪ Q ] → Π[ All {R = R} P ∪ Any Q ]
   decide p∪q [] = inj₁ []
-  decide p∪q (x ∷# xs) with p∪q x
-  ... | inj₂ qx = inj₂ (here qx)
-  ... | inj₁ px = Sum.map (px ∷_) there (decide p∪q xs)
+  decide p∪q (x ∷# xs) =
+    [ (λ px → Sum.map (px ∷_) there (decide p∪q xs))
+    , inj₂ ∘ here
+    ]′ $ p∪q x
diff --git a/src/Data/List/Fresh/Relation/Unary/All/Properties.agda b/src/Data/List/Fresh/Relation/Unary/All/Properties.agda
index cbad777b96..b32f08ca25 100644
--- a/src/Data/List/Fresh/Relation/Unary/All/Properties.agda
+++ b/src/Data/List/Fresh/Relation/Unary/All/Properties.agda
@@ -11,12 +11,12 @@ module Data.List.Fresh.Relation.Unary.All.Properties where
 open import Level using (Level; _⊔_; Lift)
 open import Data.Empty
 open import Data.Nat.Base using (ℕ; zero; suc)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (_∘′_)
 open import Relation.Nullary
 open import Relation.Unary  as U
-open import Relation.Binary as B using (Rel)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
 
 open import Data.List.Fresh using (List#; []; cons; _∷#_; _#_)
 open import Data.List.Fresh.Relation.Unary.All
diff --git a/src/Data/List/Fresh/Relation/Unary/Any.agda b/src/Data/List/Fresh/Relation/Unary/Any.agda
index 4c11dd7974..5d10af8e81 100644
--- a/src/Data/List/Fresh/Relation/Unary/Any.agda
+++ b/src/Data/List/Fresh/Relation/Unary/Any.agda
@@ -9,14 +9,13 @@
 module Data.List.Fresh.Relation.Unary.Any where
 
 open import Level using (Level; _⊔_; Lift)
-open import Data.Empty
-open import Data.Product using (∃; _,_; -,_)
+open import Data.Product.Base using (∃; _,_; -,_)
 open import Data.Sum.Base using (_⊎_; [_,_]′; inj₁; inj₂)
 open import Function.Bundles using (_⇔_; mk⇔)
-open import Relation.Nullary.Negation using (¬_)
-open import Relation.Nullary.Decidable as Dec using (Dec; yes; no; _⊎-dec_)
+open import Relation.Nullary.Negation using (¬_; contradiction)
+open import Relation.Nullary.Decidable as Dec using (Dec; no; _⊎-dec_)
 open import Relation.Unary  as U
-open import Relation.Binary as B using (Rel)
+open import Relation.Binary.Core using (Rel)
 
 open import Data.List.Fresh using (List#; []; cons; _∷#_; _#_)
 
@@ -35,10 +34,10 @@ module _ {R : Rel A r} {P : Pred A p} {x} {xs : List# A R} {pr} where
 
   head : ¬ Any P xs → Any P (cons x xs pr) → P x
   head ¬tail (here p)   = p
-  head ¬tail (there ps) = ⊥-elim (¬tail ps)
+  head ¬tail (there ps) = contradiction ps ¬tail
 
   tail : ¬ P x → Any P (cons x xs pr) → Any P xs
-  tail ¬head (here p)   = ⊥-elim (¬head p)
+  tail ¬head (here p)   = contradiction p ¬head
   tail ¬head (there ps) = ps
 
   toSum : Any P (cons x xs pr) → P x ⊎ Any P xs
diff --git a/src/Data/List/Fresh/Relation/Unary/Any/Properties.agda b/src/Data/List/Fresh/Relation/Unary/Any/Properties.agda
index f185a2ef32..70a2a6ee29 100644
--- a/src/Data/List/Fresh/Relation/Unary/Any/Properties.agda
+++ b/src/Data/List/Fresh/Relation/Unary/Any/Properties.agda
@@ -12,15 +12,15 @@ open import Level using (Level; _⊔_; Lift)
 open import Data.Bool.Base using (true; false)
 open import Data.Empty
 open import Data.Nat.Base using (ℕ; zero; suc)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
 open import Function.Base using (_∘′_)
 open import Relation.Nullary.Reflects using (invert)
 open import Relation.Nullary
 open import Relation.Unary  as U using (Pred)
-open import Relation.Binary as B using (Rel)
+open import Relation.Binary.Core using (Rel)
 open import Relation.Nary
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
 
 open import Data.List.Fresh
 open import Data.List.Fresh.Relation.Unary.All
diff --git a/src/Data/List/Kleene/AsList.agda b/src/Data/List/Kleene/AsList.agda
index bb2c52b603..0b6d4c033d 100644
--- a/src/Data/List/Kleene/AsList.agda
+++ b/src/Data/List/Kleene/AsList.agda
@@ -54,9 +54,9 @@ infixr 5 _∷_
 pattern _∷_ x xs = Kleene.∹ x Kleene.& xs
 
 ------------------------------------------------------------------------
--- The following functions change the type of the list (from ⁺ to * or vice
--- versa) in Data.KleeneList, so we reimplement them here to keep the
--- type the same.
+-- The following functions change the type of the list (from ⁺ to * or
+-- vice versa) in Data.KleeneList, so we reimplement them here to keep
+-- the type the same.
 
 scanr : (A → B → B) → B → List A → List B
 scanr f b xs = Kleene.∹ Kleene.scanr* f b xs
diff --git a/src/Data/List/Kleene/Base.agda b/src/Data/List/Kleene/Base.agda
index 906af96ea1..ef0ca0b0a2 100644
--- a/src/Data/List/Kleene/Base.agda
+++ b/src/Data/List/Kleene/Base.agda
@@ -8,11 +8,12 @@
 
 module Data.List.Kleene.Base where
 
-open import Data.Product as Product using (_×_; _,_; map₂; map₁; proj₁; proj₂)
-open import Data.Nat     as ℕ       using (ℕ; suc; zero)
-open import Data.Maybe   as Maybe   using (Maybe; just; nothing)
-open import Data.Sum     as Sum     using (_⊎_; inj₁; inj₂)
-open import Level        as Level   using (Level)
+open import Data.Product.Base as Product
+  using (_×_; _,_; map₂; map₁; proj₁; proj₂)
+open import Data.Nat.Base as ℕ using (ℕ; suc; zero)
+open import Data.Maybe.Base as Maybe using (Maybe; just; nothing; maybe′)
+open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
+open import Level using (Level)
 
 open import Algebra.Core using (Op₂)
 open import Function.Base
@@ -40,6 +41,7 @@ private
 --   simplify certain proofs.
 
 infixr 5 _&_ ∹_
+infixl 4 _+ _*
 
 record _+ {a} (A : Set a) : Set a
 data _* {a} (A : Set a) : Set a
@@ -101,6 +103,7 @@ module _ (f : B → A → B) where
 -- Concatenation
 
 module Concat where
+  infixr 4 _++++_ _+++*_ _*+++_ _*++*_
   _++++_ : A + → A + → A +
   _+++*_ : A + → A * → A +
   _*+++_ : A * → A + → A +
@@ -134,9 +137,7 @@ module _ (f : A → Maybe B) where
   mapMaybe+ : A + → B *
   mapMaybe* : A * → B *
 
-  mapMaybe+ (x & xs) with f x
-  ... | just y  = ∹ y & mapMaybe* xs
-  ... | nothing = mapMaybe* xs
+  mapMaybe+ (x & xs) = maybe′ (λ y z → ∹ y & z) id (f x) $ mapMaybe* xs
 
   mapMaybe* []     = []
   mapMaybe* (∹ xs) = mapMaybe+ xs
@@ -265,11 +266,13 @@ module _ (f : A → Maybe B → B) where
   foldrMaybe* []     = nothing
   foldrMaybe* (∹ xs) = just (foldrMaybe+ xs)
 
-  foldrMaybe+ xs = f (head xs) (foldrMaybe* (tail xs))
+  foldrMaybe+ (x & xs) = f x (foldrMaybe* xs)
 
 ------------------------------------------------------------------------
 -- Indexing
 
+infix 4 _[_]* _[_]+
+
 _[_]* : A * → ℕ → Maybe A
 _[_]+ : A + → ℕ → Maybe A
 
diff --git a/src/Data/List/Literals.agda b/src/Data/List/Literals.agda
index 6307fe4dc5..80d57901d1 100644
--- a/src/Data/List/Literals.agda
+++ b/src/Data/List/Literals.agda
@@ -8,10 +8,10 @@
 
 module Data.List.Literals where
 
-open import Agda.Builtin.FromString
-open import Data.Unit
-open import Agda.Builtin.Char
-open import Agda.Builtin.List
+open import Agda.Builtin.FromString using (IsString)
+open import Data.Unit.Base using (⊤)
+open import Agda.Builtin.Char using (Char)
+open import Agda.Builtin.List using (List)
 open import Data.String.Base using (toList)
 
 isString : IsString (List Char)
diff --git a/src/Data/List/Membership/DecPropositional.agda b/src/Data/List/Membership/DecPropositional.agda
index 4380ff8ca2..57bbb2cca0 100644
--- a/src/Data/List/Membership/DecPropositional.agda
+++ b/src/Data/List/Membership/DecPropositional.agda
@@ -6,11 +6,14 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Decidable)
-open import Relation.Binary.PropositionalEquality using (_≡_; decSetoid)
+open import Relation.Binary.Definitions using (DecidableEquality)
 
 module Data.List.Membership.DecPropositional
-  {a} {A : Set a} (_≟_ : Decidable (_≡_ {A = A})) where
+  {a} {A : Set a} (_≟_ : DecidableEquality A) where
+
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
+
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
 
 ------------------------------------------------------------------------
 -- Re-export contents of propositional membership
diff --git a/src/Data/List/Membership/DecSetoid.agda b/src/Data/List/Membership/DecSetoid.agda
index 3d798abc5b..29fe88adb6 100644
--- a/src/Data/List/Membership/DecSetoid.agda
+++ b/src/Data/List/Membership/DecSetoid.agda
@@ -6,12 +6,14 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Decidable; DecSetoid)
-open import Relation.Nullary.Decidable using (¬?)
+open import Relation.Binary.Bundles using (DecSetoid)
 
 module Data.List.Membership.DecSetoid {a ℓ} (DS : DecSetoid a ℓ) where
 
 open import Data.List.Relation.Unary.Any using (any?)
+open import Relation.Binary.Definitions using (Decidable)
+open import Relation.Nullary.Decidable using (¬?)
+
 open DecSetoid DS
 
 ------------------------------------------------------------------------
diff --git a/src/Data/List/Membership/Propositional.agda b/src/Data/List/Membership/Propositional.agda
index 84ce10c8ba..2f5edc2d7e 100644
--- a/src/Data/List/Membership/Propositional.agda
+++ b/src/Data/List/Membership/Propositional.agda
@@ -10,7 +10,8 @@
 module Data.List.Membership.Propositional {a} {A : Set a} where
 
 open import Data.List.Relation.Unary.Any using (Any)
-open import Relation.Binary.PropositionalEquality using (_≡_; _≢_; setoid; subst)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; _≢_; resp; subst)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 
 import Data.List.Membership.Setoid as SetoidMembership
 
@@ -22,6 +23,8 @@ open SetoidMembership (setoid A) public hiding (lose)
 ------------------------------------------------------------------------
 -- Different members
 
+infix 4 _≢∈_
+
 _≢∈_ : ∀ {x y : A} {xs} → x ∈ xs → y ∈ xs → Set _
 _≢∈_ x∈xs y∈xs = ∀ x≡y → subst (_∈ _) x≡y x∈xs ≢ y∈xs
 
@@ -29,4 +32,4 @@ _≢∈_ x∈xs y∈xs = ∀ x≡y → subst (_∈ _) x≡y x∈xs ≢ y∈xs
 -- Other operations
 
 lose : ∀ {p} {P : A → Set p} {x xs} → x ∈ xs → P x → Any P xs
-lose = SetoidMembership.lose (setoid A) (subst _)
+lose = SetoidMembership.lose (setoid A) (resp _)
diff --git a/src/Data/List/Membership/Propositional/Properties.agda b/src/Data/List/Membership/Propositional/Properties.agda
index 364c6d29b8..03e31d8aae 100644
--- a/src/Data/List/Membership/Propositional/Properties.agda
+++ b/src/Data/List/Membership/Propositional/Properties.agda
@@ -8,42 +8,46 @@
 
 module Data.List.Membership.Propositional.Properties where
 
-open import Algebra using (Op₂; Selective)
-open import Effect.Monad using (RawMonad)
-open import Data.Bool.Base using (Bool; false; true; T)
+open import Algebra.Core using (Op₂)
+open import Algebra.Definitions using (Selective)
 open import Data.Fin.Base using (Fin)
 open import Data.List.Base as List
-open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
-open import Data.List.Relation.Unary.Any.Properties
+open import Data.List.Effectful using (monad)
 open import Data.List.Membership.Propositional
-import Data.List.Membership.Setoid.Properties as Membershipₛ
+  using (_∈_; _∉_; mapWith∈; _≢∈_)
+import Data.List.Membership.Setoid.Properties as Membership
 open import Data.List.Relation.Binary.Equality.Propositional
   using (_≋_; ≡⇒≋; ≋⇒≡)
-open import Data.List.Effectful using (monad)
-open import Data.Nat.Base using (ℕ; zero; suc; pred; s≤s; _≤_; _<_; _≤ᵇ_)
+open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
+open import Data.List.Relation.Unary.Any.Properties
+  using (map↔; concat↔; >>=↔; ⊛↔; Any-cong; ⊗↔′; ¬Any[])
+open import Data.Nat.Base using (ℕ; suc; s≤s; _≤_; _<_; _≰_)
 open import Data.Nat.Properties
-open import Data.Product hiding (map)
+  using (suc-injective; m≤n⇒m≤1+n; _≤?_; <⇒≢; ≰⇒>)
+open import Data.Product.Base using (∃; ∃₂; _×_; _,_)
+open import Data.Product.Properties using (×-≡,≡↔≡)
 open import Data.Product.Function.NonDependent.Propositional using (_×-cong_)
 import Data.Product.Function.Dependent.Propositional as Σ
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
-open import Function.Base
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Equivalence using (module Equivalence)
-open import Function.Injection using (Injection; Injective; _↣_)
-open import Function.Inverse as Inv using (_↔_; module Inverse)
-import Function.Related as Related
-open import Function.Related.TypeIsomorphisms
+open import Effect.Monad using (RawMonad)
+open import Function.Base using (_∘_; _∘′_; _$_; id; flip; _⟨_⟩_)
+open import Function.Definitions using (Injective)
+import Function.Related.Propositional as Related
+open import Function.Bundles using (_↔_; _↣_; Injection)
+open import Function.Related.TypeIsomorphisms using (×-comm; ∃∃↔∃∃)
+open import Function.Construct.Identity using (↔-id)
 open import Level using (Level)
-open import Relation.Binary as B hiding (Decidable)
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; _≢_; refl; sym; trans; cong; subst; →-to-⟶; _≗_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions as Binary hiding (Decidable)
+open import Relation.Binary.PropositionalEquality.Core as ≡
+  using (_≡_; _≢_; refl; sym; trans; cong; cong₂; resp; _≗_)
+open import Relation.Binary.PropositionalEquality.Properties as ≡ using (setoid)
 import Relation.Binary.Properties.DecTotalOrder as DTOProperties
-open import Relation.Unary using (_⟨×⟩_; Decidable)
-import Relation.Nullary.Reflects as Reflects
+open import Relation.Nullary.Decidable.Core
+  using (Dec; yes; no; ¬¬-excluded-middle)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
 open import Relation.Nullary.Reflects using (invert)
-open import Relation.Nullary using (¬_; Dec; does; yes; no; _because_)
-open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Nullary.Decidable using (excluded-middle)
+open import Relation.Unary using (_⟨×⟩_; Decidable)
 
 private
   open module ListMonad {ℓ} = RawMonad (monad {ℓ = ℓ})
@@ -61,10 +65,10 @@ open import Data.List.Membership.Propositional.Properties.Core public
 -- Equality
 
 ∈-resp-≋ : ∀ {x : A} → (x ∈_) Respects _≋_
-∈-resp-≋ = Membershipₛ.∈-resp-≋ (P.setoid _)
+∈-resp-≋ = Membership.∈-resp-≋ (≡.setoid _)
 
 ∉-resp-≋ : ∀ {x : A} → (x ∉_) Respects _≋_
-∉-resp-≋ = Membershipₛ.∉-resp-≋ (P.setoid _)
+∉-resp-≋ = Membership.∉-resp-≋ (≡.setoid _)
 
 ------------------------------------------------------------------------
 -- mapWith∈
@@ -73,19 +77,19 @@ mapWith∈-cong : ∀ (xs : List A) → (f g : ∀ {x} → x ∈ xs → B) →
                 (∀ {x} → (x∈xs : x ∈ xs) → f x∈xs ≡ g x∈xs) →
                 mapWith∈ xs f ≡ mapWith∈ xs g
 mapWith∈-cong []       f g cong = refl
-mapWith∈-cong (x ∷ xs) f g cong = P.cong₂ _∷_ (cong (here refl))
+mapWith∈-cong (x ∷ xs) f g cong = cong₂ _∷_ (cong (here refl))
   (mapWith∈-cong xs (f ∘ there) (g ∘ there) (cong ∘ there))
 
 mapWith∈≗map : ∀ (f : A → B) xs → mapWith∈ xs (λ {x} _ → f x) ≡ map f xs
 mapWith∈≗map f xs =
-  ≋⇒≡ (Membershipₛ.mapWith∈≗map (P.setoid _) (P.setoid _) f xs)
+  ≋⇒≡ (Membership.mapWith∈≗map (≡.setoid _) (≡.setoid _) f xs)
 
 mapWith∈-id : (xs : List A) → mapWith∈ xs (λ {x} _ → x) ≡ xs
-mapWith∈-id = Membershipₛ.mapWith∈-id (P.setoid _)
+mapWith∈-id = Membership.mapWith∈-id (≡.setoid _)
 
 map-mapWith∈ : (xs : List A) (f : ∀ {x} → x ∈ xs → B) (g : B → C) →
                map g (mapWith∈ xs f) ≡ mapWith∈ xs (g ∘′ f)
-map-mapWith∈ = Membershipₛ.map-mapWith∈ (P.setoid _)
+map-mapWith∈ = Membership.map-mapWith∈ (≡.setoid _)
 
 ------------------------------------------------------------------------
 -- map
@@ -93,10 +97,10 @@ map-mapWith∈ = Membershipₛ.map-mapWith∈ (P.setoid _)
 module _ (f : A → B) where
 
   ∈-map⁺ : ∀ {x xs} → x ∈ xs → f x ∈ map f xs
-  ∈-map⁺ = Membershipₛ.∈-map⁺ (P.setoid A) (P.setoid B) (P.cong f)
+  ∈-map⁺ = Membership.∈-map⁺ (≡.setoid A) (≡.setoid B) (cong f)
 
   ∈-map⁻ : ∀ {y xs} → y ∈ map f xs → ∃ λ x → x ∈ xs × y ≡ f x
-  ∈-map⁻ = Membershipₛ.∈-map⁻ (P.setoid A) (P.setoid B)
+  ∈-map⁻ = Membership.∈-map⁻ (≡.setoid A) (≡.setoid B)
 
   map-∈↔ : ∀ {y xs} → (∃ λ x → x ∈ xs × y ≡ f x) ↔ y ∈ map f xs
   map-∈↔ {y} {xs} =
@@ -111,20 +115,21 @@ module _ (f : A → B) where
 module _ {v : A} where
 
   ∈-++⁺ˡ : ∀ {xs ys} → v ∈ xs → v ∈ xs ++ ys
-  ∈-++⁺ˡ = Membershipₛ.∈-++⁺ˡ (P.setoid A)
+  ∈-++⁺ˡ = Membership.∈-++⁺ˡ (≡.setoid A)
 
   ∈-++⁺ʳ : ∀ xs {ys} → v ∈ ys → v ∈ xs ++ ys
-  ∈-++⁺ʳ = Membershipₛ.∈-++⁺ʳ (P.setoid A)
+  ∈-++⁺ʳ = Membership.∈-++⁺ʳ (≡.setoid A)
 
   ∈-++⁻ : ∀ xs {ys} → v ∈ xs ++ ys → (v ∈ xs) ⊎ (v ∈ ys)
-  ∈-++⁻ = Membershipₛ.∈-++⁻ (P.setoid A)
+  ∈-++⁻ = Membership.∈-++⁻ (≡.setoid A)
 
   ∈-insert : ∀ xs {ys} → v ∈ xs ++ [ v ] ++ ys
-  ∈-insert xs = Membershipₛ.∈-insert (P.setoid A) xs refl
+  ∈-insert xs = Membership.∈-insert (≡.setoid A) xs refl
 
   ∈-∃++ : ∀ {xs} → v ∈ xs → ∃₂ λ ys zs → xs ≡ ys ++ [ v ] ++ zs
-  ∈-∃++ v∈xs with Membershipₛ.∈-∃++ (P.setoid A) v∈xs
-  ... | ys , zs , _ , refl , eq = ys , zs , ≋⇒≡ eq
+  ∈-∃++ v∈xs
+    with ys , zs , _ , refl , eq ← Membership.∈-∃++ (≡.setoid A) v∈xs
+    = ys , zs , ≋⇒≡ eq
 
 ------------------------------------------------------------------------
 -- concat
@@ -132,23 +137,24 @@ module _ {v : A} where
 module _ {v : A} where
 
   ∈-concat⁺ : ∀ {xss} → Any (v ∈_) xss → v ∈ concat xss
-  ∈-concat⁺ = Membershipₛ.∈-concat⁺ (P.setoid A)
+  ∈-concat⁺ = Membership.∈-concat⁺ (≡.setoid A)
 
   ∈-concat⁻ : ∀ xss → v ∈ concat xss → Any (v ∈_) xss
-  ∈-concat⁻ = Membershipₛ.∈-concat⁻ (P.setoid A)
+  ∈-concat⁻ = Membership.∈-concat⁻ (≡.setoid A)
 
   ∈-concat⁺′ : ∀ {vs xss} → v ∈ vs → vs ∈ xss → v ∈ concat xss
   ∈-concat⁺′ v∈vs vs∈xss =
-    Membershipₛ.∈-concat⁺′ (P.setoid A) v∈vs (Any.map ≡⇒≋ vs∈xss)
+    Membership.∈-concat⁺′ (≡.setoid A) v∈vs (Any.map ≡⇒≋ vs∈xss)
 
   ∈-concat⁻′ : ∀ xss → v ∈ concat xss → ∃ λ xs → v ∈ xs × xs ∈ xss
-  ∈-concat⁻′ xss v∈c with Membershipₛ.∈-concat⁻′ (P.setoid A) xss v∈c
-  ... | xs , v∈xs , xs∈xss = xs , v∈xs , Any.map ≋⇒≡ xs∈xss
+  ∈-concat⁻′ xss v∈c =
+    let xs , v∈xs , xs∈xss = Membership.∈-concat⁻′ (≡.setoid A) xss v∈c
+    in xs , v∈xs , Any.map ≋⇒≡ xs∈xss
 
   concat-∈↔ : ∀ {xss : List (List A)} →
               (∃ λ xs → v ∈ xs × xs ∈ xss) ↔ v ∈ concat xss
   concat-∈↔ {xss} =
-    (∃ λ xs → v ∈ xs × xs ∈ xss)  ↔⟨ Σ.cong Inv.id $ ×-comm _ _ ⟩
+    (∃ λ xs → v ∈ xs × xs ∈ xss)  ↔⟨ Σ.cong (↔-id _) $ ×-comm _ _ ⟩
     (∃ λ xs → xs ∈ xss × v ∈ xs)  ↔⟨ Any↔ ⟩
     Any (Any (v ≡_)) xss          ↔⟨ concat↔ ⟩
     v ∈ concat xss                ∎
@@ -161,13 +167,13 @@ module _ (f : A → B → C) where
 
   ∈-cartesianProductWith⁺ : ∀ {xs ys a b} → a ∈ xs → b ∈ ys →
                             f a b ∈ cartesianProductWith f xs ys
-  ∈-cartesianProductWith⁺ = Membershipₛ.∈-cartesianProductWith⁺
-    (P.setoid A) (P.setoid B) (P.setoid C) (P.cong₂ f)
+  ∈-cartesianProductWith⁺ = Membership.∈-cartesianProductWith⁺
+    (≡.setoid A) (≡.setoid B) (≡.setoid C) (cong₂ f)
 
   ∈-cartesianProductWith⁻ : ∀ xs ys {v} → v ∈ cartesianProductWith f xs ys →
                             ∃₂ λ a b → a ∈ xs × b ∈ ys × v ≡ f a b
-  ∈-cartesianProductWith⁻ = Membershipₛ.∈-cartesianProductWith⁻
-    (P.setoid A) (P.setoid B) (P.setoid C) f
+  ∈-cartesianProductWith⁻ = Membership.∈-cartesianProductWith⁻
+    (≡.setoid A) (≡.setoid B) (≡.setoid C) f
 
 ------------------------------------------------------------------------
 -- cartesianProduct
@@ -178,8 +184,9 @@ module _ (f : A → B → C) where
 
 ∈-cartesianProduct⁻ : ∀ xs ys {xy@(x , y) : A × B} →
                       xy ∈ cartesianProduct xs ys → x ∈ xs × y ∈ ys
-∈-cartesianProduct⁻ xs ys xy∈p[xs,ys] with ∈-cartesianProductWith⁻ _,_ xs ys xy∈p[xs,ys]
-... | (x , y , x∈xs , y∈ys , refl) = x∈xs , y∈ys
+∈-cartesianProduct⁻ xs ys xy∈p[xs,ys]
+  with _ , _ , x∈xs , y∈ys , refl ← ∈-cartesianProductWith⁻ _,_ xs ys xy∈p[xs,ys]
+  = x∈xs , y∈ys
 
 ------------------------------------------------------------------------
 -- applyUpTo
@@ -187,11 +194,11 @@ module _ (f : A → B → C) where
 module _ (f : ℕ → A) where
 
   ∈-applyUpTo⁺ : ∀ {i n} → i < n → f i ∈ applyUpTo f n
-  ∈-applyUpTo⁺ = Membershipₛ.∈-applyUpTo⁺ (P.setoid _) f
+  ∈-applyUpTo⁺ = Membership.∈-applyUpTo⁺ (≡.setoid _) f
 
   ∈-applyUpTo⁻ : ∀ {v n} → v ∈ applyUpTo f n →
                  ∃ λ i → i < n × v ≡ f i
-  ∈-applyUpTo⁻ = Membershipₛ.∈-applyUpTo⁻ (P.setoid _) f
+  ∈-applyUpTo⁻ = Membership.∈-applyUpTo⁻ (≡.setoid _) f
 
 ------------------------------------------------------------------------
 -- upTo
@@ -200,8 +207,7 @@ module _ (f : ℕ → A) where
 ∈-upTo⁺ = ∈-applyUpTo⁺ id
 
 ∈-upTo⁻ : ∀ {n i} → i ∈ upTo n → i < n
-∈-upTo⁻ p with ∈-applyUpTo⁻ id p
-... | _ , i<n , refl = i<n
+∈-upTo⁻ p with _ , i<n , refl ← ∈-applyUpTo⁻ id p = i<n
 
 ------------------------------------------------------------------------
 -- applyDownFrom
@@ -209,11 +215,11 @@ module _ (f : ℕ → A) where
 module _ (f : ℕ → A) where
 
   ∈-applyDownFrom⁺ : ∀ {i n} → i < n → f i ∈ applyDownFrom f n
-  ∈-applyDownFrom⁺ = Membershipₛ.∈-applyDownFrom⁺ (P.setoid _) f
+  ∈-applyDownFrom⁺ = Membership.∈-applyDownFrom⁺ (≡.setoid _) f
 
   ∈-applyDownFrom⁻ : ∀ {v n} → v ∈ applyDownFrom f n →
                      ∃ λ i → i < n × v ≡ f i
-  ∈-applyDownFrom⁻ = Membershipₛ.∈-applyDownFrom⁻ (P.setoid _) f
+  ∈-applyDownFrom⁻ = Membership.∈-applyDownFrom⁻ (≡.setoid _) f
 
 ------------------------------------------------------------------------
 -- downFrom
@@ -222,8 +228,7 @@ module _ (f : ℕ → A) where
 ∈-downFrom⁺ i<n = ∈-applyDownFrom⁺ id i<n
 
 ∈-downFrom⁻ : ∀ {n i} → i ∈ downFrom n → i < n
-∈-downFrom⁻ p with ∈-applyDownFrom⁻ id p
-... | _ , i<n , refl = i<n
+∈-downFrom⁻ p with _ , i<n , refl ← ∈-applyDownFrom⁻ id p = i<n
 
 ------------------------------------------------------------------------
 -- tabulate
@@ -231,10 +236,10 @@ module _ (f : ℕ → A) where
 module _ {n} {f : Fin n → A} where
 
   ∈-tabulate⁺ : ∀ i → f i ∈ tabulate f
-  ∈-tabulate⁺ = Membershipₛ.∈-tabulate⁺ (P.setoid _)
+  ∈-tabulate⁺ = Membership.∈-tabulate⁺ (≡.setoid _)
 
   ∈-tabulate⁻ : ∀ {v} → v ∈ tabulate f → ∃ λ i → v ≡ f i
-  ∈-tabulate⁻ = Membershipₛ.∈-tabulate⁻ (P.setoid _)
+  ∈-tabulate⁻ = Membership.∈-tabulate⁻ (≡.setoid _)
 
 ------------------------------------------------------------------------
 -- filter
@@ -242,29 +247,29 @@ module _ {n} {f : Fin n → A} where
 module _ {p} {P : A → Set p} (P? : Decidable P) where
 
   ∈-filter⁺ : ∀ {x xs} → x ∈ xs → P x → x ∈ filter P? xs
-  ∈-filter⁺ = Membershipₛ.∈-filter⁺ (P.setoid A) P? (P.subst P)
+  ∈-filter⁺ = Membership.∈-filter⁺ (≡.setoid A) P? (≡.resp P)
 
   ∈-filter⁻ : ∀ {v xs} → v ∈ filter P? xs → v ∈ xs × P v
-  ∈-filter⁻ = Membershipₛ.∈-filter⁻ (P.setoid A) P? (P.subst P)
+  ∈-filter⁻ = Membership.∈-filter⁻ (≡.setoid A) P? (≡.resp P)
 
 ------------------------------------------------------------------------
 -- derun and deduplicate
 
-module _ {r} {R : Rel A r} (R? : B.Decidable R) where
+module _ {r} {R : Rel A r} (R? : Binary.Decidable R) where
 
   ∈-derun⁻ : ∀ xs {z} → z ∈ derun R? xs → z ∈ xs
-  ∈-derun⁻ xs z∈derun[R,xs] = Membershipₛ.∈-derun⁻ (P.setoid A) R? xs z∈derun[R,xs]
+  ∈-derun⁻ xs z∈derun[R,xs] = Membership.∈-derun⁻ (≡.setoid A) R? xs z∈derun[R,xs]
 
   ∈-deduplicate⁻ : ∀ xs {z} → z ∈ deduplicate R? xs → z ∈ xs
-  ∈-deduplicate⁻ xs z∈dedup[R,xs] = Membershipₛ.∈-deduplicate⁻ (P.setoid A) R? xs z∈dedup[R,xs]
+  ∈-deduplicate⁻ xs z∈dedup[R,xs] = Membership.∈-deduplicate⁻ (≡.setoid A) R? xs z∈dedup[R,xs]
 
-module _ (_≈?_ : B.Decidable {A = A} _≡_) where
+module _ (_≈?_ : DecidableEquality A) where
 
   ∈-derun⁺ : ∀ {xs z} → z ∈ xs → z ∈ derun _≈?_ xs
-  ∈-derun⁺ z∈xs = Membershipₛ.∈-derun⁺ (P.setoid A) _≈?_ (flip trans) z∈xs
+  ∈-derun⁺ z∈xs = Membership.∈-derun⁺ (≡.setoid A) _≈?_ (flip trans) z∈xs
 
   ∈-deduplicate⁺ : ∀ {xs z} → z ∈ xs → z ∈ deduplicate _≈?_ xs
-  ∈-deduplicate⁺ z∈xs = Membershipₛ.∈-deduplicate⁺ (P.setoid A) _≈?_ (λ c≡b a≡b → trans a≡b (sym c≡b)) z∈xs
+  ∈-deduplicate⁺ z∈xs = Membership.∈-deduplicate⁺ (≡.setoid A) _≈?_ (λ c≡b a≡b → trans a≡b (sym c≡b)) z∈xs
 
 ------------------------------------------------------------------------
 -- _>>=_
@@ -283,8 +288,8 @@ module _ (_≈?_ : B.Decidable {A = A} _≡_) where
 ⊛-∈↔ : ∀ (fs : List (A → B)) {xs y} →
        (∃₂ λ f x → f ∈ fs × x ∈ xs × y ≡ f x) ↔ y ∈ (fs ⊛ xs)
 ⊛-∈↔ fs {xs} {y} =
-  (∃₂ λ f x → f ∈ fs × x ∈ xs × y ≡ f x)       ↔⟨ Σ.cong Inv.id (∃∃↔∃∃ _) ⟩
-  (∃ λ f → f ∈ fs × ∃ λ x → x ∈ xs × y ≡ f x)  ↔⟨ Σ.cong Inv.id ((_ ∎) ⟨ _×-cong_ ⟩ Any↔) ⟩
+  (∃₂ λ f x → f ∈ fs × x ∈ xs × y ≡ f x)       ↔⟨ Σ.cong (↔-id _) (∃∃↔∃∃ _) ⟩
+  (∃ λ f → f ∈ fs × ∃ λ x → x ∈ xs × y ≡ f x)  ↔⟨ Σ.cong (↔-id _) (↔-id _ ⟨ _×-cong_ ⟩ Any↔) ⟩
   (∃ λ f → f ∈ fs × Any (_≡_ y ∘ f) xs)        ↔⟨ Any↔ ⟩
   Any (λ f → Any (_≡_ y ∘ f) xs) fs            ↔⟨ ⊛↔ ⟩
   y ∈ (fs ⊛ xs)                                ∎
@@ -297,7 +302,7 @@ module _ (_≈?_ : B.Decidable {A = A} _≡_) where
        (x ∈ xs × y ∈ ys) ↔ (x , y) ∈ (xs ⊗ ys)
 ⊗-∈↔ {xs = xs} {ys} {x} {y} =
   (x ∈ xs × y ∈ ys)             ↔⟨ ⊗↔′ ⟩
-  Any (x ≡_ ⟨×⟩ y ≡_) (xs ⊗ ys) ↔⟨ Any-cong ×-≡×≡↔≡,≡ (_ ∎) ⟩
+  Any (x ≡_ ⟨×⟩ y ≡_) (xs ⊗ ys) ↔⟨ Any-cong (λ _ → ×-≡,≡↔≡) (↔-id _) ⟩
   (x , y) ∈ (xs ⊗ ys)           ∎
   where
   open Related.EquationalReasoning
@@ -305,14 +310,14 @@ module _ (_≈?_ : B.Decidable {A = A} _≡_) where
 ------------------------------------------------------------------------
 -- length
 
-∈-length : ∀ {x : A} {xs} → x ∈ xs → 1 ≤ length xs
-∈-length = Membershipₛ.∈-length (P.setoid _)
+∈-length : ∀ {x : A} {xs} → x ∈ xs → 0 < length xs
+∈-length = Membership.∈-length (≡.setoid _)
 
 ------------------------------------------------------------------------
 -- lookup
 
 ∈-lookup : ∀ {xs : List A} i → lookup xs i ∈ xs
-∈-lookup {xs = xs} i = Membershipₛ.∈-lookup (P.setoid _) xs i
+∈-lookup {xs = xs} i = Membership.∈-lookup (≡.setoid _) xs i
 
 ------------------------------------------------------------------------
 -- foldr
@@ -321,7 +326,7 @@ module _ {_•_ : Op₂ A} where
 
   foldr-selective : Selective _≡_ _•_ → ∀ e xs →
                     (foldr _•_ e xs ≡ e) ⊎ (foldr _•_ e xs ∈ xs)
-  foldr-selective = Membershipₛ.foldr-selective (P.setoid A)
+  foldr-selective = Membership.foldr-selective (≡.setoid A)
 
 ------------------------------------------------------------------------
 -- allFin
@@ -333,8 +338,7 @@ module _ {_•_ : Op₂ A} where
 -- inits
 
 []∈inits : ∀ {a} {A : Set a} (as : List A) → [] ∈ inits as
-[]∈inits []       = here refl
-[]∈inits (a ∷ as) = here refl
+[]∈inits _ = here refl
 
 ------------------------------------------------------------------------
 -- Other properties
@@ -342,14 +346,14 @@ module _ {_•_ : Op₂ A} where
 -- Only a finite number of distinct elements can be members of a
 -- given list.
 
-finite : (f : ℕ ↣ A) → ∀ xs → ¬ (∀ i → Injection.to f ⟨$⟩ i ∈ xs)
+finite : (inj : ℕ ↣ A) → ∀ xs → ¬ (∀ i → Injection.to inj i ∈ xs)
 finite inj []       fᵢ∈[]   = ¬Any[] (fᵢ∈[] 0)
-finite inj (x ∷ xs) fᵢ∈x∷xs = excluded-middle helper
+finite inj (x ∷ xs) fᵢ∈x∷xs = ¬¬-excluded-middle helper
   where
   open Injection inj renaming (injective to f-inj)
 
   f : ℕ → _
-  f = to ⟨$⟩_
+  f = to
 
   not-x : ∀ {i} → f i ≢ x → f i ∈ xs
   not-x {i} fᵢ≢x with fᵢ∈x∷xs i
@@ -361,31 +365,32 @@ finite inj (x ∷ xs) fᵢ∈x∷xs = excluded-middle helper
   helper (yes (i , fᵢ≡x)) = finite f′-inj xs f′ⱼ∈xs
     where
     f′ : ℕ → _
-    f′ j with does (i ≤? j)
-    ... | true  = f (suc j)
-    ... | false = f j
+    f′ j with i ≤? j
+    ... | yes _ = f (suc j)
+    ... | no  _ = f j
 
     ∈-if-not-i : ∀ {j} → i ≢ j → f j ∈ xs
     ∈-if-not-i i≢j = not-x (i≢j ∘ f-inj ∘ trans fᵢ≡x ∘ sym)
 
-    lemma : ∀ {k j} → i ≤ j → ¬ (i ≤ k) → suc j ≢ k
+    lemma : ∀ {k j} → i ≤ j → i ≰ k → suc j ≢ k
     lemma i≤j i≰1+j refl = i≰1+j (m≤n⇒m≤1+n i≤j)
 
     f′ⱼ∈xs : ∀ j → f′ j ∈ xs
-    f′ⱼ∈xs j with i ≤ᵇ j | Reflects.invert (≤ᵇ-reflects-≤ i j)
-    ... | true  | p = ∈-if-not-i (<⇒≢ (s≤s p))
-    ... | false | p = ∈-if-not-i (<⇒≢ (≰⇒> p) ∘ sym)
-
-    f′-injective′ : Injective {B = P.setoid _} (→-to-⟶ f′)
-    f′-injective′ {j} {k} eq with i ≤ᵇ j | Reflects.invert (≤ᵇ-reflects-≤ i j)
-                                | i ≤ᵇ k | Reflects.invert (≤ᵇ-reflects-≤ i k)
-    ... | true  | p | true  | q = P.cong pred (f-inj eq)
-    ... | true  | p | false | q = contradiction (f-inj eq) (lemma p q)
-    ... | false | p | true  | q = contradiction (f-inj eq) (lemma q p ∘ sym)
-    ... | false | p | false | q = f-inj eq
-
+    f′ⱼ∈xs j with i ≤? j
+    ... | yes i≤j = ∈-if-not-i (<⇒≢ (s≤s i≤j))
+    ... | no  i≰j = ∈-if-not-i (<⇒≢ (≰⇒> i≰j) ∘ sym)
+
+    f′-injective′ : Injective _≡_ _≡_ f′
+    f′-injective′ {j} {k} eq with i ≤? j | i ≤? k
+    ... | yes i≤j | yes i≤k = suc-injective (f-inj eq)
+    ... | yes i≤j | no  i≰k = contradiction (f-inj eq) (lemma i≤j i≰k)
+    ... | no  i≰j | yes i≤k = contradiction (f-inj eq) (lemma i≤k i≰j ∘ sym)
+    ... | no  i≰j | no  i≰k = f-inj eq
+
+    f′-inj : ℕ ↣ _
     f′-inj = record
-      { to        = →-to-⟶ f′
+      { to        = f′
+      ; cong      = ≡.cong f′
       ; injective = f′-injective′
       }
 
@@ -395,4 +400,4 @@ finite inj (x ∷ xs) fᵢ∈x∷xs = excluded-middle helper
 there-injective-≢∈ : ∀ {xs} {x y z : A} {x∈xs : x ∈ xs} {y∈xs : y ∈ xs} →
                      there {x = z} x∈xs ≢∈ there y∈xs →
                      x∈xs ≢∈ y∈xs
-there-injective-≢∈ neq refl eq = neq refl (P.cong there eq)
+there-injective-≢∈ neq refl eq = neq refl (≡.cong there eq)
diff --git a/src/Data/List/Membership/Propositional/Properties/Core.agda b/src/Data/List/Membership/Propositional/Properties/Core.agda
index 55a03f454c..5c77e40b96 100644
--- a/src/Data/List/Membership/Propositional/Properties/Core.agda
+++ b/src/Data/List/Membership/Propositional/Properties/Core.agda
@@ -5,82 +5,81 @@
 ------------------------------------------------------------------------
 
 -- This file is needed to break the cyclic dependency with the proof
--- `Any-cong` in `Data.Any.Properties` which relies on `Any↔` in this
--- file.
+-- `Any-cong` in `Data.List.Relation.Unary.Any.Properties` which relies
+-- on `Any↔` defined in this file.
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Data.List.Membership.Propositional.Properties.Core where
 
-open import Function.Base using (flip; id; _∘_)
-open import Function.Inverse using (_↔_; inverse)
 open import Data.List.Base using (List)
-open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
 open import Data.List.Membership.Propositional
-open import Data.Product as Prod
-  using (_,_; proj₁; proj₂; uncurry′; ∃; _×_)
+open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
+open import Data.Product.Base as Product using (_,_; ∃; _×_)
+open import Function.Base using (flip; id; _∘_)
+open import Function.Bundles using (_↔_; mk↔ₛ′)
 open import Level using (Level)
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; resp)
 open import Relation.Unary using (Pred; _⊆_)
 
 private
   variable
     a p q : Level
     A : Set a
-
-------------------------------------------------------------------------
--- Lemmas relating map and find.
-
-map∘find : ∀ {P : Pred A p} {xs}
-           (p : Any P xs) → let p′ = find p in
-           {f : _≡_ (proj₁ p′) ⊆ P} →
-           f refl ≡ proj₂ (proj₂ p′) →
-           Any.map f (proj₁ (proj₂ p′)) ≡ p
-map∘find (here  p) hyp = P.cong here  hyp
-map∘find (there p) hyp = P.cong there (map∘find p hyp)
-
-find∘map : ∀ {P : Pred A p} {Q : Pred A q}
-           {xs : List A} (p : Any P xs) (f : P ⊆ Q) →
-           find (Any.map f p) ≡ Prod.map id (Prod.map id f) (find p)
-find∘map (here  p) f = refl
-find∘map (there p) f rewrite find∘map p f = refl
+    x : A
+    xs : List A
 
 ------------------------------------------------------------------------
 -- find satisfies a simple equality when the predicate is a
 -- propositional equality.
 
-find-∈ : ∀ {x : A} {xs : List A} (x∈xs : x ∈ xs) →
-         find x∈xs ≡ (x , x∈xs , refl)
+find-∈ : (x∈xs : x ∈ xs) → find x∈xs ≡ (x , x∈xs , refl)
 find-∈ (here refl)  = refl
 find-∈ (there x∈xs) rewrite find-∈ x∈xs = refl
 
 ------------------------------------------------------------------------
--- find and lose are inverses (more or less).
+-- Lemmas relating map and find.
 
-lose∘find : ∀ {P : Pred A p} {xs : List A}
-            (p : Any P xs) →
-            uncurry′ lose (proj₂ (find p)) ≡ p
-lose∘find p = map∘find p P.refl
+module _ {P : Pred A p} where
 
-find∘lose : ∀ (P : Pred A p) {x xs}
-            (x∈xs : x ∈ xs) (pp : P x) →
-            find {P = P} (lose x∈xs pp) ≡ (x , x∈xs , pp)
-find∘lose P x∈xs p
-  rewrite find∘map x∈xs (flip (P.subst P) p)
-        | find-∈ x∈xs
-        = refl
+  map∘find : (p : Any P xs) → let x , x∈xs , px = find p in
+             {f : (x ≡_) ⊆ P} → f refl ≡ px →
+             Any.map f x∈xs ≡ p
+  map∘find (here  p) hyp = cong here  hyp
+  map∘find (there p) hyp = cong there (map∘find p hyp)
+
+  find∘map : ∀ {Q : Pred A q} {xs} (p : Any P xs) (f : P ⊆ Q) →
+             let x , x∈xs , px = find p in
+             find (Any.map f p) ≡ (x , x∈xs , f px)
+  find∘map (here  p) f = refl
+  find∘map (there p) f rewrite find∘map p f = refl
 
 ------------------------------------------------------------------------
 -- Any can be expressed using _∈_
 
 module _ {P : Pred A p} where
 
-  ∃∈-Any : ∀  {xs} → (∃ λ x → x ∈ xs × P x) → Any P xs
-  ∃∈-Any = uncurry′ lose ∘ proj₂
+  ∃∈-Any : (∃ λ x → x ∈ xs × P x) → Any P xs
+  ∃∈-Any (x , x∈xs , px) = lose {P = P} x∈xs px
+
+  ∃∈-Any∘find : (p : Any P xs) → ∃∈-Any (find p) ≡ p
+  ∃∈-Any∘find p = map∘find p refl
+
+  find∘∃∈-Any : (p : ∃ λ x → x ∈ xs × P x) → find (∃∈-Any p) ≡ p
+  find∘∃∈-Any p@(x , x∈xs , px)
+    rewrite find∘map x∈xs (flip (resp P) px) | find-∈ x∈xs = refl
 
-  Any↔ : ∀ {xs} → (∃ λ x → x ∈ xs × P x) ↔ Any P xs
-  Any↔ = inverse ∃∈-Any find from∘to lose∘find
-    where
-    from∘to : ∀ v → find (∃∈-Any v) ≡ v
-    from∘to p = find∘lose _ (proj₁ (proj₂ p)) (proj₂ (proj₂ p))
+  Any↔ : (∃ λ x → x ∈ xs × P x) ↔ Any P xs
+  Any↔ = mk↔ₛ′ ∃∈-Any find ∃∈-Any∘find find∘∃∈-Any
+
+------------------------------------------------------------------------
+-- Hence, find and lose are inverses (more or less).
+
+lose∘find : ∀ {P : Pred A p} {xs} (p : Any P xs) → ∃∈-Any (find p) ≡ p
+lose∘find = ∃∈-Any∘find
+
+find∘lose : ∀ (P : Pred A p) {x xs}
+            (x∈xs : x ∈ xs) (px : P x) →
+            find (lose {P = P} x∈xs px) ≡ (x , x∈xs , px)
+find∘lose P {x} x∈xs px = find∘∃∈-Any (x , x∈xs , px)
diff --git a/src/Data/List/Membership/Propositional/Properties/WithK.agda b/src/Data/List/Membership/Propositional/Properties/WithK.agda
index 5909ec3e72..a86f23a8ea 100644
--- a/src/Data/List/Membership/Propositional/Properties/WithK.agda
+++ b/src/Data/List/Membership/Propositional/Properties/WithK.agda
@@ -12,9 +12,9 @@ module Data.List.Membership.Propositional.Properties.WithK where
 open import Data.List.Base
 open import Data.List.Relation.Unary.Unique.Propositional
 open import Data.List.Membership.Propositional
-import Data.List.Membership.Setoid.Properties as Membershipₛ
+import Data.List.Membership.Setoid.Properties as Membership
 open import Relation.Unary using (Irrelevant)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Properties as ≡
 open import Relation.Binary.PropositionalEquality.WithK
 
 ------------------------------------------------------------------------
@@ -22,4 +22,4 @@ open import Relation.Binary.PropositionalEquality.WithK
 
 unique⇒irrelevant : ∀ {a} {A : Set a} {xs : List A} →
                     Unique xs → Irrelevant (_∈ xs)
-unique⇒irrelevant = Membershipₛ.unique⇒irrelevant (P.setoid _) ≡-irrelevant
+unique⇒irrelevant = Membership.unique⇒irrelevant (≡.setoid _) ≡-irrelevant
diff --git a/src/Data/List/Membership/Setoid.agda b/src/Data/List/Membership/Setoid.agda
index ca48b933d1..b1ff4f2773 100644
--- a/src/Data/List/Membership/Setoid.agda
+++ b/src/Data/List/Membership/Setoid.agda
@@ -6,17 +6,18 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Membership.Setoid {c ℓ} (S : Setoid c ℓ) where
 
-open import Function.Base using (_∘_; id; flip)
-open import Data.List.Base as List using (List; []; _∷_; length; lookup)
-open import Data.List.Relation.Unary.Any
-  using (Any; index; map; here; there)
-open import Data.Product as Prod using (∃; _×_; _,_)
-open import Relation.Unary using (Pred)
+open import Data.List.Base using (List; []; _∷_)
+open import Data.List.Relation.Unary.Any as Any
+  using (Any; map; here; there)
+open import Data.Product.Base as Product using (∃; _×_; _,_)
+open import Function.Base using (_∘_; flip; const)
+open import Relation.Binary.Definitions using (_Respects_)
 open import Relation.Nullary.Negation using (¬_)
+open import Relation.Unary using (Pred)
 
 open Setoid S renaming (Carrier to A)
 
@@ -34,7 +35,8 @@ x ∉ xs = ¬ x ∈ xs
 ------------------------------------------------------------------------
 -- Operations
 
-open Data.List.Relation.Unary.Any using (_∷=_; _─_) public
+_∷=_ = Any._∷=_ {A = A}
+_─_ = Any._─_ {A = A}
 
 mapWith∈ : ∀ {b} {B : Set b}
            (xs : List A) → (∀ {x} → x ∈ xs → B) → List B
@@ -47,8 +49,8 @@ mapWith∈ (x ∷ xs) f = f (here refl) ∷ mapWith∈ xs (f ∘ there)
 module _ {p} {P : Pred A p} where
 
   find : ∀ {xs} → Any P xs → ∃ λ x → x ∈ xs × P x
-  find (here px)   = (_ , here refl , px)
-  find (there pxs) = Prod.map id (Prod.map there id) (find pxs)
+  find (here px)   = _ , here refl , px
+  find (there pxs) = let x , x∈xs , px = find pxs in x , there x∈xs , px
 
   lose : P Respects _≈_ →  ∀ {x xs} → x ∈ xs → P x → Any P xs
   lose resp x∈xs px = map (flip resp px) x∈xs
diff --git a/src/Data/List/Membership/Setoid/Properties.agda b/src/Data/List/Membership/Setoid/Properties.agda
index 919bf19ba6..48303dec37 100644
--- a/src/Data/List/Membership/Setoid/Properties.agda
+++ b/src/Data/List/Membership/Setoid/Properties.agda
@@ -11,28 +11,30 @@ module Data.List.Membership.Setoid.Properties where
 open import Algebra using (Op₂; Selective)
 open import Data.Bool.Base using (true; false)
 open import Data.Fin.Base using (Fin; zero; suc)
-open import Data.List.Base
-open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
-open import Data.List.Relation.Unary.All as All using (All)
-import Data.List.Relation.Unary.Any.Properties as Any
+open import Data.Fin.Properties using (suc-injective)
+open import Data.List.Base hiding (find)
 import Data.List.Membership.Setoid as Membership
 import Data.List.Relation.Binary.Equality.Setoid as Equality
+open import Data.List.Relation.Unary.All as All using (All)
+open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
+import Data.List.Relation.Unary.Any.Properties as Any
 import Data.List.Relation.Unary.Unique.Setoid as Unique
-open import Data.Nat.Base using (suc; z≤n; s≤s; _≤_; _<_)
-open import Data.Nat.Properties using (≤-trans; n≤1+n)
-open import Data.Product as Prod using (∃; _×_; _,_ ; ∃₂; proj₁; proj₂)
+open import Data.Nat.Base using (suc; z<s; _<_)
+open import Data.Product.Base as Product using (∃; _×_; _,_ ; ∃₂)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent using (_×ₛ_)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_]′)
 open import Function.Base using (_$_; flip; _∘_; _∘′_; id)
-open import Function.Inverse using (_↔_)
+open import Function.Bundles using (_↔_)
 open import Level using (Level)
-open import Relation.Binary as B hiding (Decidable)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
-open import Relation.Unary as U using (Decidable; Pred)
-open import Relation.Nullary using (¬_; does; _because_; yes; no)
+open import Relation.Binary.Core using (Rel; _Preserves₂_⟶_⟶_; _Preserves_⟶_)
+open import Relation.Binary.Definitions as Binary hiding (Decidable)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Nullary.Decidable using (does; _because_; yes; no)
+open import Relation.Nullary.Negation using (¬_; contradiction)
 open import Relation.Nullary.Reflects using (invert)
-open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Nullary.Decidable using (¬?)
+open import Relation.Unary as Unary using (Decidable; Pred)
+
 open Setoid using (Carrier)
 
 private
@@ -62,6 +64,13 @@ module _ (S : Setoid c ℓ) where
   ∉-resp-≋ : ∀ {x} → (x ∉_) Respects _≋_
   ∉-resp-≋ xs≋ys v∉xs v∈ys = v∉xs (∈-resp-≋ (≋-sym xs≋ys) v∈ys)
 
+  -- index is injective in its first argument.
+
+  index-injective : ∀ {x₁ x₂ xs} (x₁∈xs : x₁ ∈ xs) (x₂∈xs : x₂ ∈ xs) →
+                    Any.index x₁∈xs ≡ Any.index x₂∈xs → x₁ ≈ x₂
+  index-injective (here x₁≈x)   (here x₂≈x)   _  = trans x₁≈x (sym x₂≈x)
+  index-injective (there x₁∈xs) (there x₂∈xs) eq = index-injective x₁∈xs x₂∈xs (suc-injective eq)
+
 ------------------------------------------------------------------------
 -- Irrelevance
 
@@ -75,11 +84,11 @@ module _ (S : Setoid c ℓ) where
     ∉×∈⇒≉ : ∀ {x y xs} → All (y ≉_) xs → x ∈ xs → x ≉ y
     ∉×∈⇒≉ = All.lookupWith λ y≉z x≈z x≈y → y≉z (trans (sym x≈y) x≈z)
 
-  unique⇒irrelevant : B.Irrelevant _≈_ → ∀ {xs} → Unique xs → U.Irrelevant (_∈ xs)
+  unique⇒irrelevant : Binary.Irrelevant _≈_ → ∀ {xs} → Unique xs → Unary.Irrelevant (_∈ xs)
   unique⇒irrelevant ≈-irr _        (here p)  (here q)  =
-    P.cong here (≈-irr p q)
+    ≡.cong here (≈-irr p q)
   unique⇒irrelevant ≈-irr (_  ∷ u) (there p) (there q) =
-    P.cong there (unique⇒irrelevant ≈-irr u p q)
+    ≡.cong there (unique⇒irrelevant ≈-irr u p q)
   unique⇒irrelevant ≈-irr (≉s ∷ _) (here p)  (there q) =
     contradiction p (∉×∈⇒≉ ≉s q)
   unique⇒irrelevant ≈-irr (≉s ∷ _) (there p) (here q)  =
@@ -120,42 +129,42 @@ module _ (S : Setoid c ℓ) where
 
   length-mapWith∈ : ∀ {a} {A : Set a} xs {f : ∀ {x} → x ∈ xs → A} →
                     length (mapWith∈ xs f) ≡ length xs
-  length-mapWith∈ []       = P.refl
-  length-mapWith∈ (x ∷ xs) = P.cong suc (length-mapWith∈ xs)
+  length-mapWith∈ []       = ≡.refl
+  length-mapWith∈ (x ∷ xs) = ≡.cong suc (length-mapWith∈ xs)
 
   mapWith∈-id : ∀ xs → mapWith∈ xs (λ {x} _ → x) ≡ xs
-  mapWith∈-id []       = P.refl
-  mapWith∈-id (x ∷ xs) = P.cong (x ∷_) (mapWith∈-id xs)
+  mapWith∈-id []       = ≡.refl
+  mapWith∈-id (x ∷ xs) = ≡.cong (x ∷_) (mapWith∈-id xs)
 
   map-mapWith∈ : ∀ {a b} {A : Set a} {B : Set b} →
                  ∀ xs (f : ∀ {x} → x ∈ xs → A) (g : A → B) →
                  map g (mapWith∈ xs f) ≡ mapWith∈ xs (g ∘′ f)
-  map-mapWith∈ []       f g = P.refl
-  map-mapWith∈ (x ∷ xs) f g = P.cong (_ ∷_) (map-mapWith∈ xs (f ∘ there) g)
+  map-mapWith∈ []       f g = ≡.refl
+  map-mapWith∈ (x ∷ xs) f g = ≡.cong (_ ∷_) (map-mapWith∈ xs (f ∘ there) g)
 
 ------------------------------------------------------------------------
 -- map
 
 module _ (S₁ : Setoid c₁ ℓ₁) (S₂ : Setoid c₂ ℓ₂) where
 
-  open Setoid S₁ renaming (Carrier to A₁; _≈_ to _≈₁_; refl to refl₁)
-  open Setoid S₂ renaming (Carrier to A₂; _≈_ to _≈₂_)
+  open Setoid S₁ renaming (_≈_ to _≈₁_)
+  open Setoid S₂ renaming (_≈_ to _≈₂_)
   private module M₁ = Membership S₁; open M₁ using (find) renaming (_∈_ to _∈₁_)
   private module M₂ = Membership S₂; open M₂ using () renaming (_∈_ to _∈₂_)
 
-  ∈-map⁺ : ∀ {f} → f Preserves _≈₁_ ⟶ _≈₂_ → ∀ {v xs} →
-            v ∈₁ xs → f v ∈₂ map f xs
+  ∈-map⁺ : ∀ {f} → f Preserves _≈₁_ ⟶ _≈₂_ →
+           ∀ {v xs} → v ∈₁ xs → f v ∈₂ map f xs
   ∈-map⁺ pres x∈xs = Any.map⁺ (Any.map pres x∈xs)
 
   ∈-map⁻ : ∀ {v xs f} → v ∈₂ map f xs →
            ∃ λ x → x ∈₁ xs × v ≈₂ f x
   ∈-map⁻ x∈map = find (Any.map⁻ x∈map)
 
-  map-∷= : ∀ {f} (f≈ : f Preserves _≈₁_ ⟶ _≈₂_)
-           {xs x v} → (x∈xs : x ∈₁ xs) →
-           map f (x∈xs M₁.∷= v) ≡ ∈-map⁺ f≈ x∈xs M₂.∷= f v
-  map-∷= f≈ (here x≈y)   = P.refl
-  map-∷= f≈ (there x∈xs) = P.cong (_ ∷_) (map-∷= f≈ x∈xs)
+  map-∷= : ∀ {f} (pres : f Preserves _≈₁_ ⟶ _≈₂_) →
+           ∀ {xs x v} → (x∈xs : x ∈₁ xs) →
+           map f (x∈xs M₁.∷= v) ≡ ∈-map⁺ pres x∈xs M₂.∷= f v
+  map-∷= pres (here x≈y)   = ≡.refl
+  map-∷= pres (there x∈xs) = ≡.cong (_ ∷_) (map-∷= pres x∈xs)
 
 ------------------------------------------------------------------------
 -- _++_
@@ -201,9 +210,10 @@ module _ (S : Setoid c ℓ) where
 
   ∈-∃++ : ∀ {v xs} → v ∈ xs → ∃₂ λ ys zs → ∃ λ w →
           v ≈ w × xs ≋ ys ++ [ w ] ++ zs
-  ∈-∃++ (here px)                  = [] , _ , _ , px , ≋-refl
-  ∈-∃++ (there {d} v∈xs) with ∈-∃++ v∈xs
-  ... | hs , _ , _ , v≈v′ , eq = d ∷ hs , _ , _ , v≈v′ , refl ∷ eq
+  ∈-∃++ (here px)        = [] , _ , _ , px , ≋-refl
+  ∈-∃++ (there {d} v∈xs) =
+    let hs , _ , _ , v≈v′ , eq = ∈-∃++ v∈xs
+    in d ∷ hs , _ , _ , v≈v′ , refl ∷ eq
 
 ------------------------------------------------------------------------
 -- concat
@@ -225,8 +235,21 @@ module _ (S : Setoid c ℓ) where
   ∈-concat⁺′ v∈vs = ∈-concat⁺ ∘ Any.map (flip (∈-resp-≋ S) v∈vs)
 
   ∈-concat⁻′ : ∀ {v} xss → v ∈ concat xss → ∃ λ xs → v ∈ xs × xs ∈ₗ xss
-  ∈-concat⁻′ xss v∈c[xss] with find (∈-concat⁻ xss v∈c[xss])
-  ... | xs , t , s = xs , s , t
+  ∈-concat⁻′ xss v∈c[xss] =
+    let xs , xs∈xss , v∈xs = find (∈-concat⁻ xss v∈c[xss]) in xs , v∈xs , xs∈xss
+
+------------------------------------------------------------------------
+-- reverse
+
+module _ (S : Setoid c ℓ) where
+
+  open Membership S using (_∈_)
+
+  reverse⁺ : ∀ {x xs} → x ∈ xs → x ∈ reverse xs
+  reverse⁺ = Any.reverse⁺
+
+  reverse⁻ : ∀ {x xs} → x ∈ reverse xs → x ∈ xs
+  reverse⁻ = Any.reverse⁻
 
 ------------------------------------------------------------------------
 -- cartesianProductWith
@@ -248,10 +271,12 @@ module _ (S₁ : Setoid c₁ ℓ₁) (S₂ : Setoid c₂ ℓ₂) (S₃ : Setoid
   ∈-cartesianProductWith⁻ : ∀ f xs ys {v} → v ∈₃ cartesianProductWith f xs ys →
                             ∃₂ λ a b → a ∈₁ xs × b ∈₂ ys × v ≈₃ f a b
   ∈-cartesianProductWith⁻ f (x ∷ xs) ys v∈c with ∈-++⁻ S₃ (map (f x) ys) v∈c
-  ∈-cartesianProductWith⁻ f (x ∷ xs) ys v∈c | inj₁ v∈map with ∈-map⁻ S₂ S₃ v∈map
-  ... | (b , b∈ys , v≈fxb) = x , b , here refl₁ , b∈ys , v≈fxb
-  ∈-cartesianProductWith⁻ f (x ∷ xs) ys v∈c | inj₂ v∈com with ∈-cartesianProductWith⁻ f xs ys v∈com
-  ... | (a , b , a∈xs , b∈ys , v≈fab) = a , b , there a∈xs , b∈ys , v≈fab
+  ... | inj₁ v∈map =
+    let b , b∈ys , v≈fxb = ∈-map⁻ S₂ S₃ v∈map
+    in x , b , here refl₁ , b∈ys , v≈fxb
+  ... | inj₂ v∈com =
+    let a , b , a∈xs , b∈ys , v≈fab = ∈-cartesianProductWith⁻ f xs ys v∈com
+    in  a , b , there a∈xs , b∈ys , v≈fab
 
 ------------------------------------------------------------------------
 -- cartesianProduct
@@ -332,15 +357,15 @@ module _ (S : Setoid c ℓ) {P : Pred (Carrier S) p}
 
   ∈-filter⁻ : ∀ {v xs} → v ∈ filter P? xs → v ∈ xs × P v
   ∈-filter⁻ {xs = x ∷ xs} v∈f[x∷xs] with P? x
-  ... | false because  _   = Prod.map there id (∈-filter⁻ v∈f[x∷xs])
+  ... | false because  _   = Product.map there id (∈-filter⁻ v∈f[x∷xs])
   ... |  true because [Px] with v∈f[x∷xs]
   ...   | here  v≈x   = here v≈x , resp (sym v≈x) (invert [Px])
-  ...   | there v∈fxs = Prod.map there id (∈-filter⁻ v∈fxs)
+  ...   | there v∈fxs = Product.map there id (∈-filter⁻ v∈fxs)
 
 ------------------------------------------------------------------------
 -- derun and deduplicate
 
-module _ (S : Setoid c ℓ) {R : Rel (Carrier S) ℓ₂} (R? : B.Decidable R) where
+module _ (S : Setoid c ℓ) {R : Rel (Carrier S) ℓ₂} (R? : Binary.Decidable R) where
 
   open Setoid S using (_≈_)
   open Membership S using (_∈_)
@@ -365,9 +390,9 @@ module _ (S : Setoid c ℓ) where
 
   open Membership S using (_∈_)
 
-  ∈-length : ∀ {x xs} → x ∈ xs → 1 ≤ length xs
-  ∈-length (here px)    = s≤s z≤n
-  ∈-length (there x∈xs) = ≤-trans (∈-length x∈xs) (n≤1+n _)
+  ∈-length : ∀ {x xs} → x ∈ xs → 0 < length xs
+  ∈-length (here px)    = z<s
+  ∈-length (there x∈xs) = z<s
 
 ------------------------------------------------------------------------
 -- lookup
diff --git a/src/Data/List/Nary/NonDependent.agda b/src/Data/List/Nary/NonDependent.agda
index 6fff2b0dac..c008efa6c3 100644
--- a/src/Data/List/Nary/NonDependent.agda
+++ b/src/Data/List/Nary/NonDependent.agda
@@ -10,7 +10,7 @@ module Data.List.Nary.NonDependent where
 
 open import Data.Nat.Base using (zero; suc)
 open import Data.List.Base as List using (List; []; _∷_)
-open import Data.Product as Prod using (_,_)
+open import Data.Product.Base as Product using (_,_)
 open import Data.Product.Nary.NonDependent using (Product)
 open import Function.Base using ()
 open import Function.Nary.NonDependent.Base
@@ -37,7 +37,7 @@ zipWith : ∀ n {ls} {as : Sets n ls} {r} {R : Set r} →
 zipWith 0               f       = []
 zipWith 1               f xs    = List.map f xs
 zipWith (suc n@(suc _)) f xs ys =
-  zipWith n (Prod.uncurry f) (List.zipWith _,_ xs ys)
+  zipWith n (Product.uncurry f) (List.zipWith _,_ xs ys)
 
 unzipWith : ∀ n {ls} {as : Sets n ls} {a} {A : Set a} →
             (A → Product n as) → (List A → Product n (List <$> as))
diff --git a/src/Data/List/NonEmpty.agda b/src/Data/List/NonEmpty.agda
index 9e9f189fb5..5ce7ff4be2 100644
--- a/src/Data/List/NonEmpty.agda
+++ b/src/Data/List/NonEmpty.agda
@@ -9,21 +9,7 @@
 module Data.List.NonEmpty where
 
 open import Level using (Level)
-open import Effect.Monad
-open import Data.Bool.Base using (Bool; false; true; not; T)
-open import Data.Bool.Properties
-open import Data.List.Base as List using (List; []; _∷_)
-open import Data.Maybe.Base using (Maybe ; nothing; just)
-open import Data.Nat.Base as ℕ
-open import Data.Product as Prod using (∃; _×_; proj₁; proj₂; _,_; -,_)
-open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
-open import Data.These.Base as These using (These; this; that; these)
-open import Data.Unit.Base using (tt)
-open import Data.Vec.Base as Vec using (Vec; []; _∷_)
-open import Function.Base
-open import Function.Bundles using () renaming (module Equivalence to Eq)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; _≢_; refl)
-open import Relation.Nullary.Decidable using (isYes)
+open import Data.List.Base as List using (List)
 
 ------------------------------------------------------------------------
 -- Re-export basic type and operations
diff --git a/src/Data/List/NonEmpty/Base.agda b/src/Data/List/NonEmpty/Base.agda
index 3cc83a3447..35a3608a0f 100644
--- a/src/Data/List/NonEmpty/Base.agda
+++ b/src/Data/List/NonEmpty/Base.agda
@@ -9,12 +9,11 @@
 module Data.List.NonEmpty.Base where
 
 open import Level using (Level)
-open import Data.Bool.Base using (Bool; false; true; not; T)
-open import Data.Bool.Properties using (T?)
+open import Data.Bool.Base using (Bool; false; true)
 open import Data.List.Base as List using (List; []; _∷_)
 open import Data.Maybe.Base using (Maybe ; nothing; just)
 open import Data.Nat.Base as ℕ
-open import Data.Product as Prod using (∃; _×_; proj₁; proj₂; _,_; -,_)
+open import Data.Product.Base as Prod using (∃; _×_; proj₁; proj₂; _,_; -,_)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
 open import Data.These.Base as These using (These; this; that; these)
 open import Data.Vec.Base as Vec using (Vec; []; _∷_)
@@ -144,6 +143,16 @@ concatMap f = concat ∘′ map f
 ap : List⁺ (A → B) → List⁺ A → List⁺ B
 ap fs as = concatMap (λ f → map f as) fs
 
+-- Inits
+
+inits : List A → List⁺ (List A)
+inits xs = [] ∷ List.Inits.tail xs
+
+-- Tails
+
+tails : List A → List⁺ (List A)
+tails xs = xs ∷ List.Tails.tail xs
+
 -- Reverse
 
 reverse : List⁺ A → List⁺ A
@@ -204,9 +213,12 @@ snocView (x ∷ .(xs List.∷ʳ y)) | xs List.∷ʳ′ y = (x ∷ xs) ∷ʳ′ y
 
 -- The last element in the list.
 
+private
+  last′ : ∀ {l} → SnocView {A = A} l → A
+  last′ (_ ∷ʳ′ y) = y
+
 last : List⁺ A → A
-last xs with snocView xs
-last .(ys ∷ʳ y) | ys ∷ʳ′ y = y
+last = last′ ∘ snocView
 
 -- Groups all contiguous elements for which the predicate returns the
 -- same result into lists. The left sums are the ones for which the
diff --git a/src/Data/List/NonEmpty/Categorical.agda b/src/Data/List/NonEmpty/Categorical.agda
new file mode 100644
index 0000000000..442c1a0df1
--- /dev/null
+++ b/src/Data/List/NonEmpty/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.List.NonEmpty.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.List.NonEmpty.Categorical where
+
+open import Data.List.NonEmpty.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Data.List.NonEmpty.Categorical was deprecated in v2.0.
+Use Data.List.NonEmpty.Effectful instead."
+#-}
diff --git a/src/Data/List/NonEmpty/Categorical/Transformer.agda b/src/Data/List/NonEmpty/Categorical/Transformer.agda
new file mode 100644
index 0000000000..7842b65054
--- /dev/null
+++ b/src/Data/List/NonEmpty/Categorical/Transformer.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.List.NonEmpty.Effectful.Transformer` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.List.NonEmpty.Categorical.Transformer where
+
+open import Data.List.NonEmpty.Effectful.Transformer public
+
+{-# WARNING_ON_IMPORT
+"Data.List.NonEmpty.Categorical.Transformer was deprecated in v2.0.
+Use Data.List.NonEmpty.Effectful.Transformer instead."
+#-}
diff --git a/src/Data/List/NonEmpty/Effectful.agda b/src/Data/List/NonEmpty/Effectful.agda
index 654002c839..e2edccdf9f 100644
--- a/src/Data/List/NonEmpty/Effectful.agda
+++ b/src/Data/List/NonEmpty/Effectful.agda
@@ -11,12 +11,12 @@ module Data.List.NonEmpty.Effectful where
 open import Agda.Builtin.List
 import Data.List.Effectful as List
 open import Data.List.NonEmpty.Base
-open import Data.Product using (uncurry)
+open import Data.Product.Base using (uncurry)
 open import Effect.Functor
 open import Effect.Applicative
 open import Effect.Monad
 open import Effect.Comonad
-open import Function
+open import Function.Base using (flip; _∘′_; _∘_)
 
 ------------------------------------------------------------------------
 -- List⁺ applicative functor
diff --git a/src/Data/List/NonEmpty/Properties.agda b/src/Data/List/NonEmpty/Properties.agda
index 45b27f46c3..9469cd2b87 100644
--- a/src/Data/List/NonEmpty/Properties.agda
+++ b/src/Data/List/NonEmpty/Properties.agda
@@ -8,24 +8,29 @@
 
 module Data.List.NonEmpty.Properties where
 
-open import Effect.Monad
-open import Data.Nat
-open import Data.Nat.Properties
+open import Effect.Monad using (RawMonad)
+open import Data.Nat.Base using (suc; _+_)
+open import Data.Nat.Properties using (suc-injective)
 open import Data.Maybe.Properties using (just-injective)
-open import Data.Bool using (Bool; true; false)
+open import Data.Bool.Base using (Bool; true; false)
 open import Data.List.Base as List using (List; []; _∷_; _++_)
 open import Data.List.Effectful using () renaming (monad to listMonad)
 open import Data.List.NonEmpty.Effectful using () renaming (monad to list⁺Monad)
 open import Data.List.NonEmpty
-open import Data.List.NonEmpty.Relation.Unary.All
+  using (List⁺; _∷_; tail; head; toList; _⁺++_; _⁺++⁺_; _++⁺_; length; fromList;
+    drop+; map; inits; tails; groupSeqs; ungroupSeqs)
+open import Data.List.NonEmpty.Relation.Unary.All using (All; toList⁺; _∷_)
 open import Data.List.Relation.Unary.All using ([]; _∷_) renaming (All to ListAll)
 import Data.List.Properties as List
 open import Data.Sum.Base using (inj₁; inj₂)
 open import Data.Sum.Relation.Unary.All using (inj₁; inj₂)
 import Data.Sum.Relation.Unary.All as Sum using (All; inj₁; inj₂)
 open import Level using (Level)
-open import Function.Base
-open import Relation.Binary.PropositionalEquality
+open import Function.Base using (_∘_; _$_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂; _≗_)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Relation.Unary using (Pred; Decidable; ∁)
 open import Relation.Nullary using (¬_; does; yes; no)
 
@@ -113,6 +118,18 @@ map-cong f≗g (x ∷ xs) = cong₂ _∷_ (f≗g x) (List.map-cong f≗g xs)
 map-∘ : {g : B → C} {f : A → B} → map (g ∘ f) ≗ map g ∘ map f
 map-∘ (x ∷ xs) = cong (_ ∷_) (List.map-∘ xs)
 
+------------------------------------------------------------------------
+-- inits
+
+toList-inits : toList ∘ inits ≗ List.inits {A = A}
+toList-inits _ = refl
+
+------------------------------------------------------------------------
+-- tails
+
+toList-tails : toList ∘ tails ≗ List.tails {A = A}
+toList-tails _ = refl
+
 ------------------------------------------------------------------------
 -- groupSeqs
 
diff --git a/src/Data/List/Properties.agda b/src/Data/List/Properties.agda
index e9ddbe6387..b9936f2a3b 100644
--- a/src/Data/List/Properties.agda
+++ b/src/Data/List/Properties.agda
@@ -8,11 +8,14 @@
 -- equalities than _≡_.
 
 {-# OPTIONS --cubical-compatible --safe #-}
+{-# OPTIONS --warn=noUserWarning #-} -- for deprecated scans
 
 module Data.List.Properties where
 
 open import Algebra.Bundles
-open import Algebra.Definitions as AlgebraicDefinitions using (Involutive)
+open import Algebra.Consequences.Propositional
+ using (selfInverse⇒involutive; selfInverse⇒injective)
+open import Algebra.Definitions as AlgebraicDefinitions using (SelfInverse; Involutive)
 open import Algebra.Morphism.Structures using (IsMagmaHomomorphism; IsMonoidHomomorphism)
 import Algebra.Structures as AlgebraicStructures
 open import Data.Bool.Base using (Bool; false; true; not; if_then_else_)
@@ -21,53 +24,59 @@ open import Data.List.Base as List
 open import Data.List.Membership.Propositional using (_∈_)
 open import Data.List.Relation.Unary.All using (All; []; _∷_)
 open import Data.List.Relation.Unary.Any using (Any; here; there)
-open import Data.Maybe.Base using (Maybe; just; nothing)
+open import Data.Maybe.Base as Maybe using (Maybe; just; nothing)
+open import Data.Maybe.Relation.Unary.Any using (just) renaming (Any to MAny)
 open import Data.Nat.Base
-open import Data.Nat.Divisibility
+open import Data.Nat.Divisibility using (_∣_; divides; ∣n⇒∣m*n)
 open import Data.Nat.Properties
-open import Data.Product as Prod hiding (map; zip)
-import Data.Product.Relation.Unary.All as Prod using (All)
-open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
+open import Data.Product.Base as Product
+  using (_×_; _,_; uncurry; uncurry′; proj₁; proj₂; <_,_>)
+import Data.Product.Relation.Unary.All as Product using (All)
+open import Data.Sum using (_⊎_; inj₁; inj₂; isInj₁; isInj₂)
 open import Data.These.Base as These using (These; this; that; these)
-open import Function
+open import Data.Fin.Properties using (toℕ-cast)
+open import Function.Base using (id; _∘_; _∘′_; _∋_; _-⟨_∣; ∣_⟩-_; _$_; const; flip)
+open import Function.Definitions using (Injective)
 open import Level using (Level)
-open import Relation.Binary as B using (DecidableEquality)
-import Relation.Binary.Reasoning.Setoid as EqR
-open import Relation.Binary.PropositionalEquality as P hiding ([_])
-open import Relation.Binary as B using (Rel)
+open import Relation.Binary.Definitions as B using (DecidableEquality)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
+open import Relation.Binary.PropositionalEquality.Core as ≡
+open import Relation.Binary.PropositionalEquality.Properties as ≡
+open import Relation.Binary.Core using (Rel)
 open import Relation.Nullary.Reflects using (invert)
 open import Relation.Nullary using (¬_; Dec; does; _because_; yes; no; contradiction)
 open import Relation.Nullary.Decidable as Decidable using (isYes; map′; ⌊_⌋; ¬?; _×-dec_)
 open import Relation.Unary using (Pred; Decidable; ∁)
 open import Relation.Unary.Properties using (∁?)
+import Data.Nat.GeneralisedArithmetic as ℕ
 
 open ≡-Reasoning
 
 private
   variable
-    a b c d e p : Level
+    a b c d e p ℓ : Level
     A : Set a
     B : Set b
     C : Set c
     D : Set d
     E : Set e
+    x y z w : A
+    xs ys zs ws : List A
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- _∷_
 
-module _ {x y : A} {xs ys : List A} where
-
-  ∷-injective : x ∷ xs ≡ y List.∷ ys → x ≡ y × xs ≡ ys
-  ∷-injective refl = (refl , refl)
+∷-injective : x ∷ xs ≡ y List.∷ ys → x ≡ y × xs ≡ ys
+∷-injective refl = refl , refl
 
-  ∷-injectiveˡ : x ∷ xs ≡ y List.∷ ys → x ≡ y
-  ∷-injectiveˡ refl = refl
+∷-injectiveˡ : x ∷ xs ≡ y List.∷ ys → x ≡ y
+∷-injectiveˡ refl = refl
 
-  ∷-injectiveʳ : x ∷ xs ≡ y List.∷ ys → xs ≡ ys
-  ∷-injectiveʳ refl = refl
+∷-injectiveʳ : x ∷ xs ≡ y List.∷ ys → xs ≡ ys
+∷-injectiveʳ refl = refl
 
-  ∷-dec : Dec (x ≡ y) → Dec (xs ≡ ys) → Dec (x List.∷ xs ≡ y ∷ ys)
-  ∷-dec x≟y xs≟ys = Decidable.map′ (uncurry (cong₂ _∷_)) ∷-injective (x≟y ×-dec xs≟ys)
+∷-dec : Dec (x ≡ y) → Dec (xs ≡ ys) → Dec (x ∷ xs ≡ y List.∷ ys)
+∷-dec x≟y xs≟ys = Decidable.map′ (uncurry (cong₂ _∷_)) ∷-injective (x≟y ×-dec xs≟ys)
 
 ≡-dec : DecidableEquality A → DecidableEquality (List A)
 ≡-dec _≟_ []       []       = yes refl
@@ -114,32 +123,6 @@ map-injective finj {x ∷ xs} {y ∷ ys} eq =
   let fx≡fy , fxs≡fys = ∷-injective eq in
   cong₂ _∷_ (finj fx≡fy) (map-injective finj fxs≡fys)
 
-------------------------------------------------------------------------
--- mapMaybe
-
-mapMaybe-just : (xs : List A) → mapMaybe just xs ≡ xs
-mapMaybe-just []       = refl
-mapMaybe-just (x ∷ xs) = cong (x ∷_) (mapMaybe-just xs)
-
-mapMaybe-nothing : (xs : List A) →
-                   mapMaybe {B = A} (λ _ → nothing) xs ≡ []
-mapMaybe-nothing []       = refl
-mapMaybe-nothing (x ∷ xs) = mapMaybe-nothing xs
-
-module _ (f : A → Maybe B) where
-
-  mapMaybe-concatMap : mapMaybe f ≗ concatMap (fromMaybe ∘ f)
-  mapMaybe-concatMap [] = refl
-  mapMaybe-concatMap (x ∷ xs) with f x
-  ... | just y  = cong (y ∷_) (mapMaybe-concatMap xs)
-  ... | nothing = mapMaybe-concatMap xs
-
-  length-mapMaybe : ∀ xs → length (mapMaybe f xs) ≤ length xs
-  length-mapMaybe []       = z≤n
-  length-mapMaybe (x ∷ xs) with f x
-  ... | just y  = s≤s (length-mapMaybe xs)
-  ... | nothing = m≤n⇒m≤1+n (length-mapMaybe xs)
-
 ------------------------------------------------------------------------
 -- _++_
 
@@ -170,14 +153,14 @@ module _ {A : Set a} where
   ++-identityʳ-unique : ∀ (xs : List A) {ys} → xs ≡ xs ++ ys → ys ≡ []
   ++-identityʳ-unique []       refl = refl
   ++-identityʳ-unique (x ∷ xs) eq   =
-    ++-identityʳ-unique xs (proj₂ (∷-injective eq))
+    ++-identityʳ-unique xs (∷-injectiveʳ eq)
 
   ++-identityˡ-unique : ∀ {xs} (ys : List A) → xs ≡ ys ++ xs → ys ≡ []
   ++-identityˡ-unique               []       _  = refl
   ++-identityˡ-unique {xs = x ∷ xs} (y ∷ ys) eq
     with ++-identityˡ-unique (ys ++ [ x ]) (begin
-         xs                  ≡⟨ proj₂ (∷-injective eq) ⟩
-         ys ++ x ∷ xs        ≡⟨ sym (++-assoc ys [ x ] xs) ⟩
+         xs                  ≡⟨ ∷-injectiveʳ eq ⟩
+         ys ++ x ∷ xs        ≡⟨ ++-assoc ys [ x ] xs ⟨
          (ys ++ [ x ]) ++ xs ∎)
   ++-identityˡ-unique {xs = x ∷ xs} (y ∷ []   ) eq | ()
   ++-identityˡ-unique {xs = x ∷ xs} (y ∷ _ ∷ _) eq | ()
@@ -275,7 +258,7 @@ module _ (f : A → B → C) where
   cartesianProductWith-distribʳ-++ (x ∷ xs) ys zs = begin
     prod (x ∷ xs ++ ys) zs ≡⟨⟩
     map (f x) zs ++ prod (xs ++ ys) zs ≡⟨ cong (map (f x) zs ++_) (cartesianProductWith-distribʳ-++ xs ys zs) ⟩
-    map (f x) zs ++ prod xs zs ++ prod ys zs ≡˘⟨ ++-assoc (map (f x) zs) (prod xs zs) (prod ys zs) ⟩
+    map (f x) zs ++ prod xs zs ++ prod ys zs ≡⟨ ++-assoc (map (f x) zs) (prod xs zs) (prod ys zs) ⟨
     (map (f x) zs ++ prod xs zs) ++ prod ys zs ≡⟨⟩
     prod (x ∷ xs) zs ++ prod ys zs ∎
 
@@ -290,6 +273,8 @@ module _ {f g : These A B → C} where
   alignWith-cong f≗g (a ∷ as)   (b ∷ bs) =
     cong₂ _∷_ (f≗g (these a b)) (alignWith-cong f≗g as bs)
 
+module _ {f : These A B → C} where
+
   length-alignWith : ∀ xs ys →
                    length (alignWith f xs ys) ≡ length xs ⊔ length ys
   length-alignWith []         ys       = length-map (f ∘′ that) ys
@@ -312,18 +297,50 @@ module _ {f g : These A B → C} where
   map-alignWith g (x ∷ xs) (y ∷ ys) =
     cong₂ _∷_ refl (map-alignWith g xs ys)
 
+  alignWith-flip : ∀ xs ys →
+                 alignWith f xs ys ≡ alignWith (f ∘ These.swap) ys xs
+  alignWith-flip []       []       = refl
+  alignWith-flip []       (y ∷ ys) = refl
+  alignWith-flip (x ∷ xs) []       = refl
+  alignWith-flip (x ∷ xs) (y ∷ ys) = cong (_ ∷_) (alignWith-flip xs ys)
+
+module _ {f : These A A → B} where
+
+  alignWith-comm : f ∘ These.swap ≗ f →
+                 ∀ xs ys → alignWith f xs ys ≡ alignWith f ys xs
+  alignWith-comm f-comm xs ys = begin
+    alignWith f xs ys                ≡⟨ alignWith-flip xs ys ⟩
+    alignWith (f ∘ These.swap) ys xs ≡⟨ alignWith-cong f-comm ys xs ⟩
+    alignWith f ys xs                ∎
+
+------------------------------------------------------------------------
+-- align
+
+align-map : ∀ (f : A → B) (g : C → D) →
+            ∀ xs ys → align (map f xs) (map g ys) ≡
+                      map (These.map f g) (align xs ys)
+align-map f g xs ys = begin
+  align (map f xs) (map g ys)       ≡⟨ alignWith-map f g xs ys ⟩
+  alignWith (These.map f g) xs ys   ≡⟨ sym (map-alignWith (These.map f g) xs ys) ⟩
+  map (These.map f g) (align xs ys) ∎
+
+align-flip : ∀ (xs : List A) (ys : List B) →
+             align xs ys ≡ map These.swap (align ys xs)
+align-flip xs ys = begin
+  align xs ys                  ≡⟨ alignWith-flip xs ys ⟩
+  alignWith These.swap ys xs   ≡⟨ sym (map-alignWith These.swap ys xs) ⟩
+  map These.swap (align ys xs) ∎
+
 ------------------------------------------------------------------------
 -- zipWith
 
-module _ (f : A → A → B) where
+module _ {f g : A → B → C} where
 
-  zipWith-comm : (∀ x y → f x y ≡ f y x) →
-                 ∀ xs ys → zipWith f xs ys ≡ zipWith f ys xs
-  zipWith-comm f-comm []       []       = refl
-  zipWith-comm f-comm []       (x ∷ ys) = refl
-  zipWith-comm f-comm (x ∷ xs) []       = refl
-  zipWith-comm f-comm (x ∷ xs) (y ∷ ys) =
-    cong₂ _∷_ (f-comm x y) (zipWith-comm f-comm xs ys)
+  zipWith-cong : (∀ a b → f a b ≡ g a b) → ∀ as → zipWith f as ≗ zipWith g as
+  zipWith-cong f≗g []         bs       = refl
+  zipWith-cong f≗g as@(_ ∷ _) []       = refl
+  zipWith-cong f≗g (a ∷ as)   (b ∷ bs) =
+    cong₂ _∷_ (f≗g a b) (zipWith-cong f≗g as bs)
 
 module _ (f : A → B → C) where
 
@@ -342,7 +359,7 @@ module _ (f : A → B → C) where
   length-zipWith (x ∷ xs) []       = refl
   length-zipWith (x ∷ xs) (y ∷ ys) = cong suc (length-zipWith xs ys)
 
-  zipWith-map : ∀ {d e} {D : Set d} {E : Set e} (g : D → A) (h : E → B) →
+  zipWith-map : ∀ (g : D → A) (h : E → B) →
                 ∀ xs ys → zipWith f (map g xs) (map h ys) ≡
                           zipWith (λ x y → f (g x) (h y)) xs ys
   zipWith-map g h []       []       = refl
@@ -351,7 +368,7 @@ module _ (f : A → B → C) where
   zipWith-map g h (x ∷ xs) (y ∷ ys) =
     cong₂ _∷_ refl (zipWith-map g h xs ys)
 
-  map-zipWith : ∀ {d} {D : Set d} (g : C → D) → ∀ xs ys →
+  map-zipWith : ∀ (g : C → D) → ∀ xs ys →
                 map g (zipWith f xs ys) ≡
                 zipWith (λ x y → g (f x y)) xs ys
   map-zipWith g []       []       = refl
@@ -360,25 +377,58 @@ module _ (f : A → B → C) where
   map-zipWith g (x ∷ xs) (y ∷ ys) =
     cong₂ _∷_ refl (map-zipWith g xs ys)
 
+  zipWith-flip : ∀ xs ys → zipWith f xs ys ≡ zipWith (flip f) ys xs
+  zipWith-flip []       []       = refl
+  zipWith-flip []       (x ∷ ys) = refl
+  zipWith-flip (x ∷ xs) []       = refl
+  zipWith-flip (x ∷ xs) (y ∷ ys) = cong (f x y ∷_) (zipWith-flip xs ys)
+
+module _ (f : A → A → B) where
+
+  zipWith-comm : (∀ x y → f x y ≡ f y x) →
+                 ∀ xs ys → zipWith f xs ys ≡ zipWith f ys xs
+  zipWith-comm f-comm xs ys = begin
+    zipWith f xs ys        ≡⟨ zipWith-flip f xs ys ⟩
+    zipWith (flip f) ys xs ≡⟨ zipWith-cong (flip f-comm) ys xs ⟩
+    zipWith f ys xs        ∎
+
+------------------------------------------------------------------------
+-- zip
+
+zip-map : ∀ (f : A → B) (g : C → D) →
+          ∀ xs ys → zip (map f xs) (map g ys) ≡
+                    map (Product.map f g) (zip xs ys)
+zip-map f g xs ys = begin
+  zip (map f xs) (map g ys)         ≡⟨ zipWith-map _,_ f g xs ys ⟩
+  zipWith (λ x y → f x , g y) xs ys ≡⟨ sym (map-zipWith _,_ (Product.map f g) xs ys) ⟩
+  map (Product.map f g) (zip xs ys) ∎
+
+zip-flip : ∀ (xs : List A) (ys : List B) →
+           zip xs ys ≡ map Product.swap (zip ys xs)
+zip-flip xs ys = begin
+  zip xs ys                    ≡⟨ zipWith-flip _,_ xs ys ⟩
+  zipWith (flip _,_) ys xs     ≡⟨ sym (map-zipWith _,_ Product.swap ys xs) ⟩
+  map Product.swap (zip ys xs) ∎
+
 ------------------------------------------------------------------------
 -- unalignWith
 
 unalignWith-this : unalignWith ((A → These A B) ∋ this) ≗ (_, [])
 unalignWith-this []       = refl
-unalignWith-this (a ∷ as) = cong (Prod.map₁ (a ∷_)) (unalignWith-this as)
+unalignWith-this (a ∷ as) = cong (Product.map₁ (a ∷_)) (unalignWith-this as)
 
 unalignWith-that : unalignWith ((B → These A B) ∋ that) ≗ ([] ,_)
 unalignWith-that []       = refl
-unalignWith-that (b ∷ bs) = cong (Prod.map₂ (b ∷_)) (unalignWith-that bs)
+unalignWith-that (b ∷ bs) = cong (Product.map₂ (b ∷_)) (unalignWith-that bs)
 
 module _ {f g : C → These A B} where
 
   unalignWith-cong : f ≗ g → unalignWith f ≗ unalignWith g
   unalignWith-cong f≗g []       = refl
   unalignWith-cong f≗g (c ∷ cs) with f c | g c | f≗g c
-  ... | this a    | ._ | refl = cong (Prod.map₁ (a ∷_)) (unalignWith-cong f≗g cs)
-  ... | that b    | ._ | refl = cong (Prod.map₂ (b ∷_)) (unalignWith-cong f≗g cs)
-  ... | these a b | ._ | refl = cong (Prod.map (a ∷_) (b ∷_)) (unalignWith-cong f≗g cs)
+  ... | this a    | ._ | refl = cong (Product.map₁ (a ∷_)) (unalignWith-cong f≗g cs)
+  ... | that b    | ._ | refl = cong (Product.map₂ (b ∷_)) (unalignWith-cong f≗g cs)
+  ... | these a b | ._ | refl = cong (Product.map (a ∷_) (b ∷_)) (unalignWith-cong f≗g cs)
 
 module _ (f : C → These A B) where
 
@@ -386,17 +436,17 @@ module _ (f : C → These A B) where
                     unalignWith f (map g ds) ≡ unalignWith (f ∘′ g) ds
   unalignWith-map g []       = refl
   unalignWith-map g (d ∷ ds) with f (g d)
-  ... | this a    = cong (Prod.map₁ (a ∷_)) (unalignWith-map g ds)
-  ... | that b    = cong (Prod.map₂ (b ∷_)) (unalignWith-map g ds)
-  ... | these a b = cong (Prod.map (a ∷_) (b ∷_)) (unalignWith-map g ds)
+  ... | this a    = cong (Product.map₁ (a ∷_)) (unalignWith-map g ds)
+  ... | that b    = cong (Product.map₂ (b ∷_)) (unalignWith-map g ds)
+  ... | these a b = cong (Product.map (a ∷_) (b ∷_)) (unalignWith-map g ds)
 
   map-unalignWith : (g : A → D) (h : B → E) →
-    Prod.map (map g) (map h) ∘′ unalignWith f ≗ unalignWith (These.map g h ∘′ f)
+    Product.map (map g) (map h) ∘′ unalignWith f ≗ unalignWith (These.map g h ∘′ f)
   map-unalignWith g h []       = refl
   map-unalignWith g h (c ∷ cs) with f c
-  ... | this a    = cong (Prod.map₁ (g a ∷_)) (map-unalignWith g h cs)
-  ... | that b    = cong (Prod.map₂ (h b ∷_)) (map-unalignWith g h cs)
-  ... | these a b = cong (Prod.map (g a ∷_) (h b ∷_)) (map-unalignWith g h cs)
+  ... | this a    = cong (Product.map₁ (g a ∷_)) (map-unalignWith g h cs)
+  ... | that b    = cong (Product.map₂ (h b ∷_)) (map-unalignWith g h cs)
+  ... | these a b = cong (Product.map (g a ∷_) (h b ∷_)) (map-unalignWith g h cs)
 
   unalignWith-alignWith : (g : These A B → C) → f ∘′ g ≗ id → ∀ as bs →
                           unalignWith f (alignWith g as bs) ≡ (as , bs)
@@ -412,11 +462,18 @@ module _ (f : C → These A B) where
     as , []                            ∎
   unalignWith-alignWith g g∘f≗id (a ∷ as)   (b ∷ bs)
     rewrite g∘f≗id (these a b) =
-    cong (Prod.map (a ∷_) (b ∷_)) (unalignWith-alignWith g g∘f≗id as bs)
+    cong (Product.map (a ∷_) (b ∷_)) (unalignWith-alignWith g g∘f≗id as bs)
 
 ------------------------------------------------------------------------
 -- unzipWith
 
+module _ {f g : A → B × C} where
+
+  unzipWith-cong : f ≗ g → unzipWith f ≗ unzipWith g
+  unzipWith-cong f≗g [] = refl
+  unzipWith-cong f≗g (x ∷ xs) =
+    cong₂ (Product.zip _∷_ _∷_) (f≗g x) (unzipWith-cong f≗g xs)
+
 module _ (f : A → B × C) where
 
   length-unzipWith₁ : ∀ xys →
@@ -431,9 +488,66 @@ module _ (f : A → B × C) where
 
   zipWith-unzipWith : (g : B → C → A) → uncurry′ g ∘ f ≗ id →
                       uncurry′ (zipWith g) ∘ (unzipWith f)  ≗ id
-  zipWith-unzipWith g f∘g≗id []       = refl
-  zipWith-unzipWith g f∘g≗id (x ∷ xs) =
-    cong₂ _∷_ (f∘g≗id x) (zipWith-unzipWith g f∘g≗id xs)
+  zipWith-unzipWith g g∘f≗id []       = refl
+  zipWith-unzipWith g g∘f≗id (x ∷ xs) =
+    cong₂ _∷_ (g∘f≗id x) (zipWith-unzipWith g g∘f≗id xs)
+
+  unzipWith-zipWith : (g : B → C → A) → f ∘ uncurry′ g ≗ id →
+                      ∀ xs ys → length xs ≡ length ys →
+                      unzipWith f (zipWith g xs ys) ≡ (xs , ys)
+  unzipWith-zipWith g f∘g≗id []       []       l≡l = refl
+  unzipWith-zipWith g f∘g≗id (x ∷ xs) (y ∷ ys) l≡l  =
+    cong₂ (Product.zip _∷_ _∷_) (f∘g≗id (x , y))
+          (unzipWith-zipWith g f∘g≗id xs ys (suc-injective l≡l))
+
+  unzipWith-map : (g : D → A) → unzipWith f ∘ map g ≗ unzipWith (f ∘ g)
+  unzipWith-map g []       = refl
+  unzipWith-map g (x ∷ xs) =
+    cong (Product.zip _∷_ _∷_ (f (g x))) (unzipWith-map g xs)
+
+  map-unzipWith : (g : B → D) (h : C → E) →
+                  Product.map (map g) (map h) ∘ unzipWith f ≗
+                  unzipWith (Product.map g h ∘ f)
+  map-unzipWith g h []       = refl
+  map-unzipWith g h (x ∷ xs) =
+    cong (Product.zip _∷_ _∷_ _) (map-unzipWith g h xs)
+
+  unzipWith-swap : unzipWith (Product.swap ∘ f) ≗
+                   Product.swap ∘ unzipWith f
+  unzipWith-swap []       = refl
+  unzipWith-swap (x ∷ xs) =
+    cong (Product.zip _∷_ _∷_ _) (unzipWith-swap xs)
+
+  unzipWith-++ : ∀ xs ys →
+                 unzipWith f (xs ++ ys) ≡
+                 Product.zip _++_ _++_ (unzipWith f xs) (unzipWith f ys)
+  unzipWith-++ []       ys = refl
+  unzipWith-++ (x ∷ xs) ys =
+    cong (Product.zip _∷_ _∷_ (f x)) (unzipWith-++ xs ys)
+
+------------------------------------------------------------------------
+-- unzip
+
+unzip-map : ∀ (f : A → B) (g : C → D) →
+            unzip ∘ map (Product.map f g) ≗
+            Product.map (map f) (map g) ∘ unzip
+unzip-map f g xs = begin
+  unzip (map (Product.map f g) xs)       ≡⟨ unzipWith-map id (Product.map f g) xs ⟩
+  unzipWith (Product.map f g) xs         ≡⟨ sym (map-unzipWith id f g xs) ⟩
+  Product.map (map f) (map g) (unzip xs) ∎
+
+unzip-swap : unzip ∘ map Product.swap ≗ Product.swap ∘ unzip {A = A} {B = B}
+unzip-swap xs = begin
+  unzip (map Product.swap xs) ≡⟨ unzipWith-map id Product.swap xs ⟩
+  unzipWith Product.swap xs   ≡⟨ unzipWith-swap id xs ⟩
+  Product.swap (unzip xs)     ∎
+
+zip-unzip : uncurry′ zip ∘ unzip ≗ id {A = List (A × B)}
+zip-unzip = zipWith-unzipWith id _,_ λ _ → refl
+
+unzip-zip : ∀ (xs : List A) (ys : List B) →
+            length xs ≡ length ys → unzip (zip xs ys) ≡ (xs , ys)
+unzip-zip = unzipWith-zipWith id _,_ λ _ → refl
 
 ------------------------------------------------------------------------
 -- foldr
@@ -497,8 +611,8 @@ module _ {P : Pred A p} {f : A → A → A} where
   foldr-forcesᵇ : (∀ x y → P (f x y) → P x × P y) →
                   ∀ e xs → P (foldr f e xs) → All P xs
   foldr-forcesᵇ _      _ []       _     = []
-  foldr-forcesᵇ forces _ (x ∷ xs) Pfold with forces _ _ Pfold
-  ... | (px , pfxs) = px ∷ foldr-forcesᵇ forces _ xs pfxs
+  foldr-forcesᵇ forces _ (x ∷ xs) Pfold =
+    let px , pfxs = forces _ _ Pfold in px ∷ foldr-forcesᵇ forces _ xs pfxs
 
   foldr-preservesᵇ : (∀ {x y} → P x → P y → P (f x y)) →
                      ∀ {e xs} → P e → All P xs → P (foldr f e xs)
@@ -522,6 +636,11 @@ module _ {P : Pred A p} {f : A → A → A} where
 ------------------------------------------------------------------------
 -- foldl
 
+foldl-cong : ∀ {f g : B → A → B} → (∀ x y → f x y ≡ g x y) →
+             ∀ x → foldl f x ≗ foldl g x
+foldl-cong f≗g x []       = refl
+foldl-cong f≗g x (y ∷ xs) rewrite f≗g x y = foldl-cong f≗g _ xs
+
 foldl-++ : ∀ (f : A → B → A) x ys zs →
            foldl f x (ys ++ zs) ≡ foldl f (foldl f x ys) zs
 foldl-++ f x []       zs = refl
@@ -585,7 +704,7 @@ map-concatMap f g xs = begin
   map f (concatMap g xs)
     ≡⟨⟩
   map f (concat (map g xs))
-    ≡˘⟨ concat-map (map g xs) ⟩
+    ≡⟨ concat-map (map g xs) ⟨
   concat (map (map f) (map g xs))
     ≡⟨ cong concat
          {x = map (map f) (map g xs)}
@@ -596,6 +715,116 @@ map-concatMap f g xs = begin
   concatMap (map f ∘′ g) xs
     ∎
 
+------------------------------------------------------------------------
+-- catMaybes
+
+catMaybes-concatMap : catMaybes {A = A} ≗ concatMap fromMaybe
+catMaybes-concatMap []             = refl
+catMaybes-concatMap (just x  ∷ xs) = cong (x ∷_) $ catMaybes-concatMap xs
+catMaybes-concatMap (nothing ∷ xs) = catMaybes-concatMap xs
+
+length-catMaybes : ∀ xs → length (catMaybes {A = A} xs) ≤ length xs
+length-catMaybes []             = ≤-refl
+length-catMaybes (just _  ∷ xs) = s≤s $ length-catMaybes xs
+length-catMaybes (nothing ∷ xs) = m≤n⇒m≤1+n $ length-catMaybes xs
+
+catMaybes-++ : (xs ys : List (Maybe A)) →
+               catMaybes (xs ++ ys) ≡ catMaybes xs ++ catMaybes ys
+catMaybes-++ []             _  = refl
+catMaybes-++ (just x  ∷ xs) ys = cong (x ∷_) $ catMaybes-++ xs ys
+catMaybes-++ (nothing ∷ xs) ys = catMaybes-++ xs ys
+
+map-catMaybes : (f : A → B) → map f ∘ catMaybes ≗ catMaybes ∘ map (Maybe.map f)
+map-catMaybes _ []             = refl
+map-catMaybes f (just x  ∷ xs) = cong (f x ∷_) $ map-catMaybes f xs
+map-catMaybes f (nothing ∷ xs) = map-catMaybes f xs
+
+Any-catMaybes⁺ : ∀ {P : Pred A ℓ} {xs : List (Maybe A)} →
+                 Any (MAny P) xs → Any P (catMaybes xs)
+Any-catMaybes⁺ {xs = nothing ∷ xs} (there x∈)       = Any-catMaybes⁺ x∈
+Any-catMaybes⁺ {xs = just x  ∷ xs} (here (just px)) = here px
+Any-catMaybes⁺ {xs = just x  ∷ xs} (there x∈)       = there $ Any-catMaybes⁺ x∈
+
+------------------------------------------------------------------------
+-- mapMaybe
+
+mapMaybe-cong : {f g : A → Maybe B} → f ≗ g → mapMaybe f ≗ mapMaybe g
+mapMaybe-cong f≗g = cong catMaybes ∘ map-cong f≗g
+
+mapMaybe-just : (xs : List A) → mapMaybe just xs ≡ xs
+mapMaybe-just []       = refl
+mapMaybe-just (x ∷ xs) = cong (x ∷_) (mapMaybe-just xs)
+
+mapMaybe-nothing : (xs : List A) →
+                   mapMaybe {B = B} (λ _ → nothing) xs ≡ []
+mapMaybe-nothing []       = refl
+mapMaybe-nothing (x ∷ xs) = mapMaybe-nothing xs
+
+module _ (f : A → Maybe B) where
+
+  mapMaybe-concatMap : mapMaybe f ≗ concatMap (fromMaybe ∘ f)
+  mapMaybe-concatMap xs = begin
+    catMaybes (map f xs)            ≡⟨ catMaybes-concatMap (map f xs) ⟩
+    concatMap fromMaybe (map f xs)  ≡⟨ concatMap-map fromMaybe f xs ⟩
+    concatMap (fromMaybe ∘ f) xs    ∎
+
+  length-mapMaybe : ∀ xs → length (mapMaybe f xs) ≤ length xs
+  length-mapMaybe xs = ≤-begin
+    length (mapMaybe f xs)      ≤⟨ length-catMaybes (map f xs) ⟩
+    length (map f xs)           ≤⟨ ≤-reflexive (length-map f xs) ⟩
+    length xs                   ≤-∎
+    where open ≤-Reasoning renaming (begin_ to ≤-begin_; _∎ to _≤-∎)
+
+  mapMaybe-++ : ∀ xs ys →
+                mapMaybe f (xs ++ ys) ≡ mapMaybe f xs ++ mapMaybe f ys
+  mapMaybe-++ xs ys = begin
+    catMaybes (map f (xs ++ ys))     ≡⟨ cong catMaybes (map-++ f xs ys) ⟩
+    catMaybes (map f xs ++ map f ys) ≡⟨ catMaybes-++ (map f xs) (map f ys) ⟩
+    mapMaybe f xs ++ mapMaybe f ys   ∎
+
+module _ (f : B → Maybe C) (g : A → B) where
+
+  mapMaybe-map : mapMaybe f ∘ map g ≗ mapMaybe (f ∘ g)
+  mapMaybe-map = cong catMaybes ∘ sym ∘ map-∘
+
+module _ (g : B → C) (f : A → Maybe B) where
+
+  map-mapMaybe : map g ∘ mapMaybe f ≗ mapMaybe (Maybe.map g ∘ f)
+  map-mapMaybe xs = begin
+    map g (catMaybes (map f xs))       ≡⟨ map-catMaybes g (map f xs) ⟩
+    mapMaybe (Maybe.map g) (map f xs)  ≡⟨ mapMaybe-map _ f xs ⟩
+    mapMaybe (Maybe.map g ∘ f) xs      ∎
+
+-- embedding-projection pairs
+module _ {proj : B → Maybe A} {emb : A → B} where
+  mapMaybe-map-retract : proj ∘ emb ≗ just → mapMaybe proj ∘ map emb ≗ id
+  mapMaybe-map-retract retract xs = begin
+    mapMaybe proj (map emb xs) ≡⟨ mapMaybe-map _ _ xs ⟩
+    mapMaybe (proj ∘ emb) xs   ≡⟨ mapMaybe-cong retract xs ⟩
+    mapMaybe just xs           ≡⟨ mapMaybe-just _ ⟩
+    xs                         ∎
+
+module _ {proj : C → Maybe B} {emb : A → C} where
+  mapMaybe-map-none : proj ∘ emb ≗ const nothing → mapMaybe proj ∘ map emb ≗ const []
+  mapMaybe-map-none retract xs = begin
+    mapMaybe proj (map emb xs)  ≡⟨ mapMaybe-map _ _ xs ⟩
+    mapMaybe (proj ∘ emb) xs    ≡⟨ mapMaybe-cong retract xs ⟩
+    mapMaybe (const nothing) xs ≡⟨ mapMaybe-nothing xs ⟩
+    []                          ∎
+
+-- embedding-projection pairs on sums
+mapMaybeIsInj₁∘mapInj₁ : (xs : List A) → mapMaybe (isInj₁ {B = B}) (map inj₁ xs) ≡ xs
+mapMaybeIsInj₁∘mapInj₁ = mapMaybe-map-retract λ _ → refl
+
+mapMaybeIsInj₁∘mapInj₂ : (xs : List B) → mapMaybe (isInj₁ {A = A}) (map inj₂ xs) ≡ []
+mapMaybeIsInj₁∘mapInj₂ = mapMaybe-map-none λ _ → refl
+
+mapMaybeIsInj₂∘mapInj₂ : (xs : List B) → mapMaybe (isInj₂ {A = A}) (map inj₂ xs) ≡ xs
+mapMaybeIsInj₂∘mapInj₂ = mapMaybe-map-retract λ _ → refl
+
+mapMaybeIsInj₂∘mapInj₁ : (xs : List A) → mapMaybe (isInj₂ {B = B}) (map inj₁ xs) ≡ []
+mapMaybeIsInj₂∘mapInj₁ = mapMaybe-map-none λ _ → refl
+
 ------------------------------------------------------------------------
 -- sum
 
@@ -613,42 +842,6 @@ sum-++ (x ∷ xs) ys = begin
 ∈⇒∣product {n} {n ∷ ns} (here  refl) = divides (product ns) (*-comm n (product ns))
 ∈⇒∣product {n} {m ∷ ns} (there n∈ns) = ∣n⇒∣m*n m (∈⇒∣product n∈ns)
 
-------------------------------------------------------------------------
--- replicate
-
-length-replicate : ∀ n {x : A} → length (replicate n x) ≡ n
-length-replicate zero    = refl
-length-replicate (suc n) = cong suc (length-replicate n)
-
-------------------------------------------------------------------------
--- scanr
-
-scanr-defn : ∀ (f : A → B → B) (e : B) →
-             scanr f e ≗ map (foldr f e) ∘ tails
-scanr-defn f e []             = refl
-scanr-defn f e (x ∷ [])       = refl
-scanr-defn f e (x ∷ y ∷ xs)
-  with scanr f e (y ∷ xs) | scanr-defn f e (y ∷ xs)
-... | []     | ()
-... | z ∷ zs | eq with ∷-injective eq
-...   | z≡fy⦇f⦈xs , _ = cong₂ (λ z → f x z ∷_) z≡fy⦇f⦈xs eq
-
-------------------------------------------------------------------------
--- scanl
-
-scanl-defn : ∀ (f : A → B → A) (e : A) →
-             scanl f e ≗ map (foldl f e) ∘ inits
-scanl-defn f e []       = refl
-scanl-defn f e (x ∷ xs) = cong (e ∷_) (begin
-   scanl f (f e x) xs
- ≡⟨ scanl-defn f (f e x) xs ⟩
-   map (foldl f (f e x)) (inits xs)
- ≡⟨ refl ⟩
-   map (foldl f e ∘ (x ∷_)) (inits xs)
- ≡⟨ map-∘ (inits xs) ⟩
-   map (foldl f e) (map (x ∷_) (inits xs))
- ∎)
-
 ------------------------------------------------------------------------
 -- applyUpTo
 
@@ -660,8 +853,12 @@ lookup-applyUpTo : ∀ (f : ℕ → A) n i → lookup (applyUpTo f n) i ≡ f (t
 lookup-applyUpTo f (suc n) zero    = refl
 lookup-applyUpTo f (suc n) (suc i) = lookup-applyUpTo (f ∘ suc) n i
 
+applyUpTo-∷ʳ : ∀ (f : ℕ → A) n → applyUpTo f n ∷ʳ f n ≡ applyUpTo f (suc n)
+applyUpTo-∷ʳ f zero = refl
+applyUpTo-∷ʳ f (suc n) = cong (f 0 ∷_) (applyUpTo-∷ʳ (f ∘ suc) n)
+
 ------------------------------------------------------------------------
--- applyUpTo
+-- applyDownFrom
 
 module _ (f : ℕ → A) where
 
@@ -673,6 +870,10 @@ module _ (f : ℕ → A) where
   lookup-applyDownFrom (suc n) zero    = refl
   lookup-applyDownFrom (suc n) (suc i) = lookup-applyDownFrom n i
 
+  applyDownFrom-∷ʳ : ∀ n → applyDownFrom (f ∘ suc) n ∷ʳ f 0 ≡ applyDownFrom f (suc n)
+  applyDownFrom-∷ʳ zero = refl
+  applyDownFrom-∷ʳ (suc n) = cong (f (suc n) ∷_) (applyDownFrom-∷ʳ n)
+
 ------------------------------------------------------------------------
 -- upTo
 
@@ -682,6 +883,9 @@ length-upTo = length-applyUpTo id
 lookup-upTo : ∀ n i → lookup (upTo n) i ≡ toℕ i
 lookup-upTo = lookup-applyUpTo id
 
+upTo-∷ʳ : ∀ n → upTo n ∷ʳ n ≡ upTo (suc n)
+upTo-∷ʳ = applyUpTo-∷ʳ id
+
 ------------------------------------------------------------------------
 -- downFrom
 
@@ -691,6 +895,9 @@ length-downFrom = length-applyDownFrom id
 lookup-downFrom : ∀ n i → lookup (downFrom n) i ≡ n ∸ (suc (toℕ i))
 lookup-downFrom = lookup-applyDownFrom id
 
+downFrom-∷ʳ : ∀ n → applyDownFrom suc n ∷ʳ 0 ≡ downFrom (suc n)
+downFrom-∷ʳ = applyDownFrom-∷ʳ id
+
 ------------------------------------------------------------------------
 -- tabulate
 
@@ -739,17 +946,41 @@ map-∷= (x ∷ xs) zero    v f = refl
 map-∷= (x ∷ xs) (suc k) v f = cong (f x ∷_) (map-∷= xs k v f)
 
 ------------------------------------------------------------------------
--- _─_
+-- insertAt
+
+length-insertAt : ∀ (xs : List A) (i : Fin (suc (length xs))) v →
+                  length (insertAt xs i v) ≡ suc (length xs)
+length-insertAt xs       zero    v = refl
+length-insertAt (x ∷ xs) (suc i) v = cong suc (length-insertAt xs i v)
 
-length-─ : ∀ (xs : List A) k → length (xs ─ k) ≡ pred (length xs)
-length-─ (x ∷ xs) zero        = refl
-length-─ (x ∷ y ∷ xs) (suc k) = cong suc (length-─ (y ∷ xs) k)
+------------------------------------------------------------------------
+-- removeAt
 
-map-─ : ∀ xs k (f : A → B) →
-        let eq = sym (length-map f xs) in
-        map f (xs ─ k) ≡ map f xs ─ cast eq k
-map-─ (x ∷ xs) zero    f = refl
-map-─ (x ∷ xs) (suc k) f = cong (f x ∷_) (map-─ xs k f)
+length-removeAt : ∀ (xs : List A) k → length (removeAt xs k) ≡ pred (length xs)
+length-removeAt (x ∷ xs) zero            = refl
+length-removeAt (x ∷ xs@(_ ∷ _)) (suc k) = cong suc (length-removeAt xs k)
+
+length-removeAt′ : ∀ (xs : List A) k → length xs ≡ suc (length (removeAt xs k))
+length-removeAt′ xs@(_ ∷ _) k rewrite length-removeAt xs k = refl
+
+map-removeAt : ∀ xs k (f : A → B) →
+            let eq = sym (length-map f xs) in
+            map f (removeAt xs k) ≡ removeAt (map f xs) (cast eq k)
+map-removeAt (x ∷ xs) zero    f = refl
+map-removeAt (x ∷ xs) (suc k) f = cong (f x ∷_) (map-removeAt xs k f)
+
+------------------------------------------------------------------------
+ -- insertAt and removeAt
+
+removeAt-insertAt : ∀ (xs : List A) (i : Fin (suc (length xs))) v →
+  removeAt (insertAt xs i v) ((cast (sym (length-insertAt xs i v)) i)) ≡ xs
+removeAt-insertAt xs       zero    v = refl
+removeAt-insertAt (x ∷ xs) (suc i) v = cong (_ ∷_) (removeAt-insertAt xs i v)
+
+insertAt-removeAt : (xs : List A) (i : Fin (length xs)) →
+  insertAt (removeAt xs i) (cast (length-removeAt′ xs i) i) (lookup xs i) ≡ xs
+insertAt-removeAt (x ∷ xs) zero    = refl
+insertAt-removeAt (x ∷ xs) (suc i) = cong (x ∷_) (insertAt-removeAt xs i)
 
 ------------------------------------------------------------------------
 -- take
@@ -759,6 +990,49 @@ length-take zero    xs       = refl
 length-take (suc n) []       = refl
 length-take (suc n) (x ∷ xs) = cong suc (length-take n xs)
 
+-- Take commutes with map.
+take-map : ∀ {f : A → B} (n : ℕ) xs → take n (map f xs) ≡ map f (take n xs)
+take-map zero xs = refl
+take-map (suc s) [] = refl
+take-map (suc s) (a ∷ xs) = cong (_ ∷_) (take-map s xs)
+
+take-suc : (xs : List A) (i : Fin (length xs)) → let m = toℕ i in
+           take (suc m) xs ≡ take m xs ∷ʳ lookup xs i
+take-suc (x ∷ xs) zero    = refl
+take-suc (x ∷ xs) (suc i) = cong (x ∷_) (take-suc xs i)
+
+take-suc-tabulate : ∀ {n} (f : Fin n → A) (i : Fin n) → let m = toℕ i in
+                    take (suc m) (tabulate f) ≡ take m (tabulate f) ∷ʳ f i
+take-suc-tabulate f i rewrite sym (toℕ-cast (sym (length-tabulate f)) i) | sym (lookup-tabulate f i)
+  = take-suc (tabulate f) (cast _ i)
+
+-- If you take at least as many elements from a list as it has, you get
+-- the whole list.
+take-all : (n : ℕ) (xs : List A) → n ≥ length xs → take n xs ≡ xs
+take-all zero [] _ = refl
+take-all (suc _) [] _ = refl
+take-all (suc n) (x ∷ xs) (s≤s pf) = cong (x ∷_) (take-all n xs pf)
+
+-- Taking from an empty list does nothing.
+take-[] : ∀ m → take {A = A} m [] ≡ []
+take-[] zero = refl
+take-[] (suc m) = refl
+
+-- Taking twice takes the minimum of both counts.
+take-take : ∀ n m (xs : List A) → take n (take m xs) ≡ take (n ⊓ m) xs
+take-take zero    m       xs       = refl
+take-take (suc n) zero    xs       = refl
+take-take (suc n) (suc m) []       = refl
+take-take (suc n) (suc m) (x ∷ xs) = cong (x ∷_) (take-take n m xs)
+
+-- Dropping m elements and then taking n is the same as
+-- taking n + m elements and then dropping m.
+take-drop : ∀ n m (xs : List A) →
+            take n (drop m xs) ≡ drop m (take (m + n) xs)
+take-drop n zero    xs       = refl
+take-drop n (suc m) []       = take-[] n
+take-drop n (suc m) (x ∷ xs) = take-drop n m xs
+
 ------------------------------------------------------------------------
 -- drop
 
@@ -767,10 +1041,79 @@ length-drop zero    xs       = refl
 length-drop (suc n) []       = refl
 length-drop (suc n) (x ∷ xs) = length-drop n xs
 
-take++drop : ∀ n (xs : List A) → take n xs ++ drop n xs ≡ xs
-take++drop zero    xs       = refl
-take++drop (suc n) []       = refl
-take++drop (suc n) (x ∷ xs) = cong (x ∷_) (take++drop n xs)
+-- Drop commutes with map.
+drop-map : ∀ {f : A → B} (n : ℕ) xs → drop n (map f xs) ≡ map f (drop n xs)
+drop-map zero xs = refl
+drop-map (suc n) [] = refl
+drop-map (suc n) (a ∷ xs) = drop-map n xs
+
+-- Dropping from an empty list does nothing.
+drop-[] : ∀ m → drop {A = A} m [] ≡ []
+drop-[] zero = refl
+drop-[] (suc m) = refl
+
+take++drop≡id : ∀ n (xs : List A) → take n xs ++ drop n xs ≡ xs
+take++drop≡id zero    xs       = refl
+take++drop≡id (suc n) []       = refl
+take++drop≡id (suc n) (x ∷ xs) = cong (x ∷_) (take++drop≡id n xs)
+
+drop-take-suc : (xs : List A) (i : Fin (length xs)) → let m = toℕ i in
+           drop m (take (suc m) xs) ≡ [ lookup xs i ]
+drop-take-suc (x ∷ xs) zero    = refl
+drop-take-suc (x ∷ xs) (suc i) = drop-take-suc xs i
+
+drop-take-suc-tabulate : ∀ {n} (f : Fin n → A) (i : Fin n) → let m = toℕ i in
+                  drop m (take (suc m) (tabulate f)) ≡ [ f i ]
+drop-take-suc-tabulate f i rewrite sym (toℕ-cast (sym (length-tabulate f)) i) | sym (lookup-tabulate f i)
+  = drop-take-suc (tabulate f) (cast _ i)
+
+-- Dropping m elements and then n elements is same as dropping m+n elements
+drop-drop : (m n : ℕ) → (xs : List A) → drop n (drop m xs) ≡ drop (m + n) xs
+drop-drop zero n xs = refl
+drop-drop (suc m) n [] = drop-[] n
+drop-drop (suc m) n (x ∷ xs) = drop-drop m n xs
+
+drop-all : (n : ℕ) (xs : List A) → n ≥ length xs → drop n xs ≡ []
+drop-all n       []       _ = drop-[] n
+drop-all (suc n) (x ∷ xs) p = drop-all n xs (s≤s⁻¹ p)
+
+------------------------------------------------------------------------
+-- replicate
+
+length-replicate : ∀ n {x : A} → length (replicate n x) ≡ n
+length-replicate zero    = refl
+length-replicate (suc n) = cong suc (length-replicate n)
+
+lookup-replicate : ∀ n (x : A) (i : Fin n) →
+                   lookup (replicate n x) (cast (sym (length-replicate n)) i) ≡ x
+lookup-replicate (suc n) x zero    = refl
+lookup-replicate (suc n) x (suc i) = lookup-replicate n x i
+
+map-replicate :  ∀ (f : A → B) n (x : A) →
+                 map f (replicate n x) ≡ replicate n (f x)
+map-replicate f zero    x = refl
+map-replicate f (suc n) x = cong (_ ∷_) (map-replicate f n x)
+
+zipWith-replicate : ∀ n (_⊕_ : A → B → C) (x : A) (y : B) →
+                    zipWith _⊕_ (replicate n x) (replicate n y) ≡ replicate n (x ⊕ y)
+zipWith-replicate zero    _⊕_ x y = refl
+zipWith-replicate (suc n) _⊕_ x y = cong (x ⊕ y ∷_) (zipWith-replicate n _⊕_ x y)
+
+------------------------------------------------------------------------
+-- iterate
+
+length-iterate : ∀ f (x : A) n → length (iterate f x n) ≡ n
+length-iterate f x zero    = refl
+length-iterate f x (suc n) = cong suc (length-iterate f (f x) n)
+
+iterate-id : ∀ (x : A) n → iterate id x n ≡ replicate n x
+iterate-id x zero    = refl
+iterate-id x (suc n) = cong (_ ∷_) (iterate-id x n)
+
+lookup-iterate : ∀ f (x : A) n (i : Fin n) →
+  lookup (iterate f x n) (cast (sym (length-iterate f x n)) i) ≡ ℕ.iterate f x (toℕ i)
+lookup-iterate f x (suc n) zero    = refl
+lookup-iterate f x (suc n) (suc i) = lookup-iterate f (f x) n i
 
 ------------------------------------------------------------------------
 -- splitAt
@@ -778,8 +1121,16 @@ take++drop (suc n) (x ∷ xs) = cong (x ∷_) (take++drop n xs)
 splitAt-defn : ∀ n → splitAt {A = A} n ≗ < take n , drop n >
 splitAt-defn zero    xs       = refl
 splitAt-defn (suc n) []       = refl
-splitAt-defn (suc n) (x ∷ xs) with splitAt n xs | splitAt-defn n xs
-... | (ys , zs) | ih = cong (Prod.map (x ∷_) id) ih
+splitAt-defn (suc n) (x ∷ xs) = cong (Product.map (x ∷_) id) (splitAt-defn n xs)
+
+module _ (f : A → B) where
+
+  splitAt-map : ∀ n → splitAt n ∘ map f ≗
+                      Product.map (map f) (map f) ∘ splitAt n
+  splitAt-map zero    xs       = refl
+  splitAt-map (suc n) []       = refl
+  splitAt-map (suc n) (x ∷ xs) =
+    cong (Product.map₁ (f x ∷_)) (splitAt-map n xs)
 
 ------------------------------------------------------------------------
 -- takeWhile, dropWhile, and span
@@ -795,7 +1146,7 @@ module _ {P : Pred A p} (P? : Decidable P) where
   span-defn : span P? ≗ < takeWhile P? , dropWhile P? >
   span-defn []       = refl
   span-defn (x ∷ xs) with does (P? x)
-  ... | true  = cong (Prod.map (x ∷_) id) (span-defn xs)
+  ... | true  = cong (Product.map (x ∷_) id) (span-defn xs)
   ... | false = refl
 
 ------------------------------------------------------------------------
@@ -805,9 +1156,9 @@ module _ {P : Pred A p} (P? : Decidable P) where
 
   length-filter : ∀ xs → length (filter P? xs) ≤ length xs
   length-filter []       = z≤n
-  length-filter (x ∷ xs) with does (P? x)
-  ... | false = m≤n⇒m≤1+n (length-filter xs)
-  ... | true  = s≤s (length-filter xs)
+  length-filter (x ∷ xs) with ih ← length-filter xs | does (P? x)
+  ... | false = m≤n⇒m≤1+n ih
+  ... | true  = s≤s ih
 
   filter-all : ∀ {xs} → All P xs → filter P? xs ≡ xs
   filter-all {[]}     []         = refl
@@ -819,9 +1170,9 @@ module _ {P : Pred A p} (P? : Decidable P) where
   filter-notAll (x ∷ xs) (here ¬px) with P? x
   ... | false because _ = s≤s (length-filter xs)
   ... | yes          px = contradiction px ¬px
-  filter-notAll (x ∷ xs) (there any) with does (P? x)
-  ... | false = m≤n⇒m≤1+n (filter-notAll xs any)
-  ... | true  = s≤s (filter-notAll xs any)
+  filter-notAll (x ∷ xs) (there any) with ih ← filter-notAll xs any | does (P? x)
+  ... | false = m≤n⇒m≤1+n ih
+  ... | true  = s≤s ih
 
   filter-some : ∀ {xs} → Any P xs → 0 < length (filter P? xs)
   filter-some {x ∷ xs} (here px)   with P? x
@@ -856,15 +1207,15 @@ module _ {P : Pred A p} (P? : Decidable P) where
 
   filter-idem : filter P? ∘ filter P? ≗ filter P?
   filter-idem []       = refl
-  filter-idem (x ∷ xs) with does (P? x) | inspect does (P? x)
-  ... | false | _                   = filter-idem xs
-  ... | true  | P.[ eq ] rewrite eq = cong (x ∷_) (filter-idem xs)
+  filter-idem (x ∷ xs) with does (P? x) in eq
+  ... | false            = filter-idem xs
+  ... | true  rewrite eq = cong (x ∷_) (filter-idem xs)
 
   filter-++ : ∀ xs ys → filter P? (xs ++ ys) ≡ filter P? xs ++ filter P? ys
   filter-++ []       ys = refl
-  filter-++ (x ∷ xs) ys with does (P? x)
-  ... | true  = cong (x ∷_) (filter-++ xs ys)
-  ... | false = filter-++ xs ys
+  filter-++ (x ∷ xs) ys with ih ← filter-++ xs ys | does (P? x)
+  ... | true  = cong (x ∷_) ih
+  ... | false = ih
 
 ------------------------------------------------------------------------
 -- derun and deduplicate
@@ -874,9 +1225,9 @@ module _ {R : Rel A p} (R? : B.Decidable R) where
   length-derun : ∀ xs → length (derun R? xs) ≤ length xs
   length-derun [] = ≤-refl
   length-derun (x ∷ []) = ≤-refl
-  length-derun (x ∷ y ∷ xs) with does (R? x y) | length-derun (y ∷ xs)
-  ... | true  | r = m≤n⇒m≤1+n r
-  ... | false | r = s≤s r
+  length-derun (x ∷ y ∷ xs) with ih ← length-derun (y ∷ xs) | does (R? x y)
+  ... | true  = m≤n⇒m≤1+n ih
+  ... | false = s≤s ih
 
   length-deduplicate : ∀ xs → length (deduplicate R? xs) ≤ length xs
   length-deduplicate [] = z≤n
@@ -905,16 +1256,16 @@ module _ {P : Pred A p} (P? : Decidable P) where
 
   partition-defn : partition P? ≗ < filter P? , filter (∁? P?) >
   partition-defn []       = refl
-  partition-defn (x ∷ xs) with does (P? x)
-  ...  | true  = cong (Prod.map (x ∷_) id) (partition-defn xs)
-  ...  | false = cong (Prod.map id (x ∷_)) (partition-defn xs)
+  partition-defn (x ∷ xs) with ih ← partition-defn xs | does (P? x)
+  ...  | true  = cong (Product.map (x ∷_) id) ih
+  ...  | false = cong (Product.map id (x ∷_)) ih
 
   length-partition : ∀ xs → (let (ys , zs) = partition P? xs) →
                      length ys ≤ length xs × length zs ≤ length xs
   length-partition []       = z≤n , z≤n
-  length-partition (x ∷ xs) with does (P? x) | length-partition xs
-  ...  | true  | rec = Prod.map s≤s m≤n⇒m≤1+n rec
-  ...  | false | rec = Prod.map m≤n⇒m≤1+n s≤s rec
+  length-partition (x ∷ xs) with ih ← length-partition xs | does (P? x)
+  ...  | true  = Product.map s≤s m≤n⇒m≤1+n ih
+  ...  | false = Product.map m≤n⇒m≤1+n s≤s ih
 
 ------------------------------------------------------------------------
 -- _ʳ++_
@@ -932,11 +1283,11 @@ module _ {P : Pred A p} (P? : Decidable P) where
 
 -- Reverse-append of append is reverse-append after reverse-append.
 
-ʳ++-++ : ∀ (xs {ys zs} : List A) → (xs ++ ys) ʳ++ zs ≡ ys ʳ++ xs ʳ++ zs
-ʳ++-++ [] = refl
-ʳ++-++ (x ∷ xs) {ys} {zs} = begin
+++-ʳ++ : ∀ (xs {ys zs} : List A) → (xs ++ ys) ʳ++ zs ≡ ys ʳ++ xs ʳ++ zs
+++-ʳ++ [] = refl
+++-ʳ++ (x ∷ xs) {ys} {zs} = begin
   (x ∷ xs ++ ys) ʳ++ zs   ≡⟨⟩
-  (xs ++ ys) ʳ++ x ∷ zs   ≡⟨ ʳ++-++ xs ⟩
+  (xs ++ ys) ʳ++ x ∷ zs   ≡⟨ ++-ʳ++ xs ⟩
   ys ʳ++ xs ʳ++ x ∷ zs    ≡⟨⟩
   ys ʳ++ (x ∷ xs) ʳ++ zs  ∎
 
@@ -1006,31 +1357,38 @@ foldl-ʳ++ f b (x ∷ xs) {ys} = begin
 unfold-reverse : ∀ (x : A) xs → reverse (x ∷ xs) ≡ reverse xs ∷ʳ x
 unfold-reverse x xs = ʳ++-defn xs
 
--- reverse is an involution with respect to append.
+-- reverse is an anti-homomorphism with respect to append.
 
 reverse-++ : (xs ys : List A) →
                      reverse (xs ++ ys) ≡ reverse ys ++ reverse xs
 reverse-++ xs ys = begin
   reverse (xs ++ ys)         ≡⟨⟩
-  (xs ++ ys) ʳ++ []          ≡⟨ ʳ++-++ xs ⟩
+  (xs ++ ys) ʳ++ []          ≡⟨ ++-ʳ++ xs ⟩
   ys ʳ++ xs ʳ++ []           ≡⟨⟩
   ys ʳ++ reverse xs          ≡⟨ ʳ++-defn ys ⟩
   reverse ys ++ reverse xs   ∎
 
+-- reverse is self-inverse.
+
+reverse-selfInverse : SelfInverse {A = List A} _≡_ reverse
+reverse-selfInverse {x = xs} {y = ys} xs⁻¹≈ys = begin
+  reverse ys         ≡⟨⟩
+  ys ʳ++ []          ≡⟨ cong (_ʳ++ []) xs⁻¹≈ys ⟨
+  reverse xs ʳ++ []  ≡⟨⟩
+  (xs ʳ++ []) ʳ++ [] ≡⟨ ʳ++-ʳ++ xs ⟩
+  [] ʳ++ xs ++ []    ≡⟨⟩
+  xs ++ []           ≡⟨ ++-identityʳ xs ⟩
+  xs                 ∎
+
 -- reverse is involutive.
 
 reverse-involutive : Involutive {A = List A} _≡_ reverse
-reverse-involutive xs = begin
-  reverse (reverse xs)  ≡⟨⟩
-  (xs ʳ++ []) ʳ++ []    ≡⟨ ʳ++-ʳ++ xs ⟩
-  [] ʳ++  xs ++ []      ≡⟨⟩
-  xs ++ []              ≡⟨ ++-identityʳ xs ⟩
-  xs                    ∎
+reverse-involutive = selfInverse⇒involutive reverse-selfInverse
 
 -- reverse is injective.
 
-reverse-injective : ∀ {xs ys : List A} → reverse xs ≡ reverse ys → xs ≡ ys
-reverse-injective = subst₂ _≡_ (reverse-involutive _) (reverse-involutive _) ∘ cong reverse
+reverse-injective : Injective {A = List A} _≡_ _≡_ reverse
+reverse-injective = selfInverse⇒injective reverse-selfInverse
 
 -- reverse preserves length.
 
@@ -1057,26 +1415,93 @@ reverse-foldl : ∀ (f : B → A → B) b xs →
 reverse-foldl f b xs = foldl-ʳ++ f b xs
 
 ------------------------------------------------------------------------
--- _∷ʳ_
+-- reverse, applyUpTo, and applyDownFrom
+
+reverse-applyUpTo : ∀ (f : ℕ → A) n → reverse (applyUpTo f n) ≡ applyDownFrom f n
+reverse-applyUpTo f zero = refl
+reverse-applyUpTo f (suc n) = begin
+  reverse (f 0 ∷ applyUpTo (f ∘ suc) n)  ≡⟨ reverse-++ [ f 0 ] (applyUpTo (f ∘ suc) n) ⟩
+  reverse (applyUpTo (f ∘ suc) n) ∷ʳ f 0 ≡⟨ cong (_∷ʳ f 0) (reverse-applyUpTo (f ∘ suc) n) ⟩
+  applyDownFrom (f ∘ suc) n ∷ʳ f 0       ≡⟨ applyDownFrom-∷ʳ f n ⟩
+  applyDownFrom f (suc n)                ∎
+
+reverse-upTo : ∀ n → reverse (upTo n) ≡ downFrom n
+reverse-upTo = reverse-applyUpTo id
+
+reverse-applyDownFrom : ∀ (f : ℕ → A) n → reverse (applyDownFrom f n) ≡ applyUpTo f n
+reverse-applyDownFrom f zero = refl
+reverse-applyDownFrom f (suc n) = begin
+  reverse (f n ∷ applyDownFrom f n)  ≡⟨ reverse-++ [ f n ] (applyDownFrom f n) ⟩
+  reverse (applyDownFrom f n) ∷ʳ f n ≡⟨ cong (_∷ʳ f n) (reverse-applyDownFrom f n) ⟩
+  applyUpTo f n ∷ʳ f n               ≡⟨ applyUpTo-∷ʳ f n ⟩
+  applyUpTo f (suc n)                ∎
+
+reverse-downFrom : ∀ n → reverse (downFrom n) ≡ upTo n
+reverse-downFrom = reverse-applyDownFrom id
 
-module _ {x y : A} where
+------------------------------------------------------------------------
+-- _∷ʳ_
 
-  ∷ʳ-injective : ∀ xs ys → xs ∷ʳ x ≡ ys ∷ʳ y → xs ≡ ys × x ≡ y
-  ∷ʳ-injective []          []          refl = (refl , refl)
-  ∷ʳ-injective (x ∷ xs)    (y  ∷ ys)   eq   with ∷-injective eq
-  ... | refl , eq′ = Prod.map (cong (x ∷_)) id (∷ʳ-injective xs ys eq′)
-  ∷ʳ-injective []          (_ ∷ _ ∷ _) ()
-  ∷ʳ-injective (_ ∷ _ ∷ _) []          ()
+∷ʳ-injective : ∀ xs ys → xs ∷ʳ x ≡ ys ∷ʳ y → xs ≡ ys × x ≡ y
+∷ʳ-injective []          []          refl = refl , refl
+∷ʳ-injective (x ∷ xs)    (y  ∷ ys)   eq   with refl , eq′  ← ∷-injective eq
+  = Product.map (cong (x ∷_)) id (∷ʳ-injective xs ys eq′)
+∷ʳ-injective []          (_ ∷ _ ∷ _) ()
+∷ʳ-injective (_ ∷ _ ∷ _) []          ()
 
-  ∷ʳ-injectiveˡ : ∀ (xs ys : List A) → xs ∷ʳ x ≡ ys ∷ʳ y → xs ≡ ys
-  ∷ʳ-injectiveˡ xs ys eq = proj₁ (∷ʳ-injective xs ys eq)
+∷ʳ-injectiveˡ : ∀ xs ys → xs ∷ʳ x ≡ ys ∷ʳ y → xs ≡ ys
+∷ʳ-injectiveˡ xs ys eq = proj₁ (∷ʳ-injective xs ys eq)
 
-  ∷ʳ-injectiveʳ : ∀ (xs ys : List A) → xs ∷ʳ x ≡ ys ∷ʳ y → x ≡ y
-  ∷ʳ-injectiveʳ xs ys eq = proj₂ (∷ʳ-injective xs ys eq)
+∷ʳ-injectiveʳ : ∀ xs ys → xs ∷ʳ x ≡ ys ∷ʳ y → x ≡ y
+∷ʳ-injectiveʳ xs ys eq = proj₂ (∷ʳ-injective xs ys eq)
 
-∷ʳ-++ : ∀ (xs : List A) (a : A) (ys : List A) → xs ∷ʳ a ++ ys ≡ xs ++ a ∷ ys
+∷ʳ-++ : ∀ xs (a : A) ys → xs ∷ʳ a ++ ys ≡ xs ++ a ∷ ys
 ∷ʳ-++ xs a ys = ++-assoc xs [ a ] ys
 
+------------------------------------------------------------------------
+-- uncons
+
+module _ (f : A → B) where
+
+  -- 'commute' List.uncons and List.map to obtain a Maybe.map and List.uncons.
+  uncons-map : uncons ∘ map f ≗ Maybe.map (Product.map f (map f)) ∘ uncons
+  uncons-map []       = refl
+  uncons-map (x ∷ xs) = refl
+
+------------------------------------------------------------------------
+-- head
+
+module _ {f : A → B} where
+
+  -- 'commute' List.head and List.map to obtain a Maybe.map and List.head.
+  head-map : head ∘ map f ≗ Maybe.map f ∘ head
+  head-map []      = refl
+  head-map (_ ∷ _) = refl
+
+------------------------------------------------------------------------
+-- last
+
+module _ (f : A → B) where
+
+  -- 'commute' List.last and List.map to obtain a Maybe.map and List.last.
+  last-map : last ∘ map f ≗ Maybe.map f ∘ last
+  last-map []               = refl
+  last-map (x ∷ [])         = refl
+  last-map (x ∷ xs@(_ ∷ _)) = last-map xs
+
+------------------------------------------------------------------------
+-- tail
+
+module _ (f : A → B) where
+
+  -- 'commute' List.tail and List.map to obtain a Maybe.map and List.tail.
+  tail-map : tail ∘ map f ≗ Maybe.map (map f) ∘ tail
+  tail-map []       = refl
+  tail-map (x ∷ xs) = refl
+
+
+
+
 ------------------------------------------------------------------------
 -- DEPRECATED
 ------------------------------------------------------------------------
@@ -1138,3 +1563,59 @@ zipWith-identityʳ = zipWith-zeroʳ
 "Warning: zipWith-identityʳ was deprecated in v2.0.
 Please use zipWith-zeroʳ instead."
 #-}
+
+ʳ++-++ = ++-ʳ++
+{-# WARNING_ON_USAGE ʳ++-++
+"Warning: ʳ++-++ was deprecated in v2.0.
+Please use ++-ʳ++ instead."
+#-}
+
+take++drop = take++drop≡id
+{-# WARNING_ON_USAGE take++drop
+"Warning: take++drop was deprecated in v2.0.
+Please use take++drop≡id instead."
+#-}
+
+length-─ = length-removeAt
+{-# WARNING_ON_USAGE length-─
+"Warning: length-─ was deprecated in v2.0.
+Please use length-removeAt instead."
+#-}
+
+map-─ = map-removeAt
+{-# WARNING_ON_USAGE map-─
+"Warning: map-─ was deprecated in v2.0.
+Please use map-removeAt instead."
+#-}
+
+-- Version 2.1
+
+scanr-defn : ∀ (f : A → B → B) (e : B) →
+             scanr f e ≗ map (foldr f e) ∘ tails
+scanr-defn f e []             = refl
+scanr-defn f e (x ∷ [])       = refl
+scanr-defn f e (x ∷ xs@(_ ∷ _))
+  with eq ← scanr-defn f e xs
+  with ys@(_ ∷ _) ← scanr f e xs
+  = cong₂ (λ z → f x z ∷_) (∷-injectiveˡ eq) eq
+{-# WARNING_ON_USAGE scanr-defn
+"Warning: scanr-defn was deprecated in v2.1.
+Please use Data.List.Scans.Properties.scanr-defn instead."
+#-}
+
+scanl-defn : ∀ (f : A → B → A) (e : A) →
+             scanl f e ≗ map (foldl f e) ∘ inits
+scanl-defn f e []       = refl
+scanl-defn f e (x ∷ xs) = cong (e ∷_) (begin
+   scanl f (f e x) xs
+ ≡⟨ scanl-defn f (f e x) xs ⟩
+   map (foldl f (f e x)) (inits xs)
+ ≡⟨ refl ⟩
+   map (foldl f e ∘ (x ∷_)) (inits xs)
+ ≡⟨ map-∘ (inits xs) ⟩
+   map (foldl f e) (map (x ∷_) (inits xs))
+ ∎)
+{-# WARNING_ON_USAGE scanl-defn
+"Warning: scanl-defn was deprecated in v2.1.
+Please use Data.List.Scans.Properties.scanl-defn instead."
+#-}
diff --git a/src/Data/List/Reflection.agda b/src/Data/List/Reflection.agda
index 20063430c4..3d4ab919a1 100644
--- a/src/Data/List/Reflection.agda
+++ b/src/Data/List/Reflection.agda
@@ -24,6 +24,8 @@ open import Reflection.AST.Argument
 `[] : Term
 `[] = con (quote List.[]) (2 ⋯⟅∷⟆ [])
 
+infixr 5 _`∷_
+
 _`∷_ : Term → Term → Term
 x `∷ xs = con (quote List._∷_) (2 ⋯⟅∷⟆ x ⟨∷⟩ xs ⟨∷⟩ [])
 
diff --git a/src/Data/List/Relation/Binary/BagAndSetEquality.agda b/src/Data/List/Relation/Binary/BagAndSetEquality.agda
index ac88bd72ef..815b27db89 100644
--- a/src/Data/List/Relation/Binary/BagAndSetEquality.agda
+++ b/src/Data/List/Relation/Binary/BagAndSetEquality.agda
@@ -8,64 +8,82 @@
 
 module Data.List.Relation.Binary.BagAndSetEquality where
 
-open import Algebra using (Idempotent; CommutativeMonoid)
+open import Algebra.Bundles using (CommutativeMonoid)
+open import Algebra.Definitions using (Idempotent)
 open import Algebra.Structures.Biased using (isCommutativeMonoidˡ)
 open import Effect.Monad using (RawMonad)
-open import Data.Empty
-open import Data.Fin.Base
+open import Data.Empty using (⊥; ⊥-elim)
+open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.List.Base
+  using (List; []; _∷_; map; _++_; concat; [_]; lookup; length)
 open import Data.List.Effectful using (monad; module Applicative; module MonadProperties)
-import Data.List.Properties as LP
+import Data.List.Properties as List
 open import Data.List.Relation.Unary.Any using (Any; here; there)
-open import Data.List.Relation.Unary.Any.Properties hiding (++-comm)
+open import Data.List.Relation.Unary.Any.Properties
+  using (∷↔; map↔; Any-cong; ++↔; concat↔; >>=↔; ++↔++; ⊎↔; ⊥↔Any[])
 open import Data.List.Membership.Propositional using (_∈_)
+open import Data.List.Membership.Propositional.Properties
+  using (∈-∃++)
 open import Data.List.Relation.Binary.Subset.Propositional.Properties
   using (⊆-preorder)
 open import Data.List.Relation.Binary.Permutation.Propositional
+  using (_↭_; ↭-sym; refl; module PermutationReasoning)
 open import Data.List.Relation.Binary.Permutation.Propositional.Properties
-open import Data.Product as Prod hiding (map)
+  using (∈-resp-↭; ∈-resp-[σ⁻¹∘σ]; ↭-sym-involutive; shift; ++-comm)
+open import Data.Product.Base as Product using (∃; _,_; proj₁; proj₂; _×_)
 import Data.Product.Function.Dependent.Propositional as Σ
-open import Data.Sum.Base as Sum hiding (map)
-open import Data.Sum.Properties hiding (map-cong)
+open import Data.Sum.Base as Sum using (_⊎_; [_,_]′; inj₁; inj₂)
+open import Data.Sum.Properties using (inj₂-injective; inj₁-injective)
 open import Data.Sum.Function.Propositional using (_⊎-cong_)
-open import Data.Unit.Polymorphic.Base
-open import Function.Base
-open import Function.Equality using (_⟨$⟩_)
-import Function.Equivalence as FE
-open import Function.Inverse as Inv using (_↔_; Inverse; inverse)
-open import Function.Related as Related
+open import Data.Unit.Polymorphic.Base using (⊤)
+open import Function.Base using (_∘_; _$_; id; _⟨_⟩_; case_of_)
+open import Function.Bundles using (_↔_; Inverse; Equivalence; mk↔ₛ′; mk⇔)
+open import Function.Related.Propositional as Related
   using (↔⇒; ⌊_⌋; ⌊_⌋→; ⇒→; K-refl; SK-sym)
-open import Function.Related.TypeIsomorphisms
-open import Relation.Binary
-import Relation.Binary.Reasoning.Setoid as EqR
-import Relation.Binary.Reasoning.Preorder as PreorderReasoning
-open import Relation.Binary.PropositionalEquality as P
+open import Function.Related.TypeIsomorphisms using (×-identityʳ; ∃∃↔∃∃)
+open import Function.Properties.Inverse using (↔-sym; ↔-trans; to-from)
+open import Level using (Level)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Definitions using (Trans)
+open import Relation.Binary.Bundles using (Preorder; Setoid)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
+import Relation.Binary.Reasoning.Preorder as ≲-Reasoning
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; _≢_; _≗_; refl)
-open import Relation.Nullary
-open import Data.List.Membership.Propositional.Properties
+open import Relation.Binary.PropositionalEquality.Properties as ≡
+  using (module ≡-Reasoning)
+open import Relation.Binary.Reasoning.Syntax
+open import Relation.Nullary.Negation.Core using (¬_)
+
+private
+  variable
+    a b : Level
+    A B : Set a
+    x y : A
+    ws xs ys zs : List A
 
 ------------------------------------------------------------------------
 -- Definitions
 
-open Related public using (Kind; Symmetric-kind) renaming
+open Related public using (Kind; SymmetricKind) renaming
   ( implication         to subset
-  ; reverse-implication to superset
+  ; reverseImplication  to superset
   ; equivalence         to set
   ; injection           to subbag
-  ; reverse-injection   to superbag
+  ; reverseInjection    to superbag
   ; bijection           to bag
   )
 
-[_]-Order : Kind → ∀ {a} → Set a → Preorder _ _ _
-[ k ]-Order A = Related.InducedPreorder₂ k {A = A} _∈_
+[_]-Order : Kind → Set a → Preorder _ _ _
+[ k ]-Order A = Related.InducedPreorder₂ {A = A} k _∈_
 
-[_]-Equality : Symmetric-kind → ∀ {a} → Set a → Setoid _ _
-[ k ]-Equality A = Related.InducedEquivalence₂ k {A = A} _∈_
+[_]-Equality : SymmetricKind → Set a → Setoid _ _
+[ k ]-Equality A = Related.InducedEquivalence₂ {A = A} k _∈_
 
 infix 4 _∼[_]_
 
 _∼[_]_ : ∀ {a} {A : Set a} → List A → Kind → List A → Set _
-_∼[_]_ {A = A} xs k ys = Preorder._∼_ ([ k ]-Order A) xs ys
+_∼[_]_ {A = A} xs k ys = Preorder._≲_ ([ k ]-Order A) xs ys
 
 private
   module Eq  {k a} {A : Set a} = Setoid ([ k ]-Equality A)
@@ -76,48 +94,40 @@ private
 ------------------------------------------------------------------------
 -- Bag equality implies the other relations.
 
-bag-=⇒ : ∀ {k a} {A : Set a} {xs ys : List A} →
-         xs ∼[ bag ] ys → xs ∼[ k ] ys
+bag-=⇒ : ∀ {k} → xs ∼[ bag ] ys → xs ∼[ k ] ys
 bag-=⇒ xs≈ys = ↔⇒ xs≈ys
 
 ------------------------------------------------------------------------
 -- "Equational" reasoning for _⊆_ along with an additional relatedness
 
-module ⊆-Reasoning where
-  private
-    module PreOrder {a} {A : Set a} = PreorderReasoning (⊆-preorder A)
+module ⊆-Reasoning {A : Set a} where
+  private module Base = ≲-Reasoning (⊆-preorder A)
 
-  open PreOrder public
-    hiding (step-≈; step-≈˘; step-∼)
+  open Base public
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨; step-∼; step-≲)
+    renaming (≲-go to ⊆-go)
 
-  infixr 2 step-∼ step-⊆
-  infix  1 step-∈
+  open begin-membership-syntax _IsRelatedTo_ _∈_ (λ x → begin x) public
+  open ⊆-syntax _IsRelatedTo_ _IsRelatedTo_ ⊆-go public
 
-  step-⊆ = PreOrder.step-∼
+  module _ {k : Related.ForwardKind} where
+    ∼-go : Trans _∼[ ⌊ k ⌋→ ]_ _IsRelatedTo_ _IsRelatedTo_
+    ∼-go eq = ⊆-go (⇒→ eq)
 
-  step-∈ : ∀ {a} {A : Set a} x {xs ys : List A} →
-           xs IsRelatedTo ys → x ∈ xs → x ∈ ys
-  step-∈ x xs⊆ys x∈xs = (begin xs⊆ys) x∈xs
+    open ∼-syntax _IsRelatedTo_ _IsRelatedTo_ ∼-go public
 
-  step-∼ : ∀ {k a} {A : Set a} xs {ys zs : List A} →
-           ys IsRelatedTo zs → xs ∼[ ⌊ k ⌋→ ] ys → xs IsRelatedTo zs
-  step-∼ xs ys⊆zs xs≈ys = step-⊆ xs ys⊆zs (⇒→ xs≈ys)
-
-  syntax step-∈ x  xs⊆ys x∈xs  = x ∈⟨ x∈xs ⟩ xs⊆ys
-  syntax step-∼ xs ys⊆zs xs≈ys = xs ∼⟨ xs≈ys ⟩ ys⊆zs
-  syntax step-⊆ xs ys⊆zs xs⊆ys = xs ⊆⟨ xs⊆ys ⟩ ys⊆zs
 
 ------------------------------------------------------------------------
 -- Congruence lemmas
 ------------------------------------------------------------------------
 -- _∷_
 
-module _ {a k} {A : Set a} {x y : A} {xs ys} where
+module _ {k} {x y : A} {xs ys} where
 
   ∷-cong : x ≡ y → xs ∼[ k ] ys → x ∷ xs ∼[ k ] y ∷ ys
   ∷-cong refl xs≈ys {y} = begin
     y ∈ x ∷ xs        ↔⟨ SK-sym $ ∷↔ (y ≡_) ⟩
-    (y ≡ x ⊎ y ∈ xs)  ∼⟨ (y ≡ x ∎) ⊎-cong xs≈ys ⟩
+    (y ≡ x ⊎ y ∈ xs)  ∼⟨ K-refl ⊎-cong xs≈ys ⟩
     (y ≡ x ⊎ y ∈ ys)  ↔⟨ ∷↔ (y ≡_) ⟩
     y ∈ x ∷ ys        ∎
     where open Related.EquationalReasoning
@@ -125,7 +135,7 @@ module _ {a k} {A : Set a} {x y : A} {xs ys} where
 ------------------------------------------------------------------------
 -- map
 
-module _ {ℓ k} {A B : Set ℓ} {f g : A → B} {xs ys} where
+module _ {k} {f g : A → B} {xs ys} where
 
   map-cong : f ≗ g → xs ∼[ k ] ys → map f xs ∼[ k ] map g ys
   map-cong f≗g xs≈ys {x} = begin
@@ -137,19 +147,16 @@ module _ {ℓ k} {A B : Set ℓ} {f g : A → B} {xs ys} where
     open Related.EquationalReasoning
 
     helper : ∀ y → x ≡ f y ↔ x ≡ g y
-    helper y = record
-      { to         = P.→-to-⟶ (λ x≡fy → P.trans x≡fy (        f≗g y))
-      ; from       = P.→-to-⟶ (λ x≡gy → P.trans x≡gy (P.sym $ f≗g y))
-      ; inverse-of = record
-        { left-inverse-of  = λ { P.refl → P.trans-symʳ (f≗g y) }
-        ; right-inverse-of = λ { P.refl → P.trans-symˡ (f≗g y) }
-        }
-      }
+    helper y = mk↔ₛ′
+      (λ x≡fy → ≡.trans x≡fy (        f≗g y))
+      (λ x≡gy → ≡.trans x≡gy (≡.sym $ f≗g y))
+      (λ { ≡.refl → ≡.trans-symˡ (f≗g y) })
+      λ { ≡.refl → ≡.trans-symʳ (f≗g y) }
 
 ------------------------------------------------------------------------
 -- _++_
 
-module _ {a k} {A : Set a} {xs₁ xs₂ ys₁ ys₂ : List A} where
+module _ {k} {xs₁ xs₂ ys₁ ys₂ : List A} where
 
   ++-cong : xs₁ ∼[ k ] xs₂ → ys₁ ∼[ k ] ys₂ →
             xs₁ ++ ys₁ ∼[ k ] xs₂ ++ ys₂
@@ -163,7 +170,7 @@ module _ {a k} {A : Set a} {xs₁ xs₂ ys₁ ys₂ : List A} where
 ------------------------------------------------------------------------
 -- concat
 
-module _ {a k} {A : Set a} {xss yss : List (List A)} where
+module _ {k} {xss yss : List (List A)} where
 
   concat-cong : xss ∼[ k ] yss → concat xss ∼[ k ] concat yss
   concat-cong xss≈yss {x} = begin
@@ -176,7 +183,7 @@ module _ {a k} {A : Set a} {xss yss : List (List A)} where
 ------------------------------------------------------------------------
 -- _>>=_
 
-module _ {ℓ k} {A B : Set ℓ} {xs ys} {f g : A → List B} where
+module _ {k} {A B : Set a} {xs ys} {f g : A → List B} where
 
   >>=-cong : xs ∼[ k ] ys → (∀ x → f x ∼[ k ] g x) →
              (xs >>= f) ∼[ k ] (ys >>= g)
@@ -191,16 +198,16 @@ module _ {ℓ k} {A B : Set ℓ} {xs ys} {f g : A → List B} where
 ------------------------------------------------------------------------
 -- _⊛_
 
-module _ {ℓ k} {A B : Set ℓ} {fs gs : List (A → B)} {xs ys} where
+module _ {k} {A B : Set a} {fs gs : List (A → B)} {xs ys} where
 
   ⊛-cong : fs ∼[ k ] gs → xs ∼[ k ] ys → (fs ⊛ xs) ∼[ k ] (gs ⊛ ys)
   ⊛-cong fs≈gs xs≈ys {x} = begin
     x ∈ (fs ⊛ xs)
-      ≡⟨ P.cong (x ∈_) (Applicative.unfold-⊛ fs xs) ⟩
+      ≡⟨ ≡.cong (x ∈_) (Applicative.unfold-⊛ fs xs) ⟩
     x ∈ (fs >>= λ f → xs >>= λ x → pure (f x))
       ∼⟨ >>=-cong fs≈gs (λ f → >>=-cong xs≈ys λ x → K-refl) ⟩
     x ∈ (gs >>= λ g → ys >>= λ y → pure (g y))
-      ≡˘⟨ P.cong (x ∈_) (Applicative.unfold-⊛ gs ys) ⟩
+      ≡⟨ ≡.cong (x ∈_) (Applicative.unfold-⊛ gs ys) ⟨
     x ∈ (gs ⊛ ys) ∎
     where open Related.EquationalReasoning
 
@@ -220,8 +227,7 @@ module _ {ℓ k} {A B : Set ℓ} {xs₁ xs₂ : List A} {ys₁ ys₂ : List B} w
 -- _++_ and [] form a commutative monoid, with either bag or set
 -- equality as the underlying equality.
 
-commutativeMonoid : ∀ {a} → Symmetric-kind → Set a →
-                    CommutativeMonoid _ _
+commutativeMonoid : SymmetricKind → Set a → CommutativeMonoid _ _
 commutativeMonoid {a} k A = record
   { Carrier             = List A
   ; _≈_                 = _∼[ ⌊ k ⌋ ]_
@@ -234,12 +240,10 @@ commutativeMonoid {a} k A = record
         ; ∙-cong        = ++-cong
         }
       ; assoc         = λ xs ys zs →
-                          Eq.reflexive (LP.++-assoc xs ys zs)
+                          Eq.reflexive (List.++-assoc xs ys zs)
       }
-    ; identityˡ = λ xs {x} → x ∈ xs ∎
-    ; comm      = λ xs ys {x} →
-                    x ∈ xs ++ ys  ↔⟨ ++↔++ xs ys ⟩
-                    x ∈ ys ++ xs  ∎
+    ; identityˡ = λ xs → K-refl
+    ; comm      = λ xs ys → ↔⇒ (++↔++ xs ys)
     }
   }
   where open Related.EquationalReasoning
@@ -247,25 +251,23 @@ commutativeMonoid {a} k A = record
 -- The only list which is bag or set equal to the empty list (or a
 -- subset or subbag of the list) is the empty list itself.
 
-empty-unique : ∀ {k a} {A : Set a} {xs : List A} →
-               xs ∼[ ⌊ k ⌋→ ] [] → xs ≡ []
+empty-unique : ∀ {k} → xs ∼[ ⌊ k ⌋→ ] [] → xs ≡ []
 empty-unique {xs = []}    _    = refl
-empty-unique {xs = _ ∷ _} ∷∼[] with ⇒→ ∷∼[] (here refl)
-... | ()
+empty-unique {xs = _ ∷ _} ∷∼[] with () ← ⇒→ ∷∼[] (here refl)
 
 -- _++_ is idempotent (under set equality).
 
-++-idempotent : ∀ {a} {A : Set a} → Idempotent {A = List A} _∼[ set ]_ _++_
-++-idempotent {a} xs {x} =
-  x ∈ xs ++ xs  ∼⟨ FE.equivalence ([ id , id ]′ ∘ _⟨$⟩_ (Inverse.from $ ++↔))
-                                  (_⟨$⟩_ (Inverse.to $ ++↔) ∘ inj₁) ⟩
-  x ∈ xs        ∎
+++-idempotent : Idempotent {A = List A} _∼[ set ]_ _++_
+++-idempotent xs {x} =
+  x ∈ xs ++ xs
+    ∼⟨ mk⇔ ([ id , id ]′ ∘ (Inverse.from $ ++↔)) (Inverse.to ++↔ ∘ inj₁) ⟩
+  x ∈ xs ∎
   where open Related.EquationalReasoning
 
 -- The list monad's bind distributes from the left over _++_.
 
 >>=-left-distributive :
-  ∀ {ℓ} {A B : Set ℓ} (xs : List A) {f g : A → List B} →
+  ∀ (xs : List A) {f g : A → List B} →
   (xs >>= λ x → f x ++ g x) ∼[ bag ] (xs >>= f) ++ (xs >>= g)
 >>=-left-distributive {ℓ} xs {f} {g} {y} =
   y ∈ (xs >>= λ x → f x ++ g x)                      ↔⟨ SK-sym $ >>=↔ ⟩
@@ -279,7 +281,7 @@ empty-unique {xs = _ ∷ _} ∷∼[] with ⇒→ ∷∼[] (here refl)
 -- The same applies to _⊛_.
 
 ⊛-left-distributive :
-  ∀ {ℓ} {A B : Set ℓ} (fs : List (A → B)) xs₁ xs₂ →
+  ∀ (fs : List (A → B)) xs₁ xs₂ →
   (fs ⊛ (xs₁ ++ xs₂)) ∼[ bag ] (fs ⊛ xs₁) ++ (fs ⊛ xs₂)
 ⊛-left-distributive {B = B} fs xs₁ xs₂ = begin
   fs ⊛ (xs₁ ++ xs₂)                       ≡⟨ Applicative.unfold-⊛ fs (xs₁ ++ xs₂) ⟩
@@ -289,20 +291,19 @@ empty-unique {xs = _ ∷ _} ∷∼[] with ⇒→ ∷∼[] (here refl)
                 (xs₂ >>= pure ∘ f))       ≈⟨ >>=-left-distributive fs ⟩
 
   (fs >>= λ f → xs₁ >>= pure ∘ f) ++
-  (fs >>= λ f → xs₂ >>= pure ∘ f)         ≡˘⟨ P.cong₂ _++_ (Applicative.unfold-⊛ fs xs₁) (Applicative.unfold-⊛ fs xs₂) ⟩
+  (fs >>= λ f → xs₂ >>= pure ∘ f)         ≡⟨ ≡.cong₂ _++_ (Applicative.unfold-⊛ fs xs₁) (Applicative.unfold-⊛ fs xs₂) ⟨
 
   (fs ⊛ xs₁) ++ (fs ⊛ xs₂)                ∎
-  where open EqR ([ bag ]-Equality B)
+  where open ≈-Reasoning ([ bag ]-Equality B)
 
 private
 
   -- If x ∷ xs is set equal to x ∷ ys, then xs and ys are not
   -- necessarily set equal.
 
-  ¬-drop-cons : ∀ {a} {A : Set a} {x : A} →
+  ¬-drop-cons : ∀ {x : A} →
     ¬ (∀ {xs ys} → x ∷ xs ∼[ set ] x ∷ ys → xs ∼[ set ] ys)
-  ¬-drop-cons {x = x} drop-cons
-    with FE.Equivalence.to x∼[] ⟨$⟩ here refl
+  ¬-drop-cons {x = x} drop-cons with Equivalence.to x∼[] (here refl)
     where
     x,x≈x :  (x ∷ x ∷ []) ∼[ set ] [ x ]
     x,x≈x = ++-idempotent [ x ]
@@ -313,9 +314,8 @@ private
 
 -- However, the corresponding property does hold for bag equality.
 
-drop-cons : ∀ {a} {A : Set a} {x : A} {xs ys} →
-            x ∷ xs ∼[ bag ] x ∷ ys → xs ∼[ bag ] ys
-drop-cons {A = A} {x} {xs} {ys} x∷xs≈x∷ys =
+drop-cons : ∀ {x : A} {xs ys} → x ∷ xs ∼[ bag ] x ∷ ys → xs ∼[ bag ] ys
+drop-cons {x = x} {xs} {ys} x∷xs≈x∷ys =
   ⊎-left-cancellative
     (∼→⊎↔⊎ x∷xs≈x∷ys)
     (lemma x∷xs≈x∷ys)
@@ -328,21 +328,20 @@ drop-cons {A = A} {x} {xs} {ys} x∷xs≈x∷ys =
   -- List membership can be expressed as "there is an index which
   -- points to the element".
 
-  ∈-index : ∀ {a} {A : Set a} {z}
-            (xs : List A) → z ∈ xs ↔ ∃ λ i → z ≡ lookup xs i
+  ∈-index : ∀ {z} (xs : List A) → z ∈ xs ↔ ∃ λ i → z ≡ lookup xs i
   ∈-index {z = z} [] =
     z ∈ []                              ↔⟨ SK-sym ⊥↔Any[] ⟩
-    ⊥                                   ↔⟨ SK-sym $ inverse (λ { (() , _) }) (λ ()) (λ { (() , _) }) (λ ()) ⟩
+    ⊥                                   ↔⟨ mk↔ₛ′ (λ ()) (λ { (() , _) }) (λ { (() , _) }) (λ ()) ⟩
     (∃ λ (i : Fin 0) → z ≡ lookup [] i)  ∎
     where
     open Related.EquationalReasoning
   ∈-index {z = z} (x ∷ xs) =
     z ∈ x ∷ xs                         ↔⟨ SK-sym (∷↔ _) ⟩
     (z ≡ x ⊎ z ∈ xs)                   ↔⟨ K-refl ⊎-cong ∈-index xs ⟩
-    (z ≡ x ⊎ ∃ λ i → z ≡ lookup xs i)  ↔⟨ SK-sym $ inverse (λ { (zero , p) → inj₁ p; (suc i , p) → inj₂ (i , p) })
-                                                          (λ { (inj₁ p) → zero , p; (inj₂ (i , p)) → suc i , p })
-                                                          (λ { (zero , _) → refl; (suc _ , _) → refl })
-                                                          (λ { (inj₁ _) → refl; (inj₂ _) → refl }) ⟩
+    (z ≡ x ⊎ ∃ λ i → z ≡ lookup xs i)  ↔⟨ mk↔ₛ′ (λ { (inj₁ p) → zero , p; (inj₂ (i , p)) → suc i , p })
+                                                  (λ { (zero , p) → inj₁ p; (suc i , p) → inj₂ (i , p) })
+                                                  (λ { (zero , _) → refl; (suc _ , _) → refl })
+                                                  (λ { (inj₁ _) → refl; (inj₂ _) → refl }) ⟩
     (∃ λ i → z ≡ lookup (x ∷ xs) i)    ∎
     where
     open Related.EquationalReasoning
@@ -351,7 +350,7 @@ drop-cons {A = A} {x} {xs} {ys} x∷xs≈x∷ys =
 
   index-of : ∀ {a} {A : Set a} {z} {xs : List A} →
              z ∈ xs → Fin (length xs)
-  index-of = proj₁ ∘ (Inverse.to (∈-index _) ⟨$⟩_)
+  index-of = proj₁ ∘ (Inverse.to (∈-index _))
 
   -- The type ∃ λ z → z ∈ xs is isomorphic to Fin n, where n is the
   -- length of xs.
@@ -364,7 +363,7 @@ drop-cons {A = A} {x} {xs} {ys} x∷xs≈x∷ys =
   Fin-length xs =
     (∃ λ z → z ∈ xs)                   ↔⟨ Σ.cong K-refl (∈-index xs) ⟩
     (∃ λ z → ∃ λ i → z ≡ lookup xs i)  ↔⟨ ∃∃↔∃∃ _ ⟩
-    (∃ λ i → ∃ λ z → z ≡ lookup xs i)  ↔⟨ Σ.cong K-refl (inverse _ (λ _ → _ , refl) (λ { (_ , refl) → refl }) (λ _ → refl)) ⟩
+    (∃ λ i → ∃ λ z → z ≡ lookup xs i)  ↔⟨ Σ.cong K-refl (mk↔ₛ′ _ (λ _ → _ , refl) (λ _ → refl) (λ { (_ , refl) → refl })) ⟩
     (Fin (length xs) × ⊤)              ↔⟨ ×-identityʳ _ _ ⟩
     Fin (length xs)                    ∎
     where
@@ -389,33 +388,33 @@ drop-cons {A = A} {x} {xs} {ys} x∷xs≈x∷ys =
   index-of-commutes :
     ∀ {a} {A : Set a} {z : A} {xs ys} →
     (xs≈ys : xs ∼[ bag ] ys) (p : z ∈ xs) →
-    index-of (Inverse.to xs≈ys ⟨$⟩ p) ≡
-    Inverse.to (Fin-length-cong xs≈ys) ⟨$⟩ index-of p
+    index-of (Inverse.to xs≈ys p) ≡
+    Inverse.to (Fin-length-cong xs≈ys) (index-of p)
   index-of-commutes {z = z} {xs} {ys} xs≈ys p =
-    index-of (to xs≈ys ⟨$⟩ p)                                        ≡⟨ lemma z p ⟩
+    index-of (to xs≈ys p)                                        ≡⟨ lemma z p ⟩
 
-    index-of (to xs≈ys ⟨$⟩ proj₂
-      (from (Fin-length xs) ⟨$⟩ (to (Fin-length xs) ⟨$⟩ (z , p))))   ≡⟨⟩
+    index-of (to xs≈ys (proj₂
+      (from (Fin-length xs) (to (Fin-length xs) (z , p)))))   ≡⟨⟩
 
-    index-of (proj₂ (Prod.map id (to xs≈ys ⟨$⟩_)
-      (from (Fin-length xs) ⟨$⟩ (to (Fin-length xs) ⟨$⟩ (z , p)))))  ≡⟨⟩
+    index-of (proj₂ (Product.map₂ (to xs≈ys)
+      (from (Fin-length xs) (to (Fin-length xs) (z , p)))))   ≡⟨⟩
 
-    to (Fin-length ys) ⟨$⟩ Prod.map id (to xs≈ys ⟨$⟩_)
-      (from (Fin-length xs) ⟨$⟩ index-of p)                          ≡⟨⟩
+    to (Fin-length ys) (Product.map₂ (to xs≈ys)
+      (from (Fin-length xs) (index-of p)))                    ≡⟨⟩
 
-    to (Fin-length-cong xs≈ys) ⟨$⟩ index-of p                        ∎
+    to (Fin-length-cong xs≈ys) (index-of p)                   ∎
     where
-    open P.≡-Reasoning
+    open ≡-Reasoning
     open Inverse
 
     lemma :
       ∀ z p →
-      index-of (to xs≈ys ⟨$⟩ p) ≡
-      index-of (to xs≈ys ⟨$⟩ proj₂
-        (from (Fin-length xs) ⟨$⟩ (to (Fin-length xs) ⟨$⟩ (z , p))))
-    lemma z p with to (Fin-length xs) ⟨$⟩ (z , p)
-                 | left-inverse-of (Fin-length xs) (z , p)
-    lemma .(lookup xs i) .(from (∈-index xs) ⟨$⟩ (i , refl)) | i | refl =
+      index-of (to xs≈ys p) ≡
+      index-of (to xs≈ys (proj₂
+        (from (Fin-length xs) (to (Fin-length xs) (z , p)))))
+    lemma z p with to (Fin-length xs) (z , p)
+                 | strictlyInverseʳ (Fin-length xs) (z , p)
+    lemma .(lookup xs i) .(from (∈-index xs) (i , refl)) | i | refl =
       refl
 
   -- Bag equivalence isomorphisms preserve index equality. Note that
@@ -427,15 +426,15 @@ drop-cons {A = A} {x} {xs} {ys} x∷xs≈x∷ys =
     ∀ {a} {A : Set a} {z : A} {xs ys} {p q : z ∈ xs}
     (xs≈ys : xs ∼[ bag ] ys) →
     index-of p ≡ index-of q →
-    index-of (Inverse.to xs≈ys ⟨$⟩ p) ≡
-    index-of (Inverse.to xs≈ys ⟨$⟩ q)
+    index-of (Inverse.to xs≈ys p) ≡
+    index-of (Inverse.to xs≈ys q)
   index-equality-preserved {p = p} {q} xs≈ys eq =
-    index-of (Inverse.to xs≈ys ⟨$⟩ p)                  ≡⟨ index-of-commutes xs≈ys p ⟩
-    Inverse.to (Fin-length-cong xs≈ys) ⟨$⟩ index-of p  ≡⟨ P.cong (Inverse.to (Fin-length-cong xs≈ys) ⟨$⟩_) eq ⟩
-    Inverse.to (Fin-length-cong xs≈ys) ⟨$⟩ index-of q  ≡⟨ P.sym $ index-of-commutes xs≈ys q ⟩
-    index-of (Inverse.to xs≈ys ⟨$⟩ q)                  ∎
+    index-of (Inverse.to xs≈ys p)                   ≡⟨ index-of-commutes xs≈ys p ⟩
+    Inverse.to (Fin-length-cong xs≈ys) (index-of p) ≡⟨ ≡.cong (Inverse.to (Fin-length-cong xs≈ys)) eq ⟩
+    Inverse.to (Fin-length-cong xs≈ys) (index-of q) ≡⟨ ≡.sym $ index-of-commutes xs≈ys q ⟩
+    index-of (Inverse.to xs≈ys q)                   ∎
     where
-    open P.≡-Reasoning
+    open ≡-Reasoning
 
   -- The old inspect idiom.
 
@@ -457,14 +456,14 @@ drop-cons {A = A} {x} {xs} {ys} x∷xs≈x∷ys =
   ⊎-left-cancellative :
     ∀ {a b c} {A : Set a} {B : Set b} {C : Set c}
     (f : (A ⊎ B) ↔ (A ⊎ C)) →
-    Well-behaved (Inverse.to   f ⟨$⟩_) →
-    Well-behaved (Inverse.from f ⟨$⟩_) →
+    Well-behaved (Inverse.to   f) →
+    Well-behaved (Inverse.from f) →
     B ↔ C
-  ⊎-left-cancellative {A = A} = λ inv to-hyp from-hyp → inverse
-    (g (to   inv ⟨$⟩_) to-hyp)
-    (g (from inv ⟨$⟩_) from-hyp)
-    (g∘g         inv  to-hyp from-hyp)
+  ⊎-left-cancellative {A = A} = λ inv to-hyp from-hyp → mk↔ₛ′
+    (g (to   inv) to-hyp)
+    (g (from inv) from-hyp)
     (g∘g (SK-sym inv) from-hyp to-hyp)
+    (g∘g         inv  to-hyp from-hyp)
     where
     open Inverse
 
@@ -490,44 +489,44 @@ drop-cons {A = A} {x} {xs} {ys} x∷xs≈x∷ys =
 
     g∘g : ∀ {b c} {B : Set b} {C : Set c}
           (f : (A ⊎ B) ↔ (A ⊎ C)) →
-          (to-hyp   : Well-behaved (to   f ⟨$⟩_)) →
-          (from-hyp : Well-behaved (from f ⟨$⟩_)) →
-          ∀ b → g (from f ⟨$⟩_) from-hyp (g (to f ⟨$⟩_) to-hyp b) ≡ b
+          (to-hyp   : Well-behaved (to   f)) →
+          (from-hyp : Well-behaved (from f)) →
+          ∀ b → g (from f) from-hyp (g (to f) to-hyp b) ≡ b
     g∘g f to-hyp from-hyp b = g∘g′
       where
-      open P.≡-Reasoning
-
-      g∘g′ : g (from f ⟨$⟩_) from-hyp (g (to f ⟨$⟩_) to-hyp b) ≡ b
-      g∘g′ with inspect (to f ⟨$⟩ inj₂ b)
-      g∘g′ | inj₂ c , eq₁ with inspect (from f ⟨$⟩ inj₂ c)
-      g∘g′ | inj₂ c , eq₁ | inj₂ b′ , eq₂ = inj₂-injective (
-                                              inj₂ b′            ≡⟨ P.sym eq₂ ⟩
-                                              from f ⟨$⟩ inj₂ c  ≡⟨ to-from f eq₁ ⟩
-                                              inj₂ b             ∎)
-      g∘g′ | inj₂ c , eq₁ | inj₁ a  , eq₂ with
-        inj₁ a             ≡⟨ P.sym eq₂ ⟩
-        from f ⟨$⟩ inj₂ c  ≡⟨ to-from f eq₁ ⟩
+      open ≡-Reasoning
+
+      g∘g′ : g (from f) from-hyp (g (to f) to-hyp b) ≡ b
+      g∘g′ with inspect (to f (inj₂ b))
+      g∘g′ | inj₂ c , eq₁ with inspect (from f (inj₂ c))
+      ...   | inj₂ b′ , eq₂ = inj₂-injective (
+        inj₂ b′            ≡⟨ ≡.sym eq₂ ⟩
+        from f (inj₂ c)   ≡⟨ to-from f eq₁ ⟩
+        inj₂ b            ∎)
+      ...   | inj₁ a  , eq₂ with
+        inj₁ a             ≡⟨ ≡.sym eq₂ ⟩
+        from f (inj₂ c)    ≡⟨ to-from f eq₁ ⟩
         inj₂ b             ∎
       ... | ()
-      g∘g′ | inj₁ a , eq₁ with inspect (to f ⟨$⟩ inj₁ a)
+      g∘g′ | inj₁ a , eq₁ with inspect (to f (inj₁ a))
       g∘g′ | inj₁ a , eq₁ | inj₁ a′ , eq₂ = ⊥-elim $ to-hyp eq₁ eq₂
-      g∘g′ | inj₁ a , eq₁ | inj₂ c  , eq₂ with inspect (from f ⟨$⟩ inj₂ c)
+      g∘g′ | inj₁ a , eq₁ | inj₂ c  , eq₂ with inspect (from f (inj₂ c))
       g∘g′ | inj₁ a , eq₁ | inj₂ c  , eq₂ | inj₂ b′ , eq₃ with
-        inj₁ a             ≡⟨ P.sym $ to-from f eq₂ ⟩
-        from f ⟨$⟩ inj₂ c  ≡⟨ eq₃ ⟩
+        inj₁ a             ≡⟨ ≡.sym (to-from f eq₂) ⟩
+        from f (inj₂ c)    ≡⟨ eq₃ ⟩
         inj₂ b′            ∎
       ... | ()
-      g∘g′ | inj₁ a , eq₁ | inj₂ c  , eq₂ | inj₁ a′ , eq₃ with inspect (from f ⟨$⟩ inj₁ a′)
+      g∘g′ | inj₁ a , eq₁ | inj₂ c  , eq₂ | inj₁ a′ , eq₃ with inspect (from f $ inj₁ a′)
       g∘g′ | inj₁ a , eq₁ | inj₂ c  , eq₂ | inj₁ a′ , eq₃ | inj₁ a″ , eq₄ = ⊥-elim $ from-hyp eq₃ eq₄
       g∘g′ | inj₁ a , eq₁ | inj₂ c  , eq₂ | inj₁ a′ , eq₃ | inj₂ b′ , eq₄ = inj₂-injective (
         let lemma =
-              inj₁ a′            ≡⟨ P.sym eq₃ ⟩
-              from f ⟨$⟩ inj₂ c  ≡⟨ to-from f eq₂ ⟩
+              inj₁ a′            ≡⟨ ≡.sym eq₃ ⟩
+              from f (inj₂ c)    ≡⟨ to-from f eq₂ ⟩
               inj₁ a             ∎
         in
-        inj₂ b′             ≡⟨ P.sym eq₄ ⟩
-        from f ⟨$⟩ inj₁ a′  ≡⟨ P.cong ((from f ⟨$⟩_) ∘ inj₁) $ inj₁-injective lemma ⟩
-        from f ⟨$⟩ inj₁ a   ≡⟨ to-from f eq₁ ⟩
+        inj₂ b′             ≡⟨ ≡.sym eq₄ ⟩
+        from f (inj₁ a′)    ≡⟨ ≡.cong (from f ∘ inj₁) $ inj₁-injective lemma ⟩
+        from f (inj₁ a)     ≡⟨ to-from f eq₁ ⟩
         inj₂ b              ∎)
 
   -- Some final lemmas.
@@ -536,7 +535,7 @@ drop-cons {A = A} {x} {xs} {ys} x∷xs≈x∷ys =
     ∀ {x : A} {xs ys} →
     x ∷ xs ∼[ bag ] x ∷ ys →
     ∀ {z} → (z ≡ x ⊎ z ∈ xs) ↔ (z ≡ x ⊎ z ∈ ys)
-  ∼→⊎↔⊎ {x} {xs} {ys} x∷xs≈x∷ys {z} =
+  ∼→⊎↔⊎ {x = x} {xs} {ys} x∷xs≈x∷ys {z} =
     (z ≡ x ⊎ z ∈ xs)  ↔⟨ ∷↔ _ ⟩
     z ∈ x ∷ xs        ↔⟨ x∷xs≈x∷ys ⟩
     z ∈ x ∷ ys        ↔⟨ SK-sym (∷↔ _) ⟩
@@ -545,65 +544,60 @@ drop-cons {A = A} {x} {xs} {ys} x∷xs≈x∷ys =
     open Related.EquationalReasoning
 
   lemma : ∀ {xs ys} (inv : x ∷ xs ∼[ bag ] x ∷ ys) {z} →
-          Well-behaved (Inverse.to (∼→⊎↔⊎ inv {z}) ⟨$⟩_)
-  lemma {xs} inv {b = z∈xs} {a = p} {a′ = q} hyp₁ hyp₂ with
-    zero                                                                  ≡⟨⟩
-    index-of {xs = x ∷ xs} (here p)                                       ≡⟨⟩
-    index-of {xs = x ∷ xs} (to (∷↔ _) ⟨$⟩ inj₁ p)                         ≡⟨ P.cong (index-of ∘ (to (∷↔ (_ ≡_)) ⟨$⟩_)) $ P.sym $
-                                                                               to-from (∼→⊎↔⊎ inv) {x = inj₁ p} hyp₂ ⟩
-    index-of {xs = x ∷ xs} (to (∷↔ _) ⟨$⟩ (from (∼→⊎↔⊎ inv) ⟨$⟩ inj₁ q))  ≡⟨ P.cong index-of $
-                                                                               right-inverse-of (∷↔ _) (from inv ⟨$⟩ here q) ⟩
-    index-of {xs = x ∷ xs} (to (SK-sym inv) ⟨$⟩ here q)                   ≡⟨ index-equality-preserved (SK-sym inv) refl ⟩
-    index-of {xs = x ∷ xs} (to (SK-sym inv) ⟨$⟩ here p)                   ≡⟨ P.cong index-of $ P.sym $
-                                                                               right-inverse-of (∷↔ _) (from inv ⟨$⟩ here p) ⟩
-    index-of {xs = x ∷ xs} (to (∷↔ _) ⟨$⟩ (from (∼→⊎↔⊎ inv) ⟨$⟩ inj₁ p))  ≡⟨ P.cong (index-of ∘ (to (∷↔ (_ ≡_)) ⟨$⟩_)) $
-                                                                               to-from (∼→⊎↔⊎ inv) {x = inj₂ z∈xs} hyp₁ ⟩
-    index-of {xs = x ∷ xs} (to (∷↔ _) ⟨$⟩ inj₂ z∈xs)                      ≡⟨⟩
-    index-of {xs = x ∷ xs} (there z∈xs)                                   ≡⟨⟩
-    suc (index-of {xs = xs} z∈xs)                                         ∎
+          Well-behaved (Inverse.to (∼→⊎↔⊎ inv {z}))
+  lemma {xs} inv {b = z∈xs} {a = p} {a′ = q} hyp₁ hyp₂ = case contra of λ ()
     where
     open Inverse
-    open P.≡-Reasoning
-  ... | ()
+    open ≡-Reasoning
+    contra : zero ≡ suc (index-of {xs = xs} z∈xs)
+    contra = begin
+      zero
+        ≡⟨⟩
+      index-of {xs = x ∷ xs} (here p)
+        ≡⟨⟩
+      index-of {xs = x ∷ xs} (to (∷↔ _) $ inj₁ p)
+        ≡⟨ ≡.cong (index-of ∘ (to (∷↔ (_ ≡_)))) $ to-from (∼→⊎↔⊎ inv) {x = inj₁ p} hyp₂ ⟨
+      index-of {xs = x ∷ xs} (to (∷↔ _) $ (from (∼→⊎↔⊎ inv) $ inj₁ q))
+        ≡⟨ ≡.cong index-of $ strictlyInverseˡ (∷↔ _) (from inv (here q)) ⟩
+      index-of {xs = x ∷ xs} (to (SK-sym inv) $ here q)
+        ≡⟨ index-equality-preserved (SK-sym inv) refl ⟩
+      index-of {xs = x ∷ xs} (to (SK-sym inv) $ here p)
+        ≡⟨ ≡.cong index-of $ strictlyInverseˡ (∷↔ _) (from inv (here p)) ⟨
+      index-of {xs = x ∷ xs} (to (∷↔ _) (from (∼→⊎↔⊎ inv) $ inj₁ p))
+        ≡⟨ ≡.cong (index-of ∘ (to (∷↔ (_ ≡_)))) $ to-from (∼→⊎↔⊎ inv) {x = inj₂ z∈xs} hyp₁ ⟩
+      index-of {xs = x ∷ xs} (to (∷↔ _) $ inj₂ z∈xs)
+        ≡⟨⟩
+      index-of {xs = x ∷ xs} (there z∈xs)
+        ≡⟨⟩
+      suc (index-of {xs = xs} z∈xs)
+        ∎
+
 
 ------------------------------------------------------------------------
 -- Relationships to other relations
 
-module _ {a} {A : Set a} where
+↭⇒∼bag : _↭_ {A = A} ⇒ _∼[ bag ]_
+↭⇒∼bag xs↭ys {v} = mk↔ₛ′ (to xs↭ys) (from xs↭ys) (to∘from xs↭ys) (from∘to xs↭ys)
+  where
+  to : ∀ {xs ys} → xs ↭ ys → v ∈ xs → v ∈ ys
+  to xs↭ys = ∈-resp-↭ xs↭ys
+
+  from : ∀ {xs ys} → xs ↭ ys → v ∈ ys → v ∈ xs
+  from xs↭ys = ∈-resp-↭ (↭-sym xs↭ys)
 
-  ↭⇒∼bag : _↭_ ⇒ _∼[ bag ]_
-  ↭⇒∼bag xs↭ys {v} = inverse (to xs↭ys) (from xs↭ys) (from∘to xs↭ys) (to∘from xs↭ys)
-    where
-    to : ∀ {xs ys} → xs ↭ ys → v ∈ xs → v ∈ ys
-    to xs↭ys = Any-resp-↭ {A = A} xs↭ys
-
-    from : ∀ {xs ys} → xs ↭ ys → v ∈ ys → v ∈ xs
-    from xs↭ys = Any-resp-↭ (↭-sym xs↭ys)
-
-    from∘to : ∀ {xs ys} (p : xs ↭ ys) (q : v ∈ xs) → from p (to p q) ≡ q
-    from∘to refl          v∈xs                 = refl
-    from∘to (prep _ _)    (here refl)          = refl
-    from∘to (prep _ p)    (there v∈xs)         = P.cong there (from∘to p v∈xs)
-    from∘to (swap x y p)  (here refl)          = refl
-    from∘to (swap x y p)  (there (here refl))  = refl
-    from∘to (swap x y p)  (there (there v∈xs)) = P.cong (there ∘ there) (from∘to p v∈xs)
-    from∘to (trans p₁ p₂) v∈xs
-      rewrite from∘to p₂ (Any-resp-↭ p₁ v∈xs)
-            | from∘to p₁ v∈xs                  = refl
-
-    to∘from : ∀ {xs ys} (p : xs ↭ ys) (q : v ∈ ys) → to p (from p q) ≡ q
-    to∘from p with from∘to (↭-sym p)
-    ... | res rewrite ↭-sym-involutive p = res
-
-  ∼bag⇒↭ : _∼[ bag ]_ ⇒ _↭_
-  ∼bag⇒↭ {[]} eq with empty-unique {A = A} (Inv.sym eq)
-  ... | refl = refl
-  ∼bag⇒↭ {x ∷ xs} eq with ∈-∃++ (to ⟨$⟩ (here P.refl))
-    where open Inv.Inverse (eq {x})
-  ... | zs₁ , zs₂ , p rewrite p = begin
-    x ∷ xs           <⟨ ∼bag⇒↭ (drop-cons (Inv._∘_ (comm zs₁ (x ∷ zs₂)) eq)) ⟩
+  from∘to : ∀ {xs ys} (p : xs ↭ ys) (q : v ∈ xs) → from p (to p q) ≡ q
+  from∘to = ∈-resp-[σ⁻¹∘σ]
+
+  to∘from : ∀ {xs ys} (p : xs ↭ ys) (q : v ∈ ys) → to p (from p q) ≡ q
+  to∘from p with res ← from∘to (↭-sym p) rewrite ↭-sym-involutive p = res
+
+∼bag⇒↭ : _∼[ bag ]_ ⇒ _↭_ {A = A}
+∼bag⇒↭ {A = A} {[]} eq with refl ← empty-unique (↔-sym eq) = refl
+∼bag⇒↭ {A = A} {x ∷ xs} eq
+  with zs₁ , zs₂ , p ← ∈-∃++ (Inverse.to (eq {x}) (here ≡.refl)) rewrite p = begin
+    x ∷ xs           <⟨ ∼bag⇒↭ (drop-cons (↔-trans eq (comm zs₁ (x ∷ zs₂)))) ⟩
     x ∷ (zs₂ ++ zs₁) <⟨ ++-comm zs₂ zs₁ ⟩
-    x ∷ (zs₁ ++ zs₂) ↭˘⟨ shift x zs₁ zs₂ ⟩
+    x ∷ (zs₁ ++ zs₂) ↭⟨ shift x zs₁ zs₂ ⟨
     zs₁ ++ x ∷ zs₂   ∎
     where
     open CommutativeMonoid (commutativeMonoid bag A)
diff --git a/src/Data/List/Relation/Binary/Disjoint/DecPropositional.agda b/src/Data/List/Relation/Binary/Disjoint/DecPropositional.agda
new file mode 100644
index 0000000000..82d39c261f
--- /dev/null
+++ b/src/Data/List/Relation/Binary/Disjoint/DecPropositional.agda
@@ -0,0 +1,21 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Decidability of the disjoint relation over propositional equality.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Definitions using (DecidableEquality)
+
+module Data.List.Relation.Binary.Disjoint.DecPropositional
+  {a} {A : Set a} (_≟_ : DecidableEquality A)
+  where
+
+------------------------------------------------------------------------
+-- Re-export core definitions and operations
+
+open import Data.List.Relation.Binary.Disjoint.Propositional {A = A} public
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
+open import Data.List.Relation.Binary.Disjoint.DecSetoid (decSetoid _≟_) public
+  using (disjoint?)
diff --git a/src/Data/List/Relation/Binary/Disjoint/DecSetoid.agda b/src/Data/List/Relation/Binary/Disjoint/DecSetoid.agda
new file mode 100644
index 0000000000..68b0f2b0a6
--- /dev/null
+++ b/src/Data/List/Relation/Binary/Disjoint/DecSetoid.agda
@@ -0,0 +1,29 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Decidability of the disjoint relation over setoid equality.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Bundles using (DecSetoid)
+
+module Data.List.Relation.Binary.Disjoint.DecSetoid {c ℓ} (S : DecSetoid c ℓ) where
+
+open import Data.Product.Base using (_,_)
+open import Data.List.Relation.Unary.Any using (map)
+open import Data.List.Relation.Unary.All using (all?; lookupₛ)
+open import Data.List.Relation.Unary.All.Properties using (¬All⇒Any¬)
+open import Relation.Binary.Definitions using (Decidable)
+open import Relation.Nullary using (yes; no; decidable-stable)
+open DecSetoid S
+open import Data.List.Relation.Binary.Equality.DecSetoid S
+open import Data.List.Relation.Binary.Disjoint.Setoid setoid public
+open import Data.List.Membership.DecSetoid S
+
+disjoint? : Decidable Disjoint
+disjoint? xs ys with all? (_∉? ys) xs
+... | yes xs♯ys = yes λ (v∈ , v∈′) →
+  lookupₛ setoid (λ x≈y ∉ys ∈ys → ∉ys (map (trans x≈y) ∈ys)) xs♯ys v∈ v∈′
+... | no ¬xs♯ys = let (x , x∈ , ¬∉ys) = find (¬All⇒Any¬ (_∉? _) _ ¬xs♯ys) in
+  no λ p → p (x∈ , decidable-stable (_ ∈? _) ¬∉ys)
diff --git a/src/Data/List/Relation/Binary/Disjoint/Propositional.agda b/src/Data/List/Relation/Binary/Disjoint/Propositional.agda
index ecae6c7610..f60f275b89 100644
--- a/src/Data/List/Relation/Binary/Disjoint/Propositional.agda
+++ b/src/Data/List/Relation/Binary/Disjoint/Propositional.agda
@@ -6,12 +6,10 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
-
 module Data.List.Relation.Binary.Disjoint.Propositional
   {a} {A : Set a} where
 
-open import Relation.Binary.PropositionalEquality using (setoid)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 open import Data.List.Relation.Binary.Disjoint.Setoid as DisjointUnique
 
 ------------------------------------------------------------------------
diff --git a/src/Data/List/Relation/Binary/Disjoint/Setoid.agda b/src/Data/List/Relation/Binary/Disjoint/Setoid.agda
index d5003aab4e..d912c28825 100644
--- a/src/Data/List/Relation/Binary/Disjoint/Setoid.agda
+++ b/src/Data/List/Relation/Binary/Disjoint/Setoid.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Relation.Binary.Disjoint.Setoid {c ℓ} (S : Setoid c ℓ) where
 
@@ -15,7 +16,7 @@ open import Relation.Nullary.Negation using (¬_)
 open import Function.Base using (_∘_)
 open import Data.List.Base using (List; []; [_]; _∷_)
 open import Data.List.Relation.Unary.Any using (here; there)
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 
 open Setoid S renaming (Carrier to A)
 open import Data.List.Membership.Setoid S using (_∈_; _∉_)
diff --git a/src/Data/List/Relation/Binary/Disjoint/Setoid/Properties.agda b/src/Data/List/Relation/Binary/Disjoint/Setoid/Properties.agda
index 3f0701a8ef..bc5a95fc77 100644
--- a/src/Data/List/Relation/Binary/Disjoint/Setoid/Properties.agda
+++ b/src/Data/List/Relation/Binary/Disjoint/Setoid/Properties.agda
@@ -14,9 +14,10 @@ import Data.List.Relation.Unary.Any as Any
 open import Data.List.Relation.Unary.All as All
 open import Data.List.Relation.Unary.All.Properties using (¬Any⇒All¬)
 open import Data.List.Relation.Unary.Any.Properties using (++⁻)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Data.Sum.Base using (inj₁; inj₂)
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (Symmetric)
 open import Relation.Nullary.Negation using (¬_)
 
 ------------------------------------------------------------------------
diff --git a/src/Data/List/Relation/Binary/Equality/DecPropositional.agda b/src/Data/List/Relation/Binary/Equality/DecPropositional.agda
index 6410ef418c..8f6b20ec99 100644
--- a/src/Data/List/Relation/Binary/Equality/DecPropositional.agda
+++ b/src/Data/List/Relation/Binary/Equality/DecPropositional.agda
@@ -10,16 +10,16 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Definitions using (DecidableEquality)
 
 module Data.List.Relation.Binary.Equality.DecPropositional
-  {a} {A : Set a} (_≟_ : Decidable {A = A} _≡_) where
+  {a} {A : Set a} (_≟_ : DecidableEquality A) where
 
 open import Data.List.Base using (List)
 open import Data.List.Properties using (≡-dec)
 import Data.List.Relation.Binary.Equality.Propositional as PropositionalEq
 import Data.List.Relation.Binary.Equality.DecSetoid as DecSetoidEq
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
 
 ------------------------------------------------------------------------
 -- Publically re-export everything from decSetoid and propositional
@@ -32,5 +32,7 @@ open DecSetoidEq (decSetoid _≟_) public
 ------------------------------------------------------------------------
 -- Additional proofs
 
-_≡?_ : Decidable (_≡_ {A = List A})
+infix 4 _≡?_
+
+_≡?_ : DecidableEquality (List A)
 _≡?_ = ≡-dec _≟_
diff --git a/src/Data/List/Relation/Binary/Equality/DecSetoid.agda b/src/Data/List/Relation/Binary/Equality/DecSetoid.agda
index 45f73c0902..670e3c981b 100644
--- a/src/Data/List/Relation/Binary/Equality/DecSetoid.agda
+++ b/src/Data/List/Relation/Binary/Equality/DecSetoid.agda
@@ -6,7 +6,9 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (DecSetoid)
+open import Relation.Binary.Structures using (IsDecEquivalence)
+open import Relation.Binary.Definitions using (Decidable)
 
 module Data.List.Relation.Binary.Equality.DecSetoid
   {a ℓ} (DS : DecSetoid a ℓ) where
@@ -14,7 +16,7 @@ module Data.List.Relation.Binary.Equality.DecSetoid
 import Data.List.Relation.Binary.Equality.Setoid as SetoidEquality
 import Data.List.Relation.Binary.Pointwise as PW
 open import Level
-open import Relation.Binary using (Decidable)
+open import Relation.Binary.Definitions using (Decidable)
 open DecSetoid DS
 
 ------------------------------------------------------------------------
diff --git a/src/Data/List/Relation/Binary/Equality/Propositional.agda b/src/Data/List/Relation/Binary/Equality/Propositional.agda
index f263778211..ffae515086 100644
--- a/src/Data/List/Relation/Binary/Equality/Propositional.agda
+++ b/src/Data/List/Relation/Binary/Equality/Propositional.agda
@@ -10,25 +10,26 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (_⇒_)
 
 module Data.List.Relation.Binary.Equality.Propositional {a} {A : Set a} where
 
 open import Data.List.Base
 import Data.List.Relation.Binary.Equality.Setoid as SetoidEquality
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 ------------------------------------------------------------------------
 -- Re-export everything from setoid equality
 
-open SetoidEquality (P.setoid A) public
+open SetoidEquality (≡.setoid A) public
 
 ------------------------------------------------------------------------
 -- ≋ is propositional
 
 ≋⇒≡ : _≋_ ⇒ _≡_
-≋⇒≡ []               = P.refl
-≋⇒≡ (P.refl ∷ xs≈ys) = P.cong (_ ∷_) (≋⇒≡ xs≈ys)
+≋⇒≡ []             = refl
+≋⇒≡ (refl ∷ xs≈ys) = cong (_ ∷_) (≋⇒≡ xs≈ys)
 
 ≡⇒≋ : _≡_ ⇒ _≋_
-≡⇒≋ P.refl = ≋-refl
+≡⇒≋ refl = ≋-refl
diff --git a/src/Data/List/Relation/Binary/Equality/Setoid.agda b/src/Data/List/Relation/Binary/Equality/Setoid.agda
index f1ed5f457c..0253c55460 100644
--- a/src/Data/List/Relation/Binary/Equality/Setoid.agda
+++ b/src/Data/List/Relation/Binary/Equality/Setoid.agda
@@ -6,20 +6,22 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Algebra.Core using (Op₂)
-open import Relation.Binary using (Setoid)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Relation.Binary.Equality.Setoid {a ℓ} (S : Setoid a ℓ) where
-
+open import Algebra.Core using (Op₂)
 open import Data.Fin.Base using (Fin)
-open import Data.List.Base
+open import Data.List.Base using (List; length; map; foldr; _++_; concat;
+  tabulate; filter; _ʳ++_; reverse)
 open import Data.List.Relation.Binary.Pointwise as PW using (Pointwise)
 open import Data.List.Relation.Unary.Unique.Setoid S using (Unique)
 open import Function.Base using (_∘_)
-open import Level
-open import Relation.Binary renaming (Rel to Rel₂)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Core using (_⇒_; _Preserves_⟶_) renaming (Rel to Rel₂)
+open import Relation.Binary.Definitions using (Transitive; Symmetric; Reflexive; _Respects_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Binary.Properties.Setoid S using (≉-resp₂)
+open import Relation.Binary.Structures using (IsEquivalence)
 open import Relation.Unary as U using (Pred)
 
 open Setoid S renaming (Carrier to A)
@@ -48,7 +50,7 @@ open PW public
 ≋-refl = PW.refl refl
 
 ≋-reflexive : _≡_ ⇒ _≋_
-≋-reflexive P.refl = ≋-refl
+≋-reflexive ≡.refl = ≋-refl
 
 ≋-sym : Symmetric _≋_
 ≋-sym = PW.symmetric sym
diff --git a/src/Data/List/Relation/Binary/Equality/Setoid/Properties.agda b/src/Data/List/Relation/Binary/Equality/Setoid/Properties.agda
new file mode 100644
index 0000000000..fea2638f66
--- /dev/null
+++ b/src/Data/List/Relation/Binary/Equality/Setoid/Properties.agda
@@ -0,0 +1,59 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Properties of List modulo ≋
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Bundles using (Setoid)
+
+module Data.List.Relation.Binary.Equality.Setoid.Properties
+  {c ℓ} (S : Setoid c ℓ)
+  where
+
+open import Algebra.Bundles using (Magma; Semigroup; Monoid)
+import Algebra.Structures as Structures
+open import Data.List.Base using (List; []; _++_)
+import Data.List.Properties as List
+import Data.List.Relation.Binary.Equality.Setoid as ≋
+open import Data.Product.Base using (_,_)
+open import Function.Base using (_∘_)
+open import Level using (_⊔_)
+
+open ≋ S using (_≋_; ≋-refl; ≋-reflexive; ≋-isEquivalence; ++⁺)
+open Structures _≋_ using (IsMagma; IsSemigroup; IsMonoid)
+
+------------------------------------------------------------------------
+-- The []-++-Monoid
+
+-- Structures
+
+isMagma : IsMagma _++_
+isMagma = record
+  { isEquivalence = ≋-isEquivalence
+  ; ∙-cong = ++⁺
+  }
+
+isSemigroup : IsSemigroup _++_
+isSemigroup = record
+  { isMagma = isMagma
+  ; assoc = λ xs ys zs → ≋-reflexive (List.++-assoc xs ys zs)
+  }
+
+isMonoid : IsMonoid _++_ []
+isMonoid = record
+  { isSemigroup = isSemigroup
+  ; identity = (λ _ → ≋-refl) , ≋-reflexive ∘ List.++-identityʳ
+  }
+
+-- Bundles
+
+magma : Magma c (c ⊔ ℓ)
+magma = record { isMagma = isMagma }
+
+semigroup : Semigroup c (c ⊔ ℓ)
+semigroup = record { isSemigroup = isSemigroup }
+
+monoid : Monoid c (c ⊔ ℓ)
+monoid = record { isMonoid = isMonoid }
diff --git a/src/Data/List/Relation/Binary/Infix/Heterogeneous.agda b/src/Data/List/Relation/Binary/Infix/Heterogeneous.agda
index c9668fa1ec..8a5b239eb0 100644
--- a/src/Data/List/Relation/Binary/Infix/Heterogeneous.agda
+++ b/src/Data/List/Relation/Binary/Infix/Heterogeneous.agda
@@ -9,7 +9,7 @@
 module Data.List.Relation.Binary.Infix.Heterogeneous where
 
 open import Level
-open import Relation.Binary using (REL; _⇒_)
+open import Relation.Binary.Core using (REL; _⇒_)
 open import Data.List.Base as List using (List; []; _∷_; _++_)
 open import Data.List.Relation.Binary.Pointwise
   using (Pointwise)
@@ -49,10 +49,8 @@ map R⇒S (here pref) = here (Prefix.map R⇒S pref)
 map R⇒S (there inf) = there (map R⇒S inf)
 
 toView : ∀ {as bs} → Infix R as bs → View R as bs
-toView (here p) with Prefix.toView p
-...| inf Prefix.++ suff = MkView [] inf suff
-toView (there p) with toView p
-... | MkView pref inf suff = MkView (_ ∷ pref) inf suff
+toView (here p)  with inf Prefix.++ suff ← Prefix.toView p = MkView [] inf suff
+toView (there p) with MkView pref inf suff ← toView p      = MkView (_ ∷ pref) inf suff
 
 fromView : ∀ {as bs} → View R as bs → Infix R as bs
 fromView (MkView []         inf suff) = here (Prefix.fromView (inf Prefix.++ suff))
diff --git a/src/Data/List/Relation/Binary/Infix/Heterogeneous/Properties.agda b/src/Data/List/Relation/Binary/Infix/Heterogeneous/Properties.agda
index 9366b5a027..7e85ae8661 100644
--- a/src/Data/List/Relation/Binary/Infix/Heterogeneous/Properties.agda
+++ b/src/Data/List/Relation/Binary/Infix/Heterogeneous/Properties.agda
@@ -13,21 +13,21 @@ open import Data.Bool.Base using (true; false)
 open import Data.Empty using (⊥-elim)
 open import Data.List.Base as List using (List; []; _∷_; length; map; filter; replicate)
 open import Data.Nat.Base using (zero; suc; _≤_)
-import Data.Nat.Properties as ℕₚ
+import Data.Nat.Properties as ℕ
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_]′)
 open import Function.Base using (case_of_; _$′_)
 
 open import Relation.Nullary.Decidable using (yes; no; does; map′; _⊎-dec_)
 open import Relation.Nullary.Negation using (¬_; contradiction)
 open import Relation.Unary as U using (Pred)
-open import Relation.Binary using (REL; _⇒_; Decidable; Trans; Antisym)
-open import Relation.Binary.PropositionalEquality using (_≢_; refl; cong)
-
-open import Data.List.Relation.Binary.Pointwise as Pointwise using (Pointwise)
+open import Relation.Binary.Core using (REL; _⇒_)
+open import Relation.Binary.Definitions using (Decidable; Trans; Antisym)
+open import Relation.Binary.PropositionalEquality.Core using (_≢_; refl; cong)
+open import Data.List.Relation.Binary.Pointwise.Base as Pointwise using (Pointwise)
 open import Data.List.Relation.Binary.Infix.Heterogeneous
 open import Data.List.Relation.Binary.Prefix.Heterogeneous
   as Prefix using (Prefix; []; _∷_)
-import Data.List.Relation.Binary.Prefix.Heterogeneous.Properties as Prefixₚ
+import Data.List.Relation.Binary.Prefix.Heterogeneous.Properties as Prefix
 open import Data.List.Relation.Binary.Suffix.Heterogeneous
   as Suffix using (Suffix; here; there)
 
@@ -43,7 +43,7 @@ private
 -- Conversion functions
 
 fromPointwise : ∀ {as bs} → Pointwise R as bs → Infix R as bs
-fromPointwise pw = here (Prefixₚ.fromPointwise pw)
+fromPointwise pw = here (Prefix.fromPointwise pw)
 
 fromSuffix : ∀ {as bs} → Suffix R as bs → Infix R as bs
 fromSuffix (here pw) = fromPointwise pw
@@ -52,11 +52,11 @@ fromSuffix (there p) = there (fromSuffix p)
 module _ {c t} {C : Set c} {T : REL A C t} where
 
   fromPrefixSuffix : Trans R S T → Trans (Prefix R) (Suffix S) (Infix T)
-  fromPrefixSuffix tr p (here q)  = here (Prefixₚ.trans tr p (Prefixₚ.fromPointwise q))
+  fromPrefixSuffix tr p (here q)  = here (Prefix.trans tr p (Prefix.fromPointwise q))
   fromPrefixSuffix tr p (there q) = there (fromPrefixSuffix tr p q)
 
   fromSuffixPrefix : Trans R S T → Trans (Suffix R) (Prefix S) (Infix T)
-  fromSuffixPrefix tr (here p)  q       = here (Prefixₚ.trans tr (Prefixₚ.fromPointwise p) q)
+  fromSuffixPrefix tr (here p)  q       = here (Prefix.trans tr (Prefix.fromPointwise p) q)
   fromSuffixPrefix tr (there p) (_ ∷ q) = there (fromSuffixPrefix tr p q)
 
 ∷⁻ : ∀ {as b bs} → Infix R as (b ∷ bs) → Prefix R as (b ∷ bs) ⊎ Infix R as bs
@@ -67,8 +67,8 @@ module _ {c t} {C : Set c} {T : REL A C t} where
 -- length
 
 length-mono : ∀ {as bs} → Infix R as bs → length as ≤ length bs
-length-mono (here pref) = Prefixₚ.length-mono pref
-length-mono (there p)   = ℕₚ.m≤n⇒m≤1+n (length-mono p)
+length-mono (here pref) = Prefix.length-mono pref
+length-mono (there p)   = ℕ.m≤n⇒m≤1+n (length-mono p)
 
 ------------------------------------------------------------------------
 -- As an order
@@ -76,11 +76,11 @@ length-mono (there p)   = ℕₚ.m≤n⇒m≤1+n (length-mono p)
 module _ {c t} {C : Set c} {T : REL A C t} where
 
   Prefix-Infix-trans : Trans R S T → Trans (Prefix R) (Infix S) (Infix T)
-  Prefix-Infix-trans tr p (here q)  = here (Prefixₚ.trans tr p q)
+  Prefix-Infix-trans tr p (here q)  = here (Prefix.trans tr p q)
   Prefix-Infix-trans tr p (there q) = there (Prefix-Infix-trans tr p q)
 
   Infix-Prefix-trans : Trans R S T → Trans (Infix R) (Prefix S) (Infix T)
-  Infix-Prefix-trans tr (here p)  q       = here (Prefixₚ.trans tr p q)
+  Infix-Prefix-trans tr (here p)  q       = here (Prefix.trans tr p q)
   Infix-Prefix-trans tr (there p) (_ ∷ q) = there (Infix-Prefix-trans tr p q)
 
   Suffix-Infix-trans : Trans R S T → Trans (Suffix R) (Infix S) (Infix T)
@@ -88,7 +88,7 @@ module _ {c t} {C : Set c} {T : REL A C t} where
   Suffix-Infix-trans tr p (there q) = there (Suffix-Infix-trans tr p q)
 
   Infix-Suffix-trans : Trans R S T → Trans (Infix R) (Suffix S) (Infix T)
-  Infix-Suffix-trans tr p (here q)  = Infix-Prefix-trans tr p (Prefixₚ.fromPointwise q)
+  Infix-Suffix-trans tr p (here q)  = Infix-Prefix-trans tr p (Prefix.fromPointwise q)
   Infix-Suffix-trans tr p (there q) = there (Infix-Suffix-trans tr p q)
 
   trans : Trans R S T → Trans (Infix R) (Infix S) (Infix T)
@@ -96,22 +96,22 @@ module _ {c t} {C : Set c} {T : REL A C t} where
   trans tr p (there q) = there (trans tr p q)
 
   antisym : Antisym R S T → Antisym (Infix R) (Infix S) (Pointwise T)
-  antisym asym (here p) (here q) = Prefixₚ.antisym asym p q
+  antisym asym (here p) (here q) = Prefix.antisym asym p q
   antisym asym {i = a ∷ as} {j = bs} p@(here _) (there q)
-    = ⊥-elim $′ ℕₚ.<-irrefl refl $′ begin-strict
+    = ⊥-elim $′ ℕ.<-irrefl refl $′ begin-strict
       length as <⟨ length-mono p ⟩
       length bs ≤⟨ length-mono q ⟩
-      length as ∎ where open ℕₚ.≤-Reasoning
+      length as ∎ where open ℕ.≤-Reasoning
   antisym asym {i = as} {j = b ∷ bs} (there p) q@(here _)
-    = ⊥-elim $′ ℕₚ.<-irrefl refl $′ begin-strict
+    = ⊥-elim $′ ℕ.<-irrefl refl $′ begin-strict
       length bs <⟨ length-mono q ⟩
       length as ≤⟨ length-mono p ⟩
-      length bs ∎ where open ℕₚ.≤-Reasoning
+      length bs ∎ where open ℕ.≤-Reasoning
   antisym asym {i = a ∷ as} {j = b ∷ bs} (there p) (there q)
-    = ⊥-elim $′ ℕₚ.<-irrefl refl $′ begin-strict
+    = ⊥-elim $′ ℕ.<-irrefl refl $′ begin-strict
       length as <⟨ length-mono p ⟩
       length bs <⟨ length-mono q ⟩
-      length as ∎ where open ℕₚ.≤-Reasoning
+      length as ∎ where open ℕ.≤-Reasoning
 
 ------------------------------------------------------------------------
 -- map
@@ -121,14 +121,14 @@ module _ {c d r} {C : Set c} {D : Set d} {R : REL C D r} where
   map⁺ : ∀ {as bs} (f : A → C) (g : B → D) →
          Infix (λ a b → R (f a) (g b)) as bs →
          Infix R (List.map f as) (List.map g bs)
-  map⁺ f g (here p)  = here (Prefixₚ.map⁺ f g p)
+  map⁺ f g (here p)  = here (Prefix.map⁺ f g p)
   map⁺ f g (there p) = there (map⁺ f g p)
 
   map⁻ : ∀ {as bs} (f : A → C) (g : B → D) →
          Infix R (List.map f as) (List.map g bs) →
          Infix (λ a b → R (f a) (g b)) as bs
-  map⁻ {bs = []}     f g (here p)  = here (Prefixₚ.map⁻ f g p)
-  map⁻ {bs = b ∷ bs} f g (here p)  = here (Prefixₚ.map⁻ f g p)
+  map⁻ {bs = []}     f g (here p)  = here (Prefix.map⁻ f g p)
+  map⁻ {bs = b ∷ bs} f g (here p)  = here (Prefix.map⁻ f g p)
   map⁻ {bs = b ∷ bs} f g (there p) = there (map⁻ f g p)
 
 ------------------------------------------------------------------------
@@ -139,7 +139,7 @@ module _ {p q} {P : Pred A p} {Q : Pred B q} (P? : U.Decidable P) (Q? : U.Decida
          where
 
   filter⁺ : ∀ {as bs} → Infix R as bs → Infix R (filter P? as) (filter Q? bs)
-  filter⁺ (here p) = here (Prefixₚ.filter⁺ P? Q? (λ _ → P⇒Q) (λ _ → Q⇒P) p)
+  filter⁺ (here p) = here (Prefix.filter⁺ P? Q? (λ _ → P⇒Q) (λ _ → Q⇒P) p)
   filter⁺ {bs = b ∷ bs} (there p) with does (Q? b)
   ... | true = there (filter⁺ p)
   ... | false = filter⁺ p
@@ -149,12 +149,12 @@ module _ {p q} {P : Pred A p} {Q : Pred B q} (P? : U.Decidable P) (Q? : U.Decida
 
 replicate⁺ : ∀ {m n a b} → m ≤ n → R a b →
              Infix R (replicate m a) (replicate n b)
-replicate⁺ m≤n r = here (Prefixₚ.replicate⁺ m≤n r)
+replicate⁺ m≤n r = here (Prefix.replicate⁺ m≤n r)
 
 replicate⁻ : ∀ {m n a b} → m ≢ 0 →
              Infix R (replicate m a) (replicate n b) → R a b
-replicate⁻ {m = m} {n = zero}  m≢0 (here p)  = Prefixₚ.replicate⁻ m≢0 p
-replicate⁻ {m = m} {n = suc n} m≢0 (here p)  = Prefixₚ.replicate⁻ m≢0 p
+replicate⁻ {m = m} {n = zero}  m≢0 (here p)  = Prefix.replicate⁻ m≢0 p
+replicate⁻ {m = m} {n = suc n} m≢0 (here p)  = Prefix.replicate⁻ m≢0 p
 replicate⁻ {m = m} {n = suc n} m≢0 (there p) = replicate⁻ m≢0 p
 
 ------------------------------------------------------------------------
@@ -165,4 +165,4 @@ infix? R? [] [] = yes (here [])
 infix? R? (a ∷ as) [] = no (λ where (here ()))
 infix? R? as bbs@(_ ∷ bs) =
   map′ [ here , there ]′ ∷⁻
-  (Prefixₚ.prefix? R? as bbs ⊎-dec infix? R? as bs)
+  (Prefix.prefix? R? as bbs ⊎-dec infix? R? as bs)
diff --git a/src/Data/List/Relation/Binary/Infix/Homogeneous/Properties.agda b/src/Data/List/Relation/Binary/Infix/Homogeneous/Properties.agda
index cf7c2b7b27..0abb36a149 100644
--- a/src/Data/List/Relation/Binary/Infix/Homogeneous/Properties.agda
+++ b/src/Data/List/Relation/Binary/Infix/Homogeneous/Properties.agda
@@ -10,7 +10,9 @@ module Data.List.Relation.Binary.Infix.Homogeneous.Properties where
 
 open import Level
 open import Function.Base using (_∘′_)
-open import Relation.Binary
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsDecPartialOrder)
 
 open import Data.List.Relation.Binary.Pointwise as Pointwise using (Pointwise)
 open import Data.List.Relation.Binary.Infix.Heterogeneous
diff --git a/src/Data/List/Relation/Binary/Lex.agda b/src/Data/List/Relation/Binary/Lex.agda
index f0c8fa42df..6c8fb4b323 100644
--- a/src/Data/List/Relation/Binary/Lex.agda
+++ b/src/Data/List/Relation/Binary/Lex.agda
@@ -10,7 +10,7 @@ module Data.List.Relation.Binary.Lex where
 
 open import Data.Empty using (⊥; ⊥-elim)
 open import Data.Unit.Base using (⊤; tt)
-open import Data.Product using (_×_; _,_; proj₁; proj₂; uncurry)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂; uncurry)
 open import Data.List.Base using (List; []; _∷_)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_])
 open import Function.Base using (_∘_; flip; id)
@@ -19,7 +19,10 @@ open import Level using (_⊔_)
 open import Relation.Nullary.Negation using (¬_)
 open import Relation.Nullary.Decidable as Dec
   using (Dec; yes; no; _×-dec_; _⊎-dec_)
-open import Relation.Binary hiding (_⇔_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Symmetric; Transitive; Irreflexive; Asymmetric; Antisymmetric; Decidable; _Respects₂_; _Respects_)
 open import Data.List.Relation.Binary.Pointwise.Base
    using (Pointwise; []; _∷_; head; tail)
 
diff --git a/src/Data/List/Relation/Binary/Lex/Core.agda b/src/Data/List/Relation/Binary/Lex/Core.agda
index 3c90bf3c9f..0b3e821194 100644
--- a/src/Data/List/Relation/Binary/Lex/Core.agda
+++ b/src/Data/List/Relation/Binary/Lex/Core.agda
@@ -10,7 +10,7 @@ module Data.List.Relation.Binary.Lex.Core where
 
 open import Data.Empty using (⊥; ⊥-elim)
 open import Data.Unit.Base using (⊤; tt)
-open import Data.Product using (_×_; _,_; proj₁; proj₂; uncurry)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂; uncurry)
 open import Data.List.Base using (List; []; _∷_)
 open import Function.Base using (_∘_; flip; id)
 open import Level using (Level; _⊔_)
@@ -35,7 +35,7 @@ data Lex {A : Set a} (P : Set)
   next : ∀ {x xs y ys} (x≈y : x ≈ y)
          (xs<ys : Lex P _≈_ _≺_ xs ys) → Lex P _≈_ _≺_ (x ∷ xs) (y ∷ ys)
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Lexicographic orderings, using a strict ordering as the base
 
 Lex-< : {A : Set a} (_≈_ : Rel A ℓ₁) (_≺_ : Rel A ℓ₂) →
diff --git a/src/Data/List/Relation/Binary/Lex/NonStrict.agda b/src/Data/List/Relation/Binary/Lex/NonStrict.agda
index 83c8767cb3..4afe0f8242 100644
--- a/src/Data/List/Relation/Binary/Lex/NonStrict.agda
+++ b/src/Data/List/Relation/Binary/Lex/NonStrict.agda
@@ -14,13 +14,18 @@ module Data.List.Relation.Binary.Lex.NonStrict where
 open import Data.Empty using (⊥)
 open import Function.Base
 open import Data.Unit.Base using (⊤; tt)
-open import Data.Product
 open import Data.List.Base
-open import Data.List.Relation.Binary.Pointwise using (Pointwise; [])
+open import Data.List.Relation.Binary.Pointwise.Base using (Pointwise; [])
 import Data.List.Relation.Binary.Lex.Strict as Strict
 open import Level
 open import Relation.Nullary
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (Poset; StrictPartialOrder; DecTotalOrder; StrictTotalOrder; Preorder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsPartialOrder; IsStrictPartialOrder; IsTotalOrder; IsStrictTotalOrder; IsPreorder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Irreflexive; _Respects₂_; Antisymmetric; Asymmetric; Symmetric; Transitive; Decidable; Total; Trichotomous)
 import Relation.Binary.Construct.NonStrictToStrict as Conv
 
 import Data.List.Relation.Binary.Lex as Core
diff --git a/src/Data/List/Relation/Binary/Lex/Strict.agda b/src/Data/List/Relation/Binary/Lex/Strict.agda
index fef11ad07e..277996594f 100644
--- a/src/Data/List/Relation/Binary/Lex/Strict.agda
+++ b/src/Data/List/Relation/Binary/Lex/Strict.agda
@@ -14,25 +14,31 @@ module Data.List.Relation.Binary.Lex.Strict where
 open import Data.Empty using (⊥)
 open import Data.Unit.Base using (⊤; tt)
 open import Function.Base using (_∘_; id)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Data.Sum.Base using (inj₁; inj₂)
 open import Data.List.Base using (List; []; _∷_)
 open import Level using (_⊔_)
 open import Relation.Nullary using (yes; no; ¬_)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (StrictPartialOrder; StrictTotalOrder; Preorder; Poset; DecPoset; DecTotalOrder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsStrictPartialOrder; IsStrictTotalOrder; IsPreorder; IsPartialOrder; IsDecPartialOrder; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Irreflexive; Symmetric; _Respects₂_; Total; Asymmetric; Antisymmetric; Transitive; Trichotomous; Decidable; tri≈; tri<; tri>)
 open import Relation.Binary.Consequences
 open import Data.List.Relation.Binary.Pointwise as Pointwise
    using (Pointwise; []; _∷_; head; tail)
 
 import Data.List.Relation.Binary.Lex as Core
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Re-exporting core definitions
 
 open Core public
   using (Lex-<; Lex-≤; base; halt; this; next; ¬≤-this; ¬≤-next)
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Strict lexicographic ordering.
 
 module _ {a ℓ₁ ℓ₂} {A : Set a} where
@@ -45,11 +51,11 @@ module _ {a ℓ₁ ℓ₂} {A : Set a} where
       _≋_ = Pointwise _≈_
       _<_ = Lex-< _≈_ _≺_
 
-    xs≮[] : ∀ xs → ¬ xs < []
-    xs≮[] _ (base ())
+    xs≮[] : ∀ {xs} → ¬ xs < []
+    xs≮[] (base ())
 
     ¬[]<[] : ¬ [] < []
-    ¬[]<[] = xs≮[] []
+    ¬[]<[] = xs≮[]
 
     <-irreflexive : Irreflexive _≈_ _≺_ → Irreflexive _≋_ _<_
     <-irreflexive irr (x≈y ∷ xs≋ys) (this x<y)     = irr x≈y x<y
@@ -115,9 +121,8 @@ module _ {a ℓ₁ ℓ₂} {A : Set a} where
     <-isStrictTotalOrder : IsStrictTotalOrder _≈_ _≺_ →
                            IsStrictTotalOrder _≋_ _<_
     <-isStrictTotalOrder sto = record
-      { isEquivalence = Pointwise.isEquivalence isEquivalence
-      ; trans         = <-transitive isEquivalence <-resp-≈ trans
-      ; compare       = <-compare Eq.sym compare
+      { isStrictPartialOrder = <-isStrictPartialOrder isStrictPartialOrder
+      ; compare              = <-compare Eq.sym compare
       } where open IsStrictTotalOrder sto
 
 <-strictPartialOrder : ∀ {a ℓ₁ ℓ₂} → StrictPartialOrder a ℓ₁ ℓ₂ →
@@ -132,7 +137,7 @@ module _ {a ℓ₁ ℓ₂} {A : Set a} where
   { isStrictTotalOrder = <-isStrictTotalOrder isStrictTotalOrder
   } where open StrictTotalOrder sto
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Non-strict lexicographic ordering.
 
 module _ {a ℓ₁ ℓ₂} {A : Set a} where
diff --git a/src/Data/List/Relation/Binary/Permutation/Homogeneous.agda b/src/Data/List/Relation/Binary/Permutation/Homogeneous.agda
index 9e247e734b..12015b3076 100644
--- a/src/Data/List/Relation/Binary/Permutation/Homogeneous.agda
+++ b/src/Data/List/Relation/Binary/Permutation/Homogeneous.agda
@@ -9,10 +9,15 @@
 module Data.List.Relation.Binary.Permutation.Homogeneous where
 
 open import Data.List.Base using (List; _∷_)
-open import Data.List.Relation.Binary.Pointwise as Pointwise
+open import Data.List.Relation.Binary.Pointwise.Base as Pointwise
   using (Pointwise)
+open import Data.List.Relation.Binary.Pointwise.Properties as Pointwise
+  using (symmetric)
 open import Level using (Level; _⊔_)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions using (Reflexive; Symmetric)
 
 private
   variable
diff --git a/src/Data/List/Relation/Binary/Permutation/Propositional.agda b/src/Data/List/Relation/Binary/Permutation/Propositional.agda
index 939491ecc4..c41793d28a 100644
--- a/src/Data/List/Relation/Binary/Permutation/Propositional.agda
+++ b/src/Data/List/Relation/Binary/Permutation/Propositional.agda
@@ -10,9 +10,13 @@ module Data.List.Relation.Binary.Permutation.Propositional
   {a} {A : Set a} where
 
 open import Data.List.Base using (List; []; _∷_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions using (Reflexive; Transitive)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 import Relation.Binary.Reasoning.Setoid as EqReasoning
+open import Relation.Binary.Reasoning.Syntax
 
 ------------------------------------------------------------------------
 -- An inductive definition of permutation
@@ -70,16 +74,17 @@ data _↭_ : Rel (List A) a where
 
 module PermutationReasoning where
 
-  private
-    module Base = EqReasoning ↭-setoid
+  private module Base = EqReasoning ↭-setoid
 
-  open EqReasoning ↭-setoid public
-    hiding (step-≈; step-≈˘)
+  open Base public
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨)
+    renaming (≈-go to ↭-go)
 
-  infixr 2 step-↭  step-↭˘ step-swap step-prep
+  open ↭-syntax _IsRelatedTo_ _IsRelatedTo_ ↭-go ↭-sym public
 
-  step-↭  = Base.step-≈
-  step-↭˘ = Base.step-≈˘
+  -- Some extra combinators that allow us to skip certain elements
+
+  infixr 2 step-swap step-prep
 
   -- Skip reasoning on the first element
   step-prep : ∀ x xs {ys zs : List A} → (x ∷ ys) IsRelatedTo zs →
@@ -91,7 +96,5 @@ module PermutationReasoning where
               xs ↭ ys → (x ∷ y ∷ xs) IsRelatedTo zs
   step-swap x y xs rel xs↭ys = relTo (trans (swap x y xs↭ys) (begin rel))
 
-  syntax step-↭  x y↭z x↭y = x ↭⟨  x↭y ⟩ y↭z
-  syntax step-↭˘ x y↭z y↭x = x ↭˘⟨  y↭x ⟩ y↭z
   syntax step-prep x xs y↭z x↭y = x ∷ xs <⟨ x↭y ⟩ y↭z
   syntax step-swap x y xs y↭z x↭y = x ∷ y ∷ xs <<⟨ x↭y ⟩ y↭z
diff --git a/src/Data/List/Relation/Binary/Permutation/Propositional/Properties.agda b/src/Data/List/Relation/Binary/Permutation/Propositional/Properties.agda
index c9a8048592..6fe439ed03 100644
--- a/src/Data/List/Relation/Binary/Permutation/Propositional/Properties.agda
+++ b/src/Data/List/Relation/Binary/Permutation/Propositional/Properties.agda
@@ -12,8 +12,9 @@ open import Algebra.Bundles
 open import Algebra.Definitions
 open import Algebra.Structures
 open import Data.Bool.Base using (Bool; true; false)
-open import Data.Nat using (suc)
-open import Data.Product using (-,_; proj₂)
+open import Data.Nat.Base using (suc; _*_)
+open import Data.Nat.Properties using (*-assoc; *-comm)
+open import Data.Product.Base using (-,_; proj₂)
 open import Data.List.Base as List
 open import Data.List.Relation.Binary.Permutation.Propositional
 open import Data.List.Relation.Unary.Any using (Any; here; there)
@@ -21,24 +22,24 @@ open import Data.List.Relation.Unary.All using (All; []; _∷_)
 open import Data.List.Membership.Propositional
 open import Data.List.Membership.Propositional.Properties
 import Data.List.Properties as Lₚ
-open import Data.Product using (_,_; _×_; ∃; ∃₂)
-open import Function.Base using (_∘_; _⟨_⟩_)
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Inverse as Inv using (inverse)
+open import Data.Product.Base using (_,_; _×_; ∃; ∃₂)
+open import Data.Maybe.Base using (Maybe; just; nothing)
+open import Function.Base using (_∘_; _⟨_⟩_; _$_)
 open import Level using (Level)
 open import Relation.Unary using (Pred)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as ≡
-  using (_≡_ ; refl ; cong; cong₂; _≢_; inspect)
+open import Relation.Binary.Core using (Rel; _Preserves_⟶_; _Preserves₂_⟶_⟶_)
+open import Relation.Binary.Definitions using (_Respects_; Decidable)
+open import Relation.Binary.PropositionalEquality.Core as ≡
+  using (_≡_ ; refl ; cong; cong₂; _≢_)
+open import Relation.Binary.PropositionalEquality.Properties using (module ≡-Reasoning)
 open import Relation.Nullary
 
-open PermutationReasoning
-
 private
   variable
     a b p : Level
     A : Set a
     B : Set b
+    xs ys : List A
 
 ------------------------------------------------------------------------
 -- Permutations of empty and singleton lists
@@ -173,6 +174,7 @@ shift v (x ∷ xs) ys = begin
   x ∷ (xs ++ [ v ] ++ ys) <⟨ shift v xs ys ⟩
   x ∷ v ∷ xs ++ ys        <<⟨ refl ⟩
   v ∷ x ∷ xs ++ ys        ∎
+  where open PermutationReasoning
 
 drop-mid-≡ : ∀ {x : A} ws xs {ys} {zs} →
              ws ++ [ x ] ++ ys ≡ xs ++ [ x ] ++ zs →
@@ -217,11 +219,13 @@ drop-mid {A = A} {x} ws xs p = drop-mid′ p ws xs refl refl
       _ ∷ (xs ++ _ ∷ _) <⟨ shift _ _ _ ⟩
       _ ∷ _ ∷ xs ++ _   <<⟨ refl ⟩
       _ ∷ _ ∷ xs ++ _   ∎
+      where open PermutationReasoning
   drop-mid′ (swap y z p) (y ∷ z ∷ ws) (z ∷ [])     refl refl = begin
       _ ∷ _ ∷ ws ++ _   <<⟨ refl ⟩
       _ ∷ (_ ∷ ws ++ _) <⟨ ↭-sym (shift _ _ _) ⟩
       _ ∷ (ws ++ _ ∷ _) <⟨ p ⟩
       _ ∷ _             ∎
+      where open PermutationReasoning
   drop-mid′ (swap y z p) (y ∷ z ∷ ws) (z ∷ y ∷ xs) refl refl = swap y z (drop-mid′ p _ _ refl refl)
   drop-mid′ (trans p₁ p₂) ws  xs refl refl with ∈-∃++ (∈-resp-↭ p₁ (∈-insert ws))
   ... | (h , t , refl) = trans (drop-mid′ p₁ ws h refl refl) (drop-mid′ p₂ h xs refl refl)
@@ -244,8 +248,9 @@ drop-mid {A = A} {x} ws xs p = drop-mid′ p ws xs refl refl
 ++-comm []       ys = ↭-sym (++-identityʳ ys)
 ++-comm (x ∷ xs) ys = begin
   x ∷ xs ++ ys   <⟨ ++-comm xs ys ⟩
-  x ∷ ys ++ xs   ↭˘⟨ shift x ys xs ⟩
+  x ∷ ys ++ xs   ↭⟨ shift x ys xs ⟨
   ys ++ (x ∷ xs) ∎
+  where open PermutationReasoning
 
 ++-isMagma : IsMagma {A = List A} _↭_ _++_
 ++-isMagma = record
@@ -297,10 +302,11 @@ module _ {a} {A : Set a} where
 
 shifts : ∀ xs ys {zs : List A} → xs ++ ys ++ zs ↭ ys ++ xs ++ zs
 shifts xs ys {zs} = begin
-   xs ++ ys  ++ zs ↭˘⟨ ++-assoc xs ys zs ⟩
+   xs ++ ys  ++ zs ↭⟨ ++-assoc xs ys zs ⟨
   (xs ++ ys) ++ zs ↭⟨ ++⁺ʳ zs (++-comm xs ys) ⟩
   (ys ++ xs) ++ zs ↭⟨ ++-assoc ys xs zs ⟩
    ys ++ xs  ++ zs ∎
+   where open PermutationReasoning
 
 ------------------------------------------------------------------------
 -- _∷_
@@ -316,6 +322,7 @@ drop-∷ = drop-mid [] []
   xs ++ [ x ]   ↭⟨ shift x xs [] ⟩
   x ∷ xs ++ []  ≡⟨ Lₚ.++-identityʳ _ ⟩
   x ∷ xs        ∎)
+  where open PermutationReasoning
 
 ------------------------------------------------------------------------
 -- ʳ++
@@ -324,6 +331,18 @@ drop-∷ = drop-mid [] []
 ++↭ʳ++ []       ys = ↭-refl
 ++↭ʳ++ (x ∷ xs) ys = ↭-trans (↭-sym (shift x xs ys)) (++↭ʳ++ xs (x ∷ ys))
 
+------------------------------------------------------------------------
+-- reverse
+
+↭-reverse : (xs : List A) → reverse xs ↭ xs
+↭-reverse [] = ↭-refl
+↭-reverse (x ∷ xs) = begin
+  reverse (x ∷ xs) ≡⟨ Lₚ.unfold-reverse x xs ⟩
+  reverse xs ∷ʳ x ↭⟨ ∷↭∷ʳ x (reverse xs) ⟨
+  x ∷ reverse xs   ↭⟨ prep x (↭-reverse xs) ⟩
+  x ∷ xs ∎
+  where open PermutationReasoning
+
 ------------------------------------------------------------------------
 -- merge
 
@@ -338,7 +357,40 @@ module _ {ℓ} {R : Rel A ℓ} (R? : Decidable R) where
   ... | true  | rec | _   = prep x rec
   ... | false | _   | rec = begin
     y ∷ merge R? (x ∷ xs) ys <⟨ rec ⟩
-    y ∷ x ∷ xs ++ ys         ↭˘⟨ shift y (x ∷ xs) ys ⟩
-    (x ∷ xs) ++ y ∷ ys       ≡˘⟨ Lₚ.++-assoc [ x ] xs (y ∷ ys) ⟩
+    y ∷ x ∷ xs ++ ys         ↭⟨ shift y (x ∷ xs) ys ⟨
+    (x ∷ xs) ++ y ∷ ys       ≡⟨ Lₚ.++-assoc [ x ] xs (y ∷ ys) ⟨
     x ∷ xs ++ y ∷ ys         ∎
     where open PermutationReasoning
+
+------------------------------------------------------------------------
+-- product
+
+product-↭ : product Preserves _↭_ ⟶ _≡_
+product-↭ refl = refl
+product-↭ (prep x r) = cong (x *_) (product-↭ r)
+product-↭ (trans r s) = ≡.trans (product-↭ r) (product-↭ s)
+product-↭ (swap {xs} {ys} x y r) = begin
+  x * (y * product xs) ≡˘⟨ *-assoc x y (product xs) ⟩
+  (x * y) * product xs ≡⟨ cong₂ _*_ (*-comm x y) (product-↭ r) ⟩
+  (y * x) * product ys ≡⟨ *-assoc y x (product ys) ⟩
+  y * (x * product ys) ∎
+  where open ≡-Reasoning
+
+------------------------------------------------------------------------
+-- catMaybes
+
+catMaybes-↭ : xs ↭ ys → catMaybes xs ↭ catMaybes ys
+catMaybes-↭ refl                         = refl
+catMaybes-↭ (trans xs↭ ↭ys)              = trans (catMaybes-↭ xs↭) (catMaybes-↭ ↭ys)
+catMaybes-↭ (prep nothing  xs↭)          = catMaybes-↭ xs↭
+catMaybes-↭ (prep (just x) xs↭)          = prep x $ catMaybes-↭ xs↭
+catMaybes-↭ (swap nothing  nothing  xs↭) = catMaybes-↭ xs↭
+catMaybes-↭ (swap nothing  (just y) xs↭) = prep y $ catMaybes-↭ xs↭
+catMaybes-↭ (swap (just x) nothing  xs↭) = prep x $ catMaybes-↭ xs↭
+catMaybes-↭ (swap (just x) (just y) xs↭) = swap x y $ catMaybes-↭ xs↭
+
+------------------------------------------------------------------------
+-- mapMaybe
+
+mapMaybe-↭ : (f : A → Maybe B) → xs ↭ ys → mapMaybe f xs ↭ mapMaybe f ys
+mapMaybe-↭ f = catMaybes-↭ ∘ map⁺ f
diff --git a/src/Data/List/Relation/Binary/Permutation/Setoid.agda b/src/Data/List/Relation/Binary/Permutation/Setoid.agda
index e98cc6315c..4409e78cc4 100644
--- a/src/Data/List/Relation/Binary/Permutation/Setoid.agda
+++ b/src/Data/List/Relation/Binary/Permutation/Setoid.agda
@@ -6,19 +6,25 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Function.Base using (_∘′_)
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
+open import Relation.Binary.Reasoning.Syntax
 
 module Data.List.Relation.Binary.Permutation.Setoid
   {a ℓ} (S : Setoid a ℓ) where
 
 open import Data.List.Base using (List; _∷_)
 import Data.List.Relation.Binary.Permutation.Homogeneous as Homogeneous
-import Data.List.Relation.Binary.Pointwise as Pointwise
+import Data.List.Relation.Binary.Pointwise.Properties as Pointwise using (refl)
 open import Data.List.Relation.Binary.Equality.Setoid S
 open import Data.Nat.Base using (ℕ; zero; suc; _+_)
 open import Level using (_⊔_)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 private
   module Eq = Setoid S
@@ -82,24 +88,18 @@ steps (trans xs↭ys ys↭zs) = steps xs↭ys + steps ys↭zs
 
 module PermutationReasoning where
 
-  private
-    module Base = SetoidReasoning ↭-setoid
+  private module Base = ≈-Reasoning ↭-setoid
 
-  open SetoidReasoning ↭-setoid public
-    hiding (step-≈; step-≈˘)
+  open Base public
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨)
+    renaming (≈-go to ↭-go)
 
-  infixr 2 step-↭  step-↭˘ step-≋ step-≋˘ step-swap step-prep
+  open ↭-syntax _IsRelatedTo_ _IsRelatedTo_ ↭-go ↭-sym public
+  open ≋-syntax _IsRelatedTo_ _IsRelatedTo_ (↭-go ∘′ refl) ≋-sym public
 
-  step-↭  = Base.step-≈
-  step-↭˘ = Base.step-≈˘
+  -- Some extra combinators that allow us to skip certain elements
 
-  -- Step with pointwise list equality
-  step-≋ : ∀ x {y z} → y IsRelatedTo z → x ≋ y → x IsRelatedTo z
-  step-≋ x (relTo y↔z) x≋y = relTo (trans (refl x≋y) y↔z)
-
-  -- Step with flipped pointwise list equality
-  step-≋˘ : ∀ x {y z} → y IsRelatedTo z → y ≋ x → x IsRelatedTo z
-  step-≋˘ x y↭z y≋x = x ≋⟨ ≋-sym y≋x ⟩ y↭z
+  infixr 2 step-swap step-prep
 
   -- Skip reasoning on the first element
   step-prep : ∀ x xs {ys zs : List A} → (x ∷ ys) IsRelatedTo zs →
@@ -111,9 +111,5 @@ module PermutationReasoning where
               xs ↭ ys → (x ∷ y ∷ xs) IsRelatedTo zs
   step-swap x y xs rel xs↭ys = relTo (trans (swap Eq.refl Eq.refl xs↭ys) (begin rel))
 
-  syntax step-↭  x y↭z x↭y = x ↭⟨  x↭y ⟩ y↭z
-  syntax step-↭˘ x y↭z y↭x = x ↭˘⟨  y↭x ⟩ y↭z
-  syntax step-≋  x y↭z x≋y = x ≋⟨  x≋y ⟩ y↭z
-  syntax step-≋˘ x y↭z y≋x = x ≋˘⟨  y≋x ⟩ y↭z
   syntax step-prep x xs y↭z x↭y = x ∷ xs <⟨ x↭y ⟩ y↭z
   syntax step-swap x y xs y↭z x↭y = x ∷ y ∷ xs <<⟨ x↭y ⟩ y↭z
diff --git a/src/Data/List/Relation/Binary/Permutation/Setoid/Properties.agda b/src/Data/List/Relation/Binary/Permutation/Setoid/Properties.agda
index 79ccfaadef..0440e3a3b6 100644
--- a/src/Data/List/Relation/Binary/Permutation/Setoid/Properties.agda
+++ b/src/Data/List/Relation/Binary/Permutation/Setoid/Properties.agda
@@ -6,13 +6,17 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary as B hiding (Decidable)
+open import Relation.Binary.Core
+  using (Rel; _⇒_; _Preserves_⟶_; _Preserves₂_⟶_⟶_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions as B hiding (Decidable)
 
 module Data.List.Relation.Binary.Permutation.Setoid.Properties
   {a ℓ} (S : Setoid a ℓ)
   where
 
 open import Algebra
+import Algebra.Properties.CommutativeMonoid as ACM
 open import Data.Bool.Base using (true; false)
 open import Data.List.Base as List hiding (head; tail)
 open import Data.List.Relation.Binary.Pointwise as Pointwise
@@ -26,18 +30,17 @@ import Data.List.Relation.Unary.Unique.Setoid as Unique
 import Data.List.Membership.Setoid as Membership
 open import Data.List.Membership.Setoid.Properties using (∈-∃++; ∈-insert)
 import Data.List.Properties as Lₚ
-open import Data.Nat hiding (_⊔_)
+open import Data.Nat.Base using (ℕ; suc; _<_; z<s; _+_)
 open import Data.Nat.Induction
 open import Data.Nat.Properties
-open import Data.Product using (_,_; _×_; ∃; ∃₂; proj₁; proj₂)
+open import Data.Product.Base using (_,_; _×_; ∃; ∃₂; proj₁; proj₂)
 open import Function.Base using (_∘_; _⟨_⟩_; flip)
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Inverse as Inv using (inverse)
 open import Level using (Level; _⊔_)
 open import Relation.Unary using (Pred; Decidable)
+import Relation.Binary.Reasoning.Setoid as RelSetoid
 open import Relation.Binary.Properties.Setoid S using (≉-resp₂)
-open import Relation.Binary.PropositionalEquality as ≡
-  using (_≡_ ; refl; sym; cong; cong₂; subst; _≢_; inspect)
+open import Relation.Binary.PropositionalEquality.Core as ≡
+  using (_≡_ ; refl; sym; cong; cong₂; subst; _≢_)
 open import Relation.Nullary.Decidable using (yes; no; does)
 open import Relation.Nullary.Negation using (contradiction)
 
@@ -118,7 +121,7 @@ Unique-resp-↭ = AllPairs-resp-↭ (_∘ ≈-sym) ≉-resp₂
 0<steps (prep eq xs↭ys)      = m<n⇒m<1+n (0<steps xs↭ys)
 0<steps (swap eq₁ eq₂ xs↭ys) = m<n⇒m<1+n (0<steps xs↭ys)
 0<steps (trans xs↭ys xs↭ys₁) =
-  <-transˡ (0<steps xs↭ys) (m≤m+n (steps xs↭ys) (steps xs↭ys₁))
+  <-≤-trans (0<steps xs↭ys) (m≤m+n (steps xs↭ys) (steps xs↭ys₁))
 
 steps-respˡ : ∀ {xs ys zs} (ys≋xs : ys ≋ xs) (ys↭zs : ys ↭ zs) →
               steps (↭-respˡ-≋ ys≋xs ys↭zs) ≡ steps ys↭zs
@@ -141,7 +144,7 @@ steps-respʳ ys≋xs           (trans ys↭ws ws↭zs) = cong (steps ys↭ws +_)
 ------------------------------------------------------------------------
 -- map
 
-module _ (T : Setoid b ℓ) where
+module _ {ℓ} (T : Setoid b ℓ) where
 
   open Setoid T using () renaming (_≈_ to _≈′_)
   open Permutation T using () renaming (_↭_ to _↭′_)
@@ -197,7 +200,7 @@ shift {v} {w} v≈w (x ∷ xs) ys = begin
 ++-comm []       ys = ↭-sym (++-identityʳ ys)
 ++-comm (x ∷ xs) ys = begin
   x ∷ xs ++ ys   <⟨ ++-comm xs ys ⟩
-  x ∷ ys ++ xs   ↭˘⟨ ↭-shift ys xs ⟩
+  x ∷ ys ++ xs   ↭⟨ ↭-shift ys xs ⟨
   ys ++ (x ∷ xs) ∎
 
 -- Structures
@@ -259,7 +262,7 @@ inject v ws↭ys xs↭zs = trans (++⁺ˡ _ (↭-prep _ xs↭zs)) (++⁺ʳ _ ws
 
 shifts : ∀ xs ys {zs : List A} → xs ++ ys ++ zs ↭ ys ++ xs ++ zs
 shifts xs ys {zs} = begin
-   xs ++ ys  ++ zs ↭˘⟨ ++-assoc xs ys zs ⟩
+   xs ++ ys  ++ zs ↭⟨ ++-assoc xs ys zs ⟨
   (xs ++ ys) ++ zs ↭⟨ ++⁺ʳ zs (++-comm xs ys) ⟩
   (ys ++ xs) ++ zs ↭⟨ ++-assoc ys xs zs ⟩
    ys ++ xs  ++ zs ∎
@@ -294,19 +297,19 @@ dropMiddleElement {v} ws xs {ys} {zs} p = helper p ws xs ≋-refl ≋-refl
   helper {_ ∷ as} {_ ∷ bs} (prep _ as↭bs) [] [] {ys} {zs} (_ ∷ ys≋as) (_ ∷ zs≋bs) = begin
     ys               ≋⟨  ys≋as ⟩
     as               ↭⟨  as↭bs ⟩
-    bs               ≋˘⟨ zs≋bs ⟩
+    bs               ≋⟨ zs≋bs ⟨
     zs               ∎
   helper {_ ∷ as} {_ ∷ bs} (prep a≈b as↭bs) [] (x ∷ xs) {ys} {zs} (≈₁ ∷ ≋₁) (≈₂ ∷ ≋₂) = begin
     ys               ≋⟨  ≋₁ ⟩
     as               ↭⟨  as↭bs ⟩
-    bs               ≋˘⟨ ≋₂ ⟩
+    bs               ≋⟨ ≋₂ ⟨
     xs ++ v ∷ zs     ↭⟨  shift (lemma ≈₁ a≈b ≈₂) xs zs ⟩
     x ∷ xs ++ zs     ∎
   helper {_ ∷ as} {_ ∷ bs} (prep v≈w p) (w ∷ ws) [] {ys} {zs} (≈₁ ∷ ≋₁) (≈₂ ∷ ≋₂) = begin
     w ∷ ws ++ ys     ↭⟨  ↭-sym (shift (lemma ≈₂ (≈-sym v≈w) ≈₁) ws ys) ⟩
     ws ++ v ∷ ys     ≋⟨  ≋₁ ⟩
     as               ↭⟨  p ⟩
-    bs               ≋˘⟨ ≋₂ ⟩
+    bs               ≋⟨ ≋₂ ⟨
     zs               ∎
   helper {_ ∷ as} {_ ∷ bs} (prep w≈x p) (w ∷ ws) (x ∷ xs) {ys} {zs} (≈₁ ∷ ≋₁) (≈₂ ∷ ≋₂) = begin
     w ∷ ws ++ ys     ↭⟨ prep (lemma ≈₁ w≈x ≈₂) (helper p ws xs ≋₁ ≋₂) ⟩
@@ -314,12 +317,12 @@ dropMiddleElement {v} ws xs {ys} {zs} p = helper p ws xs ≋-refl ≋-refl
   helper {_ ∷ a ∷ as} {_ ∷ b ∷ bs} (swap v≈x y≈v p) [] [] {ys} {zs} (≈₁ ∷ ≋₁) (≈₂ ∷ ≋₂) = begin
     ys               ≋⟨  ≋₁ ⟩
     a ∷ as           ↭⟨  prep (≈-trans (≈-trans (≈-trans y≈v (≈-sym ≈₂)) ≈₁) v≈x) p ⟩
-    b ∷ bs           ≋˘⟨ ≋₂ ⟩
+    b ∷ bs           ≋⟨ ≋₂ ⟨
     zs               ∎
   helper {_ ∷ a ∷ as} {_ ∷ b ∷ bs} (swap v≈w y≈w p) [] (x ∷ []) {ys} {zs} (≈₁ ∷ ≋₁) (≈₂ ∷ ≋₂) = begin
     ys               ≋⟨  ≋₁ ⟩
     a ∷ as           ↭⟨  prep y≈w p ⟩
-    _ ∷ bs           ≋˘⟨ ≈₂ ∷ tail ≋₂ ⟩
+    _ ∷ bs           ≋⟨ ≈₂ ∷ tail ≋₂ ⟨
     x ∷ zs           ∎
   helper {_ ∷ a ∷ as} {_ ∷ b ∷ bs} (swap v≈w y≈x p) [] (x ∷ w ∷ xs) {ys} {zs} (≈₁ ∷ ≋₁) (≈₂ ∷ ≋₂) = begin
     ys               ≋⟨ ≋₁ ⟩
@@ -381,15 +384,15 @@ split v as bs p = helper as bs p (<-wellFounded (steps p))
   helper (a ∷ [])     bs (refl eq)    _ = [ a ]      , bs , eq
   helper (a ∷ b ∷ as) bs (refl eq)    _ = a ∷ b ∷ as , bs , eq
   helper []           bs (prep v≈x _) _ = [] , _ , v≈x ∷ ≋-refl
-  helper (a ∷ as)     bs (prep eq as↭xs) (acc rec) with helper as bs as↭xs (rec _ ≤-refl)
+  helper (a ∷ as)     bs (prep eq as↭xs) (acc rec) with helper as bs as↭xs (rec ≤-refl)
   ... | (ps , qs , eq₂) = a ∷ ps , qs , eq ∷ eq₂
   helper [] (b ∷ bs)     (swap x≈b y≈v _) _ = [ b ] , _     , x≈b ∷ y≈v ∷ ≋-refl
   helper (a ∷ [])     bs (swap x≈v y≈a ↭) _ = []    , a ∷ _ , x≈v ∷ y≈a ∷ ≋-refl
-  helper (a ∷ b ∷ as) bs (swap x≈b y≈a as↭xs) (acc rec) with helper as bs as↭xs (rec _ ≤-refl)
+  helper (a ∷ b ∷ as) bs (swap x≈b y≈a as↭xs) (acc rec) with helper as bs as↭xs (rec ≤-refl)
   ... | (ps , qs , eq) = b ∷ a ∷ ps , qs , x≈b ∷ y≈a ∷ eq
-  helper as           bs (trans ↭₁ ↭₂) (acc rec) with helper as bs ↭₂ (rec _ (m<n+m (steps ↭₂) (0<steps ↭₁)))
+  helper as           bs (trans ↭₁ ↭₂) (acc rec) with helper as bs ↭₂ (rec (m<n+m (steps ↭₂) (0<steps ↭₁)))
   ... | (ps , qs , eq) = helper ps qs (↭-respʳ-≋ eq ↭₁)
-    (rec _ (subst (_< _) (sym (steps-respʳ eq ↭₁)) (m<m+n (steps ↭₁) (0<steps ↭₂))))
+      (rec (subst (_< _) (sym (steps-respʳ eq ↭₁)) (m<m+n (steps ↭₁) (0<steps ↭₂))))
 
 ------------------------------------------------------------------------
 -- filter
@@ -452,8 +455,8 @@ module _ {ℓ} {R : Rel A ℓ} (R? : B.Decidable R) where
   ... | true  | rec | _   = ↭-prep x rec
   ... | false | _   | rec = begin
     y ∷ merge R? (x ∷ xs) ys <⟨ rec ⟩
-    y ∷ x ∷ xs ++ ys         ↭˘⟨ ↭-shift (x ∷ xs) ys ⟩
-    (x ∷ xs) ++ y ∷ ys       ≡˘⟨ Lₚ.++-assoc [ x ] xs (y ∷ ys) ⟩
+    y ∷ x ∷ xs ++ ys         ↭⟨ ↭-shift (x ∷ xs) ys ⟨
+    (x ∷ xs) ++ y ∷ ys       ≡⟨ Lₚ.++-assoc [ x ] xs (y ∷ ys) ⟨
     x ∷ xs ++ y ∷ ys         ∎
     where open PermutationReasoning
 
@@ -473,3 +476,30 @@ module _ {ℓ} {R : Rel A ℓ} (R? : B.Decidable R) where
 ++↭ʳ++ : ∀ (xs ys : List A) → xs ++ ys ↭ xs ʳ++ ys
 ++↭ʳ++ []       ys = ↭-refl
 ++↭ʳ++ (x ∷ xs) ys = ↭-trans (↭-sym (↭-shift xs ys)) (++↭ʳ++ xs (x ∷ ys))
+
+------------------------------------------------------------------------
+-- foldr of Commutative Monoid
+
+module _ {_∙_ : Op₂ A} {ε : A} (isCmonoid : IsCommutativeMonoid _≈_ _∙_ ε) where
+  open module CM = IsCommutativeMonoid isCmonoid
+
+  private
+    module S = RelSetoid setoid
+
+    cmonoid : CommutativeMonoid _ _
+    cmonoid = record { isCommutativeMonoid = isCmonoid }
+
+  open ACM cmonoid
+
+  foldr-commMonoid : ∀ {xs ys} → xs ↭ ys → foldr _∙_ ε xs ≈ foldr _∙_ ε ys
+  foldr-commMonoid (refl []) = CM.refl
+  foldr-commMonoid (refl (x≈y ∷ xs≈ys)) = ∙-cong x≈y (foldr-commMonoid (Permutation.refl xs≈ys))
+  foldr-commMonoid (prep x≈y xs↭ys) = ∙-cong x≈y (foldr-commMonoid xs↭ys)
+  foldr-commMonoid (swap {xs} {ys} {x} {y} {x′} {y′} x≈x′ y≈y′ xs↭ys) = S.begin
+    x ∙ (y ∙ foldr _∙_ ε xs)   S.≈⟨ ∙-congˡ (∙-congˡ (foldr-commMonoid xs↭ys)) ⟩
+    x ∙ (y ∙ foldr _∙_ ε ys)   S.≈⟨ assoc x y (foldr _∙_ ε ys) ⟨
+    (x ∙ y) ∙ foldr _∙_ ε ys   S.≈⟨ ∙-congʳ (comm x y) ⟩
+    (y ∙ x) ∙ foldr _∙_ ε ys   S.≈⟨ ∙-congʳ (∙-cong y≈y′ x≈x′) ⟩
+    (y′ ∙ x′) ∙ foldr _∙_ ε ys S.≈⟨ assoc y′ x′ (foldr _∙_ ε ys) ⟩
+    y′ ∙ (x′ ∙ foldr _∙_ ε ys) S.∎
+  foldr-commMonoid (trans xs↭ys ys↭zs) = CM.trans (foldr-commMonoid xs↭ys) (foldr-commMonoid ys↭zs)
diff --git a/src/Data/List/Relation/Binary/Permutation/Setoid/Properties/Maybe.agda b/src/Data/List/Relation/Binary/Permutation/Setoid/Properties/Maybe.agda
new file mode 100644
index 0000000000..e453a599bb
--- /dev/null
+++ b/src/Data/List/Relation/Binary/Permutation/Setoid/Properties/Maybe.agda
@@ -0,0 +1,70 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Properties of permutations using setoid equality (on Maybe elements)
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.List.Relation.Binary.Permutation.Setoid.Properties.Maybe where
+
+open import Relation.Binary.Core using (_Preserves_⟶_)
+open import Relation.Binary.Bundles using (Setoid)
+
+open import Level using (Level)
+open import Function.Base using (_∘_; _$_)
+
+open import Data.List.Base using (catMaybes; mapMaybe)
+open import Data.List.Relation.Binary.Pointwise using (Pointwise; []; _∷_)
+import Data.List.Relation.Binary.Permutation.Setoid as Permutation
+open import Data.List.Relation.Binary.Permutation.Setoid.Properties
+
+open import Data.Maybe using (Maybe; nothing; just)
+open import Data.Maybe.Relation.Binary.Pointwise using (nothing; just)
+  renaming (setoid to setoidᴹ)
+
+private
+  variable
+    a b ℓ ℓ′ : Level
+
+------------------------------------------------------------------------
+-- catMaybes
+
+module _ (sᴬ : Setoid a ℓ) where
+  open Setoid sᴬ using (_≈_)
+  open Permutation sᴬ
+
+  private sᴹ = setoidᴹ sᴬ
+  open Setoid sᴹ using () renaming (_≈_ to _≈ᴹ_)
+  open Permutation sᴹ using () renaming (_↭_ to _↭ᴹ_)
+
+  catMaybes-↭ : ∀ {xs ys} → xs ↭ᴹ ys → catMaybes xs ↭ catMaybes ys
+  catMaybes-↭ (refl p) = refl (pointwise p)
+    where
+    pointwise : ∀ {xs ys} → Pointwise _≈ᴹ_ xs ys →
+                Pointwise _≈_ (catMaybes xs) (catMaybes ys)
+    pointwise []             = []
+    pointwise (just p  ∷ ps) = p ∷ pointwise ps
+    pointwise (nothing ∷ ps) = pointwise ps
+  catMaybes-↭ (trans xs↭ ↭ys)              = trans (catMaybes-↭ xs↭) (catMaybes-↭ ↭ys)
+  catMaybes-↭ (prep nothing    xs↭)        = catMaybes-↭ xs↭
+  catMaybes-↭ (prep (just x~y) xs↭)        = prep x~y $ catMaybes-↭ xs↭
+  catMaybes-↭ (swap nothing  nothing  xs↭) = catMaybes-↭ xs↭
+  catMaybes-↭ (swap nothing  (just y) xs↭) = prep y $ catMaybes-↭ xs↭
+  catMaybes-↭ (swap (just x) nothing  xs↭) = prep x $ catMaybes-↭ xs↭
+  catMaybes-↭ (swap (just x) (just y) xs↭) = swap x y $ catMaybes-↭ xs↭
+
+------------------------------------------------------------------------
+-- mapMaybe
+
+module _ (sᴬ : Setoid a ℓ) (sᴮ : Setoid b ℓ′) where
+  open Setoid sᴬ using () renaming (_≈_ to _≈ᴬ_)
+  open Permutation sᴬ using () renaming (_↭_ to _↭ᴬ_)
+  open Permutation sᴮ using () renaming (_↭_ to _↭ᴮ_)
+
+  private sᴹᴮ = setoidᴹ sᴮ
+  open Setoid sᴹᴮ using () renaming (_≈_ to _≈ᴹᴮ_)
+
+  mapMaybe-↭ : ∀ {f} → f Preserves _≈ᴬ_ ⟶ _≈ᴹᴮ_ →
+               ∀ {xs ys} → xs ↭ᴬ ys → mapMaybe f xs ↭ᴮ mapMaybe f ys
+  mapMaybe-↭ pres = catMaybes-↭ sᴮ ∘ map⁺ sᴬ sᴹᴮ pres
diff --git a/src/Data/List/Relation/Binary/Pointwise.agda b/src/Data/List/Relation/Binary/Pointwise.agda
index cadfaf0846..76e9d81f54 100644
--- a/src/Data/List/Relation/Binary/Pointwise.agda
+++ b/src/Data/List/Relation/Binary/Pointwise.agda
@@ -10,9 +10,9 @@ module Data.List.Relation.Binary.Pointwise where
 
 open import Algebra.Core using (Op₂)
 open import Function.Base
-open import Function.Inverse using (Inverse)
+open import Function.Bundles using (Inverse)
 open import Data.Bool.Base using (true; false)
-open import Data.Product hiding (map)
+open import Data.Product.Base hiding (map)
 open import Data.List.Base as List hiding (map; head; tail; uncons)
 open import Data.List.Properties using (≡-dec; length-++)
 open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
@@ -25,8 +25,12 @@ open import Level
 open import Relation.Nullary hiding (Irrelevant)
 import Relation.Nullary.Decidable as Dec using (map′)
 open import Relation.Unary as U using (Pred)
-open import Relation.Binary renaming (Rel to Rel₂)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core renaming (Rel to Rel₂)
+open import Relation.Binary.Definitions using (_Respects_; _Respects₂_)
+open import Relation.Binary.Bundles using (Setoid; DecSetoid; Preorder; Poset)
+open import Relation.Binary.Structures using (IsEquivalence; IsDecEquivalence; IsPartialOrder; IsPreorder)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 private
   variable
@@ -125,8 +129,8 @@ AllPairs-resp-Pointwise resp@(respₗ , respᵣ) (x∼y ∷ xs) (px ∷ pxs) =
 -- length
 
 Pointwise-length : Pointwise R xs ys → length xs ≡ length ys
-Pointwise-length []            = P.refl
-Pointwise-length (x∼y ∷ xs∼ys) = P.cong ℕ.suc (Pointwise-length xs∼ys)
+Pointwise-length []            = ≡.refl
+Pointwise-length (x∼y ∷ xs∼ys) = ≡.cong ℕ.suc (Pointwise-length xs∼ys)
 
 ------------------------------------------------------------------------
 -- tabulate
@@ -158,9 +162,9 @@ tabulate⁻ {n = suc n} (x∼y ∷ xs∼ys) (fsuc i) = tabulate⁻ xs∼ys i
 ++-cancelʳ (y ∷ ys) (z ∷ zs) (y∼z ∷ ys∼zs) = y∼z ∷ (++-cancelʳ ys zs ys∼zs)
 -- Impossible cases
 ++-cancelʳ {xs = xs}     []       (z ∷ zs) eq   =
-  contradiction (P.trans (Pointwise-length eq) (length-++ (z ∷ zs))) (m≢1+n+m (length xs))
+  contradiction (≡.trans (Pointwise-length eq) (length-++ (z ∷ zs))) (m≢1+n+m (length xs))
 ++-cancelʳ {xs = xs}     (y ∷ ys) []       eq   =
-  contradiction (P.trans (P.sym (length-++ (y ∷ ys))) (Pointwise-length eq)) (m≢1+n+m (length xs) ∘ P.sym)
+  contradiction (≡.trans (≡.sym (length-++ (y ∷ ys))) (Pointwise-length eq)) (m≢1+n+m (length xs) ∘ ≡.sym)
 
 ------------------------------------------------------------------------
 -- concat
@@ -242,8 +246,8 @@ lookup⁻ : length xs ≡ length ys →
           (∀ {i j} → toℕ i ≡ toℕ j → R (lookup xs i) (lookup ys j)) →
           Pointwise R xs ys
 lookup⁻ {xs = []}    {ys = []}    _             _  = []
-lookup⁻ {xs = _ ∷ _} {ys = _ ∷ _} |xs|≡|ys| eq = eq {fzero} P.refl ∷
-  lookup⁻ (suc-injective |xs|≡|ys|) (eq ∘ P.cong ℕ.suc)
+lookup⁻ {xs = _ ∷ _} {ys = _ ∷ _} |xs|≡|ys| eq = eq {fzero} ≡.refl ∷
+  lookup⁻ (suc-injective |xs|≡|ys|) (eq ∘ ≡.cong ℕ.suc)
 
 lookup⁺ : ∀ (Rxys : Pointwise R xs ys) →
           ∀ i → (let j = cast (Pointwise-length Rxys) i) →
@@ -256,19 +260,18 @@ lookup⁺ (_   ∷ Rxys) (fsuc i) = lookup⁺ Rxys i
 ------------------------------------------------------------------------
 
 Pointwise-≡⇒≡ : Pointwise {A = A} _≡_ ⇒ _≡_
-Pointwise-≡⇒≡ []               = P.refl
-Pointwise-≡⇒≡ (P.refl ∷ xs∼ys) with Pointwise-≡⇒≡ xs∼ys
-... | P.refl = P.refl
+Pointwise-≡⇒≡ []               = ≡.refl
+Pointwise-≡⇒≡ (≡.refl ∷ xs∼ys) with Pointwise-≡⇒≡ xs∼ys
+... | ≡.refl = ≡.refl
 
 ≡⇒Pointwise-≡ :  _≡_ ⇒ Pointwise {A = A} _≡_
-≡⇒Pointwise-≡ P.refl = refl P.refl
+≡⇒Pointwise-≡ ≡.refl = refl ≡.refl
 
-Pointwise-≡↔≡ : Inverse (setoid (P.setoid A)) (P.setoid (List A))
+Pointwise-≡↔≡ : Inverse (setoid (≡.setoid A)) (≡.setoid (List A))
 Pointwise-≡↔≡ = record
-  { to         = record { _⟨$⟩_ = id; cong = Pointwise-≡⇒≡ }
-  ; from       = record { _⟨$⟩_ = id; cong = ≡⇒Pointwise-≡ }
-  ; inverse-of = record
-    { left-inverse-of  = λ _ → refl P.refl
-    ; right-inverse-of = λ _ → P.refl
-    }
+  { to = id
+  ; from = id
+  ; to-cong = Pointwise-≡⇒≡
+  ; from-cong = ≡⇒Pointwise-≡
+  ; inverse = Pointwise-≡⇒≡ , ≡⇒Pointwise-≡
   }
diff --git a/src/Data/List/Relation/Binary/Pointwise/Base.agda b/src/Data/List/Relation/Binary/Pointwise/Base.agda
index 8e24dcd2dc..9a7a928742 100644
--- a/src/Data/List/Relation/Binary/Pointwise/Base.agda
+++ b/src/Data/List/Relation/Binary/Pointwise/Base.agda
@@ -8,16 +8,16 @@
 
 module Data.List.Relation.Binary.Pointwise.Base where
 
-open import Data.Product using (_×_; <_,_>)
+open import Data.Product.Base as Product using (_×_; _,_; <_,_>; ∃-syntax)
 open import Data.List.Base using (List; []; _∷_)
-open import Level
+open import Level using (Level; _⊔_)
 open import Relation.Binary.Core using (REL; _⇒_)
+open import Relation.Binary.Construct.Composition using (_;_)
 
 private
   variable
     a b c ℓ : Level
-    A : Set a
-    B : Set b
+    A B : Set a
     x y : A
     xs ys : List A
     R S : REL A B ℓ
@@ -58,3 +58,8 @@ rec P c n (Rxy ∷ Rxsys) = c Rxy (rec P c n Rxsys)
 map : R ⇒ S → Pointwise R ⇒ Pointwise S
 map R⇒S []            = []
 map R⇒S (Rxy ∷ Rxsys) = R⇒S Rxy ∷ map R⇒S Rxsys
+
+unzip : Pointwise (R ; S) ⇒ (Pointwise R ; Pointwise S)
+unzip [] = [] , [] , []
+unzip ((y , r , s) ∷ xs∼ys) =
+  Product.map (y ∷_) (Product.map (r ∷_) (s ∷_)) (unzip xs∼ys)
diff --git a/src/Data/List/Relation/Binary/Pointwise/Properties.agda b/src/Data/List/Relation/Binary/Pointwise/Properties.agda
index 61470fdc76..1761dd3cda 100644
--- a/src/Data/List/Relation/Binary/Pointwise/Properties.agda
+++ b/src/Data/List/Relation/Binary/Pointwise/Properties.agda
@@ -8,12 +8,12 @@
 
 module Data.List.Relation.Binary.Pointwise.Properties where
 
-open import Data.Product using (_,_; uncurry)
+open import Data.Product.Base using (_,_; uncurry)
 open import Data.List.Base using (List; []; _∷_)
 open import Level
 open import Relation.Binary.Core using (REL; _⇒_)
 open import Relation.Binary.Definitions
-import Relation.Binary.PropositionalEquality as P
+import Relation.Binary.PropositionalEquality.Core as ≡
 open import Relation.Nullary using (yes; no; _×-dec_)
 import Relation.Nullary.Decidable as Dec
 
@@ -72,6 +72,6 @@ decidable R? (x ∷ xs) (y ∷ ys) = Dec.map′ (uncurry _∷_) uncons
   (R? x y ×-dec decidable R? xs ys)
 
 irrelevant : Irrelevant R → Irrelevant (Pointwise R)
-irrelevant irr []       []         = P.refl
+irrelevant irr []       []         = ≡.refl
 irrelevant irr (r ∷ rs) (r₁ ∷ rs₁) =
-  P.cong₂ _∷_ (irr r r₁) (irrelevant irr rs rs₁)
+  ≡.cong₂ _∷_ (irr r r₁) (irrelevant irr rs rs₁)
diff --git a/src/Data/List/Relation/Binary/Prefix/Heterogeneous.agda b/src/Data/List/Relation/Binary/Prefix/Heterogeneous.agda
index 648663fc95..29a2fb5d02 100644
--- a/src/Data/List/Relation/Binary/Prefix/Heterogeneous.agda
+++ b/src/Data/List/Relation/Binary/Prefix/Heterogeneous.agda
@@ -12,8 +12,8 @@ open import Level
 open import Data.List.Base as List using (List; []; _∷_)
 open import Data.List.Relation.Binary.Pointwise
   using (Pointwise; []; _∷_)
-open import Data.Product using (∃; _×_; _,_; uncurry)
-open import Relation.Binary using (REL; _⇒_)
+open import Data.Product.Base using (∃; _×_; _,_; uncurry)
+open import Relation.Binary.Core using (REL; _⇒_)
 
 module _ {a b r} {A : Set a} {B : Set b} (R : REL A B r) where
 
@@ -45,14 +45,15 @@ module _ {a b r s} {A : Set a} {B : Set b} {R : REL A B r} {S : REL A B s} where
 
 module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
 
+  infixr 5 _++ᵖ_
+
   _++ᵖ_ : ∀ {as bs} → Prefix R as bs → ∀ suf → Prefix R as (bs List.++ suf)
   []       ++ᵖ suf = []
   (r ∷ rs) ++ᵖ suf = r ∷ (rs ++ᵖ suf)
 
   toView : ∀ {as bs} → Prefix R as bs → PrefixView R as bs
   toView []       = [] ++ _
-  toView (r ∷ rs) with toView rs
-  ... | rs′ ++ ds = (r ∷ rs′) ++ ds
+  toView (r ∷ rs) with rs′ ++ ds ← toView rs = (r ∷ rs′) ++ ds
 
   fromView : ∀ {as bs} → PrefixView R as bs → Prefix R as bs
   fromView ([]       ++ ds) = []
diff --git a/src/Data/List/Relation/Binary/Prefix/Heterogeneous/Properties.agda b/src/Data/List/Relation/Binary/Prefix/Heterogeneous/Properties.agda
index eea13df3b6..18f9871f1b 100644
--- a/src/Data/List/Relation/Binary/Prefix/Heterogeneous/Properties.agda
+++ b/src/Data/List/Relation/Binary/Prefix/Heterogeneous/Properties.agda
@@ -15,18 +15,20 @@ open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
 import Data.List.Relation.Unary.All.Properties as All
 open import Data.List.Base as List hiding (map; uncons)
 open import Data.List.Membership.Propositional.Properties using ([]∈inits)
-open import Data.List.Relation.Binary.Pointwise using (Pointwise; []; _∷_)
+open import Data.List.Relation.Binary.Pointwise.Base using (Pointwise; []; _∷_)
 open import Data.List.Relation.Binary.Prefix.Heterogeneous as Prefix hiding (PrefixView; _++_)
 open import Data.Nat.Base using (ℕ; zero; suc; _≤_; z≤n; s≤s)
 open import Data.Nat.Properties using (suc-injective)
-open import Data.Product as Prod using (_×_; _,_; proj₁; proj₂; uncurry)
+open import Data.Product.Base as Product using (_×_; _,_; proj₁; proj₂; uncurry)
 open import Function.Base
 
 open import Relation.Nullary.Negation using (¬_)
 open import Relation.Nullary.Decidable as Dec using (_×-dec_; yes; no; _because_)
 open import Relation.Unary as U using (Pred)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_; _≢_)
+open import Relation.Binary.Core using (Rel; REL; _⇒_)
+open import Relation.Binary.Definitions
+  using (Trans; Antisym; Irrelevant; Decidable)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; _≢_; refl; cong₂)
 
 private
   variable
@@ -156,7 +158,7 @@ replicate⁺ (s≤s m≤n) r = r ∷ replicate⁺ m≤n r
 
 replicate⁻ : ∀ {m n a b} → m ≢ 0 →
              Prefix R (replicate m a) (replicate n b) → R a b
-replicate⁻ {m = zero}  {n}     m≢0 r  = ⊥-elim (m≢0 P.refl)
+replicate⁻ {m = zero}  {n}     m≢0 r  = ⊥-elim (m≢0 refl)
 replicate⁻ {m = suc m} {suc n} m≢0 rs = Prefix.head rs
 
 ------------------------------------------------------------------------
@@ -206,9 +208,9 @@ module _ {a b c d} {A : Set a} {B : Set b} {C : Set c} {D : Set d}
 module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
 
   irrelevant : Irrelevant R → Irrelevant (Prefix R)
-  irrelevant R-irr []       []         = P.refl
+  irrelevant R-irr []       []         = refl
   irrelevant R-irr (r ∷ rs) (r′ ∷ rs′) =
-    P.cong₂ _∷_ (R-irr r r′) (irrelevant R-irr rs rs′)
+    cong₂ _∷_ (R-irr r r′) (irrelevant R-irr rs rs′)
 
 ------------------------------------------------------------------------
 -- Decidability
diff --git a/src/Data/List/Relation/Binary/Prefix/Homogeneous/Properties.agda b/src/Data/List/Relation/Binary/Prefix/Homogeneous/Properties.agda
index 97ee8cc41b..ad4291432e 100644
--- a/src/Data/List/Relation/Binary/Prefix/Homogeneous/Properties.agda
+++ b/src/Data/List/Relation/Binary/Prefix/Homogeneous/Properties.agda
@@ -10,7 +10,9 @@ module Data.List.Relation.Binary.Prefix.Homogeneous.Properties where
 
 open import Level
 open import Function.Base using (_∘′_)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; REL; _⇒_)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsDecPartialOrder)
 
 open import Data.List.Relation.Binary.Pointwise as Pointwise using (Pointwise)
 open import Data.List.Relation.Binary.Prefix.Heterogeneous
diff --git a/src/Data/List/Relation/Binary/Sublist/DecPropositional.agda b/src/Data/List/Relation/Binary/Sublist/DecPropositional.agda
index 6604f4aeec..a1df8dfd6e 100644
--- a/src/Data/List/Relation/Binary/Sublist/DecPropositional.agda
+++ b/src/Data/List/Relation/Binary/Sublist/DecPropositional.agda
@@ -8,18 +8,20 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
-open import Agda.Builtin.Equality using (_≡_)
+open import Relation.Binary.Definitions using (DecidableEquality)
 
 module Data.List.Relation.Binary.Sublist.DecPropositional
-  {a} {A : Set a} (_≟_ : Decidable {A = A} _≡_)
+  {a} {A : Set a} (_≟_ : DecidableEquality A)
   where
 
 open import Data.List.Relation.Binary.Equality.DecPropositional _≟_
   using (_≡?_)
 import Data.List.Relation.Binary.Sublist.DecSetoid as DecSetoidSublist
 import Data.List.Relation.Binary.Sublist.Propositional as PropositionalSublist
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Bundles using (DecPoset)
+open import Relation.Binary.Structures using (IsDecPartialOrder)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
 
 ------------------------------------------------------------------------
 -- Re-export core definitions and operations
diff --git a/src/Data/List/Relation/Binary/Sublist/DecPropositional/Solver.agda b/src/Data/List/Relation/Binary/Sublist/DecPropositional/Solver.agda
index 6ca8768c43..a68c5a2b2e 100644
--- a/src/Data/List/Relation/Binary/Sublist/DecPropositional/Solver.agda
+++ b/src/Data/List/Relation/Binary/Sublist/DecPropositional/Solver.agda
@@ -1,19 +1,18 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- A solver for proving that one list is a sublist of the other for types
--- which enjoy decidable equalities.
+-- A solver for proving that one list is a sublist of the other for
+-- types which enjoy decidable equalities.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Decidable)
-open import Agda.Builtin.Equality using (_≡_)
+open import Relation.Binary.Definitions using (DecidableEquality)
 
 module Data.List.Relation.Binary.Sublist.DecPropositional.Solver
-       {a} {A : Set a} (_≟_ : Decidable {A = A} _≡_)
+       {a} {A : Set a} (_≟_ : DecidableEquality A)
        where
 
-import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
 
-open import Data.List.Relation.Binary.Sublist.DecSetoid.Solver (P.decSetoid _≟_) public
+open import Data.List.Relation.Binary.Sublist.DecSetoid.Solver (decSetoid _≟_) public
diff --git a/src/Data/List/Relation/Binary/Sublist/DecSetoid.agda b/src/Data/List/Relation/Binary/Sublist/DecSetoid.agda
index 654d6c6a0e..a184386034 100644
--- a/src/Data/List/Relation/Binary/Sublist/DecSetoid.agda
+++ b/src/Data/List/Relation/Binary/Sublist/DecSetoid.agda
@@ -8,7 +8,10 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (DecSetoid; DecPoset)
+open import Relation.Binary.Structures
+  using (IsDecPartialOrder)
+open import Relation.Binary.Definitions using (Decidable)
 
 module Data.List.Relation.Binary.Sublist.DecSetoid
   {c ℓ} (S : DecSetoid c ℓ) where
diff --git a/src/Data/List/Relation/Binary/Sublist/DecSetoid/Solver.agda b/src/Data/List/Relation/Binary/Sublist/DecSetoid/Solver.agda
index b007311b23..7564052444 100644
--- a/src/Data/List/Relation/Binary/Sublist/DecSetoid/Solver.agda
+++ b/src/Data/List/Relation/Binary/Sublist/DecSetoid/Solver.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (DecSetoid)
+open import Relation.Binary.Bundles using (DecSetoid)
 
 module Data.List.Relation.Binary.Sublist.DecSetoid.Solver {c ℓ} (S : DecSetoid c ℓ) where
 
diff --git a/src/Data/List/Relation/Binary/Sublist/Heterogeneous.agda b/src/Data/List/Relation/Binary/Sublist/Heterogeneous.agda
index 854a6a1e8f..a0fe6b150c 100644
--- a/src/Data/List/Relation/Binary/Sublist/Heterogeneous.agda
+++ b/src/Data/List/Relation/Binary/Sublist/Heterogeneous.agda
@@ -11,8 +11,8 @@
 open import Data.List.Base using (List; []; _∷_; [_])
 open import Data.List.Relation.Unary.Any using (Any; here; there)
 open import Level using (_⊔_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (REL; _⇒_)
+open import Relation.Binary.Definitions using (_⟶_Respects_; Min)
 open import Relation.Unary using (Pred)
 
 module Data.List.Relation.Binary.Sublist.Heterogeneous
diff --git a/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Core.agda b/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Core.agda
index f57ac4a876..4ef8ae7793 100644
--- a/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Core.agda
+++ b/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Core.agda
@@ -13,7 +13,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (REL)
+open import Relation.Binary.Core using (REL)
 
 module Data.List.Relation.Binary.Sublist.Heterogeneous.Core
        {a b r} {A : Set a} {B : Set b} (R : REL A B r)
diff --git a/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Properties.agda b/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Properties.agda
index 7d13343130..8dd94d8b3b 100644
--- a/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Properties.agda
+++ b/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Properties.agda
@@ -1,4 +1,4 @@
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The Agda standard library
 --
 -- Properties of the heterogeneous sublist relation
@@ -11,53 +11,72 @@ module Data.List.Relation.Binary.Sublist.Heterogeneous.Properties where
 open import Level
 
 open import Data.Bool.Base using (true; false)
-open import Data.Empty
 open import Data.List.Relation.Unary.All using (Null; []; _∷_)
 open import Data.List.Relation.Unary.Any using (Any; here; there)
 open import Data.List.Base as List hiding (map; _∷ʳ_)
-import Data.List.Properties as Lₚ
+import Data.List.Properties as List
 open import Data.List.Relation.Unary.Any.Properties
   using (here-injective; there-injective)
 open import Data.List.Relation.Binary.Pointwise as Pw using (Pointwise; []; _∷_)
 open import Data.List.Relation.Binary.Sublist.Heterogeneous
 
-open import Data.Maybe.Relation.Unary.All as MAll using (nothing; just)
+open import Data.Maybe.Relation.Unary.All as Maybe using (nothing; just)
 open import Data.Nat.Base using (ℕ; _≤_; _≥_); open ℕ; open _≤_
-import Data.Nat.Properties as ℕₚ
-open import Data.Product using (∃₂; _×_; _,_; <_,_>; proj₂; uncurry)
+import Data.Nat.Properties as ℕ
+open import Data.Product.Base using (∃₂; _×_; _,_; <_,_>; proj₂; uncurry)
 
 open import Function.Base
 open import Function.Bundles using (_⤖_; _⇔_ ; mk⤖; mk⇔)
-
+open import Function.Consequences.Propositional using (strictlySurjective⇒surjective)
+open import Relation.Nullary.Decidable as Dec using (Dec; does; _because_; yes; no; ¬?)
+open import Relation.Nullary.Negation using (¬_; contradiction)
 open import Relation.Nullary.Reflects using (invert)
-open import Relation.Nullary using (Dec; does; _because_; yes; no; ¬_)
-open import Relation.Nullary.Decidable as Dec using (¬?)
 open import Relation.Unary as U using (Pred)
-open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (Rel; REL; _⇒_)
+open import Relation.Binary.Bundles using (Preorder; Poset; DecPoset)
+open import Relation.Binary.Definitions
+  using (Reflexive; Trans; Antisym; Decidable; Irrelevant; Irreflexive)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsDecPartialOrder)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+
+private
+  variable
+    a b c d e p q r s t : Level
+    A : Set a
+    B : Set b
+    C : Set c
+    D : Set d
+    x : A
+    y : B
+    as cs xs : List A
+    bs ds ys : List B
+    ass : List (List A)
+    bss : List (List B)
+    m n : ℕ
 
 ------------------------------------------------------------------------
 -- Injectivity of constructors
 
-module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
+module _ {R : REL A B r} where
 
-  ∷-injectiveˡ : ∀ {x y xs ys} {px qx : R x y} {pxs qxs : Sublist R xs ys} →
+  ∷-injectiveˡ : {px qx : R x y} {pxs qxs : Sublist R xs ys} →
                  (Sublist R (x ∷ xs) (y ∷ ys) ∋ px ∷ pxs) ≡ (qx ∷ qxs) → px ≡ qx
-  ∷-injectiveˡ P.refl = P.refl
+  ∷-injectiveˡ ≡.refl = ≡.refl
 
-  ∷-injectiveʳ : ∀ {x y xs ys} {px qx : R x y} {pxs qxs : Sublist R xs ys} →
+  ∷-injectiveʳ : {px qx : R x y} {pxs qxs : Sublist R xs ys} →
                  (Sublist R (x ∷ xs) (y ∷ ys) ∋ px ∷ pxs) ≡ (qx ∷ qxs) → pxs ≡ qxs
-  ∷-injectiveʳ P.refl = P.refl
+  ∷-injectiveʳ ≡.refl = ≡.refl
 
-  ∷ʳ-injective : ∀ {y xs ys} {pxs qxs : Sublist R xs ys} →
+  ∷ʳ-injective : {pxs qxs : Sublist R xs ys} →
                  (Sublist R xs (y ∷ ys) ∋ y ∷ʳ pxs) ≡ (y ∷ʳ qxs) → pxs ≡ qxs
-  ∷ʳ-injective P.refl = P.refl
+  ∷ʳ-injective ≡.refl = ≡.refl
 
-module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
+module _ {R : REL A B r} where
 
-  length-mono-≤ : ∀ {as bs} → Sublist R as bs → length as ≤ length bs
+  length-mono-≤ : Sublist R as bs → length as ≤ length bs
   length-mono-≤ []        = z≤n
-  length-mono-≤ (y ∷ʳ rs) = ℕₚ.m≤n⇒m≤1+n (length-mono-≤ rs)
+  length-mono-≤ (y ∷ʳ rs) = ℕ.m≤n⇒m≤1+n (length-mono-≤ rs)
   length-mono-≤ (r ∷ rs)  = s≤s (length-mono-≤ rs)
 
 ------------------------------------------------------------------------
@@ -67,30 +86,30 @@ module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
   fromPointwise []       = []
   fromPointwise (p ∷ ps) = p ∷ fromPointwise ps
 
-  toPointwise : ∀ {as bs} → length as ≡ length bs →
+  toPointwise : length as ≡ length bs →
                 Sublist R as bs → Pointwise R as bs
   toPointwise {bs = []}     eq []         = []
-  toPointwise {bs = b ∷ bs} eq (r ∷ rs)   = r ∷ toPointwise (ℕₚ.suc-injective eq) rs
+  toPointwise {bs = b ∷ bs} eq (r ∷ rs)   = r ∷ toPointwise (ℕ.suc-injective eq) rs
   toPointwise {bs = b ∷ bs} eq (b ∷ʳ rs) =
-    ⊥-elim $ ℕₚ.<-irrefl eq (s≤s (length-mono-≤ rs))
+    contradiction (s≤s (length-mono-≤ rs)) (ℕ.<-irrefl eq)
 
 ------------------------------------------------------------------------
 -- Various functions' outputs are sublists
 
 -- These lemmas are generalisations of results of the form `f xs ⊆ xs`.
--- (where _⊆_ stands for Sublist R). If R is reflexive then we can indeed
--- obtain `f xs ⊆ xs` from `xs ⊆ ys → f xs ⊆ ys`. The other direction is
--- only true if R is both reflexive and transitive.
+-- (where _⊆_ stands for Sublist R). If R is reflexive then we can
+-- indeed obtain `f xs ⊆ xs` from `xs ⊆ ys → f xs ⊆ ys`. The other
+-- direction is only true if R is both reflexive and transitive.
 
-module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
+module _ {R : REL A B r} where
 
-  tail-Sublist : ∀ {as bs} → Sublist R as bs →
-                 MAll.All (λ as → Sublist R as bs) (tail as)
+  tail-Sublist : Sublist R as bs →
+                 Maybe.All (λ as → Sublist R as bs) (tail as)
   tail-Sublist []        = nothing
-  tail-Sublist (b ∷ʳ ps) = MAll.map (b ∷ʳ_) (tail-Sublist ps)
+  tail-Sublist (b ∷ʳ ps) = Maybe.map (b ∷ʳ_) (tail-Sublist ps)
   tail-Sublist (p ∷ ps)  = just (_ ∷ʳ ps)
 
-  take-Sublist : ∀ {as bs} n → Sublist R as bs → Sublist R (take n as) bs
+  take-Sublist : ∀ n → Sublist R as bs → Sublist R (take n as) bs
   take-Sublist n       (y ∷ʳ rs) = y ∷ʳ take-Sublist n rs
   take-Sublist zero    rs        = minimum _
   take-Sublist (suc n) []        = []
@@ -102,24 +121,23 @@ module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
   drop-Sublist (suc n) []        = []
   drop-Sublist (suc n) (r ∷ rs)  = _ ∷ʳ drop-Sublist n rs
 
-module _ {a b r p} {A : Set a} {B : Set b}
-         {R : REL A B r} {P : Pred A p} (P? : U.Decidable P) where
+module _ {R : REL A B r} {P : Pred A p} (P? : U.Decidable P) where
 
-  takeWhile-Sublist : ∀ {as bs} → Sublist R as bs → Sublist R (takeWhile P? as) bs
+  takeWhile-Sublist : Sublist R as bs → Sublist R (takeWhile P? as) bs
   takeWhile-Sublist []        = []
   takeWhile-Sublist (y ∷ʳ rs) = y ∷ʳ takeWhile-Sublist rs
   takeWhile-Sublist {a ∷ as} (r ∷ rs) with does (P? a)
   ... | true  = r ∷ takeWhile-Sublist rs
   ... | false = minimum _
 
-  dropWhile-Sublist : ∀ {as bs} → Sublist R as bs → Sublist R (dropWhile P? as) bs
+  dropWhile-Sublist : Sublist R as bs → Sublist R (dropWhile P? as) bs
   dropWhile-Sublist []        = []
   dropWhile-Sublist (y ∷ʳ rs) = y ∷ʳ dropWhile-Sublist rs
   dropWhile-Sublist {a ∷ as} (r ∷ rs) with does (P? a)
   ... | true  = _ ∷ʳ dropWhile-Sublist rs
   ... | false = r ∷ rs
 
-  filter-Sublist : ∀ {as bs} → Sublist R as bs → Sublist R (filter P? as) bs
+  filter-Sublist : Sublist R as bs → Sublist R (filter P? as) bs
   filter-Sublist []        = []
   filter-Sublist (y ∷ʳ rs) = y ∷ʳ filter-Sublist rs
   filter-Sublist {a ∷ as} (r ∷ rs) with does (P? a)
@@ -132,65 +150,64 @@ module _ {a b r p} {A : Set a} {B : Set b}
 -- We write f⁺ for the proof that `xs ⊆ ys → f xs ⊆ f ys`
 -- and f⁻ for the one that `f xs ⊆ f ys → xs ⊆ ys`.
 
-module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
+module _ {R : REL A B r} where
 
 ------------------------------------------------------------------------
 -- _∷_
 
-  ∷ˡ⁻ : ∀ {a as bs} → Sublist R (a ∷ as) bs → Sublist R as bs
+  ∷ˡ⁻ : Sublist R (x ∷ xs) ys → Sublist R xs ys
   ∷ˡ⁻ (y ∷ʳ rs) = y ∷ʳ ∷ˡ⁻ rs
   ∷ˡ⁻ (r ∷  rs) = _ ∷ʳ rs
 
-  ∷ʳ⁻ : ∀ {a as b bs} → ¬ R a b → Sublist R (a ∷ as) (b ∷ bs) →
-        Sublist R (a ∷ as) bs
+  ∷ʳ⁻ : ¬ R x y → Sublist R (x ∷ xs) (y ∷ ys) →
+        Sublist R (x ∷ xs) ys
   ∷ʳ⁻ ¬r (y ∷ʳ rs) = rs
-  ∷ʳ⁻ ¬r (r ∷  rs) = ⊥-elim (¬r r)
+  ∷ʳ⁻ ¬r (r ∷  rs) = contradiction r ¬r
 
-  ∷⁻ : ∀ {a as b bs} → Sublist R (a ∷ as) (b ∷ bs) → Sublist R as bs
+  ∷⁻ : Sublist R (x ∷ xs) (y ∷ ys) → Sublist R xs ys
   ∷⁻ (y ∷ʳ rs) = ∷ˡ⁻ rs
   ∷⁻ (x ∷  rs) = rs
 
-module _ {a b c d r} {A : Set a} {B : Set b} {C : Set c} {D : Set d}
-         {R : REL C D r} where
+module _ {R : REL C D r} where
 
 ------------------------------------------------------------------------
 -- map
 
-  map⁺ : ∀ {as bs} (f : A → C) (g : B → D) →
+  map⁺ : (f : A → C) (g : B → D) →
          Sublist (λ a b → R (f a) (g b)) as bs →
          Sublist R (List.map f as) (List.map g bs)
   map⁺ f g []        = []
   map⁺ f g (y ∷ʳ rs) = g y ∷ʳ map⁺ f g rs
   map⁺ f g (r ∷ rs)  = r ∷ map⁺ f g rs
 
-  map⁻ : ∀ {as bs} (f : A → C) (g : B → D) →
+  map⁻ : (f : A → C) (g : B → D) →
          Sublist R (List.map f as) (List.map g bs) →
          Sublist (λ a b → R (f a) (g b)) as bs
-  map⁻ {[]}     {bs}     f g rs        = minimum _
-  map⁻ {a ∷ as} {b ∷ bs} f g (_ ∷ʳ rs) = b ∷ʳ map⁻ f g rs
-  map⁻ {a ∷ as} {b ∷ bs} f g (r ∷ rs)  = r ∷ map⁻ f g rs
+  map⁻ {as = []}     {bs}     f g rs        = minimum _
+  map⁻ {as = a ∷ as} {b ∷ bs} f g (_ ∷ʳ rs) = b ∷ʳ map⁻ f g rs
+  map⁻ {as = a ∷ as} {b ∷ bs} f g (r ∷ rs)  = r ∷ map⁻ f g rs
 
 
-module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
+module _ {R : REL A B r} where
 
 ------------------------------------------------------------------------
 -- _++_
 
-  ++⁺ : ∀ {as bs cs ds} → Sublist R as bs → Sublist R cs ds →
+  ++⁺ : Sublist R as bs → Sublist R cs ds →
         Sublist R (as ++ cs) (bs ++ ds)
   ++⁺ []         cds = cds
   ++⁺ (y ∷ʳ abs) cds = y ∷ʳ ++⁺ abs cds
   ++⁺ (ab ∷ abs) cds = ab ∷ ++⁺ abs cds
 
-  ++⁻ : ∀ {as bs cs ds} → length as ≡ length bs →
+  ++⁻ : length as ≡ length bs →
         Sublist R (as ++ cs) (bs ++ ds) → Sublist R cs ds
-  ++⁻ {[]}     {[]}     eq rs = rs
-  ++⁻ {a ∷ as} {b ∷ bs} eq rs = ++⁻ (ℕₚ.suc-injective eq) (∷⁻ rs)
+  ++⁻ {as = []}     {[]}     eq rs = rs
+  ++⁻ {as = a ∷ as} {b ∷ bs} eq rs = ++⁻ (ℕ.suc-injective eq) (∷⁻ rs)
 
-  ++ˡ : ∀ {as bs} (cs : List B) → Sublist R as bs → Sublist R as (cs ++ bs)
+  ++ˡ : (cs : List B) → Sublist R as bs → Sublist R as (cs ++ bs)
   ++ˡ zs = ++⁺ (minimum zs)
 
-  ++ʳ : ∀ {as bs} (cs : List B) → Sublist R as bs → Sublist R as (bs ++ cs)
+  ++ʳ : (cs : List B) → Sublist R as bs → Sublist R as (bs ++ cs)
   ++ʳ cs []        = minimum cs
   ++ʳ cs (y ∷ʳ rs) = y ∷ʳ ++ʳ cs rs
   ++ʳ cs (r ∷ rs)  = r ∷ ++ʳ cs rs
@@ -199,7 +216,7 @@ module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
 ------------------------------------------------------------------------
 -- concat
 
-  concat⁺ : ∀ {ass bss} → Sublist (Sublist R) ass bss →
+  concat⁺ : Sublist (Sublist R) ass bss →
             Sublist R (concat ass) (concat bss)
   concat⁺ []          = []
   concat⁺ (y  ∷ʳ rss) = ++ˡ y (concat⁺ rss)
@@ -208,52 +225,51 @@ module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
 ------------------------------------------------------------------------
 -- take / drop
 
-  take⁺ : ∀ {m n as bs} → m ≤ n → Pointwise R as bs →
+  take⁺ : m ≤ n → Pointwise R as bs →
           Sublist R (take m as) (take n bs)
   take⁺ z≤n       ps        = minimum _
   take⁺ (s≤s m≤n) []        = []
   take⁺ (s≤s m≤n) (p ∷  ps) = p ∷ take⁺ m≤n ps
 
-  drop⁺ : ∀ {m n as bs} → m ≥ n → Sublist R as bs →
+  drop⁺ : m ≥ n → Sublist R as bs →
           Sublist R (drop m as) (drop n bs)
-  drop⁺ {m} z≤n       rs        = drop-Sublist m rs
-  drop⁺     (s≤s m≥n) []        = []
-  drop⁺     (s≤s m≥n) (y ∷ʳ rs) = drop⁺ (ℕₚ.m≤n⇒m≤1+n m≥n) rs
-  drop⁺     (s≤s m≥n) (r ∷ rs)  = drop⁺ m≥n rs
+  drop⁺ (z≤n {m}) rs        = drop-Sublist m rs
+  drop⁺ (s≤s m≥n) []        = []
+  drop⁺ (s≤s m≥n) (y ∷ʳ rs) = drop⁺ (ℕ.m≤n⇒m≤1+n m≥n) rs
+  drop⁺ (s≤s m≥n) (r ∷ rs)  = drop⁺ m≥n rs
 
-  drop⁺-≥ : ∀ {m n as bs} → m ≥ n → Pointwise R as bs →
+  drop⁺-≥ : m ≥ n → Pointwise R as bs →
             Sublist R (drop m as) (drop n bs)
   drop⁺-≥ m≥n pw = drop⁺ m≥n (fromPointwise pw)
 
-  drop⁺-⊆ : ∀ {as bs} m → Sublist R as bs →
+  drop⁺-⊆ : ∀ m → Sublist R as bs →
             Sublist R (drop m as) (drop m bs)
-  drop⁺-⊆ m = drop⁺ (ℕₚ.≤-refl {m})
+  drop⁺-⊆ m = drop⁺ (ℕ.≤-refl {m})
 
-module _ {a b r p q} {A : Set a} {B : Set b}
-         {R : REL A B r} {P : Pred A p} {Q : Pred B q}
+module _ {R : REL A B r} {P : Pred A p} {Q : Pred B q}
          (P? : U.Decidable P) (Q? : U.Decidable Q) where
 
-  ⊆-takeWhile-Sublist : ∀ {as bs} →
-    (∀ {a b} → R a b → P a → Q b) →
-    Pointwise R as bs → Sublist R (takeWhile P? as) (takeWhile Q? bs)
+  ⊆-takeWhile-Sublist : (∀ {a b} → R a b → P a → Q b) →
+                        Pointwise R as bs →
+                        Sublist R (takeWhile P? as) (takeWhile Q? bs)
   ⊆-takeWhile-Sublist rp⇒q [] = []
   ⊆-takeWhile-Sublist {a ∷ as} {b ∷ bs} rp⇒q (p ∷ ps) with P? a | Q? b
   ... | false because _ | _               = minimum _
   ... | true  because _ | true  because _ = p ∷ ⊆-takeWhile-Sublist rp⇒q ps
-  ... | yes pa          | no ¬qb          = ⊥-elim $ ¬qb $ rp⇒q p pa
+  ... | yes pa          | no ¬qb          = contradiction (rp⇒q p pa) ¬qb
 
-  ⊇-dropWhile-Sublist : ∀ {as bs} →
-    (∀ {a b} → R a b → Q b → P a) →
-    Pointwise R as bs → Sublist R (dropWhile P? as) (dropWhile Q? bs)
+  ⊇-dropWhile-Sublist : (∀ {a b} → R a b → Q b → P a) →
+                        Pointwise R as bs →
+                        Sublist R (dropWhile P? as) (dropWhile Q? bs)
   ⊇-dropWhile-Sublist rq⇒p [] = []
   ⊇-dropWhile-Sublist {a ∷ as} {b ∷ bs} rq⇒p (p ∷ ps) with P? a | Q? b
   ... | true  because _ | true  because _ = ⊇-dropWhile-Sublist rq⇒p ps
   ... | true  because _ | false because _ =
     b ∷ʳ dropWhile-Sublist P? (fromPointwise ps)
   ... | false because _ | false because _ = p ∷ fromPointwise ps
-  ... | no ¬pa          | yes qb          = ⊥-elim $ ¬pa $ rq⇒p p qb
+  ... | no ¬pa          | yes qb          = contradiction (rq⇒p p qb) ¬pa
 
-  ⊆-filter-Sublist : ∀ {as bs} → (∀ {a b} → R a b → P a → Q b) →
+  ⊆-filter-Sublist : (∀ {a b} → R a b → P a → Q b) →
                      Sublist R as bs → Sublist R (filter P? as) (filter Q? bs)
   ⊆-filter-Sublist rp⇒q [] = []
   ⊆-filter-Sublist rp⇒q (y ∷ʳ rs) with does (Q? y)
@@ -263,18 +279,18 @@ module _ {a b r p q} {A : Set a} {B : Set b}
   ... | true  because _ | true  because _ = r ∷ ⊆-filter-Sublist rp⇒q rs
   ... | false because _ | true  because _ = _ ∷ʳ ⊆-filter-Sublist rp⇒q rs
   ... | false because _ | false because _ = ⊆-filter-Sublist rp⇒q rs
-  ... | yes pa          | no ¬qb          = ⊥-elim $ ¬qb $ rp⇒q r pa
+  ... | yes pa          | no ¬qb          = contradiction (rp⇒q r pa) ¬qb
 
-module _ {a r p} {A : Set a} {R : Rel A r} {P : Pred A p} (P? : U.Decidable P) where
+module _ {R : Rel A r} {P : Pred A p} (P? : U.Decidable P) where
 
-  takeWhile-filter : ∀ {as} → Pointwise R as as →
+  takeWhile-filter : Pointwise R as as →
                      Sublist R (takeWhile P? as) (filter P? as)
   takeWhile-filter [] = []
   takeWhile-filter {a ∷ as} (p ∷ ps) with does (P? a)
   ... | true  = p ∷ takeWhile-filter ps
   ... | false = minimum _
 
-  filter-dropWhile : ∀ {as} → Pointwise R as as →
+  filter-dropWhile : Pointwise R as as →
                      Sublist R (filter P? as) (dropWhile (¬? ∘ P?) as)
   filter-dropWhile [] = []
   filter-dropWhile {a ∷ as} (p ∷ ps) with does (P? a)
@@ -284,86 +300,83 @@ module _ {a r p} {A : Set a} {R : Rel A r} {P : Pred A p} (P? : U.Decidable P) w
 ------------------------------------------------------------------------
 -- reverse
 
-module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
+module _ {R : REL A B r} where
 
-  reverseAcc⁺ : ∀ {as bs cs ds} → Sublist R as bs → Sublist R cs ds →
+  reverseAcc⁺ : Sublist R as bs → Sublist R cs ds →
                 Sublist R (reverseAcc cs as) (reverseAcc ds bs)
   reverseAcc⁺ []         cds = cds
   reverseAcc⁺ (y ∷ʳ abs) cds = reverseAcc⁺ abs (y ∷ʳ cds)
   reverseAcc⁺ (r ∷ abs)  cds = reverseAcc⁺ abs (r ∷ cds)
 
-  ʳ++⁺ : ∀ {as bs cs ds} →
-         Sublist R as bs →
-         Sublist R cs ds →
+  ʳ++⁺ : Sublist R as bs → Sublist R cs ds →
          Sublist R (as ʳ++ cs) (bs ʳ++ ds)
   ʳ++⁺ = reverseAcc⁺
 
-  reverse⁺ : ∀ {as bs} → Sublist R as bs → Sublist R (reverse as) (reverse bs)
+  reverse⁺ : Sublist R as bs → Sublist R (reverse as) (reverse bs)
   reverse⁺ rs = reverseAcc⁺ rs []
 
-  reverse⁻ : ∀ {as bs} → Sublist R (reverse as) (reverse bs) → Sublist R as bs
-  reverse⁻ {as} {bs} p = cast (reverse⁺ p) where
-    cast = P.subst₂ (Sublist R) (Lₚ.reverse-involutive as) (Lₚ.reverse-involutive bs)
+  reverse⁻ : Sublist R (reverse as) (reverse bs) → Sublist R as bs
+  reverse⁻ {as = as} {bs = bs} p = cast (reverse⁺ p) where
+    cast = ≡.subst₂ (Sublist R) (List.reverse-involutive as) (List.reverse-involutive bs)
 
 ------------------------------------------------------------------------
 -- Inversion lemmas
 
-module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} {a as b bs} where
+module _ {R : REL A B r} where
 
-  ∷⁻¹ : R a b → Sublist R as bs ⇔ Sublist R (a ∷ as) (b ∷ bs)
+  ∷⁻¹ : R x y → Sublist R xs ys ⇔ Sublist R (x ∷ xs) (y ∷ ys)
   ∷⁻¹ r = mk⇔ (r ∷_) ∷⁻
 
-  ∷ʳ⁻¹ : ¬ R a b → Sublist R (a ∷ as) bs ⇔ Sublist R (a ∷ as) (b ∷ bs)
+  ∷ʳ⁻¹ : ¬ R x y → Sublist R (x ∷ xs) ys ⇔ Sublist R (x ∷ xs) (y ∷ ys)
   ∷ʳ⁻¹ ¬r = mk⇔ (_ ∷ʳ_) (∷ʳ⁻ ¬r)
 
 ------------------------------------------------------------------------
 -- Irrelevant special case
 
-module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
+module _ {R : REL A B r} where
 
   Sublist-[]-irrelevant : U.Irrelevant (Sublist R [])
-  Sublist-[]-irrelevant []       []        = P.refl
-  Sublist-[]-irrelevant (y ∷ʳ p) (.y ∷ʳ q) = P.cong (y ∷ʳ_) (Sublist-[]-irrelevant p q)
+  Sublist-[]-irrelevant []       []        = ≡.refl
+  Sublist-[]-irrelevant (y ∷ʳ p) (.y ∷ʳ q) = ≡.cong (y ∷ʳ_) (Sublist-[]-irrelevant p q)
 
 ------------------------------------------------------------------------
 -- (to/from)Any is a bijection
 
-  toAny-injective : ∀ {xs x} {p q : Sublist R [ x ] xs} → toAny p ≡ toAny q → p ≡ q
+  toAny-injective :{p q : Sublist R [ x ] xs} → toAny p ≡ toAny q → p ≡ q
   toAny-injective {p = y ∷ʳ p} {y ∷ʳ q} =
-    P.cong (y ∷ʳ_) ∘′ toAny-injective ∘′ there-injective
+    ≡.cong (y ∷ʳ_) ∘′ toAny-injective ∘′ there-injective
   toAny-injective {p = _ ∷ p}  {_ ∷ q}  =
-    P.cong₂ (flip _∷_) (Sublist-[]-irrelevant p q) ∘′ here-injective
+    ≡.cong₂ (flip _∷_) (Sublist-[]-irrelevant p q) ∘′ here-injective
 
-  fromAny-injective : ∀ {xs x} {p q : Any (R x) xs} →
+  fromAny-injective : {p q : Any (R x) xs} →
                       fromAny {R = R} p ≡ fromAny q → p ≡ q
-  fromAny-injective {p = here px} {here qx} = P.cong here ∘′ ∷-injectiveˡ
+  fromAny-injective {p = here px} {here qx} = ≡.cong here ∘′ ∷-injectiveˡ
   fromAny-injective {p = there p} {there q} =
-    P.cong there ∘′ fromAny-injective ∘′ ∷ʳ-injective
+    ≡.cong there ∘′ fromAny-injective ∘′ ∷ʳ-injective
 
-  toAny∘fromAny≗id : ∀ {xs x} (p : Any (R x) xs) → toAny (fromAny {R = R} p) ≡ p
-  toAny∘fromAny≗id (here px) = P.refl
-  toAny∘fromAny≗id (there p) = P.cong there (toAny∘fromAny≗id p)
+  toAny∘fromAny≗id : (p : Any (R x) xs) → toAny (fromAny {R = R} p) ≡ p
+  toAny∘fromAny≗id (here px) = ≡.refl
+  toAny∘fromAny≗id (there p) = ≡.cong there (toAny∘fromAny≗id p)
 
-  Sublist-[x]-bijection : ∀ {x xs} → (Sublist R [ x ] xs) ⤖ (Any (R x) xs)
-  Sublist-[x]-bijection = mk⤖ (toAny-injective , < fromAny , toAny∘fromAny≗id >)
+  Sublist-[x]-bijection : (Sublist R [ x ] xs) ⤖ (Any (R x) xs)
+  Sublist-[x]-bijection = mk⤖ (toAny-injective , strictlySurjective⇒surjective < fromAny , toAny∘fromAny≗id >)
 
 ------------------------------------------------------------------------
 -- Relational properties
 
 module Reflexivity
-    {a r} {A : Set a} {R : Rel A r}
+    {R : Rel A r}
     (R-refl : Reflexive R) where
 
   reflexive : _≡_ ⇒ Sublist R
-  reflexive P.refl = fromPointwise (Pw.refl R-refl)
+  reflexive ≡.refl = fromPointwise (Pw.refl R-refl)
 
   refl : Reflexive (Sublist R)
-  refl = reflexive P.refl
+  refl = reflexive ≡.refl
 
 open Reflexivity public
 
 module Transitivity
-    {a b c r s t} {A : Set a} {B : Set b} {C : Set c}
     {R : REL A B r} {S : REL B C s} {T : REL A C t}
     (rs⇒t : Trans R S T) where
 
@@ -376,36 +389,35 @@ module Transitivity
 open Transitivity public
 
 module Antisymmetry
-    {a b r s e} {A : Set a} {B : Set b}
     {R : REL A B r} {S : REL B A s} {E : REL A B e}
     (rs⇒e : Antisym R S E) where
 
-  open ℕₚ.≤-Reasoning
+  open ℕ.≤-Reasoning
 
   antisym : Antisym (Sublist R) (Sublist S) (Pointwise E)
   antisym []        []        = []
   antisym (r ∷ rs)  (s ∷ ss)  = rs⇒e r s ∷ antisym rs ss
   -- impossible cases
   antisym (_∷ʳ_ {xs} {ys₁} y rs) (_∷ʳ_ {ys₂} {zs} z ss) =
-    ⊥-elim $ ℕₚ.<-irrefl P.refl $ begin
+    contradiction (begin
     length (y ∷ ys₁) ≤⟨ length-mono-≤ ss ⟩
-    length zs        ≤⟨ ℕₚ.n≤1+n (length zs) ⟩
+    length zs        ≤⟨ ℕ.n≤1+n (length zs) ⟩
     length (z ∷ zs)  ≤⟨ length-mono-≤ rs ⟩
-    length ys₁       ∎
+    length ys₁       ∎) $ ℕ.<-irrefl ≡.refl
   antisym (_∷ʳ_ {xs} {ys₁} y rs) (_∷_ {y} {ys₂} {z} {zs} s ss)  =
-    ⊥-elim $ ℕₚ.<-irrefl P.refl $ begin
+    contradiction (begin
     length (z ∷ zs) ≤⟨ length-mono-≤ rs ⟩
     length ys₁      ≤⟨ length-mono-≤ ss ⟩
-    length zs       ∎
+    length zs       ∎) $ ℕ.<-irrefl ≡.refl
   antisym (_∷_ {x} {xs} {y} {ys₁} r rs)  (_∷ʳ_ {ys₂} {zs} z ss) =
-    ⊥-elim $ ℕₚ.<-irrefl P.refl $ begin
+    contradiction (begin
     length (y ∷ ys₁) ≤⟨ length-mono-≤ ss ⟩
     length xs        ≤⟨ length-mono-≤ rs ⟩
-    length ys₁       ∎
+    length ys₁       ∎) $ ℕ.<-irrefl ≡.refl
 
 open Antisymmetry public
 
-module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} (R? : Decidable R) where
+module _ {R : REL A B r} (R? : Decidable R) where
 
   sublist? : Decidable (Sublist R)
   sublist? []       ys       = yes (minimum ys)
@@ -416,7 +428,7 @@ module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} (R? : Decidable R) wher
   ... | false because [¬r] =
     Dec.map (∷ʳ⁻¹ (invert [¬r])) (sublist? (x ∷ xs) ys)
 
-module _ {a e r} {A : Set a} {E : Rel A e} {R : Rel A r} where
+module _ {E : Rel A e} {R : Rel A r} where
 
   isPreorder : IsPreorder E R → IsPreorder (Pointwise E) (Sublist R)
   isPreorder ER-isPreorder = record
@@ -439,22 +451,20 @@ module _ {a e r} {A : Set a} {E : Rel A e} {R : Rel A r} where
     ; _≤?_           = sublist?       ER._≤?_
     } where module ER = IsDecPartialOrder ER-isDecPartialOrder
 
-module _ {a e r} where
+preorder : Preorder a e r → Preorder _ _ _
+preorder ER-preorder = record
+  { isPreorder = isPreorder ER.isPreorder
+  } where module ER = Preorder ER-preorder
 
-  preorder : Preorder a e r → Preorder _ _ _
-  preorder ER-preorder = record
-    { isPreorder = isPreorder ER.isPreorder
-    } where module ER = Preorder ER-preorder
-
-  poset : Poset a e r → Poset _ _ _
-  poset ER-poset = record
-    { isPartialOrder = isPartialOrder ER.isPartialOrder
-    } where module ER = Poset ER-poset
+poset : Poset a e r → Poset _ _ _
+poset ER-poset = record
+  { isPartialOrder = isPartialOrder ER.isPartialOrder
+  } where module ER = Poset ER-poset
 
-  decPoset : DecPoset a e r → DecPoset _ _ _
-  decPoset ER-poset = record
-    { isDecPartialOrder = isDecPartialOrder ER.isDecPartialOrder
-    } where module ER = DecPoset ER-poset
+decPoset : DecPoset a e r → DecPoset _ _ _
+decPoset ER-poset = record
+  { isDecPartialOrder = isDecPartialOrder ER.isDecPartialOrder
+  } where module ER = DecPoset ER-poset
 
 ------------------------------------------------------------------------
 -- Properties of disjoint sublists
@@ -501,10 +511,10 @@ module Disjointness {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
   -- Disjoint is proof-irrelevant
 
   Disjoint-irrelevant : ∀{xs ys zs} → Irrelevant (Disjoint {R = R} {xs} {ys} {zs})
-  Disjoint-irrelevant [] [] = P.refl
-  Disjoint-irrelevant (y   ∷ₙ d₁) (.y   ∷ₙ d₂) = P.cong (y ∷ₙ_) (Disjoint-irrelevant d₁ d₂)
-  Disjoint-irrelevant (x≈y ∷ₗ d₁) (.x≈y ∷ₗ d₂) = P.cong (x≈y ∷ₗ_) (Disjoint-irrelevant d₁ d₂)
-  Disjoint-irrelevant (x≈y ∷ᵣ d₁) (.x≈y ∷ᵣ d₂) = P.cong (x≈y ∷ᵣ_) (Disjoint-irrelevant d₁ d₂)
+  Disjoint-irrelevant [] [] = ≡.refl
+  Disjoint-irrelevant (y   ∷ₙ d₁) (.y   ∷ₙ d₂) = ≡.cong (y ∷ₙ_) (Disjoint-irrelevant d₁ d₂)
+  Disjoint-irrelevant (x≈y ∷ₗ d₁) (.x≈y ∷ₗ d₂) = ≡.cong (x≈y ∷ₗ_) (Disjoint-irrelevant d₁ d₂)
+  Disjoint-irrelevant (x≈y ∷ᵣ d₁) (.x≈y ∷ᵣ d₂) = ≡.cong (x≈y ∷ᵣ_) (Disjoint-irrelevant d₁ d₂)
 
   -- Note: DisjointUnion is not proof-irrelevant unless the underlying relation R is.
   -- The proof is not entirely trivial, thus, we leave it for future work:
@@ -520,7 +530,7 @@ module Disjointness {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
   Disjoint-irrefl′ (y ∷ₙ d) = Disjoint-irrefl′ d
 
   Disjoint-irrefl : ∀{x xs ys} → Irreflexive {A = x ∷ xs ⊆ ys } _≡_ Disjoint
-  Disjoint-irrefl P.refl x with Disjoint-irrefl′ x
+  Disjoint-irrefl ≡.refl x with Disjoint-irrefl′ x
   ... | () ∷ _
 
   -- Symmetry
@@ -665,7 +675,6 @@ open Disjointness public
 -- Monotonicity of disjointness.
 
 module DisjointnessMonotonicity
-    {a b c r s t} {A : Set a} {B : Set b} {C : Set c}
     {R : REL A B r} {S : REL B C s} {T : REL A C t}
     (rs⇒t : Trans R S T) where
 
diff --git a/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Solver.agda b/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Solver.agda
index 9066338e8a..11db87fa52 100644
--- a/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Solver.agda
+++ b/src/Data/List/Relation/Binary/Sublist/Heterogeneous/Solver.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; Reflexive; Decidable)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Reflexive; Decidable)
 
 module Data.List.Relation.Binary.Sublist.Heterogeneous.Solver
   {a r} {A : Set a} (R : Rel A r)
@@ -20,22 +21,23 @@ module Data.List.Relation.Binary.Sublist.Heterogeneous.Solver
 
 open import Level using (_⊔_)
 open import Data.Fin as Fin
-open import Data.Maybe.Base as M
-open import Data.Nat.Base as Nat using (ℕ)
-open import Data.Product
+open import Data.Maybe.Base as Maybe using (Maybe; nothing; just; From-just; from-just)
+open import Data.Nat.Base as ℕ using (ℕ)
+open import Data.Product.Base using (Σ-syntax; _,_)
 open import Data.Vec.Base as Vec using (Vec ; lookup)
-open import Data.List hiding (lookup)
-open import Data.List.Properties
+open import Data.List.Base using (List; []; _∷_; [_]; _++_)
+open import Data.List.Properties using (++-assoc; ++-identityʳ)
 open import Data.List.Relation.Binary.Sublist.Heterogeneous
-  hiding (lookup)
+  using (Sublist; minimum; _∷_)
 open import Data.List.Relation.Binary.Sublist.Heterogeneous.Properties
-open import Function
+open import Function.Base using (_$_; case_of_)
 
-open import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.Consequences using (dec⇒weaklyDec)
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; _≗_; sym; cong; cong₂; subst₂)
-open import Relation.Nullary
+open import Relation.Binary.PropositionalEquality.Properties as ≡
 
-open P.≡-Reasoning
+open ≡.≡-Reasoning
 
 infix 4  _⊆I_ _⊆R_ _⊆T_
 
@@ -86,7 +88,7 @@ d ⊆R e = ∀ ρ → Sublist R (⟦ d ⟧R ρ) (⟦ e ⟧R ρ)
 -- Flattening in a semantics-respecting manner
 
 ⟦++⟧R : ∀ {n} xs ys (ρ : Vec (List A) n) → ⟦ xs ++ ys ⟧R ρ ≡ ⟦ xs ⟧R ρ ++ ⟦ ys ⟧R ρ
-⟦++⟧R []       ys ρ = P.refl
+⟦++⟧R []       ys ρ = ≡.refl
 ⟦++⟧R (x ∷ xs) ys ρ = begin
   ⟦ x ⟧I ρ ++ ⟦ xs ++ ys ⟧R ρ
     ≡⟨ cong (⟦ x ⟧I ρ ++_) (⟦++⟧R xs ys ρ) ⟩
@@ -96,7 +98,7 @@ d ⊆R e = ∀ ρ → Sublist R (⟦ d ⟧R ρ) (⟦ e ⟧R ρ)
     ∎
 
 flatten : ∀ {n} (t : TList n) → Σ[ r ∈ RList n ] ⟦ r ⟧R ≗ ⟦ t ⟧T
-flatten []       = [] , λ _ → P.refl
+flatten []       = [] , λ _ → ≡.refl
 flatten (It it)  = it ∷ [] , λ ρ → ++-identityʳ (⟦ It it ⟧T ρ)
 flatten (t <> u) =
   let (rt , eqt) = flatten t
@@ -123,8 +125,8 @@ private
 
 -- Solver for items
 solveI : ∀ {n} (a b : Item n) → Maybe (a ⊆I b)
-solveI (var k) (var l) = M.map var $ decToMaybe (k Fin.≟ l)
-solveI (val a) (val b) = M.map val $ decToMaybe (R? a b)
+solveI (var k) (var l) = Maybe.map var $ dec⇒weaklyDec Fin._≟_ k  l
+solveI (val a) (val b) = Maybe.map val $ dec⇒weaklyDec R? a b
 solveI _ _ = nothing
 
 -- Solver for linearised expressions
@@ -134,8 +136,8 @@ solveR [] e  = just (λ ρ → minimum _)
 solveR d  [] = nothing
 -- actual work
 solveR (a ∷ d) (b ∷ e) with solveI a b
-... | just it = M.map (keep-it it d e) (solveR d e)
-... | nothing = M.map (skip-it b (a ∷ d) e) (solveR (a ∷ d) e)
+... | just it = Maybe.map (keep-it it d e) (solveR d e)
+... | nothing = Maybe.map (skip-it b (a ∷ d) e) (solveR (a ∷ d) e)
 
 -- Coming back to ASTs thanks to flatten
 
diff --git a/src/Data/List/Relation/Binary/Sublist/Propositional.agda b/src/Data/List/Relation/Binary/Sublist/Propositional.agda
index 7700e10e59..b423548af2 100644
--- a/src/Data/List/Relation/Binary/Sublist/Propositional.agda
+++ b/src/Data/List/Relation/Binary/Sublist/Propositional.agda
@@ -14,8 +14,14 @@ open import Data.List.Base using (List)
 open import Data.List.Relation.Binary.Equality.Propositional using (≋⇒≡)
 import Data.List.Relation.Binary.Sublist.Setoid as SetoidSublist
 open import Data.List.Relation.Unary.Any using (Any)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Bundles using (Preorder; Poset)
+open import Relation.Binary.Structures using (IsPreorder; IsPartialOrder)
+open import Relation.Binary.Definitions using (Antisymmetric)
+open import Relation.Binary.PropositionalEquality.Core
+  using (subst; _≡_; refl)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (setoid; isEquivalence)
 open import Relation.Unary using (Pred)
 
 ------------------------------------------------------------------------
diff --git a/src/Data/List/Relation/Binary/Sublist/Propositional/Disjoint.agda b/src/Data/List/Relation/Binary/Sublist/Propositional/Disjoint.agda
index edcf2b565b..97557891a9 100644
--- a/src/Data/List/Relation/Binary/Sublist/Propositional/Disjoint.agda
+++ b/src/Data/List/Relation/Binary/Sublist/Propositional/Disjoint.agda
@@ -1,7 +1,9 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Sublist-related properties
+-- This module is DEPRECATED.
+-- Please use `Data.List.Relation.Binary.Sublist.Propositional.Slice`
+-- instead.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
@@ -9,26 +11,23 @@
 module Data.List.Relation.Binary.Sublist.Propositional.Disjoint
   {a} {A : Set a} where
 
-open import Data.List.Base using (List)
-open import Data.List.Relation.Binary.Sublist.Propositional
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong)
-
-------------------------------------------------------------------------
--- A Union where the triangles commute is a
--- Cospan in the slice category (_ ⊆ zs).
+{-# WARNING_ON_IMPORT
+"Data.List.Relation.Binary.Sublist.Propositional.Disjoint was deprecated in v2.1.
+Use Data.List.Relation.Binary.Sublist.Propositional.Slice instead."
+#-}
 
-record IsCospan {xs ys zs : List A} {τ₁ : xs ⊆ zs} {τ₂ : ys ⊆ zs} (u : UpperBound τ₁ τ₂) : Set a where
-  field
-    tri₁ : ⊆-trans (UpperBound.inj₁ u) (UpperBound.sub u) ≡ τ₁
-    tri₂ : ⊆-trans (UpperBound.inj₂ u) (UpperBound.sub u) ≡ τ₂
+open import Data.List.Base using (List)
+open import Data.List.Relation.Binary.Sublist.Propositional using
+  ( _⊆_; _∷_; _∷ʳ_
+  ; Disjoint; ⊆-disjoint-union; _∷ₙ_; _∷ₗ_; _∷ᵣ_
+  )
+import Data.List.Relation.Binary.Sublist.Propositional.Slice as SPSlice
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
 
-record Cospan {xs ys zs : List A} (τ₁ : xs ⊆ zs) (τ₂ : ys ⊆ zs) : Set a where
-  field
-    upperBound : UpperBound τ₁ τ₂
-    isCospan   : IsCospan upperBound
+open SPSlice using (⊆-upper-bound-is-cospan; ⊆-upper-bound-cospan)
 
-  open UpperBound upperBound public
-  open IsCospan isCospan public
+-- For backward compatibility reexport these:
+open SPSlice public using ( IsCospan; Cospan )
 
 open IsCospan
 open Cospan
@@ -57,14 +56,18 @@ module _
 
 ⊆-disjoint-union-is-cospan : ∀ {xs ys zs : List A} {τ₁ : xs ⊆ zs} {τ₂ : ys ⊆ zs} →
   (d : Disjoint τ₁ τ₂) → IsCospan (⊆-disjoint-union d)
-⊆-disjoint-union-is-cospan [] = record { tri₁ = refl ; tri₂ = refl }
-⊆-disjoint-union-is-cospan (x    ∷ₙ d) = ∷ₙ-cospan d (⊆-disjoint-union-is-cospan d)
-⊆-disjoint-union-is-cospan (refl ∷ₗ d) = ∷ₗ-cospan d (⊆-disjoint-union-is-cospan d)
-⊆-disjoint-union-is-cospan (refl ∷ᵣ d) = ∷ᵣ-cospan d (⊆-disjoint-union-is-cospan d)
+⊆-disjoint-union-is-cospan {τ₁ = τ₁} {τ₂ = τ₂} _ = ⊆-upper-bound-is-cospan τ₁ τ₂
 
 ⊆-disjoint-union-cospan : ∀ {xs ys zs : List A} {τ₁ : xs ⊆ zs} {τ₂ : ys ⊆ zs} →
   Disjoint τ₁ τ₂ → Cospan τ₁ τ₂
-⊆-disjoint-union-cospan d = record
-  { upperBound = ⊆-disjoint-union d
-  ; isCospan   = ⊆-disjoint-union-is-cospan d
-  }
+⊆-disjoint-union-cospan {τ₁ = τ₁} {τ₂ = τ₂} _ = ⊆-upper-bound-cospan τ₁ τ₂
+
+{-# WARNING_ON_USAGE ⊆-disjoint-union-is-cospan
+"Warning: ⊆-disjoint-union-is-cospan was deprecated in v2.1.
+Please use `⊆-upper-bound-is-cospan` from `Data.List.Relation.Binary.Sublist.Propositional.Slice` instead."
+#-}
+
+{-# WARNING_ON_USAGE ⊆-disjoint-union-cospan
+"Warning: ⊆-disjoint-union-cospan was deprecated in v2.1.
+Please use `⊆-upper-bound-cospan` from `Data.List.Relation.Binary.Sublist.Propositional.Slice` instead."
+#-}
diff --git a/src/Data/List/Relation/Binary/Sublist/Propositional/Example/UniqueBoundVariables.agda b/src/Data/List/Relation/Binary/Sublist/Propositional/Example/UniqueBoundVariables.agda
index b8b8745b68..4235daf001 100644
--- a/src/Data/List/Relation/Binary/Sublist/Propositional/Example/UniqueBoundVariables.agda
+++ b/src/Data/List/Relation/Binary/Sublist/Propositional/Example/UniqueBoundVariables.agda
@@ -10,7 +10,10 @@
 
 module Data.List.Relation.Binary.Sublist.Propositional.Example.UniqueBoundVariables (Base : Set) where
 
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym; cong; subst; module ≡-Reasoning)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; sym; cong; subst)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open ≡-Reasoning
 
 open import Data.List.Base using (List; []; _∷_; [_])
@@ -36,7 +39,7 @@ open import Data.List.Relation.Binary.Sublist.Propositional.Properties using
   ; equalize-separators
   )
 
-open import Data.Product using (_,_; proj₁; proj₂)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 
 infixr 8 _⇒_
 infix 1 _⊢_~_▷_
@@ -141,9 +144,10 @@ variable
 
 -- Relating de Bruijn terms and uniquely named terms.
 --
--- The judgement δ ⊢ e ~ β ▷ t relates a de Bruijn term e with potentially free variables δ : Δ ⊆ Γ
--- to a named term t with exact bound variables β : B ⊆ Γ.  The intention is to relate exactly
--- the terms with the same meaning.
+-- The judgement δ ⊢ e ~ β ▷ t relates a de Bruijn term e with
+-- potentially free variables δ : Δ ⊆ Γ to a named term t with exact
+-- bound variables β : B ⊆ Γ.  The intention is to relate exactly the
+-- terms with the same meaning.
 --
 -- The judgement will imply the disjointness of Δ and B.
 
@@ -152,8 +156,8 @@ variable
 
 data _⊢_~_▷_ {Γ Δ : Cxt} (δ : Δ ⊆ Γ) : ∀{a} (e : Exp Δ a) {B} (β : B ⊆ Γ) (t : Tm β a) → Set where
 
-  -- Free de Bruijn index x : a ∈ Δ is related to free variable y : a ∈ Γ
-  -- if δ : Δ ⊆ Γ maps x to y.
+  -- Free de Bruijn index x : a ∈ Δ is related to free variable
+  -- y : a ∈ Γ if δ : Δ ⊆ Γ maps x to y.
 
   var : ∀{y} (δx≡y : lookup δ x ≡ y) (δ#β : Disjoint δ β)
       → δ ⊢ var x ~ β ▷ var! y
@@ -229,9 +233,10 @@ disjoint-fv-bv (app dₜ dᵤ βₜ⊎βᵤ) = disjoint⇒disjoint-to-union δ#
 
 -- Translating de Bruijn terms to uniquely named terms.
 --
--- Given a de Bruijn term Δ ⊢ e : a, we seek to produce a named term β ▷ t : a
--- that is related to the de Bruijn term.  On the way, we have to compute the
--- global context Γ that hosts all free and bound variables of t.
+-- Given a de Bruijn term Δ ⊢ e : a, we seek to produce a named term
+-- β ▷ t : a that is related to the de Bruijn term.  On the way, we have
+-- to compute the global context Γ that hosts all free and bound
+-- variables of t.
 
 -- Record (NamedOf e) collects all the outputs of the translation of e.
 
@@ -293,8 +298,8 @@ dB→Named {Δ = Δ} {a = a ⇒ b} (abs e) with dB→Named e
   z#β     = subst (λ □ → Disjoint □ β) eq (shrinkDisjointˡ [a]⊆aΔ zδ#β)
   z⊎β     = Disjoint→DisjointUnion z#β
 
--- For the translation of an application (f e) we have by induction hypothesis
--- two independent extensions δ₁ : Δ ⊆ Γ₁ and δ₂ : Δ ⊆ Γ₂
+-- For the translation of an application (f e) we have by induction
+-- hypothesis two independent extensions δ₁ : Δ ⊆ Γ₁ and δ₂ : Δ ⊆ Γ₂
 -- and two bound variable lists β₁ : B₁ ⊆ Γ₁ and β₂ : B₂ ⊆ Γ₂.
 -- We need to find a common global context Γ such that
 --
@@ -309,8 +314,8 @@ dB→Named {Δ = Δ} {a = a ⇒ b} (abs e) with dB→Named e
 --   β₁′ = β₁ϕ₁ : B₁ ⊆ Γ₁₂ and
 --   β₂′ = β₂ϕ₂ : B₂ ⊆ Γ₁₂ and
 --
--- may be overlapping, but we can separate them by enlarging the global context
--- to Γ with two embeddings
+-- may be overlapping, but we can separate them by enlarging the global
+-- context to Γ with two embeddings
 --
 --   γ₁ : Γ₁₂ ⊆ Γ
 --   γ₂ : Γ₁₂ ⊆ Γ
diff --git a/src/Data/List/Relation/Binary/Sublist/Propositional/Properties.agda b/src/Data/List/Relation/Binary/Sublist/Propositional/Properties.agda
index 0c5c80e987..aeb7c74e23 100644
--- a/src/Data/List/Relation/Binary/Sublist/Propositional/Properties.agda
+++ b/src/Data/List/Relation/Binary/Sublist/Propositional/Properties.agda
@@ -19,11 +19,14 @@ open import Data.List.Relation.Binary.Sublist.Propositional
   hiding (map)
 import Data.List.Relation.Binary.Sublist.Setoid.Properties
   as SetoidProperties
-open import Data.Product using (∃; _,_; proj₂)
-open import Function.Base
+open import Data.Product.Base using (∃; _,_; proj₂)
+open import Function.Base using (id; _∘_; _∘′_)
 open import Level using (Level)
-open import Relation.Binary using (_Respects_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Definitions using (_Respects_)
+open import Relation.Binary.PropositionalEquality.Core as ≡
+  using (_≡_; refl; cong; _≗_; trans)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (setoid; subst-injective; trans-reflʳ; trans-assoc)
 open import Relation.Unary using (Pred)
 
 private
@@ -35,7 +38,7 @@ private
 -- Re-exporting setoid properties
 
 open SetoidProperties (setoid A) public
-  hiding (map⁺)
+  hiding (map⁺; ⊆-trans-idˡ; ⊆-trans-idʳ; ⊆-trans-assoc)
 
 map⁺ : ∀ {as bs} (f : A → B) → as ⊆ bs → map f as ⊆ map f bs
 map⁺ {B = B} f = SetoidProperties.map⁺ (setoid A) (setoid B) (cong f)
@@ -45,16 +48,11 @@ map⁺ {B = B} f = SetoidProperties.map⁺ (setoid A) (setoid B) (cong f)
 
 ⊆-trans-idˡ : ∀ {xs ys : List A} {τ : xs ⊆ ys} →
               ⊆-trans ⊆-refl τ ≡ τ
-⊆-trans-idˡ {_}     {τ = []    } = refl
-⊆-trans-idˡ {_}     {τ = _ ∷  _} = cong (_ ∷_ ) ⊆-trans-idˡ
-⊆-trans-idˡ {[]}    {τ = _ ∷ʳ _} = cong (_ ∷ʳ_) ⊆-trans-idˡ
-⊆-trans-idˡ {_ ∷ _} {τ = _ ∷ʳ _} = cong (_ ∷ʳ_) ⊆-trans-idˡ
+⊆-trans-idˡ {τ = τ} = SetoidProperties.⊆-trans-idˡ (setoid A) (λ _ → refl) τ
 
 ⊆-trans-idʳ : ∀ {xs ys : List A} {τ : xs ⊆ ys} →
               ⊆-trans τ ⊆-refl ≡ τ
-⊆-trans-idʳ {τ = []      } = refl
-⊆-trans-idʳ {τ = _ ∷ʳ _  } = cong (_  ∷ʳ_ ) ⊆-trans-idʳ
-⊆-trans-idʳ {τ = refl ∷ _} = cong (refl ∷_) ⊆-trans-idʳ
+⊆-trans-idʳ {τ = τ} = SetoidProperties.⊆-trans-idʳ (setoid A) trans-reflʳ τ
 
 -- Note: The associativity law is oriented such that rewriting with it
 -- may trigger reductions of ⊆-trans, which matches first on its
@@ -63,11 +61,8 @@ map⁺ {B = B} f = SetoidProperties.map⁺ (setoid A) (setoid B) (cong f)
 ⊆-trans-assoc : ∀ {ws xs ys zs : List A}
                 {τ₁ : ws ⊆ xs} {τ₂ : xs ⊆ ys} {τ₃ : ys ⊆ zs} →
                 ⊆-trans τ₁ (⊆-trans τ₂ τ₃) ≡ ⊆-trans (⊆-trans τ₁ τ₂) τ₃
-⊆-trans-assoc {τ₁ = _}        {_}      {_ ∷ʳ _} = cong (_ ∷ʳ_) ⊆-trans-assoc
-⊆-trans-assoc {τ₁ = _}        {_ ∷ʳ _} {_ ∷  _} = cong (_ ∷ʳ_) ⊆-trans-assoc
-⊆-trans-assoc {τ₁ = _ ∷ʳ _  } {_ ∷  _} {_ ∷  _} = cong (_ ∷ʳ_) ⊆-trans-assoc
-⊆-trans-assoc {τ₁ = refl ∷ _} {_ ∷  _} {_ ∷  _} = cong (_ ∷_ ) ⊆-trans-assoc
-⊆-trans-assoc {τ₁ = []}       {[]}     {[]}     = refl
+⊆-trans-assoc {τ₁ = τ₁} {τ₂ = τ₂} {τ₃ = τ₃} =
+  SetoidProperties.⊆-trans-assoc (setoid A) (λ p _ _ → ≡.sym (trans-assoc p)) τ₁ τ₂ τ₃
 
 ------------------------------------------------------------------------
 -- Laws concerning ⊆-trans and ∷ˡ⁻
@@ -149,8 +144,8 @@ lookup-⊆-trans = Any-resp-⊆-trans
 ------------------------------------------------------------------------
 -- The `lookup` function for `xs ⊆ ys` is injective.
 --
--- Note: `lookup` can be seen as a strictly increasing reindexing function
--- for indices into `xs`, producing indices into `ys`.
+-- Note: `lookup` can be seen as a strictly increasing reindexing
+-- function for indices into `xs`, producing indices into `ys`.
 
 lookup-injective : ∀ {P : Pred A ℓ} {xs ys} {τ : xs ⊆ ys} {i j : Any P xs} →
                    lookup τ i ≡ lookup τ j → i ≡ j
@@ -160,7 +155,7 @@ lookup-injective {τ = x≡y ∷ _} {here  _} {here  _} = cong here ∘′ subst
   -- However, this turns the following clause into a non-strict match.
 lookup-injective {τ = _   ∷ _} {there _} {there _} = cong there ∘′ lookup-injective ∘′ there-injective
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- from∈ ∘ to∈ turns a sublist morphism τ : x∷xs ⊆ ys into a morphism
 -- [x] ⊆ ys.  The same morphism is obtained by pre-composing τ with
 -- the canonial morphism [x] ⊆ x∷xs.
diff --git a/src/Data/List/Relation/Binary/Sublist/Propositional/Slice.agda b/src/Data/List/Relation/Binary/Sublist/Propositional/Slice.agda
new file mode 100644
index 0000000000..cf16aa0f30
--- /dev/null
+++ b/src/Data/List/Relation/Binary/Sublist/Propositional/Slice.agda
@@ -0,0 +1,82 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Slices in the propositional sublist category.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.List.Relation.Binary.Sublist.Propositional.Slice
+  {a} {A : Set a} where
+
+open import Data.List.Base using (List)
+open import Data.List.Relation.Binary.Sublist.Propositional
+ using (_⊆_; UpperBound; ⊆-trans; ∷ₙ-ub; _∷ʳ_; _∷ₗ-ub_; _∷_; _∷ᵣ-ub_;
+        _,_∷-ub_; ⊆-upper-bound; [])
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong)
+
+------------------------------------------------------------------------
+-- A Union where the triangles commute is a
+-- Cospan in the slice category (_ ⊆ zs).
+
+record IsCospan {xs ys zs : List A} {τ₁ : xs ⊆ zs} {τ₂ : ys ⊆ zs} (u : UpperBound τ₁ τ₂) : Set a where
+  field
+    tri₁ : ⊆-trans (UpperBound.inj₁ u) (UpperBound.sub u) ≡ τ₁
+    tri₂ : ⊆-trans (UpperBound.inj₂ u) (UpperBound.sub u) ≡ τ₂
+
+record Cospan {xs ys zs : List A} (τ₁ : xs ⊆ zs) (τ₂ : ys ⊆ zs) : Set a where
+  field
+    upperBound : UpperBound τ₁ τ₂
+    isCospan   : IsCospan upperBound
+
+  open UpperBound upperBound public
+  open IsCospan isCospan public
+
+open IsCospan
+open Cospan
+
+module _
+  {x : A} {xs ys zs : List A} {τ₁ : xs ⊆ zs} {τ₂ : ys ⊆ zs}
+  {u : UpperBound τ₁ τ₂} (c : IsCospan u) where
+  open UpperBound u
+  open IsCospan c
+
+  ∷ₙ-cospan : IsCospan (∷ₙ-ub u)
+  ∷ₙ-cospan = record
+    { tri₁ = cong (x ∷ʳ_) (c .tri₁)
+    ; tri₂ = cong (x ∷ʳ_) (c .tri₂)
+    }
+
+  ∷ₗ-cospan : IsCospan (refl {x = x} ∷ₗ-ub u)
+  ∷ₗ-cospan = record
+    { tri₁ = cong (refl ∷_) (c .tri₁)
+    ; tri₂ = cong (x   ∷ʳ_) (c .tri₂)
+    }
+
+  ∷ᵣ-cospan : IsCospan (refl {x = x} ∷ᵣ-ub u)
+  ∷ᵣ-cospan = record
+    { tri₁ = cong (x   ∷ʳ_) (c .tri₁)
+    ; tri₂ = cong (refl ∷_) (c .tri₂)
+    }
+
+  ∷-cospan : IsCospan (refl {x = x} , refl {x = x} ∷-ub u)
+  ∷-cospan = record
+   { tri₁ =  cong (refl ∷_) (c .tri₁)
+   ; tri₂ =  cong (refl ∷_) (c .tri₂)
+   }
+
+⊆-upper-bound-is-cospan : ∀ {xs ys zs : List A} (τ₁ : xs ⊆ zs) (τ₂ : ys ⊆ zs) →
+  IsCospan (⊆-upper-bound τ₁ τ₂)
+⊆-upper-bound-is-cospan [] [] = record { tri₁ = refl ; tri₂ = refl }
+⊆-upper-bound-is-cospan (z   ∷ʳ τ₁) (.z  ∷ʳ τ₂) = ∷ₙ-cospan (⊆-upper-bound-is-cospan τ₁ τ₂)
+⊆-upper-bound-is-cospan (z   ∷ʳ τ₁) (refl ∷ τ₂) = ∷ᵣ-cospan (⊆-upper-bound-is-cospan τ₁ τ₂)
+⊆-upper-bound-is-cospan (refl ∷ τ₁) (z   ∷ʳ τ₂) = ∷ₗ-cospan (⊆-upper-bound-is-cospan τ₁ τ₂)
+⊆-upper-bound-is-cospan (refl ∷ τ₁) (refl ∷ τ₂) = ∷-cospan (⊆-upper-bound-is-cospan τ₁ τ₂)
+
+⊆-upper-bound-cospan : ∀ {xs ys zs : List A} (τ₁ : xs ⊆ zs) (τ₂ : ys ⊆ zs) →
+  Cospan τ₁ τ₂
+⊆-upper-bound-cospan τ₁ τ₂ = record
+  { upperBound = ⊆-upper-bound τ₁ τ₂
+  ; isCospan   = ⊆-upper-bound-is-cospan τ₁ τ₂
+  }
diff --git a/src/Data/List/Relation/Binary/Sublist/Setoid.agda b/src/Data/List/Relation/Binary/Sublist/Setoid.agda
index 7a7b62c673..2fc0373d67 100644
--- a/src/Data/List/Relation/Binary/Sublist/Setoid.agda
+++ b/src/Data/List/Relation/Binary/Sublist/Setoid.agda
@@ -9,7 +9,8 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 {-# OPTIONS --postfix-projections #-}
 
-open import Relation.Binary using (Setoid; Rel)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Relation.Binary.Sublist.Setoid
   {c ℓ} (S : Setoid c ℓ) where
@@ -23,10 +24,12 @@ import Data.List.Relation.Binary.Sublist.Heterogeneous.Core
   as HeterogeneousCore
 import Data.List.Relation.Binary.Sublist.Heterogeneous.Properties
   as HeterogeneousProperties
-open import Data.Product using (∃; ∃₂; _×_; _,_; proj₂)
+open import Data.Product.Base using (∃; ∃₂; _×_; _,_; proj₂)
 
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Bundles using (Preorder; Poset)
+open import Relation.Binary.Structures using (IsPreorder; IsPartialOrder)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Nullary using (¬_; Dec; yes; no)
 
 open Setoid S renaming (Carrier to A)
@@ -159,7 +162,7 @@ record RawPushout {xs ys zs : List A} (τ : xs ⊆ ys) (σ : xs ⊆ zs) : Set (c
     leg₁         : ys ⊆ upperBound
     leg₂         : zs ⊆ upperBound
 
-open RawPushout
+open RawPushout using (leg₁; leg₂)
 
 ------------------------------------------------------------------------
 -- Extending corners of a raw pushout square
@@ -208,13 +211,25 @@ z ∷ʳ₂ rpo = record
 
 ⊆-joinˡ : ∀ {xs ys zs : List A} →
           (τ : xs ⊆ ys) (σ : xs ⊆ zs) → ∃ λ us → xs ⊆ us
-⊆-joinˡ τ σ = upperBound rpo , ⊆-trans τ (leg₁ rpo)
+⊆-joinˡ τ σ = RawPushout.upperBound rpo , ⊆-trans τ (leg₁ rpo)
   where
   rpo = ⊆-pushoutˡ τ σ
 
 
 ------------------------------------------------------------------------
 -- Upper bound of two sublists xs,ys ⊆ zs
+--
+-- Two sublists τ : xs ⊆ zs and σ : ys ⊆ zs
+-- can be joined in a unique way if τ and σ are respected.
+--
+-- For instance, if τ : [x] ⊆ [x,y,x] and σ : [y] ⊆ [x,y,x]
+-- then the union will be [x,y] or [y,x], depending on whether
+-- τ picks the first x or the second one.
+--
+-- NB: If the content of τ and σ were ignored then the union would not
+-- be unique.  Expressing uniqueness would require a notion of equality
+-- of sublist proofs, which we do not (yet) have for the setoid case
+-- (however, for the propositional case).
 
 record UpperBound {xs ys zs} (τ : xs ⊆ zs) (σ : ys ⊆ zs) : Set (c ⊔ ℓ) where
   field
@@ -251,24 +266,26 @@ x≈y ∷ᵣ-ub u = record
   ; inj₂ = x≈y  ∷ u .inj₂
   }
 
+_,_∷-ub_ : ∀ {xs ys zs} {τ : xs ⊆ zs} {σ : ys ⊆ zs} {x y z} →
+         (x≈z : x ≈ z) (y≈z : y ≈ z) → UpperBound τ σ → UpperBound (x≈z ∷ τ) (y≈z ∷ σ)
+x≈z , y≈z ∷-ub u = record
+  { sub  =  refl ∷ u .sub
+  ; inj₁ =  x≈z  ∷ u .inj₁
+  ; inj₂ =  y≈z  ∷ u .inj₂
+  }
+
+⊆-upper-bound : ∀ {xs ys zs} (τ : xs ⊆ zs) (σ : ys ⊆ zs) → UpperBound τ σ
+⊆-upper-bound []        []        = record { sub = [] ; inj₁ = [] ; inj₂ = [] }
+⊆-upper-bound (y ∷ʳ τ)  (.y ∷ʳ σ) = ∷ₙ-ub (⊆-upper-bound τ σ)
+⊆-upper-bound (y ∷ʳ τ)  (x≈y ∷ σ) = x≈y ∷ᵣ-ub ⊆-upper-bound τ σ
+⊆-upper-bound (x≈y ∷ τ) (y  ∷ʳ σ) = x≈y ∷ₗ-ub ⊆-upper-bound τ σ
+⊆-upper-bound (x≈z ∷ τ) (y≈z ∷ σ) = x≈z , y≈z ∷-ub ⊆-upper-bound τ σ
+
 ------------------------------------------------------------------------
 -- Disjoint union
 --
--- Two non-overlapping sublists τ : xs ⊆ zs and σ : ys ⊆ zs
--- can be joined in a unique way if τ and σ are respected.
---
--- For instance, if τ : [x] ⊆ [x,y,x] and σ : [y] ⊆ [x,y,x]
--- then the union will be [x,y] or [y,x], depending on whether
--- τ picks the first x or the second one.
---
--- NB: If the content of τ and σ were ignored then the union would not
--- be unique.  Expressing uniqueness would require a notion of equality
--- of sublist proofs, which we do not (yet) have for the setoid case
--- (however, for the propositional case).
+-- Upper bound of two non-overlapping sublists.
 
 ⊆-disjoint-union : ∀ {xs ys zs} {τ : xs ⊆ zs} {σ : ys ⊆ zs} →
                    Disjoint τ σ → UpperBound τ σ
-⊆-disjoint-union []         = record { sub = [] ; inj₁ = [] ; inj₂ = [] }
-⊆-disjoint-union (x   ∷ₙ d) = ∷ₙ-ub (⊆-disjoint-union d)
-⊆-disjoint-union (x≈y ∷ₗ d) = x≈y ∷ₗ-ub (⊆-disjoint-union d)
-⊆-disjoint-union (x≈y ∷ᵣ d) = x≈y ∷ᵣ-ub (⊆-disjoint-union d)
+⊆-disjoint-union {τ = τ} {σ = σ} _ = ⊆-upper-bound τ σ
diff --git a/src/Data/List/Relation/Binary/Sublist/Setoid/Properties.agda b/src/Data/List/Relation/Binary/Sublist/Setoid/Properties.agda
index dd7638bc5f..60be70aac1 100644
--- a/src/Data/List/Relation/Binary/Sublist/Setoid/Properties.agda
+++ b/src/Data/List/Relation/Binary/Sublist/Setoid/Properties.agda
@@ -1,4 +1,4 @@
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The Agda standard library
 --
 -- Properties of the setoid sublist relation
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Setoid; _⇒_; _Preserves_⟶_)
+open import Relation.Binary.Core using (Rel; _⇒_; _Preserves_⟶_)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Relation.Binary.Sublist.Setoid.Properties
   {c ℓ} (S : Setoid c ℓ) where
@@ -14,16 +15,18 @@ module Data.List.Relation.Binary.Sublist.Setoid.Properties
 open import Data.List.Base hiding (_∷ʳ_)
 open import Data.List.Relation.Unary.Any using (Any)
 import Data.Maybe.Relation.Unary.All as Maybe
-open import Data.Nat.Base using (_≤_; _≥_)
-import Data.Nat.Properties as ℕₚ
-open import Data.Product using (∃; _,_; proj₂)
+open import Data.Nat.Base using (ℕ; _≤_; _≥_)
+import Data.Nat.Properties as ℕ
+open import Data.Product.Base using (∃; _,_; proj₂)
 open import Function.Base
 open import Function.Bundles using (_⇔_; _⤖_)
 open import Level
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong)
+open import Relation.Binary.Definitions using () renaming (Decidable to Decidable₂)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_; refl; cong; cong₂)
+open import Relation.Binary.Structures using (IsDecTotalOrder)
 open import Relation.Unary using (Pred; Decidable; Irrelevant)
 open import Relation.Nullary.Negation using (¬_)
-open import Relation.Nullary.Decidable using (¬?)
+open import Relation.Nullary.Decidable using (¬?; yes; no)
 
 import Data.List.Relation.Binary.Equality.Setoid as SetoidEquality
 import Data.List.Relation.Binary.Sublist.Setoid as SetoidSublist
@@ -36,23 +39,63 @@ open SetoidEquality S using (_≋_; ≋-refl)
 open SetoidSublist S hiding (map)
 open SetoidMembership S using (_∈_)
 
+private
+  variable
+    p q r s t : Level
+    a b x y : A
+    as bs cs ds xs ys : List A
+    P : Pred A p
+    Q : Pred A q
+    m n : ℕ
+
+
 ------------------------------------------------------------------------
 -- Injectivity of constructors
 ------------------------------------------------------------------------
 
-module _ {xs ys : List A} where
+module _ where
 
-  ∷-injectiveˡ : ∀ {x y} {px qx : x ≈ y} {pxs qxs : xs ⊆ ys} →
+  ∷-injectiveˡ : ∀ {px qx : x ≈ y} {pxs qxs : xs ⊆ ys} →
                  ((x ∷ xs) ⊆ (y ∷ ys) ∋ px ∷ pxs) ≡ (qx ∷ qxs) → px ≡ qx
   ∷-injectiveˡ refl = refl
 
-  ∷-injectiveʳ : ∀ {x y} {px qx : x ≈ y} {pxs qxs : xs ⊆ ys} →
+  ∷-injectiveʳ : ∀ {px qx : x ≈ y} {pxs qxs : xs ⊆ ys} →
                  ((x ∷ xs) ⊆ (y ∷ ys) ∋ px ∷ pxs) ≡ (qx ∷ qxs) → pxs ≡ qxs
   ∷-injectiveʳ refl = refl
 
-  ∷ʳ-injective : ∀ {y} {pxs qxs : xs ⊆ ys} → y ∷ʳ pxs ≡ y ∷ʳ qxs → pxs ≡ qxs
+  ∷ʳ-injective : ∀ {pxs qxs : xs ⊆ ys} → y ∷ʳ pxs ≡ y ∷ʳ qxs → pxs ≡ qxs
   ∷ʳ-injective refl = refl
 
+------------------------------------------------------------------------
+-- Categorical properties
+------------------------------------------------------------------------
+
+module _ (trans-reflˡ : ∀ {x y} (p : x ≈ y) → trans ≈-refl p ≡ p) where
+
+  ⊆-trans-idˡ : (pxs : xs ⊆ ys) → ⊆-trans ⊆-refl pxs ≡ pxs
+  ⊆-trans-idˡ [] = refl
+  ⊆-trans-idˡ (y ∷ʳ pxs) = cong (y ∷ʳ_) (⊆-trans-idˡ pxs)
+  ⊆-trans-idˡ (x ∷ pxs) = cong₂ _∷_ (trans-reflˡ x) (⊆-trans-idˡ pxs)
+
+module _ (trans-reflʳ : ∀ {x y} (p : x ≈ y) → trans p ≈-refl ≡ p) where
+
+  ⊆-trans-idʳ : (pxs : xs ⊆ ys) → ⊆-trans pxs ⊆-refl ≡ pxs
+  ⊆-trans-idʳ [] = refl
+  ⊆-trans-idʳ (y ∷ʳ pxs) = cong (y ∷ʳ_) (⊆-trans-idʳ pxs)
+  ⊆-trans-idʳ (x ∷ pxs) = cong₂ _∷_ (trans-reflʳ x) (⊆-trans-idʳ pxs)
+
+module _ (≈-assoc : ∀ {w x y z} (p : w ≈ x) (q : x ≈ y) (r : y ≈ z) →
+                    trans p (trans q r) ≡ trans (trans p q) r) where
+
+  ⊆-trans-assoc : (ps : as ⊆ bs) (qs : bs ⊆ cs) (rs : cs ⊆ ds) →
+            ⊆-trans ps (⊆-trans qs rs) ≡ ⊆-trans (⊆-trans ps qs) rs
+  ⊆-trans-assoc ps qs (_ ∷ʳ rs) = cong (_ ∷ʳ_) (⊆-trans-assoc ps qs rs)
+  ⊆-trans-assoc ps (_ ∷ʳ qs) (_ ∷ rs) = cong (_ ∷ʳ_) (⊆-trans-assoc ps qs rs)
+  ⊆-trans-assoc (_ ∷ʳ ps) (_ ∷ qs) (_ ∷ rs) = cong (_ ∷ʳ_) (⊆-trans-assoc ps qs rs)
+  ⊆-trans-assoc (p ∷ ps) (q ∷ qs) (r ∷ rs) = cong₂ _∷_ (≈-assoc p q r) (⊆-trans-assoc ps qs rs)
+  ⊆-trans-assoc [] [] [] = refl
+
+
 ------------------------------------------------------------------------
 -- Various functions' outputs are sublists
 ------------------------------------------------------------------------
@@ -66,7 +109,7 @@ take-⊆ n xs = HeteroProperties.take-Sublist n ⊆-refl
 drop-⊆ : ∀ n xs → drop n xs ⊆ xs
 drop-⊆ n xs = HeteroProperties.drop-Sublist n ⊆-refl
 
-module _ {p} {P : Pred A p} (P? : Decidable P) where
+module _ (P? : Decidable P) where
 
   takeWhile-⊆ : ∀ xs → takeWhile P? xs ⊆ xs
   takeWhile-⊆ xs = HeteroProperties.takeWhile-Sublist P? ⊆-refl
@@ -77,7 +120,7 @@ module _ {p} {P : Pred A p} (P? : Decidable P) where
   filter-⊆ : ∀ xs → filter P? xs ⊆ xs
   filter-⊆ xs = HeteroProperties.filter-Sublist P? ⊆-refl
 
-module _ {p} {P : Pred A p} (P? : Decidable P) where
+module _ (P? : Decidable P) where
 
   takeWhile⊆filter : ∀ xs → takeWhile P? xs ⊆ filter P? xs
   takeWhile⊆filter xs = HeteroProperties.takeWhile-filter P? {xs} ≋-refl
@@ -91,15 +134,15 @@ module _ {p} {P : Pred A p} (P? : Decidable P) where
 -- We write f⁺ for the proof that `xs ⊆ ys → f xs ⊆ f ys`
 -- and f⁻ for the one that `f xs ⊆ f ys → xs ⊆ ys`.
 
-module _ {as bs : List A} where
+module _ where
 
-  ∷ˡ⁻ : ∀ {a} → a ∷ as ⊆ bs → as ⊆ bs
+  ∷ˡ⁻ : a ∷ as ⊆ bs → as ⊆ bs
   ∷ˡ⁻ = HeteroProperties.∷ˡ⁻
 
-  ∷ʳ⁻ : ∀ {a b} → ¬ (a ≈ b) → a ∷ as ⊆ b ∷ bs → a ∷ as ⊆ bs
+  ∷ʳ⁻ : ¬ (a ≈ b) → a ∷ as ⊆ b ∷ bs → a ∷ as ⊆ bs
   ∷ʳ⁻ = HeteroProperties.∷ʳ⁻
 
-  ∷⁻ : ∀ {a b} → a ∷ as ⊆ b ∷ bs → as ⊆ bs
+  ∷⁻ : a ∷ as ⊆ b ∷ bs → as ⊆ bs
   ∷⁻ = HeteroProperties.∷⁻
 
 ------------------------------------------------------------------------
@@ -118,7 +161,7 @@ module _ {b ℓ} (R : Setoid b ℓ) where
 ------------------------------------------------------------------------
 -- _++_
 
-module _ {as bs : List A} where
+module _ where
 
   ++⁺ˡ : ∀ cs → as ⊆ bs → as ⊆ cs ++ bs
   ++⁺ˡ = HeteroProperties.++ˡ
@@ -126,16 +169,16 @@ module _ {as bs : List A} where
   ++⁺ʳ : ∀ cs → as ⊆ bs → as ⊆ bs ++ cs
   ++⁺ʳ = HeteroProperties.++ʳ
 
-  ++⁺ : ∀ {cs ds} → as ⊆ bs → cs ⊆ ds → as ++ cs ⊆ bs ++ ds
+  ++⁺ : as ⊆ bs → cs ⊆ ds → as ++ cs ⊆ bs ++ ds
   ++⁺ = HeteroProperties.++⁺
 
-  ++⁻ : ∀ {cs ds} → length as ≡ length bs → as ++ cs ⊆ bs ++ ds → cs ⊆ ds
+  ++⁻ : length as ≡ length bs → as ++ cs ⊆ bs ++ ds → cs ⊆ ds
   ++⁻ = HeteroProperties.++⁻
 
 ------------------------------------------------------------------------
 -- take
 
-module _ {m n} {xs} where
+module _ where
 
   take⁺ : m ≤ n → take m xs ⊆ take n xs
   take⁺ m≤n = HeteroProperties.take⁺ m≤n ≋-refl
@@ -143,26 +186,25 @@ module _ {m n} {xs} where
 ------------------------------------------------------------------------
 -- drop
 
-module _ {m n} {xs ys : List A} where
+module _ where
 
   drop⁺ : m ≥ n → xs ⊆ ys → drop m xs ⊆ drop n ys
   drop⁺ = HeteroProperties.drop⁺
 
-module _ {m n} {xs : List A} where
+module _ where
 
   drop⁺-≥ : m ≥ n → drop m xs ⊆ drop n xs
   drop⁺-≥ m≥n = drop⁺ m≥n ⊆-refl
 
-module _ {xs ys : List A} where
+module _ where
 
   drop⁺-⊆ : ∀ n → xs ⊆ ys → drop n xs ⊆ drop n ys
-  drop⁺-⊆ n xs⊆ys = drop⁺ {n} ℕₚ.≤-refl xs⊆ys
+  drop⁺-⊆ n xs⊆ys = drop⁺ {n} ℕ.≤-refl xs⊆ys
 
 ------------------------------------------------------------------------
 -- takeWhile / dropWhile
 
-module _ {p q} {P : Pred A p} {Q : Pred A q}
-         (P? : Decidable P) (Q? : Decidable Q) where
+module _ (P? : Decidable P) (Q? : Decidable Q) where
 
   takeWhile⁺ : ∀ {xs} → (∀ {a b} → a ≈ b → P a → Q b) →
                takeWhile P? xs ⊆ takeWhile Q? xs
@@ -175,25 +217,22 @@ module _ {p q} {P : Pred A p} {Q : Pred A q}
 ------------------------------------------------------------------------
 -- filter
 
-module _ {p q} {P : Pred A p} {Q : Pred A q}
-         (P? : Decidable P) (Q? : Decidable Q) where
+module _ (P? : Decidable P) (Q? : Decidable Q) where
 
-  filter⁺ : ∀ {as bs} → (∀ {a b} → a ≈ b → P a → Q b) →
+  filter⁺ : (∀ {a b} → a ≈ b → P a → Q b) →
             as ⊆ bs → filter P? as ⊆ filter Q? bs
   filter⁺ = HeteroProperties.⊆-filter-Sublist P? Q?
 
 ------------------------------------------------------------------------
 -- reverse
 
-module _ {as bs : List A} where
+module _ where
 
-  reverseAcc⁺ : ∀ {cs ds} → as ⊆ bs → cs ⊆ ds →
+  reverseAcc⁺ : as ⊆ bs → cs ⊆ ds →
                 reverseAcc cs as ⊆ reverseAcc ds bs
   reverseAcc⁺ = HeteroProperties.reverseAcc⁺
 
-  ʳ++⁺ : ∀ {cs ds} →
-         as ⊆ bs →
-         cs ⊆ ds →
+  ʳ++⁺ : as ⊆ bs → cs ⊆ ds →
          as ʳ++ cs ⊆ bs ʳ++ ds
   ʳ++⁺ = reverseAcc⁺
 
@@ -203,11 +242,34 @@ module _ {as bs : List A} where
   reverse⁻ : reverse as ⊆ reverse bs → as ⊆ bs
   reverse⁻ = HeteroProperties.reverse⁻
 
+------------------------------------------------------------------------
+-- merge
+
+module _ {ℓ′} {_≤_ : Rel A ℓ′} (_≤?_ : Decidable₂ _≤_) where
+
+  ⊆-mergeˡ : ∀ xs ys → xs ⊆ merge _≤?_ xs ys
+  ⊆-mergeˡ []       ys = minimum ys
+  ⊆-mergeˡ (x ∷ xs) [] = ⊆-refl
+  ⊆-mergeˡ (x ∷ xs) (y ∷ ys)
+   with x ≤? y  | ⊆-mergeˡ xs (y ∷ ys)
+                      | ⊆-mergeˡ (x ∷ xs) ys
+  ... | yes x≤y | rec | _   = ≈-refl ∷ rec
+  ... | no  x≰y | _   | rec = y ∷ʳ rec
+
+  ⊆-mergeʳ : ∀ xs ys → ys ⊆ merge _≤?_ xs ys
+  ⊆-mergeʳ [] ys =  ⊆-refl
+  ⊆-mergeʳ (x ∷ xs) [] = minimum (merge _≤?_ (x ∷ xs) [])
+  ⊆-mergeʳ (x ∷ xs) (y ∷ ys)
+   with x ≤? y  | ⊆-mergeʳ xs (y ∷ ys)
+                      | ⊆-mergeʳ (x ∷ xs) ys
+  ... | yes x≤y | rec | _   = x ∷ʳ rec
+  ... | no  x≰y | _   | rec = ≈-refl ∷ rec
+
 ------------------------------------------------------------------------
 -- Inversion lemmas
 ------------------------------------------------------------------------
 
-module _ {a as b bs} where
+module _ where
 
   ∷⁻¹ : a ≈ b → as ⊆ bs ⇔ a ∷ as ⊆ b ∷ bs
   ∷⁻¹ = HeteroProperties.∷⁻¹
@@ -221,13 +283,13 @@ module _ {a as b bs} where
 
 module _ where
 
-  length-mono-≤ : ∀ {as bs} → as ⊆ bs → length as ≤ length bs
+  length-mono-≤ : as ⊆ bs → length as ≤ length bs
   length-mono-≤ = HeteroProperties.length-mono-≤
 
 ------------------------------------------------------------------------
 -- Conversion to and from list equality
 
-  to-≋ : ∀ {as bs} → length as ≡ length bs → as ⊆ bs → as ≋ bs
+  to-≋ : length as ≡ length bs → as ⊆ bs → as ≋ bs
   to-≋ = HeteroProperties.toPointwise
 
 ------------------------------------------------------------------------
@@ -239,7 +301,7 @@ module _ where
 ------------------------------------------------------------------------
 -- (to/from)∈ is a bijection
 
-module _ {x xs} where
+module _ where
 
   to∈-injective : ∀ {p q : [ x ] ⊆ xs} → to∈ p ≡ to∈ q → p ≡ q
   to∈-injective = HeteroProperties.toAny-injective
diff --git a/src/Data/List/Relation/Binary/Subset/DecPropositional.agda b/src/Data/List/Relation/Binary/Subset/DecPropositional.agda
new file mode 100644
index 0000000000..a183d298f3
--- /dev/null
+++ b/src/Data/List/Relation/Binary/Subset/DecPropositional.agda
@@ -0,0 +1,21 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Decidability of the subset relation over propositional equality.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Definitions using (DecidableEquality)
+
+module Data.List.Relation.Binary.Subset.DecPropositional
+  {a} {A : Set a} (_≟_ : DecidableEquality A)
+  where
+
+------------------------------------------------------------------------
+-- Re-export core definitions and operations
+
+open import Data.List.Relation.Binary.Subset.Propositional {A = A} public
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
+open import Data.List.Relation.Binary.Subset.DecSetoid (decSetoid _≟_) public
+  using (_⊆?_)
diff --git a/src/Data/List/Relation/Binary/Subset/DecSetoid.agda b/src/Data/List/Relation/Binary/Subset/DecSetoid.agda
new file mode 100644
index 0000000000..fcff0abacc
--- /dev/null
+++ b/src/Data/List/Relation/Binary/Subset/DecSetoid.agda
@@ -0,0 +1,33 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Decidability of the subset relation over setoid equality.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Bundles using (DecSetoid)
+
+module Data.List.Relation.Binary.Subset.DecSetoid {c ℓ} (S : DecSetoid c ℓ) where
+
+open import Function.Base using (_∘_)
+open import Data.List.Base using ([]; _∷_)
+open import Data.List.Relation.Unary.Any using (here; there; map)
+open import Relation.Binary.Definitions using (Decidable)
+open import Relation.Nullary using (yes; no)
+open DecSetoid S
+open import Data.List.Relation.Binary.Equality.DecSetoid S
+open import Data.List.Membership.DecSetoid S
+
+-- Re-export definitions
+open import Data.List.Relation.Binary.Subset.Setoid setoid public
+
+infix 4 _⊆?_
+_⊆?_ : Decidable _⊆_
+[]       ⊆? _   = yes λ ()
+(x ∷ xs) ⊆? ys  with x ∈? ys
+... | no  x∉ys  = no λ xs⊆ys → x∉ys (xs⊆ys (here refl))
+... | yes x∈ys  with xs ⊆? ys
+...   | no  xs⊈ys = no λ xs⊆ys → xs⊈ys (xs⊆ys ∘ there)
+...   | yes xs⊆ys = yes λ where (here refl) → map (trans refl) x∈ys
+                                (there x∈)  → xs⊆ys x∈
diff --git a/src/Data/List/Relation/Binary/Subset/Propositional.agda b/src/Data/List/Relation/Binary/Subset/Propositional.agda
index d97fc73114..c6ecf5e5fa 100644
--- a/src/Data/List/Relation/Binary/Subset/Propositional.agda
+++ b/src/Data/List/Relation/Binary/Subset/Propositional.agda
@@ -10,7 +10,7 @@ module Data.List.Relation.Binary.Subset.Propositional
   {a} {A : Set a} where
 
 import Data.List.Relation.Binary.Subset.Setoid as SetoidSubset
-open import Relation.Binary.PropositionalEquality using (setoid)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 
 ------------------------------------------------------------------------
 -- Re-export parameterised definitions from setoid sublists
diff --git a/src/Data/List/Relation/Binary/Subset/Propositional/Properties.agda b/src/Data/List/Relation/Binary/Subset/Propositional/Properties.agda
index 349586f59b..75e1a5b00a 100644
--- a/src/Data/List/Relation/Binary/Subset/Propositional/Properties.agda
+++ b/src/Data/List/Relation/Binary/Subset/Propositional/Properties.agda
@@ -6,39 +6,44 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary hiding (Decidable)
-
 module Data.List.Relation.Binary.Subset.Propositional.Properties
   where
 
 open import Data.Bool.Base using (Bool; true; false; T)
-open import Data.List.Base
+open import Data.List.Base using (List; map; _∷_; _++_; concat; applyUpTo;
+  any; filter)
 open import Data.List.Relation.Unary.Any using (Any; here; there)
 open import Data.List.Relation.Unary.All using (All)
 import Data.List.Relation.Unary.Any.Properties as Any hiding (filter⁺)
-open import Data.List.Effectful
+open import Data.List.Effectful using (monad)
 open import Data.List.Relation.Unary.Any using (Any)
-open import Data.List.Membership.Propositional
+open import Data.List.Membership.Propositional using (_∈_; mapWith∈)
 open import Data.List.Membership.Propositional.Properties
-import Data.List.Relation.Binary.Subset.Setoid.Properties as Setoidₚ
+  using (map-∈↔; concat-∈↔; >>=-∈↔; ⊛-∈↔; ⊗-∈↔)
+import Data.List.Relation.Binary.Subset.Setoid.Properties as Subset
 open import Data.List.Relation.Binary.Subset.Propositional
+  using (_⊆_; _⊇_)
 open import Data.List.Relation.Binary.Permutation.Propositional
+  using (_↭_; ↭-sym; ↭-isEquivalence)
 import Data.List.Relation.Binary.Permutation.Propositional.Properties as Permutation
-open import Data.Nat using (ℕ; _≤_)
-import Data.Product as Prod
+open import Data.Nat.Base using (ℕ; _≤_)
+import Data.Product.Base as Product
 import Data.Sum.Base as Sum
 open import Effect.Monad
 open import Function.Base using (_∘_; _∘′_; id; _$_)
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Inverse as Inv using (_↔_; module Inverse)
-open import Function.Equivalence using (module Equivalence)
+open import Function.Bundles using (_↔_; Inverse; Equivalence)
 open import Level using (Level)
 open import Relation.Nullary using (¬_; yes; no)
 open import Relation.Unary using (Decidable; Pred) renaming (_⊆_ to _⋐_)
-open import Relation.Binary using (_⇒_; _Respects_)
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; _≗_; isEquivalence; subst; resp; refl; setoid; module ≡-Reasoning)
-import Relation.Binary.Reasoning.Preorder as PreorderReasoning
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Bundles using (Preorder)
+open import Relation.Binary.Definitions hiding (Decidable)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≗_; subst; resp; refl)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (isEquivalence; setoid; module ≡-Reasoning)
+open import Relation.Binary.Structures using (IsPreorder)
+import Relation.Binary.Reasoning.Preorder as ≲-Reasoning
 
 private
   open module ListMonad {ℓ} = RawMonad (monad {ℓ = ℓ})
@@ -79,7 +84,7 @@ module _ (A : Set a) where
 ------------------------------------------------------------------------
 -- Relational properties with _↭_ (permutation)
 ------------------------------------------------------------------------
--- See issue #1354 for why these proofs can't be taken from `Setoidₚ`
+-- See issue #1354 for why these proofs can't be taken from `Subset`
 
 ⊆-reflexive-↭ : _↭_ {A = A} ⇒ _⊆_
 ⊆-reflexive-↭ xs↭ys = Permutation.∈-resp-↭ xs↭ys
@@ -109,7 +114,7 @@ module _ (A : Set a) where
 ------------------------------------------------------------------------
 
 module ⊆-Reasoning (A : Set a) where
-  open Setoidₚ.⊆-Reasoning (setoid A) public
+  open Subset.⊆-Reasoning (setoid A) public
     hiding (step-≋; step-≋˘)
 
 ------------------------------------------------------------------------
@@ -117,10 +122,10 @@ module ⊆-Reasoning (A : Set a) where
 ------------------------------------------------------------------------
 
 Any-resp-⊆ : ∀ {P : Pred A p} → (Any P) Respects _⊆_
-Any-resp-⊆ = Setoidₚ.Any-resp-⊆ (setoid _) (subst _)
+Any-resp-⊆ = Subset.Any-resp-⊆ (setoid _) (subst _)
 
 All-resp-⊇ : ∀ {P : Pred A p} → (All P) Respects _⊇_
-All-resp-⊇ = Setoidₚ.All-resp-⊇ (setoid _) (subst _)
+All-resp-⊇ = Subset.All-resp-⊇ (setoid _) (subst _)
 
 ------------------------------------------------------------------------
 -- Properties relating _⊆_ to various list functions
@@ -129,39 +134,39 @@ All-resp-⊇ = Setoidₚ.All-resp-⊇ (setoid _) (subst _)
 
 map⁺ : ∀ (f : A → B) → xs ⊆ ys → map f xs ⊆ map f ys
 map⁺ f xs⊆ys =
-  _⟨$⟩_ (Inverse.to (map-∈↔ f)) ∘
-  Prod.map₂ (Prod.map₁ xs⊆ys) ∘
-  _⟨$⟩_ (Inverse.from (map-∈↔ f))
+  Inverse.to (map-∈↔ f) ∘
+  Product.map₂ (Product.map₁ xs⊆ys) ∘
+  Inverse.from (map-∈↔ f)
 
 ------------------------------------------------------------------------
 -- ∷
 
 xs⊆x∷xs : ∀ (xs : List A) x → xs ⊆ x ∷ xs
-xs⊆x∷xs = Setoidₚ.xs⊆x∷xs (setoid _)
+xs⊆x∷xs = Subset.xs⊆x∷xs (setoid _)
 
 ∷⁺ʳ : ∀ x → xs ⊆ ys → x ∷ xs ⊆ x ∷ ys
-∷⁺ʳ = Setoidₚ.∷⁺ʳ (setoid _)
+∷⁺ʳ = Subset.∷⁺ʳ (setoid _)
 
 ∈-∷⁺ʳ : ∀ {x} → x ∈ ys → xs ⊆ ys → x ∷ xs ⊆ ys
-∈-∷⁺ʳ = Setoidₚ.∈-∷⁺ʳ (setoid _)
+∈-∷⁺ʳ = Subset.∈-∷⁺ʳ (setoid _)
 
 ------------------------------------------------------------------------
 -- _++_
 
 xs⊆xs++ys : ∀ (xs ys : List A) → xs ⊆ xs ++ ys
-xs⊆xs++ys = Setoidₚ.xs⊆xs++ys (setoid _)
+xs⊆xs++ys = Subset.xs⊆xs++ys (setoid _)
 
 xs⊆ys++xs : ∀ (xs ys : List A) → xs ⊆ ys ++ xs
-xs⊆ys++xs = Setoidₚ.xs⊆ys++xs (setoid _)
+xs⊆ys++xs = Subset.xs⊆ys++xs (setoid _)
 
 ++⁺ʳ : ∀ zs → xs ⊆ ys → zs ++ xs ⊆ zs ++ ys
-++⁺ʳ = Setoidₚ.++⁺ʳ (setoid _)
+++⁺ʳ = Subset.++⁺ʳ (setoid _)
 
 ++⁺ˡ : ∀ zs → xs ⊆ ys → xs ++ zs ⊆ ys ++ zs
-++⁺ˡ = Setoidₚ.++⁺ˡ (setoid _)
+++⁺ˡ = Subset.++⁺ˡ (setoid _)
 
 ++⁺ : ws ⊆ xs → ys ⊆ zs → ws ++ ys ⊆ xs ++ zs
-++⁺ = Setoidₚ.++⁺ (setoid _)
+++⁺ = Subset.++⁺ (setoid _)
 
 ------------------------------------------------------------------------
 -- concat
@@ -170,15 +175,15 @@ module _ {xss yss : List (List A)} where
 
   concat⁺ : xss ⊆ yss → concat xss ⊆ concat yss
   concat⁺ xss⊆yss =
-    _⟨$⟩_ (Inverse.to concat-∈↔) ∘
-    Prod.map₂ (Prod.map₂ xss⊆yss) ∘
-    _⟨$⟩_ (Inverse.from concat-∈↔)
+    Inverse.to concat-∈↔ ∘
+    Product.map₂ (Product.map₂ xss⊆yss) ∘
+    Inverse.from concat-∈↔
 
 ------------------------------------------------------------------------
 -- applyUpTo
 
 applyUpTo⁺ : ∀ (f : ℕ → A) {m n} → m ≤ n → applyUpTo f m ⊆ applyUpTo f n
-applyUpTo⁺ = Setoidₚ.applyUpTo⁺ (setoid _)
+applyUpTo⁺ = Subset.applyUpTo⁺ (setoid _)
 
 ------------------------------------------------------------------------
 -- _>>=_
@@ -187,9 +192,9 @@ module _ {A B : Set a} (f g : A → List B) where
 
   >>=⁺ : xs ⊆ ys → (∀ {x} → f x ⊆ g x) → (xs >>= f) ⊆ (ys >>= g)
   >>=⁺ xs⊆ys f⊆g =
-    _⟨$⟩_ (Inverse.to >>=-∈↔) ∘
-    Prod.map₂ (Prod.map xs⊆ys f⊆g) ∘
-    _⟨$⟩_ (Inverse.from >>=-∈↔)
+    Inverse.to >>=-∈↔ ∘
+    Product.map₂ (Product.map xs⊆ys f⊆g) ∘
+    Inverse.from >>=-∈↔
 
 ------------------------------------------------------------------------
 -- _⊛_
@@ -198,9 +203,9 @@ module _ {A B : Set a} {fs gs : List (A → B)} where
 
   ⊛⁺ : fs ⊆ gs → xs ⊆ ys → (fs ⊛ xs) ⊆ (gs ⊛ ys)
   ⊛⁺ fs⊆gs xs⊆ys =
-    _⟨$⟩_ (Inverse.to $ ⊛-∈↔ gs) ∘
-    Prod.map₂ (Prod.map₂ (Prod.map fs⊆gs (Prod.map₁ xs⊆ys))) ∘
-    _⟨$⟩_ (Inverse.from $ ⊛-∈↔ fs)
+    (Inverse.to $ ⊛-∈↔ gs) ∘
+    Product.map₂ (Product.map₂ (Product.map fs⊆gs (Product.map₁ xs⊆ys))) ∘
+    (Inverse.from $ ⊛-∈↔ fs)
 
 ------------------------------------------------------------------------
 -- _⊗_
@@ -209,9 +214,9 @@ module _ {A B : Set a} {ws xs : List A} {ys zs : List B} where
 
   ⊗⁺ : ws ⊆ xs → ys ⊆ zs → (ws ⊗ ys) ⊆ (xs ⊗ zs)
   ⊗⁺ ws⊆xs ys⊆zs =
-    _⟨$⟩_ (Inverse.to ⊗-∈↔) ∘
-    Prod.map ws⊆xs ys⊆zs ∘
-    _⟨$⟩_ (Inverse.from ⊗-∈↔)
+    Inverse.to ⊗-∈↔ ∘
+    Product.map ws⊆xs ys⊆zs ∘
+    Inverse.from ⊗-∈↔
 
 ------------------------------------------------------------------------
 -- any
@@ -220,9 +225,9 @@ module _ (p : A → Bool) {xs ys} where
 
   any⁺ : xs ⊆ ys → T (any p xs) → T (any p ys)
   any⁺ xs⊆ys =
-    _⟨$⟩_ (Equivalence.to Any.any⇔) ∘
+    Equivalence.to Any.any⇔ ∘
     Any-resp-⊆ xs⊆ys ∘
-    _⟨$⟩_ (Equivalence.from Any.any⇔)
+    Equivalence.from Any.any⇔
 
 ------------------------------------------------------------------------
 -- mapWith∈
@@ -234,12 +239,12 @@ module _ {xs : List A} {f : ∀ {x} → x ∈ xs → B}
   mapWith∈⁺ : (xs⊆ys : xs ⊆ ys) → (∀ {x} → f {x} ≗ g ∘ xs⊆ys) →
                 mapWith∈ xs f ⊆ mapWith∈ ys g
   mapWith∈⁺ xs⊆ys f≈g {x} =
-    _⟨$⟩_ (Inverse.to Any.mapWith∈↔) ∘
-    Prod.map₂ (Prod.map xs⊆ys (λ {x∈xs} x≡fx∈xs → begin
+    Inverse.to Any.mapWith∈↔ ∘
+    Product.map₂ (Product.map xs⊆ys (λ {x∈xs} x≡fx∈xs → begin
       x               ≡⟨ x≡fx∈xs ⟩
       f x∈xs          ≡⟨ f≈g x∈xs ⟩
       g (xs⊆ys x∈xs)  ∎)) ∘
-    _⟨$⟩_ (Inverse.from Any.mapWith∈↔)
+    Inverse.from Any.mapWith∈↔
     where open ≡-Reasoning
 
 ------------------------------------------------------------------------
@@ -248,12 +253,12 @@ module _ {xs : List A} {f : ∀ {x} → x ∈ xs → B}
 module _ {P : Pred A p} (P? : Decidable P) where
 
   filter-⊆ : ∀ xs → filter P? xs ⊆ xs
-  filter-⊆ = Setoidₚ.filter-⊆ (setoid A) P?
+  filter-⊆ = Subset.filter-⊆ (setoid A) P?
 
   module _ {Q : Pred A q} (Q? : Decidable Q) where
 
     filter⁺′ : P ⋐ Q → ∀ {xs ys} → xs ⊆ ys → filter P? xs ⊆ filter Q? ys
-    filter⁺′ = Setoidₚ.filter⁺′ (setoid A) P? (resp P) Q? (resp Q)
+    filter⁺′ = Subset.filter⁺′ (setoid A) P? (resp P) Q? (resp Q)
 
 
 ------------------------------------------------------------------------
diff --git a/src/Data/List/Relation/Binary/Subset/Setoid.agda b/src/Data/List/Relation/Binary/Subset/Setoid.agda
index 3bb516fb5c..0968e06332 100644
--- a/src/Data/List/Relation/Binary/Subset/Setoid.agda
+++ b/src/Data/List/Relation/Binary/Subset/Setoid.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Relation.Binary.Subset.Setoid
   {c ℓ} (S : Setoid c ℓ) where
diff --git a/src/Data/List/Relation/Binary/Subset/Setoid/Properties.agda b/src/Data/List/Relation/Binary/Subset/Setoid/Properties.agda
index 2a700e468f..0d0d685a27 100644
--- a/src/Data/List/Relation/Binary/Subset/Setoid/Properties.agda
+++ b/src/Data/List/Relation/Binary/Subset/Setoid/Properties.agda
@@ -9,31 +9,37 @@
 module Data.List.Relation.Binary.Subset.Setoid.Properties where
 
 open import Data.Bool.Base using (Bool; true; false)
-open import Data.List.Base hiding (_∷ʳ_)
+open import Data.List.Base hiding (_∷ʳ_; find)
+import Data.List.Properties as List
 open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
 open import Data.List.Relation.Unary.All as All using (All)
 import Data.List.Membership.Setoid as Membership
-open import Data.List.Membership.Setoid.Properties
+import Data.List.Membership.Setoid.Properties as Membershipₚ
 open import Data.Nat.Base using (ℕ; s≤s; _≤_)
 import Data.List.Relation.Binary.Subset.Setoid as Subset
 import Data.List.Relation.Binary.Sublist.Setoid as Sublist
 import Data.List.Relation.Binary.Equality.Setoid as Equality
 import Data.List.Relation.Binary.Permutation.Setoid as Permutation
 import Data.List.Relation.Binary.Permutation.Setoid.Properties as Permutationₚ
-open import Data.Product using (_,_)
-open import Function.Base using (_∘_; _∘₂_)
+open import Data.Product.Base using (_,_)
+open import Function.Base using (_∘_; _∘₂_; _$_)
 open import Level using (Level)
 open import Relation.Nullary using (¬_; does; yes; no)
 open import Relation.Nullary.Negation using (contradiction)
 open import Relation.Unary using (Pred; Decidable) renaming (_⊆_ to _⋐_)
-open import Relation.Binary hiding (Decidable)
-import Relation.Binary.Reasoning.Preorder as PreorderReasoning
+open import Relation.Binary.Core using (_⇒_; _Preserves_⟶_)
+open import Relation.Binary.Definitions
+  using (Reflexive; Transitive; _Respectsʳ_; _Respectsˡ_; _Respects_)
+open import Relation.Binary.Bundles using (Setoid; Preorder)
+open import Relation.Binary.Structures using (IsPreorder)
+import Relation.Binary.Reasoning.Preorder as ≲-Reasoning
+open import Relation.Binary.Reasoning.Syntax
 
 open Setoid using (Carrier)
 
 private
   variable
-    a p q ℓ : Level
+    a b p q r ℓ : Level
 
 ------------------------------------------------------------------------
 -- Relational properties with _≋_ (pointwise equality)
@@ -44,6 +50,7 @@ module _ (S : Setoid a ℓ) where
   open Subset S
   open Equality S
   open Membership S
+  open Membershipₚ
 
   ⊆-reflexive : _≋_ ⇒ _⊆_
   ⊆-reflexive xs≋ys = ∈-resp-≋ S xs≋ys
@@ -108,31 +115,17 @@ module _ (S : Setoid a ℓ) where
 ------------------------------------------------------------------------
 
 module ⊆-Reasoning (S : Setoid a ℓ) where
+  open Membership S using (_∈_)
 
-  open Setoid S renaming (Carrier to A)
-  open Subset S
-  open Membership S
-
-  private
-    module Base = PreorderReasoning (⊆-preorder S)
+  private module Base = ≲-Reasoning (⊆-preorder S)
 
   open Base public
-    hiding (step-∼; step-≈; step-≈˘)
-
-  infixr 2 step-⊆ step-≋ step-≋˘
-  infix 1 step-∈
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨; step-≲; step-∼)
+    renaming (≲-go to ⊆-go; ≈-go to ≋-go)
 
-  step-∈ : ∀ x {xs ys} → xs IsRelatedTo ys → x ∈ xs → x ∈ ys
-  step-∈ x xs⊆ys x∈xs = (begin xs⊆ys) x∈xs
-
-  step-⊆  = Base.step-∼
-  step-≋  = Base.step-≈
-  step-≋˘ = Base.step-≈˘
-
-  syntax step-∈  x  xs⊆ys x∈xs  = x  ∈⟨  x∈xs  ⟩ xs⊆ys
-  syntax step-⊆  xs ys⊆zs xs⊆ys = xs ⊆⟨  xs⊆ys ⟩ ys⊆zs
-  syntax step-≋  xs ys⊆zs xs≋ys = xs ≋⟨  xs≋ys ⟩ ys⊆zs
-  syntax step-≋˘ xs ys⊆zs xs≋ys = xs ≋˘⟨ xs≋ys ⟩ ys⊆zs
+  open begin-membership-syntax _IsRelatedTo_ _∈_ (λ x → Base.begin x) public
+  open ⊆-syntax _IsRelatedTo_ _IsRelatedTo_ ⊆-go public
+  open ≋-syntax _IsRelatedTo_ _IsRelatedTo_ ≋-go public
 
 ------------------------------------------------------------------------
 -- Relationship with other binary relations
@@ -176,6 +169,7 @@ module _ (S : Setoid a ℓ) where
   open Setoid S
   open Subset S
   open Membership S
+  open Membershipₚ
 
   xs⊆x∷xs : ∀ xs x → xs ⊆ x ∷ xs
   xs⊆x∷xs xs x = there
@@ -195,6 +189,7 @@ module _ (S : Setoid a ℓ) where
 
   open Subset S
   open Membership S
+  open Membershipₚ
 
   xs⊆xs++ys : ∀ xs ys → xs ⊆ xs ++ ys
   xs⊆xs++ys xs ys = ∈-++⁺ˡ S
@@ -215,6 +210,59 @@ module _ (S : Setoid a ℓ) where
   ++⁺ : ∀ {ws xs ys zs} → ws ⊆ xs → ys ⊆ zs → ws ++ ys ⊆ xs ++ zs
   ++⁺ ws⊆xs ys⊆zs = ⊆-trans S (++⁺ˡ _ ws⊆xs) (++⁺ʳ _ ys⊆zs)
 
+------------------------------------------------------------------------
+-- map
+
+module _ (S : Setoid a ℓ) (R : Setoid b r) where
+
+  private
+    module S = Setoid S
+    module R = Setoid R
+
+    module S⊆ = Subset S
+    module R⊆ = Subset R
+
+  open Membershipₚ
+
+  map⁺ : ∀ {as bs} {f : S.Carrier → R.Carrier} →
+         f Preserves S._≈_ ⟶ R._≈_ →
+         as S⊆.⊆ bs → map f as R⊆.⊆ map f bs
+  map⁺ {f = f} f-pres as⊆bs v∈f[as] =
+    let x , x∈as , v≈f[x] = ∈-map⁻ S R v∈f[as] in
+    ∈-resp-≈ R (R.sym v≈f[x]) (∈-map⁺ S R f-pres (as⊆bs x∈as))
+
+------------------------------------------------------------------------
+-- reverse
+
+module _ (S : Setoid a ℓ) where
+
+  open Setoid S renaming (Carrier to A)
+  open Subset S
+
+  reverse-selfAdjoint : ∀ {as bs} → as ⊆ reverse bs → reverse as ⊆ bs
+  reverse-selfAdjoint rs = reverse⁻ ∘ rs ∘ reverse⁻
+    where reverse⁻ = Membershipₚ.reverse⁻ S
+
+-- NB. the unit and counit of this adjunction are given by:
+-- reverse-η : ∀ {xs} → xs ⊆ reverse xs
+-- reverse-η = Membershipₚ.reverse⁺ S
+-- reverse-ε : ∀ {xs} → reverse xs ⊆ xs
+-- reverse-ε = Membershipₚ.reverse⁻ S
+
+  reverse⁺ : ∀ {as bs} → as ⊆ bs → reverse as ⊆ reverse bs
+  reverse⁺ {as} {bs} rs = reverse-selfAdjoint $ begin
+    as                   ⊆⟨ rs ⟩
+    bs                   ≡⟨ List.reverse-involutive bs ⟨
+    reverse (reverse bs) ∎
+    where open ⊆-Reasoning S
+
+  reverse⁻ : ∀ {as bs} → reverse as ⊆ reverse bs → as ⊆ bs
+  reverse⁻ {as} {bs} rs = begin
+    as                   ≡⟨ List.reverse-involutive as ⟨
+    reverse (reverse as) ⊆⟨ reverse-selfAdjoint rs ⟩
+    bs                   ∎
+    where open ⊆-Reasoning S
+
 ------------------------------------------------------------------------
 -- filter
 
@@ -222,6 +270,7 @@ module _ (S : Setoid a ℓ) where
 
   open Setoid S renaming (Carrier to A)
   open Subset S
+  open Membershipₚ
 
   filter-⊆ : ∀ {P : Pred A p} (P? : Decidable P) →
              ∀ xs → filter P? xs ⊆ xs
diff --git a/src/Data/List/Relation/Binary/Suffix/Heterogeneous.agda b/src/Data/List/Relation/Binary/Suffix/Heterogeneous.agda
index 1d84c07b50..f15737ada3 100644
--- a/src/Data/List/Relation/Binary/Suffix/Heterogeneous.agda
+++ b/src/Data/List/Relation/Binary/Suffix/Heterogeneous.agda
@@ -9,9 +9,9 @@
 module Data.List.Relation.Binary.Suffix.Heterogeneous where
 
 open import Level
-open import Relation.Binary using (REL; _⇒_)
+open import Relation.Binary.Core using (REL; _⇒_)
 open import Data.List.Base as List using (List; []; _∷_)
-open import Data.List.Relation.Binary.Pointwise as Pointwise
+open import Data.List.Relation.Binary.Pointwise.Base as Pointwise
   using (Pointwise; []; _∷_)
 
 module _ {a b r} {A : Set a} {B : Set b} (R : REL A B r) where
@@ -31,6 +31,8 @@ module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
   tail (here (_ ∷ rs)) = there (here rs)
   tail (there x) = there (tail x)
 
+  infixr 5 _++ˢ_
+
   _++ˢ_ : ∀ pre {as bs} → Suffix R as bs → Suffix R as (pre List.++ bs)
   []       ++ˢ rs = rs
   (x ∷ xs) ++ˢ rs = there (xs ++ˢ rs)
@@ -45,8 +47,7 @@ module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
 
   toView : ∀ {as bs} → Suffix R as bs → SuffixView R as bs
   toView (here rs) = [] ++ rs
-  toView (there {c} suf) with toView suf
-  ... | cs ++ rs = (c ∷ cs) ++ rs
+  toView (there {c} suf) with cs ++ rs ← toView suf = (c ∷ cs) ++ rs
 
   fromView : ∀ {as bs} → SuffixView R as bs → Suffix R as bs
   fromView ([]       ++ rs) = here rs
diff --git a/src/Data/List/Relation/Binary/Suffix/Heterogeneous/Properties.agda b/src/Data/List/Relation/Binary/Suffix/Heterogeneous/Properties.agda
index 736389bb75..3506d0000b 100644
--- a/src/Data/List/Relation/Binary/Suffix/Heterogeneous/Properties.agda
+++ b/src/Data/List/Relation/Binary/Suffix/Heterogeneous/Properties.agda
@@ -24,13 +24,14 @@ open import Relation.Nullary using (Dec; does; ¬_)
 import Relation.Nullary.Decidable as Dec
 open import Relation.Unary as U using (Pred)
 open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Binary as B
-  using (REL; Rel; Trans; Antisym; Irrelevant; _⇒_)
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; _≢_; refl; sym; subst; subst₂)
+open import Relation.Binary.Core using (REL; Rel; _⇒_)
+open import Relation.Binary.Definitions as B
+  using (Trans; Antisym; Irrelevant)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≢_; refl; sym; cong; subst; subst₂)
 
-import Data.List.Properties as Listₚ
-import Data.List.Relation.Binary.Prefix.Heterogeneous.Properties as Prefixₚ
+import Data.List.Properties as List
+import Data.List.Relation.Binary.Prefix.Heterogeneous.Properties as Prefix
 
 ------------------------------------------------------------------------
 -- Suffix and Prefix are linked via reverse
@@ -39,34 +40,32 @@ module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
 
   fromPrefix : ∀ {as bs} → Prefix R as bs →
                Suffix R (reverse as) (reverse bs)
-  fromPrefix {as} {bs} p with Prefix.toView p
-  ... | Prefix._++_ {cs} rs ds =
+  fromPrefix {as} {bs} p with Prefix._++_ {cs} rs ds ← Prefix.toView p =
     subst (Suffix R (reverse as))
-      (sym (Listₚ.reverse-++ cs ds))
+      (sym (List.reverse-++ cs ds))
       (Suffix.fromView (reverse ds Suffix.++ Pw.reverse⁺ rs))
 
   fromPrefix-rev : ∀ {as bs} → Prefix R (reverse as) (reverse bs) →
                    Suffix R as bs
   fromPrefix-rev pre =
     subst₂ (Suffix R)
-      (Listₚ.reverse-involutive _)
-      (Listₚ.reverse-involutive _)
+      (List.reverse-involutive _)
+      (List.reverse-involutive _)
       (fromPrefix pre)
 
   toPrefix-rev : ∀ {as bs} → Suffix R as bs →
                  Prefix R (reverse as) (reverse bs)
-  toPrefix-rev {as} {bs} s with Suffix.toView s
-  ... | Suffix._++_ cs {ds} rs =
+  toPrefix-rev {as} {bs} s with Suffix._++_ cs {ds} rs ← Suffix.toView s =
     subst (Prefix R (reverse as))
-      (sym (Listₚ.reverse-++ cs ds))
+      (sym (List.reverse-++ cs ds))
       (Prefix.fromView (Pw.reverse⁺ rs Prefix.++ reverse cs))
 
   toPrefix : ∀ {as bs} → Suffix R (reverse as) (reverse bs) →
              Prefix R as bs
   toPrefix suf =
     subst₂ (Prefix R)
-      (Listₚ.reverse-involutive _)
-      (Listₚ.reverse-involutive _)
+      (List.reverse-involutive _)
+      (List.reverse-involutive _)
       (toPrefix-rev suf)
 
 ------------------------------------------------------------------------
@@ -138,7 +137,7 @@ module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
     ds<cs = begin-strict
       length ds                   ≤⟨ m≤n+m (length ds) (length bs) ⟩
       length bs + length ds       <⟨ ≤-refl ⟩
-      suc (length bs + length ds) ≡⟨ sym $ Listₚ.length-++ (b ∷ bs) ⟩
+      suc (length bs + length ds) ≡⟨ sym $ List.length-++ (b ∷ bs) ⟩
       length (b ∷ bs ++ ds)       ≡⟨ sym $ Pointwise-length rs ⟩
       length cs                   ∎
 
@@ -198,14 +197,14 @@ module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
 module _ {a b r} {A : Set a} {B : Set b} {R : REL A B r} where
 
   irrelevant : Irrelevant R → Irrelevant (Suffix R)
-  irrelevant irr (here  rs)   (here  rs₁)   = P.cong here $ Pw.irrelevant irr rs rs₁
+  irrelevant irr (here  rs)   (here  rs₁)   = cong here $ Pw.irrelevant irr rs rs₁
   irrelevant irr (here  rs)   (there rsuf)  = contradiction (Pointwise-length rs) (S[as][bs]⇒∣as∣≢1+∣bs∣ rsuf)
   irrelevant irr (there rsuf) (here  rs)    = contradiction (Pointwise-length rs) (S[as][bs]⇒∣as∣≢1+∣bs∣ rsuf)
-  irrelevant irr (there rsuf) (there rsuf₁) = P.cong there $ irrelevant irr rsuf rsuf₁
+  irrelevant irr (there rsuf) (there rsuf₁) = cong there $ irrelevant irr rsuf rsuf₁
 
 ------------------------------------------------------------------------
 -- Decidability
 
   suffix? : B.Decidable R → B.Decidable (Suffix R)
   suffix? R? as bs = Dec.map′ fromPrefix-rev toPrefix-rev
-                   $ Prefixₚ.prefix? R? (reverse as) (reverse bs)
+                   $ Prefix.prefix? R? (reverse as) (reverse bs)
diff --git a/src/Data/List/Relation/Binary/Suffix/Homogeneous/Properties.agda b/src/Data/List/Relation/Binary/Suffix/Homogeneous/Properties.agda
index 8f8e9c4a77..0a5298f431 100644
--- a/src/Data/List/Relation/Binary/Suffix/Homogeneous/Properties.agda
+++ b/src/Data/List/Relation/Binary/Suffix/Homogeneous/Properties.agda
@@ -10,7 +10,9 @@ module Data.List.Relation.Binary.Suffix.Homogeneous.Properties where
 
 open import Level
 open import Function.Base using (_∘′_)
-open import Relation.Binary
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsDecPartialOrder)
 
 open import Data.List.Relation.Binary.Pointwise as Pointwise using (Pointwise)
 open import Data.List.Relation.Binary.Suffix.Heterogeneous
diff --git a/src/Data/List/Relation/Ternary/Appending.agda b/src/Data/List/Relation/Ternary/Appending.agda
index 025364f122..1a2bab30e1 100644
--- a/src/Data/List/Relation/Ternary/Appending.agda
+++ b/src/Data/List/Relation/Ternary/Appending.agda
@@ -10,10 +10,10 @@ module Data.List.Relation.Ternary.Appending {a b c} {A : Set a} {B : Set b} {C :
 
 open import Level using (Level; _⊔_)
 open import Data.List.Base as List using (List; []; _∷_)
-open import Data.List.Relation.Binary.Pointwise using (Pointwise; []; _∷_)
-open import Data.Product as Prod using (∃₂; _×_; _,_; -,_)
-open import Relation.Binary using (REL)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong)
+open import Data.List.Relation.Binary.Pointwise.Base using (Pointwise; []; _∷_)
+open import Data.Product.Base using (∃₂; _×_; _,_; -,_)
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
 
 private
   variable
@@ -38,6 +38,8 @@ module _ (L : REL A C l) (R : REL B C r) where
 ------------------------------------------------------------------------
 -- Functions manipulating Appending
 
+infixr 5 _++_
+
 _++_ : ∀ {cs₁ cs₂ : List C} → Pointwise L as cs₁ → Pointwise R bs cs₂ →
        Appending L R as bs (cs₁ List.++ cs₂)
 []       ++ rs = []++ rs
diff --git a/src/Data/List/Relation/Ternary/Appending/Properties.agda b/src/Data/List/Relation/Ternary/Appending/Properties.agda
index 11db3cf16e..9ab5089f08 100644
--- a/src/Data/List/Relation/Ternary/Appending/Properties.agda
+++ b/src/Data/List/Relation/Ternary/Appending/Properties.agda
@@ -11,45 +11,88 @@ module Data.List.Relation.Ternary.Appending.Properties where
 open import Data.List.Base using (List; [])
 open import Data.List.Relation.Ternary.Appending
 open import Data.List.Relation.Binary.Pointwise as Pw using (Pointwise; []; _∷_)
+open import Data.Product.Base as Product using (∃-syntax; _×_; _,_)
+open import Function.Base using (id)
+open import Data.List.Relation.Binary.Pointwise.Base as Pw using (Pointwise; []; _∷_)
+open import Data.List.Relation.Binary.Pointwise.Properties as Pw using (transitive)
 open import Level using (Level)
-open import Relation.Binary using (REL; Rel; Trans)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.Core using (REL; Rel; _⇒_)
+open import Relation.Binary.Definitions using (Trans)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
+open import Relation.Binary.Construct.Composition using (_;_)
 
 private
   variable
-    a a′ b b′ c c′ l r : Level
-    A : Set a
-    A′ : Set a′
-    B : Set b
-    B′ : Set b′
-    C : Set c
-    C′ : Set c′
-    L : REL A C l
-    R : REL B C r
-    as : List A
-    bs : List B
-    cs : List C
-
-module _  {e} {E : REL C C′ e} {L′ : REL A C′ l} {R′ : REL B C′ r}
-          (LEL′ : Trans L E L′) (RER′ : Trans R E R′)
-          where
+    a ℓ l r : Level
+    A A′ B B′ C C′ D D′ : Set a
+    R S T U V W X Y : REL A B ℓ
+    as bs cs ds : List A
+
+module _  (RST : Trans R S T) (USV : Trans U S V) where
 
-  respʳ-≋ : ∀ {cs′} → Appending L R as bs cs → Pointwise E cs cs′ → Appending L′ R′ as bs cs′
-  respʳ-≋ ([]++ rs) es       = []++ Pw.transitive RER′ rs es
-  respʳ-≋ (l ∷ lrs) (e ∷ es) = LEL′ l e ∷ respʳ-≋ lrs es
+  respʳ-≋ : Appending R U as bs cs → Pointwise S cs ds → Appending T V as bs ds
+  respʳ-≋ ([]++ rs) es       = []++ Pw.transitive USV rs es
+  respʳ-≋ (l ∷ lrs) (e ∷ es) = RST l e ∷ respʳ-≋ lrs es
 
-module _  {eᴬ eᴮ} {Eᴬ : REL A′ A eᴬ} {Eᴮ : REL B′ B eᴮ}
-          {L′ : REL A′ C l} (ELL′ : Trans Eᴬ L L′)
-          {R′ : REL B′ C r} (ERR′ : Trans Eᴮ R R′)
+module _  {T : REL A B l} (RST : Trans R S T)
+          {W : REL A B r} (ERW : Trans U V W)
           where
 
-  respˡ-≋ : ∀ {as′ bs′} → Pointwise Eᴬ as′ as → Pointwise Eᴮ bs′ bs →
-            Appending L R as bs cs → Appending L′ R′ as′ bs′ cs
-  respˡ-≋ []         esʳ ([]++ rs) = []++ Pw.transitive ERR′ esʳ rs
-  respˡ-≋ (eˡ ∷ esˡ) esʳ (l ∷ lrs) = ELL′ eˡ l ∷ respˡ-≋ esˡ esʳ lrs
+  respˡ-≋ : ∀ {as′ bs′} → Pointwise R as′ as → Pointwise U bs′ bs →
+            Appending S V as bs cs → Appending T W as′ bs′ cs
+  respˡ-≋ []         esʳ ([]++ rs) = []++ Pw.transitive ERW esʳ rs
+  respˡ-≋ (eˡ ∷ esˡ) esʳ (l ∷ lrs) = RST eˡ l ∷ respˡ-≋ esˡ esʳ lrs
 
-conicalˡ : Appending L R as bs [] → as ≡ []
+conicalˡ : Appending R S as bs [] → as ≡ []
 conicalˡ ([]++ rs) = refl
 
-conicalʳ : Appending L R as bs [] → bs ≡ []
+conicalʳ : Appending R S as bs [] → bs ≡ []
 conicalʳ ([]++ []) = refl
+
+through→ :
+  (R ⇒ (S ; T)) →
+  ((U ; V) ⇒ (W ; T)) →
+  ∃[ xs ] Pointwise U as xs × Appending V R xs bs cs →
+  ∃[ ys ] Appending W S as bs ys × Pointwise T ys cs
+through→ f g (_ , [] , []++ rs) =
+  let _ , rs′ , ps′ = Pw.unzip (Pw.map f rs) in
+  _ , []++ rs′ , ps′
+through→ f g (_ , p ∷ ps , l ∷ lrs) =
+  let _ , l′ , p′ = g (_ , p , l) in
+  Product.map _ (Product.map (l′ ∷_) (p′ ∷_)) (through→ f g (_ , ps , lrs))
+
+through← :
+  ((R ; S) ⇒ T) →
+  ((U ; S) ⇒ (V ; W)) →
+  ∃[ ys ] Appending U R as bs ys × Pointwise S ys cs →
+  ∃[ xs ] Pointwise V as xs × Appending W T xs bs cs
+through← f g (_ , []++ rs′ , ps′) =
+  _ , [] , []++ (Pw.transitive (λ r′ p′ → f (_ , r′ , p′)) rs′ ps′)
+through← f g (_ , l′ ∷ lrs′ , p′ ∷ ps′) =
+  let _ , p , l = g (_ , l′ , p′) in
+  Product.map _ (Product.map (p ∷_) (l ∷_)) (through← f g (_ , lrs′ , ps′))
+
+assoc→ :
+  (R ⇒ (S ; T)) →
+  ((U ; V) ⇒ (W ; T)) →
+  ((Y ; V) ⇒ X) →
+  ∃[ xs ] Appending Y U as bs xs × Appending V R xs cs ds →
+  ∃[ ys ] Appending W S bs cs ys × Appending X T as ys ds
+assoc→ f g h (_ , []++ rs , lrs′) =
+  let _ , mss , ss′ = through→ f g (_ , rs , lrs′) in
+  _ , mss , []++ ss′
+assoc→ f g h (_ , l ∷ lrs , l′ ∷ lrs′) =
+  Product.map₂ (Product.map₂ (h (_ , l , l′) ∷_)) (assoc→ f g h (_ , lrs , lrs′))
+
+assoc← :
+  ((S ; T) ⇒ R) →
+  ((W ; T) ⇒ (U ; V)) →
+  (X ⇒ (Y ; V)) →
+  ∃[ ys ] Appending W S bs cs ys × Appending X T as ys ds →
+  ∃[ xs ] Appending Y U as bs xs × Appending V R xs cs ds
+assoc← f g h (_ , mss , []++ ss′) =
+  let _ , rs , lrs′ = through← f g (_ , mss , ss′) in
+  _ , []++ rs , lrs′
+assoc← f g h (_ , mss , m′ ∷ mss′) =
+  let _ , l , l′ = h m′ in
+  Product.map _ (Product.map (l ∷_) (l′ ∷_)) (assoc← f g h (_ , mss , mss′))
diff --git a/src/Data/List/Relation/Ternary/Appending/Propositional.agda b/src/Data/List/Relation/Ternary/Appending/Propositional.agda
index 46cb27f75e..1d1ad63509 100644
--- a/src/Data/List/Relation/Ternary/Appending/Propositional.agda
+++ b/src/Data/List/Relation/Ternary/Appending/Propositional.agda
@@ -11,17 +11,18 @@ module Data.List.Relation.Ternary.Appending.Propositional
   where
 
 open import Data.List.Base as List using (List; []; _∷_)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 
-import Data.List.Properties as Listₚ
-import Data.List.Relation.Binary.Pointwise as Pw
-
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; setoid; refl; trans; cong₂; module ≡-Reasoning)
+import Data.List.Properties as List
+import Data.List.Relation.Binary.Pointwise as Pw using (≡⇒Pointwise-≡; Pointwise-≡⇒≡)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; trans; cong₂)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning; setoid)
 
 import Data.List.Relation.Ternary.Appending.Setoid (setoid A) as General
 import Data.List.Relation.Ternary.Appending.Setoid.Properties (setoid A)
-  as Appendingₚ
+  as Appending
 
 ------------------------------------------------------------------------
 -- Re-export the basic combinators
@@ -32,11 +33,13 @@ open General public
 ------------------------------------------------------------------------
 -- Definition
 
+infixr 5 _++_ _++[]
+
 _++_ : (as bs : List A) → Appending as bs (as List.++ bs)
 as ++ bs = Pw.≡⇒Pointwise-≡ refl General.++ Pw.≡⇒Pointwise-≡ refl
 
 _++[] : (as : List A) → Appending as [] as
-as ++[] = Appendingₚ.respʳ-≋ (as ++ []) (Pw.≡⇒Pointwise-≡ (Listₚ.++-identityʳ as))
+as ++[] = Appending.respʳ-≋ (as ++ []) (Pw.≡⇒Pointwise-≡ (List.++-identityʳ as))
 
 break : ∀ {as bs cs} → Appending as bs cs → as List.++ bs ≡ cs
 break {as} {bs} {cs} lrs = let (cs₁ , cs₂ , eq , acs , bcs) = General.break lrs in begin
diff --git a/src/Data/List/Relation/Ternary/Appending/Propositional/Properties.agda b/src/Data/List/Relation/Ternary/Appending/Propositional/Properties.agda
index e4ecefddae..46cf757ed0 100644
--- a/src/Data/List/Relation/Ternary/Appending/Propositional/Properties.agda
+++ b/src/Data/List/Relation/Ternary/Appending/Propositional/Properties.agda
@@ -9,15 +9,15 @@
 module Data.List.Relation.Ternary.Appending.Propositional.Properties {a} {A : Set a} where
 
 open import Data.List.Base as List using (List; [])
-import Data.List.Properties as Listₚ
-import Data.List.Relation.Binary.Pointwise as Pw
+import Data.List.Relation.Binary.Pointwise as Pw using (Pointwise-≡⇒≡)
 open import Data.List.Relation.Binary.Equality.Propositional using (_≋_)
 open import Data.List.Relation.Ternary.Appending.Propositional {A = A}
 open import Function.Base using (_∘′_)
-open import Relation.Binary.PropositionalEquality as Eq using (_≡_; setoid)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 
 import Data.List.Relation.Ternary.Appending.Setoid.Properties (setoid A)
-  as Appendingₚ
+  as Appending
 
 private
   variable
@@ -26,14 +26,14 @@ private
 ------------------------------------------------------------------------
 -- Re-export existing properties
 
-open Appendingₚ public
+open Appending public
   hiding ([]++⁻¹; ++[]⁻¹)
 
 ------------------------------------------------------------------------
 -- Prove propositional-specific ones
 
 []++⁻¹ : Appending [] bs cs → bs ≡ cs
-[]++⁻¹ = Pw.Pointwise-≡⇒≡ ∘′ Appendingₚ.[]++⁻¹
+[]++⁻¹ = Pw.Pointwise-≡⇒≡ ∘′ Appending.[]++⁻¹
 
 ++[]⁻¹ : Appending as [] cs → as ≡ cs
-++[]⁻¹ = Pw.Pointwise-≡⇒≡ ∘′ Appendingₚ.++[]⁻¹
+++[]⁻¹ = Pw.Pointwise-≡⇒≡ ∘′ Appending.++[]⁻¹
diff --git a/src/Data/List/Relation/Ternary/Appending/Setoid.agda b/src/Data/List/Relation/Ternary/Appending/Setoid.agda
index fc07b650af..0460f9ea21 100644
--- a/src/Data/List/Relation/Ternary/Appending/Setoid.agda
+++ b/src/Data/List/Relation/Ternary/Appending/Setoid.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Setoid)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Relation.Ternary.Appending.Setoid
   {c ℓ} (S : Setoid c ℓ)
diff --git a/src/Data/List/Relation/Ternary/Appending/Setoid/Properties.agda b/src/Data/List/Relation/Ternary/Appending/Setoid/Properties.agda
index 60e3e2f4ad..b4d2a97d90 100644
--- a/src/Data/List/Relation/Ternary/Appending/Setoid/Properties.agda
+++ b/src/Data/List/Relation/Ternary/Appending/Setoid/Properties.agda
@@ -6,29 +6,35 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Setoid)
+open import Relation.Binary.Bundles using (Setoid)
 
-module Data.List.Relation.Ternary.Appending.Setoid.Properties {c l} (S : Setoid c l) where
+module Data.List.Relation.Ternary.Appending.Setoid.Properties
+  {c l} (S : Setoid c l)
+  where
 
 open import Data.List.Base as List using (List; [])
-import Data.List.Properties as Listₚ
-open import Data.List.Relation.Binary.Pointwise using (Pointwise; [])
+import Data.List.Properties as List
+open import Data.List.Relation.Binary.Pointwise.Base using (Pointwise; [])
 import Data.List.Relation.Ternary.Appending.Properties as Appendingₚ
-open import Data.Product using (_,_)
-open import Relation.Binary.PropositionalEquality using (refl)
+open import Data.Product.Base using (∃-syntax; _×_; _,_)
+open import Function.Base using (id)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.PropositionalEquality.Core using (refl)
+open import Relation.Binary.Construct.Composition using (_;_)
 
+open Setoid S renaming (Carrier to A)
+open import Relation.Binary.Properties.Setoid S using (≈;≈⇒≈; ≈⇒≈;≈)
 open import Data.List.Relation.Ternary.Appending.Setoid S
-module S = Setoid S; open S renaming (Carrier to A) using (_≈_)
 
 private
   variable
-    as bs cs : List A
+    as bs cs ds : List A
 
 ------------------------------------------------------------------------
 -- Re-exporting existing properties
 
 open Appendingₚ public
-  hiding (respʳ-≋; respˡ-≋)
+  using (conicalˡ; conicalʳ)
 
 ------------------------------------------------------------------------
 -- Proving setoid-specific ones
@@ -39,13 +45,28 @@ open Appendingₚ public
 ++[]⁻¹ : Appending as [] cs → Pointwise _≈_ as cs
 ++[]⁻¹ {as} {cs} ls with break ls
 ... | cs₁ , cs₂ , refl , pw , []
-  rewrite Listₚ.++-identityʳ cs₁
+  rewrite List.++-identityʳ cs₁
   = pw
 
 respʳ-≋ : ∀ {cs′} → Appending as bs cs → Pointwise _≈_ cs cs′ →
           Appending as bs cs′
-respʳ-≋ = Appendingₚ.respʳ-≋ S.trans S.trans
+respʳ-≋ = Appendingₚ.respʳ-≋ trans trans
 
 respˡ-≋ : ∀ {as′ bs′} → Pointwise _≈_ as′ as → Pointwise _≈_ bs′ bs →
           Appending as bs cs → Appending as′ bs′ cs
-respˡ-≋ = Appendingₚ.respˡ-≋ S.trans S.trans
+respˡ-≋ = Appendingₚ.respˡ-≋ trans trans
+
+through→ :
+  ∃[ xs ] Pointwise _≈_ as xs × Appending xs bs cs →
+  ∃[ ys ] Appending as bs ys × Pointwise _≈_ ys cs
+through→ = Appendingₚ.through→ ≈⇒≈;≈ id
+
+through← :
+  ∃[ ys ] Appending as bs ys × Pointwise _≈_ ys cs →
+  ∃[ xs ] Pointwise _≈_ as xs × Appending xs bs cs
+through← = Appendingₚ.through← ≈;≈⇒≈ id
+
+assoc→ :
+  ∃[ xs ] Appending as bs xs × Appending xs cs ds →
+  ∃[ ys ] Appending bs cs ys × Appending as ys ds
+assoc→ = Appendingₚ.assoc→ ≈⇒≈;≈ id ≈;≈⇒≈
diff --git a/src/Data/List/Relation/Ternary/Interleaving.agda b/src/Data/List/Relation/Ternary/Interleaving.agda
index cfc84e52c4..38ecbf5579 100644
--- a/src/Data/List/Relation/Ternary/Interleaving.agda
+++ b/src/Data/List/Relation/Ternary/Interleaving.agda
@@ -11,12 +11,12 @@ module Data.List.Relation.Ternary.Interleaving where
 
 open import Level
 open import Data.List.Base as List using (List; []; _∷_; _++_)
-open import Data.List.Relation.Binary.Pointwise using (Pointwise; []; _∷_)
-open import Data.Product as Prod using (∃; ∃₂; _×_; uncurry; _,_; -,_; proj₂)
+open import Data.List.Relation.Binary.Pointwise.Base using (Pointwise; []; _∷_)
+open import Data.Product.Base as Product using (∃; ∃₂; _×_; uncurry; _,_; -,_; proj₂)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 open import Function.Base
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (REL; _⇒_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 ------------------------------------------------------------------------
 -- Definition
@@ -60,9 +60,9 @@ module _ {a b c l r} {A : Set a} {B : Set b} {C : Set c}
           Interleaving _≡_ _≡_ csl csr cs × Pointwise L l csl × Pointwise R r csr
   break []        = -, [] , [] , []
   break (l ∷ˡ sp) = let (_ , eq , pwl , pwr) = break sp in
-                    -, P.refl ∷ˡ eq , l ∷ pwl , pwr
+                    -, refl ∷ˡ eq , l ∷ pwl , pwr
   break (r ∷ʳ sp) = let (_ , eq , pwl , pwr) = break sp in
-                    -, P.refl ∷ʳ eq , pwl , r ∷ pwr
+                    -, refl ∷ʳ eq , pwl , r ∷ pwr
 
 -- map
 
@@ -95,11 +95,11 @@ module _ {a b l r} {A : Set a} {B : Set b} {L : REL A B l} {R : REL A B r} where
   split : ∀ {as bs} → Pointwise (λ a b → L a b ⊎ R a b) as bs →
           ∃₂ λ asr asl → Interleaving L R asl asr bs
   split []            = [] , [] , []
-  split (inj₁ l ∷ pw) = Prod.map _ (Prod.map _ (l ∷ˡ_)) (split pw)
-  split (inj₂ r ∷ pw) = Prod.map _ (Prod.map _ (r ∷ʳ_)) (split pw)
+  split (inj₁ l ∷ pw) = Product.map _ (Product.map _ (l ∷ˡ_)) (split pw)
+  split (inj₂ r ∷ pw) = Product.map _ (Product.map _ (r ∷ʳ_)) (split pw)
 
   unsplit : ∀ {l r as} → Interleaving L R l r as →
             ∃ λ bs → Pointwise (λ a b → L a b ⊎ R a b) bs as
   unsplit []        = -, []
-  unsplit (l ∷ˡ sp) = Prod.map _ (inj₁ l ∷_) (unsplit sp)
-  unsplit (r ∷ʳ sp) = Prod.map _ (inj₂ r ∷_) (unsplit sp)
+  unsplit (l ∷ˡ sp) = Product.map _ (inj₁ l ∷_) (unsplit sp)
+  unsplit (r ∷ʳ sp) = Product.map _ (inj₂ r ∷_) (unsplit sp)
diff --git a/src/Data/List/Relation/Ternary/Interleaving/Properties.agda b/src/Data/List/Relation/Ternary/Interleaving/Properties.agda
index 563adfc9d9..5317d5a7c5 100644
--- a/src/Data/List/Relation/Ternary/Interleaving/Properties.agda
+++ b/src/Data/List/Relation/Ternary/Interleaving/Properties.agda
@@ -13,10 +13,12 @@ open import Data.Nat.Properties using (+-suc)
 open import Data.List.Base hiding (_∷ʳ_)
 open import Data.List.Properties using (reverse-involutive)
 open import Data.List.Relation.Ternary.Interleaving hiding (map)
-open import Function
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; refl; sym; cong; module ≡-Reasoning)
+open import Function.Base using (_$_)
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; sym; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open ≡-Reasoning
 
 ------------------------------------------------------------------------
diff --git a/src/Data/List/Relation/Ternary/Interleaving/Propositional.agda b/src/Data/List/Relation/Ternary/Interleaving/Propositional.agda
index c1ac5c9adf..55515cd447 100644
--- a/src/Data/List/Relation/Ternary/Interleaving/Propositional.agda
+++ b/src/Data/List/Relation/Ternary/Interleaving/Propositional.agda
@@ -12,7 +12,8 @@ open import Data.List.Base as List using (List; []; _∷_; _++_)
 open import Data.List.Relation.Binary.Permutation.Propositional as Perm using (_↭_)
 open import Data.List.Relation.Binary.Permutation.Propositional.Properties using (shift)
 import Data.List.Relation.Ternary.Interleaving.Setoid as General
-open import Relation.Binary.PropositionalEquality using (setoid; refl)
+open import Relation.Binary.PropositionalEquality.Core using (refl)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 open Perm.PermutationReasoning
 
 ------------------------------------------------------------------------
diff --git a/src/Data/List/Relation/Ternary/Interleaving/Propositional/Properties.agda b/src/Data/List/Relation/Ternary/Interleaving/Propositional/Properties.agda
index b8328e48e8..c4253a7253 100644
--- a/src/Data/List/Relation/Ternary/Interleaving/Propositional/Properties.agda
+++ b/src/Data/List/Relation/Ternary/Interleaving/Propositional/Properties.agda
@@ -11,7 +11,7 @@ module Data.List.Relation.Ternary.Interleaving.Propositional.Properties
 
 import Data.List.Relation.Ternary.Interleaving.Setoid.Properties
   as SetoidProperties
-open import Relation.Binary.PropositionalEquality using (setoid)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 
 ------------------------------------------------------------------------
 -- Re-exporting existing properties
diff --git a/src/Data/List/Relation/Ternary/Interleaving/Setoid.agda b/src/Data/List/Relation/Ternary/Interleaving/Setoid.agda
index 006acdf84b..b245df5da7 100644
--- a/src/Data/List/Relation/Ternary/Interleaving/Setoid.agda
+++ b/src/Data/List/Relation/Ternary/Interleaving/Setoid.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Setoid)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Relation.Ternary.Interleaving.Setoid {c ℓ} (S : Setoid c ℓ) where
 
diff --git a/src/Data/List/Relation/Ternary/Interleaving/Setoid/Properties.agda b/src/Data/List/Relation/Ternary/Interleaving/Setoid/Properties.agda
index f66628a628..936bca38b4 100644
--- a/src/Data/List/Relation/Ternary/Interleaving/Setoid/Properties.agda
+++ b/src/Data/List/Relation/Ternary/Interleaving/Setoid/Properties.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Setoid)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Relation.Ternary.Interleaving.Setoid.Properties
   {c ℓ} (S : Setoid c ℓ) where
@@ -16,7 +16,7 @@ open import Data.Bool.Base using (true; false)
 open import Relation.Unary using (Decidable)
 open import Relation.Nullary.Decidable using (does)
 open import Relation.Nullary.Decidable using (¬?)
-open import Function
+open import Function.Base using (_∘_)
 
 open import Data.List.Relation.Binary.Equality.Setoid S using (≋-refl)
 open import Data.List.Relation.Ternary.Interleaving.Setoid S
diff --git a/src/Data/List/Relation/Unary/All.agda b/src/Data/List/Relation/Unary/All.agda
index 674a8e33d5..ea2ab858df 100644
--- a/src/Data/List/Relation/Unary/All.agda
+++ b/src/Data/List/Relation/Unary/All.agda
@@ -8,23 +8,25 @@
 
 module Data.List.Relation.Unary.All where
 
-open import Effect.Applicative
-open import Effect.Monad
-open import Data.Empty using (⊥)
 open import Data.List.Base as List using (List; []; _∷_)
 open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
 open import Data.List.Membership.Propositional renaming (_∈_ to _∈ₚ_)
 import Data.List.Membership.Setoid as SetoidMembership
-open import Data.Product as Prod
+open import Data.Product.Base as Product
   using (∃; -,_; _×_; _,_; proj₁; proj₂; uncurry)
 open import Data.Sum.Base as Sum using (inj₁; inj₂)
-open import Function
-open import Level
+open import Effect.Applicative
+open import Effect.Monad
+open import Function.Base using (_∘_; _∘′_; id; const)
+open import Level using (Level; _⊔_)
 open import Relation.Nullary hiding (Irrelevant)
 import Relation.Nullary.Decidable as Dec
 open import Relation.Unary hiding (_∈_)
-open import Relation.Binary using (Setoid; _Respects_)
-open import Relation.Binary.PropositionalEquality as P
+import Relation.Unary.Properties as Unary
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (_Respects_)
+open import Relation.Binary.PropositionalEquality.Core as ≡
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 private
   variable
@@ -48,7 +50,8 @@ data All {A : Set a} (P : Pred A p) : Pred (List A) (a ⊔ p) where
   _∷_ : ∀ {x xs} (px : P x) (pxs : All P xs) → All P (x ∷ xs)
 
 -- All P xs is a finite map from indices x ∈ xs to content P x.
--- Relation pxs [ i ]= px states that, in map pxs, key i : x ∈ xs points to value px.
+-- Relation pxs [ i ]= px states that, in map pxs, key i : x ∈ xs points
+-- to value px.
 
 infix 4 _[_]=_
 
@@ -65,7 +68,7 @@ data _[_]=_ {A : Set a} {P : Pred A p} :
 -- A list is empty if having an element is impossible.
 
 Null : Pred (List A) _
-Null = All (λ _ → ⊥)
+Null = All ∅
 
 ------------------------------------------------------------------------
 -- Operations on All
@@ -85,7 +88,7 @@ reduce f (px ∷ pxs) = f px ∷ reduce f pxs
 
 construct : (f : B → ∃ P) (xs : List B) → ∃ (All P)
 construct f []       = [] , []
-construct f (x ∷ xs) = Prod.zip _∷_ _∷_ (f x) (construct f xs)
+construct f (x ∷ xs) = Product.zip _∷_ _∷_ (f x) (construct f xs)
 
 fromList : (xs : List (∃ P)) → All P (List.map proj₁ xs)
 fromList []              = []
@@ -104,7 +107,7 @@ zipWith f (px ∷ pxs , qx ∷ qxs) = f (px , qx) ∷ zipWith f (pxs , qxs)
 
 unzipWith : R ⊆ P ∩ Q → All R ⊆ All P ∩ All Q
 unzipWith f []         = [] , []
-unzipWith f (rx ∷ rxs) = Prod.zip _∷_ _∷_ (f rx) (unzipWith f rxs)
+unzipWith f (rx ∷ rxs) = Product.zip _∷_ _∷_ (f rx) (unzipWith f rxs)
 
 zip : All P ∩ All Q ⊆ All (P ∩ Q)
 zip = zipWith id
@@ -113,17 +116,17 @@ unzip : All (P ∩ Q) ⊆ All P ∩ All Q
 unzip = unzipWith id
 
 module _(S : Setoid a ℓ) {P : Pred (Setoid.Carrier S) p} where
-  open Setoid S renaming (Carrier to C; refl to refl₁)
+  open Setoid S renaming (refl to ≈-refl)
   open SetoidMembership S
 
   tabulateₛ : (∀ {x} → x ∈ xs → P x) → All P xs
-  tabulateₛ {[]}     hyp = []
-  tabulateₛ {x ∷ xs} hyp = hyp (here refl₁) ∷ tabulateₛ (hyp ∘ there)
+  tabulateₛ {[]}    hyp = []
+  tabulateₛ {_ ∷ _} hyp = hyp (here ≈-refl) ∷ tabulateₛ (hyp ∘ there)
 
 tabulate : (∀ {x} → x ∈ₚ xs → P x) → All P xs
-tabulate = tabulateₛ (P.setoid _)
+tabulate = tabulateₛ (≡.setoid _)
 
-self : ∀ {xs : List A} → All (const A) xs
+self : ∀ {xs} → All (const A) xs
 self = tabulate (λ {x} _ → x)
 
 ------------------------------------------------------------------------
@@ -186,17 +189,17 @@ lookupAny (px ∷ pxs) (here qx) = px , qx
 lookupAny (px ∷ pxs) (there i) = lookupAny pxs i
 
 lookupWith : ∀[ P ⇒ Q ⇒ R ] → All P xs → (i : Any Q xs) → R (Any.lookup i)
-lookupWith f pxs i = Prod.uncurry f (lookupAny pxs i)
+lookupWith f pxs i = Product.uncurry f (lookupAny pxs i)
 
 lookup : All P xs → (∀ {x} → x ∈ₚ xs → P x)
 lookup pxs = lookupWith (λ { px refl → px }) pxs
 
 module _(S : Setoid a ℓ) {P : Pred (Setoid.Carrier S) p} where
-  open Setoid S renaming (sym to sym₁)
+  open Setoid S renaming (sym to ≈-sym)
   open SetoidMembership S
 
   lookupₛ : P Respects _≈_ → All P xs → (∀ {x} → x ∈ xs → P x)
-  lookupₛ resp pxs = lookupWith (λ py x=y → resp (sym₁ x=y) py) pxs
+  lookupₛ resp pxs = lookupWith (λ py x≈y → resp (≈-sym x≈y) py) pxs
 
 ------------------------------------------------------------------------
 -- Properties of predicates preserved by All
@@ -209,10 +212,13 @@ universal : Universal P → Universal (All P)
 universal u []       = []
 universal u (x ∷ xs) = u x ∷ universal u xs
 
+universal-U : Universal (All {A = A} U)
+universal-U = universal Unary.U-Universal
+
 irrelevant : Irrelevant P → Irrelevant (All P)
-irrelevant irr []           []           = P.refl
+irrelevant irr []           []           = ≡.refl
 irrelevant irr (px₁ ∷ pxs₁) (px₂ ∷ pxs₂) =
-  P.cong₂ _∷_ (irr px₁ px₂) (irrelevant irr pxs₁ pxs₂)
+  ≡.cong₂ _∷_ (irr px₁ px₂) (irrelevant irr pxs₁ pxs₂)
 
 satisfiable : Satisfiable (All P)
 satisfiable = [] , []
diff --git a/src/Data/List/Relation/Unary/All/Properties.agda b/src/Data/List/Relation/Unary/All/Properties.agda
index 004424df80..9e3c4968c8 100644
--- a/src/Data/List/Relation/Unary/All/Properties.agda
+++ b/src/Data/List/Relation/Unary/All/Properties.agda
@@ -11,40 +11,40 @@ module Data.List.Relation.Unary.All.Properties where
 open import Axiom.Extensionality.Propositional using (Extensionality)
 open import Data.Bool.Base using (Bool; T; true; false)
 open import Data.Bool.Properties using (T-∧)
-open import Data.Empty
 open import Data.Fin.Base using (Fin; zero; suc)
-open import Data.List.Base as List hiding (lookup)
-open import Data.List.Properties as Listₚ using (partition-defn)
-open import Data.List.Membership.Propositional
+open import Data.List.Base as List hiding (lookup; updateAt)
+open import Data.List.Membership.Propositional using (_∈_; _≢∈_)
 open import Data.List.Membership.Propositional.Properties
+  using (there-injective-≢∈; ∈-filter⁻)
 import Data.List.Membership.Setoid as SetoidMembership
+import Data.List.Properties as List
+import Data.List.Relation.Binary.Equality.Setoid as ≋
+open import Data.List.Relation.Binary.Pointwise.Base using (Pointwise; []; _∷_)
+open import Data.List.Relation.Binary.Subset.Propositional using (_⊆_)
 open import Data.List.Relation.Unary.All as All using
   ( All; []; _∷_; lookup; updateAt
   ; _[_]=_; here; there
   ; Null
   )
 open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
-import Data.List.Relation.Binary.Equality.Setoid as ListEq using (_≋_; []; _∷_)
-open import Data.List.Relation.Binary.Pointwise using (Pointwise; []; _∷_)
-open import Data.List.Relation.Binary.Subset.Propositional using (_⊆_)
 open import Data.Maybe.Base as Maybe using (Maybe; just; nothing)
-open import Data.Maybe.Relation.Unary.All as Maybe using (just; nothing)
+open import Data.Maybe.Relation.Unary.All as Maybe using (just; nothing; fromAny)
+open import Data.Maybe.Relation.Unary.Any as Maybe using (just)
 open import Data.Nat.Base using (zero; suc; s≤s; _<_; z<s; s<s)
 open import Data.Nat.Properties using (≤-refl; m≤n⇒m≤1+n)
-open import Data.Product as Prod using (_×_; _,_; uncurry; uncurry′)
-open import Function.Base
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Equivalence using (_⇔_; equivalence; Equivalence)
-open import Function.Inverse using (_↔_; inverse)
-open import Function.Surjection using (_↠_; surjection)
+open import Data.Product.Base as Product using (_×_; _,_; uncurry; uncurry′)
+open import Function.Base using (_∘_; _$_; id; case_of_; flip)
+open import Function.Bundles using (_↠_; mk↠ₛ; _⇔_; mk⇔; _↔_; mk↔ₛ′; Equivalence)
 open import Level using (Level)
-open import Relation.Binary as B using (REL; Setoid; _Respects_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.Bundles using (Setoid)
+import Relation.Binary.Definitions as B
+open import Relation.Binary.PropositionalEquality.Core
   using (_≡_; refl; cong; cong₂; _≗_)
-open import Relation.Nullary
 open import Relation.Nullary.Reflects using (invert)
-open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Nullary.Decidable using (¬?; decidable-stable)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
+open import Relation.Nullary.Decidable
+  using (Dec; does; yes; no; _because_; ¬?; decidable-stable)
 open import Relation.Unary
   using (Decidable; Pred; Universal; ∁; _∩_; _⟨×⟩_) renaming (_⊆_ to _⋐_)
 open import Relation.Unary.Properties using (∁?)
@@ -97,7 +97,7 @@ All¬⇒¬Any (¬p ∷ _)  (here  p) = ¬p p
 All¬⇒¬Any (_  ∷ ¬p) (there p) = All¬⇒¬Any ¬p p
 
 ¬All⇒Any¬ : Decidable P → ∀ xs → ¬ All P xs → Any (¬_ ∘ P) xs
-¬All⇒Any¬ dec []       ¬∀ = ⊥-elim (¬∀ [])
+¬All⇒Any¬ dec []       ¬∀ = contradiction [] ¬∀
 ¬All⇒Any¬ dec (x ∷ xs) ¬∀ with dec x
 ... |  true because  [p] = there (¬All⇒Any¬ dec xs (¬∀ ∘ _∷_ (invert [p])))
 ... | false because [¬p] = here (invert [¬p])
@@ -107,7 +107,7 @@ Any¬⇒¬All (here  ¬p) = ¬p           ∘ All.head
 Any¬⇒¬All (there ¬p) = Any¬⇒¬All ¬p ∘ All.tail
 
 ¬Any↠All¬ : ∀ {xs} → (¬ Any P xs) ↠ All (¬_ ∘ P) xs
-¬Any↠All¬ = surjection (¬Any⇒All¬ _) All¬⇒¬Any to∘from
+¬Any↠All¬ = mk↠ₛ {to = ¬Any⇒All¬ _} (λ y → All¬⇒¬Any y , to∘from y)
   where
   to∘from : ∀ {xs} (¬p : All (¬_ ∘ P) xs) → ¬Any⇒All¬ xs (All¬⇒¬Any ¬p) ≡ ¬p
   to∘from []         = refl
@@ -125,14 +125,14 @@ Any¬⇒¬All (there ¬p) = Any¬⇒¬All ¬p ∘ All.tail
     }
 
 Any¬⇔¬All : ∀ {xs} → Decidable P → Any (¬_ ∘ P) xs ⇔ (¬ All P xs)
-Any¬⇔¬All dec = equivalence Any¬⇒¬All (¬All⇒Any¬ dec _)
+Any¬⇔¬All dec = mk⇔ Any¬⇒¬All (¬All⇒Any¬ dec _)
 
 private
   -- If equality of functions were extensional, then the logical
   -- equivalence could be strengthened to a surjection.
   to∘from : Extensionality _ _ → (dec : Decidable P) →
             (¬∀ : ¬ All P xs) → Any¬⇒¬All (¬All⇒Any¬ dec xs ¬∀) ≡ ¬∀
-  to∘from ext P ¬∀ = ext (⊥-elim ∘ ¬∀)
+  to∘from ext P ¬∀ = ext λ ∀P → contradiction ∀P ¬∀
 
 module _ {_~_ : REL A B ℓ} where
 
@@ -176,19 +176,19 @@ lookup⇒[]= pxs i refl = []=lookup pxs i
 ------------------------------------------------------------------------
 -- map
 
-map-id : ∀ (pxs : All P xs) → All.map id pxs ≡ pxs
-map-id []         = refl
-map-id (px ∷ pxs) = cong (px ∷_)  (map-id pxs)
-
 map-cong : ∀ {f : P ⋐ Q} {g : P ⋐ Q} (pxs : All P xs) →
            (∀ {x} → f {x} ≗ g) → All.map f pxs ≡ All.map g pxs
 map-cong []         _   = refl
 map-cong (px ∷ pxs) feq = cong₂ _∷_ (feq px) (map-cong pxs feq)
 
-map-compose : ∀ {f : P ⋐ Q} {g : Q ⋐ R} (pxs : All P xs) →
-              All.map g (All.map f pxs) ≡ All.map (g ∘ f) pxs
-map-compose []         = refl
-map-compose (px ∷ pxs) = cong (_ ∷_) (map-compose pxs)
+map-id : ∀ (pxs : All P xs) → All.map id pxs ≡ pxs
+map-id []         = refl
+map-id (px ∷ pxs) = cong (px ∷_)  (map-id pxs)
+
+map-∘ : ∀ {f : P ⋐ Q} {g : Q ⋐ R} (pxs : All P xs) →
+        All.map g (All.map f pxs) ≡ All.map (g ∘ f) pxs
+map-∘ []         = refl
+map-∘ (px ∷ pxs) = cong (_ ∷_) (map-∘ pxs)
 
 lookup-map : ∀ {f : P ⋐ Q} (pxs : All P xs) (i : x ∈ xs) →
              lookup (All.map f pxs) i ≡ f (lookup pxs i)
@@ -217,7 +217,7 @@ updateAt-minimal : ∀ (i : x ∈ xs) (j : y ∈ xs) →
                    pxs              [ i ]= px →
                    updateAt j f pxs [ i ]= px
 updateAt-minimal (here .refl) (here refl) (px ∷ pxs) i≢j here        =
-  ⊥-elim (i≢j refl refl)
+  contradiction refl (i≢j refl)
 updateAt-minimal (here .refl) (there j)   (px ∷ pxs) i≢j here        = here
 updateAt-minimal (there i)    (here refl) (px ∷ pxs) i≢j (there val) = there val
 updateAt-minimal (there i)    (there j)   (px ∷ pxs) i≢j (there val) =
@@ -310,7 +310,7 @@ updateAt-commutes : ∀ (i : x ∈ xs) (j : y ∈ xs) →
                     i ≢∈ j →
                     updateAt {P = P} i f ∘ updateAt j g ≗ updateAt j g ∘ updateAt i f
 updateAt-commutes (here refl) (here refl) i≢j (px ∷ pxs) =
-  ⊥-elim (i≢j refl refl)
+  contradiction refl (i≢j refl)
 updateAt-commutes (here refl) (there j)   i≢j (px ∷ pxs) = refl
 updateAt-commutes (there i)   (here refl) i≢j (px ∷ pxs) = refl
 updateAt-commutes (there i)   (there j)   i≢j (px ∷ pxs) =
@@ -372,8 +372,11 @@ map⁻ {xs = _ ∷ _} (p ∷ ps) = p ∷ map⁻ ps
 
 -- A variant of All.map.
 
-gmap : ∀ {f : A → B} → P ⋐ Q ∘ f → All P ⋐ All Q ∘ map f
-gmap g = map⁺ ∘ All.map g
+gmap⁺ : ∀ {f : A → B} → P ⋐ Q ∘ f → All P ⋐ All Q ∘ map f
+gmap⁺ g = map⁺ ∘ All.map g
+
+gmap⁻ : ∀ {f : A → B} → Q ∘ f ⋐ P → All Q ∘ map f ⋐ All P
+gmap⁻ g = All.map g ∘ map⁻
 
 ------------------------------------------------------------------------
 -- mapMaybe
@@ -383,8 +386,18 @@ mapMaybe⁺ : ∀ {f : A → Maybe B} →
 mapMaybe⁺ {xs = []}     {f = f} []         = []
 mapMaybe⁺ {xs = x ∷ xs} {f = f} (px ∷ pxs) with f x
 ... | nothing = mapMaybe⁺ pxs
-... | just v with px
-...   | just pv = pv ∷ mapMaybe⁺ pxs
+... | just v with just pv ← px = pv ∷ mapMaybe⁺ pxs
+
+------------------------------------------------------------------------
+-- catMaybes
+
+All-catMaybes⁺ : All (Maybe.All P) xs → All P (catMaybes xs)
+All-catMaybes⁺ [] = []
+All-catMaybes⁺ (just px ∷ pxs) = px ∷ All-catMaybes⁺ pxs
+All-catMaybes⁺ (nothing ∷ pxs) = All-catMaybes⁺ pxs
+
+Any-catMaybes⁺ : All (Maybe.Any P) xs → All P (catMaybes xs)
+Any-catMaybes⁺ = All-catMaybes⁺ ∘ All.map fromAny
 
 ------------------------------------------------------------------------
 -- _++_
@@ -403,10 +416,10 @@ mapMaybe⁺ {xs = x ∷ xs} {f = f} (px ∷ pxs) with f x
 
 ++⁻ : ∀ xs {ys} → All P (xs ++ ys) → All P xs × All P ys
 ++⁻ []       p          = [] , p
-++⁻ (x ∷ xs) (px ∷ pxs) = Prod.map (px ∷_) id (++⁻ _ pxs)
+++⁻ (x ∷ xs) (px ∷ pxs) = Product.map (px ∷_) id (++⁻ _ pxs)
 
 ++↔ : (All P xs × All P ys) ↔ All P (xs ++ ys)
-++↔ {xs = zs} = inverse (uncurry ++⁺) (++⁻ zs) ++⁻∘++⁺ (++⁺∘++⁻ zs)
+++↔ {xs = zs} = mk↔ₛ′ (uncurry ++⁺) (++⁻ zs) (++⁺∘++⁻ zs) ++⁻∘++⁺
   where
   ++⁺∘++⁻ : ∀ xs (p : All P (xs ++ ys)) → uncurry′ ++⁺ (++⁻ xs p) ≡ p
   ++⁺∘++⁻ []       p          = refl
@@ -434,7 +447,7 @@ concat⁻ {xss = xs ∷ xss} pxs = ++⁻ˡ xs pxs ∷ concat⁻ (++⁻ʳ xs pxs)
 ∷ʳ⁺ pxs px = ++⁺ pxs (px ∷ [])
 
 ∷ʳ⁻ : All P (xs ∷ʳ x) → All P xs × P x
-∷ʳ⁻ pxs = Prod.map₂ singleton⁻ $ ++⁻ _ pxs
+∷ʳ⁻ pxs = Product.map₂ singleton⁻ $ ++⁻ _ pxs
 
 -- unsnoc
 
@@ -509,7 +522,7 @@ takeWhile⁺ {xs = x ∷ xs} Q? (px ∷ pxs) with does (Q? x)
 takeWhile⁻ : (P? : Decidable P) → takeWhile P? xs ≡ xs → All P xs
 takeWhile⁻ {xs = []}     P? eq = []
 takeWhile⁻ {xs = x ∷ xs} P? eq with P? x
-... | yes px = px ∷ takeWhile⁻ P? (Listₚ.∷-injectiveʳ eq)
+... | yes px = px ∷ takeWhile⁻ P? (List.∷-injectiveʳ eq)
 ... | no ¬px = case eq of λ ()
 
 all-takeWhile : (P? : Decidable P) → ∀ xs → All P (takeWhile P? xs)
@@ -581,7 +594,7 @@ module _ (P? : Decidable P) where
   all-filter : ∀ xs → All P (filter P? xs)
   all-filter []       = []
   all-filter (x ∷ xs) with P? x
-  ... |  true because [Px] = invert [Px] ∷ all-filter xs
+  ... | true  because [Px] = invert [Px] ∷ all-filter xs
   ... | false because  _   = all-filter xs
 
   filter⁺ : All Q xs → All Q (filter P? xs)
@@ -591,12 +604,12 @@ module _ (P? : Decidable P) where
   ... | true  = Qx ∷ filter⁺ Qxs
 
   filter⁻ : All Q (filter P? xs) → All Q (filter (¬? ∘ P?) xs) → All Q xs
-  filter⁻ {xs = []}           []          []                           = []
-  filter⁻ {xs = x ∷ xs}       all⁺        all⁻ with P? x  | ¬? (P? x)
-  filter⁻ {xs = x ∷ xs}       all⁺        all⁻  | yes  Px | yes  ¬Px = contradiction Px ¬Px
-  filter⁻ {xs = x ∷ xs} (qx ∷ all⁺)       all⁻  | yes  Px | no  ¬¬Px = qx ∷ filter⁻ all⁺ all⁻
-  filter⁻ {xs = x ∷ xs}       all⁺  (qx ∷ all⁻) | no    _ | yes  ¬Px = qx ∷ filter⁻ all⁺ all⁻
-  filter⁻ {xs = x ∷ xs}       all⁺        all⁻  | no  ¬Px | no  ¬¬Px = contradiction ¬Px ¬¬Px
+  filter⁻ {xs = []}          []          []                         = []
+  filter⁻ {xs = x ∷ _}       all⁺        all⁻ with P? x  | ¬? (P? x)
+  filter⁻ {xs = x ∷ _}       all⁺        all⁻  | yes  Px | yes  ¬Px = contradiction Px ¬Px
+  filter⁻ {xs = x ∷ _} (qx ∷ all⁺)       all⁻  | yes  Px | no  ¬¬Px = qx ∷ filter⁻ all⁺ all⁻
+  filter⁻ {xs = x ∷ _}       all⁺  (qx ∷ all⁻) | no    _ | yes  ¬Px = qx ∷ filter⁻ all⁺ all⁻
+  filter⁻ {xs = x ∷ _}       all⁺        all⁻  | no  ¬Px | no  ¬¬Px = contradiction ¬Px ¬¬Px
 
 ------------------------------------------------------------------------
 -- partition
@@ -605,7 +618,7 @@ module _ {P : A → Set p} (P? : Decidable P) where
 
   partition-All : ∀ xs → (let ys , zs = partition P? xs) →
                   All P ys × All (∁ P) zs
-  partition-All xs rewrite partition-defn P? xs =
+  partition-All xs rewrite List.partition-defn P? xs =
     all-filter P? xs , all-filter (∁? P?) xs
 
 ------------------------------------------------------------------------
@@ -621,7 +634,7 @@ module _ {R : A → A → Set q} (R? : B.Decidable R) where
   ... | true  = derun⁺ all[P,y∷xs]
 
   deduplicate⁺ : All P xs → All P (deduplicate R? xs)
-  deduplicate⁺ []               = []
+  deduplicate⁺ []         = []
   deduplicate⁺ (px ∷ pxs) = px ∷ filter⁺ (¬? ∘ R? _) (deduplicate⁺ pxs)
 
   derun⁻ : P B.Respects (flip R) → ∀ xs → All P (derun R? xs) → All P xs
@@ -631,8 +644,8 @@ module _ {R : A → A → Set q} (R? : B.Decidable R) where
     aux : ∀ x xs → All P (derun R? (x ∷ xs)) → All P (x ∷ xs)
     aux x []       (px ∷ []) = px ∷ []
     aux x (y ∷ xs) all[P,x∷y∷xs] with R? x y
-    aux x (y ∷ xs) all[P,y∷xs]        | yes Rxy with aux y xs all[P,y∷xs]
-    aux x (y ∷ xs) all[P,y∷xs]        | yes Rxy | r@(py ∷ _) = P-resp-R Rxy py ∷ r
+    aux x (y ∷ xs) all[P,y∷xs]        | yes Rxy
+      with r@(py ∷ _) ← aux y xs all[P,y∷xs] = P-resp-R Rxy py ∷ r
     aux x (y ∷ xs) (px ∷ all[P,y∷xs]) | no _ = px ∷ aux y xs all[P,y∷xs]
 
   deduplicate⁻ : P B.Respects R → ∀ xs → All P (deduplicate R? xs) → All P xs
@@ -642,7 +655,7 @@ module _ {R : A → A → Set q} (R? : B.Decidable R) where
     where
     aux : ∀ {z} → z ∈ filter (¬? ∘ ¬? ∘ R? x) (deduplicate R? xs) → P z
     aux {z = z} z∈filter = resp (decidable-stable (R? x z)
-      (Prod.proj₂ (∈-filter⁻ (¬? ∘ ¬? ∘ R? x) {z} {deduplicate R? xs} z∈filter))) px
+      (Product.proj₂ (∈-filter⁻ (¬? ∘ ¬? ∘ R? x) {z} {deduplicate R? xs} z∈filter))) px
 
 ------------------------------------------------------------------------
 -- zipWith
@@ -680,7 +693,7 @@ replicate⁻ (px ∷ _) = px
 
 inits⁺ : All P xs → All (All P) (inits xs)
 inits⁺ []         = [] ∷ []
-inits⁺ (px ∷ pxs) = [] ∷ gmap (px ∷_) (inits⁺ pxs)
+inits⁺ (px ∷ pxs) = [] ∷ gmap⁺ (px ∷_) (inits⁺ pxs)
 
 inits⁻ : ∀ xs → All (All P) (inits xs) → All P xs
 inits⁻ []               pxs                   = []
@@ -705,13 +718,14 @@ tails⁻ (x ∷ xs) (pxxs ∷ _) = pxxs
 module _ (p : A → Bool) where
 
   all⁺ : ∀ xs → T (all p xs) → All (T ∘ p) xs
-  all⁺ []       _     = []
-  all⁺ (x ∷ xs) px∷xs with Equivalence.to (T-∧ {p x}) ⟨$⟩ px∷xs
-  ... | (px , pxs) = px ∷ all⁺ xs pxs
+  all⁺ []       _      = []
+  all⁺ (x ∷ xs) px∷pxs =
+    let px , pxs = Equivalence.to (T-∧ {p x}) px∷pxs
+    in px ∷ all⁺ xs pxs
 
   all⁻ : All (T ∘ p) xs → T (all p xs)
   all⁻ []         = _
-  all⁻ (px ∷ pxs) = Equivalence.from T-∧ ⟨$⟩ (px , all⁻ pxs)
+  all⁻ (px ∷ pxs) = Equivalence.from T-∧ (px , all⁻ pxs)
 
 ------------------------------------------------------------------------
 -- All is anti-monotone.
@@ -729,9 +743,9 @@ all-anti-mono p xs⊆ys = all⁻ p ∘ anti-mono xs⊆ys ∘ all⁺ p _
 module _ (S : Setoid c ℓ) where
 
   open Setoid S
-  open ListEq S
+  open ≋ S
 
-  respects : P Respects _≈_ → (All P) Respects _≋_
+  respects : P B.Respects _≈_ → (All P) B.Respects _≋_
   respects p≈ []            []         = []
   respects p≈ (x≈y ∷ xs≈ys) (px ∷ pxs) = p≈ x≈y px ∷ respects p≈ xs≈ys pxs
 
@@ -774,3 +788,17 @@ updateAt-cong-relative = updateAt-cong-local
 "Warning: updateAt-cong-relative was deprecated in v2.0.
 Please use updateAt-cong-local instead."
 #-}
+
+gmap = gmap⁺
+{-# WARNING_ON_USAGE gmap
+"Warning: gmap was deprecated in v2.0.
+Please use gmap⁺ instead."
+#-}
+
+-- Version 2.1
+
+map-compose = map-∘
+{-# WARNING_ON_USAGE map-compose
+"Warning: map-compose was deprecated in v2.1.
+Please use map-∘ instead."
+#-}
diff --git a/src/Data/List/Relation/Unary/AllPairs.agda b/src/Data/List/Relation/Unary/AllPairs.agda
index f2cbf29755..6036586822 100644
--- a/src/Data/List/Relation/Unary/AllPairs.agda
+++ b/src/Data/List/Relation/Unary/AllPairs.agda
@@ -6,19 +6,19 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel)
+open import Relation.Binary.Core using (Rel; _⇒_)
 
 module Data.List.Relation.Unary.AllPairs
        {a ℓ} {A : Set a} {R : Rel A ℓ} where
 
 open import Data.List.Base using (List; []; _∷_)
 open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
-open import Data.Product as Prod using (_,_; _×_; uncurry; <_,_>)
+open import Data.Product.Base as Prod using (_,_; _×_; uncurry; <_,_>)
 open import Function.Base using (id; _∘_)
 open import Level using (_⊔_)
-open import Relation.Binary as B using (Rel; _⇒_)
+open import Relation.Binary.Definitions as B
 open import Relation.Binary.Construct.Intersection renaming (_∩_ to _∩ᵇ_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core using (refl; cong₂)
 open import Relation.Unary as U renaming (_∩_ to _∩ᵘ_) hiding (_⇒_)
 open import Relation.Nullary.Decidable as Dec using (_×-dec_; yes; no)
 
diff --git a/src/Data/List/Relation/Unary/AllPairs/Core.agda b/src/Data/List/Relation/Unary/AllPairs/Core.agda
index 04728171b0..899d2d76fd 100644
--- a/src/Data/List/Relation/Unary/AllPairs/Core.agda
+++ b/src/Data/List/Relation/Unary/AllPairs/Core.agda
@@ -12,7 +12,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel)
+open import Relation.Binary.Core using (Rel)
 
 module Data.List.Relation.Unary.AllPairs.Core
   {a ℓ} {A : Set a} (R : Rel A ℓ) where
diff --git a/src/Data/List/Relation/Unary/AllPairs/Properties.agda b/src/Data/List/Relation/Unary/AllPairs/Properties.agda
index 391fee8f8b..173dd87b62 100644
--- a/src/Data/List/Relation/Unary/AllPairs/Properties.agda
+++ b/src/Data/List/Relation/Unary/AllPairs/Properties.agda
@@ -8,21 +8,25 @@
 
 module Data.List.Relation.Unary.AllPairs.Properties where
 
-open import Data.List hiding (any)
+open import Data.List.Base using (List; []; _∷_; map; _++_; concat; take; drop;
+  applyUpTo; applyDownFrom; tabulate; filter; catMaybes)
 open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
-import Data.List.Relation.Unary.All.Properties as All
+open import Data.List.Relation.Unary.All.Properties as All using (Any-catMaybes⁺)
 open import Data.List.Relation.Unary.AllPairs as AllPairs using (AllPairs; []; _∷_)
 open import Data.Bool.Base using (true; false)
-open import Data.Fin.Base using (Fin)
-open import Data.Fin.Properties using (suc-injective)
-open import Data.Nat.Base using (zero; suc; _<_; z≤n; s≤s)
+open import Data.Maybe.Base using (Maybe; nothing; just)
+open import Data.Maybe.Relation.Binary.Pointwise using (pointwise⊆any; Pointwise)
+open import Data.Fin.Base as F using (Fin)
+open import Data.Fin.Properties using (suc-injective; <⇒≢)
+open import Data.Nat.Base using (zero; suc; _<_; z≤n; s≤s; z<s; s<s)
 open import Data.Nat.Properties using (≤-refl; m<n⇒m<1+n)
 open import Function.Base using (_∘_; flip)
 open import Level using (Level)
-open import Relation.Binary using (Rel; DecSetoid)
-open import Relation.Binary.PropositionalEquality using (_≢_)
-open import Relation.Unary using (Pred; Decidable)
-open import Relation.Nullary.Decidable using (does)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (DecSetoid)
+open import Relation.Binary.PropositionalEquality.Core using (_≢_)
+open import Relation.Unary using (Pred; Decidable; _⊆_)
+open import Relation.Nullary.Decidable.Core using (does)
 
 private
   variable
@@ -114,12 +118,16 @@ module _ {R : Rel A ℓ} where
 
 module _ {R : Rel A ℓ} where
 
+  tabulate⁺-< : ∀ {n} {f : Fin n → A} → (∀ {i j} → i F.< j → R (f i) (f j)) →
+              AllPairs R (tabulate f)
+  tabulate⁺-< {zero}  fᵢ~fⱼ = []
+  tabulate⁺-< {suc n} fᵢ~fⱼ =
+    All.tabulate⁺ (λ _ → fᵢ~fⱼ z<s) ∷
+    tabulate⁺-< (fᵢ~fⱼ ∘ s<s)
+
   tabulate⁺ : ∀ {n} {f : Fin n → A} → (∀ {i j} → i ≢ j → R (f i) (f j)) →
               AllPairs R (tabulate f)
-  tabulate⁺ {zero}  fᵢ~fⱼ = []
-  tabulate⁺ {suc n} fᵢ~fⱼ =
-    All.tabulate⁺ (λ j → fᵢ~fⱼ λ()) ∷
-    tabulate⁺ (fᵢ~fⱼ ∘ (_∘ suc-injective))
+  tabulate⁺ fᵢ~fⱼ = tabulate⁺-< (fᵢ~fⱼ ∘ <⇒≢)
 
 ------------------------------------------------------------------------
 -- filter
@@ -131,3 +139,13 @@ module _ {R : Rel A ℓ} {P : Pred A p} (P? : Decidable P) where
   filter⁺ {x ∷ xs} (x∉xs ∷ xs!) with does (P? x)
   ... | false = filter⁺ xs!
   ... | true  = All.filter⁺ P? x∉xs ∷ filter⁺ xs!
+
+------------------------------------------------------------------------
+-- catMaybes
+
+module _ {R : Rel A ℓ} where
+
+  catMaybes⁺ : {xs : List (Maybe A)} → AllPairs (Pointwise R) xs → AllPairs R (catMaybes xs)
+  catMaybes⁺ {xs = []} [] = []
+  catMaybes⁺ {xs = nothing ∷  _} (x∼xs ∷ pxs) = catMaybes⁺ pxs
+  catMaybes⁺ {xs = just x  ∷ xs} (x∼xs ∷ pxs) = Any-catMaybes⁺ (All.map pointwise⊆any x∼xs) ∷ catMaybes⁺ pxs
diff --git a/src/Data/List/Relation/Unary/Any.agda b/src/Data/List/Relation/Unary/Any.agda
index 58bdc3a5fa..361cbb4160 100644
--- a/src/Data/List/Relation/Unary/Any.agda
+++ b/src/Data/List/Relation/Unary/Any.agda
@@ -8,16 +8,14 @@
 
 module Data.List.Relation.Unary.Any where
 
-open import Data.Empty
 open import Data.Fin.Base using (Fin; zero; suc)
-open import Data.List.Base as List using (List; []; [_]; _∷_)
-open import Data.Product as Prod using (∃; _,_)
+open import Data.List.Base as List using (List; []; [_]; _∷_; removeAt)
+open import Data.Product.Base as Product using (∃; _,_)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
 open import Level using (Level; _⊔_)
-open import Relation.Nullary using (¬_; yes; no; _⊎-dec_)
-import Relation.Nullary.Decidable as Dec
-open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Unary hiding (_∈_)
+open import Relation.Nullary.Decidable.Core as Dec using (no; _⊎-dec_)
+open import Relation.Nullary.Negation using (¬_; contradiction)
+open import Relation.Unary using (Pred; _⊆_; Decidable; Satisfiable)
 
 private
   variable
@@ -46,7 +44,7 @@ head ¬pxs (here px)   = px
 head ¬pxs (there pxs) = contradiction pxs ¬pxs
 
 tail : ¬ P x → Any P (x ∷ xs) → Any P xs
-tail ¬px (here  px)  = ⊥-elim (¬px px)
+tail ¬px (here  px)  = contradiction px ¬px
 tail ¬px (there pxs) = pxs
 
 map : P ⊆ Q → Any P ⊆ Any Q
@@ -62,12 +60,14 @@ index (there pxs) = suc (index pxs)
 lookup : {P : Pred A p} → Any P xs → A
 lookup {xs = xs} p = List.lookup xs (index p)
 
+infixr 5 _∷=_
+
 _∷=_ : {P : Pred A p} → Any P xs → A → List A
 _∷=_ {xs = xs} x∈xs v = xs List.[ index x∈xs ]∷= v
 
 infixl 4 _─_
 _─_ : {P : Pred A p} → ∀ xs → Any P xs → List A
-xs ─ x∈xs = xs List.─ index x∈xs
+xs ─ x∈xs = removeAt xs (index x∈xs)
 
 -- If any element satisfies P, then P is satisfied.
 
diff --git a/src/Data/List/Relation/Unary/Any/Properties.agda b/src/Data/List/Relation/Unary/Any/Properties.agda
index abfc8f93f8..836e73d4a4 100644
--- a/src/Data/List/Relation/Unary/Any/Properties.agda
+++ b/src/Data/List/Relation/Unary/Any/Properties.agda
@@ -12,42 +12,43 @@ open import Data.Bool.Base using (Bool; false; true; T)
 open import Data.Bool.Properties using (T-∨; T-≡)
 open import Data.Empty using (⊥)
 open import Data.Fin.Base using (Fin; zero; suc)
-open import Data.List.Base as List
-open import Data.List.Properties using (ʳ++-defn)
-open import Data.List.Effectful as Listₑ using (monad)
+open import Data.List.Base as List hiding (find)
+open import Data.List.Effectful as List using (monad)
 open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
 open import Data.List.Membership.Propositional
 open import Data.List.Membership.Propositional.Properties.Core
   using (Any↔; find∘map; map∘find; lose∘find)
 open import Data.List.Relation.Binary.Pointwise
   using (Pointwise; []; _∷_)
-open import Data.Nat using (zero; suc; _<_; z<s; s<s; s≤s)
+open import Data.Nat.Base using (zero; suc; _<_; z<s; s<s; s≤s)
 open import Data.Nat.Properties using (_≟_; ≤∧≢⇒<; ≤-refl; m<n⇒m<1+n)
 open import Data.Maybe.Base using (Maybe; just; nothing)
 open import Data.Maybe.Relation.Unary.Any as MAny using (just)
-open import Data.Product as Prod
-  using (_×_; _,_; ∃; ∃₂; proj₁; proj₂; uncurry′)
-open import Data.Product.Properties
+open import Data.Product.Base as Product
+  using (_×_; _,_; ∃; ∃₂; proj₁; proj₂)
 open import Data.Product.Function.NonDependent.Propositional
   using (_×-cong_)
 import Data.Product.Function.Dependent.Propositional as Σ
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_]′)
 open import Data.Sum.Function.Propositional using (_⊎-cong_)
-open import Effect.Monad
-open import Function.Base
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Equivalence using (_⇔_; equivalence; Equivalence)
-open import Function.Inverse as Inv using (_↔_; inverse; Inverse)
-open import Function.Related as Related using (Kind; Related; SK-sym)
+open import Effect.Monad using (RawMonad)
+open import Function.Base using (_$_; _∘_; flip; const; id; _∘′_)
+open import Function.Bundles
+import Function.Properties.Inverse as Inverse
+open import Function.Related.Propositional as Related using (Kind; Related)
 open import Level using (Level)
-open import Relation.Binary as B hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; refl; inspect)
+open import Relation.Binary.Core using (Rel; REL)
+open import Relation.Binary.Definitions as B
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; sym; trans; cong; cong₂; resp)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Relation.Unary as U
   using (Pred; _⟨×⟩_; _⟨→⟩_) renaming (_⊆_ to _⋐_)
-open import Relation.Nullary using (¬_; _because_; does; ofʸ; ofⁿ; yes; no)
-open import Relation.Nullary.Decidable using (¬?; decidable-stable)
-open import Relation.Nullary.Negation using (contradiction)
+open import Relation.Nullary.Decidable.Core
+  using (¬?; _because_; does; yes; no; decidable-stable)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
+open import Relation.Nullary.Reflects using (invert)
 
 private
   open module ListMonad {ℓ} = RawMonad (monad {ℓ = ℓ})
@@ -55,9 +56,7 @@ private
 private
   variable
     a b c p q r ℓ : Level
-    A : Set a
-    B : Set b
-    C : Set c
+    A B C : Set a
     P Q R : Pred A p
     x y : A
     xs ys : List A
@@ -89,8 +88,8 @@ Any-cong : ∀ {k : Kind} → (∀ x → Related k (P x) (Q x)) →
            (∀ {z} → Related k (z ∈ xs) (z ∈ ys)) →
            Related k (Any P xs) (Any Q ys)
 Any-cong {P = P} {Q = Q} {xs = xs} {ys} P↔Q xs≈ys =
-  Any P xs                ↔⟨ SK-sym Any↔ ⟩
-  (∃ λ x → x ∈ xs × P x)  ∼⟨ Σ.cong Inv.id (xs≈ys ×-cong P↔Q _) ⟩
+  Any P xs                ↔⟨ Related.SK-sym Any↔ ⟩
+  (∃ λ x → x ∈ xs × P x)  ∼⟨ Σ.cong Inverse.↔-refl (xs≈ys ×-cong P↔Q _) ⟩
   (∃ λ x → x ∈ ys × Q x)  ↔⟨ Any↔ ⟩
   Any Q ys                ∎
   where open Related.EquationalReasoning
@@ -98,15 +97,20 @@ Any-cong {P = P} {Q = Q} {xs = xs} {ys} P↔Q xs≈ys =
 ------------------------------------------------------------------------
 -- Any.map
 
+map-cong : (f g : P ⋐ Q) → (∀ {x} (p : P x) → f p ≡ g p) →
+          (p : Any P xs) → Any.map f p ≡ Any.map g p
+map-cong f g hyp (here  p) = cong here (hyp p)
+map-cong f g hyp (there p) = cong there $ map-cong f g hyp p
+
 map-id : ∀ (f : P ⋐ P) → (∀ {x} (p : P x) → f p ≡ p) →
          (p : Any P xs) → Any.map f p ≡ p
-map-id f hyp (here  p) = P.cong here (hyp p)
-map-id f hyp (there p) = P.cong there $ map-id f hyp p
+map-id f hyp (here  p) = cong here (hyp p)
+map-id f hyp (there p) = cong there $ map-id f hyp p
 
 map-∘ : ∀ (f : Q ⋐ R) (g : P ⋐ Q) (p : Any P xs) →
         Any.map (f ∘ g) p ≡ Any.map f (Any.map g p)
 map-∘ f g (here  p) = refl
-map-∘ f g (there p) = P.cong there $ map-∘ f g p
+map-∘ f g (there p) = cong there $ map-∘ f g p
 
 ------------------------------------------------------------------------
 -- Any.lookup
@@ -124,41 +128,43 @@ lookup-index (there pxs) = lookup-index pxs
 
 -- Nested occurrences of Any can sometimes be swapped. See also ×↔.
 
-swap : ∀ {P : A → B → Set ℓ} →
-       Any (λ x → Any (P x) ys) xs → Any (λ y → Any (flip P y) xs) ys
-swap (here  pys)  = Any.map here pys
-swap (there pxys) = Any.map there (swap pxys)
+module _ {R : REL A B ℓ} where
+
+  swap : Any (λ x → Any (R x) ys) xs → Any (λ y → Any (flip R y) xs) ys
+  swap (here  pys)  = Any.map here pys
+  swap (there pxys) = Any.map there (swap pxys)
+
+  swap-there : (any : Any (λ x → Any (R x) ys) xs) →
+               swap (Any.map (there {x = x}) any) ≡ there (swap any)
+  swap-there (here  pys)  = refl
+  swap-there (there pxys) = cong (Any.map there) (swap-there pxys)
+
+module _ {R : REL A B ℓ} where
 
-swap-there : ∀ {P : A → B → Set ℓ} →
-             (any : Any (λ x → Any (P x) ys) xs) →
-             swap (Any.map (there {x = x}) any) ≡ there (swap any)
-swap-there (here  pys)  = refl
-swap-there (there pxys) = P.cong (Any.map there) (swap-there pxys)
+  swap-invol : (any : Any (λ x → Any (R x) ys) xs) →
+               swap (swap any) ≡ any
+  swap-invol (here (here px))   = refl
+  swap-invol (here (there pys)) =
+    cong (Any.map there) (swap-invol (here pys))
+  swap-invol (there pxys)       =
+    trans (swap-there (swap pxys)) (cong there (swap-invol pxys))
 
-swap-invol : ∀ {P : A → B → Set ℓ} →
-             (any : Any (λ x → Any (P x) ys) xs) →
-             swap (swap any) ≡ any
-swap-invol (here (here px))   = refl
-swap-invol (here (there pys)) =
-  P.cong (Any.map there) (swap-invol (here pys))
-swap-invol (there pxys)       =
-  P.trans (swap-there (swap pxys)) (P.cong there (swap-invol pxys))
+module _ {R : REL A B ℓ} where
 
-swap↔ : ∀ {P : A → B → Set ℓ} →
-       Any (λ x → Any (P x) ys) xs ↔ Any (λ y → Any (flip P y) xs) ys
-swap↔ = inverse swap swap swap-invol swap-invol
+  swap↔ : Any (λ x → Any (R x) ys) xs ↔ Any (λ y → Any (flip R y) xs) ys
+  swap↔ = mk↔ₛ′ swap swap swap-invol swap-invol
 
 ------------------------------------------------------------------------
 -- Lemmas relating Any to ⊥
 
 ⊥↔Any⊥ : ⊥ ↔ Any (const ⊥) xs
-⊥↔Any⊥ = inverse (λ()) (λ p → from p) (λ()) (λ p → from p)
+⊥↔Any⊥ = mk↔ₛ′ (λ()) (λ p → from p) (λ p → from p) (λ())
   where
   from : Any (const ⊥) xs → B
   from (there p) = from p
 
 ⊥↔Any[] : ⊥ ↔ Any P []
-⊥↔Any[] = inverse (λ()) (λ()) (λ()) (λ())
+⊥↔Any[] = mk↔ₛ′ (λ()) (λ()) (λ()) (λ())
 
 ------------------------------------------------------------------------
 -- Lemmas relating Any to ⊤
@@ -166,18 +172,18 @@ swap↔ = inverse swap swap swap-invol swap-invol
 -- These introduction and elimination rules are not inverses, though.
 
 any⁺ : ∀ (p : A → Bool) → Any (T ∘ p) xs → T (any p xs)
-any⁺ p (here  px)          = Equivalence.from T-∨ ⟨$⟩ inj₁ px
+any⁺ p (here  px)          = Equivalence.from T-∨ (inj₁ px)
 any⁺ p (there {x = x} pxs) with p x
 ... | true  = _
 ... | false = any⁺ p pxs
 
 any⁻ : ∀ (p : A → Bool) xs → T (any p xs) → Any (T ∘ p) xs
-any⁻ p (x ∷ xs) px∷xs with p x | inspect p x
-... | true  | P.[ eq ] = here (Equivalence.from T-≡ ⟨$⟩ eq)
-... | false | _        = there (any⁻ p xs px∷xs)
+any⁻ p (x ∷ xs) px∷xs with p x in eq
+... | true  = here (Equivalence.from T-≡ eq)
+... | false = there (any⁻ p xs px∷xs)
 
 any⇔ : ∀ {p : A → Bool} → Any (T ∘ p) xs ⇔ T (any p xs)
-any⇔ = equivalence (any⁺ _) (any⁻ _ _)
+any⇔ = mk⇔ (any⁺ _) (any⁻ _ _)
 
 ------------------------------------------------------------------------
 -- Sums commute with Any
@@ -191,7 +197,7 @@ Any-⊎⁻ (here (inj₂ q)) = inj₂ (here q)
 Any-⊎⁻ (there p)       = Sum.map there there (Any-⊎⁻ p)
 
 ⊎↔ : (Any P xs ⊎ Any Q xs) ↔ Any (λ x → P x ⊎ Q x) xs
-⊎↔ {P = P} {Q = Q} = inverse Any-⊎⁺ Any-⊎⁻ from∘to to∘from
+⊎↔ {P = P} {Q = Q} = mk↔ₛ′ Any-⊎⁺ Any-⊎⁻ to∘from from∘to
   where
   from∘to : (p : Any P xs ⊎ Any Q xs) → Any-⊎⁻ (Any-⊎⁺ p) ≡ p
   from∘to (inj₁ (here  p)) = refl
@@ -203,8 +209,8 @@ Any-⊎⁻ (there p)       = Sum.map there there (Any-⊎⁻ p)
   to∘from (here (inj₁ p)) = refl
   to∘from (here (inj₂ q)) = refl
   to∘from (there p) with Any-⊎⁻ p | to∘from p
-  to∘from (there .(Any.map inj₁ p)) | inj₁ p | refl = refl
-  to∘from (there .(Any.map inj₂ q)) | inj₂ q | refl = refl
+  ... | inj₁ p | refl = refl
+  ... | inj₂ q | refl = refl
 
 ------------------------------------------------------------------------
 -- Products "commute" with Any.
@@ -214,68 +220,75 @@ Any-×⁺ (p , q) = Any.map (λ p → Any.map (λ q → (p , q)) q) p
 
 Any-×⁻ : Any (λ x → Any (λ y → P x × Q y) ys) xs →
          Any P xs × Any Q ys
-Any-×⁻ pq with Prod.map₂ (Prod.map₂ find) (find pq)
-... | (x , x∈xs , y , y∈ys , p , q) = lose x∈xs p , lose y∈ys q
+Any-×⁻ pq = let x , x∈xs , pq′ = find pq in
+            let y , y∈ys , p , q = find pq′ in
+            lose x∈xs p , lose y∈ys q
 
 ×↔ : ∀ {xs ys} →
      (Any P xs × Any Q ys) ↔ Any (λ x → Any (λ y → P x × Q y) ys) xs
-×↔ {P = P} {Q = Q} {xs} {ys} = inverse Any-×⁺ Any-×⁻ from∘to to∘from
+×↔ {P = P} {Q = Q} {xs} {ys} = mk↔ₛ′ Any-×⁺ Any-×⁻ to∘from from∘to
   where
-  open P.≡-Reasoning
+  open ≡-Reasoning
 
   from∘to : ∀ pq → Any-×⁻ (Any-×⁺ pq) ≡ pq
-  from∘to (p , q) =
+  from∘to (p , q) = let x , x∈xs , px = find p in
 
     Any-×⁻ (Any-×⁺ (p , q))
 
-      ≡⟨⟩
+     ≡⟨⟩
 
     (let (x , x∈xs , pq)    = find (Any-×⁺ (p , q))
          (y , y∈ys , p , q) = find pq
      in  lose x∈xs p , lose y∈ys q)
 
-     ≡⟨ P.cong (λ • → let (x , x∈xs , pq)    = •
-                          (y , y∈ys , p , q) = find pq
-                      in  lose x∈xs p , lose y∈ys q)
-               (find∘map p (λ p → Any.map (p ,_) q)) ⟩
+     ≡⟨ cong (λ • → let (x , x∈xs , pq)    = •
+                        (y , y∈ys , p , q) = find pq
+                    in  lose x∈xs p , lose y∈ys q)
+             (find∘map p (λ p → Any.map (p ,_) q)) ⟩
 
     (let (x , x∈xs , p)     = find p
          (y , y∈ys , p , q) = find (Any.map (p ,_) q)
      in  lose x∈xs p , lose y∈ys q)
 
-     ≡⟨ P.cong (λ • → let (x , x∈xs , p)     = find p
-                          (y , y∈ys , p , q) = •
-                      in  lose x∈xs p , lose y∈ys q)
-               (find∘map q (proj₂ (proj₂ (find p)) ,_)) ⟩
+     ≡⟨ cong (λ • → let (x , x∈xs , _)     = find p
+                        (y , y∈ys , p , q) = •
+                    in  lose x∈xs p , lose y∈ys q)
+             (find∘map q (px ,_)) ⟩
 
     (let (x , x∈xs , p) = find p
          (y , y∈ys , q) = find q
      in  lose x∈xs p , lose y∈ys q)
 
-     ≡⟨ P.cong₂ _,_ (lose∘find p) (lose∘find q) ⟩
+     ≡⟨ cong₂ _,_ (lose∘find p) (lose∘find q) ⟩
 
     (p , q) ∎
 
-
-  to∘from : ∀ pq → Any-×⁺ {xs = xs} (Any-×⁻ pq) ≡ pq
-  to∘from pq
-    with find pq
-      | (λ (f : (proj₁ (find pq) ≡_) ⋐ _) → map∘find pq {f})
-  ... | (x , x∈xs , pq′) | lem₁
-    with find pq′
-      | (λ (f : (proj₁ (find pq′) ≡_) ⋐ _) → map∘find pq′ {f})
-  ... | (y , y∈ys , p , q) | lem₂
-    rewrite P.sym $ map-∘ {R = λ x → Any (λ y → P x × Q y) ys}
-                          (λ p → Any.map (λ q → p , q) (lose y∈ys q))
-                          (λ y → P.subst P y p)
-                          x∈xs
-            = lem₁ _ helper
-    where
-    helper : Any.map (λ q → p , q) (lose y∈ys q) ≡ pq′
-    helper rewrite P.sym $ map-∘ (λ q → p , q)
-                                 (λ y → P.subst Q y q)
-                                 y∈ys
-           = lem₂ _ refl
+  to∘from : ∀ pq → Any-×⁺ (Any-×⁻ pq) ≡ pq
+  to∘from pq =
+    let x , x∈xs , pq′ = find pq
+        y , y∈ys , px , qy = find pq′
+
+        h : P ⋐ λ x → Any (λ y → (P x) × (Q y)) ys
+        h p = Any.map (p ,_) (lose y∈ys qy)
+
+        helper : h px ≡ pq′
+        helper = begin
+          Any.map (px ,_) (lose y∈ys qy)
+            ≡⟨ map-∘ (px ,_) (λ z → resp Q z qy) y∈ys ⟨
+          Any.map (λ z → px , resp Q z qy) y∈ys
+            ≡⟨ map∘find pq′ refl ⟩
+          pq′
+            ∎
+
+    in  begin
+      Any-×⁺ (Any-×⁻ pq)
+        ≡⟨⟩
+      Any.map h (lose x∈xs px)
+        ≡⟨ map-∘ h (λ z → resp P z px) x∈xs ⟨
+      Any.map (λ z → Any.map (resp P z px ,_) (lose y∈ys qy)) x∈xs
+        ≡⟨ map∘find pq helper ⟩
+      pq
+        ∎
 
 ------------------------------------------------------------------------
 -- Half-applied product commutes with Any.
@@ -288,7 +301,7 @@ module _ {_~_ : REL A B r} where
 
   Any-Σ⁻ʳ : Any (∃ ∘ _~_) xs → ∃ λ x → Any (_~ x) xs
   Any-Σ⁻ʳ (here (b , x)) = b , here x
-  Any-Σ⁻ʳ (there xs) = Prod.map₂ there $ Any-Σ⁻ʳ xs
+  Any-Σ⁻ʳ (there xs) = Product.map₂ there $ Any-Σ⁻ʳ xs
 
 ------------------------------------------------------------------------
 -- Invertible introduction (⁺) and elimination (⁻) rules for various
@@ -319,15 +332,15 @@ module _ {f : A → B} where
 
   map⁺∘map⁻ : (p : Any P (List.map f xs)) → map⁺ (map⁻ p) ≡ p
   map⁺∘map⁻ {xs = x ∷ xs} (here  p) = refl
-  map⁺∘map⁻ {xs = x ∷ xs} (there p) = P.cong there (map⁺∘map⁻ p)
+  map⁺∘map⁻ {xs = x ∷ xs} (there p) = cong there (map⁺∘map⁻ p)
 
   map⁻∘map⁺ : ∀ (P : Pred B p) →
               (p : Any (P ∘ f) xs) → map⁻ {P = P} (map⁺ p) ≡ p
   map⁻∘map⁺ P (here  p) = refl
-  map⁻∘map⁺ P (there p) = P.cong there (map⁻∘map⁺ P p)
+  map⁻∘map⁺ P (there p) = cong there (map⁻∘map⁺ P p)
 
   map↔ : Any (P ∘ f) xs ↔ Any P (List.map f xs)
-  map↔ = inverse map⁺ map⁻ (map⁻∘map⁺ _) map⁺∘map⁻
+  map↔ = mk↔ₛ′ map⁺ map⁻ map⁺∘map⁻ (map⁻∘map⁺ _)
 
   gmap : P ⋐ Q ∘ f → Any P ⋐ Any Q ∘ map f
   gmap g = map⁺ ∘ Any.map g
@@ -364,9 +377,9 @@ module _ {P : A → Set p} where
   ++⁺∘++⁻ : ∀ xs {ys} (p : Any P (xs ++ ys)) → [ ++⁺ˡ , ++⁺ʳ xs ]′ (++⁻ xs p) ≡ p
   ++⁺∘++⁻ []       p         = refl
   ++⁺∘++⁻ (x ∷ xs) (here  p) = refl
-  ++⁺∘++⁻ (x ∷ xs) (there p) with ++⁻ xs p | ++⁺∘++⁻ xs p
-  ... | inj₁ p′ | ih = P.cong there ih
-  ... | inj₂ p′ | ih = P.cong there ih
+  ++⁺∘++⁻ (x ∷ xs) (there p) with ih ← ++⁺∘++⁻ xs p | ++⁻ xs p
+  ... | inj₁ _ = cong there ih
+  ... | inj₂ _ = cong there ih
 
   ++⁻∘++⁺ : ∀ xs {ys} (p : Any P xs ⊎ Any P ys) →
             ++⁻ xs ([ ++⁺ˡ , ++⁺ʳ xs ]′ p) ≡ p
@@ -376,7 +389,7 @@ module _ {P : A → Set p} where
   ++⁻∘++⁺ (x ∷ xs)      (inj₂ p)         rewrite ++⁻∘++⁺ xs      (inj₂ p) = refl
 
   ++↔ : ∀ {xs ys} → (Any P xs ⊎ Any P ys) ↔ Any P (xs ++ ys)
-  ++↔ {xs = xs} = inverse [ ++⁺ˡ , ++⁺ʳ xs ]′ (++⁻ xs) (++⁻∘++⁺ xs) (++⁺∘++⁻ xs)
+  ++↔ {xs = xs} = mk↔ₛ′ [ ++⁺ˡ , ++⁺ʳ xs ]′ (++⁻ xs) (++⁺∘++⁻ xs) (++⁻∘++⁺ xs)
 
   ++-comm : ∀ xs ys → Any P (xs ++ ys) → Any P (ys ++ xs)
   ++-comm xs ys = [ ++⁺ʳ ys , ++⁺ˡ ]′ ∘ ++⁻ xs
@@ -398,8 +411,8 @@ module _ {P : A → Set p} where
           | ++⁻∘++⁺ ys {ys = x ∷ xs} (inj₁ p) = refl
 
   ++↔++ : ∀ xs ys → Any P (xs ++ ys) ↔ Any P (ys ++ xs)
-  ++↔++ xs ys = inverse (++-comm xs ys) (++-comm ys xs)
-                        (++-comm∘++-comm xs) (++-comm∘++-comm ys)
+  ++↔++ xs ys = mk↔ₛ′ (++-comm xs ys) (++-comm ys xs)
+                        (++-comm∘++-comm ys) (++-comm∘++-comm xs)
 
   ++-insert : ∀ xs {ys} → P x → Any P (xs ++ [ x ] ++ ys)
   ++-insert xs Px = ++⁺ʳ xs (++⁺ˡ (singleton⁺ Px))
@@ -443,10 +456,10 @@ module _ {P : A → Set p} where
   concat⁻∘concat⁺ (here                      p) = concat⁻∘++⁺ˡ _ p
   concat⁻∘concat⁺ (there {x = xs} {xs = xss} p)
     rewrite concat⁻∘++⁺ʳ xs xss (concat⁺ p) =
-      P.cong there $ concat⁻∘concat⁺ p
+      cong there $ concat⁻∘concat⁺ p
 
   concat↔ : ∀ {xss} → Any (Any P) xss ↔ Any P (concat xss)
-  concat↔ {xss} = inverse concat⁺ (concat⁻ xss) concat⁻∘concat⁺ (concat⁺∘concat⁻ xss)
+  concat↔ {xss} = mk↔ₛ′ concat⁺ (concat⁻ xss) (concat⁺∘concat⁻ xss) concat⁻∘concat⁺
 
 ------------------------------------------------------------------------
 -- cartesianProductWith
@@ -463,10 +476,10 @@ module _ (f : A → B → C) where
                           Any R (cartesianProductWith f xs ys) →
                           Any P xs × Any Q ys
   cartesianProductWith⁻ resp (x ∷ xs) ys Rxsys with ++⁻ (map (f x) ys) Rxsys
-  cartesianProductWith⁻ resp (x ∷ xs) ys Rxsys | inj₁ Rfxys with map⁻ Rfxys
-  ... | Rxys = here (proj₁ (resp (proj₂ (Any.satisfied Rxys)))) , Any.map (proj₂ ∘ resp) Rxys
-  cartesianProductWith⁻ resp (x ∷ xs) ys Rxsys | inj₂ Rc with cartesianProductWith⁻ resp xs ys Rc
-  ... | pxs , qys = there pxs , qys
+  ... | inj₁ Rfxys = let Rxys = map⁻ Rfxys
+    in here (proj₁ (resp (proj₂ (Any.satisfied Rxys)))) , Any.map (proj₂ ∘ resp) Rxys
+  ... | inj₂ Rc    = let pxs , qys = cartesianProductWith⁻ resp xs ys Rc
+    in there pxs , qys
 
 ------------------------------------------------------------------------
 -- cartesianProduct
@@ -490,24 +503,22 @@ applyUpTo⁺ f p (s<s i<n@(s≤s _)) =
 applyUpTo⁻ : ∀ f {n} → Any P (applyUpTo f n) →
              ∃ λ i → i < n × P (f i)
 applyUpTo⁻ f {suc n} (here p)  = zero , z<s , p
-applyUpTo⁻ f {suc n} (there p) with applyUpTo⁻ (f ∘ suc) p
-... | i , i<n , q = suc i , s<s i<n , q
+applyUpTo⁻ f {suc n} (there p) =
+  let i , i<n , q = applyUpTo⁻ (f ∘ suc) p in suc i , s<s i<n , q
 
 ------------------------------------------------------------------------
 -- applyDownFrom
 
-module _ {P : A → Set p} where
-
-  applyDownFrom⁺ : ∀ f {i n} → P (f i) → i < n → Any P (applyDownFrom f n)
-  applyDownFrom⁺ f {i} {suc n} p (s≤s i≤n) with i ≟ n
-  ... | yes P.refl = here p
-  ... | no  i≢n    = there (applyDownFrom⁺ f p (≤∧≢⇒< i≤n i≢n))
+applyDownFrom⁺ : ∀ f {i n} → P (f i) → i < n → Any P (applyDownFrom f n)
+applyDownFrom⁺ f {i} {suc n} p (s≤s i≤n) with i ≟ n
+... | yes refl = here p
+... | no  i≢n  = there (applyDownFrom⁺ f p (≤∧≢⇒< i≤n i≢n))
 
-  applyDownFrom⁻ : ∀ f {n} → Any P (applyDownFrom f n) →
-                   ∃ λ i → i < n × P (f i)
-  applyDownFrom⁻ f {suc n} (here p)  = n , ≤-refl , p
-  applyDownFrom⁻ f {suc n} (there p) with applyDownFrom⁻ f p
-  ... | i , i<n , pf = i , m<n⇒m<1+n i<n , pf
+applyDownFrom⁻ : ∀ f {n} → Any P (applyDownFrom f n) →
+                 ∃ λ i → i < n × P (f i)
+applyDownFrom⁻ f {suc n} (here p)  = n , ≤-refl , p
+applyDownFrom⁻ f {suc n} (there p) =
+  let i , i<n , q = applyDownFrom⁻ f p in i , m<n⇒m<1+n i<n , q
 
 ------------------------------------------------------------------------
 -- tabulate
@@ -518,7 +529,7 @@ tabulate⁺ (suc i) p = there (tabulate⁺ i p)
 
 tabulate⁻ : ∀ {n} {f : Fin n → A} → Any P (tabulate f) → ∃ λ i → P (f i)
 tabulate⁻ {n = suc _} (here p)  = zero , p
-tabulate⁻ {n = suc _} (there p) = Prod.map suc id (tabulate⁻ p)
+tabulate⁻ {n = suc _} (there p) = Product.map suc id (tabulate⁻ p)
 
 ------------------------------------------------------------------------
 -- filter
@@ -527,8 +538,8 @@ module _ (Q? : U.Decidable Q) where
 
   filter⁺ : (p : Any P xs) → Any P (filter Q? xs) ⊎ ¬ Q (Any.lookup p)
   filter⁺ {xs = x ∷ _} (here px) with Q? x
-  ... | true  because _       = inj₁ (here px)
-  ... | false because ofⁿ ¬Qx = inj₂ ¬Qx
+  ... | true  because _     = inj₁ (here px)
+  ... | false because [¬Qx] = inj₂ (invert [¬Qx])
   filter⁺ {xs = x ∷ _} (there p) with does (Q? x)
   ... | true  = Sum.map₁ there (filter⁺ p)
   ... | false = filter⁺ p
@@ -542,14 +553,14 @@ module _ (Q? : U.Decidable Q) where
 ------------------------------------------------------------------------
 -- derun and deduplicate
 
-module _ {R : A → A → Set r} (R? : B.Decidable R) where
+module _ {R : Rel A r} (R? : B.Decidable R) where
 
   private
     derun⁺-aux : ∀ x xs → P Respects R → P x → Any P (derun R? (x ∷ xs))
     derun⁺-aux x [] resp Px = here Px
     derun⁺-aux x (y ∷ xs) resp Px with R? x y
-    ... | true  because ofʸ Rxy = derun⁺-aux y xs resp (resp Rxy Px)
-    ... | false because _       = here Px
+    ... | true  because [Rxy] = derun⁺-aux y xs resp (resp (invert [Rxy]) Px)
+    ... | false because _     = here Px
 
   derun⁺ : P Respects R → Any P xs → Any P (derun R? xs)
   derun⁺ {xs = x ∷ xs}     resp (here px)   = derun⁺-aux x xs resp px
@@ -561,9 +572,10 @@ module _ {R : A → A → Set r} (R? : B.Decidable R) where
   deduplicate⁺ {xs = x ∷ xs} resp (here px)   = here px
   deduplicate⁺ {xs = x ∷ xs} resp (there pxs)
     with filter⁺ (¬? ∘ R? x) (deduplicate⁺ resp pxs)
-  ... | inj₁ p = there p
-  ... | inj₂ ¬¬q with decidable-stable (R? x (Any.lookup (deduplicate⁺ resp pxs))) ¬¬q
-  ...  | q = here (resp q (lookup-result (deduplicate⁺ resp pxs)))
+  ... | inj₁ p   = there p
+  ... | inj₂ ¬¬q =
+    let q = decidable-stable (R? x (Any.lookup (deduplicate⁺ resp pxs))) ¬¬q
+    in  here (resp q (lookup-result (deduplicate⁺ resp pxs)))
 
   private
     derun⁻-aux : Any P (derun R? (x ∷ xs)) → Any P (x ∷ xs)
@@ -597,11 +609,11 @@ module _ {P : B → Set p} where
                 ∃₂ λ x (x∈xs : x ∈ xs) → P (f x∈xs)
   mapWith∈⁻ (y ∷ xs) f (here  p) = (y , here refl , p)
   mapWith∈⁻ (y ∷ xs) f (there p) =
-    Prod.map₂ (Prod.map there id) $ mapWith∈⁻ xs (f ∘ there) p
+    Product.map₂ (Product.map there id) $ mapWith∈⁻ xs (f ∘ there) p
 
   mapWith∈↔ : ∀ {xs : List A} {f : ∀ {x} → x ∈ xs → B} →
                 (∃₂ λ x (x∈xs : x ∈ xs) → P (f x∈xs)) ↔ Any P (mapWith∈ xs f)
-  mapWith∈↔ = inverse (mapWith∈⁺ _) (mapWith∈⁻ _ _) (from∘to _) (to∘from _ _)
+  mapWith∈↔ = mk↔ₛ′ (mapWith∈⁺ _) (mapWith∈⁻ _ _) (to∘from _ _) (from∘to _)
     where
     from∘to : ∀ {xs : List A} (f : ∀ {x} → x ∈ xs → B)
               (p : ∃₂ λ x (x∈xs : x ∈ xs) → P (f x∈xs)) →
@@ -615,7 +627,7 @@ module _ {P : B → Set p} where
               mapWith∈⁺ f (mapWith∈⁻ xs f p) ≡ p
     to∘from (y ∷ xs) f (here  p) = refl
     to∘from (y ∷ xs) f (there p) =
-      P.cong there $ to∘from xs (f ∘ there) p
+      cong there $ to∘from xs (f ∘ there) p
 
 ------------------------------------------------------------------------
 -- reverse
@@ -628,50 +640,44 @@ reverseAcc⁺ acc (x ∷ xs) (inj₂ (there y)) = reverseAcc⁺ (x ∷ acc) xs (
 
 reverseAcc⁻ : ∀ acc xs → Any P (reverseAcc acc xs) → Any P acc ⊎ Any P xs
 reverseAcc⁻ acc []       ps = inj₁ ps
-reverseAcc⁻ acc (x ∷ xs) ps rewrite ʳ++-defn xs {x ∷ acc} with ++⁻ (reverseAcc [] xs) ps
-... | inj₂ (here p') = inj₂ (here p')
-... | inj₂ (there ps') = inj₁ ps'
-... | inj₁ ps' with reverseAcc⁻ [] xs ps'
-...   | inj₂ ps'' = inj₂ (there ps'')
+reverseAcc⁻ acc (x ∷ xs) ps with reverseAcc⁻ (x ∷ acc) xs ps
+... | inj₁ (here px) = inj₂ (here px)
+... | inj₁ (there pxs) = inj₁ pxs
+... | inj₂ pxs = inj₂ (there pxs)
 
 reverse⁺ : Any P xs → Any P (reverse xs)
 reverse⁺ ps = reverseAcc⁺ [] _ (inj₂ ps)
 
 reverse⁻ : Any P (reverse xs) → Any P xs
-reverse⁻ ps with reverseAcc⁻ [] _ ps
-... | inj₂ ps' = ps'
+reverse⁻ ps with inj₂ pxs ← reverseAcc⁻ [] _ ps = pxs
 
 ------------------------------------------------------------------------
 -- pure
 
-module _ {P : A → Set p} where
-
-  pure⁺ : P x → Any P (pure x)
-  pure⁺ = here
+pure⁺ : P x → Any P (pure x)
+pure⁺ = here
 
-  pure⁻ : Any P (pure x) → P x
-  pure⁻ (here p) = p
+pure⁻ : Any P (pure x) → P x
+pure⁻ (here p) = p
 
-  pure⁺∘pure⁻ : (p : Any P (pure x)) → pure⁺ (pure⁻ p) ≡ p
-  pure⁺∘pure⁻ (here p) = refl
+pure⁺∘pure⁻ : (p : Any P (pure x)) → pure⁺ (pure⁻ p) ≡ p
+pure⁺∘pure⁻ (here p) = refl
 
-  pure⁻∘pure⁺ : (p : P x) → pure⁻ (pure⁺ p) ≡ p
-  pure⁻∘pure⁺ p = refl
+pure⁻∘pure⁺ : (p : P x) → pure⁻ {P = P} (pure⁺ p) ≡ p
+pure⁻∘pure⁺ p = refl
 
-  pure↔ : P x ↔ Any P (pure x)
-  pure↔ = inverse pure⁺ pure⁻ pure⁻∘pure⁺ pure⁺∘pure⁻
+pure↔ : P x ↔ Any P (pure x)
+pure↔ {P = P} = mk↔ₛ′ pure⁺ pure⁻ pure⁺∘pure⁻ (pure⁻∘pure⁺ {P = P})
 
 ------------------------------------------------------------------------
 -- _∷_
 
-module _ (P : Pred A p) where
-
-  ∷↔ : (P x ⊎ Any P xs) ↔ Any P (x ∷ xs)
-  ∷↔ {x = x} {xs} =
-    (P x         ⊎ Any P xs)  ↔⟨ pure↔ {P = P} ⊎-cong (Any P xs ∎) ⟩
-    (Any P [ x ] ⊎ Any P xs)  ↔⟨ ++↔ {P = P} {xs = [ x ]} ⟩
-    Any P (x ∷ xs)            ∎
-    where open Related.EquationalReasoning
+∷↔ : (P : Pred A p) → (P x ⊎ Any P xs) ↔ Any P (x ∷ xs)
+∷↔ {x = x} {xs} P =
+  (P x         ⊎ Any P xs)  ↔⟨ pure↔ ⊎-cong (Any P xs ∎) ⟩
+  (Any P [ x ] ⊎ Any P xs)  ↔⟨ ++↔ ⟩
+  Any P (x ∷ xs)            ∎
+  where open Related.EquationalReasoning
 
 ------------------------------------------------------------------------
 -- _>>=_
@@ -694,17 +700,16 @@ module _ {A B : Set ℓ} {P : B → Set p} {f : A → List B} where
   Any (λ f → Any (P ∘ f) xs) fs                ↔⟨ Any-cong (λ _ → Any-cong (λ _ → pure↔) (_ ∎)) (_ ∎) ⟩
   Any (λ f → Any (Any P ∘ pure ∘ f) xs) fs     ↔⟨ Any-cong (λ _ → >>=↔ ) (_ ∎) ⟩
   Any (λ f → Any P (xs >>= pure ∘ f)) fs       ↔⟨ >>=↔ ⟩
-  Any P (fs >>= λ f → xs >>= λ x → pure (f x)) ≡˘⟨ P.cong (Any P) (Listₑ.Applicative.unfold-⊛ fs xs) ⟩
-  Any P (fs ⊛ xs)                              ∎
+  Any P (fs >>= λ f → xs >>= λ x → pure (f x)) ≡⟨ cong (Any P) (List.Applicative.unfold-⊛ fs xs) ⟨
+  Any P (fs ⊛ xs)                               ∎
   where open Related.EquationalReasoning
 
+
 -- An alternative introduction rule for _⊛_
 
-⊛⁺′ : ∀ {P : A → Set ℓ} {Q : B → Set ℓ} {fs : List (A → B)} {xs} →
+⊛⁺′ : ∀ {P : Pred A ℓ} {Q : Pred B ℓ} {fs : List (A → B)} {xs} →
       Any (P ⟨→⟩ Q) fs → Any P xs → Any Q (fs ⊛ xs)
-⊛⁺′ pq p =
-  Inverse.to ⊛↔ ⟨$⟩
-    Any.map (λ pq → Any.map (λ {x} → pq {x}) p) pq
+⊛⁺′ pq p = Inverse.to ⊛↔ (Any.map (λ pq → Any.map (λ {x} → pq {x}) p) pq)
 
 ------------------------------------------------------------------------
 -- _⊗_
@@ -715,7 +720,7 @@ module _ {A B : Set ℓ} {P : B → Set p} {f : A → List B} where
   Any (λ x → Any (λ y → P (x , y)) ys) xs                           ↔⟨ pure↔ ⟩
   Any (λ _,_ → Any (λ x → Any (λ y → P (x , y)) ys) xs) (pure _,_)  ↔⟨ ⊛↔ ⟩
   Any (λ x, → Any (P ∘ x,) ys) (pure _,_ ⊛ xs)                      ↔⟨ ⊛↔ ⟩
-  Any P (pure _,_ ⊛ xs ⊛ ys)                                        ≡˘⟨ P.cong (Any P ∘′ (_⊛ ys)) (Listₑ.Applicative.unfold-<$> _,_ xs) ⟩
+  Any P (pure _,_ ⊛ xs ⊛ ys)                                        ≡⟨ cong (Any P ∘′ (_⊛ ys)) (List.Applicative.unfold-<$> _,_ xs) ⟨
   Any P (xs ⊗ ys)                                                   ∎
   where open Related.EquationalReasoning
 
diff --git a/src/Data/List/Relation/Unary/Enumerates/Setoid.agda b/src/Data/List/Relation/Unary/Enumerates/Setoid.agda
index cdfd9c7ed5..8da8806ce1 100644
--- a/src/Data/List/Relation/Unary/Enumerates/Setoid.agda
+++ b/src/Data/List/Relation/Unary/Enumerates/Setoid.agda
@@ -6,9 +6,9 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.List
+open import Data.List.Base using (List)
 open import Level
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Relation.Unary.Enumerates.Setoid
   {a ℓ} (S : Setoid a ℓ) where
diff --git a/src/Data/List/Relation/Unary/Enumerates/Setoid/Properties.agda b/src/Data/List/Relation/Unary/Enumerates/Setoid/Properties.agda
index b9eabc66b3..0f374ea1b5 100644
--- a/src/Data/List/Relation/Unary/Enumerates/Setoid/Properties.agda
+++ b/src/Data/List/Relation/Unary/Enumerates/Setoid/Properties.agda
@@ -11,21 +11,23 @@ open import Data.List.Membership.Setoid.Properties as Membership
 open import Data.List.Relation.Unary.Any using (index)
 open import Data.List.Relation.Unary.Any.Properties using (lookup-index)
 open import Data.List.Relation.Unary.Enumerates.Setoid
-open import Data.Sum using (inj₁; inj₂)
+open import Data.Sum.Base using (inj₁; inj₂)
 open import Data.Sum.Relation.Binary.Pointwise
   using (_⊎ₛ_; inj₁; inj₂)
-open import Data.Product using (_,_; proj₁; proj₂)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent
   using (_×ₛ_)
-open import Function
+open import Function.Base using (_∘_)
+open import Function.Bundles using (Surjection)
+open import Function.Definitions using (Surjective)
+open import Function.Consequences using (strictlySurjective⇒surjective)
 open import Level
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality using (_≡_)
+open import Relation.Binary.Bundles using (Setoid; DecSetoid)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Binary.Properties.Setoid using (respʳ-flip)
 
 module Data.List.Relation.Unary.Enumerates.Setoid.Properties where
 
-open Setoid
 
 private
   variable
@@ -38,8 +40,8 @@ module _ (S : Setoid a ℓ₁) (T : Setoid b ℓ₂) (surj : Surjection S T) whe
   open Surjection surj
 
   map⁺ : ∀ {xs} → IsEnumeration S xs → IsEnumeration T (map to xs)
-  map⁺ _∈xs y with surjective y
-  ... | (x , fx≈y) = ∈-resp-≈ T fx≈y (∈-map⁺ S T cong (x ∈xs))
+  map⁺ _∈xs y with (x , fx≈y) ← strictlySurjective y =
+      ∈-resp-≈ T fx≈y (∈-map⁺ S T cong (x ∈xs))
 
 ------------------------------------------------------------------------
 -- _++_
@@ -82,7 +84,9 @@ module _ (S? : DecSetoid a ℓ₁) where
 -- lookup
 
 module _ (S : Setoid a ℓ₁) where
+  open Setoid S
 
   lookup-surjective : ∀ {xs} → IsEnumeration S xs →
-                      Surjective _≡_ (_≈_ S) (lookup xs)
-  lookup-surjective _∈xs y = index (y ∈xs) , sym S (lookup-index (y ∈xs))
+                      Surjective _≡_ _≈_ (lookup xs)
+  lookup-surjective _∈xs = strictlySurjective⇒surjective
+    trans (λ { ≡.refl → refl}) (λ y → index (y ∈xs) , sym (lookup-index (y ∈xs)))
diff --git a/src/Data/List/Relation/Unary/First.agda b/src/Data/List/Relation/Unary/First.agda
index b00f35e9d3..25eb9fc37a 100644
--- a/src/Data/List/Relation/Unary/First.agda
+++ b/src/Data/List/Relation/Unary/First.agda
@@ -15,13 +15,13 @@ open import Data.Fin.Base as Fin using (Fin; zero; suc)
 open import Data.List.Base as List using (List; []; _∷_)
 open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
 open import Data.List.Relation.Unary.Any as Any using (Any; here; there)
-open import Data.Product as Prod using (∃; -,_; _,_)
-open import Data.Sum as Sum using (_⊎_; inj₁; inj₂)
-open import Function
+open import Data.Product.Base using (∃; -,_; _,_)
+open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
+open import Function.Base using (id; _∘′_)
 open import Relation.Unary
 open import Relation.Nullary
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Basic type.
 
 module _ {p q} (P : Pred A p) (Q : Pred A q) where
diff --git a/src/Data/List/Relation/Unary/First/Properties.agda b/src/Data/List/Relation/Unary/First/Properties.agda
index 7885712d7e..4a68a544af 100644
--- a/src/Data/List/Relation/Unary/First/Properties.agda
+++ b/src/Data/List/Relation/Unary/First/Properties.agda
@@ -8,17 +8,17 @@
 
 module Data.List.Relation.Unary.First.Properties where
 
-open import Data.Empty
 open import Data.Fin.Base using (suc)
 open import Data.List.Base as List using (List; []; _∷_)
 open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
 open import Data.List.Relation.Unary.Any as Any using (here; there)
 open import Data.List.Relation.Unary.First
-import Data.Sum as Sum
-open import Function
-open import Relation.Binary.PropositionalEquality as P using (_≡_; refl; _≗_)
-open import Relation.Unary
-open import Relation.Nullary.Negation
+import Data.Sum.Base as Sum
+open import Function.Base using (_∘′_; _∘_; id)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_; refl; _≗_)
+import Relation.Nullary.Decidable.Core as Dec
+open import Relation.Nullary.Negation.Core using (contradiction)
+open import Relation.Unary using (Pred; _⊆_; ∁; Irrelevant; Decidable)
 
 ------------------------------------------------------------------------
 -- map
@@ -52,7 +52,7 @@ module _ {a p q} {A : Set a} {P : Pred A p} {Q : Pred A q} where
 module _ {a p q} {A : Set a} {P : Pred A p} {Q : Pred A q} where
 
   All⇒¬First : P ⊆ ∁ Q → All P ⊆ ∁ (First P Q)
-  All⇒¬First p⇒¬q (px ∷ pxs) [ qx ]   = ⊥-elim (p⇒¬q px qx)
+  All⇒¬First p⇒¬q (px ∷ pxs) [ qx ]   = contradiction qx (p⇒¬q px)
   All⇒¬First p⇒¬q (_ ∷ pxs)  (_ ∷ hf) = All⇒¬First p⇒¬q pxs hf
 
   First⇒¬All : Q ⊆ ∁ P → First P Q ⊆ ∁ (All P)
@@ -64,16 +64,16 @@ module _ {a p q} {A : Set a} {P : Pred A p} {Q : Pred A q} where
 
   unique-index : ∀ {xs} → P ⊆ ∁ Q → (f₁ f₂ : First P Q xs) → index f₁ ≡ index f₂
   unique-index p⇒¬q [ _ ]    [ _ ]    = refl
-  unique-index p⇒¬q [ qx ]   (px ∷ _) = ⊥-elim (p⇒¬q px qx)
-  unique-index p⇒¬q (px ∷ _) [ qx ]   = ⊥-elim (p⇒¬q px qx)
-  unique-index p⇒¬q (_ ∷ f₁) (_ ∷ f₂) = P.cong suc (unique-index p⇒¬q f₁ f₂)
+  unique-index p⇒¬q [ qx ]   (px ∷ _) = contradiction qx (p⇒¬q px)
+  unique-index p⇒¬q (px ∷ _) [ qx ]   = contradiction qx (p⇒¬q px)
+  unique-index p⇒¬q (_ ∷ f₁) (_ ∷ f₂) = ≡.cong suc (unique-index p⇒¬q f₁ f₂)
 
   irrelevant : P ⊆ ∁ Q → Irrelevant P → Irrelevant Q → Irrelevant (First P Q)
-  irrelevant p⇒¬q p-irr q-irr [ qx₁ ]    [ qx₂ ]    = P.cong [_] (q-irr qx₁ qx₂)
-  irrelevant p⇒¬q p-irr q-irr [ qx₁ ]    (px₂ ∷ f₂) = ⊥-elim (p⇒¬q px₂ qx₁)
-  irrelevant p⇒¬q p-irr q-irr (px₁ ∷ f₁) [ qx₂ ]    = ⊥-elim (p⇒¬q px₁ qx₂)
-  irrelevant p⇒¬q p-irr q-irr (px₁ ∷ f₁) (px₂ ∷ f₂) =
-    P.cong₂ _∷_ (p-irr px₁ px₂) (irrelevant p⇒¬q p-irr q-irr f₁ f₂)
+  irrelevant p⇒¬q p-irr q-irr [ px ]    [ qx ]    = ≡.cong [_] (q-irr px qx)
+  irrelevant p⇒¬q p-irr q-irr [ qx ]    (px ∷ _)  = contradiction qx (p⇒¬q px)
+  irrelevant p⇒¬q p-irr q-irr (px ∷ _)  [ qx ]    = contradiction qx (p⇒¬q px)
+  irrelevant p⇒¬q p-irr q-irr (px ∷ f)  (qx ∷ g) =
+    ≡.cong₂ _∷_ (p-irr px qx) (irrelevant p⇒¬q p-irr q-irr f g)
 
 ------------------------------------------------------------------------
 -- Decidability
@@ -81,14 +81,14 @@ module _ {a p q} {A : Set a} {P : Pred A p} {Q : Pred A q} where
 module _ {a p} {A : Set a} {P : Pred A p} where
 
   first? : Decidable P → Decidable (First P (∁ P))
-  first? P? xs = Sum.toDec
-               $ Sum.map₂ (All⇒¬First contradiction)
-               $ first (Sum.fromDec ∘ P?) xs
+  first? P? = Dec.fromSum
+            ∘ Sum.map₂ (All⇒¬First contradiction)
+            ∘ first (Dec.toSum ∘ P?)
 
   cofirst? : Decidable P → Decidable (First (∁ P) P)
-  cofirst? P? xs = Sum.toDec
-                 $ Sum.map₂ (All⇒¬First id)
-                 $ first (Sum.swap ∘ Sum.fromDec ∘ P?) xs
+  cofirst? P? = Dec.fromSum
+              ∘ Sum.map₂ (All⇒¬First id)
+              ∘ first (Sum.swap ∘ Dec.toSum ∘ P?)
 
 ------------------------------------------------------------------------
 -- Conversion to Any
@@ -97,11 +97,11 @@ module _ {a p} {A : Set a} {P : Pred A p} where
 
   fromAny∘toAny≗id : ∀ {xs} → fromAny {Q = P} {x = xs} ∘′ toAny ≗ id
   fromAny∘toAny≗id [ qx ]      = refl
-  fromAny∘toAny≗id (px ∷ pqxs) = P.cong (_ ∷_) (fromAny∘toAny≗id pqxs)
+  fromAny∘toAny≗id (px ∷ pqxs) = ≡.cong (_ ∷_) (fromAny∘toAny≗id pqxs)
 
   toAny∘fromAny≗id : ∀ {xs} → toAny {Q = P} ∘′ fromAny {x = xs} ≗ id
   toAny∘fromAny≗id (here px) = refl
-  toAny∘fromAny≗id (there v) = P.cong there (toAny∘fromAny≗id v)
+  toAny∘fromAny≗id (there v) = ≡.cong there (toAny∘fromAny≗id v)
 
 ------------------------------------------------------------------------
 -- Equivalence between the inductive definition and the view
diff --git a/src/Data/List/Relation/Unary/Grouped.agda b/src/Data/List/Relation/Unary/Grouped.agda
index eceb6a80d0..f10bc1fd32 100644
--- a/src/Data/List/Relation/Unary/Grouped.agda
+++ b/src/Data/List/Relation/Unary/Grouped.agda
@@ -8,11 +8,12 @@
 
 module Data.List.Relation.Unary.Grouped where
 
-open import Data.List using (List; []; _∷_; map)
+open import Data.List.Base using (List; []; _∷_; map)
 open import Data.List.Relation.Unary.All as All using (All; []; _∷_; all?)
-open import Data.Sum using (_⊎_; inj₁; inj₂)
-open import Data.Product using (_×_; _,_)
-open import Relation.Binary as B using (REL; Rel)
+open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
+open import Data.Product.Base using (_×_; _,_)
+open import Relation.Binary.Core using (REL; Rel)
+open import Relation.Binary.Definitions as B
 open import Relation.Unary as U using (Pred)
 open import Relation.Nullary.Negation using (¬_)
 open import Relation.Nullary.Decidable as Dec using (yes; ¬?; _⊎-dec_; _×-dec_)
diff --git a/src/Data/List/Relation/Unary/Grouped/Properties.agda b/src/Data/List/Relation/Unary/Grouped/Properties.agda
index 189dba033c..b0e4e42a4d 100644
--- a/src/Data/List/Relation/Unary/Grouped/Properties.agda
+++ b/src/Data/List/Relation/Unary/Grouped/Properties.agda
@@ -8,47 +8,41 @@
 
 module Data.List.Relation.Unary.Grouped.Properties where
 
-open import Data.Bool using (true; false)
-open import Data.List
+open import Data.Bool.Base using (true; false)
+open import Data.List.Base using ([]; [_]; _∷_; map; derun)
 open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
 import Data.List.Relation.Unary.All.Properties as All
 open import Data.List.Relation.Unary.AllPairs as AllPairs using (AllPairs; []; _∷_)
 open import Data.List.Relation.Unary.Grouped
-open import Function using (_∘_; _⇔_; Equivalence)
-open import Relation.Binary as B using (REL; Rel)
+open import Data.Product.Base using (_,_)
+open import Function.Base using (_∘_; _on_)
+open import Level using (Level)
+open import Relation.Binary.Definitions as B
+open import Relation.Binary.Core using (_⇔_; REL; Rel)
 open import Relation.Unary as U using (Pred)
-open import Relation.Nullary using (¬_; does; yes; no)
-open import Relation.Nullary.Negation using (contradiction)
-open import Level
+open import Relation.Nullary.Decidable.Core using (does; yes; no)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
 
 private
   variable
     a b c p q : Level
-    A : Set a
-    B : Set b
-    C : Set c
+    A B C : Set a
 
 ------------------------------------------------------------------------
 -- map
 
 module _ (P : Rel A p) (Q : Rel B q) where
 
-  map⁺ : ∀ {f xs} → (∀ {x y} → P x y ⇔ Q (f x) (f y)) → Grouped P xs → Grouped Q (map f xs)
-  map⁺ {f} {[]} P⇔Q [] = []
-  map⁺ {f} {x ∷ xs} P⇔Q (all[¬Px,xs] ∷≉ g) = aux all[¬Px,xs] ∷≉ map⁺ P⇔Q g where
-    aux : ∀ {ys} → All (λ y → ¬ P x y) ys → All (λ y → ¬ Q (f x) y) (map f ys)
-    aux [] = []
-    aux (py ∷ pys) = py ∘ Equivalence.from P⇔Q ∷ aux pys
-  map⁺ {f} {x₁ ∷ x₂ ∷ xs} P⇔Q (Px₁x₂ ∷≈ g) = Equivalence.to P⇔Q Px₁x₂ ∷≈ map⁺ P⇔Q g
+  map⁺ : ∀ {f xs} → P ⇔ (Q on f) → Grouped P xs → Grouped Q (map f xs)
+  map⁺ P⇔Q            []                      = []
+  map⁺ P⇔Q@(_ , Q⇒P) (all[¬Px,xs] ∷≉ g[xs]) = All.gmap⁺ (_∘ Q⇒P) all[¬Px,xs] ∷≉ map⁺ P⇔Q g[xs]
+  map⁺ P⇔Q@(P⇒Q , _) (Px₁x₂ ∷≈ g[xs])       = P⇒Q Px₁x₂ ∷≈ map⁺ P⇔Q g[xs]
 
-  map⁻ : ∀ {f xs} → (∀ {x y} → P x y ⇔ Q (f x) (f y)) → Grouped Q (map f xs) → Grouped P xs
-  map⁻ {f} {[]} P⇔Q [] = []
-  map⁻ {f} {x ∷ []} P⇔Q ([] ∷≉ []) = [] ∷≉ []
-  map⁻ {f} {x₁ ∷ x₂ ∷ xs} P⇔Q (all[¬Qx,xs] ∷≉ g) = aux all[¬Qx,xs] ∷≉ map⁻ P⇔Q g where
-    aux : ∀ {ys} → All (λ y → ¬ Q (f x₁) y) (map f ys) → All (λ y → ¬ P x₁ y) ys
-    aux {[]} [] = []
-    aux {y ∷ ys} (py ∷ pys) = py ∘ Equivalence.to P⇔Q ∷ aux pys
-  map⁻ {f} {x₁ ∷ x₂ ∷ xs} P⇔Q (Qx₁x₂ ∷≈ g) = Equivalence.from P⇔Q Qx₁x₂ ∷≈ map⁻ P⇔Q g
+  map⁻ : ∀ {f xs} → P ⇔ (Q on f) → Grouped Q (map f xs) → Grouped P xs
+  map⁻ {xs = []}          P⇔Q            []                  = []
+  map⁻ {xs = _ ∷ []}     P⇔Q            ([] ∷≉ [])         = [] ∷≉ []
+  map⁻ {xs = _ ∷ _ ∷ _} P⇔Q@(P⇒Q , _) (all[¬Qx,xs] ∷≉ g) = All.gmap⁻ (_∘ P⇒Q) all[¬Qx,xs] ∷≉ map⁻ P⇔Q g
+  map⁻ {xs = _ ∷ _ ∷ _} P⇔Q@(_ , Q⇒P) (Qx₁x₂ ∷≈ g)       = Q⇒P Qx₁x₂ ∷≈ map⁻ P⇔Q g
 
 ------------------------------------------------------------------------
 -- [_]
diff --git a/src/Data/List/Relation/Unary/Linked.agda b/src/Data/List/Relation/Unary/Linked.agda
index cfafbc28b5..dc1b7fb87d 100644
--- a/src/Data/List/Relation/Unary/Linked.agda
+++ b/src/Data/List/Relation/Unary/Linked.agda
@@ -10,15 +10,16 @@ module Data.List.Relation.Unary.Linked {a} {A : Set a} where
 
 open import Data.List.Base as List using (List; []; _∷_)
 open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
-open import Data.Product as Prod using (_,_; _×_; uncurry; <_,_>)
+open import Data.Product.Base as Prod using (_,_; _×_; uncurry; <_,_>)
 open import Data.Maybe.Base using (just)
 open import Data.Maybe.Relation.Binary.Connected
   using (Connected; just; just-nothing)
 open import Function.Base using (id; _∘_)
 open import Level using (Level; _⊔_)
-open import Relation.Binary as B using (Rel; _⇒_)
+open import Relation.Binary.Definitions as B
+open import Relation.Binary.Core using (Rel; _⇒_)
 open import Relation.Binary.Construct.Intersection renaming (_∩_ to _∩ᵇ_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core using (refl; cong₂)
 open import Relation.Unary as U renaming (_∩_ to _∩ᵘ_) hiding (_⇒_)
 open import Relation.Nullary.Decidable using (yes; no; map′; _×-dec_)
 
diff --git a/src/Data/List/Relation/Unary/Linked/Properties.agda b/src/Data/List/Relation/Unary/Linked/Properties.agda
index 7106ad3e1e..563448730c 100644
--- a/src/Data/List/Relation/Unary/Linked/Properties.agda
+++ b/src/Data/List/Relation/Unary/Linked/Properties.agda
@@ -17,13 +17,15 @@ open import Data.List.Relation.Unary.All using (All; []; _∷_)
 open import Data.List.Relation.Unary.Linked as Linked
   using (Linked; []; [-]; _∷_)
 open import Data.Nat.Base using (zero; suc; _<_; z<s; s<s)
-open import Data.Nat.Properties using (≤-refl; ≤-pred; m≤n⇒m≤1+n)
+open import Data.Nat.Properties using (≤-refl; m≤n⇒m≤1+n)
 open import Data.Maybe.Relation.Binary.Connected
   using (Connected; just; nothing; just-nothing; nothing-just)
 open import Level using (Level)
 open import Function.Base using (_∘_; flip; _on_)
-open import Relation.Binary using (Rel; Transitive; DecSetoid)
-open import Relation.Binary.PropositionalEquality using (_≢_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (DecSetoid)
+open import Relation.Binary.Definitions using (Transitive)
+open import Relation.Binary.PropositionalEquality.Core using (_≢_)
 open import Relation.Unary using (Pred; Decidable)
 open import Relation.Nullary.Decidable using (yes; no; does)
 
diff --git a/src/Data/List/Relation/Unary/Sorted/TotalOrder.agda b/src/Data/List/Relation/Unary/Sorted/TotalOrder.agda
index e9295c61ff..cfdf8bf275 100644
--- a/src/Data/List/Relation/Unary/Sorted/TotalOrder.agda
+++ b/src/Data/List/Relation/Unary/Sorted/TotalOrder.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (TotalOrder)
+open import Relation.Binary.Bundles using (TotalOrder)
 
 module Data.List.Relation.Unary.Sorted.TotalOrder
   {a ℓ₁ ℓ₂} (totalOrder : TotalOrder a ℓ₁ ℓ₂) where
@@ -17,9 +17,9 @@ open import Data.List.Base using (List; []; _∷_)
 open import Data.List.Relation.Unary.Linked as Linked using (Linked)
 open import Level using (_⊔_)
 open import Relation.Unary as U using (Pred; _⊆_)
-open import Relation.Binary as B
+open import Relation.Binary.Definitions as B
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Definition
 
 Sorted : Pred (List A) (a ⊔ ℓ₂)
diff --git a/src/Data/List/Relation/Unary/Sorted/TotalOrder/Properties.agda b/src/Data/List/Relation/Unary/Sorted/TotalOrder/Properties.agda
index 69654ef242..c8c4210ed6 100644
--- a/src/Data/List/Relation/Unary/Sorted/TotalOrder/Properties.agda
+++ b/src/Data/List/Relation/Unary/Sorted/TotalOrder/Properties.agda
@@ -14,15 +14,21 @@ open import Data.List.Relation.Unary.AllPairs using (AllPairs)
 open import Data.List.Relation.Unary.Linked as Linked
   using (Linked; []; [-]; _∷_; _∷′_; head′; tail)
 import Data.List.Relation.Unary.Linked.Properties as Linked
+import Data.List.Relation.Binary.Sublist.Setoid as Sublist
+import Data.List.Relation.Binary.Sublist.Setoid.Properties as SublistProperties
 open import Data.List.Relation.Unary.Sorted.TotalOrder hiding (head)
+
 open import Data.Maybe.Base using (just; nothing)
 open import Data.Maybe.Relation.Binary.Connected using (Connected; just)
 open import Data.Nat.Base using (ℕ; zero; suc; _<_)
+
 open import Level using (Level)
-open import Relation.Binary hiding (Decidable)
+open import Relation.Binary.Core using (_Preserves_⟶_)
+open import Relation.Binary.Bundles using (TotalOrder; DecTotalOrder; Preorder)
 import Relation.Binary.Properties.TotalOrder as TotalOrderProperties
 open import Relation.Unary using (Pred; Decidable)
 open import Relation.Nullary.Decidable using (yes; no)
+
 private
   variable
     a b p ℓ₁ ℓ₂ ℓ₃ ℓ₄ : Level
@@ -101,7 +107,7 @@ module _ (O : TotalOrder a ℓ₁ ℓ₂) where
 -- merge
 
 module _ (DO : DecTotalOrder a ℓ₁ ℓ₂) where
-  open DecTotalOrder DO renaming (totalOrder to O)
+  open DecTotalOrder DO using (_≤_; _≤?_) renaming (totalOrder to O)
   open TotalOrderProperties O using (≰⇒≥)
 
   private
@@ -109,22 +115,33 @@ module _ (DO : DecTotalOrder a ℓ₁ ℓ₂) where
                 Connected _≤_ (just v) (head xs) →
                 Connected _≤_ (just v) (head ys) →
                 Connected _≤_ (just v) (head (merge _≤?_ xs ys))
-    merge-con {xs = []}     {[]}     cxs cys = cys
-    merge-con {xs = []}     {y ∷ ys} cxs cys = cys
+    merge-con {xs = []}              cxs cys = cys
     merge-con {xs = x ∷ xs} {[]}     cxs cys = cxs
     merge-con {xs = x ∷ xs} {y ∷ ys} cxs cys with x ≤? y
     ... | yes x≤y = cxs
     ... | no  x≰y = cys
 
   merge⁺ : ∀ {xs ys} → Sorted O xs → Sorted O ys → Sorted O (merge _≤?_ xs ys)
-  merge⁺ {[]}     {[]}     rxs rys = []
-  merge⁺ {[]}     {x ∷ ys} rxs rys = rys
+  merge⁺ {[]}              rxs rys = rys
   merge⁺ {x ∷ xs} {[]}     rxs rys = rxs
-  merge⁺ {x ∷ xs} {y ∷ ys} rxs rys with x ≤? y |
-    merge⁺ (Linked.tail rxs) rys | merge⁺ rxs (Linked.tail rys)
+  merge⁺ {x ∷ xs} {y ∷ ys} rxs rys
+   with x ≤? y  | merge⁺ (Linked.tail rxs) rys
+                      | merge⁺ rxs (Linked.tail rys)
   ... | yes x≤y | rec | _   = merge-con (head′ rxs)      (just x≤y)  ∷′ rec
   ... | no  x≰y | _   | rec = merge-con (just (≰⇒≥ x≰y)) (head′ rys) ∷′ rec
 
+  -- Reexport ⊆-mergeˡʳ
+
+  S = Preorder.Eq.setoid (DecTotalOrder.preorder DO)
+  open Sublist S using (_⊆_)
+  module SP = SublistProperties S
+
+  ⊆-mergeˡ : ∀ xs ys → xs ⊆ merge _≤?_ xs ys
+  ⊆-mergeˡ = SP.⊆-mergeˡ _≤?_
+
+  ⊆-mergeʳ : ∀ xs ys → ys ⊆ merge _≤?_ xs ys
+  ⊆-mergeʳ = SP.⊆-mergeʳ _≤?_
+
 ------------------------------------------------------------------------
 -- filter
 
diff --git a/src/Data/List/Relation/Unary/Sufficient.agda b/src/Data/List/Relation/Unary/Sufficient.agda
index be7bf76261..35d63add25 100644
--- a/src/Data/List/Relation/Unary/Sufficient.agda
+++ b/src/Data/List/Relation/Unary/Sufficient.agda
@@ -18,7 +18,7 @@ module Data.List.Relation.Unary.Sufficient where
 
 open import Level using (Level; _⊔_)
 open import Data.List.Base using (List; []; _∷_; [_]; _++_)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 private
   variable
diff --git a/src/Data/List/Relation/Unary/Unique/DecPropositional.agda b/src/Data/List/Relation/Unary/Unique/DecPropositional.agda
index 19ba99025f..f2e3692103 100644
--- a/src/Data/List/Relation/Unary/Unique/DecPropositional.agda
+++ b/src/Data/List/Relation/Unary/Unique/DecPropositional.agda
@@ -6,8 +6,9 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (DecSetoid; DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (decSetoid)
+open import Relation.Binary.Bundles using (DecSetoid)
+open import Relation.Binary.Definitions using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
 
 module Data.List.Relation.Unary.Unique.DecPropositional
   {a} {A : Set a} (_≟_ : DecidableEquality A) where
diff --git a/src/Data/List/Relation/Unary/Unique/DecPropositional/Properties.agda b/src/Data/List/Relation/Unary/Unique/DecPropositional/Properties.agda
index 7512f05246..44039ab152 100644
--- a/src/Data/List/Relation/Unary/Unique/DecPropositional/Properties.agda
+++ b/src/Data/List/Relation/Unary/Unique/DecPropositional/Properties.agda
@@ -6,17 +6,17 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.List
-import Data.List.Relation.Unary.Unique.DecSetoid.Properties as Setoid
-open import Data.List.Relation.Unary.All.Properties using (all-filter)
-open import Level
-open import Relation.Binary using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (decSetoid)
+open import Relation.Binary.Definitions using (DecidableEquality)
 
 module Data.List.Relation.Unary.Unique.DecPropositional.Properties
   {a} {A : Set a} (_≟_ : DecidableEquality A) where
 
+open import Data.List.Base using (deduplicate)
+open import Data.List.Relation.Unary.All.Properties using (all-filter)
 open import Data.List.Relation.Unary.Unique.DecPropositional _≟_
+import Data.List.Relation.Unary.Unique.DecSetoid.Properties as Setoid
+open import Level
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
 
 ------------------------------------------------------------------------
 -- Re-export propositional properties
diff --git a/src/Data/List/Relation/Unary/Unique/DecSetoid.agda b/src/Data/List/Relation/Unary/Unique/DecSetoid.agda
index 4b7133c8f1..bddc7b2727 100644
--- a/src/Data/List/Relation/Unary/Unique/DecSetoid.agda
+++ b/src/Data/List/Relation/Unary/Unique/DecSetoid.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (DecSetoid)
+open import Relation.Binary.Bundles using (DecSetoid)
 import Data.List.Relation.Unary.AllPairs as AllPairs
 open import Relation.Unary using (Decidable)
 open import Relation.Nullary.Decidable using (¬?)
diff --git a/src/Data/List/Relation/Unary/Unique/DecSetoid/Properties.agda b/src/Data/List/Relation/Unary/Unique/DecSetoid/Properties.agda
index 8945b2f220..73d42b7b8a 100644
--- a/src/Data/List/Relation/Unary/Unique/DecSetoid/Properties.agda
+++ b/src/Data/List/Relation/Unary/Unique/DecSetoid/Properties.agda
@@ -6,13 +6,12 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.List
+open import Data.List.Base using ([]; _∷_; deduplicate)
 import Data.List.Relation.Unary.Unique.DecSetoid as Unique
 open import Data.List.Relation.Unary.All.Properties using (all-filter)
 open import Data.List.Relation.Unary.Unique.Setoid.Properties
 open import Level
-open import Relation.Binary using (DecSetoid)
-open import Relation.Nullary.Decidable using (¬?)
+open import Relation.Binary.Bundles using (DecSetoid)
 
 module Data.List.Relation.Unary.Unique.DecSetoid.Properties where
 
@@ -30,5 +29,4 @@ module _ (DS : DecSetoid a ℓ) where
 
   deduplicate-! : ∀ xs → Unique (deduplicate _≟_ xs)
   deduplicate-! []       = []
-  deduplicate-! (x ∷ xs) = all-filter (λ y → ¬? (x ≟ y)) (deduplicate _≟_ xs)
-                         ∷ filter⁺ S  (λ y → ¬? (x ≟ y)) (deduplicate-! xs)
+  deduplicate-! (x ∷ xs) = all-filter _ (deduplicate _≟_ xs) ∷ filter⁺ S _ (deduplicate-! xs)
diff --git a/src/Data/List/Relation/Unary/Unique/Propositional.agda b/src/Data/List/Relation/Unary/Unique/Propositional.agda
index 4e3b600d2e..2c32f0da46 100644
--- a/src/Data/List/Relation/Unary/Unique/Propositional.agda
+++ b/src/Data/List/Relation/Unary/Unique/Propositional.agda
@@ -8,7 +8,7 @@
 
 module Data.List.Relation.Unary.Unique.Propositional {a} {A : Set a} where
 
-open import Relation.Binary.PropositionalEquality using (setoid)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 open import Data.List.Relation.Unary.Unique.Setoid as SetoidUnique
 
 ------------------------------------------------------------------------
diff --git a/src/Data/List/Relation/Unary/Unique/Propositional/Properties.agda b/src/Data/List/Relation/Unary/Unique/Propositional/Properties.agda
index a223a2c9cc..bcd7df1176 100644
--- a/src/Data/List/Relation/Unary/Unique/Propositional/Properties.agda
+++ b/src/Data/List/Relation/Unary/Unique/Propositional/Properties.agda
@@ -8,22 +8,27 @@
 
 module Data.List.Relation.Unary.Unique.Propositional.Properties where
 
-open import Data.List.Base
+open import Data.List.Base using (map; _++_; concat; cartesianProductWith;
+  cartesianProduct; drop; take; applyUpTo; upTo; applyDownFrom; downFrom;
+  tabulate; allFin; filter)
 open import Data.List.Relation.Binary.Disjoint.Propositional
+  using (Disjoint)
 open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
 open import Data.List.Relation.Unary.AllPairs as AllPairs using (AllPairs)
-open import Data.List.Relation.Unary.Unique.Propositional
+open import Data.List.Relation.Unary.Unique.Propositional using (Unique)
 import Data.List.Relation.Unary.Unique.Setoid.Properties as Setoid
 open import Data.Fin.Base using (Fin)
 open import Data.Nat.Base using (_<_)
 open import Data.Nat.Properties using (<⇒≢)
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent using (≡⇒≡×≡)
 open import Function.Base using (id; _∘_)
 open import Level using (Level)
-open import Relation.Binary using (Rel; Setoid)
-open import Relation.Binary.PropositionalEquality
-  using (refl; _≡_; _≢_; sym; setoid)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Core
+  using (refl; _≡_; _≢_; sym)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 open import Relation.Unary using (Pred; Decidable)
 open import Relation.Nullary.Negation using (¬_)
 
diff --git a/src/Data/List/Relation/Unary/Unique/Setoid.agda b/src/Data/List/Relation/Unary/Unique/Setoid.agda
index aad10762ac..041b68ec9b 100644
--- a/src/Data/List/Relation/Unary/Unique/Setoid.agda
+++ b/src/Data/List/Relation/Unary/Unique/Setoid.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; Setoid)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
 open import Relation.Nullary.Negation using (¬_)
 
 module Data.List.Relation.Unary.Unique.Setoid {a ℓ} (S : Setoid a ℓ) where
diff --git a/src/Data/List/Relation/Unary/Unique/Setoid/Properties.agda b/src/Data/List/Relation/Unary/Unique/Setoid/Properties.agda
index a7413994ba..ffb587018a 100644
--- a/src/Data/List/Relation/Unary/Unique/Setoid/Properties.agda
+++ b/src/Data/List/Relation/Unary/Unique/Setoid/Properties.agda
@@ -16,15 +16,16 @@ open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
 open import Data.List.Relation.Unary.All.Properties using (All¬⇒¬Any)
 open import Data.List.Relation.Unary.AllPairs as AllPairs using (AllPairs)
 open import Data.List.Relation.Unary.Unique.Setoid
-open import Data.Product using (_×_; _,_; proj₁; proj₂)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent using (_×ₛ_)
 import Data.List.Relation.Unary.AllPairs.Properties as AllPairs
 open import Data.Fin.Base using (Fin)
 open import Data.Nat.Base using (_<_)
 open import Function.Base using (_∘_; id)
 open import Level using (Level)
-open import Relation.Binary using (Rel; Setoid)
-open import Relation.Binary.PropositionalEquality using (_≡_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 open import Relation.Unary using (Pred; Decidable)
 open import Relation.Nullary.Negation using (¬_)
 open import Relation.Nullary.Negation using (contraposition)
diff --git a/src/Data/List/Reverse.agda b/src/Data/List/Reverse.agda
index 92b2aa5b0c..a197142c3f 100644
--- a/src/Data/List/Reverse.agda
+++ b/src/Data/List/Reverse.agda
@@ -8,10 +8,12 @@
 
 module Data.List.Reverse where
 
-open import Data.List.Base as L hiding (reverse)
+open import Data.List.Base as L using (List; []; _∷_; _∷ʳ_)
 open import Data.List.Properties
-open import Function
-open import Relation.Binary.PropositionalEquality
+  using (unfold-reverse; reverse-involutive)
+open import Function.Base using (_$_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (subst; sym)
 
 -- If you want to traverse a list from the end, then you can use the
 -- reverse view of it.
diff --git a/src/Data/List/Scans/Base.agda b/src/Data/List/Scans/Base.agda
new file mode 100644
index 0000000000..73e7d794ad
--- /dev/null
+++ b/src/Data/List/Scans/Base.agda
@@ -0,0 +1,49 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- List scans: definitions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.List.Scans.Base where
+
+open import Data.List.Base as List using (List; []; _∷_)
+open import Data.List.NonEmpty.Base as List⁺ using (List⁺; _∷_; toList)
+open import Function.Base using (_∘_)
+open import Level using (Level)
+
+private
+  variable
+    a b : Level
+    A : Set a
+    B : Set b
+
+
+------------------------------------------------------------------------
+-- Definitions
+
+-- Scanr
+
+module _ (f : A → B → B) where
+
+  scanr⁺ : (e : B) → List A → List⁺ B
+  scanr⁺ e []       = e ∷ []
+  scanr⁺ e (x ∷ xs) = let y ∷ ys = scanr⁺ e xs in f x y ∷ y ∷ ys
+
+  scanr : (e : B) → List A → List B
+  scanr e = toList ∘ scanr⁺ e
+
+-- Scanl
+
+module _ (f : A → B → A) where
+
+  scanl⁺ : A → List B → List⁺ A
+  scanl⁺ e xs = e ∷ go e xs
+    where
+    go : A → List B → List A
+    go _ []       = []
+    go e (x ∷ xs) = let fex = f e x in fex ∷ go fex xs
+
+  scanl : A → List B → List A
+  scanl e = toList ∘ scanl⁺ e
diff --git a/src/Data/List/Scans/Properties.agda b/src/Data/List/Scans/Properties.agda
new file mode 100644
index 0000000000..01b2229684
--- /dev/null
+++ b/src/Data/List/Scans/Properties.agda
@@ -0,0 +1,59 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- List scans: properties
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.List.Scans.Properties where
+
+open import Data.List.Base as List using (List; []; _∷_)
+open import Data.List.NonEmpty.Base as List⁺ using (List⁺; _∷_; toList)
+import Data.List.Properties as List
+import Data.List.NonEmpty.Properties as List⁺
+open import Data.List.Scans.Base
+open import Function.Base using (_∘_; _$_)
+open import Level using (Level)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≗_; refl; trans; cong; cong₂)
+
+private
+  variable
+    a b : Level
+    A : Set a
+    B : Set b
+
+
+------------------------------------------------------------------------
+-- Properties
+
+-- scanr⁺ and scanr
+
+module _ (f : A → B → B) (e : B) where
+
+  private
+    h = List.foldr f e
+
+  scanr⁺-defn : scanr⁺ f e ≗ List⁺.map h ∘ List⁺.tails
+  scanr⁺-defn []       = refl
+  scanr⁺-defn (x ∷ xs) = let eq = scanr⁺-defn xs
+    in cong₂ (λ z → f x z ∷_) (cong List⁺.head eq) (cong toList eq)
+
+  scanr-defn : scanr f e ≗ List.map h ∘ List.tails
+  scanr-defn xs = cong toList (scanr⁺-defn xs)
+
+-- scanl⁺ and scanl
+
+module _ (f : A → B → A) where
+
+  private
+    h = List.foldl f
+
+  scanl⁺-defn : ∀ e → scanl⁺ f e ≗ List⁺.map (h e) ∘ List⁺.inits
+  scanl⁺-defn e []       = refl
+  scanl⁺-defn e (x ∷ xs) = let eq = scanl⁺-defn (f e x) xs in
+    cong (e ∷_) $ cong (f e x ∷_) $ trans (cong List⁺.tail eq) (List.map-∘ _)
+
+  scanl-defn : ∀ e → scanl f e ≗ List.map (h e) ∘ List.inits
+  scanl-defn e xs = cong toList (scanl⁺-defn e xs)
diff --git a/src/Data/List/Show.agda b/src/Data/List/Show.agda
new file mode 100644
index 0000000000..116bd82061
--- /dev/null
+++ b/src/Data/List/Show.agda
@@ -0,0 +1,16 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Showing lists
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.List.Show where
+
+open import Data.List.Base using (List; map)
+open import Data.String.Base using (String; between; intersperse)
+open import Function.Base using (_∘_)
+
+show : ∀ {a} {A : Set a} → (A → String) → (List A → String)
+show s = between "[" "]" ∘ intersperse ", " ∘ map s
diff --git a/src/Data/List/Sort.agda b/src/Data/List/Sort.agda
index d0939b4d49..acae2ce7f5 100644
--- a/src/Data/List/Sort.agda
+++ b/src/Data/List/Sort.agda
@@ -10,7 +10,7 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Data.List.Base using (List)
-open import Relation.Binary using (DecTotalOrder)
+open import Relation.Binary.Bundles using (DecTotalOrder)
 
 module Data.List.Sort
   {a ℓ₁ ℓ₂} (O : DecTotalOrder a ℓ₁ ℓ₂)
diff --git a/src/Data/List/Sort/Base.agda b/src/Data/List/Sort/Base.agda
index 0c20220e78..ae64c39bd3 100644
--- a/src/Data/List/Sort/Base.agda
+++ b/src/Data/List/Sort/Base.agda
@@ -9,7 +9,7 @@
 open import Data.List.Base using (List)
 open import Data.List.Relation.Binary.Permutation.Propositional
 open import Level using (_⊔_)
-open import Relation.Binary using (TotalOrder)
+open import Relation.Binary.Bundles using (TotalOrder)
 
 module Data.List.Sort.Base
   {a ℓ₁ ℓ₂} (totalOrder : TotalOrder a ℓ₁ ℓ₂)
diff --git a/src/Data/List/Sort/MergeSort.agda b/src/Data/List/Sort/MergeSort.agda
index 09ccdf2471..529d8623d3 100644
--- a/src/Data/List/Sort/MergeSort.agda
+++ b/src/Data/List/Sort/MergeSort.agda
@@ -10,8 +10,13 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Bool using (true; false)
+open import Relation.Binary.Bundles using (DecTotalOrder)
+
+module Data.List.Sort.MergeSort
+  {a ℓ₁ ℓ₂} (O : DecTotalOrder a ℓ₁ ℓ₂) where
+open import Data.Bool.Base using (true; false)
 open import Data.List.Base
+  using (List; []; _∷_; merge; length; map; [_]; concat; _++_)
 open import Data.List.Properties using (length-partition; ++-assoc; concat-[-])
 open import Data.List.Relation.Unary.Linked using ([]; [-])
 import Data.List.Relation.Unary.Sorted.TotalOrder.Properties as Sorted
@@ -20,23 +25,19 @@ import Data.List.Relation.Unary.All.Properties as All
 open import Data.List.Relation.Binary.Permutation.Propositional
 import Data.List.Relation.Binary.Permutation.Propositional.Properties as Perm
 open import Data.Maybe.Base using (just)
-open import Relation.Nullary.Decidable using (does)
-open import Data.Nat using (_<_; _>_; z<s; s<s)
+open import Data.Nat.Base using (_<_; _>_; z<s; s<s)
 open import Data.Nat.Induction
 open import Data.Nat.Properties using (m<n⇒m<1+n)
-open import Data.Product as Prod using (_,_)
+open import Data.Product.Base as Product using (_,_)
 open import Function.Base using (_∘_)
-open import Relation.Binary using (DecTotalOrder)
-open import Relation.Nullary.Negation using (¬_)
-
-module Data.List.Sort.MergeSort
-  {a ℓ₁ ℓ₂} (O : DecTotalOrder a ℓ₁ ℓ₂) where
+open import Relation.Nullary.Negation.Core using (¬_)
+open import Relation.Nullary.Decidable.Core using (does)
 
 open DecTotalOrder O renaming (Carrier to A)
 
 open import Data.List.Sort.Base totalOrder
 open import Data.List.Relation.Unary.Sorted.TotalOrder totalOrder hiding (head)
-open import Relation.Binary.Properties.DecTotalOrder O using (_≰_; ≰⇒≥; ≰-respˡ-≈)
+open import Relation.Binary.Properties.DecTotalOrder O using (≰⇒≥; ≰-respˡ-≈)
 
 open PermutationReasoning
 
@@ -44,20 +45,21 @@ open PermutationReasoning
 -- Definition
 
 mergePairs : List (List A) → List (List A)
-mergePairs (xs ∷ ys ∷ xss) = merge _≤?_ xs ys ∷ mergePairs xss
+mergePairs (xs ∷ ys ∷ yss) = merge _≤?_ xs ys ∷ mergePairs yss
 mergePairs xss             = xss
 
 private
-  length-mergePairs : ∀ xs ys xss → length (mergePairs (xs ∷ ys ∷ xss)) < length (xs ∷ ys ∷ xss)
+  length-mergePairs : ∀ xs ys yss → let zss = xs ∷ ys ∷ yss in
+                      length (mergePairs zss) < length zss
   length-mergePairs _ _ []              = s<s z<s
-  length-mergePairs _ _ (xss ∷ [])      = s<s (s<s z<s)
-  length-mergePairs _ _ (xs ∷ ys ∷ xss) = s<s (m<n⇒m<1+n (length-mergePairs xs ys xss))
+  length-mergePairs _ _ (xs ∷ [])       = s<s (s<s z<s)
+  length-mergePairs _ _ (xs ∷ ys ∷ yss) = s<s (m<n⇒m<1+n (length-mergePairs xs ys yss))
 
 mergeAll : (xss : List (List A)) → Acc _<_ (length xss) → List A
 mergeAll []        _               = []
 mergeAll (xs ∷ []) _               = xs
-mergeAll (xs ∷ ys ∷ xss) (acc rec) = mergeAll
-  (mergePairs (xs ∷ ys ∷ xss)) (rec _ (length-mergePairs xs ys xss))
+mergeAll xss@(xs ∷ ys ∷ yss) (acc rec) = mergeAll
+  (mergePairs xss) (rec (length-mergePairs xs ys yss))
 
 sort : List A → List A
 sort xs = mergeAll (map [_] xs) (<-wellFounded-fast _)
diff --git a/src/Data/List/Zipper.agda b/src/Data/List/Zipper.agda
index 86f122e522..e2cc769ed2 100644
--- a/src/Data/List/Zipper.agda
+++ b/src/Data/List/Zipper.agda
@@ -11,7 +11,7 @@ module Data.List.Zipper where
 open import Data.Nat.Base
 open import Data.Maybe.Base as Maybe using (Maybe ; just ; nothing)
 open import Data.List.Base as List using (List ; [] ; _∷_)
-open import Function
+open import Function.Base using (_on_; flip)
 
 
 -- Definition
diff --git a/src/Data/List/Zipper/Properties.agda b/src/Data/List/Zipper/Properties.agda
index 3e3dea85d2..1548b5bde4 100644
--- a/src/Data/List/Zipper/Properties.agda
+++ b/src/Data/List/Zipper/Properties.agda
@@ -11,11 +11,16 @@ module Data.List.Zipper.Properties where
 open import Data.List.Base as List using (List ; [] ; _∷_)
 open import Data.List.Properties
 open import Data.List.Zipper
+  using (Zipper; toList; left; right; mkZipper; reverse; _ˡ++_; _ʳ++_;
+         _++ˡ_; _++ʳ_; map; foldr)
 open import Data.Maybe.Base using (Maybe; just; nothing)
 open import Data.Maybe.Relation.Unary.All using (All; just; nothing)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; sym)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open ≡-Reasoning
-open import Function
+open import Function.Base using (_on_; _$′_; _$_; flip)
 
 -- Invariant: Zipper represents a given list
 ------------------------------------------------------------------------
diff --git a/src/Data/Maybe.agda b/src/Data/Maybe.agda
index f39d35d2ff..d3f78a7d78 100644
--- a/src/Data/Maybe.agda
+++ b/src/Data/Maybe.agda
@@ -9,10 +9,10 @@
 module Data.Maybe where
 
 open import Data.Empty using (⊥)
-open import Data.Unit using (⊤)
+open import Data.Unit.Base using (⊤)
 open import Data.Bool.Base using (T)
-open import Data.Maybe.Relation.Unary.All
-open import Data.Maybe.Relation.Unary.Any
+open import Data.Maybe.Relation.Unary.All using (All)
+open import Data.Maybe.Relation.Unary.Any using (Any; just)
 open import Level using (Level)
 
 private
diff --git a/src/Data/Maybe/Base.agda b/src/Data/Maybe/Base.agda
index 0cb8c473bf..447280b9dd 100644
--- a/src/Data/Maybe/Base.agda
+++ b/src/Data/Maybe/Base.agda
@@ -10,14 +10,13 @@
 
 module Data.Maybe.Base where
 
-open import Level
+open import Level using (Level; Lift)
 open import Data.Bool.Base using (Bool; true; false; not)
 open import Data.Unit.Base using (⊤)
 open import Data.These.Base using (These; this; that; these)
-open import Data.Product as Prod using (_×_; _,_)
-open import Function.Base
-open import Relation.Nullary.Reflects
-open import Relation.Nullary.Decidable.Core
+open import Data.Product.Base as Prod using (_×_; _,_)
+open import Function.Base using (_∘_; id; const)
+import Relation.Nullary.Decidable.Core as Dec
 
 private
   variable
@@ -46,10 +45,6 @@ is-just nothing  = false
 is-nothing : Maybe A → Bool
 is-nothing = not ∘ is-just
 
-decToMaybe : Dec A → Maybe A
-decToMaybe ( true because [a]) = just (invert [a])
-decToMaybe (false because  _ ) = nothing
-
 -- A dependent eliminator.
 
 maybe : ∀ {A : Set a} {B : Maybe A → Set b} →
@@ -137,3 +132,14 @@ thisM a = maybe′ (these a) (this a)
 
 thatM : Maybe A → B → These A B
 thatM = maybe′ these that
+
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.1
+-- decToMaybe
+
+open Dec using (decToMaybe) public
diff --git a/src/Data/Maybe/Categorical.agda b/src/Data/Maybe/Categorical.agda
new file mode 100644
index 0000000000..e6ec7a7a2c
--- /dev/null
+++ b/src/Data/Maybe/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Maybe.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Maybe.Categorical where
+
+open import Data.Maybe.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Data.Maybe.Categorical was deprecated in v2.0.
+Use Data.Maybe.Effectful instead."
+#-}
diff --git a/src/Data/Maybe/Categorical/Transformer.agda b/src/Data/Maybe/Categorical/Transformer.agda
new file mode 100644
index 0000000000..aca111a00a
--- /dev/null
+++ b/src/Data/Maybe/Categorical/Transformer.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Maybe.Effectful.Transformer` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Maybe.Categorical.Transformer where
+
+open import Data.Maybe.Effectful.Transformer public
+
+{-# WARNING_ON_IMPORT
+"Data.Maybe.Categorical.Transformer was deprecated in v2.0.
+Use Data.Maybe.Effectful.Transformer instead."
+#-}
diff --git a/src/Data/Maybe/Effectful.agda b/src/Data/Maybe/Effectful.agda
index 405b4eab42..7e0bf0216b 100644
--- a/src/Data/Maybe/Effectful.agda
+++ b/src/Data/Maybe/Effectful.agda
@@ -67,6 +67,9 @@ monad = record
   ; _>>=_ = _>>=_
   }
 
+join : Maybe (Maybe A) → Maybe A
+join = Join.join monad
+
 monadZero : RawMonadZero {f} Maybe
 monadZero = record
   { rawMonad = monad
diff --git a/src/Data/Maybe/Properties.agda b/src/Data/Maybe/Properties.agda
index 6833f301e7..2b4f1567e8 100644
--- a/src/Data/Maybe/Properties.agda
+++ b/src/Data/Maybe/Properties.agda
@@ -8,16 +8,21 @@
 
 module Data.Maybe.Properties where
 
-open import Algebra.Bundles
+open import Algebra.Bundles using (Semigroup; Monoid)
 import Algebra.Structures as Structures
 import Algebra.Definitions as Definitions
-open import Data.Maybe.Base
+open import Data.Maybe.Base using (Maybe; just; nothing; map; _<∣>_;
+  maybe; maybe′)
 open import Data.Maybe.Relation.Unary.All using (All; just; nothing)
-open import Data.Product using (_,_)
-open import Function
+open import Data.Product.Base using (_,_)
+open import Function.Base using (_∋_; id; _∘_; _∘′_)
+open import Function.Definitions using (Injective)
 open import Level using (Level)
-open import Relation.Binary using (Decidable)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂; _≗_)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (isEquivalence)
+open import Relation.Binary.Definitions using (DecidableEquality)
 open import Relation.Nullary.Decidable using (yes; no)
 open import Relation.Nullary.Decidable using (map′)
 
@@ -34,7 +39,7 @@ private
 just-injective : ∀ {x y} → (Maybe A ∋ just x) ≡ just y → x ≡ y
 just-injective refl = refl
 
-≡-dec : Decidable _≡_ → Decidable {A = Maybe A} _≡_
+≡-dec : DecidableEquality A → DecidableEquality (Maybe A)
 ≡-dec _≟_ nothing  nothing  = yes refl
 ≡-dec _≟_ (just x) nothing  = no λ()
 ≡-dec _≟_ nothing  (just y) = no λ()
diff --git a/src/Data/Maybe/Relation/Binary/Connected.agda b/src/Data/Maybe/Relation/Binary/Connected.agda
index e2fea581af..7bf8f33310 100644
--- a/src/Data/Maybe/Relation/Binary/Connected.agda
+++ b/src/Data/Maybe/Relation/Binary/Connected.agda
@@ -9,11 +9,11 @@
 module Data.Maybe.Relation.Binary.Connected where
 
 open import Level
-open import Data.Product
 open import Data.Maybe.Base using (Maybe; just; nothing)
 open import Function.Bundles using (_⇔_; mk⇔)
-open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (REL; _⇒_)
+open import Relation.Binary.Definitions using (Reflexive; Sym; Decidable)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Nullary
 import Relation.Nullary.Decidable as Dec
 
@@ -52,7 +52,7 @@ refl R-refl {just _}  = just R-refl
 refl R-refl {nothing} = nothing
 
 reflexive : _≡_ ⇒ R → _≡_ ⇒ Connected R
-reflexive reflexive P.refl = refl (reflexive P.refl)
+reflexive reflexive ≡.refl = refl (reflexive ≡.refl)
 
 sym : Sym R S → Sym (Connected R) (Connected S)
 sym R-sym (just p)     = just (R-sym p)
diff --git a/src/Data/Maybe/Relation/Binary/Pointwise.agda b/src/Data/Maybe/Relation/Binary/Pointwise.agda
index 389c1fde6e..073ac74a81 100644
--- a/src/Data/Maybe/Relation/Binary/Pointwise.agda
+++ b/src/Data/Maybe/Relation/Binary/Pointwise.agda
@@ -9,12 +9,17 @@
 module Data.Maybe.Relation.Binary.Pointwise where
 
 open import Level
-open import Data.Product
+open import Data.Product.Base using (∃; _×_; -,_; _,_)
 open import Data.Maybe.Base using (Maybe; just; nothing)
+open import Data.Maybe.Relation.Unary.Any using (Any; just)
 open import Function.Bundles using (_⇔_; mk⇔)
-open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (REL; Rel; _⇒_)
+open import Relation.Binary.Bundles using (Setoid; DecSetoid)
+open import Relation.Binary.Definitions using (Reflexive; Sym; Trans; Decidable)
+open import Relation.Binary.Structures using (IsEquivalence; IsDecEquivalence)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Nullary
+open import Relation.Unary using (_⊆_)
 import Relation.Nullary.Decidable as Dec
 
 ------------------------------------------------------------------------
@@ -38,10 +43,10 @@ module _ {a b ℓ} {A : Set a} {B : Set b} {R : REL A B ℓ} where
   just-equivalence = mk⇔ just drop-just
 
   nothing-inv : ∀ {x} → Pointwise R nothing x → x ≡ nothing
-  nothing-inv nothing = P.refl
+  nothing-inv nothing = ≡.refl
 
   just-inv : ∀ {x y} → Pointwise R (just x) y → ∃ λ z → y ≡ just z × R x z
-  just-inv (just r) = -, P.refl , r
+  just-inv (just r) = -, ≡.refl , r
 
 ------------------------------------------------------------------------
 -- Relational properties
@@ -53,7 +58,7 @@ module _ {a r} {A : Set a} {R : Rel A r} where
   refl R-refl {nothing} = nothing
 
   reflexive : _≡_ ⇒ R → _≡_ ⇒ Pointwise R
-  reflexive reflexive P.refl = refl (reflexive P.refl)
+  reflexive reflexive ≡.refl = refl (reflexive ≡.refl)
 
 module _ {a b r₁ r₂} {A : Set a} {B : Set b}
          {R : REL A B r₁} {S : REL B A r₂} where
@@ -90,6 +95,9 @@ module _ {a r} {A : Set a} {R : Rel A r} where
     ; _≟_           = dec R._≟_
     } where module R = IsDecEquivalence R-isDecEquivalence
 
+  pointwise⊆any : ∀ {x} → Pointwise R (just x) ⊆ Any (R x)
+  pointwise⊆any (just Rxy) = just Rxy
+
 module _ {c ℓ} where
 
   setoid : Setoid c ℓ → Setoid c (c ⊔ ℓ)
diff --git a/src/Data/Maybe/Relation/Unary/All.agda b/src/Data/Maybe/Relation/Unary/All.agda
index 0c2c3faecd..f26a261f42 100644
--- a/src/Data/Maybe/Relation/Unary/All.agda
+++ b/src/Data/Maybe/Relation/Unary/All.agda
@@ -12,11 +12,11 @@ open import Effect.Applicative
 open import Effect.Monad
 open import Data.Maybe.Base using (Maybe; just; nothing)
 open import Data.Maybe.Relation.Unary.Any using (Any; just)
-open import Data.Product as Prod using (_,_)
+open import Data.Product.Base as Product using (_,_)
 open import Function.Base using (id; _∘′_)
 open import Function.Bundles using (_⇔_; mk⇔)
 open import Level
-open import Relation.Binary.PropositionalEquality as P using (_≡_; cong)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
 open import Relation.Unary
 open import Relation.Nullary hiding (Irrelevant)
 import Relation.Nullary.Decidable as Dec
@@ -56,7 +56,7 @@ module _ {a p q r} {A : Set a} {P : Pred A p} {Q : Pred A q} {R : Pred A r} wher
   zipWith f (nothing , nothing) = nothing
 
   unzipWith : P ⊆ Q ∩ R → All P ⊆ All Q ∩ All R
-  unzipWith f (just px) = Prod.map just just (f px)
+  unzipWith f (just px) = Product.map just just (f px)
   unzipWith f nothing   = nothing , nothing
 
 module _ {a p q} {A : Set a} {P : Pred A p} {Q : Pred A q} where
@@ -114,7 +114,7 @@ module _ {a p} {A : Set a} {P : Pred A p} where
 
   irrelevant : Irrelevant P → Irrelevant (All P)
   irrelevant P-irrelevant (just p) (just q) = cong just (P-irrelevant p q)
-  irrelevant P-irrelevant nothing  nothing  = P.refl
+  irrelevant P-irrelevant nothing  nothing  = refl
 
   satisfiable : Satisfiable (All P)
   satisfiable = nothing , nothing
diff --git a/src/Data/Maybe/Relation/Unary/All/Properties.agda b/src/Data/Maybe/Relation/Unary/All/Properties.agda
index 37d55adf0a..6c494632f1 100644
--- a/src/Data/Maybe/Relation/Unary/All/Properties.agda
+++ b/src/Data/Maybe/Relation/Unary/All/Properties.agda
@@ -12,8 +12,8 @@ open import Data.Maybe.Base
 open import Data.Maybe.Relation.Unary.All as All
   using (All; nothing; just)
 open import Data.Maybe.Relation.Binary.Connected
-open import Data.Product using (_×_; _,_)
-open import Function
+open import Data.Product.Base using (_×_; _,_)
+open import Function.Base using (_∘_)
 open import Level
 open import Relation.Unary
 open import Relation.Binary.Core
diff --git a/src/Data/Maybe/Relation/Unary/Any.agda b/src/Data/Maybe/Relation/Unary/Any.agda
index 61a06e840a..d379ce2998 100644
--- a/src/Data/Maybe/Relation/Unary/Any.agda
+++ b/src/Data/Maybe/Relation/Unary/Any.agda
@@ -9,11 +9,11 @@
 module Data.Maybe.Relation.Unary.Any where
 
 open import Data.Maybe.Base using (Maybe; just; nothing)
-open import Data.Product as Prod using (∃; _,_; -,_)
+open import Data.Product.Base as Product using (∃; _,_; -,_)
 open import Function.Base using (id)
 open import Function.Bundles using (_⇔_; mk⇔)
 open import Level
-open import Relation.Binary.PropositionalEquality as P using (_≡_; cong)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong)
 open import Relation.Unary
 open import Relation.Nullary hiding (Irrelevant)
 import Relation.Nullary.Decidable as Dec
@@ -50,7 +50,7 @@ module _ {a p q r} {A : Set a} {P : Pred A p} {Q : Pred A q} {R : Pred A r} wher
   zipWith f (just px , just qx) = just (f (px , qx))
 
   unzipWith : P ⊆ Q ∩ R → Any P ⊆ Any Q ∩ Any R
-  unzipWith f (just px) = Prod.map just just (f px)
+  unzipWith f (just px) = Product.map just just (f px)
 
 module _ {a p q} {A : Set a} {P : Pred A p} {Q : Pred A q} where
 
@@ -73,4 +73,4 @@ module _ {a p} {A : Set a} {P : Pred A p} where
   irrelevant P-irrelevant (just p) (just q) = cong just (P-irrelevant p q)
 
   satisfiable : Satisfiable P → Satisfiable (Any P)
-  satisfiable P-satisfiable = Prod.map just just P-satisfiable
+  satisfiable P-satisfiable = Product.map just just P-satisfiable
diff --git a/src/Data/Nat.agda b/src/Data/Nat.agda
index 1abd7d9d7c..8811565c11 100644
--- a/src/Data/Nat.agda
+++ b/src/Data/Nat.agda
@@ -42,5 +42,8 @@ open import Data.Nat.Properties public
 
 -- Version 0.17
 
+-- Version 2.0
+
+-- solely for the re-export of this name, formerly in `Data.Nat.Properties.Core`
 open import Data.Nat.Properties public
   using (≤-pred)
diff --git a/src/Data/Nat/Base.agda b/src/Data/Nat/Base.agda
index 1e2db666b8..db46274f24 100644
--- a/src/Data/Nat/Base.agda
+++ b/src/Data/Nat/Base.agda
@@ -12,6 +12,7 @@
 module Data.Nat.Base where
 
 open import Algebra.Bundles.Raw using (RawMagma; RawMonoid; RawNearSemiring; RawSemiring)
+open import Algebra.Definitions.RawMagma using (_∣ˡ_; _,_)
 open import Data.Bool.Base using (Bool; true; false; T; not)
 open import Data.Parity.Base using (Parity; 0ℙ; 1ℙ)
 open import Level using (0ℓ)
@@ -19,6 +20,7 @@ open import Relation.Binary.Core using (Rel)
 open import Relation.Binary.PropositionalEquality.Core
   using (_≡_; _≢_; refl)
 open import Relation.Nullary.Negation.Core using (¬_; contradiction)
+open import Relation.Unary using (Pred)
 
 ------------------------------------------------------------------------
 -- Types
@@ -26,6 +28,9 @@ open import Relation.Nullary.Negation.Core using (¬_; contradiction)
 open import Agda.Builtin.Nat public
   using (zero; suc) renaming (Nat to ℕ)
 
+--smart constructor
+pattern 2+ n = suc (suc n)
+
 ------------------------------------------------------------------------
 -- Boolean equality relation
 
@@ -57,11 +62,21 @@ m < n = suc m ≤ n
 
 -- Smart constructors of _<_
 
-pattern z<s {n}         = s≤s (z≤n {n})
+pattern z<s     {n}     = s≤s (z≤n {n})
 pattern s<s {m} {n} m<n = s≤s {m} {n} m<n
+pattern sz<ss   {n}     = s<s (z<s {n})
+
+-- Smart destructors of _≤_, _<_
+
+s≤s⁻¹ : ∀ {m n} → suc m ≤ suc n → m ≤ n
+s≤s⁻¹ (s≤s m≤n) = m≤n
+
+s<s⁻¹ : ∀ {m n} → suc m < suc n → m < n
+s<s⁻¹ (s<s m<n) = m<n
+
 
 ------------------------------------------------------------------------
--- other ordering relations
+-- Other derived ordering relations
 
 _≥_ : Rel ℕ 0ℓ
 m ≥ n = n ≤ m
@@ -84,13 +99,19 @@ a ≯ b = ¬ a > b
 ------------------------------------------------------------------------
 -- Simple predicates
 
--- Defining `NonZero` in terms of `T` and therefore ultimately `⊤` and
--- `⊥` allows Agda to automatically infer nonZero-ness for any natural
--- of the form `suc n`. Consequently in many circumstances this
--- eliminates the need to explicitly pass a proof when the NonZero
--- argument is either an implicit or an instance argument.
+-- Defining these predicates in terms of `T` and therefore ultimately
+-- `⊤` and `⊥` allows Agda to automatically infer them for any natural
+-- of the correct form. Consequently in many circumstances this
+-- eliminates the need to explicitly pass a proof when the predicate
+-- argument is either an implicit or an instance argument. See `_/_`
+-- and `_%_` further down this file for examples.
 --
--- See `Data.Nat.DivMod` for an example.
+-- Furthermore, defining these predicates as single-field records
+-- (rather defining them directly as the type of their field) is
+-- necessary as the current version of Agda is far better at
+-- reconstructing meta-variable values for the record parameters.
+
+-- A predicate saying that a number is not equal to 0.
 
 record NonZero (n : ℕ) : Set where
   field
@@ -119,12 +140,88 @@ instance
 >-nonZero⁻¹ : ∀ n → .{{NonZero n}} → n > 0
 >-nonZero⁻¹ (suc n) = z<s
 
+-- The property of being a non-zero, non-unit
+
+record NonTrivial (n : ℕ) : Set where
+  field
+    nonTrivial : T (1 <ᵇ n)
+
+-- Instances
+
+instance
+  nonTrivial : ∀ {n} → NonTrivial (2+ n)
+  nonTrivial = _
+
+-- Constructors
+
+n>1⇒nonTrivial : ∀ {n} → n > 1 → NonTrivial n
+n>1⇒nonTrivial sz<ss = _
+
+-- Destructors
+
+nonTrivial⇒nonZero : ∀ n → .{{NonTrivial n}} → NonZero n
+nonTrivial⇒nonZero (2+ _) = _
+
+nonTrivial⇒n>1 : ∀ n → .{{NonTrivial n}} → n > 1
+nonTrivial⇒n>1 (2+ _) = sz<ss
+
+nonTrivial⇒≢1 : ∀ {n} → .{{NonTrivial n}} → n ≢ 1
+nonTrivial⇒≢1 {{()}} refl
+
 ------------------------------------------------------------------------
--- Arithmetic
+-- Raw bundles
 
 open import Agda.Builtin.Nat public
   using (_+_; _*_) renaming (_-_ to _∸_)
 
++-rawMagma : RawMagma 0ℓ 0ℓ
++-rawMagma = record
+  { _≈_ = _≡_
+  ; _∙_ = _+_
+  }
+
++-0-rawMonoid : RawMonoid 0ℓ 0ℓ
++-0-rawMonoid = record
+  { _≈_ = _≡_
+  ; _∙_ = _+_
+  ; ε   = 0
+  }
+
+*-rawMagma : RawMagma 0ℓ 0ℓ
+*-rawMagma = record
+  { _≈_ = _≡_
+  ; _∙_ = _*_
+  }
+
+*-1-rawMonoid : RawMonoid 0ℓ 0ℓ
+*-1-rawMonoid = record
+  { _≈_ = _≡_
+  ; _∙_ = _*_
+  ; ε = 1
+  }
+
++-*-rawNearSemiring : RawNearSemiring 0ℓ 0ℓ
++-*-rawNearSemiring = record
+  { Carrier = _
+  ; _≈_ = _≡_
+  ; _+_ = _+_
+  ; _*_ = _*_
+  ; 0# = 0
+  }
+
++-*-rawSemiring : RawSemiring 0ℓ 0ℓ
++-*-rawSemiring = record
+  { Carrier = _
+  ; _≈_ = _≡_
+  ; _+_ = _+_
+  ; _*_ = _*_
+  ; 0# = 0
+  ; 1# = 1
+  }
+
+------------------------------------------------------------------------
+-- Arithmetic
+
 open import Agda.Builtin.Nat
   using (div-helper; mod-helper)
 
@@ -132,8 +229,8 @@ pred : ℕ → ℕ
 pred n = n ∸ 1
 
 infix  8 _!
-infixl 7 _⊓_ _/_ _%_
-infixl 6 _+⋎_ _⊔_
+infixl 7 _⊓_ _⊓′_ _/_ _%_
+infixl 6 _+⋎_ _⊔_ _⊔′_
 
 -- Argument-swapping addition. Used by Data.Vec._⋎_.
 
@@ -192,6 +289,8 @@ parity (suc (suc n)) = parity n
 
 -- Naïve exponentiation
 
+infixr 8 _^_
+
 _^_ : ℕ → ℕ → ℕ
 x ^ zero  = 1
 x ^ suc n = x * x ^ n
@@ -204,8 +303,8 @@ x ^ suc n = x * x ^ n
 ∣ suc x - suc y ∣ = ∣ x - y ∣
 
 -- Distance in terms of primitive operations.
--- This is much faster than `∣_-_∣` but harder to reason about. For proofs
--- involving this function, convert it to `∣_-_∣` with
+-- This is much faster than `∣_-_∣` but harder to reason about.
+-- For proofs involving this function, convert it to `∣_-_∣` with
 -- `Data.Nat.Properties.∣-∣≡∣-∣′`.
 ∣_-_∣′ : ℕ → ℕ → ℕ
 ∣ x - y ∣′ with x <ᵇ y
@@ -231,10 +330,10 @@ zero  ! = 1
 suc n ! = suc n * n !
 
 ------------------------------------------------------------------------
--- Alternative definition of _≤_
+-- Extensionally equivalent alternative definitions of _≤_/_<_ etc.
 
--- The following definition of _≤_ is more suitable for well-founded
--- induction (see Data.Nat.Induction)
+-- _≤′_: this definition is more suitable for well-founded induction
+-- (see Data.Nat.Induction)
 
 infix 4 _≤′_ _<′_ _≥′_ _>′_
 
@@ -256,17 +355,14 @@ m ≥′ n = n ≤′ m
 _>′_ : Rel ℕ 0ℓ
 m >′ n = n <′ m
 
-------------------------------------------------------------------------
--- Another alternative definition of _≤_
-
-record _≤″_ (m n : ℕ) : Set where
-  constructor less-than-or-equal
-  field
-    {k}   : ℕ
-    proof : m + k ≡ n
+-- _≤″_: this definition of _≤_ is used for proof-irrelevant ‵DivMod`
+-- and is a specialised instance of a general algebraic construction
 
 infix 4 _≤″_ _<″_ _≥″_ _>″_
 
+_≤″_ : (m n : ℕ)  → Set
+_≤″_ = _∣ˡ_ +-rawMagma
+
 _<″_ : Rel ℕ 0ℓ
 m <″ n = suc m ≤″ n
 
@@ -276,10 +372,12 @@ m ≥″ n = n ≤″ m
 _>″_ : Rel ℕ 0ℓ
 m >″ n = n <″ m
 
-------------------------------------------------------------------------
--- Another alternative definition of _≤_
+-- Smart destructor of _<″_
+
+s<″s⁻¹ : ∀ {m n} → suc m <″ suc n → m <″ n
+s<″s⁻¹ (k , refl) = k , refl
 
--- Useful for induction when you have an upper bound.
+-- _≤‴_: this definition is useful for induction with an upper bound.
 
 data _≤‴_ : ℕ → ℕ → Set where
   ≤‴-refl : ∀{m} → m ≤‴ m
@@ -314,51 +412,33 @@ compare (suc m) (suc n) with compare m n
 ... | equal   m   = equal (suc m)
 ... | greater n k = greater (suc n) k
 
-------------------------------------------------------------------------
--- Raw bundles
-
-+-rawMagma : RawMagma 0ℓ 0ℓ
-+-rawMagma = record
-  { _≈_ = _≡_
-  ; _∙_ = _+_
-  }
-
-+-0-rawMonoid : RawMonoid 0ℓ 0ℓ
-+-0-rawMonoid = record
-  { _≈_ = _≡_
-  ; _∙_ = _+_
-  ; ε   = 0
-  }
-
-*-rawMagma : RawMagma 0ℓ 0ℓ
-*-rawMagma = record
-  { _≈_ = _≡_
-  ; _∙_ = _*_
-  }
-
-*-1-rawMonoid : RawMonoid 0ℓ 0ℓ
-*-1-rawMonoid = record
-  { _≈_ = _≡_
-  ; _∙_ = _*_
-  ; ε = 1
-  }
-
-+-*-rawNearSemiring : RawNearSemiring 0ℓ 0ℓ
-+-*-rawNearSemiring = record
-  { Carrier = _
-  ; _≈_ = _≡_
-  ; _+_ = _+_
-  ; _*_ = _*_
-  ; 0# = 0
-  }
-
-+-*-rawSemiring : RawSemiring 0ℓ 0ℓ
-+-*-rawSemiring = record
-  { Carrier = _
-  ; _≈_ = _≡_
-  ; _+_ = _+_
-  ; _*_ = _*_
-  ; 0# = 0
-  ; 1# = 1
-  }
 
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.1
+
+-- Smart constructors of _≤″_ and _<″_
+pattern less-than-or-equal {k} eq = k , eq
+{-# WARNING_ON_USAGE less-than-or-equal
+"Warning: less-than-or-equal was deprecated in v2.1. Please match directly on proofs of ≤″ using constructor Algebra.Definitions.RawMagma._∣ˡ_._,_ instead. "
+#-}
+pattern ≤″-offset k = k , refl
+{-# WARNING_ON_USAGE ≤″-offset
+"Warning: ≤″-offset was deprecated in v2.1. Please match directly on proofs of ≤″ using pattern (_, refl) from Algebra.Definitions.RawMagma._∣ˡ_ instead. "
+#-}
+pattern <″-offset k = k , refl
+{-# WARNING_ON_USAGE <″-offset
+"Warning: <″-offset was deprecated in v2.1. Please match directly on proofs of ≤″ using pattern (_, refl) from Algebra.Definitions.RawMagma._∣ˡ_ instead. "
+#-}
+
+-- Smart destructors of _<″_
+
+s≤″s⁻¹ : ∀ {m n} → suc m ≤″ suc n → m ≤″ n
+s≤″s⁻¹ (k , refl) = k , refl
+{-# WARNING_ON_USAGE s≤″s⁻¹
+"Warning: s≤″s⁻¹ was deprecated in v2.1. Please match directly on proofs of ≤″ using pattern (_, refl) from Algebra.Definitions.RawMagma._∣ˡ_ instead. "
+#-}
diff --git a/src/Data/Nat/Binary/Properties.agda b/src/Data/Nat/Binary/Properties.agda
index 5cf86313c3..4669e479d9 100644
--- a/src/Data/Nat/Binary/Properties.agda
+++ b/src/Data/Nat/Binary/Properties.agda
@@ -11,36 +11,45 @@ module Data.Nat.Binary.Properties where
 open import Algebra.Bundles
 open import Algebra.Morphism.Structures
 import Algebra.Morphism.MonoidMonomorphism as MonoidMonomorphism
-open import Algebra.Consequences.Propositional
+open import Algebra.Consequences.Propositional using (comm∧distrˡ⇒distrʳ)
 open import Data.Bool.Base using (if_then_else_; Bool; true; false)
 open import Data.Maybe.Base using (Maybe; just; nothing)
 open import Data.Nat.Binary.Base
-open import Data.Nat as ℕ using (ℕ; z≤n; s≤s)
+open import Data.Nat.Base as ℕ using (ℕ; z≤n; s≤s; s<s⁻¹)
 open import Data.Nat.DivMod using (_%_; _/_; m/n≤m; +-distrib-/-∣ˡ)
 open import Data.Nat.Divisibility using (∣-refl)
-import Data.Nat.Base as ℕᵇ
-import Data.Nat.Properties as ℕₚ
-open import Data.Nat.Solver
-open import Data.Product using (_×_; _,_; proj₁; proj₂; ∃)
+import Data.Nat.Properties as ℕ
+open import Data.Nat.Solver using (module +-*-Solver)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂; ∃)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 open import Function.Base using (_∘_; _$_; id)
-open import Function.Definitions using (Injective)
-open import Function.Definitions.Core2 using (Surjective)
+open import Function.Definitions using (Injective; Surjective;
+  Inverseˡ; Inverseʳ; Inverseᵇ)
+open import Function.Consequences.Propositional
+ using (strictlySurjective⇒surjective; strictlyInverseˡ⇒inverseˡ;
+        strictlyInverseʳ⇒inverseʳ)
 open import Level using (0ℓ)
 open import Relation.Binary
-open import Relation.Binary.Consequences
+open import Relation.Binary.Consequences using (trans∧irr⇒asym; tri⇒dec<)
 open import Relation.Binary.Morphism
+ using (IsRelHomomorphism; IsOrderHomomorphism; IsOrderMonomorphism)
 import Relation.Binary.Morphism.OrderMonomorphism as OrderMonomorphism
-open import Relation.Binary.PropositionalEquality
-import Relation.Binary.Reasoning.Base.Triple as InequalityReasoning
+open import Relation.Binary.PropositionalEquality.Algebra
+  using (magma; isMagma)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≢_; refl; cong; cong₂; sym; _≗_; trans; ≢-sym; subst₂;
+        subst; resp₂)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (isDecEquivalence; setoid; decSetoid; module ≡-Reasoning;
+         isEquivalence)
 open import Relation.Nullary using (¬_; yes; no)
 import Relation.Nullary.Decidable as Dec
-open import Relation.Nullary.Negation using (contradiction)
+open import Relation.Nullary.Negation.Core using (contradiction)
 
 open import Algebra.Definitions {A = ℕᵇ} _≡_
 open import Algebra.Structures {A = ℕᵇ} _≡_
 import Algebra.Properties.CommutativeSemigroup as CommSemigProp
-import Algebra.Properties.CommutativeSemigroup ℕₚ.+-commutativeSemigroup
+import Algebra.Properties.CommutativeSemigroup ℕ.+-commutativeSemigroup
   as ℕ-+-semigroupProperties
 import Relation.Binary.Construct.StrictToNonStrict _≡_ _<_
   as StrictToNonStrict
@@ -68,7 +77,7 @@ infix 4  _<?_ _≟_ _≤?_
 1+[2_]-injective : Injective _≡_ _≡_ 1+[2_]
 1+[2_]-injective refl = refl
 
-_≟_ : Decidable {A = ℕᵇ} _≡_
+_≟_ : DecidableEquality ℕᵇ
 zero     ≟ zero     =  yes refl
 zero     ≟ 2[1+ _ ] =  no λ()
 zero     ≟ 1+[2 _ ] =  no λ()
@@ -95,16 +104,16 @@ zero     ≟ 1+[2 _ ] =  no λ()
 toℕ-double : ∀ x → toℕ (double x) ≡ 2 ℕ.* (toℕ x)
 toℕ-double zero     =  refl
 toℕ-double 1+[2 x ] =  cong ((2 ℕ.*_) ∘ ℕ.suc) (toℕ-double x)
-toℕ-double 2[1+ x ] =  cong (2 ℕ.*_) (sym (ℕₚ.*-distribˡ-+ 2 1 (toℕ x)))
+toℕ-double 2[1+ x ] =  cong (2 ℕ.*_) (sym (ℕ.*-distribˡ-+ 2 1 (toℕ x)))
 
 toℕ-suc : ∀ x → toℕ (suc x) ≡ ℕ.suc (toℕ x)
 toℕ-suc zero     =  refl
 toℕ-suc 2[1+ x ] =  cong (ℕ.suc ∘ (2 ℕ.*_)) (toℕ-suc x)
-toℕ-suc 1+[2 x ] =  ℕₚ.*-distribˡ-+ 2 1 (toℕ x)
+toℕ-suc 1+[2 x ] =  ℕ.*-distribˡ-+ 2 1 (toℕ x)
 
 toℕ-pred : ∀ x → toℕ (pred x) ≡ ℕ.pred (toℕ x)
 toℕ-pred zero     =  refl
-toℕ-pred 2[1+ x ] =  cong ℕ.pred $ sym $ ℕₚ.*-distribˡ-+ 2 1 (toℕ x)
+toℕ-pred 2[1+ x ] =  cong ℕ.pred $ sym $ ℕ.*-distribˡ-+ 2 1 (toℕ x)
 toℕ-pred 1+[2 x ] =  toℕ-double x
 
 toℕ-fromℕ' : toℕ ∘ fromℕ' ≗ id
@@ -117,7 +126,7 @@ toℕ-fromℕ' (ℕ.suc n) = begin
   where open ≡-Reasoning
 
 fromℕ≡fromℕ' : fromℕ ≗ fromℕ'
-fromℕ≡fromℕ' n = fromℕ-helper≡fromℕ' n n ℕₚ.≤-refl
+fromℕ≡fromℕ' n = fromℕ-helper≡fromℕ' n n ℕ.≤-refl
   where
   split : ℕᵇ → Maybe Bool × ℕᵇ
   split zero     = nothing , zero
@@ -157,9 +166,9 @@ fromℕ≡fromℕ' n = fromℕ-helper≡fromℕ' n n ℕₚ.≤-refl
   tail-homo ℕ.zero = refl
   tail-homo (ℕ.suc ℕ.zero) = refl
   tail-homo (ℕ.suc (ℕ.suc n)) = begin
-    tail (suc (fromℕ' (ℕ.suc (ℕ.suc n))))  ≡˘⟨ tail-suc (fromℕ' n) ⟩
+    tail (suc (fromℕ' (ℕ.suc (ℕ.suc n))))  ≡⟨ tail-suc (fromℕ' n) ⟨
     suc (tail (suc (fromℕ' n)))            ≡⟨ cong suc (tail-homo n) ⟩
-    fromℕ' (ℕ.suc (n / 2))                 ≡˘⟨ cong fromℕ' (+-distrib-/-∣ˡ {2} n ∣-refl) ⟩
+    fromℕ' (ℕ.suc (n / 2))                 ≡⟨ cong fromℕ' (+-distrib-/-∣ˡ {2} n ∣-refl) ⟨
     fromℕ' (ℕ.suc (ℕ.suc n) / 2)           ∎
 
   fromℕ-helper≡fromℕ' : ∀ n w → n ℕ.≤ w → fromℕ.helper n n w ≡ fromℕ' n
@@ -168,10 +177,10 @@ fromℕ≡fromℕ' n = fromℕ-helper≡fromℕ' n n ℕₚ.≤-refl
     split-injective (begin
       split (fromℕ.helper n (ℕ.suc n) (ℕ.suc w))         ≡⟨ split-if _ _ ⟩
       just (n % 2 ℕ.≡ᵇ 0) , fromℕ.helper n (n / 2) w     ≡⟨ cong (_ ,_) rec-n/2 ⟩
-      just (n % 2 ℕ.≡ᵇ 0) , fromℕ' (n / 2)               ≡˘⟨ cong₂ _,_ (head-homo n) (tail-homo n) ⟩
+      just (n % 2 ℕ.≡ᵇ 0) , fromℕ' (n / 2)               ≡⟨ cong₂ _,_ (head-homo n) (tail-homo n) ⟨
       head (fromℕ' (ℕ.suc n)) , tail (fromℕ' (ℕ.suc n))  ≡⟨⟩
       split (fromℕ' (ℕ.suc n))                           ∎)
-    where rec-n/2 = fromℕ-helper≡fromℕ' (n / 2) w (ℕₚ.≤-trans (m/n≤m n 2) n≤w)
+    where rec-n/2 = fromℕ-helper≡fromℕ' (n / 2) w (ℕ.≤-trans (m/n≤m n 2) n≤w)
 
 toℕ-fromℕ : toℕ ∘ fromℕ ≗ id
 toℕ-fromℕ n rewrite fromℕ≡fromℕ' n = toℕ-fromℕ' n
@@ -180,24 +189,24 @@ toℕ-injective : Injective _≡_ _≡_ toℕ
 toℕ-injective {zero}     {zero}     _               =  refl
 toℕ-injective {2[1+ x ]} {2[1+ y ]} 2[1+xN]≡2[1+yN] =  cong 2[1+_] x≡y
   where
-  1+xN≡1+yN = ℕₚ.*-cancelˡ-≡ (ℕ.suc _) (ℕ.suc _) 2 2[1+xN]≡2[1+yN]
+  1+xN≡1+yN = ℕ.*-cancelˡ-≡ (ℕ.suc _) (ℕ.suc _) 2 2[1+xN]≡2[1+yN]
   xN≡yN     = cong ℕ.pred 1+xN≡1+yN
   x≡y       = toℕ-injective xN≡yN
 
 toℕ-injective {2[1+ x ]} {1+[2 y ]} 2[1+xN]≡1+2yN =
-  contradiction 2[1+xN]≡1+2yN (ℕₚ.even≢odd (ℕ.suc (toℕ x)) (toℕ y))
+  contradiction 2[1+xN]≡1+2yN (ℕ.even≢odd (ℕ.suc (toℕ x)) (toℕ y))
 
 toℕ-injective {1+[2 x ]} {2[1+ y ]} 1+2xN≡2[1+yN] =
-  contradiction (sym 1+2xN≡2[1+yN]) (ℕₚ.even≢odd (ℕ.suc (toℕ y)) (toℕ x))
+  contradiction (sym 1+2xN≡2[1+yN]) (ℕ.even≢odd (ℕ.suc (toℕ y)) (toℕ x))
 
 toℕ-injective {1+[2 x ]} {1+[2 y ]} 1+2xN≡1+2yN =  cong 1+[2_] x≡y
   where
   2xN≡2yN = cong ℕ.pred 1+2xN≡1+2yN
-  xN≡yN   = ℕₚ.*-cancelˡ-≡ _ _ 2 2xN≡2yN
+  xN≡yN   = ℕ.*-cancelˡ-≡ _ _ 2 2xN≡2yN
   x≡y     = toℕ-injective xN≡yN
 
-toℕ-surjective : Surjective _≡_ toℕ
-toℕ-surjective n = (fromℕ n , toℕ-fromℕ n)
+toℕ-surjective : Surjective _≡_ _≡_ toℕ
+toℕ-surjective = strictlySurjective⇒surjective (λ n → fromℕ n , toℕ-fromℕ n)
 
 toℕ-isRelHomomorphism : IsRelHomomorphism _≡_ _≡_ toℕ
 toℕ-isRelHomomorphism = record
@@ -215,6 +224,15 @@ fromℕ-injective {x} {y} f[x]≡f[y] = begin
 fromℕ-toℕ : fromℕ ∘ toℕ ≗ id
 fromℕ-toℕ = toℕ-injective ∘ toℕ-fromℕ ∘ toℕ
 
+toℕ-inverseˡ : Inverseˡ _≡_ _≡_ toℕ fromℕ
+toℕ-inverseˡ = strictlyInverseˡ⇒inverseˡ {f⁻¹ = fromℕ} toℕ toℕ-fromℕ
+
+toℕ-inverseʳ : Inverseʳ _≡_ _≡_ toℕ fromℕ
+toℕ-inverseʳ = strictlyInverseʳ⇒inverseʳ toℕ fromℕ-toℕ
+
+toℕ-inverseᵇ : Inverseᵇ _≡_ _≡_ toℕ fromℕ
+toℕ-inverseᵇ = toℕ-inverseˡ , toℕ-inverseʳ
+
 fromℕ-pred : ∀ n → fromℕ (ℕ.pred n) ≡ pred (fromℕ n)
 fromℕ-pred n = begin
   fromℕ (ℕ.pred n)        ≡⟨ cong (fromℕ ∘ ℕ.pred) (sym (toℕ-fromℕ n)) ⟩
@@ -273,47 +291,47 @@ x≢0⇒x>0 {1+[2 _ ]} _   =  0<odd
 <⇒≤ : _<_ ⇒ _≤_
 <⇒≤ = inj₁
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _<_ and toℕ & fromℕ.
 
 toℕ-mono-< : toℕ Preserves _<_ ⟶ ℕ._<_
-toℕ-mono-< {zero}     {2[1+ _ ]} _               =  ℕₚ.0<1+n
-toℕ-mono-< {zero}     {1+[2 _ ]} _               =  ℕₚ.0<1+n
+toℕ-mono-< {zero}     {2[1+ _ ]} _               =  ℕ.0<1+n
+toℕ-mono-< {zero}     {1+[2 _ ]} _               =  ℕ.0<1+n
 toℕ-mono-< {2[1+ x ]} {2[1+ y ]} (even<even x<y) =  begin
-  ℕ.suc (2 ℕ.* (ℕ.suc xN))    ≤⟨ ℕₚ.+-monoʳ-≤ 1 (ℕₚ.*-monoʳ-≤ 2 xN<yN) ⟩
-  ℕ.suc (2 ℕ.* yN)            ≤⟨ ℕₚ.n≤1+n _ ⟩
-  2 ℕ.+ (2 ℕ.* yN)            ≡⟨ sym (ℕₚ.*-distribˡ-+ 2 1 yN) ⟩
+  ℕ.suc (2 ℕ.* (ℕ.suc xN))    ≤⟨ ℕ.+-monoʳ-≤ 1 (ℕ.*-monoʳ-≤ 2 xN<yN) ⟩
+  ℕ.suc (2 ℕ.* yN)            ≤⟨ ℕ.n≤1+n _ ⟩
+  2 ℕ.+ (2 ℕ.* yN)            ≡⟨ sym (ℕ.*-distribˡ-+ 2 1 yN) ⟩
   2 ℕ.* (ℕ.suc yN)            ∎
-  where open ℕₚ.≤-Reasoning;  xN = toℕ x;  yN = toℕ y;  xN<yN = toℕ-mono-< x<y
+  where open ℕ.≤-Reasoning;  xN = toℕ x;  yN = toℕ y;  xN<yN = toℕ-mono-< x<y
 toℕ-mono-< {2[1+ x ]} {1+[2 y ]} (even<odd x<y) =
-  ℕₚ.+-monoʳ-≤ 1 (ℕₚ.*-monoʳ-≤ 2 (toℕ-mono-< x<y))
+  ℕ.+-monoʳ-≤ 1 (ℕ.*-monoʳ-≤ 2 (toℕ-mono-< x<y))
 toℕ-mono-< {1+[2 x ]} {2[1+ y ]} (odd<even (inj₁ x<y)) =   begin
   ℕ.suc (ℕ.suc (2 ℕ.* xN))    ≡⟨⟩
-  2 ℕ.+ (2 ℕ.* xN)            ≡⟨ sym (ℕₚ.*-distribˡ-+ 2 1 xN) ⟩
-  2 ℕ.* (ℕ.suc xN)            ≤⟨ ℕₚ.*-monoʳ-≤ 2 xN<yN ⟩
-  2 ℕ.* yN                    ≤⟨ ℕₚ.*-monoʳ-≤ 2 (ℕₚ.n≤1+n _) ⟩
+  2 ℕ.+ (2 ℕ.* xN)            ≡⟨ sym (ℕ.*-distribˡ-+ 2 1 xN) ⟩
+  2 ℕ.* (ℕ.suc xN)            ≤⟨ ℕ.*-monoʳ-≤ 2 xN<yN ⟩
+  2 ℕ.* yN                    ≤⟨ ℕ.*-monoʳ-≤ 2 (ℕ.n≤1+n _) ⟩
   2 ℕ.* (ℕ.suc yN)            ∎
-  where open ℕₚ.≤-Reasoning;  xN = toℕ x;  yN = toℕ y;  xN<yN = toℕ-mono-< x<y
+  where open ℕ.≤-Reasoning;  xN = toℕ x;  yN = toℕ y;  xN<yN = toℕ-mono-< x<y
 toℕ-mono-< {1+[2 x ]} {2[1+ .x ]} (odd<even (inj₂ refl)) =
-  ℕₚ.≤-reflexive (sym (ℕₚ.*-distribˡ-+ 2 1 (toℕ x)))
-toℕ-mono-< {1+[2 x ]} {1+[2 y ]} (odd<odd x<y) =  ℕₚ.+-monoʳ-< 1 (ℕₚ.*-monoʳ-< 2 xN<yN)
+  ℕ.≤-reflexive (sym (ℕ.*-distribˡ-+ 2 1 (toℕ x)))
+toℕ-mono-< {1+[2 x ]} {1+[2 y ]} (odd<odd x<y) =  ℕ.+-monoʳ-< 1 (ℕ.*-monoʳ-< 2 xN<yN)
   where xN = toℕ x;  yN = toℕ y;  xN<yN = toℕ-mono-< x<y
 
 toℕ-cancel-< : ∀ {x y} → toℕ x ℕ.< toℕ y → x < y
 toℕ-cancel-< {zero}     {2[1+ y ]} x<y = 0<even
 toℕ-cancel-< {zero}     {1+[2 y ]} x<y = 0<odd
 toℕ-cancel-< {2[1+ x ]} {2[1+ y ]} x<y =
-  even<even (toℕ-cancel-< (ℕ.≤-pred (ℕₚ.*-cancelˡ-< 2 _ _ x<y)))
+  even<even (toℕ-cancel-< (s<s⁻¹ (ℕ.*-cancelˡ-< 2 _ _ x<y)))
 toℕ-cancel-< {2[1+ x ]} {1+[2 y ]} x<y
-  rewrite ℕₚ.*-distribˡ-+ 2 1 (toℕ x) =
-  even<odd (toℕ-cancel-< (ℕₚ.*-cancelˡ-< 2 _ _ (ℕₚ.≤-trans (s≤s (ℕₚ.n≤1+n _)) (ℕₚ.≤-pred x<y))))
-toℕ-cancel-< {1+[2 x ]} {2[1+ y ]} x<y with toℕ x ℕₚ.≟ toℕ y
+  rewrite ℕ.*-distribˡ-+ 2 1 (toℕ x) =
+  even<odd (toℕ-cancel-< (ℕ.*-cancelˡ-< 2 _ _ (ℕ.≤-trans (s≤s (ℕ.n≤1+n _)) (s<s⁻¹ x<y))))
+toℕ-cancel-< {1+[2 x ]} {2[1+ y ]} x<y with toℕ x ℕ.≟ toℕ y
 ... | yes x≡y = odd<even (inj₂ (toℕ-injective x≡y))
 ... | no  x≢y
-  rewrite ℕₚ.+-suc (toℕ y) (toℕ y ℕ.+ 0) =
-  odd<even (inj₁ (toℕ-cancel-< (ℕₚ.≤∧≢⇒< (ℕₚ.*-cancelˡ-≤ 2 (ℕₚ.+-cancelˡ-≤ 2 _ _ x<y)) x≢y)))
+  rewrite ℕ.+-suc (toℕ y) (toℕ y ℕ.+ 0) =
+  odd<even (inj₁ (toℕ-cancel-< (ℕ.≤∧≢⇒< (ℕ.*-cancelˡ-≤ 2 (ℕ.+-cancelˡ-≤ 2 _ _ x<y)) x≢y)))
 toℕ-cancel-< {1+[2 x ]} {1+[2 y ]} x<y =
-  odd<odd (toℕ-cancel-< (ℕₚ.*-cancelˡ-< 2 _ _ (ℕ.≤-pred x<y)))
+  odd<odd (toℕ-cancel-< (ℕ.*-cancelˡ-< 2 _ _ (s<s⁻¹ x<y)))
 
 fromℕ-cancel-< : ∀ {x y} → fromℕ x < fromℕ y → x ℕ.< y
 fromℕ-cancel-< = subst₂ ℕ._<_ (toℕ-fromℕ _) (toℕ-fromℕ _) ∘ toℕ-mono-<
@@ -334,7 +352,7 @@ toℕ-isMonomorphism-< = record
   ; cancel              = toℕ-cancel-<
   }
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Relational properties of _<_
 
 <-irrefl : Irreflexive _≡_ _<_
@@ -357,6 +375,9 @@ toℕ-isMonomorphism-< = record
 <-trans (odd<odd x<y) (odd<even (inj₂ refl))   =  odd<even (inj₁ x<y)
 <-trans (odd<odd x<y) (odd<odd y<z)            =  odd<odd (<-trans x<y y<z)
 
+<-asym : Asymmetric _<_
+<-asym {x} {y} = trans∧irr⇒asym refl <-trans <-irrefl {x} {y}
+
 -- Should not be implemented via the morphism `toℕ` in order to
 -- preserve O(log n) time requirement.
 <-cmp : Trichotomous _≡_ _<_
@@ -387,7 +408,7 @@ toℕ-isMonomorphism-< = record
 _<?_ : Decidable _<_
 _<?_ = tri⇒dec< <-cmp
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Structures for _<_
 
 <-isStrictPartialOrder : IsStrictPartialOrder _≡_ _<_
@@ -400,12 +421,11 @@ _<?_ = tri⇒dec< <-cmp
 
 <-isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_
 <-isStrictTotalOrder = record
-  { isEquivalence = isEquivalence
-  ; trans         = <-trans
-  ; compare       = <-cmp
+  { isStrictPartialOrder = <-isStrictPartialOrder
+  ; compare              = <-cmp
   }
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Bundles for _<_
 
 <-strictPartialOrder : StrictPartialOrder _ _ _
@@ -418,7 +438,7 @@ _<?_ = tri⇒dec< <-cmp
   { isStrictTotalOrder =  <-isStrictTotalOrder
   }
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Other properties of _<_
 
 x<2[1+x] : ∀ x → x < 2[1+ x ]
@@ -432,9 +452,9 @@ x<1+[2x] zero     = 0<odd
 x<1+[2x] 2[1+ x ] = even<odd (x<2[1+x] x)
 x<1+[2x] 1+[2 x ] = odd<odd (x<1+[2x] x)
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _≤_
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Basic properties
 
 <⇒≱ : _<_ ⇒ _≱_
@@ -468,17 +488,17 @@ x<1+[2x] 1+[2 x ] = odd<odd (x<1+[2x] x)
 x≤0⇒x≡0 : x ≤ zero → x ≡ zero
 x≤0⇒x≡0 (inj₂ x≡0) = x≡0
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _<_ and toℕ & fromℕ.
 
 fromℕ-mono-≤ : fromℕ Preserves ℕ._≤_ ⟶ _≤_
-fromℕ-mono-≤ m≤n  with ℕₚ.m≤n⇒m<n∨m≡n m≤n
+fromℕ-mono-≤ m≤n  with ℕ.m≤n⇒m<n∨m≡n m≤n
 ... | inj₁ m<n =  inj₁ (fromℕ-mono-< m<n)
 ... | inj₂ m≡n =  inj₂ (cong fromℕ m≡n)
 
 toℕ-mono-≤ : toℕ Preserves _≤_ ⟶ ℕ._≤_
-toℕ-mono-≤ (inj₁ x<y)  =  ℕₚ.<⇒≤ (toℕ-mono-< x<y)
-toℕ-mono-≤ (inj₂ refl) =  ℕₚ.≤-reflexive refl
+toℕ-mono-≤ (inj₁ x<y)  =  ℕ.<⇒≤ (toℕ-mono-< x<y)
+toℕ-mono-≤ (inj₂ refl) =  ℕ.≤-reflexive refl
 
 toℕ-cancel-≤ : ∀ {x y} → toℕ x ℕ.≤ toℕ y → x ≤ y
 toℕ-cancel-≤ = subst₂ _≤_ (fromℕ-toℕ _) (fromℕ-toℕ _) ∘ fromℕ-mono-≤
@@ -499,7 +519,7 @@ toℕ-isMonomorphism-≤ = record
   ; cancel              = toℕ-cancel-≤
   }
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Relational properties of _≤_
 
 ≤-refl : Reflexive _≤_
@@ -537,7 +557,7 @@ x ≤? y with <-cmp x y
 ... | tri> _   _   y<x = no (<⇒≱ y<x)
 
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Structures
 
 ≤-isPreorder : IsPreorder _≡_ _≤_
@@ -566,7 +586,7 @@ x ≤? y with <-cmp x y
   ; _≤?_         = _≤?_
   }
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Bundles
 
 ≤-preorder : Preorder 0ℓ 0ℓ 0ℓ
@@ -589,19 +609,25 @@ x ≤? y with <-cmp x y
   { isDecTotalOrder = ≤-isDecTotalOrder
   }
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Equational reasoning for _≤_ and _<_
 
-module ≤-Reasoning = InequalityReasoning
-  ≤-isPreorder
-  <-trans
-  (resp₂ _<_) <⇒≤
-  <-≤-trans ≤-<-trans
-  hiding (step-≈; step-≈˘)
+module ≤-Reasoning where
+
+  open import Relation.Binary.Reasoning.Base.Triple
+    ≤-isPreorder
+    <-asym
+    <-trans
+    (resp₂ _<_)
+    <⇒≤
+    <-≤-trans
+    ≤-<-trans
+    public
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨)
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _<ℕ_
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 <⇒<ℕ : ∀ {x y} → x < y → x <ℕ y
 <⇒<ℕ x<y = toℕ-mono-< x<y
@@ -621,8 +647,8 @@ module ≤-Reasoning = InequalityReasoning
 
 toℕ-homo-+ : ∀ x y → toℕ (x + y) ≡ toℕ x ℕ.+ toℕ y
 toℕ-homo-+ zero     _        = refl
-toℕ-homo-+ 2[1+ x ] zero     = cong ℕ.suc (sym (ℕₚ.+-identityʳ _))
-toℕ-homo-+ 1+[2 x ] zero     = cong ℕ.suc (sym (ℕₚ.+-identityʳ _))
+toℕ-homo-+ 2[1+ x ] zero     = cong ℕ.suc (sym (ℕ.+-identityʳ _))
+toℕ-homo-+ 1+[2 x ] zero     = cong ℕ.suc (sym (ℕ.+-identityʳ _))
 toℕ-homo-+ 2[1+ x ] 2[1+ y ] = begin
   toℕ (2[1+ x ] + 2[1+ y ])          ≡⟨⟩
   toℕ 2[1+ (suc (x + y)) ]           ≡⟨⟩
@@ -670,19 +696,19 @@ toℕ-homo-+ 1+[2 x ] 1+[2 y ] = begin
   toℕ 1+[2 x ] ℕ.+ toℕ 1+[2 y ]           ∎
   where open ≡-Reasoning;  m = toℕ x;  n = toℕ y
 
-toℕ-isMagmaHomomorphism-+ : IsMagmaHomomorphism +-rawMagma ℕᵇ.+-rawMagma toℕ
+toℕ-isMagmaHomomorphism-+ : IsMagmaHomomorphism +-rawMagma ℕ.+-rawMagma toℕ
 toℕ-isMagmaHomomorphism-+ = record
   { isRelHomomorphism = toℕ-isRelHomomorphism
   ; homo              = toℕ-homo-+
   }
 
-toℕ-isMonoidHomomorphism-+ : IsMonoidHomomorphism +-0-rawMonoid ℕᵇ.+-0-rawMonoid toℕ
+toℕ-isMonoidHomomorphism-+ : IsMonoidHomomorphism +-0-rawMonoid ℕ.+-0-rawMonoid toℕ
 toℕ-isMonoidHomomorphism-+ = record
   { isMagmaHomomorphism = toℕ-isMagmaHomomorphism-+
   ; ε-homo              = refl
   }
 
-toℕ-isMonoidMonomorphism-+ : IsMonoidMonomorphism +-0-rawMonoid ℕᵇ.+-0-rawMonoid toℕ
+toℕ-isMonoidMonomorphism-+ : IsMonoidMonomorphism +-0-rawMonoid ℕ.+-0-rawMonoid toℕ
 toℕ-isMonoidMonomorphism-+ = record
   { isMonoidHomomorphism = toℕ-isMonoidHomomorphism-+
   ; injective            = toℕ-injective
@@ -729,25 +755,25 @@ private
   module +-Monomorphism = MonoidMonomorphism toℕ-isMonoidMonomorphism-+
 
 +-assoc : Associative _+_
-+-assoc = +-Monomorphism.assoc ℕₚ.+-isMagma ℕₚ.+-assoc
++-assoc = +-Monomorphism.assoc ℕ.+-isMagma ℕ.+-assoc
 
 +-comm : Commutative _+_
-+-comm = +-Monomorphism.comm ℕₚ.+-isMagma ℕₚ.+-comm
++-comm = +-Monomorphism.comm ℕ.+-isMagma ℕ.+-comm
 
 +-identityˡ : LeftIdentity zero _+_
 +-identityˡ _ = refl
 
 +-identityʳ : RightIdentity zero _+_
-+-identityʳ = +-Monomorphism.identityʳ ℕₚ.+-isMagma ℕₚ.+-identityʳ
++-identityʳ = +-Monomorphism.identityʳ ℕ.+-isMagma ℕ.+-identityʳ
 
 +-identity : Identity zero _+_
 +-identity = +-identityˡ , +-identityʳ
 
 +-cancelˡ-≡ : LeftCancellative _+_
-+-cancelˡ-≡ = +-Monomorphism.cancelˡ ℕₚ.+-isMagma ℕₚ.+-cancelˡ-≡
++-cancelˡ-≡ = +-Monomorphism.cancelˡ ℕ.+-isMagma ℕ.+-cancelˡ-≡
 
 +-cancelʳ-≡ : RightCancellative _+_
-+-cancelʳ-≡ = +-Monomorphism.cancelʳ ℕₚ.+-isMagma ℕₚ.+-cancelʳ-≡
++-cancelʳ-≡ = +-Monomorphism.cancelʳ ℕ.+-isMagma ℕ.+-cancelʳ-≡
 
 ------------------------------------------------------------------------
 -- Structures for _+_
@@ -756,7 +782,7 @@ private
 +-isMagma = isMagma _+_
 
 +-isSemigroup : IsSemigroup _+_
-+-isSemigroup = +-Monomorphism.isSemigroup ℕₚ.+-isSemigroup
++-isSemigroup = +-Monomorphism.isSemigroup ℕ.+-isSemigroup
 
 +-isCommutativeSemigroup : IsCommutativeSemigroup _+_
 +-isCommutativeSemigroup = record
@@ -765,10 +791,10 @@ private
   }
 
 +-0-isMonoid : IsMonoid _+_ 0ᵇ
-+-0-isMonoid = +-Monomorphism.isMonoid ℕₚ.+-0-isMonoid
++-0-isMonoid = +-Monomorphism.isMonoid ℕ.+-0-isMonoid
 
 +-0-isCommutativeMonoid : IsCommutativeMonoid _+_ 0ᵇ
-+-0-isCommutativeMonoid = +-Monomorphism.isCommutativeMonoid ℕₚ.+-0-isCommutativeMonoid
++-0-isCommutativeMonoid = +-Monomorphism.isCommutativeMonoid ℕ.+-0-isCommutativeMonoid
 
 ------------------------------------------------------------------------
 -- Bundles for _+_
@@ -799,14 +825,14 @@ private
 
 module Bin+CSemigroup = CommSemigProp +-commutativeSemigroup
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _+_ and _≤_
 
 +-mono-≤ : _+_ Preserves₂ _≤_ ⟶ _≤_ ⟶ _≤_
 +-mono-≤ {x} {x′} {y} {y′} x≤x′ y≤y′ =  begin
   x + y                 ≡⟨ sym $ cong₂ _+_ (fromℕ-toℕ x) (fromℕ-toℕ y) ⟩
   fromℕ m + fromℕ n     ≡⟨ sym (fromℕ-homo-+ m n) ⟩
-  fromℕ (m ℕ.+ n)       ≤⟨ fromℕ-mono-≤ (ℕₚ.+-mono-≤ m≤m′ n≤n′) ⟩
+  fromℕ (m ℕ.+ n)       ≤⟨ fromℕ-mono-≤ (ℕ.+-mono-≤ m≤m′ n≤n′) ⟩
   fromℕ (m′ ℕ.+ n′)     ≡⟨ fromℕ-homo-+ m′ n′ ⟩
   fromℕ m′ + fromℕ n′   ≡⟨ cong₂ _+_ (fromℕ-toℕ x′) (fromℕ-toℕ y′) ⟩
   x′ + y′               ∎
@@ -826,7 +852,7 @@ module Bin+CSemigroup = CommSemigProp +-commutativeSemigroup
 +-mono-<-≤ {x} {x′} {y} {y′} x<x′ y≤y′ =  begin-strict
   x + y                  ≡⟨ sym $ cong₂ _+_ (fromℕ-toℕ x) (fromℕ-toℕ y) ⟩
   fromℕ m + fromℕ n      ≡⟨ sym (fromℕ-homo-+ m n) ⟩
-  fromℕ (m ℕ.+ n)        <⟨ fromℕ-mono-< (ℕₚ.+-mono-<-≤ m<m′ n≤n′) ⟩
+  fromℕ (m ℕ.+ n)        <⟨ fromℕ-mono-< (ℕ.+-mono-<-≤ m<m′ n≤n′) ⟩
   fromℕ (m′ ℕ.+ n′)      ≡⟨ fromℕ-homo-+ m′ n′ ⟩
   fromℕ m′ + fromℕ n′    ≡⟨ cong₂ _+_ (fromℕ-toℕ x′) (fromℕ-toℕ y′) ⟩
   x′ + y′                ∎
@@ -864,7 +890,7 @@ x≤x+y x y =  begin
 x<x+y : ∀ x {y} → y > 0ᵇ → x < x + y
 x<x+y x {y} y>0 = begin-strict
   x                             ≡⟨ sym (fromℕ-toℕ x) ⟩
-  fromℕ (toℕ x)                 <⟨ fromℕ-mono-< (ℕₚ.m<m+n (toℕ x) (toℕ-mono-< y>0)) ⟩
+  fromℕ (toℕ x)                 <⟨ fromℕ-mono-< (ℕ.m<m+n (toℕ x) (toℕ-mono-< y>0)) ⟩
   fromℕ (toℕ x ℕ.+ toℕ y)       ≡⟨ fromℕ-homo-+ (toℕ x) (toℕ y) ⟩
   fromℕ (toℕ x) + fromℕ (toℕ y) ≡⟨ cong₂ _+_ (fromℕ-toℕ x) (fromℕ-toℕ y) ⟩
   x + y                         ∎
@@ -894,12 +920,12 @@ x≢0⇒x+y≢0 {zero}     _    0≢0 =  contradiction refl 0≢0
 private  2*ₙ2*ₙ =  (2 ℕ.*_) ∘ (2 ℕ.*_)
 
 toℕ-homo-* : ∀ x y → toℕ (x * y) ≡ toℕ x ℕ.* toℕ y
-toℕ-homo-* x y =  aux x y (size x ℕ.+ size y) ℕₚ.≤-refl
+toℕ-homo-* x y =  aux x y (size x ℕ.+ size y) ℕ.≤-refl
   where
   aux : (x y : ℕᵇ) → (cnt : ℕ) → (size x ℕ.+ size y ℕ.≤ cnt) →  toℕ (x * y) ≡ toℕ x ℕ.* toℕ y
   aux zero     _        _ _ = refl
-  aux 2[1+ x ] zero     _ _ = sym (ℕₚ.*-zeroʳ (toℕ x ℕ.+ (ℕ.suc (toℕ x ℕ.+ 0))))
-  aux 1+[2 x ] zero     _ _ = sym (ℕₚ.*-zeroʳ (toℕ x ℕ.+ (toℕ x ℕ.+ 0)))
+  aux 2[1+ x ] zero     _ _ = sym (ℕ.*-zeroʳ (toℕ x ℕ.+ (ℕ.suc (toℕ x ℕ.+ 0))))
+  aux 1+[2 x ] zero     _ _ = sym (ℕ.*-zeroʳ (toℕ x ℕ.+ (toℕ x ℕ.+ 0)))
   aux 2[1+ x ] 2[1+ y ] (ℕ.suc cnt) (s≤s |x|+1+|y|≤cnt) = begin
     toℕ (2[1+ x ] * 2[1+ y ])                ≡⟨⟩
     toℕ (double 2[1+ (x + (y + xy)) ])       ≡⟨ toℕ-double 2[1+ (x + (y + xy)) ] ⟩
@@ -916,7 +942,7 @@ toℕ-homo-* x y =  aux x y (size x ℕ.+ size y) ℕₚ.≤-refl
     where
     open ≡-Reasoning;  m = toℕ x;  n = toℕ y;  xy = x * y
 
-    |x|+|y|≤cnt = ℕₚ.≤-trans (ℕₚ.+-monoʳ-≤ (size x) (ℕₚ.n≤1+n (size y))) |x|+1+|y|≤cnt
+    |x|+|y|≤cnt = ℕ.≤-trans (ℕ.+-monoʳ-≤ (size x) (ℕ.n≤1+n (size y))) |x|+1+|y|≤cnt
 
   aux 2[1+ x ] 1+[2 y ] (ℕ.suc cnt) (s≤s |x|+1+|y|≤cnt) = begin
     toℕ (2[1+ x ] * 1+[2 y ])                  ≡⟨⟩
@@ -964,13 +990,13 @@ toℕ-homo-* x y =  aux x y (size x ℕ.+ size y) ℕₚ.≤-refl
     ℕ.suc (2 ℕ.* (toℕ (x + y * 1+2x)))      ≡⟨ cong (ℕ.suc ∘ (2 ℕ.*_)) (toℕ-homo-+ x (y * 1+2x)) ⟩
     ℕ.suc (2 ℕ.* (m ℕ.+ (toℕ (y * 1+2x))))  ≡⟨ cong (ℕ.suc ∘ (2 ℕ.*_) ∘ (m ℕ.+_))
                                                  (aux y 1+2x cnt |y|+1+|x|≤cnt) ⟩
-    ℕ.suc (2 ℕ.* (m ℕ.+ (n ℕ.* [1+2x]′)))   ≡⟨ cong ℕ.suc $ ℕₚ.*-distribˡ-+ 2 m (n ℕ.* [1+2x]′) ⟩
-    ℕ.suc (2m ℕ.+ (2 ℕ.* (n ℕ.* [1+2x]′)))  ≡⟨ cong (ℕ.suc ∘ (2m ℕ.+_)) (sym (ℕₚ.*-assoc 2 n _)) ⟩
+    ℕ.suc (2 ℕ.* (m ℕ.+ (n ℕ.* [1+2x]′)))   ≡⟨ cong ℕ.suc $ ℕ.*-distribˡ-+ 2 m (n ℕ.* [1+2x]′) ⟩
+    ℕ.suc (2m ℕ.+ (2 ℕ.* (n ℕ.* [1+2x]′)))  ≡⟨ cong (ℕ.suc ∘ (2m ℕ.+_)) (sym (ℕ.*-assoc 2 n _)) ⟩
     (ℕ.suc 2m) ℕ.+ 2n ℕ.* [1+2x]′           ≡⟨⟩
     [1+2x]′ ℕ.+ 2n ℕ.* [1+2x]′              ≡⟨ cong (ℕ._+ (2n ℕ.* [1+2x]′)) $
-                                                    sym (ℕₚ.*-identityˡ [1+2x]′) ⟩
-    1 ℕ.* [1+2x]′ ℕ.+ 2n ℕ.* [1+2x]′        ≡⟨ sym (ℕₚ.*-distribʳ-+ [1+2x]′ 1 2n) ⟩
-    (ℕ.suc 2n) ℕ.* [1+2x]′                  ≡⟨ ℕₚ.*-comm (ℕ.suc 2n) [1+2x]′ ⟩
+                                                    sym (ℕ.*-identityˡ [1+2x]′) ⟩
+    1 ℕ.* [1+2x]′ ℕ.+ 2n ℕ.* [1+2x]′        ≡⟨ sym (ℕ.*-distribʳ-+ [1+2x]′ 1 2n) ⟩
+    (ℕ.suc 2n) ℕ.* [1+2x]′                  ≡⟨ ℕ.*-comm (ℕ.suc 2n) [1+2x]′ ⟩
     toℕ 1+[2 x ] ℕ.* toℕ 1+[2 y ]           ∎
     where
     open ≡-Reasoning
@@ -983,19 +1009,19 @@ toℕ-homo-* x y =  aux x y (size x ℕ.+ size y) ℕₚ.≤-refl
     |y|+1+|x|≤cnt = subst (ℕ._≤ cnt) eq |x|+1+|y|≤cnt
 
 
-toℕ-isMagmaHomomorphism-* : IsMagmaHomomorphism *-rawMagma ℕᵇ.*-rawMagma toℕ
+toℕ-isMagmaHomomorphism-* : IsMagmaHomomorphism *-rawMagma ℕ.*-rawMagma toℕ
 toℕ-isMagmaHomomorphism-* = record
   { isRelHomomorphism = toℕ-isRelHomomorphism
   ; homo              = toℕ-homo-*
   }
 
-toℕ-isMonoidHomomorphism-* : IsMonoidHomomorphism *-1-rawMonoid ℕᵇ.*-1-rawMonoid toℕ
+toℕ-isMonoidHomomorphism-* : IsMonoidHomomorphism *-1-rawMonoid ℕ.*-1-rawMonoid toℕ
 toℕ-isMonoidHomomorphism-* = record
   { isMagmaHomomorphism = toℕ-isMagmaHomomorphism-*
   ; ε-homo              = refl
   }
 
-toℕ-isMonoidMonomorphism-* : IsMonoidMonomorphism *-1-rawMonoid ℕᵇ.*-1-rawMonoid toℕ
+toℕ-isMonoidMonomorphism-* : IsMonoidMonomorphism *-1-rawMonoid ℕ.*-1-rawMonoid toℕ
 toℕ-isMonoidMonomorphism-* = record
   { isMonoidHomomorphism = toℕ-isMonoidHomomorphism-*
   ; injective            = toℕ-injective
@@ -1022,13 +1048,13 @@ private
 -- by `toℕ`/`fromℕ`.
 
 *-assoc : Associative _*_
-*-assoc = *-Monomorphism.assoc ℕₚ.*-isMagma ℕₚ.*-assoc
+*-assoc = *-Monomorphism.assoc ℕ.*-isMagma ℕ.*-assoc
 
 *-comm : Commutative _*_
-*-comm = *-Monomorphism.comm ℕₚ.*-isMagma ℕₚ.*-comm
+*-comm = *-Monomorphism.comm ℕ.*-isMagma ℕ.*-comm
 
 *-identityˡ : LeftIdentity 1ᵇ _*_
-*-identityˡ = *-Monomorphism.identityˡ ℕₚ.*-isMagma ℕₚ.*-identityˡ
+*-identityˡ = *-Monomorphism.identityˡ ℕ.*-isMagma ℕ.*-identityˡ
 
 *-identityʳ : RightIdentity 1ᵇ _*_
 *-identityʳ x =  trans (*-comm x 1ᵇ) (*-identityˡ x)
@@ -1052,7 +1078,7 @@ private
   a * (b + c)                          ≡⟨ sym (fromℕ-toℕ (a * (b + c))) ⟩
   fromℕ (toℕ (a * (b + c)))            ≡⟨ cong fromℕ (toℕ-homo-* a (b + c)) ⟩
   fromℕ (k ℕ.* (toℕ (b + c)))          ≡⟨ cong (fromℕ ∘ (k ℕ.*_)) (toℕ-homo-+ b c) ⟩
-  fromℕ (k ℕ.* (m ℕ.+ n))              ≡⟨ cong fromℕ (ℕₚ.*-distribˡ-+ k m n) ⟩
+  fromℕ (k ℕ.* (m ℕ.+ n))              ≡⟨ cong fromℕ (ℕ.*-distribˡ-+ k m n) ⟩
   fromℕ (k ℕ.* m ℕ.+ k ℕ.* n)          ≡⟨ cong fromℕ $ sym $
                                             cong₂ ℕ._+_ (toℕ-homo-* a b) (toℕ-homo-* a c) ⟩
   fromℕ (toℕ (a * b) ℕ.+ toℕ (a * c))  ≡⟨ cong fromℕ (sym (toℕ-homo-+ (a * b) (a * c))) ⟩
@@ -1061,7 +1087,7 @@ private
   where open ≡-Reasoning;  k = toℕ a;  m = toℕ b;  n = toℕ c
 
 *-distribʳ-+ : _*_ DistributesOverʳ _+_
-*-distribʳ-+ = comm+distrˡ⇒distrʳ *-comm *-distribˡ-+
+*-distribʳ-+ = comm∧distrˡ⇒distrʳ *-comm *-distribˡ-+
 
 *-distrib-+ : _*_ DistributesOver _+_
 *-distrib-+ = *-distribˡ-+ , *-distribʳ-+
@@ -1073,13 +1099,13 @@ private
 *-isMagma = isMagma _*_
 
 *-isSemigroup : IsSemigroup _*_
-*-isSemigroup = *-Monomorphism.isSemigroup ℕₚ.*-isSemigroup
+*-isSemigroup = *-Monomorphism.isSemigroup ℕ.*-isSemigroup
 
 *-1-isMonoid : IsMonoid _*_ 1ᵇ
-*-1-isMonoid = *-Monomorphism.isMonoid ℕₚ.*-1-isMonoid
+*-1-isMonoid = *-Monomorphism.isMonoid ℕ.*-1-isMonoid
 
 *-1-isCommutativeMonoid : IsCommutativeMonoid _*_ 1ᵇ
-*-1-isCommutativeMonoid = *-Monomorphism.isCommutativeMonoid ℕₚ.*-1-isCommutativeMonoid
+*-1-isCommutativeMonoid = *-Monomorphism.isCommutativeMonoid ℕ.*-1-isCommutativeMonoid
 
 +-*-isSemiringWithoutAnnihilatingZero : IsSemiringWithoutAnnihilatingZero _+_ _*_ zero 1ᵇ
 +-*-isSemiringWithoutAnnihilatingZero = record
@@ -1141,10 +1167,10 @@ private
 *-mono-≤ : _*_ Preserves₂ _≤_ ⟶ _≤_ ⟶ _≤_
 *-mono-≤ {x} {u} {y} {v} x≤u y≤v = toℕ-cancel-≤ (begin
   toℕ (x * y)      ≡⟨ toℕ-homo-* x y ⟩
-  toℕ x ℕ.* toℕ y  ≤⟨ ℕₚ.*-mono-≤ (toℕ-mono-≤ x≤u) (toℕ-mono-≤ y≤v) ⟩
+  toℕ x ℕ.* toℕ y  ≤⟨ ℕ.*-mono-≤ (toℕ-mono-≤ x≤u) (toℕ-mono-≤ y≤v) ⟩
   toℕ u ℕ.* toℕ v  ≡⟨ sym (toℕ-homo-* u v) ⟩
   toℕ (u * v)      ∎)
-  where open ℕₚ.≤-Reasoning
+  where open ℕ.≤-Reasoning
 
 *-monoʳ-≤ : ∀ x → (x *_) Preserves _≤_ ⟶ _≤_
 *-monoʳ-≤ x y≤y′ = *-mono-≤ (≤-refl {x}) y≤y′
@@ -1155,10 +1181,10 @@ private
 *-mono-< : _*_ Preserves₂ _<_ ⟶ _<_ ⟶ _<_
 *-mono-< {x} {u} {y} {v} x<u y<v = toℕ-cancel-< (begin-strict
   toℕ (x * y)      ≡⟨ toℕ-homo-* x y ⟩
-  toℕ x ℕ.* toℕ y  <⟨ ℕₚ.*-mono-< (toℕ-mono-< x<u) (toℕ-mono-< y<v) ⟩
+  toℕ x ℕ.* toℕ y  <⟨ ℕ.*-mono-< (toℕ-mono-< x<u) (toℕ-mono-< y<v) ⟩
   toℕ u ℕ.* toℕ v  ≡⟨ sym (toℕ-homo-* u v) ⟩
   toℕ (u * v)      ∎)
-  where open ℕₚ.≤-Reasoning
+  where open ℕ.≤-Reasoning
 
 *-monoʳ-< : ∀ x → ((1ᵇ + x) *_) Preserves _<_ ⟶ _<_
 *-monoʳ-< x {y} {z} y<z = begin-strict
@@ -1309,6 +1335,18 @@ double-suc x = begin
 -- Properties of suc
 ------------------------------------------------------------------------
 
+suc≢0 : suc x ≢ zero
+suc≢0 {zero}     ()
+suc≢0 {2[1+ _ ]} ()
+suc≢0 {1+[2 _ ]} ()
+
+suc-injective : Injective _≡_ _≡_ suc
+suc-injective {zero} {zero} p = refl
+suc-injective {zero} {2[1+ y ]} p = contradiction 1+[2 p ]-injective (suc≢0 ∘ sym)
+suc-injective {2[1+ x ]} {zero} p = contradiction 1+[2 p ]-injective suc≢0
+suc-injective {2[1+ x ]} {2[1+ y ]} p = cong 2[1+_] (suc-injective 1+[2 p ]-injective)
+suc-injective {1+[2 x ]} {1+[2 y ]} refl = refl
+
 2[1+_]-double-suc : 2[1+_] ≗ double ∘ suc
 2[1+_]-double-suc zero     = refl
 2[1+_]-double-suc 2[1+ x ] = cong 2[1+_] (2[1+_]-double-suc x)
@@ -1325,11 +1363,6 @@ double-suc x = begin
   suc (double 1+[2 x ])   ∎
   where open ≡-Reasoning;  2x = double x
 
-suc≢0 : suc x ≢ zero
-suc≢0 {zero}     ()
-suc≢0 {2[1+ _ ]} ()
-suc≢0 {1+[2 _ ]} ()
-
 x+suc[y]≡suc[x]+y : ∀ x y → x + suc y ≡ suc x + y
 x+suc[y]≡suc[x]+y x y = begin
   x + suc y     ≡⟨ +-comm x _ ⟩
@@ -1432,7 +1465,7 @@ pred-mono-≤ : pred Preserves _≤_ ⟶ _≤_
 pred-mono-≤ {x} {y} x≤y = begin
   pred x             ≡⟨ cong pred (sym (fromℕ-toℕ x)) ⟩
   pred (fromℕ m)     ≡⟨ sym (fromℕ-pred m) ⟩
-  fromℕ (ℕ.pred m)   ≤⟨ fromℕ-mono-≤ (ℕₚ.pred-mono (toℕ-mono-≤ x≤y)) ⟩
+  fromℕ (ℕ.pred m)   ≤⟨ fromℕ-mono-≤ (ℕ.pred-mono-≤ (toℕ-mono-≤ x≤y)) ⟩
   fromℕ (ℕ.pred n)   ≡⟨ fromℕ-pred n ⟩
   pred (fromℕ n)     ≡⟨ cong pred (fromℕ-toℕ y) ⟩
   pred y             ∎
diff --git a/src/Data/Nat/Binary/Subtraction.agda b/src/Data/Nat/Binary/Subtraction.agda
index 67eebc88f6..1e38de460e 100644
--- a/src/Data/Nat/Binary/Subtraction.agda
+++ b/src/Data/Nat/Binary/Subtraction.agda
@@ -8,22 +8,29 @@
 
 module Data.Nat.Binary.Subtraction where
 
-open import Algebra using (Op₂; Magma)
-open import Algebra.Consequences.Propositional using (comm+distrˡ⇒distrʳ)
+open import Algebra.Core using (Op₂)
+open import Algebra.Bundles using (Magma)
+open import Algebra.Consequences.Propositional using (comm∧distrˡ⇒distrʳ)
 open import Algebra.Morphism.Consequences using (homomorphic₂-inv)
-open import Data.Bool.Base using (true; false)
+open import Data.Bool.Base using (true; false; if_then_else_)
 open import Data.Nat as ℕ using (ℕ)
-open import Data.Nat.Binary.Base
+open import Data.Nat.Binary.Base using (ℕᵇ; 0ᵇ; 2[1+_]; 1+[2_]; double;
+  pred; toℕ; fromℕ; even<odd; odd<even; _≥_; _>_; _≤_; _<_; _+_; zero; suc; 1ᵇ;
+  _*_)
 open import Data.Nat.Binary.Properties
-import Data.Nat.Properties as ℕₚ
-open import Data.Product using (_×_; _,_; proj₁; proj₂; ∃)
-open import Data.Sum using (inj₁; inj₂)
-open import Data.Vec using ([]; _∷_)
-open import Function using (_∘_; _$_)
+import Data.Nat.Properties as ℕ
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂; ∃)
+open import Data.Sum.Base using (inj₁; inj₂)
+open import Data.Vec.Base using ([]; _∷_)
+open import Function.Base using (_∘_; _$_)
 open import Level using (0ℓ)
 open import Relation.Binary
   using (Tri; tri<; tri≈; tri>; _Preserves_⟶_; _Preserves₂_⟶_⟶_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Algebra using (magma)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂; sym; trans; subst; _≢_)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Relation.Nullary using (Dec; yes; no; does)
 open import Relation.Nullary.Negation using (contradiction)
 
@@ -46,12 +53,8 @@ zero     ∸ _        = 0ᵇ
 x        ∸ zero     = x
 2[1+ x ] ∸ 2[1+ y ] = double (x ∸ y)
 1+[2 x ] ∸ 1+[2 y ] = double (x ∸ y)
-2[1+ x ] ∸ 1+[2 y ] with does (x <? y)
-... | true  = 0ᵇ
-... | false = 1+[2 (x ∸ y) ]
-1+[2 x ] ∸ 2[1+ y ] with does (x ≤? y)
-... | true  = 0ᵇ
-... | false = pred (double (x ∸ y))
+2[1+ x ] ∸ 1+[2 y ] = if does (x <? y) then 0ᵇ else 1+[2 (x ∸ y) ]
+1+[2 x ] ∸ 2[1+ y ] = if does (x ≤? y) then 0ᵇ else pred (double (x ∸ y))
 
 ------------------------------------------------------------------------
 -- Properties of _∸_ and _≡_
@@ -77,40 +80,40 @@ toℕ-homo-∸ 2[1+ x ] zero     = refl
 toℕ-homo-∸ 2[1+ x ] 2[1+ y ] = begin
   toℕ (double (x ∸ y))          ≡⟨ toℕ-double (x ∸ y) ⟩
   2 ℕ.* toℕ (x ∸ y)             ≡⟨ cong (2 ℕ.*_) (toℕ-homo-∸ x y) ⟩
-  2 ℕ.* (toℕ x ℕ.∸ toℕ y)       ≡⟨ ℕₚ.*-distribˡ-∸ 2 (ℕ.suc (toℕ x)) (ℕ.suc (toℕ y)) ⟩
+  2 ℕ.* (toℕ x ℕ.∸ toℕ y)       ≡⟨ ℕ.*-distribˡ-∸ 2 (ℕ.suc (toℕ x)) (ℕ.suc (toℕ y)) ⟩
   toℕ 2[1+ x ] ℕ.∸ toℕ 2[1+ y ] ∎
   where open ≡-Reasoning
 toℕ-homo-∸ 2[1+ x ] 1+[2 y ] with x <? y
-... | yes x<y  = sym (ℕₚ.m≤n⇒m∸n≡0 (toℕ-mono-≤ (inj₁ (even<odd x<y))))
+... | yes x<y  = sym (ℕ.m≤n⇒m∸n≡0 (toℕ-mono-≤ (inj₁ (even<odd x<y))))
 ... | no  x≮y  = begin
   ℕ.suc (2 ℕ.* toℕ (x ∸ y))                     ≡⟨ cong (ℕ.suc ∘ (2 ℕ.*_)) (toℕ-homo-∸ x y) ⟩
-  ℕ.suc (2 ℕ.* (toℕ x ℕ.∸ toℕ y))               ≡⟨ cong ℕ.suc (ℕₚ.*-distribˡ-∸ 2 (toℕ x) (toℕ y)) ⟩
-  ℕ.suc (2 ℕ.* toℕ x ℕ.∸ 2 ℕ.* toℕ y)           ≡⟨ sym (ℕₚ.+-∸-assoc 1 (ℕₚ.*-monoʳ-≤ 2 (toℕ-mono-≤ (≮⇒≥ x≮y)))) ⟩
-  ℕ.suc (2 ℕ.* toℕ x) ℕ.∸ 2 ℕ.* toℕ y           ≡⟨ sym (cong (ℕ._∸ 2 ℕ.* toℕ y) (ℕₚ.+-suc (toℕ x) (1 ℕ.* toℕ x))) ⟩
+  ℕ.suc (2 ℕ.* (toℕ x ℕ.∸ toℕ y))               ≡⟨ cong ℕ.suc (ℕ.*-distribˡ-∸ 2 (toℕ x) (toℕ y)) ⟩
+  ℕ.suc (2 ℕ.* toℕ x ℕ.∸ 2 ℕ.* toℕ y)           ≡⟨ sym (ℕ.+-∸-assoc 1 (ℕ.*-monoʳ-≤ 2 (toℕ-mono-≤ (≮⇒≥ x≮y)))) ⟩
+  ℕ.suc (2 ℕ.* toℕ x) ℕ.∸ 2 ℕ.* toℕ y           ≡⟨ sym (cong (ℕ._∸ 2 ℕ.* toℕ y) (ℕ.+-suc (toℕ x) (1 ℕ.* toℕ x))) ⟩
   2 ℕ.* (ℕ.suc (toℕ x)) ℕ.∸ ℕ.suc (2 ℕ.* toℕ y) ∎
   where open ≡-Reasoning
 toℕ-homo-∸ 1+[2 x ] zero     = refl
 toℕ-homo-∸ 1+[2 x ] 2[1+ y ] with x ≤? y
-... | yes x≤y = sym (ℕₚ.m≤n⇒m∸n≡0 (toℕ-mono-≤ (inj₁ (odd<even x≤y))))
+... | yes x≤y = sym (ℕ.m≤n⇒m∸n≡0 (toℕ-mono-≤ (inj₁ (odd<even x≤y))))
 ... | no  _   = begin
   toℕ (pred (double (x ∸ y)))                   ≡⟨ toℕ-pred (double (x ∸ y)) ⟩
   ℕ.pred (toℕ (double (x ∸ y)))                 ≡⟨ cong ℕ.pred (toℕ-double (x ∸ y)) ⟩
   ℕ.pred (2 ℕ.* toℕ (x ∸ y))                    ≡⟨ cong (ℕ.pred ∘ (2 ℕ.*_)) (toℕ-homo-∸ x y) ⟩
-  ℕ.pred (2 ℕ.* (toℕ x ℕ.∸ toℕ y))              ≡⟨ cong ℕ.pred (ℕₚ.*-distribˡ-∸ 2 (toℕ x) (toℕ y)) ⟩
-  ℕ.pred (2 ℕ.* toℕ x ℕ.∸ 2 ℕ.* toℕ y)          ≡⟨ ℕₚ.pred[m∸n]≡m∸[1+n] (2 ℕ.* toℕ x) (2 ℕ.* toℕ y) ⟩
-  2 ℕ.* toℕ x ℕ.∸ ℕ.suc (2 ℕ.* toℕ y)           ≡⟨ sym (cong (2 ℕ.* toℕ x ℕ.∸_) (ℕₚ.+-suc (toℕ y) (1 ℕ.* toℕ y))) ⟩
+  ℕ.pred (2 ℕ.* (toℕ x ℕ.∸ toℕ y))              ≡⟨ cong ℕ.pred (ℕ.*-distribˡ-∸ 2 (toℕ x) (toℕ y)) ⟩
+  ℕ.pred (2 ℕ.* toℕ x ℕ.∸ 2 ℕ.* toℕ y)          ≡⟨ ℕ.pred[m∸n]≡m∸[1+n] (2 ℕ.* toℕ x) (2 ℕ.* toℕ y) ⟩
+  2 ℕ.* toℕ x ℕ.∸ ℕ.suc (2 ℕ.* toℕ y)           ≡⟨ sym (cong (2 ℕ.* toℕ x ℕ.∸_) (ℕ.+-suc (toℕ y) (1 ℕ.* toℕ y))) ⟩
   ℕ.suc (2 ℕ.* toℕ x) ℕ.∸ 2 ℕ.* (ℕ.suc (toℕ y)) ∎
   where open ≡-Reasoning
 toℕ-homo-∸ 1+[2 x ] 1+[2 y ] = begin
   toℕ (double (x ∸ y))        ≡⟨ toℕ-double (x ∸ y) ⟩
   2 ℕ.* toℕ (x ∸ y)           ≡⟨ cong (2 ℕ.*_) (toℕ-homo-∸ x y) ⟩
-  2 ℕ.* (toℕ x ℕ.∸ toℕ y)     ≡⟨ ℕₚ.*-distribˡ-∸ 2 (toℕ x) (toℕ y) ⟩
+  2 ℕ.* (toℕ x ℕ.∸ toℕ y)     ≡⟨ ℕ.*-distribˡ-∸ 2 (toℕ x) (toℕ y) ⟩
   2 ℕ.* toℕ x ℕ.∸ 2 ℕ.* toℕ y ∎
   where open ≡-Reasoning
 
 fromℕ-homo-∸ : ∀ m n → fromℕ (m ℕ.∸ n) ≡ (fromℕ m) ∸ (fromℕ n)
-fromℕ-homo-∸ = homomorphic₂-inv ∸-magma ℕₚ.∸-magma {toℕ}
-  (cong fromℕ) (toℕ-fromℕ , fromℕ-toℕ) toℕ-homo-∸
+fromℕ-homo-∸ = homomorphic₂-inv ∸-magma ℕ.∸-magma
+  (cong fromℕ) toℕ-inverseᵇ toℕ-homo-∸
 
 ------------------------------------------------------------------------
 -- Properties of _∸_ and _≤_/_<_
@@ -126,22 +129,22 @@ odd∸even-for> {x} {y} x>y with x ≤? y
 ... | yes x≤y = contradiction x>y (≤⇒≯ x≤y)
 
 x≤y⇒x∸y≡0 : x ≤ y → x ∸ y ≡ 0ᵇ
-x≤y⇒x∸y≡0 {x} {y} = toℕ-injective ∘ trans (toℕ-homo-∸ x y) ∘ ℕₚ.m≤n⇒m∸n≡0 ∘ toℕ-mono-≤
+x≤y⇒x∸y≡0 {x} {y} = toℕ-injective ∘ trans (toℕ-homo-∸ x y) ∘ ℕ.m≤n⇒m∸n≡0 ∘ toℕ-mono-≤
 
 x∸y≡0⇒x≤y : x ∸ y ≡ 0ᵇ → x ≤ y
-x∸y≡0⇒x≤y {x} {y} = toℕ-cancel-≤ ∘ ℕₚ.m∸n≡0⇒m≤n ∘ trans (sym (toℕ-homo-∸ x y)) ∘ cong toℕ
+x∸y≡0⇒x≤y {x} {y} = toℕ-cancel-≤ ∘ ℕ.m∸n≡0⇒m≤n ∘ trans (sym (toℕ-homo-∸ x y)) ∘ cong toℕ
 
 x<y⇒y∸x>0 : x < y → y ∸ x > 0ᵇ
-x<y⇒y∸x>0 {x} {y} = toℕ-cancel-< ∘ subst (ℕ._> 0) (sym (toℕ-homo-∸ y x)) ∘ ℕₚ.m<n⇒0<n∸m ∘ toℕ-mono-<
+x<y⇒y∸x>0 {x} {y} = toℕ-cancel-< ∘ subst (ℕ._> 0) (sym (toℕ-homo-∸ y x)) ∘ ℕ.m<n⇒0<n∸m ∘ toℕ-mono-<
 
----------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _∸_ and _+_
 
 [x∸y]+y≡x : x ≥ y → (x ∸ y) + y ≡ x
 [x∸y]+y≡x {x} {y} x≥y = toℕ-injective (begin
   toℕ (x ∸ y + y)             ≡⟨ toℕ-homo-+ (x ∸ y) y ⟩
   toℕ (x ∸ y) ℕ.+ toℕ y       ≡⟨ cong (ℕ._+ toℕ y) (toℕ-homo-∸ x y) ⟩
-  (toℕ x ℕ.∸ toℕ y) ℕ.+ toℕ y ≡⟨ ℕₚ.m∸n+n≡m (toℕ-mono-≤ x≥y) ⟩
+  (toℕ x ℕ.∸ toℕ y) ℕ.+ toℕ y ≡⟨ ℕ.m∸n+n≡m (toℕ-mono-≤ x≥y) ⟩
   toℕ x                       ∎)
   where open ≡-Reasoning
 
@@ -162,7 +165,7 @@ x+[y∸x]≡y {x} {y} x≤y = begin-equality
 ∸-+-assoc x y z = toℕ-injective $ begin
   toℕ ((x ∸ y) ∸ z)       ≡⟨ toℕ-homo-∸ (x ∸ y) z ⟩
   toℕ (x ∸ y) ℕ.∸ n       ≡⟨ cong (ℕ._∸ n) (toℕ-homo-∸ x y) ⟩
-  (k ℕ.∸ m) ℕ.∸ n         ≡⟨ ℕₚ.∸-+-assoc k m n ⟩
+  (k ℕ.∸ m) ℕ.∸ n         ≡⟨ ℕ.∸-+-assoc k m n ⟩
   k ℕ.∸ (m ℕ.+ n)         ≡⟨ cong (k ℕ.∸_) (sym (toℕ-homo-+ y z)) ⟩
   k ℕ.∸ (toℕ (y + z))     ≡⟨ sym (toℕ-homo-∸ x (y + z)) ⟩
   toℕ (x ∸ (y + z))       ∎
@@ -172,7 +175,7 @@ x+[y∸x]≡y {x} {y} x≤y = begin-equality
 +-∸-assoc x {y} {z} z≤y = toℕ-injective $ begin
   toℕ ((x + y) ∸ z)     ≡⟨ toℕ-homo-∸ (x + y) z ⟩
   (toℕ (x + y)) ℕ.∸ n   ≡⟨ cong (ℕ._∸ n) (toℕ-homo-+ x y) ⟩
-  (k ℕ.+ m) ℕ.∸ n       ≡⟨ ℕₚ.+-∸-assoc k n≤m ⟩
+  (k ℕ.+ m) ℕ.∸ n       ≡⟨ ℕ.+-∸-assoc k n≤m ⟩
   k ℕ.+ (m ℕ.∸ n)       ≡⟨ cong (k ℕ.+_) (sym (toℕ-homo-∸ y z)) ⟩
   k ℕ.+ toℕ (y ∸ z)     ≡⟨ sym (toℕ-homo-+ x (y ∸ z)) ⟩
   toℕ (x + (y ∸ z))     ∎
@@ -196,10 +199,10 @@ suc[x]∸suc[y] x y = begin-equality
 ∸-mono-≤ : _∸_ Preserves₂ _≤_ ⟶ _≥_ ⟶ _≤_
 ∸-mono-≤ {x} {y} {u} {v} x≤y v≤u = toℕ-cancel-≤ (begin
   toℕ (x ∸ u)      ≡⟨ toℕ-homo-∸ x u ⟩
-  toℕ x ℕ.∸ toℕ u  ≤⟨ ℕₚ.∸-mono (toℕ-mono-≤ x≤y) (toℕ-mono-≤ v≤u) ⟩
+  toℕ x ℕ.∸ toℕ u  ≤⟨ ℕ.∸-mono (toℕ-mono-≤ x≤y) (toℕ-mono-≤ v≤u) ⟩
   toℕ y ℕ.∸ toℕ v  ≡⟨ sym (toℕ-homo-∸ y v) ⟩
   toℕ (y ∸ v)      ∎)
-  where open ℕₚ.≤-Reasoning
+  where open ℕ.≤-Reasoning
 
 ∸-monoˡ-≤ : (x : ℕᵇ) → (_∸ x) Preserves _≤_ ⟶ _≤_
 ∸-monoˡ-≤ x y≤z = ∸-mono-≤ y≤z (≤-refl {x})
@@ -230,14 +233,14 @@ x∸y<x {x} {y} x≢0 y≢0 = begin-strict
 *-distribˡ-∸ x y z = toℕ-injective $ begin
   toℕ (x * (y ∸ z))              ≡⟨ toℕ-homo-* x (y ∸ z) ⟩
   k ℕ.* (toℕ (y ∸ z))            ≡⟨ cong (k ℕ.*_) (toℕ-homo-∸ y z) ⟩
-  k ℕ.* (m ℕ.∸ n)                ≡⟨ ℕₚ.*-distribˡ-∸ k m n ⟩
+  k ℕ.* (m ℕ.∸ n)                ≡⟨ ℕ.*-distribˡ-∸ k m n ⟩
   (k ℕ.* m) ℕ.∸ (k ℕ.* n)        ≡⟨ cong₂ ℕ._∸_ (sym (toℕ-homo-* x y)) (sym (toℕ-homo-* x z)) ⟩
   toℕ (x * y) ℕ.∸ toℕ (x * z)    ≡⟨ sym (toℕ-homo-∸ (x * y) (x * z)) ⟩
   toℕ ((x * y) ∸ (x * z))        ∎
   where open ≡-Reasoning;  k = toℕ x;  m = toℕ y;  n = toℕ z
 
 *-distribʳ-∸ : _*_ DistributesOverʳ _∸_
-*-distribʳ-∸ = comm+distrˡ⇒distrʳ *-comm *-distribˡ-∸
+*-distribʳ-∸ = comm∧distrˡ⇒distrʳ *-comm *-distribˡ-∸
 
 *-distrib-∸ : _*_ DistributesOver _∸_
 *-distrib-∸ = *-distribˡ-∸ , *-distribʳ-∸
diff --git a/src/Data/Nat/Combinatorics.agda b/src/Data/Nat/Combinatorics.agda
index e60390c725..9a1cae638f 100644
--- a/src/Data/Nat/Combinatorics.agda
+++ b/src/Data/Nat/Combinatorics.agda
@@ -8,15 +8,19 @@
 
 module Data.Nat.Combinatorics where
 
-open import Data.Nat.Base
-open import Data.Nat.DivMod
-open import Data.Nat.Divisibility
+open import Data.Nat.Base using (ℕ; zero; suc; _!; _∸_; z≤n; s≤s; _≤_;
+  _+_; _*_; _<_; s<s; ≢-nonZero)
+open import Data.Nat.DivMod using (_/_; n/1≡n; /-congˡ; /-congʳ; m*n/n≡m;
+  m/n/o≡m/[n*o]; n/n≡1; +-distrib-/-∣ˡ; m*n/m*o≡n/o)
+open import Data.Nat.Divisibility using (_∣_; *-monoʳ-∣)
 open import Data.Nat.Properties
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Definitions using (tri>; tri≈; tri<)
+open import Relation.Binary.PropositionalEquality.Core
   using (_≡_; refl; sym; cong; subst)
 
 import Data.Nat.Combinatorics.Base          as Base
 import Data.Nat.Combinatorics.Specification as Specification
+import Algebra.Properties.CommutativeSemigroup as CommSemigroupProperties
 
 open ≤-Reasoning
 
@@ -46,6 +50,15 @@ nPn≡n! n = begin-equality
   where instance
     _ = (n ∸ n) !≢0
 
+nP1≡n : ∀ n → n P 1 ≡ n
+nP1≡n zero        = refl
+nP1≡n n@(suc n-1) = begin-equality
+  n P 1          ≡⟨ nPk≡n!/[n∸k]! (s≤s (z≤n {n-1})) ⟩
+  n ! / n-1 !    ≡⟨ m*n/n≡m n (n-1 !) ⟩
+  n              ∎
+  where instance
+    _ = n-1 !≢0
+
 ------------------------------------------------------------------------
 -- Properties of _C_
 
@@ -55,21 +68,21 @@ open Specification public
 nCk≡nC[n∸k] : k ≤ n → n C k ≡ n C (n ∸ k)
 nCk≡nC[n∸k] {k} {n} k≤n = begin-equality
   n C k                               ≡⟨ nCk≡n!/k![n-k]! k≤n ⟩
-  n ! / (k ! * (n ∸ k) !)             ≡˘⟨ /-congʳ (*-comm ((n ∸ k) !) (k !)) ⟩
-  n ! / ((n ∸ k) ! * k !)             ≡˘⟨ /-congʳ (cong ((n ∸ k) ! *_) (cong _! (m∸[m∸n]≡n k≤n))) ⟩
-  n ! / ((n ∸ k) ! * (n ∸ (n ∸ k)) !) ≡˘⟨ nCk≡n!/k![n-k]! (m≤n⇒n∸m≤n k≤n) ⟩
+  n ! / (k ! * (n ∸ k) !)             ≡⟨ /-congʳ (*-comm ((n ∸ k) !) (k !)) ⟨
+  n ! / ((n ∸ k) ! * k !)             ≡⟨ /-congʳ (cong ((n ∸ k) ! *_) (cong _! (m∸[m∸n]≡n k≤n))) ⟨
+  n ! / ((n ∸ k) ! * (n ∸ (n ∸ k)) !) ≡⟨ nCk≡n!/k![n-k]! (m≤n⇒n∸m≤n k≤n) ⟨
   n C (n ∸ k)                         ∎
   where instance
     _ = (n ∸ k) !* k !≢0
     _ = k !* (n ∸ k) !≢0
     _ = (n ∸ k) !* (n ∸ (n ∸ k)) !≢0
 
-nCk≡nPk/k! : k ≤ n → n C k ≡ (n P k / k !) {{k !≢0}}
+nCk≡nPk/k! : k ≤ n → n C k ≡ ((n P k) / k !) {{k !≢0}}
 nCk≡nPk/k! {k} {n} k≤n = begin-equality
   n C k                   ≡⟨ nCk≡n!/k![n-k]! k≤n ⟩
-  n ! / (k ! * (n ∸ k) !) ≡˘⟨ /-congʳ (*-comm ((n ∸ k)!) (k !)) ⟩
-  n ! / ((n ∸ k) ! * k !) ≡˘⟨ m/n/o≡m/[n*o] (n !) ((n ∸ k) !) (k !) ⟩
-  (n ! / (n ∸ k) !) / k ! ≡˘⟨ /-congˡ (nPk≡n!/[n∸k]! k≤n) ⟩
+  n ! / (k ! * (n ∸ k) !) ≡⟨ /-congʳ (*-comm ((n ∸ k)!) (k !)) ⟨
+  n ! / ((n ∸ k) ! * k !) ≡⟨ m/n/o≡m/[n*o] (n !) ((n ∸ k) !) (k !) ⟨
+  (n ! / (n ∸ k) !) / k ! ≡⟨ /-congˡ (nPk≡n!/[n∸k]! k≤n) ⟨
   (n P k) / k !           ∎
   where instance
     _ = k !≢0
@@ -85,3 +98,138 @@ nCn≡1 n = begin-equality
   1              ∎
   where instance
     _ = n !≢0
+
+nC1≡n : ∀ n → n C 1 ≡ n
+nC1≡n zero    = refl
+nC1≡n n@(suc n-1) = begin-equality
+  n C 1          ≡⟨ nCk≡nPk/k!  (s≤s (z≤n {n-1})) ⟩
+  (n P 1) / 1 !  ≡⟨ n/1≡n (n P 1) ⟩
+  n P 1          ≡⟨ nP1≡n n ⟩
+  n              ∎
+
+
+------------------------------------------------------------------------
+-- Arithmetic of (n C k)
+
+module _ {n k} (k<n : k < n) where
+
+  private
+
+    [n-k]            = n ∸ k
+    [n-k-1]          = n ∸ suc k
+
+    [n-k]!           = [n-k] !
+    [n-k-1]!         = [n-k-1] !
+
+    [n-k]≡1+[n-k-1]  : [n-k] ≡ suc [n-k-1]
+    [n-k]≡1+[n-k-1]  = +-∸-assoc 1 k<n
+
+
+  [n-k]*[n-k-1]!≡[n-k]! : [n-k] * [n-k-1]! ≡ [n-k]!
+  [n-k]*[n-k-1]!≡[n-k]! = begin-equality
+      [n-k] * [n-k-1]!
+        ≡⟨ cong (_* [n-k-1]!) [n-k]≡1+[n-k-1] ⟩
+      (suc [n-k-1]) * [n-k-1]!
+        ≡⟨ cong _! [n-k]≡1+[n-k-1] ⟨
+      [n-k]!                ∎
+
+  private
+
+    n!           = n !
+    k!           = k !
+    [k+1]!       = (suc k) !
+
+    d[k]         = k! * [n-k]!
+    [k+1]*d[k]   = (suc k) * d[k]
+    d[k+1]       = [k+1]! * [n-k-1]!
+    [n-k]*d[k+1] = [n-k] * d[k+1]
+
+  [n-k]*d[k+1]≡[k+1]*d[k] : [n-k]*d[k+1] ≡ [k+1]*d[k]
+  [n-k]*d[k+1]≡[k+1]*d[k] = begin-equality
+    [n-k]*d[k+1]
+      ≡⟨ x∙yz≈y∙xz [n-k] [k+1]! [n-k-1]! ⟩
+    [k+1]! * ([n-k] * [n-k-1]!)
+      ≡⟨ *-assoc (suc k) k! ([n-k] * [n-k-1]!) ⟩
+    (suc k) * (k! * ([n-k] * [n-k-1]!))
+       ≡⟨ cong ((suc k) *_) (cong (k! *_) [n-k]*[n-k-1]!≡[n-k]!) ⟩
+    [k+1]*d[k]             ∎
+    where open CommSemigroupProperties *-commutativeSemigroup
+
+k![n∸k]!∣n! : ∀ {n k} → k ≤ n → k ! * (n ∸ k) ! ∣ n !
+k![n∸k]!∣n! {n} {k} k≤n = subst (_∣ n !) (*-comm ((n ∸ k) !) (k !)) ([n∸k]!k!∣n! k≤n)
+
+nCk+nC[k+1]≡[n+1]C[k+1] : ∀ n k → n C k + n C (suc k) ≡ suc n C suc k
+nCk+nC[k+1]≡[n+1]C[k+1] n k with <-cmp k n
+{- case k>n, in which case 1+k>1+n>n -}
+... | tri> _ _ k>n = begin-equality
+  n C k + n C (suc k) ≡⟨ cong (_+ (n C (suc k))) (k>n⇒nCk≡0 k>n) ⟩
+  0 + n C (suc k)     ≡⟨⟩
+  n C (suc k)         ≡⟨ k>n⇒nCk≡0 (m<n⇒m<1+n k>n) ⟩
+  0                   ≡⟨ k>n⇒nCk≡0 (s<s k>n) ⟨
+  suc n C suc k       ∎
+{- case k≡n, in which case 1+k≡1+n>n -}
+... | tri≈ _ k≡n _ rewrite k≡n = begin-equality
+  n C n + n C (suc n) ≡⟨ cong (n C n +_) (k>n⇒nCk≡0 (n<1+n n)) ⟩
+  n C n + 0           ≡⟨ +-identityʳ (n C n) ⟩
+  n C n               ≡⟨ nCn≡1 n ⟩
+  1                   ≡⟨ nCn≡1 (suc n) ⟨
+  suc n C suc n       ∎
+{- case k<n, in which case 1+k<1+n and there's arithmetic to perform -}
+... | tri< k<n _ _ = begin-equality
+  n C k + n C (suc k)
+    ≡⟨ cong (n C k +_) (nCk≡n!/k![n-k]! k<n)  ⟩
+  n C k + (n! / d[k+1])
+    ≡⟨ cong (n C k +_) (m*n/m*o≡n/o (n ∸ k) n! d[k+1]) ⟨
+  n C k + [n-k]*n!/[n-k]*d[k+1]
+    ≡⟨ cong (_+ [n-k]*n!/[n-k]*d[k+1]) (nCk≡n!/k![n-k]! k≤n) ⟩
+  n! / d[k] + _
+    ≡⟨ cong (_+ [n-k]*n!/[n-k]*d[k+1]) (m*n/m*o≡n/o (suc k) n! d[k]) ⟨
+  (suc k * n!) / [k+1]*d[k] + _
+    ≡⟨ cong (((suc k * n!) / [k+1]*d[k]) +_) (/-congʳ ([n-k]*d[k+1]≡[k+1]*d[k] k<n)) ⟩
+  (suc k * n!) / [k+1]*d[k] + ((n ∸ k) * n! / [k+1]*d[k])
+    ≡⟨ +-distrib-/-∣ˡ _ (*-monoʳ-∣ (suc k) (k![n∸k]!∣n! k≤n)) ⟨
+  ((suc k) * n! + (n ∸ k) * n!) / [k+1]*d[k]
+    ≡⟨ cong (_/ [k+1]*d[k]) (*-distribʳ-+ (n !) (suc k) (n ∸ k)) ⟨
+  ((suc k + (n ∸ k)) * n !) / [k+1]*d[k]
+    ≡⟨ cong (λ z → z * n ! / [k+1]*d[k]) [k+1]+[n-k]≡[n+1] ⟩
+  ((suc n) * n !) / [k+1]*d[k]
+    ≡⟨ /-congʳ (*-assoc (suc k) (k !) ((n ∸ k) !)) ⟨
+  ((suc n) * n !) / (((suc k) * k !) * (n ∸ k) !)
+    ≡⟨⟩
+  suc n ! / (suc k ! * (suc n ∸ suc k) !)
+    ≡⟨ nCk≡n!/k![n-k]! [k+1]≤[n+1] ⟨
+  suc n C suc k ∎
+  where
+    k≤n                     : k ≤ n
+    k≤n                     = <⇒≤ k<n
+
+    [k+1]≤[n+1]             : suc k ≤ suc n
+    [k+1]≤[n+1]             = s≤s k≤n
+
+    [k+1]+[n-k]≡[n+1]       : (suc k) + (n ∸ k) ≡ suc n
+    [k+1]+[n-k]≡[n+1]       = m+[n∸m]≡n {suc k} [k+1]≤[n+1]
+
+    [n-k]                   = n ∸ k
+    [n-k-1]                 = n ∸ suc k
+
+    n!                      = n !
+    k!                      = k !
+    [k+1]!                  = (suc k) !
+    [n-k]!                  = [n-k] !
+    [n-k-1]!                = [n-k-1] !
+
+    d[k]                    = k! * [n-k]!
+    [k+1]*d[k]              = (suc k) * d[k]
+    d[k+1]                  = [k+1]! * [n-k-1]!
+    [n-k]*d[k+1]            = [n-k] * d[k+1]
+    n!/[n-k]*d[k+1]         = n ! / [n-k]*d[k+1]
+    [n-k]*n!/[n-k]*d[k+1]   = [n-k] * n! / [n-k]*d[k+1]
+    [n-k]*n!/[k+1]*d[k]     = [n-k] * n! / [k+1]*d[k]
+
+    instance
+      [k+1]!*[n-k]!≢0 = (suc k) !* [n-k] !≢0
+      d[k]≢0          = k !* [n-k] !≢0
+      d[k+1]≢0        = (suc k) !* (n ∸ suc k) !≢0
+      [k+1]*d[k]≢0    = m*n≢0 (suc k) d[k]
+      [n-k]≢0         = ≢-nonZero (m>n⇒m∸n≢0 k<n)
+      [n-k]*d[k+1]≢0  = m*n≢0 [n-k] d[k+1]
diff --git a/src/Data/Nat/Combinatorics/Base.agda b/src/Data/Nat/Combinatorics/Base.agda
index 3ee7066441..149665c801 100644
--- a/src/Data/Nat/Combinatorics/Base.agda
+++ b/src/Data/Nat/Combinatorics/Base.agda
@@ -25,6 +25,8 @@ open import Data.Nat.Properties using (_!≢0)
 
 -- n P k = n ! / (n ∸ k) !
 
+infixl 6.5 _P′_ _P_
+
 -- Base definition. Only valid for k ≤ n.
 
 _P′_ : ℕ → ℕ → ℕ
@@ -44,6 +46,8 @@ n P k = if k ≤ᵇ n then n P′ k else 0
 
 -- n C k = n ! / (k ! * (n ∸ k) !)
 
+infixl 6.5 _C′_ _C_
+
 -- Base definition. Only valid for k ≤ n.
 
 _C′_ : ℕ → ℕ → ℕ
diff --git a/src/Data/Nat/Combinatorics/Specification.agda b/src/Data/Nat/Combinatorics/Specification.agda
index 533a565d23..cf7f826522 100644
--- a/src/Data/Nat/Combinatorics/Specification.agda
+++ b/src/Data/Nat/Combinatorics/Specification.agda
@@ -10,19 +10,20 @@
 
 module Data.Nat.Combinatorics.Specification where
 
-open import Data.Bool using (T; true; false)
-open import Data.Nat.Base
-open import Data.Nat.DivMod
-open import Data.Nat.Divisibility
+open import Data.Bool.Base using (T; true; false)
+open import Data.Nat.Base using (zero; suc; _≤ᵇ_; _≤_; _!; _∸_; pred;
+  >-nonZero; _*_; NonZero; _+_; s≤s; z≤n; _>_)
+open import Data.Nat.DivMod using (_/_; n/n≡1; /-congʳ; m*n/m!≡n/[m∸1]!;
+  *-/-assoc; n/1≡n; m/n/o≡m/[n*o]; /-congˡ)
+open import Data.Nat.Divisibility using (m≤n⇒m!∣n!; _∣_; ∣-refl;
+  ∣-reflexive; module ∣-Reasoning; ∣m∣n⇒∣m+n; *-monoʳ-∣; m∣n/o⇒o*m∣n)
 open import Data.Nat.Properties
 open import Data.Nat.Combinatorics.Base
-open import Data.Sum using (inj₁; inj₂)
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; trans; _≢_)
+open import Data.Sum.Base using (inj₁; inj₂)
 open import Relation.Nullary.Decidable using (yes; no; does)
 open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Binary.PropositionalEquality
-  using (subst; refl; sym; cong; cong₂)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; trans; _≢_; subst; refl; sym; cong; cong₂)
 
 import Algebra.Properties.CommutativeSemigroup *-commutativeSemigroup as *-CS
 
@@ -40,7 +41,7 @@ nP′k≡n!/[n∸k]! : ∀ {n k} → k ≤ n → n P′ k ≡ (n ! / (n ∸ k) !
 nP′k≡n!/[n∸k]! {n} {zero}  z≤n = sym (n/n≡1 (n !) {{n !≢0}})
 nP′k≡n!/[n∸k]! {n} {suc k} k<n = begin-equality
   (n ∸ k) * (n P′ k)             ≡⟨ cong ((n ∸ k) *_) (nP′k≡n!/[n∸k]! (<⇒≤ k<n)) ⟩
-  (n ∸ k) * (n ! / (n ∸ k) !)    ≡˘⟨ *-/-assoc (n ∸ k) (m≤n⇒m!∣n! (m∸n≤m n k)) ⟩
+  (n ∸ k) * (n ! / (n ∸ k) !)    ≡⟨ *-/-assoc (n ∸ k) (m≤n⇒m!∣n! (m∸n≤m n k)) ⟨
   (((n ∸ k) * n !) / (n ∸ k) !)  ≡⟨ m*n/m!≡n/[m∸1]! (n ∸ k) (n !) ⟩
   (n ! / (pred (n ∸ k) !))       ≡⟨ /-congʳ (cong _! (pred[m∸n]≡m∸[1+n] n k)) ⟩
   (n ! / (n ∸ suc k) !)          ∎
@@ -57,20 +58,20 @@ nP′k≡n[n∸1P′k∸1] : ∀ n k → .{{NonZero n}} → .{{NonZero k}} →
 nP′k≡n[n∸1P′k∸1] n           (suc zero)            = refl
 nP′k≡n[n∸1P′k∸1] n@(suc n-1) k@(suc k-1@(suc k-2)) = begin-equality
   n P′ k                        ≡⟨⟩
-  (n ∸ k-1) * n P′ k-1          ≡⟨ cong ((n ∸ k-1) *_) (nP′k≡n[n∸1P′k∸1] n k-1) ⟩
-  (n ∸ k-1) * (n * n-1 P′ k-2)  ≡⟨ x∙yz≈y∙xz (n ∸ k-1) n (n-1 P′ k-2) ⟩
-  n * ((n ∸ k-1) * n-1 P′ k-2)  ≡⟨⟩
-  n * n-1 P′ k-1                ∎
+  (n ∸ k-1) * (n P′ k-1)        ≡⟨ cong ((n ∸ k-1) *_) (nP′k≡n[n∸1P′k∸1] n k-1) ⟩
+  (n ∸ k-1) * (n * (n-1 P′ k-2))  ≡⟨ x∙yz≈y∙xz (n ∸ k-1) n (n-1 P′ k-2) ⟩
+  n * ((n ∸ k-1) * (n-1 P′ k-2))  ≡⟨⟩
+  n * (n-1 P′ k-1)              ∎
   where open ≤-Reasoning; open *-CS
 
 P′-rec : ∀ {n k} → k ≤ n → .{{NonZero k}} →
         n P′ k ≡ k * (pred n P′ pred k) + pred n P′ k
 P′-rec n@{suc n-1} k@{suc k-1} k≤n = begin-equality
-  n P′ k                                      ≡⟨ nP′k≡n[n∸1P′k∸1] n k ⟩
-  n * n-1 P′ k-1                              ≡˘⟨ cong (_* n-1 P′ k-1) (m+[n∸m]≡n {k} {n} k≤n) ⟩
-  (k + (n ∸ k)) * n-1 P′ k-1                  ≡⟨ *-distribʳ-+ (n-1 P′ k-1) k (n ∸ k) ⟩
-  k * (n-1 P′ k-1) + (n-1 ∸ k-1) * n-1 P′ k-1 ≡⟨⟩
-  k * (n-1 P′ k-1) + n-1 P′ k                 ∎
+  n P′ k                                        ≡⟨ nP′k≡n[n∸1P′k∸1] n k ⟩
+  n * (n-1 P′ k-1)                              ≡⟨ cong (_* (n-1 P′ k-1)) (m+[n∸m]≡n {k} {n} k≤n) ⟨
+  (k + (n ∸ k)) * (n-1 P′ k-1)                  ≡⟨ *-distribʳ-+ (n-1 P′ k-1) k (n ∸ k) ⟩
+  k * (n-1 P′ k-1) + (n-1 ∸ k-1) * (n-1 P′ k-1) ≡⟨⟩
+  k * (n-1 P′ k-1) + (n-1 P′ k)                 ∎
   where open ≤-Reasoning
 
 nP′n≡n! : ∀ n → n P′ n ≡ n !
@@ -89,7 +90,7 @@ k!∣nP′k n@{suc n-1} k@{suc k-1} k≤n@(s≤s k-1≤n-1) with k-1 ≟ n-1
 ... | no  k≢n  = begin
   k !                           ≡⟨⟩
   k * k-1 !                     ∣⟨ ∣m∣n⇒∣m+n (*-monoʳ-∣ k (k!∣nP′k k-1≤n-1)) ( k!∣nP′k (≤∧≢⇒< k-1≤n-1 k≢n)) ⟩
-  k * (n-1 P′ k-1) + (n-1 P′ k) ≡˘⟨ P′-rec k≤n ⟩
+  k * (n-1 P′ k-1) + (n-1 P′ k) ≡⟨ P′-rec k≤n ⟨
   n P′ k                        ∎
   where open ∣-Reasoning
 
@@ -134,7 +135,7 @@ C′-sym {n} {k} k≤n = begin-equality
   n C′ (n ∸ k)                        ≡⟨ nC′k≡n!/k![n-k]! {n} {n ∸ k} (m≤n⇒n∸m≤n k≤n) ⟩
   n ! / ((n ∸ k) ! * (n ∸ (n ∸ k)) !) ≡⟨ /-congʳ (cong ((n ∸ k) ! *_) (cong _! (m∸[m∸n]≡n k≤n))) ⟩
   n ! / ((n ∸ k) ! * k !)             ≡⟨ /-congʳ (*-comm ((n ∸ k) !) (k !)) ⟩
-  n ! / (k ! * (n ∸ k) !)             ≡˘⟨ nC′k≡n!/k![n-k]! k≤n ⟩
+  n ! / (k ! * (n ∸ k) !)             ≡⟨ nC′k≡n!/k![n-k]! k≤n ⟨
   n C′ k                              ∎
   where
   open ≤-Reasoning
diff --git a/src/Data/Nat/Coprimality.agda b/src/Data/Nat/Coprimality.agda
index 6f126a80d6..16a9cf9897 100644
--- a/src/Data/Nat/Coprimality.agda
+++ b/src/Data/Nat/Coprimality.agda
@@ -8,9 +8,6 @@
 
 module Data.Nat.Coprimality where
 
-open import Data.Empty
-open import Data.Fin.Base using (toℕ; fromℕ<)
-open import Data.Fin.Properties using (toℕ-fromℕ<)
 open import Data.Nat.Base
 open import Data.Nat.Divisibility
 open import Data.Nat.GCD
@@ -18,14 +15,18 @@ open import Data.Nat.GCD.Lemmas
 open import Data.Nat.Primality
 open import Data.Nat.Properties
 open import Data.Nat.DivMod
-open import Data.Product as Prod
-open import Function
+open import Data.Product.Base as Prod
+open import Data.Sum.Base as Sum using (inj₁; inj₂)
+open import Function.Base using (_∘_)
 open import Level using (0ℓ)
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; _≢_; refl; trans; cong; subst; module ≡-Reasoning)
-open import Relation.Nullary as Nullary hiding (recompute)
-open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Binary
+open import Relation.Binary.PropositionalEquality.Core as ≡
+  using (_≡_; _≢_; refl; trans; cong; subst)
+open import Relation.Nullary as Nullary using (¬_; contradiction; map′)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Symmetric; Decidable)
+
+private
+  variable d m n o p : ℕ
 
 open ≤-Reasoning
 
@@ -36,22 +37,22 @@ open ≤-Reasoning
 -- prime), i.e. if their only common divisor is 1.
 
 Coprime : Rel ℕ 0ℓ
-Coprime m n = ∀ {i} → i ∣ m × i ∣ n → i ≡ 1
+Coprime m n = ∀ {d} → d ∣ m × d ∣ n → d ≡ 1
 
 ------------------------------------------------------------------------
 -- Relationship between GCD and coprimality
 
-coprime⇒GCD≡1 : ∀ {m n} → Coprime m n → GCD m n 1
-coprime⇒GCD≡1 {m} {n} c = GCD.is (1∣ m , 1∣ n) (∣-reflexive ∘ c)
+coprime⇒GCD≡1 : Coprime m n → GCD m n 1
+coprime⇒GCD≡1 {m} {n} coprime = GCD.is (1∣ m , 1∣ n) (∣-reflexive ∘ coprime)
 
-GCD≡1⇒coprime : ∀ {m n} → GCD m n 1 → Coprime m n
-GCD≡1⇒coprime g cd with GCD.greatest g cd
-... | divides q eq = m*n≡1⇒n≡1 q _ (P.sym eq)
+GCD≡1⇒coprime : GCD m n 1 → Coprime m n
+GCD≡1⇒coprime g cd with divides q eq ← GCD.greatest g cd
+  = m*n≡1⇒n≡1 q _ (≡.sym eq)
 
-coprime⇒gcd≡1 : ∀ {m n} → Coprime m n → gcd m n ≡ 1
+coprime⇒gcd≡1 : Coprime m n → gcd m n ≡ 1
 coprime⇒gcd≡1 coprime = GCD.unique (gcd-GCD _ _) (coprime⇒GCD≡1 coprime)
 
-gcd≡1⇒coprime : ∀ {m n} → gcd m n ≡ 1 → Coprime m n
+gcd≡1⇒coprime : gcd m n ≡ 1 → Coprime m n
 gcd≡1⇒coprime gcd≡1 = GCD≡1⇒coprime (subst (GCD _ _) gcd≡1 (gcd-GCD _ _))
 
 coprime-/gcd : ∀ m n .{{_ : NonZero (gcd m n)}} →
@@ -64,18 +65,8 @@ coprime-/gcd m n = GCD≡1⇒coprime (GCD-/gcd m n)
 sym : Symmetric Coprime
 sym c = c ∘ swap
 
-private
-  0≢1 : 0 ≢ 1
-  0≢1 ()
-
-  2+≢1 : ∀ {n} → suc (suc n) ≢ 1
-  2+≢1 ()
-
 coprime? : Decidable Coprime
-coprime? i j with mkGCD i j
-... | (0           , g) = no  (0≢1  ∘ GCD.unique g ∘ coprime⇒GCD≡1)
-... | (1           , g) = yes (GCD≡1⇒coprime g)
-... | (suc (suc d) , g) = no  (2+≢1 ∘ GCD.unique g ∘ coprime⇒GCD≡1)
+coprime? m n = map′ gcd≡1⇒coprime coprime⇒gcd≡1 (gcd m n ≟ 1)
 
 ------------------------------------------------------------------------
 -- Other basic properties
@@ -87,21 +78,21 @@ coprime? i j with mkGCD i j
 
 -- Nothing except for 1 is coprime to 0.
 
-0-coprimeTo-m⇒m≡1 : ∀ {m} → Coprime 0 m → m ≡ 1
-0-coprimeTo-m⇒m≡1 {m} c = c (m ∣0 , ∣-refl)
+0-coprimeTo-m⇒m≡1 : Coprime 0 m → m ≡ 1
+0-coprimeTo-m⇒m≡1 {m} coprime = coprime (m ∣0 , ∣-refl)
 
-¬0-coprimeTo-2+ : ∀ {n} → ¬ Coprime 0 (2 + n)
-¬0-coprimeTo-2+ coprime = contradiction (0-coprimeTo-m⇒m≡1 coprime) λ()
+¬0-coprimeTo-2+ : .{{NonTrivial n}} → ¬ Coprime 0 n
+¬0-coprimeTo-2+ {n} coprime = contradiction (0-coprimeTo-m⇒m≡1 coprime) (nonTrivial⇒≢1 {n})
 
 -- If m and n are coprime, then n + m and n are also coprime.
 
-coprime-+ : ∀ {m n} → Coprime m n → Coprime (n + m) n
-coprime-+ c (d₁ , d₂) = c (∣m+n∣m⇒∣n d₁ d₂ , d₂)
+coprime-+ : Coprime m n → Coprime (n + m) n
+coprime-+ coprime (d₁ , d₂) = coprime (∣m+n∣m⇒∣n d₁ d₂ , d₂)
 
 -- Recomputable
 
-recompute : ∀ {n d} → .(Coprime n d) → Coprime n d
-recompute {n} {d} c = Nullary.recompute (coprime? n d) c
+recompute : .(Coprime n d) → Coprime n d
+recompute {n} {d} coprime = Nullary.recompute (coprime? n d) coprime
 
 ------------------------------------------------------------------------
 -- Relationship with Bezout's lemma
@@ -109,30 +100,29 @@ recompute {n} {d} c = Nullary.recompute (coprime? n d) c
 -- If the "gcd" in Bézout's identity is non-zero, then the "other"
 -- divisors are coprime.
 
-Bézout-coprime : ∀ {i j d} .{{_ : NonZero d}} →
-                 Bézout.Identity d (i * d) (j * d) → Coprime i j
-Bézout-coprime {d = suc _} (Bézout.+- x y eq) (divides q₁ refl , divides q₂ refl) =
+Bézout-coprime : .{{NonZero d}} →
+                 Bézout.Identity d (m * d) (n * d) → Coprime m n
+Bézout-coprime {d = suc _} (Bézout.+- x y eq) (divides-refl q₁ , divides-refl q₂) =
   lem₁₀ y q₂ x q₁ eq
-Bézout-coprime {d = suc _} (Bézout.-+ x y eq) (divides q₁ refl , divides q₂ refl) =
+Bézout-coprime {d = suc _} (Bézout.-+ x y eq) (divides-refl q₁ , divides-refl q₂) =
   lem₁₀ x q₁ y q₂ eq
 
 -- Coprime numbers satisfy Bézout's identity.
 
-coprime-Bézout : ∀ {i j} → Coprime i j → Bézout.Identity 1 i j
+coprime-Bézout : Coprime m n → Bézout.Identity 1 m n
 coprime-Bézout = Bézout.identity ∘ coprime⇒GCD≡1
 
--- If i divides jk and is coprime to j, then it divides k.
+-- If m divides n*o and is coprime to n, then it divides o.
 
-coprime-divisor : ∀ {k i j} → Coprime i j → i ∣ j * k → i ∣ k
-coprime-divisor {k} c (divides q eq′) with coprime-Bézout c
-... | Bézout.+- x y eq = divides (x * k ∸ y * q) (lem₈ x y eq eq′)
-... | Bézout.-+ x y eq = divides (y * q ∸ x * k) (lem₉ x y eq eq′)
+coprime-divisor : Coprime m n → m ∣ n * o → m ∣ o
+coprime-divisor {o = o} c (divides q eq′) with coprime-Bézout c
+... | Bézout.+- x y eq = divides (x * o ∸ y * q) (lem₈ x y eq eq′)
+... | Bézout.-+ x y eq = divides (y * q ∸ x * o) (lem₉ x y eq eq′)
 
--- If d is a common divisor of mk and nk, and m and n are coprime,
--- then d divides k.
+-- If d is a common divisor of m*o and n*o, and m and n are coprime,
+-- then d divides o.
 
-coprime-factors : ∀ {d m n k} →
-                  Coprime m n → d ∣ m * k × d ∣ n * k → d ∣ k
+coprime-factors : Coprime m n → d ∣ m * o × d ∣ n * o → d ∣ o
 coprime-factors c (divides q₁ eq₁ , divides q₂ eq₂) with coprime-Bézout c
 ... | Bézout.+- x y eq = divides (x * q₁ ∸ y * q₂) (lem₁₁ x y eq eq₁ eq₂)
 ... | Bézout.-+ x y eq = divides (y * q₂ ∸ x * q₁) (lem₁₁ y x eq eq₂ eq₁)
@@ -140,11 +130,7 @@ coprime-factors c (divides q₁ eq₁ , divides q₂ eq₂) with coprime-Bézout
 ------------------------------------------------------------------------
 -- Primality implies coprimality.
 
-prime⇒coprime : ∀ m → Prime m →
-                ∀ n → 0 < n → n < m → Coprime m n
-prime⇒coprime (suc (suc _)) p _ _ _ {0} (0∣m , _) =
-  contradiction (0∣⇒≡0 0∣m) λ()
-prime⇒coprime (suc (suc _)) _ _ _ _ {1} _         = refl
-prime⇒coprime (suc (suc _)) p (suc _) _ n<m {(suc (suc _))} (d∣m , d∣n) =
-  contradiction d∣m (p 2≤d d<m)
-  where 2≤d = s≤s (s≤s z≤n); d<m = <-transˡ (s≤s (∣⇒≤ d∣n)) n<m
+prime⇒coprime : Prime p → .{{NonZero n}} → n < p → Coprime p n
+prime⇒coprime p n<p (d∣p , d∣n) with prime⇒irreducible p d∣p
+... | inj₁ d≡1      = d≡1
+... | inj₂ d≡p@refl = contradiction n<p (≤⇒≯ (∣⇒≤ d∣n))
diff --git a/src/Data/Nat/DivMod.agda b/src/Data/Nat/DivMod.agda
index f2b2d8657e..86bc8d3168 100644
--- a/src/Data/Nat/DivMod.agda
+++ b/src/Data/Nat/DivMod.agda
@@ -11,21 +11,25 @@ module Data.Nat.DivMod where
 open import Agda.Builtin.Nat using (div-helper; mod-helper)
 
 open import Data.Fin.Base using (Fin; toℕ; fromℕ<)
-open import Data.Fin.Properties using (toℕ-fromℕ<)
-open import Data.Nat.Base as Nat
+open import Data.Fin.Properties using (nonZeroIndex; toℕ-fromℕ<)
+open import Data.Nat.Base
 open import Data.Nat.DivMod.Core
 open import Data.Nat.Divisibility.Core
 open import Data.Nat.Induction
 open import Data.Nat.Properties
-open import Function using (_$_)
-open import Relation.Binary.PropositionalEquality
-open import Relation.Nullary.Decidable using (yes; no)
-open import Relation.Nullary.Decidable using (False; toWitnessFalse)
-
-import Algebra.Properties.CommutativeSemigroup *-commutativeSemigroup as *-CS
+open import Data.Product.Base using (_,_)
+open import Data.Sum.Base using (inj₁; inj₂)
+open import Function.Base using (_$_; _∘_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; cong; cong₂; refl; trans; _≢_; sym)
+open import Relation.Nullary.Negation using (contradiction)
 
 open ≤-Reasoning
 
+private
+  variable
+    m n o p : ℕ
+
 ------------------------------------------------------------------------
 -- Definitions
 
@@ -33,25 +37,25 @@ open import Data.Nat.Base public
   using (_%_; _/_)
 
 ------------------------------------------------------------------------
--- Relationship between _%_ and _div_
+-- Relationship between _%_ and _/_
 
 m≡m%n+[m/n]*n : ∀ m n .{{_ : NonZero n}} → m ≡ m % n + (m / n) * n
 m≡m%n+[m/n]*n m (suc n) = div-mod-lemma 0 0 m n
 
 m%n≡m∸m/n*n : ∀ m n .{{_ : NonZero n}} → m % n ≡ m ∸ (m / n) * n
 m%n≡m∸m/n*n m n = begin-equality
-  m % n                  ≡˘⟨ m+n∸n≡m (m % n) m/n*n ⟩
-  m % n + m/n*n ∸ m/n*n  ≡˘⟨ cong (_∸ m/n*n) (m≡m%n+[m/n]*n m n) ⟩
+  m % n                  ≡⟨ m+n∸n≡m (m % n) m/n*n ⟨
+  m % n + m/n*n ∸ m/n*n  ≡⟨ cong (_∸ m/n*n) (m≡m%n+[m/n]*n m n) ⟨
   m ∸ m/n*n              ∎
   where m/n*n = (m / n) * n
 
 ------------------------------------------------------------------------
 -- Properties of _%_
 
-%-congˡ : ∀ {m n o} .⦃ _ : NonZero o ⦄ → m ≡ n → m % o ≡ n % o
+%-congˡ : .{{_ : NonZero o}} → m ≡ n → m % o ≡ n % o
 %-congˡ refl = refl
 
-%-congʳ : ∀ {m n o} .⦃ _ : NonZero m ⦄ .⦃ _ : NonZero n ⦄ → m ≡ n →
+%-congʳ : .{{_ : NonZero m}} .{{_ : NonZero n}} → m ≡ n →
           o % m ≡ o % n
 %-congʳ refl = refl
 
@@ -70,46 +74,27 @@ m%n%n≡m%n m (suc n-1) = modₕ-idem 0 m n-1
 [m+kn]%n≡m%n : ∀ m k n .{{_ : NonZero n}} → (m + k * n) % n ≡ m % n
 [m+kn]%n≡m%n m zero    n = cong (_% n) (+-identityʳ m)
 [m+kn]%n≡m%n m (suc k) n = begin-equality
-  (m + (n + k * n)) % n ≡⟨ cong (_% n) (sym (+-assoc m n (k * n))) ⟩
+  (m + (n + k * n)) % n ≡⟨ cong (_% n) (+-assoc m n (k * n)) ⟨
   (m + n + k * n)   % n ≡⟨ [m+kn]%n≡m%n (m + n) k n ⟩
   (m + n)           % n ≡⟨ [m+n]%n≡m%n m n ⟩
   m                 % n ∎
 
-m≤n⇒[n∸m]%m≡n%m : ∀ {m n} .⦃ _ : NonZero m ⦄ → m ≤ n →
+m≤n⇒[n∸m]%m≡n%m : .{{_ : NonZero m}} → m ≤ n →
                   (n ∸ m) % m ≡ n % m
 m≤n⇒[n∸m]%m≡n%m {m} {n} m≤n = begin-equality
-  (n ∸ m) % m     ≡˘⟨ [m+n]%n≡m%n (n ∸ m) m ⟩
+  (n ∸ m) % m     ≡⟨ [m+n]%n≡m%n (n ∸ m) m ⟨
   (n ∸ m + m) % m ≡⟨ cong (_% m) (m∸n+n≡m m≤n) ⟩
   n % m           ∎
 
-m*n≤o⇒[o∸m*n]%n≡o%n : ∀ m {n o} .⦃ _ : NonZero n ⦄ → m * n ≤ o →
+m*n≤o⇒[o∸m*n]%n≡o%n : ∀ m {n o} .{{_ : NonZero n}} → m * n ≤ o →
                       (o ∸ m * n) % n ≡ o % n
 m*n≤o⇒[o∸m*n]%n≡o%n m {n} {o} m*n≤o = begin-equality
-  (o ∸ m * n) % n         ≡˘⟨ [m+kn]%n≡m%n (o ∸ m * n) m n ⟩
+  (o ∸ m * n) % n         ≡⟨ [m+kn]%n≡m%n (o ∸ m * n) m n ⟨
   (o ∸ m * n + m * n) % n ≡⟨ cong (_% n) (m∸n+n≡m m*n≤o) ⟩
   o % n                   ∎
 
-m∣n⇒o%n%m≡o%m : ∀ m n o .⦃ _ : NonZero m ⦄ .⦃ _ : NonZero n ⦄ → m ∣ n →
-                o % n % m ≡ o % m
-m∣n⇒o%n%m≡o%m m n o (divides p refl) = begin-equality
-  o % pm % m               ≡⟨ %-congˡ (m%n≡m∸m/n*n o pm) ⟩
-  (o ∸ o / pm * pm) % m    ≡˘⟨ cong (λ # → (o ∸ #) % m) (*-assoc (o / pm) p m) ⟩
-  (o ∸ o / pm * p * m) % m ≡⟨ m*n≤o⇒[o∸m*n]%n≡o%n (o / pm * p) lem ⟩
-  o % m                    ∎
-  where
-  pm = p * m
-
-  lem : o / pm * p * m ≤ o
-  lem = begin
-    o / pm * p * m       ≡⟨ *-assoc (o / pm) p m ⟩
-    -- Sort out dependencies in this file, then use m/n*n≤m instead.
-    o / pm * pm          ≤⟨ m≤m+n (o / pm * pm) (o % pm) ⟩
-    o / pm * pm + o % pm ≡⟨ +-comm _ (o % pm) ⟩
-    o % pm + o / pm * pm ≡˘⟨ m≡m%n+[m/n]*n o pm ⟩
-    o                    ∎
-
 m*n%n≡0 : ∀ m n .{{_ : NonZero n}} → (m * n) % n ≡ 0
-m*n%n≡0 m (suc n-1) = [m+kn]%n≡m%n 0 m (suc n-1)
+m*n%n≡0 m n@(suc _) = [m+kn]%n≡m%n 0 m n
 
 m%n<n : ∀ m n .{{_ : NonZero n}} → m % n < n
 m%n<n m (suc n-1) = s≤s (a[modₕ]n<n 0 m n-1)
@@ -120,12 +105,12 @@ m%n≤n m n = <⇒≤ (m%n<n m n)
 m%n≤m : ∀ m n .{{_ : NonZero n}} → m % n ≤ m
 m%n≤m m (suc n-1) = a[modₕ]n≤a 0 m n-1
 
-m≤n⇒m%n≡m : ∀ {m n} → m ≤ n → m % suc n ≡ m
-m≤n⇒m%n≡m {m} {n} m≤n with ≤⇒≤″ m≤n
-... | less-than-or-equal {k} refl = a≤n⇒a[modₕ]n≡a 0 (m + k) m k
+m≤n⇒m%n≡m : m ≤ n → m % suc n ≡ m
+m≤n⇒m%n≡m {m = m} m≤n with k , refl ← m≤n⇒∃[o]m+o≡n m≤n
+  = a≤n⇒a[modₕ]n≡a 0 (m + k) m k
 
-m<n⇒m%n≡m : ∀ {m n} .⦃ _ : NonZero n ⦄ → m < n → m % n ≡ m
-m<n⇒m%n≡m {m} {suc n} m<n = m≤n⇒m%n≡m (<⇒≤pred m<n)
+m<n⇒m%n≡m : .{{_ : NonZero n}} → m < n → m % n ≡ m
+m<n⇒m%n≡m {n = suc _} m<n = m≤n⇒m%n≡m (<⇒≤pred m<n)
 
 %-pred-≡0 : ∀ {m n} .{{_ : NonZero n}} → (suc m % n) ≡ 0 → (m % n) ≡ n ∸ 1
 %-pred-≡0 {m} {suc n-1} eq = a+1[modₕ]n≡0⇒a[modₕ]n≡n-1 0 n-1 m eq
@@ -141,15 +126,15 @@ m<[1+n%d]⇒m≤[n%d] {m} n (suc d-1) = k<1+a[modₕ]n⇒k≤a[modₕ]n 0 m n d-
   (m + n)                         % d ≡⟨ cong (λ v → (v + n) % d) (m≡m%n+[m/n]*n m d) ⟩
   (m % d +  m / d * d + n)        % d ≡⟨ cong (_% d) (+-assoc (m % d) _ n) ⟩
   (m % d + (m / d * d + n))       % d ≡⟨ cong (λ v → (m % d + v) % d) (+-comm _ n) ⟩
-  (m % d + (n + m / d * d))       % d ≡⟨ cong (_% d) (sym (+-assoc (m % d) n _)) ⟩
+  (m % d + (n + m / d * d))       % d ≡⟨ cong (_% d) (+-assoc (m % d) n _) ⟨
   (m % d +  n + m / d * d)        % d ≡⟨ [m+kn]%n≡m%n (m % d + n) (m / d) d ⟩
   (m % d +  n)                    % d ≡⟨ cong (λ v → (m % d + v) % d) (m≡m%n+[m/n]*n n d) ⟩
-  (m % d + (n % d + (n / d) * d)) % d ≡⟨ sym (cong (_% d) (+-assoc (m % d) (n % d) _)) ⟩
+  (m % d + (n % d + (n / d) * d)) % d ≡⟨ cong (_% d) (+-assoc (m % d) (n % d) _) ⟨
   (m % d +  n % d + (n / d) * d)  % d ≡⟨ [m+kn]%n≡m%n (m % d + n % d) (n / d) d ⟩
   (m % d +  n % d)                % d ∎
 
 %-distribˡ-* : ∀ m n d .{{_ : NonZero d}} → (m * n) % d ≡ ((m % d) * (n % d)) % d
-%-distribˡ-* m n d@(suc d-1) = begin-equality
+%-distribˡ-* m n d = begin-equality
   (m * n)                                             % d ≡⟨ cong (λ h → (h * n) % d) (m≡m%n+[m/n]*n m d) ⟩
   ((m′ + k * d) * n)                                  % d ≡⟨ cong (λ h → ((m′ + k * d) * h) % d) (m≡m%n+[m/n]*n n d) ⟩
   ((m′ + k * d) * (n′ + j * d))                       % d ≡⟨ cong (_% d) lemma ⟩
@@ -166,32 +151,31 @@ m<[1+n%d]⇒m≤[n%d] {m} n (suc d-1) = k<1+a[modₕ]n⇒k≤a[modₕ]n 0 m n d-
     (m′ + k * d) * (n′ + j * d)                       ≡⟨ *-distribʳ-+ (n′ + j * d) m′ (k * d) ⟩
     m′ * (n′ + j * d) + (k * d) * (n′ + j * d)        ≡⟨ cong₂ _+_ (*-distribˡ-+ m′ n′ (j * d)) (*-comm (k * d) (n′ + j * d)) ⟩
     (m′ * n′ + m′ * (j * d)) + (n′ + j * d) * (k * d) ≡⟨ +-assoc (m′ * n′) (m′ * (j * d)) ((n′ + j * d) * (k * d)) ⟩
-    m′ * n′ + (m′ * (j * d) + (n′ + j * d) * (k * d)) ≡˘⟨ cong (m′ * n′ +_) (cong₂ _+_ (*-assoc m′ j d) (*-assoc (n′ + j * d) k d)) ⟩
-    m′ * n′ + ((m′ * j) * d + ((n′ + j * d) * k) * d) ≡˘⟨ cong (m′ * n′ +_) (*-distribʳ-+ d (m′ * j) ((n′ + j * d) * k)) ⟩
+    m′ * n′ + (m′ * (j * d) + (n′ + j * d) * (k * d)) ≡⟨ cong (m′ * n′ +_) (cong₂ _+_ (*-assoc m′ j d) (*-assoc (n′ + j * d) k d)) ⟨
+    m′ * n′ + ((m′ * j) * d + ((n′ + j * d) * k) * d) ≡⟨ cong (m′ * n′ +_) (*-distribʳ-+ d (m′ * j) ((n′ + j * d) * k)) ⟨
     m′ * n′ + (m′ * j + (n′ + j * d) * k) * d         ∎
 
 %-remove-+ˡ : ∀ {m} n {d} .{{_ : NonZero d}} → d ∣ m → (m + n) % d ≡ n % d
-%-remove-+ˡ {m} n {d@(suc d-1)} (divides p refl) = begin-equality
+%-remove-+ˡ {m@.(p * d)} n {d} (divides-refl p) = begin-equality
+  (m + n)     % d ≡⟨⟩
   (p * d + n) % d ≡⟨ cong (_% d) (+-comm (p * d) n) ⟩
   (n + p * d) % d ≡⟨ [m+kn]%n≡m%n n p d ⟩
   n           % d ∎
 
 %-remove-+ʳ : ∀ m {n d} .{{_ : NonZero d}} → d ∣ n → (m + n) % d ≡ m % d
-%-remove-+ʳ m {n} {suc _} eq rewrite +-comm m n = %-remove-+ˡ {n} m eq
+%-remove-+ʳ m {n} rewrite +-comm m n = %-remove-+ˡ {n} m
 
 ------------------------------------------------------------------------
 -- Properties of _/_
 
-/-congˡ : ∀ {m n o : ℕ} .{{_ : NonZero o}} →
-          m ≡ n → m / o ≡ n / o
+/-congˡ : .{{_ : NonZero o}} → m ≡ n → m / o ≡ n / o
 /-congˡ refl = refl
 
-/-congʳ : ∀ {m n o : ℕ} .{{_ : NonZero n}} .{{_ : NonZero o}} →
-          n ≡ o → m / n ≡ m / o
+/-congʳ : .{{_ : NonZero n}} .{{_ : NonZero o}} → n ≡ o → m / n ≡ m / o
 /-congʳ refl = refl
 
 0/n≡0 : ∀ n .{{_ : NonZero n}} → 0 / n ≡ 0
-0/n≡0 (suc n-1) = refl
+0/n≡0 (suc _) = refl
 
 n/1≡n : ∀ n → n / 1 ≡ n
 n/1≡n n = a[divₕ]1≡a 0 n
@@ -203,16 +187,16 @@ m*n/n≡m : ∀ m n .{{_ : NonZero n}} → m * n / n ≡ m
 m*n/n≡m m (suc n-1) = a*n[divₕ]n≡a 0 m n-1
 
 m/n*n≡m : ∀ {m n} .{{_ : NonZero n}} → n ∣ m → m / n * n ≡ m
-m/n*n≡m {_} {n@(suc n-1)} (divides q refl) = cong (_* n) (m*n/n≡m q n)
+m/n*n≡m {n = n} (divides-refl q) = cong (_* n) (m*n/n≡m q n)
 
-m*[n/m]≡n : ∀ {m n} .{{_ : NonZero m}} → m ∣ n → m * (n / m) ≡ n
+m*[n/m]≡n : .{{_ : NonZero m}} → m ∣ n → m * (n / m) ≡ n
 m*[n/m]≡n {m} m∣n = trans (*-comm m (_ / m)) (m/n*n≡m m∣n)
 
 m/n*n≤m : ∀ m n .{{_ : NonZero n}} → (m / n) * n ≤ m
-m/n*n≤m m n@(suc n-1) = begin
+m/n*n≤m m n = begin
   (m / n) * n          ≤⟨ m≤m+n ((m / n) * n) (m % n) ⟩
   (m / n) * n + m % n  ≡⟨ +-comm _ (m % n) ⟩
-  m % n + (m / n) * n  ≡⟨ sym (m≡m%n+[m/n]*n m n) ⟩
+  m % n + (m / n) * n  ≡⟨ m≡m%n+[m/n]*n m n ⟨
   m                    ∎
 
 m/n≤m : ∀ m n .{{_ : NonZero n}} → (m / n) ≤ m
@@ -221,17 +205,18 @@ m/n≤m m n = *-cancelʳ-≤ (m / n) m n (begin
   m           ≤⟨ m≤m*n m n ⟩
   m * n       ∎)
 
-m/n<m : ∀ m n .{{_ : NonZero m}} .{{_ : NonZero n}} → n ≥ 2 → m / n < m
-m/n<m m n n≥2 = *-cancelʳ-< _ (m / n) m (begin-strict
-  (m / n) * n ≤⟨ m/n*n≤m m n ⟩
-  m           <⟨ m<m*n m n n≥2 ⟩
-  m * n       ∎)
+m/n<m : ∀ m n .{{_ : NonZero m}} .{{_ : NonZero n}} →
+        1 < n → m / n < m
+m/n<m m n 1<n = *-cancelʳ-< _ (m / n) m $ begin-strict
+  m / n * n ≤⟨ m/n*n≤m m n ⟩
+  m         <⟨ m<m*n m n 1<n ⟩
+  m * n     ∎
 
-/-mono-≤ : ∀ {m n o p} .{{_ : NonZero o}} .{{_ : NonZero p}} →
+/-mono-≤ : .{{_ : NonZero o}} .{{_ : NonZero p}} →
            m ≤ n → o ≥ p → m / o ≤ n / p
 /-mono-≤ m≤n (s≤s o≥p) = divₕ-mono-≤ 0 m≤n o≥p
 
-/-monoˡ-≤ : ∀ {m n} o .{{_ : NonZero o}} → m ≤ n → m / o ≤ n / o
+/-monoˡ-≤ : ∀ o .{{_ : NonZero o}} → m ≤ n → m / o ≤ n / o
 /-monoˡ-≤ o m≤n = /-mono-≤ m≤n (≤-refl {o})
 
 /-monoʳ-≤ : ∀ m {n o} .{{_ : NonZero n}} .{{_ : NonZero o}} →
@@ -241,9 +226,9 @@ m/n<m m n n≥2 = *-cancelʳ-< _ (m / n) m (begin-strict
 /-cancelʳ-≡ : ∀ {m n o} .{{_ : NonZero o}} →
               o ∣ m → o ∣ n → m / o ≡ n / o → m ≡ n
 /-cancelʳ-≡ {m} {n} {o} o∣m o∣n m/o≡n/o = begin-equality
-  m           ≡˘⟨ m*[n/m]≡n {o} {m} o∣m ⟩
-  o * (m / o) ≡⟨  cong (o *_) m/o≡n/o ⟩
-  o * (n / o) ≡⟨  m*[n/m]≡n {o} {n} o∣n ⟩
+  m           ≡⟨ m*[n/m]≡n {o} {m} o∣m ⟨
+  o * (m / o) ≡⟨ cong (o *_) m/o≡n/o ⟩
+  o * (n / o) ≡⟨ m*[n/m]≡n {o} {n} o∣n ⟩
   n           ∎
 
 m<n⇒m/n≡0 : ∀ {m n} .{{_ : NonZero n}} → m < n → m / n ≡ 0
@@ -251,28 +236,41 @@ m<n⇒m/n≡0 {m} {suc n-1} (s≤s m≤n) = divₕ-finish n-1 m n-1 m≤n
 
 m≥n⇒m/n>0 : ∀ {m n} .{{_ : NonZero n}} → m ≥ n → m / n > 0
 m≥n⇒m/n>0 {m@(suc _)} {n@(suc _)} m≥n = begin
-  1     ≡⟨ sym (n/n≡1 m) ⟩
+  1     ≡⟨ n/n≡1 m ⟨
   m / m ≤⟨ /-monoʳ-≤ m m≥n ⟩
   m / n ∎
 
+m/n≡0⇒m<n : ∀ {m n} .{{_ : NonZero n}} → m / n ≡ 0 → m < n
+m/n≡0⇒m<n {m} {n@(suc _)} m/n≡0  with <-≤-connex m n
+... | inj₁ m<n = m<n
+... | inj₂ n≤m = contradiction m/n≡0 (≢-nonZero⁻¹ _)
+  where instance _ =  >-nonZero (m≥n⇒m/n>0 n≤m)
+
+m/n≢0⇒n≤m : ∀ {m n} .{{_ : NonZero n}} → m / n ≢ 0 → n ≤ m
+m/n≢0⇒n≤m {m} {n@(suc _)} m/n≢0 with <-≤-connex m n
+... | inj₁ m<n = contradiction (m<n⇒m/n≡0 m<n) m/n≢0
+... | inj₂ n≤m = n≤m
+
 +-distrib-/ : ∀ m n {d} .{{_ : NonZero d}} → m % d + n % d < d →
               (m + n) / d ≡ m / d + n / d
 +-distrib-/ m n {suc d-1} leq = +-distrib-divₕ 0 0 m n d-1 leq
 
 +-distrib-/-∣ˡ : ∀ {m} n {d} .{{_ : NonZero d}} →
                  d ∣ m → (m + n) / d ≡ m / d + n / d
-+-distrib-/-∣ˡ {m} n {d} (divides p refl) = +-distrib-/ m n (begin-strict
++-distrib-/-∣ˡ {m@.(p * d)} n {d} (divides-refl p) = +-distrib-/ m n $ begin-strict
+  m % d + n % d     ≡⟨⟩
   p * d % d + n % d ≡⟨ cong (_+ n % d) (m*n%n≡0 p d) ⟩
   n % d             <⟨ m%n<n n d ⟩
-  d                 ∎)
+  d                 ∎
 
 +-distrib-/-∣ʳ : ∀ m {n} {d} .{{_ : NonZero d}} →
                  d ∣ n → (m + n) / d ≡ m / d + n / d
-+-distrib-/-∣ʳ m {n} {d} (divides p refl) = +-distrib-/ m n (begin-strict
++-distrib-/-∣ʳ m {n@.(p * d)} {d} (divides-refl p) = +-distrib-/ m n $ begin-strict
+  m % d + n % d     ≡⟨⟩
   m % d + p * d % d ≡⟨ cong (m % d +_) (m*n%n≡0 p d) ⟩
   m % d + 0         ≡⟨ +-identityʳ _ ⟩
   m % d             <⟨ m%n<n m d ⟩
-  d                 ∎)
+  d                 ∎
 
 m/n≡1+[m∸n]/n : ∀ {m n} .{{_ : NonZero n}} → m ≥ n → m / n ≡ 1 + ((m ∸ n) / n)
 m/n≡1+[m∸n]/n {m@(suc m-1)} {n@(suc n-1)} m≥n = begin-equality
@@ -282,79 +280,92 @@ m/n≡1+[m∸n]/n {m@(suc m-1)} {n@(suc n-1)} m≥n = begin-equality
   1 + (div-helper 0 n-1 (m ∸ n) n-1) ≡⟨⟩
   1 + (m ∸ n) / n                    ∎
 
+[m∸n]/n≡m/n∸1 : ∀ m n .{{_ : NonZero n}} → (m ∸ n) / n ≡ pred (m / n)
+[m∸n]/n≡m/n∸1 m n with <-≤-connex m n
+... | inj₁ m<n = begin-equality
+  (m ∸ n) / n  ≡⟨ m<n⇒m/n≡0 (≤-<-trans (m∸n≤m m n) m<n) ⟩
+  0            ≡⟨⟩
+  pred 0       ≡⟨ cong pred (m<n⇒m/n≡0 m<n) ⟨
+  pred (m / n) ∎
+... | inj₂ n≥m = begin-equality
+  (m ∸ n) / n            ≡⟨⟩
+  pred (1 + (m ∸ n) / n) ≡⟨ cong pred (m/n≡1+[m∸n]/n n≥m) ⟨
+  pred (m / n)           ∎
+
+m∣n⇒o%n%m≡o%m : ∀ m n o .{{_ : NonZero m}} .{{_ : NonZero n}} → m ∣ n →
+                o % n % m ≡ o % m
+m∣n⇒o%n%m≡o%m m n@.(p * m) o (divides-refl p) = begin-equality
+  o % n % m                ≡⟨⟩
+  o % pm % m               ≡⟨ %-congˡ (m%n≡m∸m/n*n o pm) ⟩
+  (o ∸ o / pm * pm) % m    ≡⟨ cong (λ # → (o ∸ #) % m) (*-assoc (o / pm) p m) ⟨
+  (o ∸ o / pm * p * m) % m ≡⟨ m*n≤o⇒[o∸m*n]%n≡o%n (o / pm * p) lem ⟩
+  o % m                    ∎
+  where
+  pm = p * m
+
+  lem : o / pm * p * m ≤ o
+  lem = begin
+    o / pm * p * m       ≡⟨ *-assoc (o / pm) p m ⟩
+    o / pm * pm          ≤⟨ m/n*n≤m o pm ⟩
+    o                    ∎
+
 m*n/m*o≡n/o : ∀ m n o .{{_ : NonZero o}} .{{_ : NonZero (m * o)}} →
               (m * n) / (m * o) ≡ n / o
-m*n/m*o≡n/o m@(suc m-1) n o = helper (<-wellFounded n)
+m*n/m*o≡n/o m n o = helper (<-wellFounded n)
   where
+  instance _ = m*n≢0 m o
   helper : ∀ {n} → Acc _<_ n → (m * n) / (m * o) ≡ n / o
-  helper {n} (acc rec) with n <? o
-  ... | yes n<o = trans (m<n⇒m/n≡0 (*-monoʳ-< m n<o)) (sym (m<n⇒m/n≡0 n<o))
-  ... | no  n≮o = begin-equality
-    (m * n) / (m * o)             ≡⟨  m/n≡1+[m∸n]/n (*-monoʳ-≤ m (≮⇒≥ n≮o)) ⟩
-    1 + (m * n ∸ m * o) / (m * o) ≡˘⟨ cong (λ v → 1 + v / (m * o)) (*-distribˡ-∸ m n o) ⟩
-    1 + (m * (n ∸ o)) / (m * o)   ≡⟨  cong suc (helper (rec (n ∸ o) n∸o<n)) ⟩
-    1 + (n ∸ o) / o               ≡˘⟨ cong₂ _+_ (n/n≡1 o) refl ⟩
-    o / o + (n ∸ o) / o           ≡˘⟨ +-distrib-/-∣ˡ (n ∸ o) (divides 1 ((sym (*-identityˡ o)))) ⟩
-    (o + (n ∸ o)) / o             ≡⟨  cong (_/ o) (m+[n∸m]≡n (≮⇒≥ n≮o)) ⟩
+  helper {n} (acc rec) with <-≤-connex n o
+  ... | inj₁ n<o = trans (m<n⇒m/n≡0 (*-monoʳ-< m n<o)) (sym (m<n⇒m/n≡0 n<o))
+    where instance _ = m*n≢0⇒m≢0 m
+  ... | inj₂ n≥o = begin-equality
+    (m * n) / (m * o)             ≡⟨ m/n≡1+[m∸n]/n (*-monoʳ-≤ m n≥o) ⟩
+    1 + (m * n ∸ m * o) / (m * o) ≡⟨ cong (suc ∘ (_/ (m * o))) (*-distribˡ-∸ m n o) ⟨
+    1 + (m * (n ∸ o)) / (m * o)   ≡⟨ cong suc (helper (rec n∸o<n)) ⟩
+    1 + (n ∸ o) / o               ≡⟨ m/n≡1+[m∸n]/n n≥o ⟨
     n / o                         ∎
-    where n∸o<n = ∸-monoʳ-< (n≢0⇒n>0 (≢-nonZero⁻¹ o)) (≮⇒≥ n≮o)
+    where n∸o<n = ∸-monoʳ-< (n≢0⇒n>0 (≢-nonZero⁻¹ o)) n≥o
 
-m*n/o*n≡m/o : ∀ m n o .⦃ _ : NonZero o ⦄ ⦃ _ : NonZero (o * n) ⦄ →
+m*n/o*n≡m/o : ∀ m n o .{{_ : NonZero o}} .{{_ : NonZero (o * n)}} →
               m * n / (o * n) ≡ m / o
-m*n/o*n≡m/o m n o ⦃ _ ⦄ ⦃ o*n≢0 ⦄ = begin-equality
+m*n/o*n≡m/o m n o = begin-equality
   m * n / (o * n) ≡⟨ /-congˡ (*-comm m n) ⟩
   n * m / (o * n) ≡⟨ /-congʳ (*-comm o n) ⟩
   n * m / (n * o) ≡⟨ m*n/m*o≡n/o n m o ⟩
   m / o           ∎
-  where instance n*o≢0 = subst NonZero (*-comm o n) o*n≢0
-
-m<n*o⇒m/o<n : ∀ {m n o} .⦃ _ : NonZero o ⦄ → m < n * o → m / o < n
-m<n*o⇒m/o<n {m} {suc n} {o} m<n*o with m <? o
-... | yes m<o = begin-strict
+  where instance
+    _ : NonZero n
+    _ = m*n≢0⇒n≢0 o
+    _ : NonZero (n * o)
+    _ = m*n≢0 n o
+
+m<n*o⇒m/o<n : ∀ {m n o} .{{_ : NonZero o}} → m < n * o → m / o < n
+m<n*o⇒m/o<n {m} {1} {o} m<o rewrite *-identityˡ o = begin-strict
   m / o ≡⟨ m<n⇒m/n≡0 m<o ⟩
   0     <⟨ z<s ⟩
-  suc n ∎
-... | no m≮o = begin-strict
-  m / o             ≡⟨ m/n≡1+[m∸n]/n (≮⇒≥ m≮o) ⟩
-  suc ((m ∸ o) / o) <⟨ s≤s (m<n*o⇒m/o<n lem) ⟩
-  suc n             ∎
-  where
-  lem : m ∸ o < n * o
-  lem = begin-strict
-    m ∸ o         <⟨ ∸-monoˡ-< m<n*o (≮⇒≥ m≮o) ⟩
-    o + n * o ∸ o ≡⟨ m+n∸m≡n o (n * o) ⟩
-    n * o         ∎
-
-[m∸n]/n≡m/n∸1 : ∀ m n .⦃ _ : NonZero n ⦄ → (m ∸ n) / n ≡ pred (m / n)
-[m∸n]/n≡m/n∸1 m n with m <? n
-... | yes m<n = begin-equality
-  (m ∸ n) / n  ≡⟨ m<n⇒m/n≡0 (<-transʳ (m∸n≤m m n) m<n) ⟩
-  0            ≡⟨⟩
-  0 ∸ 1        ≡˘⟨ cong (_∸ 1) (m<n⇒m/n≡0 m<n) ⟩
-  m / n ∸ 1    ≡⟨⟩
-  pred (m / n) ∎
-... | no m≮n = begin-equality
-  (m ∸ n) / n           ≡⟨⟩
-  suc ((m ∸ n) / n) ∸ 1 ≡˘⟨ cong (_∸ 1) (m/n≡1+[m∸n]/n (≮⇒≥ m≮n)) ⟩
-  m / n ∸ 1             ≡⟨⟩
-  pred (m / n)          ∎
-
-[m∸n*o]/o≡m/o∸n : ∀ m n o .⦃ _ : NonZero o ⦄ → (m ∸ n * o) / o ≡ m / o ∸ n
+  1 ∎
+m<n*o⇒m/o<n {m} {suc n@(suc _)} {o} m<n*o = pred-cancel-< $ begin-strict
+  pred (m / o) ≡⟨ [m∸n]/n≡m/n∸1 m o ⟨
+  (m ∸ o) / o  <⟨ m<n*o⇒m/o<n (m<n+o⇒m∸n<o m o m<n*o) ⟩
+  n ∎
+  where instance _ = m*n≢0 n o
+
+[m∸n*o]/o≡m/o∸n : ∀ m n o .{{_ : NonZero o}} → (m ∸ n * o) / o ≡ m / o ∸ n
 [m∸n*o]/o≡m/o∸n m zero    o = refl
 [m∸n*o]/o≡m/o∸n m (suc n) o = begin-equality
-  (m ∸ (o + n * o)) / o ≡˘⟨ /-congˡ (∸-+-assoc m o (n * o)) ⟩
+  (m ∸ (o + n * o)) / o ≡⟨ /-congˡ (∸-+-assoc m o (n * o)) ⟨
   (m ∸ o ∸ n * o) / o   ≡⟨ [m∸n*o]/o≡m/o∸n (m ∸ o) n o ⟩
   (m ∸ o) / o ∸ n       ≡⟨ cong (_∸ n) ([m∸n]/n≡m/n∸1 m o) ⟩
   m / o ∸ 1 ∸ n         ≡⟨ ∸-+-assoc (m / o) 1 n ⟩
   m / o ∸ suc n         ∎
 
-m/n/o≡m/[n*o] : ∀ m n o .⦃ _ : NonZero n ⦄ .⦃ _ : NonZero o ⦄
-                .⦃ _ : NonZero (n * o) ⦄ → m / n / o ≡ m / (n * o)
+m/n/o≡m/[n*o] : ∀ m n o .{{_ : NonZero n}} .{{_ : NonZero o}}
+                .{{_ : NonZero (n * o)}} → m / n / o ≡ m / (n * o)
 m/n/o≡m/[n*o] m n o = begin-equality
   m / n / o                             ≡⟨ /-congˡ {o = o} (/-congˡ (m≡m%n+[m/n]*n m n*o)) ⟩
   (m % n*o + m / n*o * n*o) / n / o     ≡⟨ /-congˡ (+-distrib-/-∣ʳ (m % n*o) lem₁) ⟩
   (m % n*o / n + m / n*o * n*o / n) / o ≡⟨ cong (λ # → (m % n*o / n + #) / o) lem₂ ⟩
-  (m % n*o / n + m / n*o * o) / o       ≡⟨ +-distrib-/-∣ʳ (m % n*o / n) (divides (m / n*o) refl) ⟩
+  (m % n*o / n + m / n*o * o) / o       ≡⟨ +-distrib-/-∣ʳ (m % n*o / n) (divides-refl (m / n*o)) ⟩
   m % n*o / n / o + m / n*o * o / o     ≡⟨ cong (m % n*o / n / o +_) (m*n/n≡m (m / n*o) o) ⟩
   m % n*o / n / o + m / n*o             ≡⟨ cong (_+ m / n*o) (m<n⇒m/n≡0 (m<n*o⇒m/o<n {n = o} lem₃)) ⟩
   m / n*o                               ∎
@@ -365,13 +376,13 @@ m/n/o≡m/[n*o] m n o = begin-equality
   lem₁ : n ∣ m / n*o * n*o
   lem₁ = divides (m / n*o * o) $ begin-equality
     m / n*o * n*o   ≡⟨ cong (m / n*o *_) (*-comm n o) ⟩
-    m / n*o * o*n   ≡˘⟨ *-assoc (m / n*o) o n ⟩
+    m / n*o * o*n   ≡⟨ *-assoc (m / n*o) o n ⟨
     m / n*o * o * n ∎
 
   lem₂ : m / n*o * n*o / n ≡ m / n*o * o
   lem₂ = begin-equality
     m / n*o * n*o / n   ≡⟨ cong (λ # → m / n*o * # / n) (*-comm n o) ⟩
-    m / n*o * o*n / n   ≡˘⟨ /-congˡ (*-assoc (m / n*o) o n) ⟩
+    m / n*o * o*n / n   ≡⟨ /-congˡ (*-assoc (m / n*o) o n) ⟨
     m / n*o * o * n / n ≡⟨ m*n/n≡m (m / n*o * o) n ⟩
     m / n*o * o         ∎
 
@@ -382,49 +393,56 @@ m/n/o≡m/[n*o] m n o = begin-equality
     o*n     ∎
 
 *-/-assoc : ∀ m {n d} .{{_ : NonZero d}} → d ∣ n → m * n / d ≡ m * (n / d)
-*-/-assoc zero    {_} {d@(suc _)} d∣n = 0/n≡0 (suc d)
-*-/-assoc (suc m) {n} {d@(suc _)} d∣n = begin-equality
+*-/-assoc zero    {_} {d} d∣n = 0/n≡0 d
+*-/-assoc (suc m) {n} {d} d∣n = begin-equality
   (n + m * n) / d     ≡⟨ +-distrib-/-∣ˡ _ d∣n ⟩
   n / d + (m * n) / d ≡⟨ cong (n / d +_) (*-/-assoc m d∣n) ⟩
   n / d + m * (n / d) ∎
 
-/-*-interchange : ∀ {m n o p} .{{_ : NonZero o}} .{{_ : NonZero p}} .{{_ : NonZero (o * p)}} →
+/-*-interchange : .{{_ : NonZero o}} .{{_ : NonZero p}} .{{_ : NonZero (o * p)}} →
                   o ∣ m → p ∣ n → (m * n) / (o * p) ≡ (m / o) * (n / p)
-/-*-interchange {m} {n} {o@(suc _)} {p@(suc _)} o∣m p∣n = *-cancelˡ-≡ _ _ (o * p) (begin-equality
-  (o * p) * ((m * n) / (o * p)) ≡⟨  m*[n/m]≡n (*-pres-∣ o∣m p∣n) ⟩
-  m * n                         ≡˘⟨ cong₂ _*_ (m*[n/m]≡n o∣m) (m*[n/m]≡n p∣n) ⟩
-  (o * (m / o)) * (p * (n / p)) ≡⟨ [m*n]*[o*p]≡[m*o]*[n*p] o (m / o) p (n / p) ⟩
-  (o * p) * ((m / o) * (n / p)) ∎)
+/-*-interchange {o} {p} {m@.(q * o)} {n@.(r * p)} (divides-refl q) (divides-refl r)
+  = begin-equality
+  (m * n) / (o * p) ≡⟨⟩
+  q * o * (r * p) / (o * p) ≡⟨ /-congˡ ([m*n]*[o*p]≡[m*o]*[n*p] q o r p) ⟩
+  q * r * (o * p) / (o * p) ≡⟨ m*n/n≡m (q * r) (o * p) ⟩
+  q * r                     ≡⟨ cong₂ _*_ (m*n/n≡m q o) (m*n/n≡m r p) ⟨
+  (q * o / o) * (r * p / p) ≡⟨⟩
+  (m / o) * (n / p)         ∎
 
 m*n/m!≡n/[m∸1]! : ∀ m n .{{_ : NonZero m}} →
-                 (m * n / m !) {{m !≢0}}  ≡ (n / (pred m) !) {{pred m !≢0}}
-m*n/m!≡n/[m∸1]! (suc m) n = m*n/m*o≡n/o (suc m) n (m !) {{m !≢0}} {{suc m !≢0}}
-
-m%[n*o]/o≡m/o%n : ∀ m n o .⦃ _ : NonZero n ⦄ .⦃ _ : NonZero o ⦄
-                  ⦃ _ : NonZero (n * o) ⦄ → m % (n * o) / o ≡ m / o % n
-m%[n*o]/o≡m/o%n m n o ⦃ _ ⦄ ⦃ _ ⦄ ⦃ n*o≢0 ⦄ = begin-equality
+                  let instance _ = m !≢0 ; instance _ = (pred m) !≢0 in
+                  (m * n / m !) ≡ (n / (pred m) !)
+m*n/m!≡n/[m∸1]! m′@(suc m) n = m*n/m*o≡n/o m′ n (m !)
+  where instance
+    _ = m !≢0
+    _ = m′ !≢0
+
+m%[n*o]/o≡m/o%n : ∀ m n o .{{_ : NonZero n}} .{{_ : NonZero o}} →
+                  {{_ : NonZero (n * o)}} → m % (n * o) / o ≡ m / o % n
+m%[n*o]/o≡m/o%n m n o = begin-equality
   m % (n * o) / o                   ≡⟨ /-congˡ (m%n≡m∸m/n*n m (n * o)) ⟩
-  (m ∸ (m / (n * o) * (n * o))) / o ≡˘⟨ cong (λ # → (m ∸ #) / o) (*-assoc (m / (n * o)) n o) ⟩
+  (m ∸ (m / (n * o) * (n * o))) / o ≡⟨ cong (λ # → (m ∸ #) / o) (*-assoc (m / (n * o)) n o) ⟨
   (m ∸ (m / (n * o) * n * o)) / o   ≡⟨ [m∸n*o]/o≡m/o∸n m (m / (n * o) * n) o ⟩
   m / o ∸ m / (n * o) * n           ≡⟨ cong (λ # → m / o ∸ # * n) (/-congʳ (*-comm n o)) ⟩
-  m / o ∸ m / (o * n) * n           ≡˘⟨ cong (λ # → m / o ∸ # * n) (m/n/o≡m/[n*o] m o n ) ⟩
-  m / o ∸ m / o / n * n             ≡˘⟨ m%n≡m∸m/n*n (m / o) n ⟩
+  m / o ∸ m / (o * n) * n           ≡⟨ cong (λ # → m / o ∸ # * n) (m/n/o≡m/[n*o] m o n ) ⟨
+  m / o ∸ m / o / n * n             ≡⟨ m%n≡m∸m/n*n (m / o) n ⟨
   m / o % n                         ∎
-  where instance o*n≢0 = subst NonZero (*-comm n o) n*o≢0
+  where instance _ = m*n≢0 o n
 
-m%n*o≡m*o%[n*o] : ∀ m n o .⦃ _ : NonZero n ⦄ ⦃ _ : NonZero (n * o) ⦄ →
+m%n*o≡m*o%[n*o] : ∀ m n o .{{_ : NonZero n}} .{{_ : NonZero (n * o)}} →
                   m % n * o ≡ m * o % (n * o)
-m%n*o≡m*o%[n*o] m n o ⦃ _ ⦄ ⦃ n*o≢0 ⦄ = begin-equality
+m%n*o≡m*o%[n*o] m n o = begin-equality
   m % n * o                         ≡⟨ cong (_* o) (m%n≡m∸m/n*n m n) ⟩
   (m ∸ m / n * n) * o               ≡⟨ *-distribʳ-∸ o m (m / n * n) ⟩
-  m * o ∸ m / n * n * o             ≡˘⟨ cong (λ # → m * o ∸ # * n * o) (m*n/o*n≡m/o m o n) ⟩
+  m * o ∸ m / n * n * o             ≡⟨ cong (λ # → m * o ∸ # * n * o) (m*n/o*n≡m/o m o n) ⟨
   m * o ∸ m * o / (n * o) * n * o   ≡⟨ cong (m * o ∸_) (*-assoc (m * o / (n * o)) n o) ⟩
-  m * o ∸ m * o / (n * o) * (n * o) ≡˘⟨ m%n≡m∸m/n*n (m * o) (n * o) ⟩
+  m * o ∸ m * o / (n * o) * (n * o) ≡⟨ m%n≡m∸m/n*n (m * o) (n * o) ⟨
   m * o % (n * o)                   ∎
 
-[m*n+o]%[p*n]≡[m*n]%[p*n]+o : ∀ m {n o} p ⦃ _ : NonZero (p * n) ⦄ → o < n →
+[m*n+o]%[p*n]≡[m*n]%[p*n]+o : ∀ m {n o} p .{{_ : NonZero (p * n)}} → o < n →
                               (m * n + o) % (p * n) ≡ (m * n) % (p * n) + o
-[m*n+o]%[p*n]≡[m*n]%[p*n]+o m {n} {o} p@(suc p-1) ⦃ p*n≢0 ⦄ o<n = begin-equality
+[m*n+o]%[p*n]≡[m*n]%[p*n]+o m {n} {o} p@(suc p-1) o<n = begin-equality
   (mn + o) % pn           ≡⟨ %-distribˡ-+ mn o pn ⟩
   (mn % pn + o % pn) % pn ≡⟨ cong (λ # → (mn % pn + #) % pn) (m<n⇒m%n≡m (m<n⇒m<o*n p o<n)) ⟩
   (mn % pn + o) % pn      ≡⟨ m<n⇒m%n≡m lem₂ ⟩
@@ -435,7 +453,7 @@ m%n*o≡m*o%[n*o] m n o ⦃ _ ⦄ ⦃ n*o≢0 ⦄ = begin-equality
 
   lem₁ : mn % pn ≤ p-1 * n
   lem₁ = begin
-    mn % pn     ≡˘⟨ m%n*o≡m*o%[n*o] m p n ⟩
+    mn % pn     ≡⟨ m%n*o≡m*o%[n*o] m p n ⟨
     (m % p) * n ≤⟨ *-monoˡ-≤ n (m<1+n⇒m≤n (m%n<n m p)) ⟩
     p-1 * n     ∎
 
@@ -455,18 +473,23 @@ record DivMod (dividend divisor : ℕ) : Set where
     remainder : Fin divisor
     property  : dividend ≡ toℕ remainder + quotient * divisor
 
+  nonZeroDivisor : NonZero divisor
+  nonZeroDivisor = nonZeroIndex remainder
+
+
 infixl 7 _div_ _mod_ _divMod_
 
 _div_ : (dividend divisor : ℕ) .{{_ : NonZero divisor}} → ℕ
 _div_ = _/_
 
 _mod_ : (dividend divisor : ℕ) .{{_ : NonZero divisor}} → Fin divisor
-m mod (suc n) = fromℕ< (m%n<n m (suc n))
+m mod n = fromℕ< (m%n<n m n)
 
 _divMod_ : (dividend divisor : ℕ) .{{_ : NonZero divisor}} →
            DivMod dividend divisor
-m divMod n@(suc n-1) = result (m / n) (m mod n) (begin-equality
-  m                                   ≡⟨  m≡m%n+[m/n]*n m n ⟩
-  m % n                    + [m/n]*n  ≡˘⟨ cong (_+ [m/n]*n) (toℕ-fromℕ< (m%n<n m n)) ⟩
-  toℕ (fromℕ< (m%n<n m n)) + [m/n]*n  ∎)
-  where [m/n]*n = m / n * n
+m divMod n = result (m / n) (m mod n) $ begin-equality
+  m                               ≡⟨  m≡m%n+[m/n]*n m n ⟩
+  m % n                + [m/n]*n  ≡⟨ cong (_+ [m/n]*n) (toℕ-fromℕ< [m%n]<n) ⟨
+  toℕ (fromℕ< [m%n]<n) + [m/n]*n  ∎
+  where [m/n]*n = m / n * n ; [m%n]<n = m%n<n m n
+
diff --git a/src/Data/Nat/DivMod/Core.agda b/src/Data/Nat/DivMod/Core.agda
index 02b1c917c6..7e627f4bfa 100644
--- a/src/Data/Nat/DivMod/Core.agda
+++ b/src/Data/Nat/DivMod/Core.agda
@@ -11,17 +11,19 @@ module Data.Nat.DivMod.Core where
 open import Agda.Builtin.Nat using ()
   renaming (div-helper to divₕ; mod-helper to modₕ)
 
-open import Data.Nat.Base
+open import Data.Nat.Base using (zero; suc; _+_; _*_; _∸_; _≤_; _<_;
+ _≥_; z≤n; s≤s)
 open import Data.Nat.Properties
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
-open import Data.Product using (_×_; _,_)
-open import Relation.Binary.PropositionalEquality
+open import Data.Product.Base using (_×_; _,_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; sym; subst; trans)
 open import Relation.Nullary.Decidable using (yes; no)
 open import Relation.Nullary.Negation using (contradiction)
 
 open ≤-Reasoning
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Helper lemmas that have no interpretation for _%_, only for modₕ
 
 private
@@ -38,7 +40,7 @@ private
     modₕ (a + suc acc) n b 0       ≡⟨ cong (λ v → modₕ v n b 0) (+-suc a acc) ⟩
     modₕ (suc a + acc) n b 0       ∎
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Lemmas for modₕ that also have an interpretation for _%_
 
 a[modₕ]1≡0 : ∀ a → modₕ 0 0 a 0 ≡ 0
@@ -120,7 +122,7 @@ a+n[modₕ]n≡a[modₕ]n acc (suc a) (suc n) rewrite +-suc acc n = begin-equali
   mod₁ = modₕ acc       (suc acc + n)
   mod₂ = modₕ (suc acc) (suc acc + n)
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Helper lemmas that have no interpretation for `_/_`, only for `divₕ`
 
 private
@@ -154,14 +156,14 @@ private
   divₕ-offsetEq d (suc n) zero    zero    j≤d k≤d (inj₂′ (refl , _)) =
     divₕ-offsetEq d n d d ≤-refl ≤-refl (inj₂′ (refl , a[modₕ]n<n 0 n d , ≤-refl))
   divₕ-offsetEq d (suc n) zero    zero    j≤d k≤d (inj₃ (_ , 0<mod , mod≤0)) =
-    contradiction (<-transˡ 0<mod mod≤0) λ()
+    contradiction (<-≤-trans 0<mod mod≤0) λ()
   -- (0 , suc) cases
   divₕ-offsetEq d (suc n) zero (suc k)    j≤d k≤d (inj₁  (refl , _ , 1+k<mod)) =
     divₕ-offsetEq d n d k ≤-refl (<⇒≤ k≤d) (inj₃ (refl , k<1+a[modₕ]n⇒k≤a[modₕ]n 0 (suc k) n d 1+k<mod , a[modₕ]n<n 0 n d))
   divₕ-offsetEq d (suc n) zero (suc k)    j≤d k≤d (inj₂′ (refl , mod≤0 , _)) =
     divₕ-offsetEq d n d k ≤-refl (<⇒≤ k≤d) (inj₃ (refl , subst (k <_) (sym (a+1[modₕ]n≡0⇒a[modₕ]n≡n-1 0 d n (n≤0⇒n≡0 mod≤0))) k≤d , a[modₕ]n<n 0 n d))
   divₕ-offsetEq d (suc n) zero (suc k)    j≤d k≤d (inj₃  (_ , 1+k<mod , mod≤0)) =
-    contradiction (<-transˡ 1+k<mod mod≤0) λ()
+    contradiction (<-≤-trans 1+k<mod mod≤0) λ()
   -- (suc , 0) cases
   divₕ-offsetEq d (suc n) (suc j) zero j≤d k≤d (inj₁  (_ , () , _))
   divₕ-offsetEq d (suc n) (suc j) zero j≤d k≤d (inj₂′ (_ , _ , ()))
@@ -174,9 +176,9 @@ private
   ... | yes mod≡0 = divₕ-offsetEq d n j k (<⇒≤ j≤d) (<⇒≤ k≤d) (inj₁ (eq , j≤k , subst (k <_) (sym (a+1[modₕ]n≡0⇒a[modₕ]n≡n-1 0 d n mod≡0)) k≤d))
   ... | no  mod≢0 = divₕ-offsetEq d n j k (<⇒≤ j≤d) (<⇒≤ k≤d) (inj₂′ (eq , 1+a[modₕ]n≤1+k⇒a[modₕ]n≤k 0 j n d (n≢0⇒n>0 mod≢0) mod≤1+j , j≤k))
   divₕ-offsetEq d (suc n) (suc j) (suc k) j≤d k≤d (inj₃  (eq , k<mod , mod≤1+j)) =
-    divₕ-offsetEq d n j k (<⇒≤ j≤d) (<⇒≤ k≤d) (inj₃ (eq , k<1+a[modₕ]n⇒k≤a[modₕ]n 0 (suc k) n d k<mod , 1+a[modₕ]n≤1+k⇒a[modₕ]n≤k 0 j n d (<-transʳ z≤n k<mod) mod≤1+j))
+    divₕ-offsetEq d n j k (<⇒≤ j≤d) (<⇒≤ k≤d) (inj₃ (eq , k<1+a[modₕ]n⇒k≤a[modₕ]n 0 (suc k) n d k<mod , 1+a[modₕ]n≤1+k⇒a[modₕ]n≤k 0 j n d (≤-<-trans z≤n k<mod) mod≤1+j))
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Lemmas for divₕ that also have an interpretation for _/_
 
 -- The quotient and remainder are related to the dividend and
diff --git a/src/Data/Nat/DivMod/WithK.agda b/src/Data/Nat/DivMod/WithK.agda
index 458a7eef33..c161d7ab3e 100644
--- a/src/Data/Nat/DivMod/WithK.agda
+++ b/src/Data/Nat/DivMod/WithK.agda
@@ -8,16 +8,17 @@
 
 module Data.Nat.DivMod.WithK where
 
-open import Data.Nat using (ℕ; NonZero; _+_; _*_; _≟_)
+open import Data.Nat.Base using (ℕ; NonZero; _+_; _*_)
 open import Data.Nat.DivMod hiding (_mod_; _divMod_)
 open import Data.Nat.Properties using (≤⇒≤″)
-open import Data.Nat.WithK
+open import Data.Nat.WithK using (≤″-erase)
 open import Data.Fin.Base using (Fin; toℕ; fromℕ<″)
 open import Data.Fin.Properties using (toℕ-fromℕ<″)
 open import Function.Base using (_$_)
-open import Relation.Binary.PropositionalEquality
-  using (refl; sym; cong; module ≡-Reasoning)
-open import Relation.Binary.PropositionalEquality.WithK
+open import Relation.Binary.PropositionalEquality.Core using (cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
+open import Relation.Binary.PropositionalEquality.WithK using (≡-erase)
 
 open ≡-Reasoning
 
@@ -27,17 +28,15 @@ infixl 7 _mod_ _divMod_
 -- Certified modulus
 
 _mod_ : (dividend divisor : ℕ) → .{{ _ : NonZero divisor }} → Fin divisor
-a mod n = fromℕ<″ (a % n) (≤″-erase (≤⇒≤″ (m%n<n a n)))
+m mod n = fromℕ<″ (m % n) (≤″-erase (≤⇒≤″ (m%n<n m n)))
 
 ------------------------------------------------------------------------
 -- Returns modulus and division result with correctness proof
 
 _divMod_ : (dividend divisor : ℕ) → .{{ NonZero divisor }} →
            DivMod dividend divisor
-a divMod n = result (a / n) (a mod n) $ ≡-erase $ begin
-  a                                 ≡⟨ m≡m%n+[m/n]*n a n ⟩
-  a % n              + [a/n]*n      ≡⟨ cong (_+ [a/n]*n) (sym (toℕ-fromℕ<″ lemma′)) ⟩
-  toℕ (fromℕ<″ _ lemma′) + [a/n]*n  ∎
-  where
-  lemma′ = ≤″-erase (≤⇒≤″ (m%n<n a n))
-  [a/n]*n = a / n * n
+m divMod n = result (m / n) (m mod n) $ ≡-erase $ begin
+  m                                 ≡⟨ m≡m%n+[m/n]*n m n ⟩
+  m % n                  + [m/n]*n  ≡⟨ cong (_+ [m/n]*n) (toℕ-fromℕ<″ lemma″) ⟨
+  toℕ (fromℕ<″ _ lemma″) + [m/n]*n  ∎
+  where [m/n]*n = m / n * n ; lemma″ = ≤″-erase (≤⇒≤″ (m%n<n m n))
diff --git a/src/Data/Nat/Divisibility.agda b/src/Data/Nat/Divisibility.agda
index 07a80bcdd9..c5d42a2c90 100644
--- a/src/Data/Nat/Divisibility.agda
+++ b/src/Data/Nat/Divisibility.agda
@@ -8,44 +8,82 @@
 
 module Data.Nat.Divisibility where
 
-open import Algebra
 open import Data.Nat.Base
 open import Data.Nat.DivMod
+  using (m≡m%n+[m/n]*n; m%n≡m∸m/n*n; m*n/n≡m; m*n%n≡0; *-/-assoc)
 open import Data.Nat.Properties
-open import Data.Product
-open import Data.Unit using (tt)
-open import Function.Base
+open import Function.Base using (_∘′_; _$_; flip)
 open import Function.Bundles using (_⇔_; mk⇔)
 open import Level using (0ℓ)
-open import Relation.Nullary.Decidable using (yes; no)
-open import Relation.Nullary.Decidable as Dec using (False)
-open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Binary
-import Relation.Binary.Reasoning.Preorder as PreorderReasoning
-open import Relation.Binary.PropositionalEquality as PropEq
-  using (_≡_; _≢_; refl; sym; trans; cong; cong₂; subst)
+open import Relation.Nullary.Decidable as Dec using (yes; no)
+open import Relation.Nullary.Negation.Core using (contradiction)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Bundles using (Preorder; Poset)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder)
+open import Relation.Binary.Definitions
+  using (Reflexive; Transitive; Antisymmetric; Decidable)
+import Relation.Binary.Reasoning.Preorder as ≲-Reasoning
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≢_; refl; sym; cong; subst)
+open import Relation.Binary.Reasoning.Syntax
+open import Relation.Binary.PropositionalEquality.Properties
+  using (isEquivalence; module ≡-Reasoning)
+
+private
+  variable d m n o p : ℕ
+
+
+------------------------------------------------------------------------
+-- Definition and derived properties
+
+open import Data.Nat.Divisibility.Core public hiding (*-pres-∣)
+
+quotient≢0 : (m∣n : m ∣ n) → .{{NonZero n}} → NonZero (quotient m∣n)
+quotient≢0 m∣n rewrite _∣_.equality m∣n = m*n≢0⇒m≢0 (quotient m∣n)
+
+m∣n⇒n≡quotient*m : (m∣n : m ∣ n) → n ≡ (quotient m∣n) * m
+m∣n⇒n≡quotient*m m∣n = _∣_.equality m∣n
+
+m∣n⇒n≡m*quotient : (m∣n : m ∣ n) → n ≡ m * (quotient m∣n)
+m∣n⇒n≡m*quotient {m = m} m∣n rewrite _∣_.equality m∣n = *-comm (quotient m∣n) m
+
+quotient-∣ : (m∣n : m ∣ n) → (quotient m∣n) ∣ n
+quotient-∣ {m = m} m∣n = divides m (m∣n⇒n≡m*quotient m∣n)
+
+quotient>1 : (m∣n : m ∣ n) → m < n → 1 < quotient m∣n
+quotient>1 {m} {n} m∣n m<n = *-cancelˡ-< m 1 (quotient m∣n) $ begin-strict
+    m * 1        ≡⟨ *-identityʳ m ⟩
+    m            <⟨ m<n ⟩
+    n            ≡⟨ m∣n⇒n≡m*quotient m∣n ⟩
+    m * quotient m∣n ∎
+  where open ≤-Reasoning
+
+quotient-< : (m∣n : m ∣ n) → .{{NonTrivial m}} → .{{NonZero n}} → quotient m∣n < n
+quotient-< {m} {n} m∣n = begin-strict
+  quotient m∣n     <⟨ m<m*n (quotient m∣n) m (nonTrivial⇒n>1 m) ⟩
+  quotient m∣n * m ≡⟨ _∣_.equality m∣n ⟨
+  n                ∎
+  where open ≤-Reasoning; instance _ = quotient≢0 m∣n
 
 ------------------------------------------------------------------------
--- Definition
+-- Relating _/_ and quotient
 
-open import Data.Nat.Divisibility.Core public
+n/m≡quotient : (m∣n : m ∣ n) .{{_ : NonZero m}} → n / m ≡ quotient m∣n
+n/m≡quotient {m = m} (divides-refl q) = m*n/n≡m q m
 
 ------------------------------------------------------------------------
 -- Relationship with _%_
 
 m%n≡0⇒n∣m : ∀ m n .{{_ : NonZero n}} → m % n ≡ 0 → n ∣ m
-m%n≡0⇒n∣m m n eq = divides (m / n) (begin-equality
-  m                  ≡⟨ m≡m%n+[m/n]*n m n ⟩
-  m % n + m / n * n  ≡⟨ cong₂ _+_ eq refl ⟩
-  m / n * n          ∎)
-  where open ≤-Reasoning
+m%n≡0⇒n∣m m n eq = divides (m / n) $ begin
+  m                ≡⟨ m≡m%n+[m/n]*n m n ⟩
+  m % n + [m/n]*n  ≡⟨ cong (_+ [m/n]*n) eq ⟩
+  [m/n]*n          ∎
+  where open ≡-Reasoning; [m/n]*n = m / n * n
 
 n∣m⇒m%n≡0 : ∀ m n .{{_ : NonZero n}} → n ∣ m → m % n ≡ 0
-n∣m⇒m%n≡0 m n (divides v eq) = begin-equality
-  m       % n  ≡⟨ cong (_% n) eq ⟩
-  (v * n) % n  ≡⟨ m*n%n≡0 v n ⟩
-  0            ∎
-  where open ≤-Reasoning
+n∣m⇒m%n≡0 .(q * n) n (divides-refl q) = m*n%n≡0 q n
 
 m%n≡0⇔n∣m : ∀ m n .{{_ : NonZero n}} → m % n ≡ 0 ⇔ n ∣ m
 m%n≡0⇔n∣m m n = mk⇔ (m%n≡0⇒n∣m m n) (n∣m⇒m%n≡0 m n)
@@ -53,19 +91,17 @@ m%n≡0⇔n∣m m n = mk⇔ (m%n≡0⇒n∣m m n) (n∣m⇒m%n≡0 m n)
 ------------------------------------------------------------------------
 -- Properties of _∣_ and _≤_
 
-∣⇒≤ : ∀ {m n} .{{_ : NonZero n}} → m ∣ n → m ≤ n
-∣⇒≤ {m} {n@(suc _)} (divides (suc q) eq) = begin
-  m          ≤⟨ m≤m+n m (q * m) ⟩
-  suc q * m  ≡⟨ sym eq ⟩
-  n          ∎
-  where open ≤-Reasoning
+∣⇒≤ : .{{_ : NonZero n}} → m ∣ n → m ≤ n
+∣⇒≤ {n@.(q * m)} {m} (divides-refl q@(suc p)) = m≤m+n m (p * m)
 
->⇒∤ : ∀ {m n} .{{_ : NonZero n}} → m > n → m ∤ n
->⇒∤ (s≤s m>n) m∣n = contradiction (∣⇒≤ m∣n) (≤⇒≯ m>n)
+>⇒∤ : .{{_ : NonZero n}} → m > n → m ∤ n
+>⇒∤ {n@(suc _)} n<m@(s<s _) m∣n = contradiction (∣⇒≤ m∣n) (<⇒≱ n<m)
 
 ------------------------------------------------------------------------
 -- _∣_ is a partial order
 
+-- these could/should inherit from Algebra.Properties.Monoid.Divisibility
+
 ∣-reflexive : _≡_ ⇒ _∣_
 ∣-reflexive {n} refl = divides 1 (sym (*-identityˡ n))
 
@@ -73,24 +109,24 @@ m%n≡0⇔n∣m m n = mk⇔ (m%n≡0⇒n∣m m n) (n∣m⇒m%n≡0 m n)
 ∣-refl = ∣-reflexive refl
 
 ∣-trans : Transitive _∣_
-∣-trans (divides p refl) (divides q refl) =
+∣-trans (divides-refl p) (divides-refl q) =
   divides (q * p) (sym (*-assoc q p _))
 
 ∣-antisym : Antisymmetric _≡_ _∣_
-∣-antisym {m}     {zero}  _ (divides q refl) = *-zeroʳ q
-∣-antisym {zero}  {n}     (divides p eq) _   = sym (trans eq (*-comm p 0))
-∣-antisym {suc m} {suc n} p∣q           q∣p  = ≤-antisym (∣⇒≤ p∣q) (∣⇒≤ q∣p)
+∣-antisym {m}     {zero}   _  q∣p = m∣n⇒n≡m*quotient q∣p
+∣-antisym {zero}  {n}     p∣q  _  = sym (m∣n⇒n≡m*quotient p∣q)
+∣-antisym {suc m} {suc n} p∣q q∣p = ≤-antisym (∣⇒≤ p∣q) (∣⇒≤ q∣p)
 
 infix 4 _∣?_
 
 _∣?_ : Decidable _∣_
-zero  ∣? zero   = yes (divides 0 refl)
-zero  ∣? suc m  = no ((λ()) ∘′ ∣-antisym (divides 0 refl))
-suc n ∣? m      = Dec.map (m%n≡0⇔n∣m m (suc n)) (m % suc n ≟ 0)
+zero  ∣? zero   = yes (divides-refl 0)
+zero  ∣? suc m  = no ((λ()) ∘′ ∣-antisym (divides-refl 0))
+n@(suc _) ∣? m  = Dec.map (m%n≡0⇔n∣m m n) (m % n ≟ 0)
 
 ∣-isPreorder : IsPreorder _≡_ _∣_
 ∣-isPreorder = record
-  { isEquivalence = PropEq.isEquivalence
+  { isEquivalence = isEquivalence
   ; reflexive     = ∣-reflexive
   ; trans         = ∣-trans
   }
@@ -115,52 +151,51 @@ suc n ∣? m      = Dec.map (m%n≡0⇔n∣m m (suc n)) (m % suc n ≟ 0)
 -- A reasoning module for the _∣_ relation
 
 module ∣-Reasoning where
-  private
-    module Base = PreorderReasoning ∣-preorder
+  private module Base = ≲-Reasoning ∣-preorder
 
   open Base public
-    hiding (step-≈; step-≈˘; step-∼)
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨; step-∼; step-≲)
+    renaming (≲-go to ∣-go)
+
+  open ∣-syntax _IsRelatedTo_ _IsRelatedTo_ ∣-go public
 
-  infixr 2 step-∣
-  step-∣ = Base.step-∼
-  syntax step-∣ x y∣z x∣y = x ∣⟨ x∣y ⟩ y∣z
 
 ------------------------------------------------------------------------
 -- Simple properties of _∣_
 
-infix 10 1∣_ _∣0
-
-1∣_ : ∀ n → 1 ∣ n
-1∣ n = divides n (sym (*-identityʳ n))
+infix 10 _∣0 1∣_
 
 _∣0 : ∀ n → n ∣ 0
-n ∣0 = divides 0 refl
+n ∣0 = divides-refl 0
 
-0∣⇒≡0 : ∀ {n} → 0 ∣ n → n ≡ 0
+0∣⇒≡0 : 0 ∣ n → n ≡ 0
 0∣⇒≡0 {n} 0∣n = ∣-antisym (n ∣0) 0∣n
 
-∣1⇒≡1 : ∀ {n} → n ∣ 1 → n ≡ 1
+1∣_ : ∀ n → 1 ∣ n
+1∣ n = divides n (sym (*-identityʳ n))
+
+∣1⇒≡1 : n ∣ 1 → n ≡ 1
 ∣1⇒≡1 {n} n∣1 = ∣-antisym n∣1 (1∣ n)
 
-n∣n : ∀ {n} → n ∣ n
-n∣n {n} = ∣-refl
+n∣n : n ∣ n
+n∣n = ∣-refl
 
 ------------------------------------------------------------------------
 -- Properties of _∣_ and _+_
 
-∣m∣n⇒∣m+n : ∀ {i m n} → i ∣ m → i ∣ n → i ∣ m + n
-∣m∣n⇒∣m+n (divides p refl) (divides q refl) =
+∣m∣n⇒∣m+n : d ∣ m → d ∣ n → d ∣ m + n
+∣m∣n⇒∣m+n (divides-refl p) (divides-refl q) =
   divides (p + q) (sym (*-distribʳ-+ _ p q))
 
-∣m+n∣m⇒∣n : ∀ {i m n} → i ∣ m + n → i ∣ m → i ∣ n
-∣m+n∣m⇒∣n {i} {m} {n} (divides p m+n≡p*i) (divides q m≡q*i) =
+∣m+n∣m⇒∣n : d ∣ m + n → d ∣ m → d ∣ n
+∣m+n∣m⇒∣n {d} {m} {n} (divides p m+n≡p*d) (divides-refl q) =
   divides (p ∸ q) $ begin-equality
-    n             ≡⟨ sym (m+n∸n≡m n m) ⟩
+    n             ≡⟨ m+n∸n≡m n m ⟨
     n + m ∸ m     ≡⟨ cong (_∸ m) (+-comm n m) ⟩
-    m + n ∸ m     ≡⟨ cong₂ _∸_ m+n≡p*i m≡q*i ⟩
-    p * i ∸ q * i ≡⟨ sym (*-distribʳ-∸ i p q) ⟩
-    (p ∸ q) * i   ∎
-  where open ∣-Reasoning
+    m + n ∸ m     ≡⟨ cong (_∸ m) m+n≡p*d ⟩
+    p * d ∸ q * d ≡⟨ *-distribʳ-∸ d p q ⟨
+    (p ∸ q) * d   ∎
+    where open ∣-Reasoning
 
 ------------------------------------------------------------------------
 -- Properties of _∣_ and _*_
@@ -174,95 +209,92 @@ m∣m*n n = divides n (*-comm _ n)
 n∣m*n*o : ∀ m {n} o → n ∣ m * n * o
 n∣m*n*o m o = ∣-trans (n∣m*n m) (m∣m*n o)
 
-∣m⇒∣m*n : ∀ {i m} n → i ∣ m → i ∣ m * n
-∣m⇒∣m*n {i} {m} n (divides q refl) = ∣-trans (n∣m*n q) (m∣m*n n)
+∣m⇒∣m*n : ∀ n → d ∣ m → d ∣ m * n
+∣m⇒∣m*n n (divides-refl q) = ∣-trans (n∣m*n q) (m∣m*n n)
 
-∣n⇒∣m*n : ∀ {i} m {n} → i ∣ n → i ∣ m * n
+∣n⇒∣m*n : ∀ m {n} → d ∣ n → d ∣ m * n
 ∣n⇒∣m*n m {n} rewrite *-comm m n = ∣m⇒∣m*n m
 
-m*n∣⇒m∣ : ∀ {i} m n → m * n ∣ i → m ∣ i
-m*n∣⇒m∣ m n (divides q refl) = ∣n⇒∣m*n q (m∣m*n n)
+m*n∣⇒m∣ : ∀ m n → m * n ∣ d → m ∣ d
+m*n∣⇒m∣ m n (divides-refl q) = ∣n⇒∣m*n q (m∣m*n n)
 
-m*n∣⇒n∣ : ∀ {i} m n → m * n ∣ i → n ∣ i
+m*n∣⇒n∣ : ∀ m n → m * n ∣ d → n ∣ d
 m*n∣⇒n∣ m n rewrite *-comm m n = m*n∣⇒m∣ n m
 
-*-monoʳ-∣ : ∀ {i j} k → i ∣ j → k * i ∣ k * j
-*-monoʳ-∣ {i} {j} k (divides q refl) = divides q $ begin-equality
-  k * (q * i)  ≡⟨ sym (*-assoc k q i) ⟩
-  (k * q) * i  ≡⟨ cong (_* i) (*-comm k q) ⟩
-  (q * k) * i  ≡⟨ *-assoc q k i ⟩
-  q * (k * i)  ∎
-  where open ≤-Reasoning
+*-pres-∣ : o ∣ m → p ∣ n → o * p ∣ m * n
+*-pres-∣ {o} {m@.(q * o)} {p} {n@.(r * p)} (divides-refl q) (divides-refl r) =
+  divides (q * r) ([m*n]*[o*p]≡[m*o]*[n*p] q o r p)
+
+*-monoʳ-∣ : ∀ o → m ∣ n → o * m ∣ o * n
+*-monoʳ-∣ o = *-pres-∣ (∣-refl {o})
 
-*-monoˡ-∣ : ∀ {i j} k → i ∣ j → i * k ∣ j * k
-*-monoˡ-∣ {i} {j} k rewrite *-comm i k | *-comm j k = *-monoʳ-∣ k
+*-monoˡ-∣ : ∀ o → m ∣ n → m * o ∣ n * o
+*-monoˡ-∣ o = flip *-pres-∣ (∣-refl {o})
 
-*-cancelˡ-∣ : ∀ {i j} k .{{_ : NonZero k}} → k * i ∣ k * j → i ∣ j
-*-cancelˡ-∣ {i} {j} k@(suc _) (divides q eq) =
-  divides q $ *-cancelʳ-≡ j (q * i) _ $ begin-equality
-    j * k        ≡⟨ *-comm j k ⟩
-    k * j        ≡⟨ eq ⟩
-    q * (k * i)  ≡⟨ cong (q *_) (*-comm k i) ⟩
-    q * (i * k)  ≡⟨ sym (*-assoc q i k) ⟩
-    (q * i) * k  ∎
-    where open ≤-Reasoning
+*-cancelˡ-∣ : ∀ o .{{_ : NonZero o}} → o * m ∣ o * n → m ∣ n
+*-cancelˡ-∣ {m} {n} o o*m∣o*n = divides q $ *-cancelˡ-≡ n (q * m) o $ begin-equality
+  o * n       ≡⟨ m∣n⇒n≡m*quotient o*m∣o*n ⟩
+  o * m * q   ≡⟨ *-assoc o m q ⟩
+  o * (m * q) ≡⟨ cong (o *_) (*-comm q m) ⟨
+  o * (q * m) ∎
+  where
+  open ∣-Reasoning
+  q = quotient o*m∣o*n
 
-*-cancelʳ-∣ : ∀ {i j} k .{{_ : NonZero k}} → i * k ∣ j * k → i ∣ j
-*-cancelʳ-∣ {i} {j} k rewrite *-comm i k | *-comm j k = *-cancelˡ-∣ k
+*-cancelʳ-∣ : ∀ o .{{_ : NonZero o}} → m * o ∣ n * o → m ∣ n
+*-cancelʳ-∣ {m} {n} o rewrite *-comm m o | *-comm n o = *-cancelˡ-∣ o
 
 ------------------------------------------------------------------------
 -- Properties of _∣_ and _∸_
 
-∣m∸n∣n⇒∣m : ∀ i {m n} → n ≤ m → i ∣ m ∸ n → i ∣ n → i ∣ m
-∣m∸n∣n⇒∣m i {m} {n} n≤m (divides p m∸n≡p*i) (divides q n≡q*o) =
+∣m∸n∣n⇒∣m : ∀ d → n ≤ m → d ∣ m ∸ n → d ∣ n → d ∣ m
+∣m∸n∣n⇒∣m {n} {m} d n≤m (divides p m∸n≡p*d) (divides-refl q) =
   divides (p + q) $ begin-equality
-    m             ≡⟨ sym (m+[n∸m]≡n n≤m) ⟩
+    m             ≡⟨ m+[n∸m]≡n n≤m ⟨
     n + (m ∸ n)   ≡⟨ +-comm n (m ∸ n) ⟩
-    m ∸ n + n     ≡⟨ cong₂ _+_ m∸n≡p*i n≡q*o ⟩
-    p * i + q * i ≡⟨ sym (*-distribʳ-+ i p q)  ⟩
-    (p + q) * i   ∎
-  where open ≤-Reasoning
+    m ∸ n + n     ≡⟨ cong (_+ n) m∸n≡p*d ⟩
+    p * d + q * d ≡⟨ *-distribʳ-+ d p q ⟨
+    (p + q) * d   ∎
+  where open ∣-Reasoning
 
 ------------------------------------------------------------------------
 -- Properties of _∣_ and _/_
 
-m/n∣m : ∀ {m n} .{{_ : NonZero n}} → n ∣ m → m / n ∣ m
-m/n∣m {m} {n} (divides p refl) = begin
-  p * n / n ≡⟨ m*n/n≡m p n ⟩
-  p         ∣⟨ m∣m*n n ⟩
-  p * n     ∎
+m/n∣m : .{{_ : NonZero n}} → n ∣ m → m / n ∣ m
+m/n∣m {n} {m} n∣m = begin
+  m / n        ≡⟨ n/m≡quotient n∣m ⟩
+  quotient n∣m ∣⟨ quotient-∣ n∣m ⟩
+  m            ∎
   where open ∣-Reasoning
 
-m*n∣o⇒m∣o/n : ∀ m n {o} .{{_ : NonZero n}} → m * n ∣ o → m ∣ o / n
-m*n∣o⇒m∣o/n m n {_} (divides p refl) = begin
-  m               ∣⟨ n∣m*n p ⟩
-  p * m           ≡⟨ sym (*-identityʳ (p * m)) ⟩
-  p * m * 1       ≡⟨ sym (cong (p * m *_) (n/n≡1 n)) ⟩
-  p * m * (n / n) ≡⟨ sym (*-/-assoc (p * m) (n∣n {n})) ⟩
-  p * m * n / n   ≡⟨ cong (_/ n) (*-assoc p m n) ⟩
-  p * (m * n) / n ∎
+m*n∣o⇒m∣o/n : ∀ m n .{{_ : NonZero n}} → m * n ∣ o → m ∣ o / n
+m*n∣o⇒m∣o/n m n (divides-refl p) = divides p $ begin-equality
+  p * (m * n) / n   ≡⟨ *-/-assoc p (n∣m*n m) ⟩
+  p * ((m * n) / n) ≡⟨ cong (p *_) (m*n/n≡m m n) ⟩
+  p * m ∎
   where open ∣-Reasoning
 
-m*n∣o⇒n∣o/m : ∀ m n {o} .{{_ : NonZero m}} → m * n ∣ o → n ∣ (o / m)
+m*n∣o⇒n∣o/m : ∀ m n .{{_ : NonZero m}} → m * n ∣ o → n ∣ (o / m)
 m*n∣o⇒n∣o/m m n rewrite *-comm m n = m*n∣o⇒m∣o/n n m
 
-m∣n/o⇒m*o∣n : ∀ {m n o} .{{_ : NonZero o}} → o ∣ n → m ∣ n / o → m * o ∣ n
-m∣n/o⇒m*o∣n {m} {n} {o} (divides p refl) m∣p*o/o = begin
+m∣n/o⇒m*o∣n : .{{_ : NonZero o}} → o ∣ n → m ∣ n / o → m * o ∣ n
+m∣n/o⇒m*o∣n {o} {n@.(p * o)} {m} (divides-refl p) m∣p*o/o = begin
   m * o ∣⟨ *-monoˡ-∣ o (subst (m ∣_) (m*n/n≡m p o) m∣p*o/o) ⟩
   p * o ∎
   where open ∣-Reasoning
 
-m∣n/o⇒o*m∣n : ∀ {m n o} .{{_ : NonZero o}} → o ∣ n → m ∣ n / o → o * m ∣ n
-m∣n/o⇒o*m∣n {m} {_} {o} rewrite *-comm o m = m∣n/o⇒m*o∣n
+m∣n/o⇒o*m∣n : .{{_ : NonZero o}} → o ∣ n → m ∣ n / o → o * m ∣ n
+m∣n/o⇒o*m∣n {o} {_} {m} rewrite *-comm o m = m∣n/o⇒m*o∣n
 
-m/n∣o⇒m∣o*n : ∀ {m n o} .{{_ : NonZero n}} → n ∣ m → m / n ∣ o → m ∣ o * n
-m/n∣o⇒m∣o*n {_} {n} {o} (divides p refl) p*n/n∣o = begin
+m/n∣o⇒m∣o*n : .{{_ : NonZero n}} → n ∣ m → m / n ∣ o → m ∣ o * n
+m/n∣o⇒m∣o*n {n} {m@.(p * n)} {o} (divides-refl p) p*n/n∣o = begin
   p * n ∣⟨ *-monoˡ-∣ n (subst (_∣ o) (m*n/n≡m p n) p*n/n∣o) ⟩
   o * n ∎
   where open ∣-Reasoning
 
-m∣n*o⇒m/n∣o : ∀ {m n o} .{{_ : NonZero n}} → n ∣ m → m ∣ o * n → m / n ∣ o
-m∣n*o⇒m/n∣o {_} {n@(suc _)} {o} (divides p refl) pn∣on = begin
+m∣n*o⇒m/n∣o : .{{_ : NonZero n}} → n ∣ m → m ∣ o * n → m / n ∣ o
+m∣n*o⇒m/n∣o {n} {m@.(p * n)} {o} (divides-refl p) pn∣on = begin
+  m / n     ≡⟨⟩
   p * n / n ≡⟨ m*n/n≡m p n ⟩
   p         ∣⟨ *-cancelʳ-∣ n pn∣on ⟩
   o         ∎
@@ -271,32 +303,58 @@ m∣n*o⇒m/n∣o {_} {n@(suc _)} {o} (divides p refl) pn∣on = begin
 ------------------------------------------------------------------------
 -- Properties of _∣_ and _%_
 
-∣n∣m%n⇒∣m : ∀ {m n d} .{{_ : NonZero n}} → d ∣ n → d ∣ m % n → d ∣ m
-∣n∣m%n⇒∣m {m} {n} {d} (divides a n≡ad) (divides b m%n≡bd) =
-  divides (b + (m / n) * a) (begin-equality
+∣n∣m%n⇒∣m : .{{_ : NonZero n}} → d ∣ n → d ∣ m % n → d ∣ m
+∣n∣m%n⇒∣m {n@.(p * d)} {d} {m} (divides-refl p) (divides q m%n≡qd) =
+  divides (q + (m / n) * p) $ begin-equality
     m                         ≡⟨ m≡m%n+[m/n]*n m n ⟩
-    m % n + (m / n) * n       ≡⟨ cong₂ _+_ m%n≡bd (cong (m / n *_) n≡ad) ⟩
-    b * d + (m / n) * (a * d) ≡⟨ sym (cong (b * d +_) (*-assoc (m / n) a d)) ⟩
-    b * d + ((m / n) * a) * d ≡⟨ sym (*-distribʳ-+ d b _) ⟩
-    (b + (m / n) * a) * d     ∎)
-    where open ≤-Reasoning
-
-%-presˡ-∣ : ∀ {m n d} .{{_ : NonZero n}} → d ∣ m → d ∣ n → d ∣ m % n
-%-presˡ-∣ {m} {n} {d} (divides a refl) (divides b 1+n≡bd) =
-  divides (a ∸ ad/n * b) $ begin-equality
-    a * d % n              ≡⟨  m%n≡m∸m/n*n (a * d) n ⟩
-    a * d ∸ ad/n * n       ≡⟨  cong (λ v → a * d ∸ ad/n * v) 1+n≡bd ⟩
-    a * d ∸ ad/n * (b * d) ≡˘⟨ cong (a * d ∸_) (*-assoc ad/n b d) ⟩
-    a * d ∸ (ad/n * b) * d ≡˘⟨ *-distribʳ-∸ d a (ad/n * b) ⟩
-    (a ∸ ad/n * b) * d     ∎
-  where open ≤-Reasoning; ad/n = a * d / n
+    m % n + (m / n) * n       ≡⟨ cong (_+ (m / n) * n) m%n≡qd ⟩
+    q * d + (m / n) * n       ≡⟨⟩
+    q * d + (m / n) * (p * d) ≡⟨ cong (q * d +_) (*-assoc (m / n) p d) ⟨
+    q * d + ((m / n) * p) * d ≡⟨ *-distribʳ-+ d q _ ⟨
+    (q + (m / n) * p) * d     ∎
+  where open ∣-Reasoning
+
+%-presˡ-∣ : .{{_ : NonZero n}} → d ∣ m → d ∣ n → d ∣ m % n
+%-presˡ-∣ {n} {d} {m@.(p * d)} (divides-refl p) (divides q 1+n≡qd) =
+  divides (p ∸ m / n * q) $ begin-equality
+    m % n                   ≡⟨ m%n≡m∸m/n*n m n ⟩
+    m ∸ m / n * n           ≡⟨ cong (λ v → m ∸ m / n * v) 1+n≡qd ⟩
+    m ∸ m / n * (q * d)     ≡⟨ cong (m ∸_) (*-assoc (m / n) q d) ⟨
+    m  ∸ (m / n * q) * d    ≡⟨⟩
+    p * d ∸ (m / n * q) * d ≡⟨ *-distribʳ-∸ d p (m / n * q) ⟨
+    (p ∸ m / n * q) * d     ∎
+  where open ∣-Reasoning
 
 ------------------------------------------------------------------------
 -- Properties of _∣_ and !_
 
-m≤n⇒m!∣n! : ∀ {m n} → m ≤ n → m ! ∣ n !
+m≤n⇒m!∣n! : m ≤ n → m ! ∣ n !
 m≤n⇒m!∣n! m≤n = help (≤⇒≤′ m≤n)
   where
-  help : ∀ {m n} → m ≤′ n → m ! ∣ n !
-  help {m} {n}     ≤′-refl        = ∣-refl
-  help {m} {suc n} (≤′-step m≤′n) = ∣n⇒∣m*n (suc n) (help m≤′n)
+  help : m ≤′ n → m ! ∣ n !
+  help         ≤′-refl       = ∣-refl
+  help {n = n} (≤′-step m≤n) = ∣n⇒∣m*n n (help m≤n)
+
+------------------------------------------------------------------------
+-- Properties of _HasNonTrivialDivisorLessThan_
+
+-- Smart constructor
+
+hasNonTrivialDivisor-≢ : .{{NonTrivial d}} → .{{NonZero n}} →
+                         d ≢ n → d ∣ n → n HasNonTrivialDivisorLessThan n
+hasNonTrivialDivisor-≢ d≢n d∣n
+  = hasNonTrivialDivisor (≤∧≢⇒< (∣⇒≤ d∣n) d≢n) d∣n
+
+-- Monotonicity wrt ∣
+
+hasNonTrivialDivisor-∣ : m HasNonTrivialDivisorLessThan n → m ∣ o →
+                         o HasNonTrivialDivisorLessThan n
+hasNonTrivialDivisor-∣ (hasNonTrivialDivisor d<n d∣m) m∣o
+  = hasNonTrivialDivisor d<n (∣-trans d∣m m∣o)
+
+-- Monotonicity wrt ≤
+
+hasNonTrivialDivisor-≤ : m HasNonTrivialDivisorLessThan n → n ≤ o →
+                         m HasNonTrivialDivisorLessThan o
+hasNonTrivialDivisor-≤ (hasNonTrivialDivisor d<n d∣m) n≤o
+  = hasNonTrivialDivisor (<-≤-trans d<n n≤o) d∣m
diff --git a/src/Data/Nat/Divisibility/Core.agda b/src/Data/Nat/Divisibility/Core.agda
index 635a70c111..1b43ab22d6 100644
--- a/src/Data/Nat/Divisibility/Core.agda
+++ b/src/Data/Nat/Divisibility/Core.agda
@@ -12,16 +12,19 @@
 
 module Data.Nat.Divisibility.Core where
 
-open import Data.Nat.Base using (ℕ; _*_)
+open import Data.Nat.Base using (ℕ; _*_; _<_; NonTrivial)
 open import Data.Nat.Properties
-open import Level using (0ℓ)
 open import Relation.Nullary.Negation using (¬_)
-open import Relation.Binary using (Rel)
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; refl; sym; cong₂; module ≡-Reasoning)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl)
+
+
+private
+  variable m n o p : ℕ
 
 ------------------------------------------------------------------------
--- Definition
+-- Main definition
 --
 -- m ∣ n is inhabited iff m divides n. Some sources, like Hardy and
 -- Wright's "An Introduction to the Theory of Numbers", require m to
@@ -35,19 +38,44 @@ record _∣_ (m n : ℕ) : Set where
   constructor divides
   field quotient : ℕ
         equality : n ≡ quotient * m
-open _∣_ using (quotient) public
 
-_∤_ : Rel ℕ 0ℓ
+_∤_ : Rel ℕ _
 m ∤ n = ¬ (m ∣ n)
 
+-- Smart constructor
+
+pattern divides-refl q = divides q refl
+
+open _∣_ using (quotient) public
+
+------------------------------------------------------------------------
+-- Restricted divisor relation
+
+-- Relation for having a non-trivial divisor below a given bound.
+-- Useful when reasoning about primality.
+infix 10 _HasNonTrivialDivisorLessThan_
 
+record _HasNonTrivialDivisorLessThan_ (m n : ℕ) : Set where
+  constructor hasNonTrivialDivisor
+  field
+    {divisor}       : ℕ
+    .{{nontrivial}} : NonTrivial divisor
+    divisor-<       : divisor < n
+    divisor-∣       : divisor ∣ m
+
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
 ------------------------------------------------------------------------
--- Basic properties
-
-*-pres-∣ : ∀ {m n o p} → o ∣ m → p ∣ n → o * p ∣ m * n
-*-pres-∣ {m} {n} {o} {p} (divides c m≡c*o) (divides d n≡d*p) =
-  divides (c * d) (begin
-    m * n             ≡⟨ cong₂ _*_ m≡c*o n≡d*p ⟩
-    (c * o) * (d * p) ≡⟨ [m*n]*[o*p]≡[m*o]*[n*p] c o d p ⟩
-    (c * d) * (o * p) ∎)
-  where open ≡-Reasoning
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.1
+
+*-pres-∣ : o ∣ m → p ∣ n → o * p ∣ m * n
+*-pres-∣ {o} {m@.(q * o)} {p} {n@.(r * p)} (divides-refl q) (divides-refl r) =
+  divides (q * r) ([m*n]*[o*p]≡[m*o]*[n*p] q o r p)
+
+{-# WARNING_ON_USAGE *-pres-∣
+"Warning: *-pres-∣ was deprecated in v2.1.
+ Please use Data.Nat.Divisibility.*-pres-∣ instead."
+#-}
diff --git a/src/Data/Nat/GCD.agda b/src/Data/Nat/GCD.agda
index fe90cc0282..26d44549fb 100644
--- a/src/Data/Nat/GCD.agda
+++ b/src/Data/Nat/GCD.agda
@@ -15,14 +15,17 @@ open import Data.Nat.GCD.Lemmas
 open import Data.Nat.Properties
 open import Data.Nat.Induction
   using (Acc; acc; <′-Rec; <′-recBuilder; <-wellFounded-fast)
-open import Data.Product
+open import Data.Product.Base
+  using (_×_; _,_; proj₂; proj₁; swap; uncurry′; ∃; map)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
-open import Function
+open import Function.Base using (_$_; _∘_)
 open import Induction using (build)
 open import Induction.Lexicographic using (_⊗_; [_⊗_])
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.Definitions using (tri<; tri>; tri≈; Symmetric)
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; _≢_; subst; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Relation.Nullary.Decidable using (Dec)
 open import Relation.Nullary.Negation using (contradiction)
 import Relation.Nullary.Decidable as Dec
@@ -42,7 +45,7 @@ open import Algebra.Definitions {A = ℕ} _≡_ as Algebra
 
 gcd′ : ∀ m n → Acc _<_ m → n < m → ℕ
 gcd′ m zero      _         _   = m
-gcd′ m n@(suc _) (acc rec) n<m = gcd′ n (m % n) (rec _ n<m) (m%n<n m n)
+gcd′ m n@(suc _) (acc rec) n<m = gcd′ n (m % n) (rec n<m) (m%n<n m n)
 
 gcd : ℕ → ℕ → ℕ
 gcd m n with <-cmp m n
@@ -54,15 +57,15 @@ gcd m n with <-cmp m n
 -- Core properties of gcd′
 
 gcd′[m,n]∣m,n : ∀ {m n} rec n<m → gcd′ m n rec n<m ∣ m × gcd′ m n rec n<m ∣ n
-gcd′[m,n]∣m,n {m} {zero}  rec       n<m = ∣-refl , m ∣0
-gcd′[m,n]∣m,n {m} {suc n} (acc rec) n<m
-  with gcd′[m,n]∣m,n (rec _ n<m) (m%n<n m (suc n))
-... | gcd∣n , gcd∣m%n = ∣n∣m%n⇒∣m gcd∣n gcd∣m%n , gcd∣n
+gcd′[m,n]∣m,n {m} {zero}      rec       n<m = ∣-refl , m ∣0
+gcd′[m,n]∣m,n {m} {n@(suc _)} (acc rec) n<m
+  with gcd∣n , gcd∣m%n ← gcd′[m,n]∣m,n (rec n<m) (m%n<n m n)
+  = ∣n∣m%n⇒∣m gcd∣n gcd∣m%n , gcd∣n
 
 gcd′-greatest : ∀ {m n c} rec n<m → c ∣ m → c ∣ n → c ∣ gcd′ m n rec n<m
-gcd′-greatest {m} {zero}  rec       n<m c∣m c∣n = c∣m
-gcd′-greatest {m} {suc n} (acc rec) n<m c∣m c∣n =
-  gcd′-greatest (rec _ n<m) (m%n<n m (suc n)) c∣n (%-presˡ-∣ c∣m c∣n)
+gcd′-greatest {m} {zero}      rec       n<m c∣m c∣n = c∣m
+gcd′-greatest {m} {n@(suc _)} (acc rec) n<m c∣m c∣n =
+  gcd′-greatest (rec n<m) (m%n<n m n) c∣n (%-presˡ-∣ c∣m c∣n)
 
 ------------------------------------------------------------------------
 -- Core properties of gcd
@@ -76,7 +79,7 @@ gcd[m,n]∣m m n with <-cmp m n
 gcd[m,n]∣n : ∀ m n → gcd m n ∣ n
 gcd[m,n]∣n m n with <-cmp m n
 ... | tri< n<m _    _ = proj₁ (gcd′[m,n]∣m,n {n} {m} _ _)
-... | tri≈ _ P.refl _ = ∣-refl
+... | tri≈ _ ≡.refl _ = ∣-refl
 ... | tri> _ _    m<n = proj₂ (gcd′[m,n]∣m,n {m} {n} _ _)
 
 gcd-greatest : ∀ {m n c} → c ∣ m → c ∣ n → c ∣ gcd m n
@@ -99,11 +102,11 @@ gcd[m,n]≢0 m n (inj₁ m≢0) eq = m≢0 (0∣⇒≡0 (subst (_∣ m) eq (gcd[
 gcd[m,n]≢0 m n (inj₂ n≢0) eq = n≢0 (0∣⇒≡0 (subst (_∣ n) eq (gcd[m,n]∣n m n)))
 
 gcd[m,n]≡0⇒m≡0 : ∀ {m n} → gcd m n ≡ 0 → m ≡ 0
-gcd[m,n]≡0⇒m≡0 {zero}  {n} eq = P.refl
+gcd[m,n]≡0⇒m≡0 {zero}  {n} eq = ≡.refl
 gcd[m,n]≡0⇒m≡0 {suc m} {n} eq = contradiction eq (gcd[m,n]≢0 (suc m) n (inj₁ λ()))
 
 gcd[m,n]≡0⇒n≡0 : ∀ m {n} → gcd m n ≡ 0 → n ≡ 0
-gcd[m,n]≡0⇒n≡0 m {zero}  eq = P.refl
+gcd[m,n]≡0⇒n≡0 m {zero}  eq = ≡.refl
 gcd[m,n]≡0⇒n≡0 m {suc n} eq = contradiction eq (gcd[m,n]≢0 m (suc n) (inj₂ λ()))
 
 gcd-comm : Commutative gcd
@@ -137,12 +140,12 @@ gcd-assoc m n p = ∣-antisym
       p               ∎
 
 gcd-identityˡ : LeftIdentity 0 gcd
-gcd-identityˡ zero = P.refl
-gcd-identityˡ (suc _) = P.refl
+gcd-identityˡ zero = ≡.refl
+gcd-identityˡ (suc _) = ≡.refl
 
 gcd-identityʳ : RightIdentity 0 gcd
-gcd-identityʳ zero = P.refl
-gcd-identityʳ (suc _) = P.refl
+gcd-identityʳ zero = ≡.refl
+gcd-identityʳ (suc _) = ≡.refl
 
 gcd-identity : Algebra.Identity 0 gcd
 gcd-identity = gcd-identityˡ , gcd-identityʳ
@@ -166,10 +169,8 @@ gcd-universality : ∀ {m n g} →
                    (∀ {d} → d ∣ m × d ∣ n → d ∣ g) →
                    (∀ {d} → d ∣ g → d ∣ m × d ∣ n) →
                    g ≡ gcd m n
-gcd-universality {m} {n} forwards backwards with backwards ∣-refl
-... | back₁ , back₂ = ∣-antisym
-  (gcd-greatest back₁ back₂)
-  (forwards (gcd[m,n]∣m m n , gcd[m,n]∣n m n))
+gcd-universality {m} {n} forwards backwards with back₁ , back₂ ← backwards ∣-refl
+  = ∣-antisym (gcd-greatest back₁ back₂) (forwards (gcd[m,n]∣m m n , gcd[m,n]∣n m n))
 
 -- This could be simplified with some nice backwards/forwards reasoning
 -- after the new function hierarchy is up and running.
@@ -180,18 +181,18 @@ gcd[cm,cn]/c≡gcd[m,n] c m n = gcd-universality forwards backwards
   forwards {d} (d∣m , d∣n) = m*n∣o⇒n∣o/m c d (gcd-greatest (*-monoʳ-∣ c d∣m) (*-monoʳ-∣ c d∣n))
 
   backwards : ∀ {d : ℕ} → d ∣ gcd (c * m) (c * n) / c → d ∣ m × d ∣ n
-  backwards {d} d∣gcd[cm,cn]/c with m∣n/o⇒o*m∣n (gcd-greatest (m∣m*n m) (m∣m*n n)) d∣gcd[cm,cn]/c
-  ... | cd∣gcd[cm,n] =
-    *-cancelˡ-∣ c (∣-trans cd∣gcd[cm,n] (gcd[m,n]∣m (c * m) _)) ,
-    *-cancelˡ-∣ c (∣-trans cd∣gcd[cm,n] (gcd[m,n]∣n (c * m) _))
+  backwards {d} d∣gcd[cm,cn]/c
+    with cd∣gcd[cm,n] ← m∣n/o⇒o*m∣n (gcd-greatest (m∣m*n m) (m∣m*n n)) d∣gcd[cm,cn]/c
+    = *-cancelˡ-∣ c (∣-trans cd∣gcd[cm,n] (gcd[m,n]∣m (c * m) _)) ,
+      *-cancelˡ-∣ c (∣-trans cd∣gcd[cm,n] (gcd[m,n]∣n (c * m) _))
 
 c*gcd[m,n]≡gcd[cm,cn] : ∀ c m n → c * gcd m n ≡ gcd (c * m) (c * n)
-c*gcd[m,n]≡gcd[cm,cn] zero      m n = P.sym gcd[0,0]≡0
+c*gcd[m,n]≡gcd[cm,cn] zero      m n = ≡.sym gcd[0,0]≡0
 c*gcd[m,n]≡gcd[cm,cn] c@(suc _) m n = begin
-  c * gcd m n                   ≡⟨ cong (c *_) (P.sym (gcd[cm,cn]/c≡gcd[m,n] c m n)) ⟩
+  c * gcd m n                   ≡⟨ cong (c *_) (≡.sym (gcd[cm,cn]/c≡gcd[m,n] c m n)) ⟩
   c * (gcd (c * m) (c * n) / c) ≡⟨ m*[n/m]≡n (gcd-greatest (m∣m*n m) (m∣m*n n)) ⟩
   gcd (c * m) (c * n)           ∎
-  where open P.≡-Reasoning
+  where open ≡-Reasoning
 
 gcd[m,n]≤n : ∀ m n .{{_ : NonZero n}} → gcd m n ≤ n
 gcd[m,n]≤n m n = ∣⇒≤ (gcd[m,n]∣n m n)
@@ -256,8 +257,8 @@ module GCD where
   -- n + k.
 
   step : ∀ {n k d} → GCD n k d → GCD n (n + k) d
-  step g with GCD.commonDivisor g
-  step {n} {k} {d} g | (d₁ , d₂) = is (d₁ , ∣m∣n⇒∣m+n d₁ d₂) greatest′
+  step {n} {k} {d} g with d₁ , d₂ ← GCD.commonDivisor g
+    = is (d₁ , ∣m∣n⇒∣m+n d₁ d₂) greatest′
     where
     greatest′ : ∀ {d′} → d′ ∣ n × d′ ∣ n + k → d′ ∣ d
     greatest′ (d₁ , d₂) = GCD.greatest g (d₁ , ∣m+n∣m⇒∣n d₂ d₁)
@@ -281,7 +282,7 @@ mkGCD m n = gcd m n , gcd-GCD m n
 
 gcd? : (m n d : ℕ) → Dec (GCD m n d)
 gcd? m n d =
-  Dec.map′ (λ { P.refl → gcd-GCD m n }) (GCD.unique (gcd-GCD m n))
+  Dec.map′ (λ { ≡.refl → gcd-GCD m n }) (GCD.unique (gcd-GCD m n))
            (gcd m n ≟ d)
 
 GCD-* : ∀ {m n d c} .{{_ : NonZero c}} → GCD (m * c) (n * c) (d * c) → GCD m n d
@@ -292,11 +293,11 @@ GCD-* {c = suc _} (GCD.is (dc∣nc , dc∣mc) dc-greatest) =
 GCD-/ : ∀ {m n d c} .{{_ : NonZero c}} → c ∣ m → c ∣ n → c ∣ d →
         GCD m n d → GCD (m / c) (n / c) (d / c)
 GCD-/ {m} {n} {d} {c} {{x}}
-  (divides p P.refl) (divides q P.refl) (divides r P.refl) gcd
+  (divides-refl p) (divides-refl q) (divides-refl r) gcd
   rewrite m*n/n≡m p c {{x}} | m*n/n≡m q c {{x}} | m*n/n≡m r c {{x}} = GCD-* gcd
 
 GCD-/gcd : ∀ m n .{{_ : NonZero (gcd m n)}} → GCD (m / gcd m n) (n / gcd m n) 1
-GCD-/gcd m n rewrite P.sym (n/n≡1 (gcd m n)) =
+GCD-/gcd m n rewrite ≡.sym (n/n≡1 (gcd m n)) =
   GCD-/ (gcd[m,n]∣m m n) (gcd[m,n]∣n m n) ∣-refl (gcd-GCD m n)
 
 ------------------------------------------------------------------------
@@ -326,10 +327,10 @@ module Bézout where
     sym (-+ x y eq) = +- y x eq
 
     refl : ∀ {d} → Identity d d d
-    refl = -+ 0 1 P.refl
+    refl = -+ 0 1 ≡.refl
 
     base : ∀ {d} → Identity d 0 d
-    base = -+ 0 1 P.refl
+    base = -+ 0 1 ≡.refl
 
     private
       infixl 7 _⊕_
@@ -388,18 +389,16 @@ module Bézout where
     P (m , n) = Lemma m n
 
     gcd″ : ∀ p → (<′-Rec ⊗ <′-Rec) P p → P p
-    gcd″ (zero  , n)     rec = Lemma.base n
-    gcd″ (suc m , zero)  rec = Lemma.sym (Lemma.base (suc m))
-    gcd″ (suc m , suc n) rec with compare m n
-    ... | equal m     = Lemma.refl (suc m)
-    ... | less m k    = Lemma.stepˡ $ proj₁ rec (suc k) (lem₁ k m)
+    gcd″ (zero      , n)     rec = Lemma.base n
+    gcd″ (m@(suc _) , zero)  rec = Lemma.sym (Lemma.base m)
+    gcd″ (m′@(suc m) , n′@(suc n)) rec with compare m n
+    ... | equal m     = Lemma.refl m′
+    ... | less m k    = Lemma.stepˡ $ proj₁ rec (lem₁ k m)
                       -- "gcd (suc m) (suc k)"
-    ... | greater n k = Lemma.stepʳ $ proj₂ rec (suc k) (lem₁ k n) (suc n)
+    ... | greater n k = Lemma.stepʳ $ proj₂ rec (lem₁ k n) n′
                       -- "gcd (suc k) (suc n)"
 
   -- Bézout's identity can be recovered from the GCD.
 
   identity : ∀ {m n d} → GCD m n d → Identity d m n
-  identity {m} {n} g with lemma m n
-  ... | result d g′ b with GCD.unique g g′
-  ...   | P.refl = b
+  identity {m} {n} g with result d g′ b ← lemma m n rewrite GCD.unique g g′ = b
diff --git a/src/Data/Nat/GCD/Lemmas.agda b/src/Data/Nat/GCD/Lemmas.agda
index 8d92924ddd..5f358e6cf3 100644
--- a/src/Data/Nat/GCD/Lemmas.agda
+++ b/src/Data/Nat/GCD/Lemmas.agda
@@ -10,21 +10,26 @@ module Data.Nat.GCD.Lemmas where
 
 open import Data.Nat.Base
 open import Data.Nat.Properties
-open import Data.Nat.Solver
-open import Function
-open import Relation.Binary.PropositionalEquality
+open import Function.Base using (_$_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂; sym)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 
-open +-*-Solver
 open ≡-Reasoning
 
 private
-  distrib-comm : ∀ x k n → x * k + x * n ≡ x * (n + k)
-  distrib-comm =
-    solve 3 (λ x k n → x :* k :+ x :* n  :=  x :* (n :+ k)) refl
+  comm-factor : ∀ x k n → x * k + x * n ≡ x * (n + k)
+  comm-factor x k n = begin
+    x * k + x * n ≡⟨ +-comm (x * k) _ ⟩
+    x * n + x * k ≡⟨ *-distribˡ-+ x n k ⟨
+    x * (n + k)   ∎
 
   distrib-comm₂ : ∀ d x k n → d + x * (n + k) ≡ d + x * k + x * n
-  distrib-comm₂ =
-    solve 4 (λ d x k n → d :+ x :* (n :+ k) :=  d :+ x :* k :+ x :* n) refl
+  distrib-comm₂ d x k n = begin
+    d + x * (n + k)     ≡⟨ cong (d +_) (comm-factor x k n) ⟨
+    d + (x * k + x * n) ≡⟨ +-assoc d _ _ ⟨
+    d + x * k + x * n   ∎
 
 -- Other properties
 -- TODO: Can this proof be simplified? An automatic solver which can
@@ -40,26 +45,112 @@ lem₀ i j m n eq = begin
 lem₁ : ∀ i j → 2 + i ≤′ 2 + j + i
 lem₁ i j = ≤⇒≤′ $ s≤s $ s≤s $ m≤n+m i j
 
+private
+  times2 : ∀ x → x + x ≡ 2 * x
+  times2 x = cong (x +_) (sym (+-identityʳ x))
+
+  times2′ : ∀ x y → x * y + x * y ≡ 2 * x * y
+  times2′ x y = begin
+    x * y + x * y ≡⟨ times2 (x * y) ⟩
+    2 * (x * y)   ≡⟨ *-assoc 2 x y ⟨
+    2 * x * y     ∎
+
 lem₂ : ∀ d x {k n} →
        d + x * k ≡ x * n → d + x * (n + k) ≡ 2 * x * n
 lem₂ d x {k} {n} eq = begin
   d + x * (n + k)    ≡⟨ distrib-comm₂ d x k n ⟩
-  d + x * k + x * n  ≡⟨ cong₂ _+_ eq refl ⟩
-  x * n + x * n      ≡⟨ solve 3 (λ x n k → x :* n :+ x :* n
-                                       :=  con 2 :* x :* n)
-                                 refl x n k ⟩
+  d + x * k + x * n  ≡⟨ cong (_+ x * n) eq ⟩
+  x * n + x * n      ≡⟨ times2′ x n ⟩
   2 * x * n          ∎
 
+private
+  distrib₃ : ∀ a b c x → (a + b + c) * x ≡ a * x + b * x + c * x
+  distrib₃ a b c x = begin
+    (a + b + c) * x       ≡⟨ *-distribʳ-+ x (a + b) c ⟩
+    (a + b) * x + c * x   ≡⟨ cong (_+ c * x) (*-distribʳ-+ x a b) ⟩
+    a * x + b * x + c * x ∎
+
+  lem₃₁ : ∀ a b c → a + (b + c) ≡ b + a + c
+  lem₃₁ a b c = begin
+    a + (b + c) ≡⟨ +-assoc a b c ⟨
+    (a + b) + c ≡⟨ cong (_+ c) (+-comm a b) ⟩
+    b + a + c   ∎
+
+  +-assoc-comm : ∀ a b c d → a + (b + c + d) ≡ (a + c) + (b + d)
+  +-assoc-comm a b c d = begin
+    a + (b + c + d)   ≡⟨ cong (a +_) (cong (_+ d) (+-comm b c)) ⟩
+    a + (c + b + d)   ≡⟨ cong (a +_) (+-assoc c b d) ⟩
+    a + (c + (b + d)) ≡⟨ +-assoc a c _ ⟨
+    (a + c) + (b + d) ∎
+
+  *-on-right : ∀ a b c {d} → b * c ≡ d → a * b * c ≡ a * d
+  *-on-right a b c {d} eq = begin
+    a * b * c   ≡⟨ *-assoc a b c ⟩
+    a * (b * c) ≡⟨ cong (a *_) eq ⟩
+    a * d       ∎
+
+  *-on-left : ∀ a b c {d} → a * b ≡ d → a * (b * c) ≡ d * c
+  *-on-left a b c {d} eq = begin
+    a * (b * c) ≡⟨ *-assoc a b c ⟨
+    a * b * c   ≡⟨ cong (_* c) eq ⟩
+    d * c       ∎
+
+  +-on-right : ∀ a b c {d} → b + c ≡ d → a + b + c ≡ a + d
+  +-on-right a b c {d} eq = begin
+    a + b + c   ≡⟨ +-assoc a b c ⟩
+    a + (b + c) ≡⟨ cong (a +_) eq ⟩
+    a + d       ∎
+
+  +-on-left : ∀ a b c d → a + b ≡ d → a + (b + c) ≡ d + c
+  +-on-left a b c d eq = begin
+    a + (b + c) ≡⟨ +-assoc a b c ⟨
+    a + b + c   ≡⟨ cong (_+ c) eq ⟩
+    d + c       ∎
+
+  +-focus-mid : ∀ a b c d → a + b + c + d ≡ a + (b + c) + d
+  +-focus-mid a b c d = begin
+    a + b + c + d     ≡⟨ cong (_+ d) (+-assoc a b c) ⟩
+    a + (b + c) + d   ∎
+
+  +-assoc-comm′ : ∀ a b c d → a + b + c + d ≡ a + (b + d) + c
+  +-assoc-comm′ a b c d = begin
+    a + b + c + d     ≡⟨ +-on-left a (b + c) d (a + b + c) (sym $ +-assoc a b c) ⟨
+    a + (b + c + d)   ≡⟨ cong (a +_) (+-on-right b c d (+-comm c d)) ⟩
+    a + (b + (d + c)) ≡⟨ cong (a +_) (+-assoc b d c) ⟨
+    a + (b + d + c)   ≡⟨ +-assoc a _ c ⟨
+    a + (b + d) + c   ∎
+
+  lem₃₂ : ∀ a b c n → a * n + (b * n + a * n + c * n) ≡ (a + a + (b + c)) * n
+  lem₃₂ a b c n = begin
+    a * n + (b * n + a * n + c * n) ≡⟨ cong (a * n +_) (distrib₃ b a c n) ⟨
+    a * n + (b + a + c) * n         ≡⟨ *-distribʳ-+ n a _ ⟨
+    (a + (b + a + c)) * n           ≡⟨ cong (_* n) (+-assoc-comm a b a c) ⟩
+    (a + a + (b + c)) * n           ∎
+
+  mid-to-right : ∀ a b c → a + 2 * b + c ≡ (a + b + c) + b
+  mid-to-right a b c = begin
+    a + 2 * b + c   ≡⟨ cong (λ x → a + x + c) (times2 b) ⟨
+    a + (b + b) + c ≡⟨ +-assoc-comm′ a b c b ⟨
+    a + b + c + b   ∎
+
+  mid-to-left : ∀ a b c → a + 2 * b + c ≡ b + (a + b + c)
+  mid-to-left a b c = begin
+    a + 2 * b + c   ≡⟨ cong (λ x → a + x + c) (times2 b) ⟨
+    a + (b + b) + c ≡⟨ cong (_+ c) (+-on-left a b b _ (+-comm a b)) ⟩
+    b + a + b + c   ≡⟨ +-on-left b (a + b) c (b + a + b) (sym $ +-assoc b a b) ⟨
+    b + (a + b + c) ∎
+
 lem₃ : ∀ d x {i k n} →
        d + (1 + x + i) * k ≡ x * n →
        d + (1 + x + i) * (n + k) ≡ (1 + 2 * x + i) * n
 lem₃ d x {i} {k} {n} eq = begin
-  d + y * (n + k)      ≡⟨ distrib-comm₂ d y k n ⟩
-  d + y * k + y * n    ≡⟨ cong₂ _+_ eq refl ⟩
-  x * n + y * n        ≡⟨ solve 3 (λ x n i → x :* n :+ (con 1 :+ x :+ i) :* n
-                                         :=  (con 1 :+ con 2 :* x :+ i) :* n)
-                                  refl x n i ⟩
-  (1 + 2 * x + i) * n  ∎
+  d + y * (n + k)                     ≡⟨ distrib-comm₂ d y k n ⟩
+  d + y * k + y * n                   ≡⟨ cong (_+ y * n) eq ⟩
+  x * n + y * n                       ≡⟨ cong (x * n +_) (distrib₃ 1 x i n) ⟩
+  x * n + (1 * n + x * n + i * n)     ≡⟨ lem₃₂ x 1 i n  ⟩
+  (x + x + (1 + i)) * n               ≡⟨ cong (_* n) (cong (_+ (1 + i)) (times2 x)) ⟩
+  (2 * x + (1 + i)) * n               ≡⟨ cong (_* n) (lem₃₁ (2 * x) 1 i) ⟩
+  (1 + 2 * x + i) * n                 ∎
   where y = 1 + x + i
 
 lem₄ : ∀ d y {k i} n →
@@ -67,32 +158,29 @@ lem₄ : ∀ d y {k i} n →
        d + y * (n + k) ≡ (1 + 2 * y + i) * n
 lem₄ d y {k} {i} n eq = begin
   d + y * (n + k)          ≡⟨ distrib-comm₂ d y k n ⟩
-  d + y * k + y * n        ≡⟨ cong₂ _+_ eq refl ⟩
-  (1 + y + i) * n + y * n  ≡⟨ solve 3 (λ y i n → (con 1 :+ y :+ i) :* n :+ y :* n
-                                             :=  (con 1 :+ con 2 :* y :+ i) :* n)
-                                      refl y i n ⟩
+  d + y * k + y * n        ≡⟨ cong (_+ y * n) eq ⟩
+  (1 + y + i) * n + y * n  ≡⟨ *-distribʳ-+ n (1 + y + i) y ⟨
+  (1 + y + i + y) * n      ≡⟨ cong (_* n) (mid-to-right 1 y i) ⟨
   (1 + 2 * y + i) * n      ∎
 
 lem₅ : ∀ d x {n k} →
        d + x * n ≡ x * k →
        d + 2 * x * n ≡ x * (n + k)
 lem₅ d x {n} {k} eq = begin
-  d + 2 * x * n      ≡⟨ solve 3 (λ d x n → d :+ con 2 :* x :* n
-                                       :=  d :+ x :* n :+ x :* n)
-                                refl d x n ⟩
-  d + x * n + x * n  ≡⟨ cong₂ _+_ eq refl ⟩
-  x * k + x * n      ≡⟨ distrib-comm x k n ⟩
-  x * (n + k)        ∎
+  d + 2 * x * n       ≡⟨ cong (d +_) (times2′ x n) ⟨
+  d + (x * n + x * n) ≡⟨ +-assoc d (x * n) _ ⟨
+  d + x * n + x * n   ≡⟨ cong (_+ x * n) eq ⟩
+  x * k + x * n       ≡⟨ comm-factor x k n ⟩
+  x * (n + k)         ∎
 
 lem₆ : ∀ d x {n i k} →
        d + x * n ≡ (1 + x + i) * k →
        d + (1 + 2 * x + i) * n ≡ (1 + x + i) * (n + k)
 lem₆ d x {n} {i} {k} eq = begin
-  d + (1 + 2 * x + i) * n  ≡⟨ solve 4 (λ d x i n → d :+ (con 1 :+ con 2 :* x :+ i) :* n
-                                               :=  d :+ x :* n :+ (con 1 :+ x :+ i) :* n)
-                                      refl d x i n ⟩
-  d + x * n + y * n        ≡⟨ cong₂ _+_ eq refl ⟩
-  y * k + y * n            ≡⟨ distrib-comm y k n ⟩
+  d + (1 + 2 * x + i) * n  ≡⟨ cong (λ z → d + z * n) (mid-to-left 1 x i) ⟩
+  d + (x + y) * n          ≡⟨ cong (d +_) (*-distribʳ-+ n x y) ⟩
+  d + (x * n + y * n)      ≡⟨ +-on-left d _ _ _ eq ⟩
+  y * k + y * n            ≡⟨ comm-factor y k n ⟩
   y * (n + k)              ∎
   where y = 1 + x + i
 
@@ -100,12 +188,11 @@ lem₇ : ∀ d y {i} n {k} →
        d + (1 + y + i) * n ≡ y * k →
        d + (1 + 2 * y + i) * n ≡ y * (n + k)
 lem₇ d y {i} n {k} eq = begin
-  d + (1 + 2 * y + i) * n      ≡⟨ solve 4 (λ d y i n → d :+ (con 1 :+ con 2 :* y :+ i) :* n
-                                                   :=  d :+ (con 1 :+ y :+ i) :* n :+ y :* n)
-                                          refl d y i n ⟩
-  d + (1 + y + i) * n + y * n  ≡⟨ cong₂ _+_ eq refl ⟩
-  y * k + y * n                ≡⟨ distrib-comm y k n ⟩
-  y * (n + k)                  ∎
+  d + (1 + 2 * y + i) * n       ≡⟨ cong (λ z → d + z * n) (mid-to-right 1 y i) ⟩
+  d + (1 + y + i + y) * n       ≡⟨ cong (d +_) (*-distribʳ-+ n (1 + y + i) y) ⟩
+  d + ((1 + y + i) * n + y * n) ≡⟨ +-on-left d _ _ _ eq ⟩
+  y * k + y * n                 ≡⟨ comm-factor y k n ⟩
+  y * (n + k)                   ∎
 
 lem₈ : ∀ {i j k q} x y →
        1 + y * j ≡ x * i → j * k ≡ q * i →
@@ -114,17 +201,12 @@ lem₈ {i} {j} {k} {q} x y eq eq′ =
   sym (lem₀ (x * k) (y * q) i k lemma)
   where
   lemma = begin
-    x * k * i        ≡⟨ solve 3 (λ x k i → x :* k :* i
-                                       :=  x :* i :* k)
-                                refl x k i ⟩
-    x * i * k        ≡⟨ cong (_* k) (sym eq) ⟩
-    (1 + y * j) * k  ≡⟨ solve 3 (λ y j k → (con 1 :+ y :* j) :* k
-                                       :=  y :* (j :* k) :+ k)
-                                refl y j k ⟩
+    x * k * i        ≡⟨ *-on-right x k i (*-comm k i) ⟩
+    x * (i * k)      ≡⟨ *-on-left x i k (sym eq) ⟩
+    (1 + y * j) * k  ≡⟨ +-comm k _ ⟩
+    (y * j) * k + k  ≡⟨ cong (_+ k) (*-assoc y j k) ⟩
     y * (j * k) + k  ≡⟨ cong (λ n → y * n + k) eq′ ⟩
-    y * (q * i) + k  ≡⟨ solve 4 (λ y q i k → y :* (q :* i) :+ k
-                                         :=  y :*  q :* i  :+ k)
-                                refl y q i k ⟩
+    y * (q * i) + k  ≡⟨ cong (_+ k) (*-assoc y q i)  ⟨
     y *  q * i  + k  ∎
 
 lem₉ : ∀ {i j k q} x y →
@@ -133,15 +215,19 @@ lem₉ : ∀ {i j k q} x y →
 lem₉ {i} {j} {k} {q} x y eq eq′ =
   sym (lem₀ (y * q) (x * k) i k lemma)
   where
-  lem   = solve 3 (λ a b c → a :* b :* c  :=  b :* c :* a) refl
+  lem : ∀ a b c → a * b * c ≡ b * c * a
+  lem a b c = begin
+    a * b * c   ≡⟨ *-assoc a b c ⟩
+    a * (b * c) ≡⟨ *-comm a _ ⟩
+    b * c * a   ∎
   lemma = begin
     y * q * i        ≡⟨ lem y q i ⟩
-    q * i * y        ≡⟨ cong (λ n → n * y) (sym eq′) ⟩
-    j * k * y        ≡⟨ sym (lem y j k) ⟩
-    y * j * k        ≡⟨ cong (λ n → n * k) (sym eq) ⟩
-    (1 + x * i) * k  ≡⟨ solve 3 (λ x i k → (con 1 :+ x :* i) :* k
-                                       :=  x :* k :* i :+ k)
-                                refl x i k ⟩
+    q * i * y        ≡⟨ cong (λ n → n * y) eq′ ⟨
+    j * k * y        ≡⟨ lem y j k ⟨
+    y * j * k        ≡⟨ cong (λ n → n * k) eq ⟨
+    (1 + x * i) * k  ≡⟨ +-comm k _ ⟩
+    x * i * k + k    ≡⟨ cong (_+ k) (*-on-right x i k (*-comm i k)) ⟩
+    x * (k * i) + k  ≡⟨ cong (_+ k) (*-assoc x k i) ⟨
     x * k * i + k    ∎
 
 lem₁₀ : ∀ {a′} b c {d} e f → let a = suc a′ in
@@ -151,28 +237,29 @@ lem₁₀ {a′} b c {d} e f eq =
   m*n≡1⇒n≡1 (e * f ∸ b * c) d
     (lem₀ (e * f) (b * c) d 1
        (*-cancelʳ-≡ (e * f * d) (b * c * d + 1) _ (begin
-          e * f * d * a        ≡⟨ solve 4 (λ e f d a → e :* f :* d :* a
-                                                   :=  e :* (f :* d :* a))
-                                          refl e f d a ⟩
-          e * (f * d * a)      ≡⟨ sym eq ⟩
-          a + b * (c * d * a)  ≡⟨ solve 4 (λ a b c d → a :+ b :* (c :* d :* a)
-                                                   :=  (b :* c :* d :+ con 1) :* a)
-                                          refl a b c d ⟩
-          (b * c * d + 1) * a  ∎)))
+          e * f * d * a           ≡⟨ *-assoc₄₃ e f d a ⟩
+          e * (f * d * a)         ≡⟨ eq ⟨
+          a + b * (c * d * a)     ≡⟨ cong (a +_) (*-assoc₄₃ b c d a) ⟨
+          a + b * c * d * a       ≡⟨ +-comm a _ ⟩
+          b * c * d * a + a       ≡⟨ cong (b * c * d * a +_) (+-identityʳ a) ⟨
+          b * c * d * a + (a + 0) ≡⟨ *-distribʳ-+ a (b * c * d) 1 ⟨
+          (b * c * d + 1) * a     ∎)))
   where a = suc a′
+        *-assoc₄₃ : ∀ w x y z → w * x * y * z ≡ w * (x * y * z)
+        *-assoc₄₃ w x y z = begin
+          w * x * y * z   ≡⟨ cong (_* z) (*-assoc w x y) ⟩
+          w * (x * y) * z ≡⟨ *-assoc w _ z ⟩
+          w * (x * y * z) ∎
 
 lem₁₁ : ∀ {i j m n k d} x y →
        1 + y * j ≡ x * i → i * k ≡ m * d → j * k ≡ n * d →
        k ≡ (x * m ∸ y * n) * d
 lem₁₁ {i} {j} {m} {n} {k} {d} x y eq eq₁ eq₂ =
   sym (lem₀ (x * m) (y * n) d k (begin
-    x * m * d        ≡⟨ *-assoc x m d ⟩
-    x * (m * d)      ≡⟨ cong (x *_) (sym eq₁) ⟩
-    x * (i * k)      ≡⟨ sym (*-assoc x i k) ⟩
-    x * i * k        ≡⟨ cong₂ _*_ (sym eq) refl ⟩
-    (1 + y * j) * k  ≡⟨ solve 3 (λ y j k → (con 1 :+ y :* j) :* k
-                                       :=  y :* (j :* k) :+ k)
-                                refl y j k ⟩
+    x * m * d        ≡⟨ *-on-right x m d (sym eq₁) ⟩
+    x * (i * k)      ≡⟨ *-on-left x i k (sym eq) ⟩
+    (1 + y * j) * k  ≡⟨ +-comm k _ ⟩
+    y * j * k + k    ≡⟨ cong (_+ k) (*-assoc y j k) ⟩
     y * (j * k) + k  ≡⟨ cong (λ p → y * p + k) eq₂ ⟩
-    y * (n * d) + k  ≡⟨ cong₂ _+_ (sym $ *-assoc y n d) refl ⟩
+    y * (n * d) + k  ≡⟨ cong (_+ k) (*-assoc y n d) ⟨
     y * n * d + k    ∎))
diff --git a/src/Data/Nat/GeneralisedArithmetic.agda b/src/Data/Nat/GeneralisedArithmetic.agda
index 38d9472092..a5b1d7700f 100644
--- a/src/Data/Nat/GeneralisedArithmetic.agda
+++ b/src/Data/Nat/GeneralisedArithmetic.agda
@@ -8,11 +8,15 @@
 
 module Data.Nat.GeneralisedArithmetic where
 
-open import Data.Nat.Base
-open import Data.Nat.Properties
+open import Data.Nat.Base using (ℕ; zero; suc; _+_; _*_; _^_)
+open import Data.Nat.Properties using (+-comm; +-assoc; *-identityˡ;
+  *-assoc)
 open import Function.Base using (_∘′_; _∘_; id)
 open import Level using (Level)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; sym)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open ≡-Reasoning
 
 private
diff --git a/src/Data/Nat/Induction.agda b/src/Data/Nat/Induction.agda
index ea68692a51..e1554074c4 100644
--- a/src/Data/Nat/Induction.agda
+++ b/src/Data/Nat/Induction.agda
@@ -10,9 +10,8 @@ module Data.Nat.Induction where
 
 open import Data.Nat.Base
 open import Data.Nat.Properties using (<⇒<′)
-open import Data.Product
+open import Data.Product.Base using (_×_; _,_)
 open import Data.Unit.Polymorphic.Base
-open import Function.Base
 open import Induction
 open import Induction.WellFounded as WF
 open import Level using (Level)
@@ -68,8 +67,8 @@ cRec = build cRecBuilder
 
 <′-wellFounded n = acc (<′-wellFounded′ n)
 
-<′-wellFounded′ (suc n) n <′-base       = <′-wellFounded n
-<′-wellFounded′ (suc n) m (<′-step m<n) = <′-wellFounded′ n m m<n
+<′-wellFounded′ (suc n) <′-base       = <′-wellFounded n
+<′-wellFounded′ (suc n) (<′-step m<n) = <′-wellFounded′ n m<n
 
 module _ {ℓ : Level} where
   open WF.All <′-wellFounded ℓ public
@@ -91,17 +90,17 @@ module _ {ℓ : Level} where
 -- the first billion proofs. Use this when you require the function
 -- using the proof of well-foundedness to evaluate fast.
 --
--- IMPORTANT: You have to be a little bit careful when using this to always
--- make the function be strict in some other argument than the accessibility
--- proof, otherwise you will have neutral terms unfolding a billion times
--- before getting stuck.
+-- IMPORTANT: You have to be a little bit careful when using this to
+-- always make the function be strict in some other argument than the
+-- accessibility proof, otherwise you will have neutral terms unfolding
+-- a billion times before getting stuck.
 <-wellFounded-fast : WellFounded _<_
 <-wellFounded-fast = <-wellFounded-skip 1000000000
   where
   <-wellFounded-skip : ∀ (k : ℕ) → WellFounded _<_
   <-wellFounded-skip zero    n       = <-wellFounded n
   <-wellFounded-skip (suc k) zero    = <-wellFounded 0
-  <-wellFounded-skip (suc k) (suc n) = acc (λ m _ → <-wellFounded-skip k m)
+  <-wellFounded-skip (suc k) (suc n) = acc λ {m} _ → <-wellFounded-skip k m
 
 module _ {ℓ : Level} where
   open WF.All <-wellFounded ℓ public
diff --git a/src/Data/Nat/InfinitelyOften.agda b/src/Data/Nat/InfinitelyOften.agda
index 0913f3fd5c..38a4c3eecd 100644
--- a/src/Data/Nat/InfinitelyOften.agda
+++ b/src/Data/Nat/InfinitelyOften.agda
@@ -11,16 +11,17 @@ module Data.Nat.InfinitelyOften where
 open import Effect.Monad using (RawMonad)
 open import Level using (Level; 0ℓ)
 open import Data.Empty using (⊥-elim)
-open import Data.Nat.Base
+open import Data.Nat.Base using (ℕ; _≤_; _⊔_; _+_; suc; zero; s≤s)
 open import Data.Nat.Properties
-open import Data.Product as Prod hiding (map)
-open import Data.Sum hiding (map)
-open import Function
-open import Relation.Binary.PropositionalEquality
+open import Data.Product.Base as Prod hiding (map)
+open import Data.Sum.Base using (inj₁; inj₂; _⊎_)
+open import Function.Base using (_∘_; id)
+open import Relation.Binary.PropositionalEquality.Core using (_≢_)
 open import Relation.Nullary.Negation using (¬_)
 open import Relation.Nullary.Negation using (¬¬-Monad; call/cc)
 open import Relation.Unary using (Pred; _∪_; _⊆_)
-open RawMonad (¬¬-Monad {p = 0ℓ})
+
+open RawMonad (¬¬-Monad {a = 0ℓ})
 
 private
   variable
diff --git a/src/Data/Nat/LCM.agda b/src/Data/Nat/LCM.agda
index 9b8932785a..fc8937577b 100644
--- a/src/Data/Nat/LCM.agda
+++ b/src/Data/Nat/LCM.agda
@@ -15,12 +15,12 @@ open import Data.Nat.Divisibility
 open import Data.Nat.DivMod
 open import Data.Nat.Properties
 open import Data.Nat.GCD
-open import Data.Product
+open import Data.Product.Base using (_×_; _,_; uncurry′; ∃)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
-open import Function
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; refl; sym; trans; cong; cong₂; module ≡-Reasoning)
-open import Relation.Binary
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; sym; trans; cong; cong₂; subst)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Relation.Nullary.Decidable using (False; fromWitnessFalse)
 
 private
@@ -32,8 +32,8 @@ private
 -- Definition
 
 lcm : ℕ → ℕ → ℕ
-lcm zero        n = zero
-lcm m@(suc m-1) n = m * (n / gcd m n)
+lcm zero      n = zero
+lcm m@(suc _) n = m * (n / gcd m n)
   where instance _ = gcd≢0ˡ {m} {n}
 
 ------------------------------------------------------------------------
@@ -53,16 +53,16 @@ n∣lcm[m,n] : ∀ m n → n ∣ lcm m n
 n∣lcm[m,n] zero        n = n ∣0
 n∣lcm[m,n] m@(suc m-1) n = begin
   n                 ∣⟨  m∣m*n (m / gcd m n) ⟩
-  n * (m / gcd m n) ≡˘⟨ *-/-assoc n (gcd[m,n]∣m m n) ⟩
+  n * (m / gcd m n) ≡⟨ *-/-assoc n (gcd[m,n]∣m m n) ⟨
   n * m / gcd m n   ≡⟨  cong (_/ gcd m n) (*-comm n m) ⟩
-  m * n / gcd m n   ≡˘⟨ rearrange m n ⟩
+  m * n / gcd m n   ≡⟨ rearrange m n ⟨
   m * (n / gcd m n) ∎
   where open ∣-Reasoning; instance _ = gcd≢0ˡ {m} {n}
 
 
 lcm-least : ∀ {m n c} → m ∣ c → n ∣ c → lcm m n ∣ c
 lcm-least {zero}      {n} {c} 0∣c _   = 0∣c
-lcm-least {m@(suc _)} {n} {c} m∣c n∣c = P.subst (_∣ c) (sym (rearrange m n))
+lcm-least {m@(suc _)} {n} {c} m∣c n∣c = subst (_∣ c) (sym (rearrange m n))
   (m∣n*o⇒m/n∣o gcd[m,n]∣m*n mn∣c*gcd)
   where
   instance _ = gcd≢0ˡ {m} {n}
@@ -73,8 +73,8 @@ lcm-least {m@(suc _)} {n} {c} m∣c n∣c = P.subst (_∣ c) (sym (rearrange m n
 
   mn∣c*gcd : m * n ∣ c * gcd m n
   mn∣c*gcd = begin
-    m * n               ∣⟨  gcd-greatest (P.subst (_∣ c * m) (*-comm n m) (*-monoˡ-∣ m n∣c)) (*-monoˡ-∣ n m∣c) ⟩
-    gcd (c * m) (c * n) ≡˘⟨ c*gcd[m,n]≡gcd[cm,cn] c m n ⟩
+    m * n               ∣⟨  gcd-greatest (subst (_∣ c * m) (*-comm n m) (*-monoˡ-∣ m n∣c)) (*-monoˡ-∣ n m∣c) ⟩
+    gcd (c * m) (c * n) ≡⟨ c*gcd[m,n]≡gcd[cm,cn] c m n ⟨
     c * gcd m n         ∎
 
 ------------------------------------------------------------------------
diff --git a/src/Data/Nat/Literals.agda b/src/Data/Nat/Literals.agda
index 2c18dc185c..22a53dedeb 100644
--- a/src/Data/Nat/Literals.agda
+++ b/src/Data/Nat/Literals.agda
@@ -8,9 +8,9 @@
 
 module Data.Nat.Literals where
 
-open import Agda.Builtin.FromNat
-open import Agda.Builtin.Nat
-open import Data.Unit
+open import Agda.Builtin.FromNat using (Number)
+open import Agda.Builtin.Nat using (Nat)
+open import Data.Unit.Base using (⊤)
 
 number : Number Nat
 number = record
diff --git a/src/Data/Nat/Logarithm.agda b/src/Data/Nat/Logarithm.agda
index 4e08abcf4d..48155f1427 100644
--- a/src/Data/Nat/Logarithm.agda
+++ b/src/Data/Nat/Logarithm.agda
@@ -1,4 +1,4 @@
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The Agda standard library
 --
 -- Logarithm base 2 and respective properties
@@ -8,10 +8,10 @@
 
 module Data.Nat.Logarithm where
 
-open import Data.Nat
+open import Data.Nat.Base
 open import Data.Nat.Induction using (<-wellFounded)
 open import Data.Nat.Logarithm.Core
-open import Relation.Binary.PropositionalEquality using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 ------------------------------------------------------------------------
 -- Logarithm base 2
diff --git a/src/Data/Nat/Logarithm/Core.agda b/src/Data/Nat/Logarithm/Core.agda
index 63385c89c1..fea77bf42d 100644
--- a/src/Data/Nat/Logarithm/Core.agda
+++ b/src/Data/Nat/Logarithm/Core.agda
@@ -1,4 +1,4 @@
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The Agda standard library
 --
 -- Logarithm base 2 core definitions and properties
@@ -8,12 +8,15 @@
 
 module Data.Nat.Logarithm.Core where
 
-open import Data.Nat.Base
+open import Data.Nat.Base using (ℕ; _<_; zero; suc; _+_; ⌊_/2⌋; ⌈_/2⌉;
+  _≤_; z≤n; s≤s; _∸_; NonZero; _*_; _^_)
 open import Data.Nat.Properties
 open import Data.Nat.Induction using (<-wellFounded)
 open import Induction.WellFounded using (Acc; acc)
-open import Relation.Binary.PropositionalEquality
-open import Data.Unit
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; sym)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 
 ------------------------------------------------------------------------
 -- Logarithm base 2
@@ -23,7 +26,7 @@ open import Data.Unit
 ⌊log2⌋ : ∀ n → Acc _<_ n → ℕ
 ⌊log2⌋ 0          _        = 0
 ⌊log2⌋ 1          _        = 0
-⌊log2⌋ (suc n′@(suc n)) (acc rs) = 1 + ⌊log2⌋ (suc ⌊ n /2⌋) (rs _ (⌊n/2⌋<n n′))
+⌊log2⌋ (suc n′@(suc n)) (acc rs) = 1 + ⌊log2⌋ (suc ⌊ n /2⌋) (rs (⌊n/2⌋<n n′))
 
 
 -- Ceil version
@@ -31,7 +34,7 @@ open import Data.Unit
 ⌈log2⌉ : ∀ n → Acc _<_ n → ℕ
 ⌈log2⌉ 0                _        = 0
 ⌈log2⌉ 1                _        = 0
-⌈log2⌉ (suc (suc n)) (acc rs) = 1 + ⌈log2⌉ (suc ⌈ n /2⌉) (rs _ (⌈n/2⌉<n n))
+⌈log2⌉ (suc (suc n)) (acc rs) = 1 + ⌈log2⌉ (suc ⌈ n /2⌉) (rs (⌈n/2⌉<n n))
 
 ------------------------------------------------------------------------
 -- Properties of ⌊log2⌋
@@ -72,7 +75,7 @@ open import Data.Unit
 ⌊log2⌋2^n≡n : ∀ n {acc} → ⌊log2⌋ (2 ^ n) acc ≡ n
 ⌊log2⌋2^n≡n zero    = refl
 ⌊log2⌋2^n≡n (suc n) = begin
-  ⌊log2⌋ ((2 ^ n) + ((2 ^ n) + zero)) _ ≡⟨ ⌊log2⌋2*b≡1+⌊log2⌋b (2 ^ n) {{>-nonZero (2^n>0 n)}} ⟩
+  ⌊log2⌋ ((2 ^ n) + ((2 ^ n) + zero)) _ ≡⟨ ⌊log2⌋2*b≡1+⌊log2⌋b (2 ^ n) {{m^n≢0 2 n}} ⟩
   1 + ⌊log2⌋ (2 ^ n) (<-wellFounded _)  ≡⟨ cong suc (⌊log2⌋2^n≡n n) ⟩
   suc n                                 ∎
   where open ≡-Reasoning
@@ -116,7 +119,7 @@ open import Data.Unit
 ⌈log2⌉2^n≡n : ∀ n {acc} → ⌈log2⌉ (2 ^ n) acc ≡ n
 ⌈log2⌉2^n≡n zero    = refl
 ⌈log2⌉2^n≡n (suc n) = begin
-  ⌈log2⌉ ((2 ^ n) + ((2 ^ n) + zero)) _ ≡⟨ ⌈log2⌉2*n≡1+⌈log2⌉n (2 ^ n) {{>-nonZero (2^n>0 n)}} ⟩
+  ⌈log2⌉ ((2 ^ n) + ((2 ^ n) + zero)) _ ≡⟨ ⌈log2⌉2*n≡1+⌈log2⌉n (2 ^ n) {{m^n≢0 2 n}} ⟩
   1 + ⌈log2⌉ (2 ^ n) (<-wellFounded _)  ≡⟨ cong suc (⌈log2⌉2^n≡n n) ⟩
   suc n                                 ∎
   where open ≡-Reasoning
diff --git a/src/Data/Nat/Primality.agda b/src/Data/Nat/Primality.agda
index e634095eea..b07883ce9b 100644
--- a/src/Data/Nat/Primality.agda
+++ b/src/Data/Nat/Primality.agda
@@ -8,136 +8,418 @@
 
 module Data.Nat.Primality where
 
-open import Data.Empty using (⊥)
+open import Data.List.Base using ([]; _∷_; product)
+open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
 open import Data.Nat.Base
 open import Data.Nat.Divisibility
 open import Data.Nat.GCD using (module GCD; module Bézout)
 open import Data.Nat.Properties
-open import Data.Product
-open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
+open import Data.Product.Base using (∃-syntax; _×_; map₂; _,_)
+open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_]′)
 open import Function.Base using (flip; _∘_; _∘′_)
+open import Function.Bundles using (_⇔_; mk⇔)
 open import Relation.Nullary.Decidable as Dec
-  using (yes; no; from-yes; ¬?; decidable-stable; _×-dec_; _→-dec_)
-open import Relation.Nullary.Negation using (¬_; contradiction)
-open import Relation.Unary using (Decidable)
-open import Relation.Binary.PropositionalEquality
-  using (refl; sym; cong; subst)
+  using (yes; no; from-yes; from-no; ¬?; _×-dec_; _⊎-dec_; _→-dec_; decidable-stable)
+open import Relation.Nullary.Negation using (¬_; contradiction; contradiction₂)
+open import Relation.Unary using (Pred; Decidable)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≢_; refl; cong)
 
 private
   variable
-    n : ℕ
+    d m n o p : ℕ
+
+  recompute-nonTrivial : .{{NonTrivial n}} → NonTrivial n
+  recompute-nonTrivial {n} {{nontrivial}} =
+    Dec.recompute (nonTrivial? n) nontrivial
 
 ------------------------------------------------------------------------
 -- Definitions
+------------------------------------------------------------------------
+
+-- The positive/existential relation `BoundedNonTrivialDivisor` is
+-- the basis for the whole development, as it captures the possible
+-- non-trivial divisors of a given number; its complement, `Rough`,
+-- therefore sets *lower* bounds on any possible such divisors.
 
--- Definition of compositeness
+-- The predicate `Composite` is then defined as the 'diagonal' instance
+-- of `BoundedNonTrivialDivisor`, while `Prime` is essentially defined as
+-- the complement of `Composite`. Finally, `Irreducible` is the positive
+-- analogue of `Prime`.
 
-Composite : ℕ → Set
-Composite 0 = ⊥
-Composite 1 = ⊥
-Composite n = ∃ λ d → 2 ≤ d × d < n × d ∣ n
+------------------------------------------------------------------------
+-- Roughness
 
--- Definition of primality.
+-- A number is m-rough if all its non-trivial divisors are bounded below
+-- by m.
+infix 10 _Rough_
 
-Prime : ℕ → Set
-Prime 0 = ⊥
-Prime 1 = ⊥
-Prime n = ∀ {d} → 2 ≤ d → d < n → d ∤ n
+_Rough_ : ℕ → Pred ℕ _
+m Rough n = ¬ (n HasNonTrivialDivisorLessThan m)
 
 ------------------------------------------------------------------------
--- Decidability
+-- Compositeness
 
-composite? : Decidable Composite
-composite? 0               = no λ()
-composite? 1               = no λ()
-composite? n@(suc (suc _)) = Dec.map′
-  (map₂ λ { (a , b , c) → (b , a , c)})
-  (map₂ λ { (a , b , c) → (b , a , c)})
-  (anyUpTo? (λ d → 2 ≤? d ×-dec d ∣? n) n)
+-- A number is composite if it has a proper non-trivial divisor.
+Composite : Pred ℕ _
+Composite n = n HasNonTrivialDivisorLessThan n
 
-prime? : Decidable Prime
-prime? 0               = no λ()
-prime? 1               = no λ()
-prime? n@(suc (suc _)) = Dec.map′
-  (λ f {d} → flip (f {d}))
-  (λ f {d} → flip (f {d}))
-  (allUpTo? (λ d → 2 ≤? d →-dec ¬? (d ∣? n)) n)
+-- A shorter pattern synonym for the record constructor producing a
+-- witness for `Composite`.
+pattern
+  composite {d} d<n d∣n = hasNonTrivialDivisor {divisor = d} d<n d∣n
 
 ------------------------------------------------------------------------
--- Relationships between compositeness and primality
+-- Primality
 
-composite⇒¬prime : Composite n → ¬ Prime n
-composite⇒¬prime {n@(suc (suc _))} (d , 2≤d , d<n , d∣n) n-prime =
-  n-prime 2≤d d<n d∣n
+-- Prime as the complement of Composite (and hence the diagonal of Rough
+-- as defined above). The constructor `prime` takes a proof `notComposite`
+-- that NonTrivial p is not composite and thereby enforces that:
+-- * p is a fortiori NonZero and NonUnit
+-- * p is p-Rough, i.e. any proper divisor must be at least p, i.e. p itself
+record Prime (p : ℕ) : Set where
+  constructor prime
+  field
+    .{{nontrivial}} : NonTrivial p
+    notComposite    : ¬ Composite p
+
+------------------------------------------------------------------------
+-- Irreducibility
 
-¬composite⇒prime : 2 ≤ n → ¬ Composite n → Prime n
-¬composite⇒prime (s≤s (s≤s _)) ¬n-composite {d} 2≤d d<n d∣n =
-  ¬n-composite (d , 2≤d , d<n , d∣n)
+Irreducible : Pred ℕ _
+Irreducible n = ∀ {d} → d ∣ n → d ≡ 1 ⊎ d ≡ n
 
-prime⇒¬composite : Prime n → ¬ Composite n
-prime⇒¬composite {n@(suc (suc _))} n-prime (d , 2≤d , d<n , d∣n) =
-  n-prime 2≤d d<n d∣n
+------------------------------------------------------------------------
+-- Properties
+------------------------------------------------------------------------
+
+------------------------------------------------------------------------
+-- Roughness
+
+-- 1 is always n-rough
+rough-1 : ∀ n → n Rough 1
+rough-1 _ (hasNonTrivialDivisor _ d∣1) =
+  contradiction (∣1⇒≡1 d∣1) nonTrivial⇒≢1
+
+-- Any number is 0-, 1- and 2-rough,
+-- because no proper divisor d can be strictly less than 0, 1, or 2
+0-rough : 0 Rough n
+0-rough (hasNonTrivialDivisor () _)
+
+1-rough : 1 Rough n
+1-rough (hasNonTrivialDivisor {{()}} z<s _)
+
+2-rough : 2 Rough n
+2-rough (hasNonTrivialDivisor {{()}} (s<s z<s) _)
+
+-- If a number n > 1 is m-rough, then m ≤ n
+rough⇒≤ : .{{NonTrivial n}} → m Rough n → m ≤ n
+rough⇒≤ rough = ≮⇒≥ n≮m
+  where n≮m = λ m>n → rough (hasNonTrivialDivisor m>n ∣-refl)
+
+-- If a number n is m-rough, and m ∤ n, then n is (suc m)-rough
+∤⇒rough-suc : m ∤ n → m Rough n → (suc m) Rough n
+∤⇒rough-suc m∤n r (hasNonTrivialDivisor d<1+m d∣n)
+  with m<1+n⇒m<n∨m≡n d<1+m
+... | inj₁ d<m      = r (hasNonTrivialDivisor d<m d∣n)
+... | inj₂ d≡m@refl = contradiction d∣n m∤n
+
+-- If a number is m-rough, then so are all of its divisors
+rough∧∣⇒rough : m Rough o → n ∣ o → m Rough n
+rough∧∣⇒rough r n∣o bntd = r (hasNonTrivialDivisor-∣ bntd n∣o)
+
+------------------------------------------------------------------------
+-- Compositeness
+
+-- Smart constructors
+
+composite-≢ : ∀ d → .{{NonTrivial d}} → .{{NonZero n}} →
+              d ≢ n → d ∣ n → Composite n
+composite-≢ d = hasNonTrivialDivisor-≢ {d}
+
+composite-∣ : .{{NonZero n}} → Composite m → m ∣ n → Composite n
+composite-∣ (composite {d} d<m d∣n) m∣n@(divides-refl q)
+  = composite (*-monoʳ-< q d<m) (*-monoʳ-∣ q d∣n)
+  where instance
+    _ = m≢0∧n>1⇒m*n>1 q d
+    _ = m*n≢0⇒m≢0 q
+
+-- Basic (counter-)examples of Composite
+
+¬composite[0] : ¬ Composite 0
+¬composite[0] = 0-rough
 
--- note that this has to recompute the factor!
-¬prime⇒composite : 2 ≤ n → ¬ Prime n → Composite n
-¬prime⇒composite {n} 2≤n ¬n-prime =
-  decidable-stable (composite? n) (¬n-prime ∘′ ¬composite⇒prime 2≤n)
+¬composite[1] : ¬ Composite 1
+¬composite[1] = 1-rough
+
+composite[4] : Composite 4
+composite[4] = composite-≢ 2 (λ()) (divides-refl 2)
+
+composite[6] : Composite 6
+composite[6] = composite-≢ 3 (λ()) (divides-refl 2)
+
+composite⇒nonZero : Composite n → NonZero n
+composite⇒nonZero {suc _} _ = _
+
+composite⇒nonTrivial : Composite n → NonTrivial n
+composite⇒nonTrivial {1}    composite[1] =
+  contradiction composite[1] ¬composite[1]
+composite⇒nonTrivial {2+ _} _            = _
+
+composite? : Decidable Composite
+composite? n = Dec.map CompositeUpTo⇔Composite (compositeUpTo? n)
+  where
+  -- For technical reasons, in order to be able to prove decidability
+  -- via the `all?` and `any?` combinators for *bounded* predicates on
+  -- `ℕ`, we further define the bounded counterparts to predicates
+  -- `P...` as `P...UpTo` and show the equivalence of the two.
+
+  -- Equivalent bounded predicate definition
+  CompositeUpTo : Pred ℕ _
+  CompositeUpTo n = ∃[ d ] d < n × NonTrivial d × d ∣ n
+
+  -- Proof of equivalence
+  comp-upto⇒comp : CompositeUpTo n → Composite n
+  comp-upto⇒comp (_ , d<n , ntd , d∣n) = composite d<n d∣n
+    where instance _ = ntd
+
+  comp⇒comp-upto : Composite n → CompositeUpTo n
+  comp⇒comp-upto (composite d<n d∣n) = _ , d<n , recompute-nonTrivial , d∣n
+
+  CompositeUpTo⇔Composite : CompositeUpTo n ⇔ Composite n
+  CompositeUpTo⇔Composite = mk⇔ comp-upto⇒comp comp⇒comp-upto
+
+  -- Proof of decidability
+  compositeUpTo? : Decidable CompositeUpTo
+  compositeUpTo? n = anyUpTo? (λ d → nonTrivial? d ×-dec d ∣? n) n
 
 ------------------------------------------------------------------------
--- Euclid's lemma
+-- Primality
+
+-- Basic (counter-)examples
+
+¬prime[0] : ¬ Prime 0
+¬prime[0] ()
+
+¬prime[1] : ¬ Prime 1
+¬prime[1] ()
+
+prime[2] : Prime 2
+prime[2] = prime 2-rough
 
--- For p prime, if p ∣ m * n, then either p ∣ m or p ∣ n.
--- This demonstrates that the usual definition of prime numbers matches the
--- ring theoretic definition of a prime element of the semiring ℕ.
+prime⇒nonZero : Prime p → NonZero p
+prime⇒nonZero _ = nonTrivial⇒nonZero _
+
+prime⇒nonTrivial : Prime p → NonTrivial p
+prime⇒nonTrivial _ = recompute-nonTrivial
+
+prime? : Decidable Prime
+prime? 0        = no ¬prime[0]
+prime? 1        = no ¬prime[1]
+prime? n@(2+ _) = Dec.map PrimeUpTo⇔Prime (primeUpTo? n)
+  where
+  -- Equivalent bounded predicate definition
+  PrimeUpTo : Pred ℕ _
+  PrimeUpTo n = ∀ {d} → d < n → NonTrivial d → d ∤ n
+
+  -- Proof of equivalence
+  prime⇒prime-upto : Prime n → PrimeUpTo n
+  prime⇒prime-upto (prime p) {d} d<n ntd d∣n
+    = p (composite d<n d∣n) where instance _ = ntd
+
+  prime-upto⇒prime : .{{NonTrivial n}} → PrimeUpTo n → Prime n
+  prime-upto⇒prime upto = prime
+    λ (composite d<n d∣n) → upto d<n recompute-nonTrivial d∣n
+
+  PrimeUpTo⇔Prime : .{{NonTrivial n}} → PrimeUpTo n ⇔ Prime n
+  PrimeUpTo⇔Prime = mk⇔ prime-upto⇒prime prime⇒prime-upto
+
+  -- Proof of decidability
+  primeUpTo? : Decidable PrimeUpTo
+  primeUpTo? n = allUpTo? (λ d → nonTrivial? d →-dec ¬? (d ∣? n)) n
+
+-- Euclid's lemma - for p prime, if p ∣ m * n, then either p ∣ m or p ∣ n.
+--
+-- This demonstrates that the usual definition of prime numbers matches
+-- the ring theoretic definition of a prime element of the semiring ℕ.
 -- This is useful for proving many other theorems involving prime numbers.
 euclidsLemma : ∀ m n {p} → Prime p → p ∣ m * n → p ∣ m ⊎ p ∣ n
-euclidsLemma m n {p@(suc (suc _))} p-prime p∣m*n = result
+euclidsLemma m n {p} pp@(prime pr) p∣m*n = result
   where
   open ∣-Reasoning
+  instance _ = prime⇒nonZero pp
 
   p∣rmn : ∀ r → p ∣ r * m * n
   p∣rmn r = begin
     p           ∣⟨ p∣m*n ⟩
     m * n       ∣⟨ n∣m*n r ⟩
-    r * (m * n) ≡˘⟨ *-assoc r m n ⟩
+    r * (m * n) ≡⟨ *-assoc r m n ⟨
     r * m * n   ∎
 
   result : p ∣ m ⊎ p ∣ n
   result with Bézout.lemma m p
-  -- if the GCD of m and p is zero then p must be zero, which is impossible as p
-  -- is a prime
-  ... | Bézout.result 0 g _ = contradiction (0∣⇒≡0 (GCD.gcd∣n g)) λ()
+  -- if the GCD of m and p is zero then p must be zero, which is
+  -- impossible as p is a prime.
+  -- note: this should be a typechecker-rejectable case!?
+  ... | Bézout.result 0 g _ =
+    contradiction (0∣⇒≡0 (GCD.gcd∣n g)) (≢-nonZero⁻¹ _)
 
-  -- if the GCD of m and p is one then m and p is coprime, and we know that for
-  -- some integers s and r, sm + rp = 1. We can use this fact to determine that p
-  -- divides n
+  -- if the GCD of m and p is one then m and p are coprime, and we know
+  -- that for some integers s and r, sm + rp = 1. We can use this fact
+  -- to determine that p divides n
   ... | Bézout.result 1 _ (Bézout.+- r s 1+sp≡rm) =
     inj₂ (flip ∣m+n∣m⇒∣n (n∣m*n*o s n) (begin
       p             ∣⟨ p∣rmn r ⟩
-      r * m * n     ≡˘⟨ cong (_* n) 1+sp≡rm ⟩
+      r * m * n     ≡⟨ cong (_* n) 1+sp≡rm ⟨
       n + s * p * n ≡⟨ +-comm n (s * p * n) ⟩
       s * p * n + n ∎))
 
   ... | Bézout.result 1 _ (Bézout.-+ r s 1+rm≡sp) =
     inj₂ (flip ∣m+n∣m⇒∣n (p∣rmn r) (begin
       p             ∣⟨ n∣m*n*o s n ⟩
-      s * p * n     ≡˘⟨ cong (_* n) 1+rm≡sp ⟩
+      s * p * n     ≡⟨ cong (_* n) 1+rm≡sp ⟨
       n + r * m * n ≡⟨ +-comm n (r * m * n) ⟩
       r * m * n + n ∎))
 
-  -- if the GCD of m and p is greater than one, then it must be p and hence p ∣ m.
-  ... | Bézout.result d@(suc (suc _)) g _ with d ≟ p
-  ...   | yes refl = inj₁ (GCD.gcd∣m g)
-  ...   | no  d≢p  = contradiction (GCD.gcd∣n g) (p-prime 2≤d d<p)
-    where 2≤d = s≤s (s≤s z≤n); d<p = flip ≤∧≢⇒< d≢p (∣⇒≤ (GCD.gcd∣n g))
+  -- if the GCD of m and p is greater than one, then it must be p and
+  -- hence p ∣ m.
+  ... | Bézout.result d@(2+ _) g _ with d ≟ p
+  ...   | yes d≡p@refl = inj₁ (GCD.gcd∣m g)
+  ...   | no  d≢p = contradiction (composite-≢ d d≢p (GCD.gcd∣n g)) pr
+
+-- Relationship between roughness and primality.
+prime⇒rough : Prime p → p Rough p
+prime⇒rough (prime pr) = pr
+
+-- If a number n is p-rough, and p > 1 divides n, then p must be prime
+rough∧∣⇒prime : .{{NonTrivial p}} → p Rough n → p ∣ n → Prime p
+rough∧∣⇒prime r p∣n = prime (rough∧∣⇒rough r p∣n)
+
+-- If a number n is m-rough, and m * m > n, then n must be prime.
+rough∧square>⇒prime : .{{NonTrivial n}} → m Rough n → m * m > n → Prime n
+rough∧square>⇒prime rough m*m>n = prime ¬composite
+  where
+    ¬composite : ¬ Composite _
+    ¬composite (composite d<n d∣n) = contradiction (m∣n⇒n≡quotient*m d∣n)
+      (<⇒≢ (<-≤-trans m*m>n (*-mono-≤
+        (rough⇒≤ (rough∧∣⇒rough rough (quotient-∣ d∣n)))
+        (rough⇒≤ (rough∧∣⇒rough rough d∣n)))))
+      where instance _ = n>1⇒nonTrivial (quotient>1 d∣n d<n)
+
+-- Relationship between compositeness and primality.
+composite⇒¬prime : Composite n → ¬ Prime n
+composite⇒¬prime composite[d] (prime p) = p composite[d]
+
+¬composite⇒prime : .{{NonTrivial n}} → ¬ Composite n → Prime n
+¬composite⇒prime = prime
+
+prime⇒¬composite : Prime n → ¬ Composite n
+prime⇒¬composite (prime p) = p
+
+-- Note that this has to recompute the factor!
+¬prime⇒composite : .{{NonTrivial n}} → ¬ Prime n → Composite n
+¬prime⇒composite {n} ¬prime[n] =
+  decidable-stable (composite? n) (¬prime[n] ∘′ ¬composite⇒prime)
+
+productOfPrimes≢0 : ∀ {as} → All Prime as → NonZero (product as)
+productOfPrimes≢0 pas = product≢0 (All.map prime⇒nonZero pas)
+  where
+  product≢0 : ∀ {ns} → All NonZero ns → NonZero (product ns)
+  product≢0 [] = _
+  product≢0 {n ∷ ns} (nzn ∷ nzns) = m*n≢0 n _ {{nzn}} {{product≢0 nzns}}
+
+productOfPrimes≥1 : ∀ {as} → All Prime as → product as ≥ 1
+productOfPrimes≥1 {as} pas = >-nonZero⁻¹ _ {{productOfPrimes≢0 pas}}
+
+------------------------------------------------------------------------
+-- Basic (counter-)examples of Irreducible
+
+¬irreducible[0] : ¬ Irreducible 0
+¬irreducible[0] irr[0] = contradiction₂ 2≡1⊎2≡0 (λ ()) (λ ())
+  where 2≡1⊎2≡0 = irr[0] {2} (divides-refl 0)
+
+irreducible[1] : Irreducible 1
+irreducible[1] m∣1 = inj₁ (∣1⇒≡1 m∣1)
+
+irreducible[2] : Irreducible 2
+irreducible[2] {zero}  0∣2 with () ← 0∣⇒≡0 0∣2
+irreducible[2] {suc _} d∣2 with ∣⇒≤ d∣2
+... | z<s     = inj₁ refl
+... | s<s z<s = inj₂ refl
+
+irreducible⇒nonZero : Irreducible n → NonZero n
+irreducible⇒nonZero {zero}    = flip contradiction ¬irreducible[0]
+irreducible⇒nonZero {suc _} _ = _
+
+irreducible? : Decidable Irreducible
+irreducible? zero      = no ¬irreducible[0]
+irreducible? n@(suc _) =
+  Dec.map IrreducibleUpTo⇔Irreducible (irreducibleUpTo? n)
+  where
+  -- Equivalent bounded predicate definition
+  IrreducibleUpTo : Pred ℕ _
+  IrreducibleUpTo n = ∀ {d} → d < n → d ∣ n → d ≡ 1 ⊎ d ≡ n
+
+  -- Proof of equivalence
+  irr-upto⇒irr : .{{NonZero n}} → IrreducibleUpTo n → Irreducible n
+  irr-upto⇒irr irr-upto m∣n
+    = [ flip irr-upto m∣n , inj₂ ]′ (m≤n⇒m<n∨m≡n (∣⇒≤ m∣n))
+
+  irr⇒irr-upto : Irreducible n → IrreducibleUpTo n
+  irr⇒irr-upto irr m<n m∣n = irr m∣n
+
+  IrreducibleUpTo⇔Irreducible : .{{NonZero n}} →
+                                 IrreducibleUpTo n ⇔ Irreducible n
+  IrreducibleUpTo⇔Irreducible = mk⇔ irr-upto⇒irr irr⇒irr-upto
+
+  -- Decidability
+  irreducibleUpTo? : Decidable IrreducibleUpTo
+  irreducibleUpTo? n = allUpTo?
+    (λ m → (m ∣? n) →-dec (m ≟ 1 ⊎-dec m ≟ n)) n
+
+-- Relationship between primality and irreducibility.
+prime⇒irreducible : Prime p → Irreducible p
+prime⇒irreducible {p} pp@(prime pr) = irr
+  where
+  instance _ = prime⇒nonZero pp
+  irr : .{{NonZero p}} → Irreducible p
+  irr {0}    0∣p = contradiction (0∣⇒≡0 0∣p) (≢-nonZero⁻¹ p)
+  irr {1}    1∣p = inj₁ refl
+  irr {2+ _} d∣p = inj₂ (≤∧≮⇒≡ (∣⇒≤ d∣p) d≮p)
+    where d≮p = λ d<p → pr (composite d<p d∣p)
+
+
+irreducible⇒prime : .{{NonTrivial p}} → Irreducible p → Prime p
+irreducible⇒prime irr = prime
+  λ (composite d<p d∣p) → [ nonTrivial⇒≢1 , (<⇒≢ d<p) ]′ (irr d∣p)
+
+------------------------------------------------------------------------
+-- Using decidability
+
+-- Once we have the above decision procedures, then instead of
+-- constructing proofs of e.g. Prime-ness by hand, we call the
+-- appropriate function, and use the witness extraction functions
+-- `from-yes`, `from-no` to return the checked proofs.
 
 private
 
-  -- Example: 2 is prime.
+  -- Example: 2 is prime, but not-composite.
   2-is-prime : Prime 2
   2-is-prime = from-yes (prime? 2)
 
+  2-is-not-composite : ¬ Composite 2
+  2-is-not-composite = from-no (composite? 2)
+
+  -- Example: 4 and 6 are composite, hence not-prime
+  4-is-composite : Composite 4
+  4-is-composite = from-yes (composite? 4)
+
+  4-is-not-prime : ¬ Prime 4
+  4-is-not-prime = from-no (prime? 4)
 
-  -- Example: 6 is composite
   6-is-composite : Composite 6
   6-is-composite = from-yes (composite? 6)
+
+  6-is-not-prime : ¬ Prime 6
+  6-is-not-prime = from-no (prime? 6)
diff --git a/src/Data/Nat/Primality/Factorisation.agda b/src/Data/Nat/Primality/Factorisation.agda
new file mode 100644
index 0000000000..4a91348a66
--- /dev/null
+++ b/src/Data/Nat/Primality/Factorisation.agda
@@ -0,0 +1,205 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Prime factorisation of natural numbers and its properties
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Nat.Primality.Factorisation where
+
+open import Data.Nat.Base
+open import Data.Nat.Divisibility
+  using (_∣?_; quotient; quotient>1; quotient-<; quotient-∣; m∣n⇒n≡m*quotient; _∣_; ∣1⇒≡1;
+        divides)
+open import Data.Nat.Properties
+open import Data.Nat.Induction using (<-Rec; <-rec; <-recBuilder)
+open import Data.Nat.Primality
+  using (Prime; _Rough_; rough∧square>⇒prime; ∤⇒rough-suc; rough∧∣⇒rough; rough∧∣⇒prime;
+         2-rough; euclidsLemma; prime⇒irreducible; ¬prime[1]; productOfPrimes≥1; prime⇒nonZero)
+open import Data.Product.Base using (∃-syntax; _×_; _,_; proj₁; proj₂)
+open import Data.List.Base using (List; []; _∷_; _++_; product)
+open import Data.List.Membership.Propositional using (_∈_)
+open import Data.List.Membership.Propositional.Properties using (∈-∃++)
+open import Data.List.Relation.Unary.All as All using (All; []; _∷_)
+open import Data.List.Relation.Unary.Any using (here; there)
+open import Data.List.Relation.Binary.Permutation.Propositional
+  using (_↭_; prep; swap; ↭-reflexive; ↭-refl; ↭-trans; refl; module PermutationReasoning)
+open import Data.List.Relation.Binary.Permutation.Propositional.Properties
+  using (product-↭; All-resp-↭; shift)
+open import Data.Sum.Base using (inj₁; inj₂)
+open import Function.Base using (_$_; _∘_; _|>_; flip)
+open import Induction using (build)
+open import Induction.Lexicographic using (_⊗_; [_⊗_])
+open import Relation.Nullary.Decidable using (yes; no)
+open import Relation.Nullary.Negation using (contradiction)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; sym; trans; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
+
+private
+  variable
+    n : ℕ
+
+------------------------------------------------------------------------
+-- Core definition
+
+record PrimeFactorisation (n : ℕ) : Set where
+  field
+    factors : List ℕ
+    isFactorisation : n ≡ product factors
+    factorsPrime : All Prime factors
+
+open PrimeFactorisation public using (factors)
+open PrimeFactorisation
+
+------------------------------------------------------------------------
+-- Finding a factorisation
+
+primeFactorisation[1] : PrimeFactorisation 1
+primeFactorisation[1] = record
+  { factors = []
+  ; isFactorisation = refl
+  ; factorsPrime = []
+  }
+
+primeFactorisation[p] : Prime n → PrimeFactorisation n
+primeFactorisation[p] {n} pr = record
+  { factors = n ∷ []
+  ; isFactorisation = sym (*-identityʳ n)
+  ; factorsPrime = pr ∷ []
+  }
+
+-- This builds up three important things:
+-- * a proof that every number we've gotten to so far has increasingly higher
+--   possible least prime factor, so we don't have to repeat smaller factors
+--   over and over (this is the "m" and "rough" parameters)
+-- * a witness that this limit is getting closer to the number of interest, in a
+--   way that helps the termination checker (the "k" and "eq" parameters)
+-- * a proof that we can factorise any smaller number, which is useful when we
+--   encounter a factor, as we can then divide by that factor and continue from
+--   there without termination issues
+factorise : ∀ n → .{{NonZero n}} → PrimeFactorisation n
+factorise 1 = primeFactorisation[1]
+factorise n₀@(2+ _) = build [ <-recBuilder ⊗ <-recBuilder ] P facRec (n₀ , suc n₀ ∸ 4) 2-rough refl
+  where
+  P : ℕ × ℕ → Set
+  P (n , k) = ∀ {m} → .{{NonTrivial n}} → .{{NonTrivial m}} → m Rough n → suc n ∸ m * m ≡ k → PrimeFactorisation n
+
+  facRec : ∀ n×k → (<-Rec ⊗ <-Rec) P n×k → P n×k
+  facRec (n , zero) _ rough eq =
+  -- Case 1: m * m > n, ∴ Prime n
+    primeFactorisation[p] (rough∧square>⇒prime rough (m∸n≡0⇒m≤n eq))
+  facRec (n@(2+ _) , suc k) (recFactor , recQuotient) {m@(2+ _)} rough eq with m ∣? n
+  -- Case 2: m ∤ n, try larger m, reducing k accordingly
+  ... | no m∤n = recFactor (≤-<-trans (m∸n≤m k (m + m)) (n<1+n k)) {suc m} (∤⇒rough-suc m∤n rough) $ begin
+    suc n ∸ (suc m + m * suc m)   ≡⟨ cong (λ # → suc n ∸ (suc m + #)) (*-suc m m) ⟩
+    suc n ∸ (suc m + (m + m * m)) ≡⟨ cong (suc n ∸_) (+-assoc (suc m) m (m * m)) ⟨
+    suc n ∸ (suc (m + m) + m * m) ≡⟨ cong (suc n ∸_) (+-comm (suc (m + m)) (m * m)) ⟩
+    suc n ∸ (m * m + suc (m + m)) ≡⟨ ∸-+-assoc (suc n) (m * m) (suc (m + m)) ⟨
+    (suc n ∸ m * m) ∸ suc (m + m) ≡⟨ cong (_∸ suc (m + m)) eq ⟩
+    suc k ∸ suc (m + m)           ∎
+    where open ≡-Reasoning
+  -- Case 3: m ∣ n, record m and recurse on the quotient
+  ... | yes m∣n = record
+    { factors = m ∷ ps
+    ; isFactorisation = sym m*Πps≡n
+    ; factorsPrime = rough∧∣⇒prime rough m∣n ∷ primes
+    }
+    where
+      m<n : m < n
+      m<n = begin-strict
+        m            <⟨ s≤s (≤-trans (m≤n+m m _) (+-monoʳ-≤ _ (m≤m+n m _))) ⟩
+        pred (m * m) <⟨ s<s⁻¹ (m∸n≢0⇒n<m λ eq′ → 0≢1+n (trans (sym eq′) eq)) ⟩
+        n            ∎
+        where open ≤-Reasoning
+
+      q = quotient m∣n
+
+      instance _  = n>1⇒nonTrivial (quotient>1 m∣n m<n)
+
+      factorisation[q] : PrimeFactorisation q
+      factorisation[q] = recQuotient (quotient-< m∣n) (suc q ∸ m * m) (rough∧∣⇒rough rough (quotient-∣ m∣n)) refl
+
+      ps = factors factorisation[q]
+
+      primes = factorsPrime factorisation[q]
+
+      m*Πps≡n : m * product ps ≡ n
+      m*Πps≡n = begin
+        m * product ps ≡⟨ cong (m *_) (isFactorisation factorisation[q]) ⟨
+        m * q          ≡⟨ m∣n⇒n≡m*quotient m∣n ⟨
+        n              ∎
+        where open ≡-Reasoning
+
+------------------------------------------------------------------------
+-- Properties of a factorisation
+
+factorisationHasAllPrimeFactors : ∀ {as} {p} → Prime p → p ∣ product as → All Prime as → p ∈ as
+factorisationHasAllPrimeFactors {[]} {2+ p} pPrime p∣Πas [] = contradiction (∣1⇒≡1 p∣Πas) λ ()
+factorisationHasAllPrimeFactors {a ∷ as} {p} pPrime p∣aΠas (aPrime ∷ asPrime) with euclidsLemma a (product as) pPrime p∣aΠas
+... | inj₂ p∣Πas = there (factorisationHasAllPrimeFactors pPrime p∣Πas asPrime)
+... | inj₁ p∣a with prime⇒irreducible aPrime p∣a
+...   | inj₁ refl = contradiction pPrime ¬prime[1]
+...   | inj₂ refl = here refl
+
+private
+  factorisationUnique′ : (as bs : List ℕ) → product as ≡ product bs → All Prime as → All Prime bs → as ↭ bs
+  factorisationUnique′ [] [] Πas≡Πbs asPrime bsPrime = refl
+  factorisationUnique′ [] (b@(2+ _) ∷ bs) Πas≡Πbs prime[as] (_ ∷ prime[bs]) =
+    contradiction Πas≡Πbs (<⇒≢ Πas<Πbs)
+    where
+      Πas<Πbs : product [] < product (b ∷ bs)
+      Πas<Πbs = begin-strict
+        1                ≡⟨⟩
+        1 * 1            <⟨ *-monoˡ-< 1 {1} {b} sz<ss ⟩
+        b * 1            ≤⟨ *-monoʳ-≤ b (productOfPrimes≥1 prime[bs]) ⟩
+        b * product bs   ≡⟨⟩
+        product (b ∷ bs) ∎
+        where open ≤-Reasoning
+
+  factorisationUnique′ (a ∷ as) bs Πas≡Πbs (prime[a] ∷ prime[as]) prime[bs] = a∷as↭bs
+    where
+      a∣Πbs : a ∣ product bs
+      a∣Πbs = divides (product as) $ begin
+        product bs       ≡⟨ Πas≡Πbs ⟨
+        product (a ∷ as) ≡⟨⟩
+        a * product as   ≡⟨ *-comm a (product as) ⟩
+        product as * a   ∎
+        where open ≡-Reasoning
+
+      shuffle : ∃[ bs′ ] bs ↭ a ∷ bs′
+      shuffle with ys , zs , p ← ∈-∃++ (factorisationHasAllPrimeFactors prime[a] a∣Πbs prime[bs])
+        = ys ++ zs , ↭-trans (↭-reflexive p) (shift a ys zs)
+
+      bs′ = proj₁ shuffle
+      bs↭a∷bs′ = proj₂ shuffle
+
+      Πas≡Πbs′ : product as ≡ product bs′
+      Πas≡Πbs′ = *-cancelˡ-≡ (product as) (product bs′) a {{prime⇒nonZero prime[a]}} $ begin
+        a * product as  ≡⟨ Πas≡Πbs ⟩
+        product bs      ≡⟨ product-↭ bs↭a∷bs′ ⟩
+        a * product bs′ ∎
+        where open ≡-Reasoning
+
+      prime[bs'] : All Prime bs′
+      prime[bs'] = All.tail (All-resp-↭ bs↭a∷bs′ prime[bs])
+
+      a∷as↭bs : a ∷ as ↭ bs
+      a∷as↭bs = begin
+        a ∷ as  <⟨ factorisationUnique′ as bs′ Πas≡Πbs′ prime[as] prime[bs'] ⟩
+        a ∷ bs′ ↭⟨ bs↭a∷bs′ ⟨
+        bs      ∎
+        where open PermutationReasoning
+
+factorisationUnique : (f f′ : PrimeFactorisation n) → factors f ↭ factors f′
+factorisationUnique {n} f f′ =
+  factorisationUnique′ (factors f) (factors f′) Πf≡Πf′ (factorsPrime f) (factorsPrime f′)
+  where
+    Πf≡Πf′ : product (factors f) ≡ product (factors f′)
+    Πf≡Πf′ = begin
+      product (factors f)  ≡⟨ isFactorisation f ⟨
+      n                    ≡⟨ isFactorisation f′ ⟩
+      product (factors f′) ∎
+      where open ≡-Reasoning
diff --git a/src/Data/Nat/Properties.agda b/src/Data/Nat/Properties.agda
index 0426d94d14..21ea925467 100644
--- a/src/Data/Nat/Properties.agda
+++ b/src/Data/Nat/Properties.agda
@@ -11,32 +11,39 @@
 
 module Data.Nat.Properties where
 
-open import Axiom.UniquenessOfIdentityProofs
-open import Algebra.Bundles
+open import Axiom.UniquenessOfIdentityProofs using (module Decidable⇒UIP)
+open import Algebra.Bundles using (Magma; Semigroup; CommutativeSemigroup;
+  CommutativeMonoid; Monoid; Semiring; CommutativeSemiring; CommutativeSemiringWithoutOne)
+open import Algebra.Definitions.RawMagma using (_,_)
 open import Algebra.Morphism
 open import Algebra.Consequences.Propositional
+  using (comm+cancelˡ⇒cancelʳ; comm∧distrʳ⇒distrˡ; comm∧distrˡ⇒distrʳ)
 open import Algebra.Construct.NaturalChoice.Base
+  using (MinOperator; MaxOperator)
 import Algebra.Construct.NaturalChoice.MinMaxOp as MinMaxOp
 import Algebra.Lattice.Construct.NaturalChoice.MinMaxOp as LatticeMinMaxOp
 import Algebra.Properties.CommutativeSemigroup as CommSemigroupProperties
 open import Data.Bool.Base using (Bool; false; true; T)
 open import Data.Bool.Properties using (T?)
-open import Data.Empty using (⊥)
 open import Data.Nat.Base
-open import Data.Product using (∄; ∃; _×_; _,_)
-open import Data.Sum.Base as Sum
-open import Data.Unit using (tt)
-open import Function.Base
+open import Data.Product.Base using (∃; _×_; _,_)
+open import Data.Sum.Base as Sum using (inj₁; inj₂; _⊎_; [_,_]′)
+open import Data.Unit.Base using (tt)
+open import Function.Base using (_∘_; flip; _$_; id; _∘′_; _$′_)
 open import Function.Bundles using (_↣_)
-open import Function.Metric.Nat
+open import Function.Metric.Nat using (TriangleInequality; IsProtoMetric; IsPreMetric;
+  IsQuasiSemiMetric; IsSemiMetric; IsMetric; PreMetric; QuasiSemiMetric;
+  SemiMetric; Metric)
 open import Level using (0ℓ)
 open import Relation.Unary as U using (Pred)
+open import Relation.Binary.Core
+  using (_⇒_; _Preserves_⟶_; _Preserves₂_⟶_⟶_)
 open import Relation.Binary
 open import Relation.Binary.Consequences using (flip-Connex)
 open import Relation.Binary.PropositionalEquality
 open import Relation.Nullary hiding (Irrelevant)
-open import Relation.Nullary.Decidable using (True; via-injection; map′)
-open import Relation.Nullary.Negation using (contradiction; contradiction₂)
+open import Relation.Nullary.Decidable using (True; via-injection; map′; recompute)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
 open import Relation.Nullary.Reflects using (fromEquivalence)
 
 open import Algebra.Definitions {A = ℕ} _≡_
@@ -45,6 +52,12 @@ open import Algebra.Definitions
   using (LeftCancellative; RightCancellative; Cancellative)
 open import Algebra.Structures {A = ℕ} _≡_
 
+
+private
+  variable
+    m n o k : ℕ
+
+
 ------------------------------------------------------------------------
 -- Properties of NonZero
 ------------------------------------------------------------------------
@@ -53,12 +66,21 @@ nonZero? : U.Decidable NonZero
 nonZero? zero    = no NonZero.nonZero
 nonZero? (suc n) = yes _
 
+------------------------------------------------------------------------
+-- Properties of NonTrivial
+------------------------------------------------------------------------
+
+nonTrivial? : U.Decidable NonTrivial
+nonTrivial? 0      = no λ()
+nonTrivial? 1      = no λ()
+nonTrivial? (2+ n) = yes _
+
 ------------------------------------------------------------------------
 -- Properties of _≡_
 ------------------------------------------------------------------------
 
-suc-injective : ∀ {m n} → suc m ≡ suc n → m ≡ n
-suc-injective refl = refl
+suc-injective : suc m ≡ suc n → m ≡ n
+suc-injective = cong pred
 
 ≡ᵇ⇒≡ : ∀ m n → T (m ≡ᵇ n) → m ≡ n
 ≡ᵇ⇒≡ zero    zero    _  = refl
@@ -81,7 +103,7 @@ m ≟ n = map′ (≡ᵇ⇒≡ m n) (≡⇒≡ᵇ m n) (T? (m ≡ᵇ n))
 ≡-irrelevant : Irrelevant {A = ℕ} _≡_
 ≡-irrelevant = Decidable⇒UIP.≡-irrelevant _≟_
 
-≟-diag : ∀ {m n} (eq : m ≡ n) → (m ≟ n) ≡ yes eq
+≟-diag : (eq : m ≡ n) → (m ≟ n) ≡ yes eq
 ≟-diag = ≡-≟-identity _≟_
 
 ≡-isDecEquivalence : IsDecEquivalence (_≡_ {A = ℕ})
@@ -97,13 +119,13 @@ m ≟ n = map′ (≡ᵇ⇒≡ m n) (≡⇒≡ᵇ m n) (T? (m ≡ᵇ n))
   ; isDecEquivalence = ≡-isDecEquivalence
   }
 
-0≢1+n : ∀ {n} → 0 ≢ suc n
+0≢1+n : 0 ≢ suc n
 0≢1+n ()
 
-1+n≢0 : ∀ {n} → suc n ≢ 0
+1+n≢0 : suc n ≢ 0
 1+n≢0 ()
 
-1+n≢n : ∀ {n} → suc n ≢ n
+1+n≢n : suc n ≢ n
 1+n≢n {suc n} = 1+n≢n ∘ suc-injective
 
 ------------------------------------------------------------------------
@@ -114,7 +136,7 @@ m ≟ n = map′ (≡ᵇ⇒≡ m n) (≡⇒≡ᵇ m n) (T? (m ≡ᵇ n))
 <ᵇ⇒< zero    (suc n) m<n = z<s
 <ᵇ⇒< (suc m) (suc n) m<n = s<s (<ᵇ⇒< m n m<n)
 
-<⇒<ᵇ : ∀ {m n} → m < n → T (m <ᵇ n)
+<⇒<ᵇ : m < n → T (m <ᵇ n)
 <⇒<ᵇ z<s               = tt
 <⇒<ᵇ (s<s m<n@(s≤s _)) = <⇒<ᵇ m<n
 
@@ -129,7 +151,7 @@ m ≟ n = map′ (≡ᵇ⇒≡ m n) (≡⇒≡ᵇ m n) (T? (m ≡ᵇ n))
 ≤ᵇ⇒≤ zero    n m≤n = z≤n
 ≤ᵇ⇒≤ (suc m) n m≤n = <ᵇ⇒< m n m≤n
 
-≤⇒≤ᵇ : ∀ {m n} → m ≤ n → T (m ≤ᵇ n)
+≤⇒≤ᵇ : m ≤ n → T (m ≤ᵇ n)
 ≤⇒≤ᵇ z≤n         = tt
 ≤⇒≤ᵇ m≤n@(s≤s _) = <⇒<ᵇ m≤n
 
@@ -161,9 +183,7 @@ m ≟ n = map′ (≡ᵇ⇒≡ m n) (≡⇒≡ᵇ m n) (T? (m ≡ᵇ n))
 ≤-total : Total _≤_
 ≤-total zero    _       = inj₁ z≤n
 ≤-total _       zero    = inj₂ z≤n
-≤-total (suc m) (suc n) with ≤-total m n
-... | inj₁ m≤n = inj₁ (s≤s m≤n)
-... | inj₂ n≤m = inj₂ (s≤s n≤m)
+≤-total (suc m) (suc n) = Sum.map s≤s s≤s (≤-total m n)
 
 ≤-irrelevant : Irrelevant _≤_
 ≤-irrelevant z≤n        z≤n        = refl
@@ -249,26 +269,26 @@ _≥?_ = flip _≤?_
 ------------------------------------------------------------------------
 -- Other properties of _≤_
 
-s≤s-injective : ∀ {m n} {p q : m ≤ n} → s≤s p ≡ s≤s q → p ≡ q
+s≤s-injective : {p q : m ≤ n} → s≤s p ≡ s≤s q → p ≡ q
 s≤s-injective refl = refl
 
-≤-pred : ∀ {m n} → suc m ≤ suc n → m ≤ n
-≤-pred (s≤s m≤n) = m≤n
+≤-pred : suc m ≤ suc n → m ≤ n
+≤-pred = s≤s⁻¹
 
-m≤n⇒m≤1+n : ∀ {m n} → m ≤ n → m ≤ 1 + n
+m≤n⇒m≤1+n : m ≤ n → m ≤ 1 + n
 m≤n⇒m≤1+n z≤n       = z≤n
 m≤n⇒m≤1+n (s≤s m≤n) = s≤s (m≤n⇒m≤1+n m≤n)
 
 n≤1+n : ∀ n → n ≤ 1 + n
 n≤1+n _ = m≤n⇒m≤1+n ≤-refl
 
-1+n≰n : ∀ {n} → 1 + n ≰ n
+1+n≰n : 1 + n ≰ n
 1+n≰n (s≤s 1+n≤n) = 1+n≰n 1+n≤n
 
-n≤0⇒n≡0 : ∀ {n} → n ≤ 0 → n ≡ 0
+n≤0⇒n≡0 : n ≤ 0 → n ≡ 0
 n≤0⇒n≡0 z≤n = refl
 
-n≤1⇒n≡0∨n≡1 : ∀ {n : ℕ} → n ≤ 1 → n ≡ 0 ⊎ n ≡ 1
+n≤1⇒n≡0∨n≡1 : n ≤ 1 → n ≡ 0 ⊎ n ≡ 1
 n≤1⇒n≡0∨n≡1 z≤n       = inj₁ refl
 n≤1⇒n≡0∨n≡1 (s≤s z≤n) = inj₂ refl
 
@@ -348,11 +368,11 @@ n≤1⇒n≡0∨n≡1 (s≤s z≤n) = inj₂ refl
 <-trans : Transitive _<_
 <-trans (s≤s i≤j) (s≤s j<k) = s≤s (≤-trans i≤j (≤-trans (n≤1+n _) j<k))
 
-<-transʳ : Trans _≤_ _<_ _<_
-<-transʳ m≤n (s<s n≤o) = s≤s (≤-trans m≤n n≤o)
+≤-<-trans : LeftTrans _≤_ _<_
+≤-<-trans m≤n (s<s n≤o) = s≤s (≤-trans m≤n n≤o)
 
-<-transˡ : Trans _<_ _≤_ _<_
-<-transˡ (s<s m≤n) (s≤s n≤o) = s≤s (≤-trans m≤n n≤o)
+<-≤-trans : RightTrans _<_ _≤_
+<-≤-trans (s<s m≤n) (s≤s n≤o) = s≤s (≤-trans m≤n n≤o)
 
 -- NB: we use the builtin function `_<ᵇ_` here so that the function
 -- quickly decides which constructor to return. It still takes a
@@ -392,7 +412,7 @@ _>?_ = flip _<?_
   }
 
 <-isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_
-<-isStrictTotalOrder = record
+<-isStrictTotalOrder = isStrictTotalOrderᶜ record
   { isEquivalence = isEquivalence
   ; trans         = <-trans
   ; compare       = <-cmp
@@ -411,58 +431,56 @@ _>?_ = flip _<?_
 ------------------------------------------------------------------------
 -- Other properties of _<_
 
-s<s-injective : ∀ {m n} {p q : m < n} → s<s p ≡ s<s q → p ≡ q
+s<s-injective : {p q : m < n} → s<s p ≡ s<s q → p ≡ q
 s<s-injective refl = refl
 
-<-pred : ∀ {m n} → suc m < suc n → m < n
-<-pred (s<s m<n) = m<n
+<-pred : suc m < suc n → m < n
+<-pred = s<s⁻¹
 
-m<n⇒m<1+n : ∀ {m n} → m < n → m < 1 + n
+m<n⇒m<1+n : m < n → m < 1 + n
 m<n⇒m<1+n z<s               = z<s
 m<n⇒m<1+n (s<s m<n@(s≤s _)) = s<s (m<n⇒m<1+n m<n)
 
-n≮0 : ∀ {n} → n ≮ 0
+n≮0 : n ≮ 0
 n≮0 ()
 
-n≮n : ∀ n → n ≮ n
+n≮n : ∀ n → n ≮ n -- implicit?
 n≮n n = <-irrefl (refl {x = n})
 
-0<1+n : ∀ {n} → 0 < suc n
+0<1+n : 0 < suc n
 0<1+n = z<s
 
 n<1+n : ∀ n → n < suc n
 n<1+n n = ≤-refl
 
-n<1⇒n≡0 : ∀ {n} → n < 1 → n ≡ 0
+n<1⇒n≡0 : n < 1 → n ≡ 0
 n<1⇒n≡0 (s≤s n≤0) = n≤0⇒n≡0 n≤0
 
-n>0⇒n≢0 : ∀ {n} → n > 0 → n ≢ 0
+n>0⇒n≢0 : n > 0 → n ≢ 0
 n>0⇒n≢0 {suc n} _ ()
 
-n≢0⇒n>0 : ∀ {n} → n ≢ 0 → n > 0
+n≢0⇒n>0 : n ≢ 0 → n > 0
 n≢0⇒n>0 {zero}  0≢0 =  contradiction refl 0≢0
 n≢0⇒n>0 {suc n} _   =  0<1+n
 
-m<n⇒0<n : ∀ {m n} → m < n → 0 < n
+m<n⇒0<n : m < n → 0 < n
 m<n⇒0<n = ≤-trans 0<1+n
 
-m<n⇒n≢0 : ∀ {m n} → m < n → n ≢ 0
+m<n⇒n≢0 : m < n → n ≢ 0
 m<n⇒n≢0 (s≤s m≤n) ()
 
-m<n⇒m≤1+n : ∀ {m n} → m < n → m ≤ suc n
+m<n⇒m≤1+n : m < n → m ≤ suc n
 m<n⇒m≤1+n = m≤n⇒m≤1+n ∘ <⇒≤
 
 m<1+n⇒m<n∨m≡n :  ∀ {m n} → m < suc n → m < n ⊎ m ≡ n
-m<1+n⇒m<n∨m≡n {0}     {0}     _          =  inj₂ refl
-m<1+n⇒m<n∨m≡n {0}     {suc n} _          =  inj₁ 0<1+n
-m<1+n⇒m<n∨m≡n {suc m} {suc n} (s<s m<1+n)  with m<1+n⇒m<n∨m≡n m<1+n
-... | inj₂ m≡n = inj₂ (cong suc m≡n)
-... | inj₁ m<n = inj₁ (s<s m<n)
+m<1+n⇒m<n∨m≡n {0}     {0}     _           = inj₂ refl
+m<1+n⇒m<n∨m≡n {0}     {suc n} _           = inj₁ 0<1+n
+m<1+n⇒m<n∨m≡n {suc m} {suc n} (s<s m<1+n) = Sum.map s<s (cong suc) (m<1+n⇒m<n∨m≡n m<1+n)
 
-m≤n⇒m<n∨m≡n :  ∀ {m n} → m ≤ n → m < n ⊎ m ≡ n
+m≤n⇒m<n∨m≡n : m ≤ n → m < n ⊎ m ≡ n
 m≤n⇒m<n∨m≡n m≤n = m<1+n⇒m<n∨m≡n (s≤s m≤n)
 
-m<1+n⇒m≤n : ∀ {m n} → m < suc n → m ≤ n
+m<1+n⇒m≤n : m < suc n → m ≤ n
 m<1+n⇒m≤n (s≤s m≤n) = m≤n
 
 ∀[m≤n⇒m≢o]⇒n<o : ∀ n o → (∀ {m} → m ≤ n → m ≢ o) → n < o
@@ -479,7 +497,7 @@ m<1+n⇒m≤n (s≤s m≤n) = m≤n
 ∀[m<n⇒m≢o]⇒n≤o (suc n) (suc o) m<n⇒m≢o = s≤s (∀[m<n⇒m≢o]⇒n≤o n o rec)
   where
   rec : ∀ {m} → m < n → m ≢ o
-  rec x<m refl = m<n⇒m≢o (s≤s x<m) refl
+  rec o<n refl = m<n⇒m≢o (s<s o<n) refl
 
 ------------------------------------------------------------------------
 -- A module for reasoning about the _≤_ and _<_ relations
@@ -488,13 +506,14 @@ m<1+n⇒m≤n (s≤s m≤n) = m≤n
 module ≤-Reasoning where
   open import Relation.Binary.Reasoning.Base.Triple
     ≤-isPreorder
+    <-asym
     <-trans
     (resp₂ _<_)
     <⇒≤
-    <-transˡ
-    <-transʳ
+    <-≤-trans
+    ≤-<-trans
     public
-    hiding (step-≈; step-≈˘)
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨)
 
 open ≤-Reasoning
 
@@ -653,11 +672,11 @@ m+n≡0⇒n≡0 m {n} m+n≡0 = m+n≡0⇒m≡0 n (trans (+-comm n m) (m+n≡0))
 +-cancel-< : Cancellative _<_ _+_
 +-cancel-< = +-cancelˡ-< , +-cancelʳ-<
 
-m≤n⇒m≤o+n : ∀ {m n} o → m ≤ n → m ≤ o + n
+m≤n⇒m≤o+n : ∀ o → m ≤ n → m ≤ o + n
 m≤n⇒m≤o+n zero    m≤n = m≤n
 m≤n⇒m≤o+n (suc o) m≤n = m≤n⇒m≤1+n (m≤n⇒m≤o+n o m≤n)
 
-m≤n⇒m≤n+o : ∀ {m n} o → m ≤ n → m ≤ n + o
+m≤n⇒m≤n+o : ∀ o → m ≤ n → m ≤ n + o
 m≤n⇒m≤n+o {m} o m≤n = subst (m ≤_) (+-comm o _) (m≤n⇒m≤o+n o m≤n)
 
 m≤m+n : ∀ m n → m ≤ m + n
@@ -704,7 +723,7 @@ m+n≤o⇒n≤o (suc m) m+n<o = m+n≤o⇒n≤o m (<⇒≤ m+n<o)
 +-monoʳ-< (suc n) m≤o = s≤s (+-monoʳ-< n m≤o)
 
 m+1+n≰m : ∀ m {n} → m + suc n ≰ m
-m+1+n≰m (suc m) (s≤s m+1+n≤m) = m+1+n≰m m m+1+n≤m
+m+1+n≰m (suc m) m+1+n≤m = m+1+n≰m m (s≤s⁻¹ m+1+n≤m)
 
 m<m+n : ∀ m {n} → n > 0 → m < m + n
 m<m+n zero    n>0 = n>0
@@ -714,8 +733,8 @@ m<n+m : ∀ m {n} → n > 0 → m < n + m
 m<n+m m {n} n>0 rewrite +-comm n m = m<m+n m n>0
 
 m+n≮n : ∀ m n → m + n ≮ n
-m+n≮n zero    n                   = n≮n n
-m+n≮n (suc m) (suc n) (s<s m+n<n) = m+n≮n m (suc n) (m<n⇒m<1+n m+n<n)
+m+n≮n zero    n                = n≮n n
+m+n≮n (suc m) n@(suc _) sm+n<n = m+n≮n m n (m<n⇒m<1+n (s<s⁻¹ sm+n<n))
 
 m+n≮m : ∀ m n → m + n ≮ m
 m+n≮m m n = subst (_≮ m) (+-comm n m) (m+n≮n n m)
@@ -777,7 +796,7 @@ m+n≮m m n = subst (_≮ m) (+-comm n m) (m+n≮n n m)
   suc n * m + o * m   ∎
 
 *-distribˡ-+ : _*_ DistributesOverˡ _+_
-*-distribˡ-+ = comm+distrʳ⇒distrˡ *-comm *-distribʳ-+
+*-distribˡ-+ = comm∧distrʳ⇒distrˡ *-comm *-distribʳ-+
 
 *-distrib-+ : _*_ DistributesOver _+_
 *-distrib-+ = *-distribˡ-+ , *-distribʳ-+
@@ -895,9 +914,15 @@ m*n≡0⇒m≡0∨n≡0 : ∀ m {n} → m * n ≡ 0 → m ≡ 0 ⊎ n ≡ 0
 m*n≡0⇒m≡0∨n≡0 zero    {n}     eq = inj₁ refl
 m*n≡0⇒m≡0∨n≡0 (suc m) {zero}  eq = inj₂ refl
 
-m*n≢0 : ∀ m n → .{{_ : NonZero m}} .{{_ : NonZero n}} → NonZero (m * n)
+m*n≢0 : ∀ m n .{{_ : NonZero m}} .{{_ : NonZero n}} → NonZero (m * n)
 m*n≢0 (suc m) (suc n) = _
 
+m*n≢0⇒m≢0 : ∀ m {n} → .{{NonZero (m * n)}} → NonZero m
+m*n≢0⇒m≢0 (suc _) = _
+
+m*n≢0⇒n≢0 : ∀ m {n} → .{{NonZero (m * n)}} → NonZero n
+m*n≢0⇒n≢0 m {n} rewrite *-comm m n = m*n≢0⇒m≢0 n {m}
+
 m*n≡0⇒m≡0 : ∀ m n .{{_ : NonZero n}} → m * n ≡ 0 → m ≡ 0
 m*n≡0⇒m≡0 zero (suc _) eq = refl
 
@@ -914,19 +939,25 @@ m*n≡1⇒n≡1 m n eq = m*n≡1⇒m≡1 n m (trans (*-comm n m) eq)
 [m*n]*[o*p]≡[m*o]*[n*p] m n o p = begin-equality
   (m * n) * (o * p) ≡⟨  *-assoc m n (o * p) ⟩
   m * (n * (o * p)) ≡⟨  cong (m *_) (x∙yz≈y∙xz n o p) ⟩
-  m * (o * (n * p)) ≡˘⟨ *-assoc m o (n * p) ⟩
+  m * (o * (n * p)) ≡⟨ *-assoc m o (n * p) ⟨
   (m * o) * (n * p) ∎
   where open CommSemigroupProperties *-commutativeSemigroup
 
+m≢0∧n>1⇒m*n>1 : ∀ m n .{{_ : NonZero m}} .{{_ : NonTrivial n}} → NonTrivial (m * n)
+m≢0∧n>1⇒m*n>1 (suc m) (2+ n) = _
+
+n≢0∧m>1⇒m*n>1 : ∀ m n .{{_ : NonZero n}} .{{_ : NonTrivial m}} → NonTrivial (m * n)
+n≢0∧m>1⇒m*n>1 m n rewrite *-comm m n = m≢0∧n>1⇒m*n>1 n m
+
 ------------------------------------------------------------------------
 -- Other properties of _*_ and _≤_/_<_
 
 *-cancelʳ-≤ : ∀ m n o .{{_ : NonZero o}} → m * o ≤ n * o → m ≤ n
-*-cancelʳ-≤ zero    _       (suc o) _  = z≤n
-*-cancelʳ-≤ (suc m) (suc n) (suc o) le =
-  s≤s (*-cancelʳ-≤ m n (suc o) (+-cancelˡ-≤ _ _ _ le))
+*-cancelʳ-≤ zero    _       _         _  = z≤n
+*-cancelʳ-≤ (suc m) (suc n) o@(suc _) le =
+  s≤s (*-cancelʳ-≤ m n o (+-cancelˡ-≤ _ _ _ le))
 
-*-cancelˡ-≤ : ∀ {m n} o .{{_ : NonZero o}} → o * m ≤ o * n → m ≤ n
+*-cancelˡ-≤ : ∀ o .{{_ : NonZero o}} → o * m ≤ o * n → m ≤ n
 *-cancelˡ-≤ {m} {n} o rewrite *-comm o m | *-comm o n = *-cancelʳ-≤ m n o
 
 *-mono-≤ : _*_ Preserves₂ _≤_ ⟶ _≤_ ⟶ _≤_
@@ -944,14 +975,12 @@ m*n≡1⇒n≡1 m n eq = m*n≡1⇒m≡1 n m (trans (*-comm n m) eq)
 *-mono-< (s<s m<n@(s≤s _)) u<v@(s≤s _) = +-mono-< u<v (*-mono-< m<n u<v)
 
 *-monoˡ-< : ∀ n .{{_ : NonZero n}} → (_* n) Preserves _<_ ⟶ _<_
-*-monoˡ-< (suc n) z<s       = 0<1+n
-*-monoˡ-< (suc n) (s<s m<o@(s≤s _)) =
-  +-mono-≤-< (≤-refl {suc n}) (*-monoˡ-< (suc n) m<o)
+*-monoˡ-< n@(suc _) z<s               = 0<1+n
+*-monoˡ-< n@(suc _) (s<s m<o@(s≤s _)) = +-mono-≤-< ≤-refl (*-monoˡ-< n m<o)
 
 *-monoʳ-< : ∀ n .{{_ : NonZero n}} → (n *_) Preserves _<_ ⟶ _<_
 *-monoʳ-< (suc zero)      m<o@(s≤s _) = +-mono-≤ m<o z≤n
-*-monoʳ-< (suc n@(suc _)) m<o@(s≤s _) =
-  +-mono-≤ m<o (<⇒≤ (*-monoʳ-< n m<o))
+*-monoʳ-< (suc n@(suc _)) m<o@(s≤s _) = +-mono-≤ m<o (<⇒≤ (*-monoʳ-< n m<o))
 
 m≤m*n : ∀ m n .{{_ : NonZero n}} → m ≤ m * n
 m≤m*n m n@(suc _) = begin
@@ -972,8 +1001,8 @@ m<m*n m@(suc m-1) n@(suc (suc n-2)) (s≤s (s≤s _)) = begin-strict
   n + m-1 * n ≡⟨⟩
   m * n       ∎
 
-m<n⇒m<n*o : ∀ {m n} o .{{_ : NonZero o}} → m < n → m < n * o
-m<n⇒m<n*o {m} {n} o m<n = <-transˡ m<n (m≤m*n n o)
+m<n⇒m<n*o : ∀ o .{{_ : NonZero o}} → m < n → m < n * o
+m<n⇒m<n*o {n = n} o m<n = <-≤-trans m<n (m≤m*n n o)
 
 m<n⇒m<o*n : ∀ {m n} o .{{_ : NonZero o}} → m < n → m < o * n
 m<n⇒m<o*n {m} {n} o m<n = begin-strict
@@ -1046,29 +1075,44 @@ m^n≡1⇒n≡0∨m≡1 m (suc n) eq = inj₂ (m*n≡1⇒m≡1 m (m ^ n) eq)
 m^n≢0 : ∀ m n .{{_ : NonZero m}} → NonZero (m ^ n)
 m^n≢0 m n = ≢-nonZero (≢-nonZero⁻¹ m ∘′ m^n≡0⇒m≡0 m n)
 
-2^n>0 : ∀ (n : ℕ) → 2 ^ n > 0
-2^n>0 zero = z<s
-2^n>0 (suc n) = ≤-trans (2^n>0 n) (m≤m+n (2 ^ n) ((2 ^ n) + zero))
+m^n>0 : ∀ m .{{_ : NonZero m}} n → m ^ n > 0
+m^n>0 m n = >-nonZero⁻¹ (m ^ n) {{m^n≢0 m n}}
+
+^-monoˡ-≤ : ∀ n → (_^ n) Preserves _≤_ ⟶ _≤_
+^-monoˡ-≤ zero m≤o = s≤s z≤n
+^-monoˡ-≤ (suc n) m≤o = *-mono-≤ m≤o (^-monoˡ-≤ n m≤o)
+
+^-monoʳ-≤ : ∀ m .{{_ : NonZero m}} → (m ^_) Preserves _≤_ ⟶ _≤_
+^-monoʳ-≤ m {_} {o} z≤n = n≢0⇒n>0 (≢-nonZero⁻¹ (m ^ o) {{m^n≢0 m o}})
+^-monoʳ-≤ m (s≤s n≤o) = *-monoʳ-≤ m (^-monoʳ-≤ m n≤o)
+
+^-monoˡ-< : ∀ n .{{_ : NonZero n}} → (_^ n) Preserves _<_ ⟶ _<_
+^-monoˡ-< (suc zero)      m<o = *-monoˡ-< 1 m<o
+^-monoˡ-< (suc n@(suc _)) m<o = *-mono-< m<o (^-monoˡ-< n m<o)
+
+^-monoʳ-< : ∀ m → 1 < m → (m ^_) Preserves _<_ ⟶ _<_
+^-monoʳ-< m@(suc _) 1<m {zero}  {suc o} z<s       = *-mono-≤ 1<m (m^n>0 m o)
+^-monoʳ-< m@(suc _) 1<m {suc n} {suc o} (s<s n<o) = *-monoʳ-< m (^-monoʳ-< m 1<m n<o)
 
 ------------------------------------------------------------------------
 -- Properties of _⊓_ and _⊔_
 ------------------------------------------------------------------------
 -- Basic specification in terms of _≤_
 
-m≤n⇒m⊔n≡n : ∀ {m n} → m ≤ n → m ⊔ n ≡ n
+m≤n⇒m⊔n≡n : m ≤ n → m ⊔ n ≡ n
 m≤n⇒m⊔n≡n {zero}  _         = refl
 m≤n⇒m⊔n≡n {suc m} (s≤s m≤n) = cong suc (m≤n⇒m⊔n≡n m≤n)
 
-m≥n⇒m⊔n≡m : ∀ {m n} → m ≥ n → m ⊔ n ≡ m
+m≥n⇒m⊔n≡m : m ≥ n → m ⊔ n ≡ m
 m≥n⇒m⊔n≡m {zero}  {zero}  z≤n       = refl
 m≥n⇒m⊔n≡m {suc m} {zero}  z≤n       = refl
 m≥n⇒m⊔n≡m {suc m} {suc n} (s≤s m≥n) = cong suc (m≥n⇒m⊔n≡m m≥n)
 
-m≤n⇒m⊓n≡m : ∀ {m n} → m ≤ n → m ⊓ n ≡ m
+m≤n⇒m⊓n≡m : m ≤ n → m ⊓ n ≡ m
 m≤n⇒m⊓n≡m {zero}  z≤n       = refl
 m≤n⇒m⊓n≡m {suc m} (s≤s m≤n) = cong suc (m≤n⇒m⊓n≡m m≤n)
 
-m≥n⇒m⊓n≡n : ∀ {m n} → m ≥ n → m ⊓ n ≡ n
+m≥n⇒m⊓n≡n : m ≥ n → m ⊓ n ≡ n
 m≥n⇒m⊓n≡n {zero}  {zero}  z≤n       = refl
 m≥n⇒m⊓n≡n {suc m} {zero}  z≤n       = refl
 m≥n⇒m⊓n≡n {suc m} {suc n} (s≤s m≤n) = cong suc (m≥n⇒m⊓n≡n m≤n)
@@ -1263,23 +1307,23 @@ antimono-≤-distrib-⊔ : ∀ {f} → f Preserves _≤_ ⟶ _≥_ →
                        ∀ m n → f (m ⊔ n) ≡ f m ⊓ f n
 antimono-≤-distrib-⊔ {f} = ⊓-⊔-properties.antimono-≤-distrib-⊔ (cong f)
 
-m<n⇒m<n⊔o : ∀ {m n} o → m < n → m < n ⊔ o
+m<n⇒m<n⊔o : ∀ o → m < n → m < n ⊔ o
 m<n⇒m<n⊔o = m≤n⇒m≤n⊔o
 
-m<n⇒m<o⊔n : ∀ {m n} o → m < n → m < o ⊔ n
+m<n⇒m<o⊔n : ∀ o → m < n → m < o ⊔ n
 m<n⇒m<o⊔n = m≤n⇒m≤o⊔n
 
 m⊔n<o⇒m<o : ∀ m n {o} → m ⊔ n < o → m < o
-m⊔n<o⇒m<o m n m⊔n<o = <-transʳ (m≤m⊔n m n) m⊔n<o
+m⊔n<o⇒m<o m n m⊔n<o = ≤-<-trans (m≤m⊔n m n) m⊔n<o
 
 m⊔n<o⇒n<o : ∀ m n {o} → m ⊔ n < o → n < o
-m⊔n<o⇒n<o m n m⊔n<o = <-transʳ (m≤n⊔m m n) m⊔n<o
+m⊔n<o⇒n<o m n m⊔n<o = ≤-<-trans (m≤n⊔m m n) m⊔n<o
 
 ⊔-mono-< : _⊔_ Preserves₂ _<_ ⟶ _<_ ⟶ _<_
 ⊔-mono-< = ⊔-mono-≤
 
-⊔-pres-<m : ∀ {m n o} → n < m → o < m → n ⊔ o < m
-⊔-pres-<m {m} n<m o<m = subst (_ <_) (⊔-idem m) (⊔-mono-< n<m o<m)
+⊔-pres-<m : n < m → o < m → n ⊔ o < m
+⊔-pres-<m {m = m} n<m o<m = subst (_ <_) (⊔-idem m) (⊔-mono-< n<m o<m)
 
 ------------------------------------------------------------------------
 -- Other properties of _⊔_ and _+_
@@ -1289,7 +1333,7 @@ m⊔n<o⇒n<o m n m⊔n<o = <-transʳ (m≤n⊔m m n) m⊔n<o
 +-distribˡ-⊔ (suc m) n o = cong suc (+-distribˡ-⊔ m n o)
 
 +-distribʳ-⊔ : _+_ DistributesOverʳ _⊔_
-+-distribʳ-⊔ = comm+distrˡ⇒distrʳ +-comm +-distribˡ-⊔
++-distribʳ-⊔ = comm∧distrˡ⇒distrʳ +-comm +-distribˡ-⊔
 
 +-distrib-⊔ : _+_ DistributesOver _⊔_
 +-distrib-⊔ = +-distribˡ-⊔ , +-distribʳ-⊔
@@ -1306,19 +1350,19 @@ m⊔n≤m+n m n with ⊔-sel m n
 *-distribˡ-⊔ m zero o = sym (cong (_⊔ m * o) (*-zeroʳ m))
 *-distribˡ-⊔ m (suc n) zero = begin-equality
   m * (suc n ⊔ zero)         ≡⟨⟩
-  m * suc n                  ≡˘⟨ ⊔-identityʳ (m * suc n) ⟩
-  m * suc n ⊔ zero           ≡˘⟨ cong (m * suc n ⊔_) (*-zeroʳ m) ⟩
+  m * suc n                  ≡⟨ ⊔-identityʳ (m * suc n) ⟨
+  m * suc n ⊔ zero           ≡⟨ cong (m * suc n ⊔_) (*-zeroʳ m) ⟨
   m * suc n ⊔ m * zero       ∎
 *-distribˡ-⊔ m (suc n) (suc o) = begin-equality
   m * (suc n ⊔ suc o)        ≡⟨⟩
   m * suc (n ⊔ o)            ≡⟨ *-suc m (n ⊔ o) ⟩
   m + m * (n ⊔ o)            ≡⟨ cong (m +_) (*-distribˡ-⊔ m n o) ⟩
   m + (m * n ⊔ m * o)        ≡⟨ +-distribˡ-⊔ m (m * n) (m * o) ⟩
-  (m + m * n) ⊔ (m + m * o)  ≡˘⟨ cong₂ _⊔_ (*-suc m n) (*-suc m o) ⟩
+  (m + m * n) ⊔ (m + m * o)  ≡⟨ cong₂ _⊔_ (*-suc m n) (*-suc m o) ⟨
   (m * suc n) ⊔ (m * suc o)  ∎
 
 *-distribʳ-⊔ : _*_ DistributesOverʳ _⊔_
-*-distribʳ-⊔ = comm+distrˡ⇒distrʳ *-comm *-distribˡ-⊔
+*-distribʳ-⊔ = comm∧distrˡ⇒distrʳ *-comm *-distribˡ-⊔
 
 *-distrib-⊔ : _*_ DistributesOver _⊔_
 *-distrib-⊔ = *-distribˡ-⊔ , *-distribʳ-⊔
@@ -1371,22 +1415,22 @@ m⊔n≤m+n m n with ⊔-sel m n
 ------------------------------------------------------------------------
 -- Other properties of _⊓_ and _≤_/_<_
 
-m<n⇒m⊓o<n : ∀ {m n} o → m < n → m ⊓ o < n
-m<n⇒m⊓o<n o m<n = <-transʳ (m⊓n≤m _ o) m<n
+m<n⇒m⊓o<n : ∀ o → m < n → m ⊓ o < n
+m<n⇒m⊓o<n o m<n = ≤-<-trans (m⊓n≤m _ o) m<n
 
-m<n⇒o⊓m<n : ∀ {m n} o → m < n → o ⊓ m < n
-m<n⇒o⊓m<n o m<n = <-transʳ (m⊓n≤n o _) m<n
+m<n⇒o⊓m<n : ∀ o → m < n → o ⊓ m < n
+m<n⇒o⊓m<n o m<n = ≤-<-trans (m⊓n≤n o _) m<n
 
-m<n⊓o⇒m<n : ∀ {m} n o → m < n ⊓ o → m < n
+m<n⊓o⇒m<n : ∀ n o → m < n ⊓ o → m < n
 m<n⊓o⇒m<n = m≤n⊓o⇒m≤n
 
-m<n⊓o⇒m<o : ∀ {m} n o → m < n ⊓ o → m < o
+m<n⊓o⇒m<o : ∀ n o → m < n ⊓ o → m < o
 m<n⊓o⇒m<o = m≤n⊓o⇒m≤o
 
 ⊓-mono-< : _⊓_ Preserves₂ _<_ ⟶ _<_ ⟶ _<_
 ⊓-mono-< = ⊓-mono-≤
 
-⊓-pres-m< : ∀ {m n o} → m < n → m < o → m < n ⊓ o
+⊓-pres-m< : m < n → m < o → m < n ⊓ o
 ⊓-pres-m< {m} m<n m<o = subst (_< _) (⊓-idem m) (⊓-mono-< m<n m<o)
 
 ------------------------------------------------------------------------
@@ -1397,7 +1441,7 @@ m<n⊓o⇒m<o = m≤n⊓o⇒m≤o
 +-distribˡ-⊓ (suc m) n o = cong suc (+-distribˡ-⊓ m n o)
 
 +-distribʳ-⊓ : _+_ DistributesOverʳ _⊓_
-+-distribʳ-⊓ = comm+distrˡ⇒distrʳ +-comm +-distribˡ-⊓
++-distribʳ-⊓ = comm∧distrˡ⇒distrʳ +-comm +-distribˡ-⊓
 
 +-distrib-⊓ : _+_ DistributesOver _⊓_
 +-distrib-⊓ = +-distribˡ-⊓ , +-distribʳ-⊓
@@ -1415,24 +1459,24 @@ m⊓n≤m+n m n with ⊓-sel m n
   m * (0 ⊓ o)               ≡⟨⟩
   m * 0                     ≡⟨ *-zeroʳ m ⟩
   0                         ≡⟨⟩
-  0 ⊓ (m * o)               ≡˘⟨ cong (_⊓ (m * o)) (*-zeroʳ m) ⟩
+  0 ⊓ (m * o)               ≡⟨ cong (_⊓ (m * o)) (*-zeroʳ m) ⟨
   (m * 0) ⊓ (m * o)         ∎
 *-distribˡ-⊓ m (suc n) 0 = begin-equality
   m * (suc n ⊓ 0)           ≡⟨⟩
   m * 0                     ≡⟨ *-zeroʳ m ⟩
-  0                         ≡˘⟨ ⊓-zeroʳ (m * suc n) ⟩
-  (m * suc n) ⊓ 0           ≡˘⟨ cong (m * suc n ⊓_) (*-zeroʳ m) ⟩
+  0                         ≡⟨ ⊓-zeroʳ (m * suc n) ⟨
+  (m * suc n) ⊓ 0           ≡⟨ cong (m * suc n ⊓_) (*-zeroʳ m) ⟨
   (m * suc n) ⊓ (m * 0)     ∎
 *-distribˡ-⊓ m (suc n) (suc o) = begin-equality
   m * (suc n ⊓ suc o)       ≡⟨⟩
   m * suc (n ⊓ o)           ≡⟨ *-suc m (n ⊓ o) ⟩
   m + m * (n ⊓ o)           ≡⟨ cong (m +_) (*-distribˡ-⊓ m n o) ⟩
   m + (m * n) ⊓ (m * o)     ≡⟨ +-distribˡ-⊓ m (m * n) (m * o) ⟩
-  (m + m * n) ⊓ (m + m * o) ≡˘⟨ cong₂ _⊓_ (*-suc m n) (*-suc m o) ⟩
+  (m + m * n) ⊓ (m + m * o) ≡⟨ cong₂ _⊓_ (*-suc m n) (*-suc m o) ⟨
   (m * suc n) ⊓ (m * suc o) ∎
 
 *-distribʳ-⊓ : _*_ DistributesOverʳ _⊓_
-*-distribʳ-⊓ = comm+distrˡ⇒distrʳ *-comm *-distribˡ-⊓
+*-distribʳ-⊓ = comm∧distrˡ⇒distrʳ *-comm *-distribˡ-⊓
 
 *-distrib-⊓ : _*_ DistributesOver _⊓_
 *-distrib-⊓ = *-distribˡ-⊓ , *-distribʳ-⊓
@@ -1478,10 +1522,10 @@ m≮m∸n (suc m) (suc n) = m≮m∸n m n ∘ ≤-trans (n≤1+n (suc m))
 ∸-mono (s≤s m₁≤m₂) (s≤s n₁≥n₂)    = ∸-mono m₁≤m₂ n₁≥n₂
 ∸-mono m₁≤m₂       (z≤n {n = n₁}) = ≤-trans (m∸n≤m _ n₁) m₁≤m₂
 
-∸-monoˡ-≤ : ∀ {m n} o → m ≤ n → m ∸ o ≤ n ∸ o
+∸-monoˡ-≤ : ∀ o → m ≤ n → m ∸ o ≤ n ∸ o
 ∸-monoˡ-≤ o m≤n = ∸-mono {u = o} m≤n ≤-refl
 
-∸-monoʳ-≤ : ∀ {m n} o → m ≤ n → o ∸ m ≥ o ∸ n
+∸-monoʳ-≤ : ∀ o → m ≤ n → o ∸ m ≥ o ∸ n
 ∸-monoʳ-≤ _ m≤n = ∸-mono ≤-refl m≤n
 
 ∸-monoˡ-< : ∀ {m n o} → m < o → n ≤ m → m ∸ n < o ∸ n
@@ -1502,41 +1546,41 @@ m≮m∸n (suc m) (suc n) = m≮m∸n m n ∘ ≤-trans (n≤1+n (suc m))
 ∸-cancelʳ-< {suc m} {zero}  {_}     o∸n<o∸m = 0<1+n
 ∸-cancelʳ-< {suc m} {suc n} {suc o} o∸n<o∸m = s≤s (∸-cancelʳ-< o∸n<o∸m)
 
-∸-cancelˡ-≡ :  ∀ {m n o} → n ≤ m → o ≤ m → m ∸ n ≡ m ∸ o → n ≡ o
+∸-cancelˡ-≡ :  n ≤ m → o ≤ m → m ∸ n ≡ m ∸ o → n ≡ o
 ∸-cancelˡ-≡ {_}         z≤n       z≤n       _  = refl
 ∸-cancelˡ-≡ {o = suc o} z≤n       (s≤s _)   eq = contradiction eq (1+m≢m∸n o)
 ∸-cancelˡ-≡ {n = suc n} (s≤s _)   z≤n       eq = contradiction (sym eq) (1+m≢m∸n n)
 ∸-cancelˡ-≡ {_}         (s≤s n≤m) (s≤s o≤m) eq = cong suc (∸-cancelˡ-≡ n≤m o≤m eq)
 
-∸-cancelʳ-≡ :  ∀ {m n o} → o ≤ m → o ≤ n → m ∸ o ≡ n ∸ o → m ≡ n
+∸-cancelʳ-≡ :  o ≤ m → o ≤ n → m ∸ o ≡ n ∸ o → m ≡ n
 ∸-cancelʳ-≡  z≤n       z≤n      eq = eq
 ∸-cancelʳ-≡ (s≤s o≤m) (s≤s o≤n) eq = cong suc (∸-cancelʳ-≡ o≤m o≤n eq)
 
-m∸n≡0⇒m≤n : ∀ {m n} → m ∸ n ≡ 0 → m ≤ n
+m∸n≡0⇒m≤n : m ∸ n ≡ 0 → m ≤ n
 m∸n≡0⇒m≤n {zero}  {_}    _   = z≤n
 m∸n≡0⇒m≤n {suc m} {suc n} eq = s≤s (m∸n≡0⇒m≤n eq)
 
-m≤n⇒m∸n≡0 : ∀ {m n} → m ≤ n → m ∸ n ≡ 0
+m≤n⇒m∸n≡0 : m ≤ n → m ∸ n ≡ 0
 m≤n⇒m∸n≡0 {n = n} z≤n      = 0∸n≡0 n
 m≤n⇒m∸n≡0 {_}    (s≤s m≤n) = m≤n⇒m∸n≡0 m≤n
 
-m<n⇒0<n∸m : ∀ {m n} → m < n → 0 < n ∸ m
+m<n⇒0<n∸m : m < n → 0 < n ∸ m
 m<n⇒0<n∸m {zero}  {suc n} _         = 0<1+n
 m<n⇒0<n∸m {suc m} {suc n} (s≤s m<n) = m<n⇒0<n∸m m<n
 
-m∸n≢0⇒n<m : ∀ {m n} → m ∸ n ≢ 0 → n < m
+m∸n≢0⇒n<m : m ∸ n ≢ 0 → n < m
 m∸n≢0⇒n<m {m} {n} m∸n≢0 with n <? m
 ... | yes n<m = n<m
 ... | no  n≮m = contradiction (m≤n⇒m∸n≡0 (≮⇒≥ n≮m)) m∸n≢0
 
-m>n⇒m∸n≢0 : ∀ {m n} → m > n → m ∸ n ≢ 0
+m>n⇒m∸n≢0 : m > n → m ∸ n ≢ 0
 m>n⇒m∸n≢0 {n = suc n} (s≤s m>n) = m>n⇒m∸n≢0 m>n
 
-m≤n⇒n∸m≤n : ∀ {m n} → m ≤ n → n ∸ m ≤ n
+m≤n⇒n∸m≤n : m ≤ n → n ∸ m ≤ n
 m≤n⇒n∸m≤n z≤n       = ≤-refl
 m≤n⇒n∸m≤n (s≤s m≤n) = m≤n⇒m≤1+n (m≤n⇒n∸m≤n m≤n)
 
----------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _∸_ and _+_
 
 +-∸-comm : ∀ {m} n {o} → o ≤ m → (m + n) ∸ o ≡ (m ∸ o) + n
@@ -1558,6 +1602,25 @@ m≤n⇒n∸m≤n (s≤s m≤n) = m≤n⇒m≤1+n (m≤n⇒n∸m≤n m≤n)
   (m + n) ∸ o          ≡⟨ +-∸-assoc m o≤n ⟩
   m + (n ∸ o)          ∎
 
+m≤n+o⇒m∸n≤o : ∀ m n {o} → m ≤ n + o → m ∸ n ≤ o
+m≤n+o⇒m∸n≤o      m  zero    le = le
+m≤n+o⇒m∸n≤o zero    (suc n)  _ = z≤n
+m≤n+o⇒m∸n≤o (suc m) (suc n) le = m≤n+o⇒m∸n≤o m n (s≤s⁻¹ le)
+
+m<n+o⇒m∸n<o : ∀ m n {o} → .{{NonZero o}} → m < n + o → m ∸ n < o
+m<n+o⇒m∸n<o      m  zero                lt = lt
+m<n+o⇒m∸n<o zero    (suc n) {o@(suc _)} lt = z<s
+m<n+o⇒m∸n<o (suc m) (suc n)             lt = m<n+o⇒m∸n<o m n  (s<s⁻¹ lt)
+
+m+n≤o⇒m≤o∸n : ∀ m {n o} → m + n ≤ o → m ≤ o ∸ n
+m+n≤o⇒m≤o∸n zero    le       = z≤n
+m+n≤o⇒m≤o∸n (suc m) (s≤s le)
+  rewrite +-∸-assoc 1 (m+n≤o⇒n≤o m le) = s≤s (m+n≤o⇒m≤o∸n m le)
+
+m≤o∸n⇒m+n≤o : ∀ m {n o} (n≤o : n ≤ o) → m ≤ o ∸ n → m + n ≤ o
+m≤o∸n⇒m+n≤o m         z≤n       le rewrite +-identityʳ m = le
+m≤o∸n⇒m+n≤o m {suc n} (s≤s n≤o) le rewrite +-suc m n = s≤s (m≤o∸n⇒m+n≤o m n≤o le)
+
 m≤n+m∸n : ∀ m n → m ≤ n + (m ∸ n)
 m≤n+m∸n zero    n       = z≤n
 m≤n+m∸n (suc m) zero    = ≤-refl
@@ -1573,7 +1636,7 @@ m+n∸n≡m m n = begin-equality
 m+n∸m≡n : ∀ m n → m + n ∸ m ≡ n
 m+n∸m≡n m n = trans (cong (_∸ m) (+-comm m n)) (m+n∸n≡m n m)
 
-m+[n∸m]≡n : ∀ {m n} → m ≤ n → m + (n ∸ m) ≡ n
+m+[n∸m]≡n : m ≤ n → m + (n ∸ m) ≡ n
 m+[n∸m]≡n {m} {n} m≤n = begin-equality
   m + (n ∸ m)  ≡⟨ sym $ +-∸-assoc m m≤n ⟩
   (m + n) ∸ m  ≡⟨ cong (_∸ m) (+-comm m n) ⟩
@@ -1611,7 +1674,7 @@ m∸[m∸n]≡n {suc m} {suc n} (s≤s n≤m) = begin-equality
   m + n * m ∸ (m + o * m) ∎
 
 *-distribˡ-∸ : _*_ DistributesOverˡ _∸_
-*-distribˡ-∸ = comm+distrʳ⇒distrˡ *-comm *-distribʳ-∸
+*-distribˡ-∸ = comm∧distrʳ⇒distrˡ *-comm *-distribʳ-∸
 
 *-distrib-∸ : _*_ DistributesOver _∸_
 *-distrib-∸ = *-distribˡ-∸ , *-distribʳ-∸
@@ -1654,27 +1717,50 @@ m⊓n+n∸m≡n (suc m) (suc n) = cong suc $ m⊓n+n∸m≡n m n
 -- Properties of pred
 ------------------------------------------------------------------------
 
-pred-mono : pred Preserves _≤_ ⟶ _≤_
-pred-mono m≤n = ∸-mono m≤n (≤-refl {1})
-
-pred[n]≤n : ∀ {n} → pred n ≤ n
+pred[n]≤n : pred n ≤ n
 pred[n]≤n {zero}  = z≤n
 pred[n]≤n {suc n} = n≤1+n n
 
-≤pred⇒≤ : ∀ {m n} → m ≤ pred n → m ≤ n
-≤pred⇒≤ {m} {zero}  le = le
-≤pred⇒≤ {m} {suc n} le = m≤n⇒m≤1+n le
+≤pred⇒≤ : m ≤ pred n → m ≤ n
+≤pred⇒≤ {n = zero}  le = le
+≤pred⇒≤ {n = suc n} le = m≤n⇒m≤1+n le
 
-≤⇒pred≤ : ∀ {m n} → m ≤ n → pred m ≤ n
+≤⇒pred≤ : m ≤ n → pred m ≤ n
 ≤⇒pred≤ {zero}  le = le
 ≤⇒pred≤ {suc m} le = ≤-trans (n≤1+n m) le
 
-<⇒≤pred : ∀ {m n} → m < n → m ≤ pred n
+<⇒≤pred : m < n → m ≤ pred n
 <⇒≤pred (s≤s le) = le
 
 suc-pred : ∀ n .{{_ : NonZero n}} → suc (pred n) ≡ n
 suc-pred (suc n) = refl
 
+pred-mono-≤ : pred Preserves _≤_ ⟶ _≤_
+pred-mono-≤ {zero}          _   = z≤n
+pred-mono-≤ {suc _} {suc _} m≤n = s≤s⁻¹ m≤n
+
+pred-mono-< : .{{NonZero m}} → m < n → pred m < pred n
+pred-mono-< {m = suc _} {n = suc _} = s<s⁻¹
+
+pred-cancel-≤ : pred m ≤ pred n → (m ≡ 1 × n ≡ 0) ⊎ m ≤ n
+pred-cancel-≤ {m = zero}  {n = zero}  _  = inj₂ z≤n
+pred-cancel-≤ {m = zero}  {n = suc _} _  = inj₂ z≤n
+pred-cancel-≤ {m = suc _} {n = zero} z≤n = inj₁ (refl , refl)
+pred-cancel-≤ {m = suc _} {n = suc _} le = inj₂ (s≤s le)
+
+pred-cancel-< : pred m < pred n → m < n
+pred-cancel-< {m = zero}  {n = suc _} _ = z<s
+pred-cancel-< {m = suc _} {n = suc _}   = s<s
+
+pred-injective : .{{NonZero m}} → .{{NonZero n}} → pred m ≡ pred n → m ≡ n
+pred-injective {suc m} {suc n} = cong suc
+
+pred-cancel-≡ : pred m ≡ pred n → ((m ≡ 0 × n ≡ 1) ⊎ (m ≡ 1 × n ≡ 0)) ⊎ m ≡ n
+pred-cancel-≡ {m = zero}  {n = zero}  _    = inj₂ refl
+pred-cancel-≡ {m = zero}  {n = suc _} refl = inj₁ (inj₁ (refl , refl))
+pred-cancel-≡ {m = suc _} {n = zero}  refl = inj₁ (inj₂ (refl , refl))
+pred-cancel-≡ {m = suc _} {n = suc _}      = inj₂ ∘ pred-injective
+
 ------------------------------------------------------------------------
 -- Properties of ∣_-_∣
 ------------------------------------------------------------------------
@@ -1682,25 +1768,25 @@ suc-pred (suc n) = refl
 ------------------------------------------------------------------------
 -- Basic
 
-m≡n⇒∣m-n∣≡0 : ∀ {m n} → m ≡ n → ∣ m - n ∣ ≡ 0
+m≡n⇒∣m-n∣≡0 : m ≡ n → ∣ m - n ∣ ≡ 0
 m≡n⇒∣m-n∣≡0 {zero}  refl = refl
 m≡n⇒∣m-n∣≡0 {suc m} refl = m≡n⇒∣m-n∣≡0 {m} refl
 
-∣m-n∣≡0⇒m≡n : ∀ {m n} → ∣ m - n ∣ ≡ 0 → m ≡ n
+∣m-n∣≡0⇒m≡n :  ∣ m - n ∣ ≡ 0 → m ≡ n
 ∣m-n∣≡0⇒m≡n {zero}  {zero}  eq = refl
 ∣m-n∣≡0⇒m≡n {suc m} {suc n} eq = cong suc (∣m-n∣≡0⇒m≡n eq)
 
-m≤n⇒∣n-m∣≡n∸m : ∀ {m n} → m ≤ n → ∣ n - m ∣ ≡ n ∸ m
-m≤n⇒∣n-m∣≡n∸m {_} {zero}  z≤n       = refl
-m≤n⇒∣n-m∣≡n∸m {_} {suc m} z≤n       = refl
-m≤n⇒∣n-m∣≡n∸m {_} {_}     (s≤s m≤n) = m≤n⇒∣n-m∣≡n∸m m≤n
+m≤n⇒∣n-m∣≡n∸m : m ≤ n → ∣ n - m ∣ ≡ n ∸ m
+m≤n⇒∣n-m∣≡n∸m {n = zero}  z≤n       = refl
+m≤n⇒∣n-m∣≡n∸m {n = suc n} z≤n       = refl
+m≤n⇒∣n-m∣≡n∸m {n = _}     (s≤s m≤n) = m≤n⇒∣n-m∣≡n∸m m≤n
 
-m≤n⇒∣m-n∣≡n∸m : ∀ {m n} → m ≤ n → ∣ m - n ∣ ≡ n ∸ m
-m≤n⇒∣m-n∣≡n∸m {_} {zero}  z≤n       = refl
-m≤n⇒∣m-n∣≡n∸m {_} {suc n} z≤n       = refl
-m≤n⇒∣m-n∣≡n∸m {_} {_}     (s≤s m≤n) = m≤n⇒∣m-n∣≡n∸m m≤n
+m≤n⇒∣m-n∣≡n∸m : m ≤ n → ∣ m - n ∣ ≡ n ∸ m
+m≤n⇒∣m-n∣≡n∸m {n = zero}  z≤n       = refl
+m≤n⇒∣m-n∣≡n∸m {n = suc n} z≤n       = refl
+m≤n⇒∣m-n∣≡n∸m {n = _}     (s≤s m≤n) = m≤n⇒∣m-n∣≡n∸m m≤n
 
-∣m-n∣≡m∸n⇒n≤m : ∀ {m n} → ∣ m - n ∣ ≡ m ∸ n → n ≤ m
+∣m-n∣≡m∸n⇒n≤m : ∣ m - n ∣ ≡ m ∸ n → n ≤ m
 ∣m-n∣≡m∸n⇒n≤m {zero}  {zero}  eq = z≤n
 ∣m-n∣≡m∸n⇒n≤m {suc m} {zero}  eq = z≤n
 ∣m-n∣≡m∸n⇒n≤m {suc m} {suc n} eq = s≤s (∣m-n∣≡m∸n⇒n≤m eq)
@@ -1769,7 +1855,7 @@ private
   ∣ a * m - a * n ∣ ∎
 
 *-distribʳ-∣-∣ : _*_ DistributesOverʳ ∣_-_∣
-*-distribʳ-∣-∣ = comm+distrˡ⇒distrʳ *-comm *-distribˡ-∣-∣
+*-distribʳ-∣-∣ = comm∧distrˡ⇒distrʳ *-comm *-distribˡ-∣-∣
 
 *-distrib-∣-∣ : _*_ DistributesOver ∣_-_∣
 *-distrib-∣-∣ = *-distribˡ-∣-∣ , *-distribʳ-∣-∣
@@ -1924,6 +2010,8 @@ n≡⌈n+n/2⌉ (suc n′@(suc n)) =
 1≤n! zero    = ≤-refl
 1≤n! (suc n) = *-mono-≤ (m≤m+n 1 n) (1≤n! n)
 
+infix 4 _!≢0 _!*_!≢0
+
 _!≢0 : ∀ n → NonZero (n !)
 n !≢0 = >-nonZero (1≤n! n)
 
@@ -1937,11 +2025,11 @@ m !* n !≢0 = m*n≢0 _ _ {{m !≢0}} {{n !≢0}}
 ≤′-trans m≤n ≤′-refl       = m≤n
 ≤′-trans m≤n (≤′-step n≤o) = ≤′-step (≤′-trans m≤n n≤o)
 
-z≤′n : ∀ {n} → zero ≤′ n
+z≤′n : zero ≤′ n
 z≤′n {zero}  = ≤′-refl
 z≤′n {suc n} = ≤′-step z≤′n
 
-s≤′s : ∀ {m n} → m ≤′ n → suc m ≤′ suc n
+s≤′s : m ≤′ n → suc m ≤′ suc n
 s≤′s ≤′-refl        = ≤′-refl
 s≤′s (≤′-step m≤′n) = ≤′-step (s≤′s m≤′n)
 
@@ -1953,30 +2041,30 @@ s≤′s (≤′-step m≤′n) = ≤′-step (s≤′s m≤′n)
 ≤⇒≤′ z≤n       = z≤′n
 ≤⇒≤′ (s≤s m≤n) = s≤′s (≤⇒≤′ m≤n)
 
-≤′-step-injective : ∀ {m n} {p q : m ≤′ n} → ≤′-step p ≡ ≤′-step q → p ≡ q
+≤′-step-injective : {p q : m ≤′ n} → ≤′-step p ≡ ≤′-step q → p ≡ q
 ≤′-step-injective refl = refl
 
 ------------------------------------------------------------------------
 -- Properties of _<′_ and _<_
 ------------------------------------------------------------------------
 
-z<′s : ∀ {n} → zero <′ suc n
+z<′s : zero <′ suc n
 z<′s {zero}  = <′-base
 z<′s {suc n} = <′-step (z<′s {n})
 
-s<′s : ∀ {m n} → m <′ n → suc m <′ suc n
+s<′s : m <′ n → suc m <′ suc n
 s<′s <′-base        = <′-base
 s<′s (<′-step m<′n) = <′-step (s<′s m<′n)
 
-<⇒<′ : ∀ {m n} → m < n → m <′ n
+<⇒<′ : m < n → m <′ n
 <⇒<′ z<s               = z<′s
 <⇒<′ (s<s m<n@(s≤s _)) = s<′s (<⇒<′ m<n)
 
-<′⇒< : ∀ {m n} → m <′ n → m < n
+<′⇒< : m <′ n → m < n
 <′⇒< <′-base        = n<1+n _
 <′⇒< (<′-step m<′n) = m<n⇒m<1+n (<′⇒< m<′n)
 
-m<1+n⇒m<n∨m≡n′ : ∀ {m n} → m < suc n → m < n ⊎ m ≡ n
+m<1+n⇒m<n∨m≡n′ : m < suc n → m < n ⊎ m ≡ n
 m<1+n⇒m<n∨m≡n′ m<n with <⇒<′ m<n
 ... | <′-base      = inj₂ refl
 ... | <′-step m<′n = inj₁ (<′⇒< m<′n)
@@ -2019,27 +2107,46 @@ n≤′m+n (suc m) n = ≤′-step (n≤′m+n m n)
 -- Properties of _≤″_ and _<″_
 ------------------------------------------------------------------------
 
+-- equivalence of  _≤″_ to _≤_
+
+≤⇒≤″ : _≤_ ⇒ _≤″_
+≤⇒≤″ = (_ ,_) ∘ m+[n∸m]≡n
+
+<⇒<″ : _<_ ⇒ _<″_
+<⇒<″ = ≤⇒≤″
+
+≤″⇒≤ : _≤″_ ⇒ _≤_
+≤″⇒≤ (k , refl) = m≤m+n _ k
+
+-- equivalence to the old definition of _≤″_
+
+≤″-proof : (le : m ≤″ n) → let k , _ = le in m + k ≡ n
+≤″-proof (_ , prf) = prf
+
+-- yielding analogous proof for _≤_
+
+m≤n⇒∃[o]m+o≡n : .(m ≤ n) → ∃ λ k → m + k ≡ n
+m≤n⇒∃[o]m+o≡n m≤n = _ , m+[n∸m]≡n (recompute (_ ≤? _) m≤n)
+
+-- whose witness is equal to monus
+
+guarded-∸≗∸ : ∀ {m n} → .(m≤n : m ≤ n) →
+              let k , _ = m≤n⇒∃[o]m+o≡n m≤n in k ≡ n ∸ m
+guarded-∸≗∸ m≤n = refl
+
+-- equivalence of _<″_ to _<ᵇ_
+
 m<ᵇn⇒1+m+[n-1+m]≡n : ∀ m n → T (m <ᵇ n) → suc m + (n ∸ suc m) ≡ n
 m<ᵇn⇒1+m+[n-1+m]≡n m n lt = m+[n∸m]≡n (<ᵇ⇒< m n lt)
 
 m<ᵇ1+m+n : ∀ m {n} → T (m <ᵇ suc (m + n))
 m<ᵇ1+m+n m = <⇒<ᵇ (m≤m+n (suc m) _)
 
-<ᵇ⇒<″ : ∀ {m n} → T (m <ᵇ n) → m <″ n
-<ᵇ⇒<″ {m} {n} leq = less-than-or-equal (m+[n∸m]≡n (<ᵇ⇒< m n leq))
+<ᵇ⇒<″ : T (m <ᵇ n) → m <″ n
+<ᵇ⇒<″ {m} {n} = <⇒<″ ∘ (<ᵇ⇒< m n)
 
 <″⇒<ᵇ : ∀ {m n} → m <″ n → T (m <ᵇ n)
-<″⇒<ᵇ {m} (less-than-or-equal refl) = <⇒<ᵇ (m≤m+n (suc m) _)
-
--- equivalence to _≤_
-
-≤″⇒≤ : _≤″_ ⇒ _≤_
-≤″⇒≤ {zero}  (less-than-or-equal refl) = z≤n
-≤″⇒≤ {suc m} (less-than-or-equal refl) =
-  s≤s (≤″⇒≤ (less-than-or-equal refl))
-
-≤⇒≤″ : _≤_ ⇒ _≤″_
-≤⇒≤″ = less-than-or-equal ∘ m+[n∸m]≡n
+<″⇒<ᵇ {m} (k , refl) = <⇒<ᵇ (m≤m+n (suc m) k)
 
 -- NB: we use the builtin function `_<ᵇ_ : (m n : ℕ) → Bool` here so
 -- that the function quickly decides whether to return `yes` or `no`.
@@ -2053,7 +2160,7 @@ _<″?_ : Decidable _<″_
 m <″? n = map′ <ᵇ⇒<″ <″⇒<ᵇ (T? (m <ᵇ n))
 
 _≤″?_ : Decidable _≤″_
-zero  ≤″? n = yes (less-than-or-equal refl)
+zero  ≤″? n = yes (n , refl)
 suc m ≤″? n = m <″? n
 
 _≥″?_ : Decidable _≥″_
@@ -2063,10 +2170,9 @@ _>″?_ : Decidable _>″_
 _>″?_ = flip _<″?_
 
 ≤″-irrelevant : Irrelevant _≤″_
-≤″-irrelevant {m} (less-than-or-equal eq₁)
-                  (less-than-or-equal eq₂)
-  with +-cancelˡ-≡ m _ _ (trans eq₁ (sym eq₂))
-... | refl = cong less-than-or-equal (≡-irrelevant eq₁ eq₂)
+≤″-irrelevant {m} (_ , eq₁) (_ , eq₂)
+  with refl ← +-cancelˡ-≡ m _ _ (trans eq₁ (sym eq₂))
+  = cong (_ ,_) (≡-irrelevant eq₁ eq₂)
 
 <″-irrelevant : Irrelevant _<″_
 <″-irrelevant = ≤″-irrelevant
@@ -2082,23 +2188,21 @@ _>″?_ = flip _<″?_
 ------------------------------------------------------------------------
 
 ≤‴⇒≤″ : ∀{m n} → m ≤‴ n → m ≤″ n
-≤‴⇒≤″ {m = m} ≤‴-refl     = less-than-or-equal {k = 0} (+-identityʳ m)
-≤‴⇒≤″ {m = m} (≤‴-step x) = less-than-or-equal (trans (+-suc m _) (_≤″_.proof ind)) where
-  ind = ≤‴⇒≤″ x
+≤‴⇒≤″ {m = m} ≤‴-refl       = 0 , +-identityʳ m
+≤‴⇒≤″ {m = m} (≤‴-step m≤n) = _ , trans (+-suc m _) (≤″-proof (≤‴⇒≤″ m≤n))
 
 m≤‴m+k : ∀{m n k} → m + k ≡ n → m ≤‴ n
-m≤‴m+k {m} {k = zero} refl = subst (λ z → m ≤‴ z) (sym (+-identityʳ m)) (≤‴-refl {m})
-m≤‴m+k {m} {k = suc k} proof
-  = ≤‴-step (m≤‴m+k {k = k} (trans (sym (+-suc m _)) proof))
+m≤‴m+k {m} {k = zero}  refl = subst (λ z → m ≤‴ z) (sym (+-identityʳ m)) (≤‴-refl {m})
+m≤‴m+k {m} {k = suc k} prf  = ≤‴-step (m≤‴m+k {k = k} (trans (sym (+-suc m _)) prf))
 
 ≤″⇒≤‴ : ∀{m n} → m ≤″ n → m ≤‴ n
-≤″⇒≤‴ (less-than-or-equal {k} proof) = m≤‴m+k proof
+≤″⇒≤‴ m≤n = m≤‴m+k (≤″-proof m≤n)
 
-0≤‴n : ∀{n} → 0 ≤‴ n
-0≤‴n {n} = m≤‴m+k refl
+0≤‴n : 0 ≤‴ n
+0≤‴n = m≤‴m+k refl
 
-<ᵇ⇒<‴ : ∀ {m n} → T (m <ᵇ n) → m <‴ n
-<ᵇ⇒<‴ {m} {n} leq = ≤″⇒≤‴ (<ᵇ⇒<″ leq)
+<ᵇ⇒<‴ : T (m <ᵇ n) → m <‴ n
+<ᵇ⇒<‴ leq = ≤″⇒≤‴ (<ᵇ⇒<″ leq)
 
 <‴⇒<ᵇ : ∀ {m n} → m <‴ n → T (m <ᵇ n)
 <‴⇒<ᵇ leq = <″⇒<ᵇ (≤‴⇒≤″ leq)
@@ -2146,7 +2250,7 @@ module _ {p} {P : Pred ℕ p} (P? : U.Decidable P) where
   ... | _      | yes (n , n<v , Pn) = yes (n , m≤n⇒m≤1+n n<v , Pn)
   ... | no ¬Pv | no ¬Pn<v           = no ¬Pn<1+v
     where
-    ¬Pn<1+v : ∄ λ n → n < suc v × P n
+    ¬Pn<1+v : ¬ (∃ λ n → n < suc v × P n)
     ¬Pn<1+v (n , s≤s n≤v , Pn) with n ≟ v
     ... | yes refl = ¬Pv Pn
     ... | no  n≢v  = ¬Pn<v (n , ≤∧≢⇒< n≤v n≢v , Pn)
@@ -2154,8 +2258,8 @@ module _ {p} {P : Pred ℕ p} (P? : U.Decidable P) where
   allUpTo? : ∀ v → Dec (∀ {n} → n < v → P n)
   allUpTo? zero    = yes λ()
   allUpTo? (suc v) with P? v | allUpTo? v
-  ... | no ¬Pv | _        = no (λ prf → ¬Pv   (prf ≤-refl))
-  ... | _      | no ¬Pn<v = no (λ prf → ¬Pn<v (prf ∘ m≤n⇒m≤1+n))
+  ... | no ¬Pv | _        = no λ prf → ¬Pv   (prf ≤-refl)
+  ... | _      | no ¬Pn<v = no λ prf → ¬Pn<v (prf ∘ m≤n⇒m≤1+n)
   ... | yes Pn | yes Pn<v = yes Pn<1+v
     where
       Pn<1+v : ∀ {n} → n < suc v → P n
@@ -2263,7 +2367,7 @@ n≤m⊔n = m≤n⊔m
 
 -- Version 2.0
 
-suc[pred[n]]≡n : ∀ {n} → n ≢ 0 → suc (pred n) ≡ n
+suc[pred[n]]≡n : n ≢ 0 → suc (pred n) ≡ n
 suc[pred[n]]≡n {zero}  0≢0 = contradiction refl 0≢0
 suc[pred[n]]≡n {suc n} _   = refl
 {-# WARNING_ON_USAGE suc[pred[n]]≡n
@@ -2290,6 +2394,21 @@ suc[pred[n]]≡n {suc n} _   = refl
 "Warning: <-step was deprecated in v2.0. Please use m<n⇒m<1+n instead. "
 #-}
 
+pred-mono = pred-mono-≤
+{-# WARNING_ON_USAGE pred-mono
+"Warning: pred-mono was deprecated in v2.0. Please use pred-mono-≤ instead. "
+#-}
+
 {- issue1844/issue1755: raw bundles have moved to `Data.X.Base` -}
 open Data.Nat.Base public
   using (*-rawMagma; *-1-rawMonoid)
+
+<-transʳ = ≤-<-trans
+{-# WARNING_ON_USAGE <-transʳ
+"Warning: <-transʳ was deprecated in v2.0. Please use ≤-<-trans instead. "
+#-}
+
+<-transˡ = <-≤-trans
+{-# WARNING_ON_USAGE <-transˡ
+"Warning: <-transˡ was deprecated in v2.0. Please use <-≤-trans instead. "
+#-}
diff --git a/src/Data/Nat/Properties/Core.agda b/src/Data/Nat/Properties/Core.agda
index 94031fdc37..66bfdaa32b 100644
--- a/src/Data/Nat/Properties/Core.agda
+++ b/src/Data/Nat/Properties/Core.agda
@@ -2,7 +2,7 @@
 -- The Agda standard library
 --
 -- This module is DEPRECATED. Please use
--- `Data.Nat.Properties` directly.
+-- `Data.Nat.Base directly.
 --
 ------------------------------------------------------------------------
 
@@ -12,7 +12,7 @@ module Data.Nat.Properties.Core where
 
 {-# WARNING_ON_IMPORT
 "Data.Nat.Properties.Core was deprecated in v2.0.
-Use Data.Nat.Properties instead."
+Use Data.Nat.Base instead."
 #-}
 
 open import Data.Nat.Base
@@ -22,4 +22,4 @@ open import Data.Nat.Base
 ------------------------------------------------------------------------
 
 ≤-pred : ∀ {m n} → suc m ≤ suc n → m ≤ n
-≤-pred (s≤s m≤n) = m≤n
+≤-pred = s≤s⁻¹
diff --git a/src/Data/Nat/PseudoRandom/LCG.agda b/src/Data/Nat/PseudoRandom/LCG.agda
index c6c98843cf..32e55c7228 100644
--- a/src/Data/Nat/PseudoRandom/LCG.agda
+++ b/src/Data/Nat/PseudoRandom/LCG.agda
@@ -35,12 +35,12 @@ list (suc k) gen x = x ∷ list k gen (step gen x)
 -- Examples of parameters
 -- Taken from https://en.wikipedia.org/wiki/Linear_congruential_generator
 
--- /!\ As explained in that wikipedia entry, none of these are claimed to
--- be good parameters.
+-- /!\ As explained in that wikipedia entry, none of these are claimed
+-- to be good parameters.
 
--- Note also that if you need your output to have good properties you may
--- need to postprocess the stream of values to only use some of the bits of
--- the output!
+-- Note also that if you need your output to have good properties you
+-- may need to postprocess the stream of values to only use some of the
+-- bits of the output!
 
 glibc : Generator
 glibc = record
diff --git a/src/Data/Nat/PseudoRandom/LCG/Unsafe.agda b/src/Data/Nat/PseudoRandom/LCG/Unsafe.agda
index 17de9de089..545c30c85f 100644
--- a/src/Data/Nat/PseudoRandom/LCG/Unsafe.agda
+++ b/src/Data/Nat/PseudoRandom/LCG/Unsafe.agda
@@ -9,9 +9,9 @@
 {-# OPTIONS --cubical-compatible --sized-types #-}
 
 open import Codata.Sized.Stream using (Stream; unfold)
-open import Data.Nat.PseudoRandom.LCG
-open import Data.Nat using (ℕ)
-open import Data.Product using (<_,_>)
+open import Data.Nat.PseudoRandom.LCG using (Generator; step)
+open import Data.Nat.Base using (ℕ)
+open import Data.Product.Base using (<_,_>)
 open import Function.Base using (id)
 
 module Data.Nat.PseudoRandom.LCG.Unsafe where
diff --git a/src/Data/Nat/Show.agda b/src/Data/Nat/Show.agda
index 454bc95b76..23ab91b0fd 100644
--- a/src/Data/Nat/Show.agda
+++ b/src/Data/Nat/Show.agda
@@ -16,9 +16,9 @@ open import Data.List.Effectful using (module TraversableA)
 open import Data.Maybe.Base as Maybe using (Maybe; nothing; _<∣>_; when)
 import Data.Maybe.Effectful as Maybe
 open import Data.Nat
-open import Data.Product using (proj₁)
-open import Data.String as String using (String)
-open import Function.Base
+open import Data.Product.Base using (proj₁)
+open import Data.String.Base using (toList; fromList; String)
+open import Function.Base using (_∘′_; _∘_)
 open import Relation.Nullary.Decidable using (True)
 
 ------------------------------------------------------------------------
@@ -28,7 +28,7 @@ readMaybe : ∀ base {base≤16 : True (base ≤? 16)} → String → Maybe ℕ
 readMaybe _ "" = nothing
 readMaybe base = Maybe.map convert
               ∘′ TraversableA.mapA Maybe.applicative readDigit
-              ∘′ String.toList
+              ∘′ toList
 
   where
 
@@ -62,7 +62,7 @@ toDecimalChars : ℕ → List Char
 toDecimalChars = List.map toDigitChar ∘′ toNatDigits 10
 
 show : ℕ → String
-show = String.fromList ∘ toDecimalChars
+show = fromList ∘′ toDecimalChars
 
 -- Arbitrary base betwen 2 & 16.
 -- Warning: when compiled the time complexity of `showInBase b n` is
@@ -81,5 +81,5 @@ showInBase : (base : ℕ)
              {base≥2 : True (2 ≤? base)}
              {base≤16 : True (base ≤? 16)} →
              ℕ → String
-showInBase base {base≥2} {base≤16} = String.fromList
+showInBase base {base≥2} {base≤16} = fromList
                                    ∘ charsInBase base {base≥2} {base≤16}
diff --git a/src/Data/Nat/Show/Properties.agda b/src/Data/Nat/Show/Properties.agda
index 739a00c2e4..13dd34ace2 100644
--- a/src/Data/Nat/Show/Properties.agda
+++ b/src/Data/Nat/Show/Properties.agda
@@ -6,21 +6,25 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Digit using (showDigit; toDigits)
 open import Data.Digit.Properties using (toDigits-injective; showDigit-injective)
-open import Function using (_∘_)
 import Data.List.Properties as Listₚ
 open import Data.Nat.Base using (ℕ)
 open import Data.Nat.Properties using (_≤?_)
-open import Relation.Nullary.Decidable using (True)
-open import Relation.Binary.PropositionalEquality using (_≡_)
 open import Data.Nat.Show using (charsInBase)
+open import Function.Base using (_∘_)
+open import Relation.Nullary.Decidable using (True)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 module Data.Nat.Show.Properties where
 
 module _ (base : ℕ) {base≥2 : True (2 ≤? base)} {base≤16 : True (base ≤? 16)} where
 
-  charsInBase-injective : ∀ n m → charsInBase base {base≥2} {base≤16} n ≡ charsInBase base {base≥2} {base≤16} m → n ≡ m
-  charsInBase-injective n m = toDigits-injective base {base≥2} _ _
+  private
+    charsInBase-base         = charsInBase base {base≥2} {base≤16}
+    toDigits-injective-base  = toDigits-injective base {base≥2} {base≥2}
+    showDigit-injective-base = showDigit-injective base {base≤16} {base≤16}
+
+  charsInBase-injective : ∀ n m →  charsInBase-base n ≡ charsInBase-base m → n ≡ m
+  charsInBase-injective n m = toDigits-injective-base _ _
                             ∘ Listₚ.reverse-injective
-                            ∘ Listₚ.map-injective (showDigit-injective _ _ _)
+                            ∘ Listₚ.map-injective (showDigit-injective-base _ _)
diff --git a/src/Data/Nat/Solver.agda b/src/Data/Nat/Solver.agda
index 4c851c0e4b..efd14902b4 100644
--- a/src/Data/Nat/Solver.agda
+++ b/src/Data/Nat/Solver.agda
@@ -4,7 +4,7 @@
 -- Automatic solvers for equations over naturals
 ------------------------------------------------------------------------
 
--- See README.Nat for examples of how to use this solver
+-- See README.Data.Nat for examples of how to use this solver
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
diff --git a/src/Data/Nat/Tactic/RingSolver.agda b/src/Data/Nat/Tactic/RingSolver.agda
index af327ce06c..1d5c2036f5 100644
--- a/src/Data/Nat/Tactic/RingSolver.agda
+++ b/src/Data/Nat/Tactic/RingSolver.agda
@@ -10,14 +10,14 @@
 
 module Data.Nat.Tactic.RingSolver where
 
-open import Agda.Builtin.Reflection
+open import Agda.Builtin.Reflection using (Term; TC)
 
 open import Data.Maybe.Base using (just; nothing)
-open import Data.Nat.Base using (zero; suc)
-open import Data.Nat.Properties
+open import Data.Nat.Base using (zero)
+open import Data.Nat.Properties using (+-*-commutativeSemiring)
 open import Level using (0ℓ)
-open import Data.Unit using (⊤)
-open import Relation.Binary.PropositionalEquality
+open import Data.Unit.Base using (⊤)
+open import Relation.Binary.PropositionalEquality.Core using (refl)
 
 import Tactic.RingSolver as Solver
 import Tactic.RingSolver.Core.AlmostCommutativeRing as ACR
diff --git a/src/Data/Nat/WithK.agda b/src/Data/Nat/WithK.agda
index 49966a93f0..bb6a97a7aa 100644
--- a/src/Data/Nat/WithK.agda
+++ b/src/Data/Nat/WithK.agda
@@ -8,8 +8,9 @@
 
 module Data.Nat.WithK where
 
+open import Algebra.Definitions.RawMagma using (_,_)
 open import Data.Nat.Base
 open import Relation.Binary.PropositionalEquality.WithK
 
 ≤″-erase : ∀ {m n} → m ≤″ n → m ≤″ n
-≤″-erase (less-than-or-equal eq) = less-than-or-equal (≡-erase eq)
+≤″-erase (_ , eq) = _ , ≡-erase eq
diff --git a/src/Data/Parity/Base.agda b/src/Data/Parity/Base.agda
index 6f9e85f9a0..0ac22a9c7a 100644
--- a/src/Data/Parity/Base.agda
+++ b/src/Data/Parity/Base.agda
@@ -26,6 +26,8 @@ data Parity : Set where
 
 -- The opposite parity.
 
+infix 8 _⁻¹
+
 _⁻¹ : Parity → Parity
 1ℙ ⁻¹ = 0ℙ
 0ℙ ⁻¹ = 1ℙ
diff --git a/src/Data/Parity/Properties.agda b/src/Data/Parity/Properties.agda
index ed25a7b2fe..ebca1ef000 100644
--- a/src/Data/Parity/Properties.agda
+++ b/src/Data/Parity/Properties.agda
@@ -9,24 +9,28 @@
 module Data.Parity.Properties where
 
 open import Algebra.Bundles
-open import Data.Empty
 open import Data.Nat.Base as ℕ using (zero; suc; parity)
 open import Data.Parity.Base as ℙ using (Parity; 0ℙ; 1ℙ; _⁻¹; toSign; fromSign)
-open import Data.Product using (_,_)
-open import Data.Sign.Base as 𝕊
-open import Function hiding (Inverse)
+open import Data.Product.Base using (_,_)
+import Data.Sign.Base as 𝕊
+open import Function.Base using (_$_; id)
+open import Function.Definitions
+open import Function.Consequences.Propositional
+  using (inverseʳ⇒injective; inverseˡ⇒surjective)
 open import Level using (0ℓ)
 open import Relation.Binary
   using (Decidable; DecidableEquality; Setoid; DecSetoid; IsDecEquivalence)
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; _≢_; refl; sym; cong; cong₂; module ≡-Reasoning
-        ; setoid; isEquivalence; decSetoid; isDecEquivalence)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≢_; refl; sym; cong; cong₂)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning; setoid; isEquivalence; decSetoid; isDecEquivalence)
 open import Relation.Nullary using (yes; no)
+open import Relation.Nullary.Negation.Core using (contradiction)
 
 open import Algebra.Structures {A = Parity} _≡_
 open import Algebra.Definitions {A = Parity} _≡_
 open import Algebra.Consequences.Propositional
-  using (selfInverse⇒involutive; selfInverse⇒injective; comm+distrˡ⇒distrʳ)
+  using (selfInverse⇒involutive; selfInverse⇒injective; comm∧distrˡ⇒distrʳ)
 open import Algebra.Morphism.Structures
 
 ------------------------------------------------------------------------
@@ -127,8 +131,8 @@ p+p≡0ℙ 1ℙ = refl
 
 +-cancelʳ-≡ : RightCancellative ℙ._+_
 +-cancelʳ-≡ _ 1ℙ 1ℙ _  = refl
-+-cancelʳ-≡ _ 1ℙ 0ℙ eq = ⊥-elim (p≢p⁻¹ _ $ sym eq)
-+-cancelʳ-≡ _ 0ℙ 1ℙ eq = ⊥-elim (p≢p⁻¹ _ eq)
++-cancelʳ-≡ _ 1ℙ 0ℙ eq = contradiction (sym eq) (p≢p⁻¹ _)
++-cancelʳ-≡ _ 0ℙ 1ℙ eq = contradiction eq (p≢p⁻¹ _)
 +-cancelʳ-≡ _ 0ℙ 0ℙ _  = refl
 
 +-cancelˡ-≡ : LeftCancellative ℙ._+_
@@ -252,7 +256,7 @@ p+p≡0ℙ 1ℙ = refl
 *-distribˡ-+ 1ℙ 1ℙ 1ℙ = refl
 
 *-distribʳ-+ : ℙ._*_ DistributesOverʳ ℙ._+_
-*-distribʳ-+ = comm+distrˡ⇒distrʳ *-comm *-distribˡ-+
+*-distribʳ-+ = comm∧distrˡ⇒distrʳ *-comm *-distribˡ-+
 
 *-distrib-+ : ℙ._*_ DistributesOver ℙ._+_
 *-distrib-+ = *-distribˡ-+ , *-distribʳ-+
@@ -369,7 +373,6 @@ p+p≡0ℙ 1ℙ = refl
   ; *-assoc          = *-assoc
   ; *-identity       = *-identity
   ; distrib          = *-distrib-+
-  ; zero             = *-zero
   }
 
 +-*-ring : Ring 0ℓ 0ℓ
@@ -401,23 +404,19 @@ p+p≡0ℙ 1ℙ = refl
 ⁻¹-homo-opposite 0ℙ = refl
 ⁻¹-homo-opposite 1ℙ = refl
 
-toSign-inverts-fromSign : ∀ {p s} → toSign p ≡ s → fromSign s ≡ p
-toSign-inverts-fromSign {0ℙ} refl = refl
-toSign-inverts-fromSign {1ℙ} refl = refl
+toSign-inverseʳ : Inverseʳ _≡_ _≡_ toSign fromSign
+toSign-inverseʳ {0ℙ} refl = refl
+toSign-inverseʳ {1ℙ} refl = refl
 
-fromSign-inverts-toSign : ∀ {s p} → fromSign s ≡ p → toSign p ≡ s
-fromSign-inverts-toSign { + }  refl = refl
-fromSign-inverts-toSign { - } refl = refl
+toSign-inverseˡ : Inverseˡ _≡_ _≡_ toSign fromSign
+toSign-inverseˡ { 𝕊.+ } refl = refl
+toSign-inverseˡ { 𝕊.- } refl = refl
 
 toSign-injective : Injective _≡_ _≡_ toSign
-toSign-injective {p} {q} eq = begin
-  p                   ≡⟨ sym (toSign-inverts-fromSign {p} refl) ⟩
-  fromSign (toSign p) ≡⟨ cong fromSign eq ⟩
-  fromSign (toSign q) ≡⟨ toSign-inverts-fromSign {q} refl ⟩
-  q ∎ where open ≡-Reasoning
+toSign-injective = inverseʳ⇒injective toSign toSign-inverseʳ
 
 toSign-surjective : Surjective _≡_ _≡_ toSign
-toSign-surjective s = (fromSign s) , fromSign-inverts-toSign {s} refl
+toSign-surjective = inverseˡ⇒surjective toSign-inverseˡ
 
 toSign-isMagmaHomomorphism : IsMagmaHomomorphism ℙ.+-rawMagma 𝕊.*-rawMagma toSign
 toSign-isMagmaHomomorphism = record
@@ -476,7 +475,7 @@ toSign-isGroupIsomorphism = record
 
 
 ------------------------------------------------------------------------
--- relating Nat and Parity
+-- Relating Nat and Parity
 
 -- successor and (_⁻¹)
 
diff --git a/src/Data/Product.agda b/src/Data/Product.agda
index 08c0aa0c7f..d0f6db0cde 100644
--- a/src/Data/Product.agda
+++ b/src/Data/Product.agda
@@ -8,33 +8,46 @@
 
 module Data.Product where
 
-open import Function.Base
-open import Level
-open import Relation.Nullary.Negation.Core
+open import Level using (Level; _⊔_)
+open import Relation.Nullary.Negation.Core using (¬_)
 
 private
   variable
-    a b c ℓ : Level
-    A B : Set a
+    a b c ℓ p q r s : Level
+    A B C : Set a
 
 ------------------------------------------------------------------------
 -- Definition of dependent products
 
 open import Data.Product.Base public
 
-------------------------------------------------------------------------
--- Existential quantifiers
+-- These are here as they are not 'basic' but instead "very dependent",
+-- i.e. the result type depends on the full input 'point' (x , y).
+map-Σ : {B : A → Set b} {P : A → Set p} {Q : {x : A} → P x → B x → Set q} →
+   (f : (x : A) → B x) → (∀ {x} → (y : P x) → Q y (f x)) →
+   ((x , y) : Σ A P) → Σ (B x) (Q y)
+map-Σ f g (x , y) = (f x , g y)
+
+-- This is a "non-dependent" version of map-Σ whereby the input is actually
+-- a pair (i.e. _×_ ) but the output type still depends on the input 'point' (x , y).
+map-Σ′ : {B : A → Set b} {P : Set p} {Q : P → Set q} →
+  (f : (x : A) → B x) → ((x : P) → Q x) → ((x , y) : A × P) → B x × Q y
+map-Σ′ f g (x , y) = (f x , g y)
+
+-- This is a generic zipWith for Σ where different functions are applied to each
+-- component pair, and recombined.
+zipWith : {P : A → Set p} {Q : B → Set q} {R : C → Set r} {S : (x : C) → R x → Set s}
+  (_∙_ : A → B → C) → (_∘_ : ∀ {x y} → P x → Q y → R (x ∙ y)) →
+  (_*_ : (x : C) → (y : R x) → S x y) →
+  ((a , p) : Σ A P) → ((b , q) : Σ B Q) → S (a ∙ b) (p ∘ q)
+zipWith _∙_ _∘_ _*_ (a , p) (b , q) = (a ∙ b) * (p ∘ q)
 
-∃ : ∀ {A : Set a} → (A → Set b) → Set (a ⊔ b)
-∃ = Σ _
+------------------------------------------------------------------------
+-- Negation of existential quantifier
 
 ∄ : ∀ {A : Set a} → (A → Set b) → Set (a ⊔ b)
 ∄ P = ¬ ∃ P
 
-∃₂ : ∀ {A : Set a} {B : A → Set b}
-     (C : (x : A) → B x → Set c) → Set (a ⊔ b ⊔ c)
-∃₂ C = ∃ λ a → ∃ λ b → C a b
-
 -- Unique existence (parametrised by an underlying equality).
 
 ∃! : {A : Set a} → (A → A → Set ℓ) → (A → Set b) → Set (a ⊔ b ⊔ ℓ)
@@ -42,13 +55,6 @@ open import Data.Product.Base public
 
 -- Syntax
 
-infix 2 ∃-syntax
-
-∃-syntax : ∀ {A : Set a} → (A → Set b) → Set (a ⊔ b)
-∃-syntax = ∃
-
-syntax ∃-syntax (λ x → B) = ∃[ x ] B
-
 infix 2 ∄-syntax
 
 ∄-syntax : ∀ {A : Set a} → (A → Set b) → Set (a ⊔ b)
diff --git a/src/Data/Product/Algebra.agda b/src/Data/Product/Algebra.agda
index f11045d778..aed57d4ed3 100644
--- a/src/Data/Product/Algebra.agda
+++ b/src/Data/Product/Algebra.agda
@@ -11,13 +11,13 @@ module Data.Product.Algebra where
 open import Algebra
 open import Data.Bool.Base using (true; false)
 open import Data.Empty.Polymorphic using (⊥; ⊥-elim)
-open import Data.Product
+open import Data.Product.Base
 open import Data.Product.Properties
-open import Data.Sum as Sum using (_⊎_; inj₁; inj₂; [_,_]′)
+open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_]′)
 open import Data.Sum.Algebra
 open import Data.Unit.Polymorphic using (⊤; tt)
 open import Function.Base using (_∘′_)
-open import Function.Bundles using (_↔_; Inverse; mk↔′)
+open import Function.Bundles using (_↔_; Inverse; mk↔ₛ′)
 open import Function.Properties.Inverse using (↔-isEquivalence)
 open import Level using (Level; suc)
 open import Relation.Binary.PropositionalEquality.Core
@@ -29,13 +29,7 @@ import Function.Definitions as FuncDef
 private
   variable
     a b c d p : Level
-    A : Set a
-    B : Set b
-    C : Set c
-    D : Set d
-
-  module _ {A : Set a} {B : Set b} where
-    open FuncDef {A = A} {B} _≡_ _≡_
+    A B C D : Set a
 
 ------------------------------------------------------------------------
 -- Properties of Σ
@@ -43,64 +37,64 @@ private
 -- Σ is associative
 Σ-assoc : {B : A → Set b} {C : (a : A) → B a → Set c} →
           Σ (Σ A B) (uncurry C) ↔ Σ A (λ a → Σ (B a) (C a))
-Σ-assoc = mk↔′ assocʳ assocˡ cong′ cong′
+Σ-assoc = mk↔ₛ′ assocʳ assocˡ cong′ cong′
 
 -- Σ is associative, alternate formulation
 Σ-assoc-alt : {B : A → Set b} {C : Σ A B → Set c} →
           Σ (Σ A B) C ↔ Σ A (λ a → Σ (B a) (curry C a))
-Σ-assoc-alt = mk↔′ assocʳ-curried assocˡ-curried cong′ cong′
+Σ-assoc-alt = mk↔ₛ′ assocʳ-curried assocˡ-curried cong′ cong′
 
 ------------------------------------------------------------------------
 -- Algebraic properties
 
 -- × is a congruence
 ×-cong : A ↔ B → C ↔ D → (A × C) ↔ (B × D)
-×-cong i j = mk↔′ (map I.to J.to) (map I.from J.from)
-  (λ {(a , b) → cong₂ _,_ (I.inverseˡ a) (J.inverseˡ b)})
-  (λ {(a , b) → cong₂ _,_ (I.inverseʳ a) (J.inverseʳ b)})
+×-cong i j = mk↔ₛ′ (map I.to J.to) (map I.from J.from)
+  (λ {(a , b) → cong₂ _,_ (I.strictlyInverseˡ a) (J.strictlyInverseˡ b)})
+  (λ {(a , b) → cong₂ _,_ (I.strictlyInverseʳ a) (J.strictlyInverseʳ b)})
   where module I = Inverse i; module J = Inverse j
 
 -- × is commutative.
 -- (we don't use Commutative because it isn't polymorphic enough)
 ×-comm : (A : Set a) (B : Set b) → (A × B) ↔ (B × A)
-×-comm _ _ = mk↔′ swap swap swap-involutive swap-involutive
+×-comm _ _ = mk↔ₛ′ swap swap swap-involutive swap-involutive
 
 module _ (ℓ : Level) where
 
   -- × is associative
   ×-assoc : Associative {ℓ = ℓ} _↔_ _×_
-  ×-assoc _ _ _ = mk↔′ assocʳ′ assocˡ′ cong′ cong′
+  ×-assoc _ _ _ = mk↔ₛ′ assocʳ′ assocˡ′ cong′ cong′
 
   -- ⊤ is the identity for ×
   ×-identityˡ : LeftIdentity {ℓ = ℓ} _↔_ ⊤ _×_
-  ×-identityˡ _ = mk↔′ proj₂ (tt ,_) cong′ cong′
+  ×-identityˡ _ = mk↔ₛ′ proj₂ (tt ,_) cong′ cong′
 
   ×-identityʳ : RightIdentity {ℓ = ℓ} _↔_ ⊤ _×_
-  ×-identityʳ _ = mk↔′ proj₁ (_, tt) cong′ cong′
+  ×-identityʳ _ = mk↔ₛ′ proj₁ (_, tt) cong′ cong′
 
   ×-identity : Identity _↔_ ⊤ _×_
   ×-identity = ×-identityˡ , ×-identityʳ
 
   -- ⊥ is the zero for ×
   ×-zeroˡ : LeftZero {ℓ = ℓ} _↔_ ⊥ _×_
-  ×-zeroˡ A = mk↔′ proj₁ ⊥-elim ⊥-elim λ ()
+  ×-zeroˡ A = mk↔ₛ′ proj₁ ⊥-elim ⊥-elim λ ()
 
   ×-zeroʳ : RightZero {ℓ = ℓ} _↔_ ⊥ _×_
-  ×-zeroʳ A = mk↔′ proj₂ ⊥-elim ⊥-elim λ ()
+  ×-zeroʳ A = mk↔ₛ′ proj₂ ⊥-elim ⊥-elim λ ()
 
   ×-zero : Zero _↔_ ⊥ _×_
   ×-zero = ×-zeroˡ , ×-zeroʳ
 
   -- × distributes over ⊎
   ×-distribˡ-⊎ : _DistributesOverˡ_ {ℓ = ℓ} _↔_ _×_ _⊎_
-  ×-distribˡ-⊎ _ _ _ = mk↔′
+  ×-distribˡ-⊎ _ _ _ = mk↔ₛ′
     (uncurry λ x → [ inj₁ ∘′ (x ,_) , inj₂ ∘′ (x ,_) ]′)
     [ map₂ inj₁ , map₂ inj₂ ]′
     Sum.[ cong′ , cong′ ]
     (uncurry λ _ → Sum.[ cong′ , cong′ ])
 
   ×-distribʳ-⊎ : _DistributesOverʳ_ {ℓ = ℓ} _↔_ _×_ _⊎_
-  ×-distribʳ-⊎ _ _ _ = mk↔′
+  ×-distribʳ-⊎ _ _ _ = mk↔ₛ′
     (uncurry [ curry inj₁ , curry inj₂ ]′)
     [ map₁ inj₁ , map₁ inj₂ ]′
     Sum.[ cong′ , cong′ ]
diff --git a/src/Data/Product/Base.agda b/src/Data/Product/Base.agda
index 7ee638392c..02f7e52697 100644
--- a/src/Data/Product/Base.agda
+++ b/src/Data/Product/Base.agda
@@ -9,7 +9,7 @@
 module Data.Product.Base where
 
 open import Function.Base
-open import Level
+open import Level using (Level; _⊔_)
 
 private
   variable
@@ -31,6 +31,19 @@ open import Agda.Builtin.Sigma public
 module Σ = Agda.Builtin.Sigma.Σ
   renaming (fst to proj₁; snd to proj₂)
 
+------------------------------------------------------------------------
+-- Existential quantifiers
+
+∃ : ∀ {A : Set a} → (A → Set b) → Set (a ⊔ b)
+∃ = Σ _
+
+∃₂ : ∀ {A : Set a} {B : A → Set b}
+     (C : (x : A) → B x → Set c) → Set (a ⊔ b ⊔ c)
+∃₂ C = ∃ λ a → ∃ λ b → C a b
+
+------------------------------------------------------------------------
+-- Syntaxes
+
 -- The syntax declaration below is attached to Σ-syntax, to make it
 -- easy to import Σ without the special syntax.
 
@@ -41,6 +54,13 @@ infix 2 Σ-syntax
 
 syntax Σ-syntax A (λ x → B) = Σ[ x ∈ A ] B
 
+infix 2 ∃-syntax
+
+∃-syntax : ∀ {A : Set a} → (A → Set b) → Set (a ⊔ b)
+∃-syntax = ∃
+
+syntax ∃-syntax (λ x → B) = ∃[ x ] B
+
 ------------------------------------------------------------------------
 -- Definition of non-dependent products
 
diff --git a/src/Data/Product/Categorical/Examples.agda b/src/Data/Product/Categorical/Examples.agda
new file mode 100644
index 0000000000..e832d67b19
--- /dev/null
+++ b/src/Data/Product/Categorical/Examples.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Product.Categorical.Examples` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Product.Categorical.Examples where
+
+open import Data.Product.Effectful.Examples public
+
+{-# WARNING_ON_IMPORT
+"Data.Product.Categorical.Examples was deprecated in v2.0.
+Use Data.Product.Effectful.Examples instead."
+#-}
diff --git a/src/Data/Product/Categorical/Left.agda b/src/Data/Product/Categorical/Left.agda
new file mode 100644
index 0000000000..de68a8575e
--- /dev/null
+++ b/src/Data/Product/Categorical/Left.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Product.Categorical.Left` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Product.Categorical.Left where
+
+open import Data.Product.Effectful.Left public
+
+{-# WARNING_ON_IMPORT
+"Data.Product.Categorical.Left was deprecated in v2.0.
+Use Data.Product.Effectful.Left instead."
+#-}
diff --git a/src/Data/Product/Categorical/Left/Base.agda b/src/Data/Product/Categorical/Left/Base.agda
new file mode 100644
index 0000000000..ffa7fed34c
--- /dev/null
+++ b/src/Data/Product/Categorical/Left/Base.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Product.Categorical.Left.Base` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Product.Categorical.Left.Base where
+
+open import Data.Product.Effectful.Left.Base public
+
+{-# WARNING_ON_IMPORT
+"Data.Product.Categorical.Left.Base was deprecated in v2.0.
+Use Data.Product.Effectful.Left.Base instead."
+#-}
diff --git a/src/Data/Product/Categorical/Right.agda b/src/Data/Product/Categorical/Right.agda
new file mode 100644
index 0000000000..bdd34822e3
--- /dev/null
+++ b/src/Data/Product/Categorical/Right.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Product.Categorical.Right` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Product.Categorical.Right where
+
+open import Data.Product.Effectful.Right public
+
+{-# WARNING_ON_IMPORT
+"Data.Product.Categorical.Right was deprecated in v2.0.
+Use Data.Product.Effectful.Right instead."
+#-}
diff --git a/src/Data/Product/Categorical/Right/Base.agda b/src/Data/Product/Categorical/Right/Base.agda
new file mode 100644
index 0000000000..556009642a
--- /dev/null
+++ b/src/Data/Product/Categorical/Right/Base.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Product.Categorical.Right.Base` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Product.Categorical.Right.Base where
+
+open import Data.Product.Effectful.Right.Base public
+
+{-# WARNING_ON_IMPORT
+"Data.Product.Categorical.Right.Base was deprecated in v2.0.
+Use Data.Product.Effectful.Right.Base instead."
+#-}
diff --git a/src/Data/Product/Effectful/Examples.agda b/src/Data/Product/Effectful/Examples.agda
index 90488642f6..b4cc86618e 100644
--- a/src/Data/Product/Effectful/Examples.agda
+++ b/src/Data/Product/Effectful/Examples.agda
@@ -14,12 +14,12 @@ module Data.Product.Effectful.Examples
 open import Level using (Lift; lift; _⊔_)
 open import Effect.Functor using (RawFunctor)
 open import Effect.Monad using (RawMonad)
-open import Data.Product
+open import Data.Product.Base using (_×_; _,_)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent
-open import Function
+open import Function.Base using (id)
 import Function.Identity.Effectful as Id
-open import Relation.Binary using (Rel)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 ------------------------------------------------------------------------
 -- Examples
@@ -38,16 +38,16 @@ private
 
   open RawFunctor functor
 
-  -- This type to the right of × needs to be a "lifted" version of (B : Set b)
-  -- that lives in the universe (Set (a ⊔ b)).
+  -- This type to the right of × needs to be a "lifted" version of
+  -- (B : Set b) that lives in the universe (Set (a ⊔ b)).
   fmapIdₗ : (x : A.Carrier × Lift a B) → (id <$> x) ≈ x
   fmapIdₗ x = A.refl , refl
 
   open RawMonad monad
 
-  -- Now, let's show that "pure" is a unit for >>=. We use Lift in exactly
-  -- the same way as above. The data (x : B) then needs to be "lifted" to
-  -- this new type (Lift B).
+  -- Now, let's show that "pure" is a unit for >>=. We use Lift in
+  -- exactly the same way as above. The data (x : B) then needs to be
+  -- "lifted" to this new type (Lift B).
   pureUnitL : ∀ {x : B} {f : Lift a B → A.Carrier × Lift a B} →
                 (pure (lift x) >>= f) ≈ f (lift x)
   pureUnitL = A.identityˡ _ , refl
diff --git a/src/Data/Product/Effectful/Left.agda b/src/Data/Product/Effectful/Left.agda
index 66362621ee..6fcfc7b266 100644
--- a/src/Data/Product/Effectful/Left.agda
+++ b/src/Data/Product/Effectful/Left.agda
@@ -18,7 +18,7 @@ open import Level
 module Data.Product.Effectful.Left
   {a e} (A : RawMonoid a e) (b : Level) where
 
-open import Data.Product
+open import Data.Product.Base
 import Data.Product.Effectful.Left.Base as Base
 open import Effect.Applicative using (RawApplicative)
 open import Effect.Monad using (RawMonad; RawMonadT; mkRawMonad)
@@ -49,7 +49,7 @@ monad = record
   }
 
 -- The monad instance also requires some mucking about with universe levels.
-monadT : RawMonadT (_∘′ Productₗ)
+monadT : ∀ {ℓ} → RawMonadT {g₁ = ℓ} (_∘′ Productₗ)
 monadT M = record
   { lift = (ε ,_) <$>_
   ; rawMonad = mkRawMonad _
diff --git a/src/Data/Product/Effectful/Left/Base.agda b/src/Data/Product/Effectful/Left/Base.agda
index d5b0b42c92..e3f7edef69 100644
--- a/src/Data/Product/Effectful/Left/Base.agda
+++ b/src/Data/Product/Effectful/Left/Base.agda
@@ -17,7 +17,7 @@ open import Level
 module Data.Product.Effectful.Left.Base
   {a} (A : Set a) (b : Level) where
 
-open import Data.Product using (_×_; map₂; proj₁; proj₂; <_,_>)
+open import Data.Product.Base using (_×_; map₂; proj₁; proj₂; <_,_>)
 open import Effect.Functor using (RawFunctor)
 open import Effect.Comonad using (RawComonad)
 
diff --git a/src/Data/Product/Effectful/Right.agda b/src/Data/Product/Effectful/Right.agda
index 640b4e908d..a10bbad006 100644
--- a/src/Data/Product/Effectful/Right.agda
+++ b/src/Data/Product/Effectful/Right.agda
@@ -18,7 +18,7 @@ open import Level
 module Data.Product.Effectful.Right
   (a : Level) {b e} (B : RawMonoid b e) where
 
-open import Data.Product
+open import Data.Product.Base
 import Data.Product.Effectful.Right.Base as Base
 open import Effect.Applicative using (RawApplicative)
 open import Effect.Monad using (RawMonad; RawMonadT; mkRawMonad)
@@ -48,7 +48,7 @@ monad = record
   ; _>>=_ = uncurry λ a w₁ f → map₂ (w₁ ∙_) (f a)
   }
 
-monadT : RawMonadT (_∘′ Productᵣ)
+monadT : ∀ {ℓ} → RawMonadT {g₁ = ℓ} (_∘′ Productᵣ)
 monadT M = record
   { lift = (_, ε) <$>_
   ; rawMonad = mkRawMonad _
diff --git a/src/Data/Product/Effectful/Right/Base.agda b/src/Data/Product/Effectful/Right/Base.agda
index 273185bf8e..556483f66f 100644
--- a/src/Data/Product/Effectful/Right/Base.agda
+++ b/src/Data/Product/Effectful/Right/Base.agda
@@ -17,7 +17,7 @@ open import Level
 module Data.Product.Effectful.Right.Base
   {b} (B : Set b) (a : Level) where
 
-open import Data.Product using (_×_; map₁; proj₁; proj₂; <_,_>)
+open import Data.Product.Base using (_×_; map₁; proj₁; proj₂; <_,_>)
 open import Effect.Functor using (RawFunctor)
 open import Effect.Comonad using (RawComonad)
 
diff --git a/src/Data/Product/Function/Dependent/Propositional.agda b/src/Data/Product/Function/Dependent/Propositional.agda
index d062e33d39..cb8a8d99a1 100644
--- a/src/Data/Product/Function/Dependent/Propositional.agda
+++ b/src/Data/Product/Function/Dependent/Propositional.agda
@@ -9,326 +9,310 @@
 
 module Data.Product.Function.Dependent.Propositional where
 
-open import Data.Product
-open import Data.Product.Function.NonDependent.Setoid
-open import Data.Product.Relation.Binary.Pointwise.NonDependent
-open import Relation.Binary hiding (_⇔_)
-open import Function.Base
-open import Function.Equality using (_⟶_; _⟨$⟩_)
-open import Function.Equivalence as Equiv using (_⇔_; module Equivalence)
-open import Function.HalfAdjointEquivalence using (↔→≃; _≃_)
-open import Function.Injection as Inj
-  using (Injective; _↣_; module Injection)
-open import Function.Inverse as Inv using (_↔_; module Inverse)
-open import Function.LeftInverse as LeftInv
-  using (_↞_; _LeftInverseOf_; module LeftInverse)
-open import Function.Related
-open import Function.Related.TypeIsomorphisms
-open import Function.Surjection as Surj using (_↠_; module Surjection)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Data.Product.Base as Product using (Σ; map; proj₂; _,_)
+open import Data.Product.Properties using (Σ-≡,≡→≡; Σ-≡,≡↔≡; Σ-≡,≡←≡)
+open import Level using (Level; 0ℓ)
+open import Function.Related.Propositional
+  using (_∼[_]_; module EquationalReasoning; K-reflexive;
+         implication; reverseImplication; equivalence; injection;
+         reverseInjection; leftInverse; surjection; bijection)
+open import Function.Base using (_$_; _∘_; _∘′_)
+open import Function.Properties.Inverse using (↔⇒↠; ↔⇒⟶; ↔⇒⟵; ↔-sym; ↔⇒↩)
+open import Function.Properties.RightInverse using (↩⇒↪; ↪⇒↩)
+open import Function.Properties.Inverse.HalfAdjointEquivalence
+  using (↔⇒≃; _≃_; ≃⇒↔)
+open import Function.Consequences.Propositional
+  using (inverseʳ⇒injective; strictlySurjective⇒surjective)
+open import Function.Definitions using (Inverseˡ; Inverseʳ; Injective; StrictlySurjective)
+open import Function.Bundles
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Binary.PropositionalEquality.Properties as ≡
+  using (module ≡-Reasoning)
+
+private
+  variable
+    i a b c d : Level
+    I J : Set i
+    A B : I → Set a
 
 ------------------------------------------------------------------------
--- Combinators for various function types
-
-module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
-         {b₁ b₂} {B₁ : A₁ → Set b₁} {B₂ : A₂ → Set b₂}
-         where
-
-  ⇔ : (A₁⇔A₂ : A₁ ⇔ A₂) →
-      (∀ {x} → B₁ x → B₂ (Equivalence.to   A₁⇔A₂ ⟨$⟩ x)) →
-      (∀ {y} → B₂ y → B₁ (Equivalence.from A₁⇔A₂ ⟨$⟩ y)) →
-      Σ A₁ B₁ ⇔ Σ A₂ B₂
-  ⇔ A₁⇔A₂ B-to B-from = Equiv.equivalence
-    (map (Equivalence.to   A₁⇔A₂ ⟨$⟩_) B-to)
-    (map (Equivalence.from A₁⇔A₂ ⟨$⟩_) B-from)
-
-  ⇔-↠ : ∀ (A₁↠A₂ : A₁ ↠ A₂) →
-        (∀ {x} → _⇔_ (B₁ x) (B₂ (Surjection.to A₁↠A₂ ⟨$⟩ x))) →
-        _⇔_ (Σ A₁ B₁) (Σ A₂ B₂)
-  ⇔-↠ A₁↠A₂ B₁⇔B₂ = Equiv.equivalence
-    (map (Surjection.to   A₁↠A₂ ⟨$⟩_) (Equivalence.to B₁⇔B₂ ⟨$⟩_))
-    (map (Surjection.from A₁↠A₂ ⟨$⟩_)
-       ((Equivalence.from B₁⇔B₂ ⟨$⟩_) ∘
-        P.subst B₂ (P.sym $ Surjection.right-inverse-of A₁↠A₂ _)))
+-- Functions
+
+module _ where
+  open Func
+
+  Σ-⟶ : (I⟶J : I ⟶ J) →
+         (∀ {i} → A i ⟶ B (to I⟶J i)) →
+         Σ I A ⟶ Σ J B
+  Σ-⟶ I⟶J A⟶B = mk⟶ $ Product.map (to I⟶J) (to A⟶B)
+
+------------------------------------------------------------------------
+-- Equivalences
+
+module _ where
+  open Surjection
+
+  Σ-⇔ : (I↠J : I ↠ J) →
+         (∀ {i} → A i ⇔ B (to I↠J i)) →
+         Σ I A ⇔ Σ J B
+  Σ-⇔ {B = B} I↠J A⇔B = mk⇔
+    (map (to  I↠J) (Equivalence.to A⇔B))
+    (map (to⁻ I↠J) (Equivalence.from A⇔B ∘ ≡.subst B (≡.sym (proj₂ (surjective I↠J _) ≡.refl))))
 
   -- See also Data.Product.Relation.Binary.Pointwise.Dependent.WithK.↣.
 
-  ↣ : ∀ (A₁↔A₂ : A₁ ↔ A₂) →
-      (∀ {x} → B₁ x ↣ B₂ (Inverse.to A₁↔A₂ ⟨$⟩ x)) →
-      Σ A₁ B₁ ↣ Σ A₂ B₂
-  ↣ A₁↔A₂ B₁↣B₂ = Inj.injection to to-injective
+------------------------------------------------------------------------
+-- Injections
+
+module _ where
+
+  Σ-↣ : (I↔J : I ↔ J) →
+         (∀ {i} → A i ↣ B (Inverse.to I↔J i)) →
+         Σ I A ↣ Σ J B
+  Σ-↣ {I = I} {J = J} {A = A} {B = B} I↔J A↣B = mk↣ to-injective
     where
-    open P.≡-Reasoning
+    open ≡.≡-Reasoning
 
-    A₁≃A₂ = ↔→≃ A₁↔A₂
+    I≃J = ↔⇒≃ I↔J
 
     subst-application′ :
-      let open _≃_ A₁≃A₂ in
-      {x₁ x₂ : A₁} {y : B₁ (from (to x₁))}
-      (g : ∀ x → B₁ (from (to x)) → B₂ (to x)) (eq : to x₁ ≡ to x₂) →
-      P.subst B₂ eq (g x₁ y) ≡ g x₂ (P.subst B₁ (P.cong from eq) y)
+      let open _≃_ I≃J in
+      {x₁ x₂ : I} {y : A (from (to x₁))}
+      (g : ∀ x → A (from (to x)) → B (to x))
+      (eq : to x₁ ≡ to x₂) →
+      ≡.subst B eq (g x₁ y) ≡ g x₂ (≡.subst A (≡.cong from eq) y)
     subst-application′ {x₁} {x₂} {y} g eq =
-      P.subst B₂ eq (g x₁ y)                      ≡⟨ P.cong (P.subst B₂ eq) (P.sym (g′-lemma _ _)) ⟩
-      P.subst B₂ eq (g′ (to x₁) y)                ≡⟨ P.subst-application B₁ g′ eq ⟩
-      g′ (to x₂) (P.subst B₁ (P.cong from eq) y)  ≡⟨ g′-lemma _ _ ⟩
-      g x₂ (P.subst B₁ (P.cong from eq) y)        ∎
+      ≡.subst B eq (g x₁ y)                      ≡⟨ ≡.cong (≡.subst B eq) (≡.sym (g′-lemma _ _)) ⟩
+      ≡.subst B eq (g′ (to x₁) y)                ≡⟨ ≡.subst-application A g′ eq ⟩
+      g′ (to x₂) (≡.subst A (≡.cong from eq) y)  ≡⟨ g′-lemma _ _ ⟩
+      g x₂ (≡.subst A (≡.cong from eq) y)        ∎
       where
-      open _≃_ A₁≃A₂
+      open _≃_ I≃J
 
-      g′ : ∀ x → B₁ (from x) → B₂ x
+      g′ : ∀ x → A (from x) → B x
       g′ x =
-        P.subst B₂ (right-inverse-of x) ∘
+        ≡.subst B (right-inverse-of x) ∘
         g (from x) ∘
-        P.subst B₁ (P.sym (P.cong from (right-inverse-of x)))
+        ≡.subst A (≡.sym (≡.cong from (right-inverse-of x)))
 
       g′-lemma : ∀ x y → g′ (to x) y ≡ g x y
       g′-lemma x y =
-        P.subst B₂ (right-inverse-of (to x))
+        ≡.subst B (right-inverse-of (to x))
           (g (from (to x)) $
-           P.subst B₁ (P.sym (P.cong from (right-inverse-of (to x)))) y)  ≡⟨ P.cong (λ p → P.subst B₂ p (g (from (to x))
-                                                                                                           (P.subst B₁ (P.sym (P.cong from p)) y)))
-                                                                               (P.sym (left-right x)) ⟩
-        P.subst B₂ (P.cong to (left-inverse-of x))
+           ≡.subst A (≡.sym (≡.cong from (right-inverse-of (to x)))) y)  ≡⟨ ≡.cong (λ p → ≡.subst B p (g (from (to x))
+                                                                                                           (≡.subst A (≡.sym (≡.cong from p)) y)))
+                                                                               (≡.sym (left-right x)) ⟩
+        ≡.subst B (≡.cong to (left-inverse-of x))
           (g (from (to x)) $
-           P.subst B₁
-             (P.sym (P.cong from (P.cong to (left-inverse-of x))))
+           ≡.subst A
+             (≡.sym (≡.cong from (≡.cong to (left-inverse-of x))))
              y)                                                           ≡⟨ lemma _ ⟩
 
         g x y                                                             ∎
         where
-        lemma :
-          ∀ {x′} eq {y : B₁ (from (to x′))} →
-          P.subst B₂ (P.cong to eq)
-            (g (from (to x))
-               (P.subst B₁ (P.sym (P.cong from (P.cong to eq))) y)) ≡
-          g x′ y
-        lemma P.refl = P.refl
+        lemma : ∀ {x′} eq {y : A (from (to x′))} →
+                  ≡.subst B (≡.cong to eq)
+                    (g (from (to x))
+                      (≡.subst A (≡.sym (≡.cong from (≡.cong to eq))) y)) ≡
+                  g x′ y
+        lemma ≡.refl = ≡.refl
 
-    to = map (_≃_.to A₁≃A₂) (Injection.to B₁↣B₂ ⟨$⟩_)
+    open Injection
 
-    to-injective : Injective (P.→-to-⟶ {B = P.setoid _} to)
+    to′ : Σ I A → Σ J B
+    to′ = Product.map (_≃_.to I≃J) (to A↣B)
+
+    to-injective : Injective _≡_ _≡_ to′
     to-injective {(x₁ , x₂)} {(y₁ , y₂)} =
+
       Σ-≡,≡→≡ ∘′
 
-      map (_≃_.injective A₁≃A₂) (λ {eq₁} eq₂ →
-
-        let lemma =
-
-              Injection.to B₁↣B₂ ⟨$⟩
-              P.subst B₁ (_≃_.injective A₁≃A₂ eq₁) x₂                     ≡⟨⟩
-
-              Injection.to B₁↣B₂ ⟨$⟩
-              P.subst B₁
-                (P.trans (P.sym (_≃_.left-inverse-of A₁≃A₂ x₁))
-                   (P.trans (P.cong (_≃_.from A₁≃A₂) eq₁)
-                      (P.trans (_≃_.left-inverse-of A₁≃A₂ y₁)
-                         P.refl)))
-                x₂                                                        ≡⟨ P.cong (λ p → Injection.to B₁↣B₂ ⟨$⟩
-                                                                                             P.subst B₁
-                                                                                               (P.trans (P.sym (_≃_.left-inverse-of A₁≃A₂ _))
-                                                                                                  (P.trans (P.cong (_≃_.from A₁≃A₂) eq₁) p))
-                                                                                               x₂)
-                                                                               (P.trans-reflʳ _) ⟩
-              Injection.to B₁↣B₂ ⟨$⟩
-              P.subst B₁
-                (P.trans (P.sym (_≃_.left-inverse-of A₁≃A₂ x₁))
-                   (P.trans (P.cong (_≃_.from A₁≃A₂) eq₁)
-                      (_≃_.left-inverse-of A₁≃A₂ y₁)))
-                x₂                                                        ≡⟨ P.cong (Injection.to B₁↣B₂ ⟨$⟩_)
-                                                                               (P.sym (P.subst-subst (P.sym (_≃_.left-inverse-of A₁≃A₂ _)))) ⟩
-              Injection.to B₁↣B₂ ⟨$⟩
-              (P.subst B₁ (P.trans (P.cong (_≃_.from A₁≃A₂) eq₁)
-                             (_≃_.left-inverse-of A₁≃A₂ y₁)) $
-               P.subst B₁ (P.sym (_≃_.left-inverse-of A₁≃A₂ x₁)) x₂)      ≡⟨ P.cong (Injection.to B₁↣B₂ ⟨$⟩_)
-                                                                               (P.sym (P.subst-subst (P.cong (_≃_.from A₁≃A₂) eq₁))) ⟩
-              Injection.to B₁↣B₂ ⟨$⟩
-              (P.subst B₁ (_≃_.left-inverse-of A₁≃A₂ y₁) $
-               P.subst B₁ (P.cong (_≃_.from A₁≃A₂) eq₁) $
-               P.subst B₁ (P.sym (_≃_.left-inverse-of A₁≃A₂ x₁)) x₂)      ≡⟨ P.sym (subst-application′
-                                                                                      (λ x y → Injection.to B₁↣B₂ ⟨$⟩
-                                                                                                 P.subst B₁ (_≃_.left-inverse-of A₁≃A₂ x) y)
+      map (_≃_.injective I≃J) (λ {eq₁} eq₂ → injective A↣B (
+              to A↣B (≡.subst A (_≃_.injective I≃J eq₁) x₂)             ≡⟨⟩
+
+              (let eq =
+                      ≡.trans (≡.sym (_≃_.left-inverse-of I≃J x₁))
+                        (≡.trans (≡.cong (_≃_.from I≃J) eq₁)
+                          (≡.trans (_≃_.left-inverse-of I≃J y₁)
+                            ≡.refl)) in
+              to A↣B (≡.subst A eq x₂))                                   ≡⟨ ≡.cong (λ p → to A↣B
+                                                                                             (≡.subst A
+                                                                                               (≡.trans (≡.sym (_≃_.left-inverse-of I≃J _))
+                                                                                                  (≡.trans (≡.cong (_≃_.from I≃J) eq₁) p))
+                                                                                               x₂))
+                                                                               (≡.trans-reflʳ _) ⟩
+
+              (let eq = ≡.trans (≡.sym (_≃_.left-inverse-of I≃J x₁))
+                          (≡.trans (≡.cong (_≃_.from I≃J) eq₁)
+                            (_≃_.left-inverse-of I≃J y₁)) in
+              to A↣B (≡.subst A eq x₂))                                  ≡⟨ ≡.cong (to A↣B)
+                                                                               (≡.sym (≡.subst-subst (≡.sym (_≃_.left-inverse-of I≃J _)))) ⟩
+
+              to A↣B ((≡.subst A (≡.trans (≡.cong (_≃_.from I≃J) eq₁)
+                             (_≃_.left-inverse-of I≃J y₁)) $
+               ≡.subst A (≡.sym (_≃_.left-inverse-of I≃J x₁)) x₂))      ≡⟨ ≡.cong (to A↣B)
+                                                                               (≡.sym (≡.subst-subst (≡.cong (_≃_.from I≃J) eq₁))) ⟩
+              to A↣B (
+              (≡.subst A (_≃_.left-inverse-of I≃J y₁) $
+               ≡.subst A (≡.cong (_≃_.from I≃J) eq₁) $
+               ≡.subst A (≡.sym (_≃_.left-inverse-of I≃J x₁)) x₂))      ≡⟨ ≡.sym (subst-application′
+                                                                                      (λ x y → to A↣B
+                                                                                                 (≡.subst A (_≃_.left-inverse-of I≃J x) y))
                                                                                       eq₁) ⟩
-              P.subst B₂ eq₁
-                (Injection.to B₁↣B₂ ⟨$⟩
-                 (P.subst B₁ (_≃_.left-inverse-of A₁≃A₂ x₁) $
-                  P.subst B₁ (P.sym (_≃_.left-inverse-of A₁≃A₂ x₁)) x₂))  ≡⟨ P.cong (P.subst B₂ eq₁ ∘ (Injection.to B₁↣B₂ ⟨$⟩_))
-                                                                               (P.subst-subst (P.sym (_≃_.left-inverse-of A₁≃A₂ _))) ⟩
-              P.subst B₂ eq₁
-                (Injection.to B₁↣B₂ ⟨$⟩
-                 P.subst B₁
-                   (P.trans (P.sym (_≃_.left-inverse-of A₁≃A₂ x₁))
-                      (_≃_.left-inverse-of A₁≃A₂ x₁))
-                   x₂)                                                    ≡⟨ P.cong (λ p → P.subst B₂ eq₁
-                                                                                             (Injection.to B₁↣B₂ ⟨$⟩ P.subst B₁ p x₂))
-                                                                               (P.trans-symˡ (_≃_.left-inverse-of A₁≃A₂ _)) ⟩
-              P.subst B₂ eq₁
-                (Injection.to B₁↣B₂ ⟨$⟩ P.subst B₁ P.refl x₂)             ≡⟨⟩
-
-              P.subst B₂ eq₁ (Injection.to B₁↣B₂ ⟨$⟩ x₂)                  ≡⟨ eq₂ ⟩
-
-              Injection.to B₁↣B₂ ⟨$⟩ y₂                                   ∎
-
-        in
-
-        P.subst B₁ (_≃_.injective A₁≃A₂ eq₁) x₂  ≡⟨ Injection.injective B₁↣B₂ lemma ⟩
-        y₂                                       ∎) ∘
+              ≡.subst B eq₁ (to A↣B $
+                 (≡.subst A (_≃_.left-inverse-of I≃J x₁) $
+                  ≡.subst A (≡.sym (_≃_.left-inverse-of I≃J x₁)) x₂))  ≡⟨ ≡.cong (≡.subst B eq₁ ∘ to A↣B)
+                                                                               (≡.subst-subst (≡.sym (_≃_.left-inverse-of I≃J _))) ⟩
+
+              (let eq = ≡.trans (≡.sym (_≃_.left-inverse-of I≃J x₁))
+                          (_≃_.left-inverse-of I≃J x₁) in
+              ≡.subst B eq₁ (to A↣B (≡.subst A eq x₂)))                  ≡⟨ ≡.cong (λ p → ≡.subst B eq₁ (to A↣B (≡.subst A p x₂)))
+                                                                              (≡.trans-symˡ (_≃_.left-inverse-of I≃J _)) ⟩
+              ≡.subst B eq₁ (to A↣B (≡.subst A ≡.refl x₂))               ≡⟨⟩
+
+              ≡.subst B eq₁ (to A↣B x₂)                                  ≡⟨ eq₂ ⟩
+
+              to A↣B y₂                                                  ∎
+
+        )) ∘
 
       Σ-≡,≡←≡
 
-  ↞ : (A₁↞A₂ : A₁ ↞ A₂) →
-      (∀ {x} → B₁ (LeftInverse.from A₁↞A₂ ⟨$⟩ x) ↞ B₂ x) →
-      Σ A₁ B₁ ↞ Σ A₂ B₂
-  ↞ A₁↞A₂ B₁↞B₂ = record
-    { to              = P.→-to-⟶ to
-    ; from            = P.→-to-⟶ from
-    ; left-inverse-of = left-inverse-of
-    }
+------------------------------------------------------------------------
+-- Surjections
+
+module _ where
+  open Surjection
+
+  Σ-↠ : (I↠J : I ↠ J) →
+       (∀ {x} → A x ↠ B (to I↠J x)) →
+       Σ I A ↠ Σ J B
+  Σ-↠ {I = I} {J = J} {A = A} {B = B} I↠J A↠B =
+    mk↠ₛ strictlySurjective′
     where
-    open P.≡-Reasoning
+    to′ : Σ I A → Σ J B
+    to′ = map (to I↠J) (to A↠B)
 
-    from = map (LeftInverse.from A₁↞A₂ ⟨$⟩_) (LeftInverse.from B₁↞B₂ ⟨$⟩_)
+    backcast : ∀ {i} → B i → B (to I↠J (to⁻ I↠J i))
+    backcast = ≡.subst B (≡.sym (to∘to⁻ I↠J _))
 
-    to   = map
-      (LeftInverse.to A₁↞A₂ ⟨$⟩_)
-      (λ {x} y →
-         LeftInverse.to B₁↞B₂ ⟨$⟩
-           P.subst B₁ (P.sym (LeftInverse.left-inverse-of A₁↞A₂ x)) y)
+    to⁻′ : Σ J B → Σ I A
+    to⁻′ = map (to⁻ I↠J) (Surjection.to⁻ A↠B ∘ backcast)
 
-    left-inverse-of : ∀ p → from (to p) ≡ p
-    left-inverse-of (x , y) = Σ-≡,≡→≡
-      ( LeftInverse.left-inverse-of A₁↞A₂ x
-      , (P.subst B₁ (LeftInverse.left-inverse-of A₁↞A₂ x)
-           (LeftInverse.from B₁↞B₂ ⟨$⟩ (LeftInverse.to B₁↞B₂ ⟨$⟩
-              (P.subst B₁ (P.sym (LeftInverse.left-inverse-of A₁↞A₂ x))
-                 y)))                                                    ≡⟨ P.cong (P.subst B₁ _) (LeftInverse.left-inverse-of B₁↞B₂ _) ⟩
+    strictlySurjective′ : StrictlySurjective _≡_ to′
+    strictlySurjective′ (x , y) = to⁻′ (x , y) , Σ-≡,≡→≡
+      ( to∘to⁻ I↠J x
+      , (≡.subst B (to∘to⁻ I↠J x) (to A↠B (to⁻ A↠B (backcast y))) ≡⟨ ≡.cong (≡.subst B _) (to∘to⁻ A↠B _) ⟩
+         ≡.subst B (to∘to⁻ I↠J x) (backcast y)                      ≡⟨ ≡.subst-subst-sym (to∘to⁻ I↠J x) ⟩
+         y                                                          ∎)
+      ) where open ≡.≡-Reasoning
 
-         P.subst B₁ (LeftInverse.left-inverse-of A₁↞A₂ x)
-           (P.subst B₁ (P.sym (LeftInverse.left-inverse-of A₁↞A₂ x))
-              y)                                                         ≡⟨ P.subst-subst-sym (LeftInverse.left-inverse-of A₁↞A₂ x) ⟩
 
-         y                                                               ∎)
-      )
+------------------------------------------------------------------------
+-- Left inverses
+
+module _ where
+  open LeftInverse
 
-  ↠ : (A₁↠A₂ : A₁ ↠ A₂) →
-      (∀ {x} → B₁ x ↠ B₂ (Surjection.to A₁↠A₂ ⟨$⟩ x)) →
-      Σ A₁ B₁ ↠ Σ A₂ B₂
-  ↠ A₁↠A₂ B₁↠B₂ = record
-    { to         = P.→-to-⟶ to
-    ; surjective = record
-      { from             = P.→-to-⟶ from
-      ; right-inverse-of = right-inverse-of
-      }
-    }
+  Σ-↩ : (I↩J : I ↩ J) →
+         (∀ {i} → A i ↩ B (to I↩J i)) →
+         Σ I A ↩ Σ J B
+  Σ-↩ {I = I} {J = J} {A = A} {B = B} I↩J A↩B = mk↩ {to = to′ } {from = from′} inv
     where
-    open P.≡-Reasoning
-
-    to   = map (Surjection.to A₁↠A₂ ⟨$⟩_)
-                    (Surjection.to B₁↠B₂ ⟨$⟩_)
-    from = map
-      (Surjection.from A₁↠A₂ ⟨$⟩_)
-      (λ {x} y →
-         Surjection.from B₁↠B₂ ⟨$⟩
-           P.subst B₂ (P.sym (Surjection.right-inverse-of A₁↠A₂ x)) y)
-
-    right-inverse-of : ∀ p → to (from p) ≡ p
-    right-inverse-of (x , y) = Σ-≡,≡→≡
-      ( Surjection.right-inverse-of A₁↠A₂ x
-      , (P.subst B₂ (Surjection.right-inverse-of A₁↠A₂ x)
-           (Surjection.to B₁↠B₂ ⟨$⟩ (Surjection.from B₁↠B₂ ⟨$⟩
-              (P.subst B₂ (P.sym (Surjection.right-inverse-of A₁↠A₂ x))
-                 y)))                                                    ≡⟨ P.cong (P.subst B₂ _) (Surjection.right-inverse-of B₁↠B₂ _) ⟩
-
-         P.subst B₂ (Surjection.right-inverse-of A₁↠A₂ x)
-           (P.subst B₂ (P.sym (Surjection.right-inverse-of A₁↠A₂ x))
-              y)                                                         ≡⟨ P.subst-subst-sym (Surjection.right-inverse-of A₁↠A₂ x) ⟩
-
-         y                                                               ∎)
-      )
+    to′ : Σ I A → Σ J B
+    to′ = map (to I↩J) (to A↩B)
+
+    backcast : ∀ {j} → B j → B (to I↩J (from I↩J j))
+    backcast = ≡.subst B (≡.sym (inverseˡ I↩J ≡.refl))
 
-  ↔ : (A₁↔A₂ : A₁ ↔ A₂) →
-      (∀ {x} → B₁ x ↔ B₂ (Inverse.to A₁↔A₂ ⟨$⟩ x)) →
-      Σ A₁ B₁ ↔ Σ A₂ B₂
-  ↔ A₁↔A₂ B₁↔B₂ = Inv.inverse
-    (Surjection.to   surjection′ ⟨$⟩_)
-    (Surjection.from surjection′ ⟨$⟩_)
+    from′ : Σ J B → Σ I A
+    from′ = map (from I↩J) (from A↩B ∘ backcast)
+
+    inv : Inverseˡ _≡_ _≡_ to′ from′
+    inv {j , b} ≡.refl = Σ-≡,≡→≡ (strictlyInverseˡ I↩J j  , (
+      begin
+        ≡.subst B (inverseˡ I↩J ≡.refl) (to A↩B (from A↩B (backcast b))) ≡⟨ ≡.cong (≡.subst B _) (inverseˡ A↩B ≡.refl) ⟩
+        ≡.subst B (inverseˡ I↩J ≡.refl) (backcast b)                       ≡⟨ ≡.subst-subst-sym (inverseˡ I↩J _) ⟩
+        b                                                                  ∎)) where open ≡.≡-Reasoning
+
+------------------------------------------------------------------------
+-- Right inverses
+
+------------------------------------------------------------------------
+-- Inverses
+
+module _ where
+  open Inverse
+
+  Σ-↔ : (I↔J : I ↔ J) →
+      (∀ {x} → A x ↔ B (to I↔J x)) →
+      Σ I A ↔ Σ J B
+  Σ-↔ {I = I} {J = J} {A = A} {B = B} I↔J A↔B = mk↔ₛ′
+    (Surjection.to surjection′)
+    (Surjection.to⁻ surjection′)
+    (Surjection.to∘to⁻ surjection′)
     left-inverse-of
-    (Surjection.right-inverse-of surjection′)
     where
-    open P.≡-Reasoning
-
-    A₁≃A₂ = ↔→≃ A₁↔A₂
-
-    surjection′ : _↠_ (Σ A₁ B₁) (Σ A₂ B₂)
-    surjection′ =
-      ↠ (Inverse.surjection (_≃_.inverse A₁≃A₂))
-        (Inverse.surjection B₁↔B₂)
-
-    left-inverse-of :
-      ∀ p → Surjection.from surjection′ ⟨$⟩
-              (Surjection.to surjection′ ⟨$⟩ p) ≡ p
-    left-inverse-of (x , y) = Σ-≡,≡→≡
-      ( _≃_.left-inverse-of A₁≃A₂ x
-      , (P.subst B₁ (_≃_.left-inverse-of A₁≃A₂ x)
-           (Inverse.from B₁↔B₂ ⟨$⟩
-              (P.subst B₂ (P.sym (_≃_.right-inverse-of A₁≃A₂
-                                    (_≃_.to A₁≃A₂ x)))
-                 (Inverse.to B₁↔B₂ ⟨$⟩ y)))                   ≡⟨ P.subst-application B₂ (λ _ → Inverse.from B₁↔B₂ ⟨$⟩_) _ ⟩
-
-         Inverse.from B₁↔B₂ ⟨$⟩
-           (P.subst B₂ (P.cong (_≃_.to A₁≃A₂)
-                          (_≃_.left-inverse-of A₁≃A₂ x))
-              (P.subst B₂ (P.sym (_≃_.right-inverse-of A₁≃A₂
-                                    (_≃_.to A₁≃A₂ x)))
-                 (Inverse.to B₁↔B₂ ⟨$⟩ y)))                   ≡⟨ P.cong (λ eq → Inverse.from B₁↔B₂ ⟨$⟩ P.subst B₂ eq
-                                                                                  (P.subst B₂ (P.sym (_≃_.right-inverse-of A₁≃A₂ _)) _))
-                                                                   (_≃_.left-right A₁≃A₂ _) ⟩
-         Inverse.from B₁↔B₂ ⟨$⟩
-           (P.subst B₂ (_≃_.right-inverse-of A₁≃A₂
-                          (_≃_.to A₁≃A₂ x))
-              (P.subst B₂ (P.sym (_≃_.right-inverse-of A₁≃A₂
-                                    (_≃_.to A₁≃A₂ x)))
-                 (Inverse.to B₁↔B₂ ⟨$⟩ y)))                   ≡⟨ P.cong (Inverse.from B₁↔B₂ ⟨$⟩_)
-                                                                   (P.subst-subst-sym (_≃_.right-inverse-of A₁≃A₂ _)) ⟩
-
-         Inverse.from B₁↔B₂ ⟨$⟩ (Inverse.to B₁↔B₂ ⟨$⟩ y)      ≡⟨ Inverse.left-inverse-of B₁↔B₂ _ ⟩
+    open ≡.≡-Reasoning
+
+    I≃J = ↔⇒≃ I↔J
+
+    surjection′ : Σ I A ↠ Σ J B
+    surjection′ = Σ-↠ (↔⇒↠ (≃⇒↔ I≃J)) (↔⇒↠ A↔B)
+
+    left-inverse-of : ∀ p → Surjection.to⁻ surjection′ (Surjection.to surjection′ p) ≡ p
+    left-inverse-of (x , y) = to Σ-≡,≡↔≡
+      ( _≃_.left-inverse-of I≃J x
+      , (≡.subst A (_≃_.left-inverse-of I≃J x)
+           (from A↔B
+              (≡.subst B (≡.sym (_≃_.right-inverse-of I≃J
+                                    (_≃_.to I≃J x)))
+                 (to A↔B y)))                   ≡⟨ ≡.subst-application B (λ _ → from A↔B) _ ⟩
+
+         from A↔B
+           (≡.subst B (≡.cong (_≃_.to I≃J)
+                          (_≃_.left-inverse-of I≃J x))
+              (≡.subst B (≡.sym (_≃_.right-inverse-of I≃J
+                                    (_≃_.to I≃J x)))
+                 (to A↔B y)))                   ≡⟨ ≡.cong (λ eq → from A↔B (≡.subst B eq
+                                                                                  (≡.subst B (≡.sym (_≃_.right-inverse-of I≃J _)) _)))
+                                                                   (_≃_.left-right I≃J _) ⟩
+         from A↔B
+           (≡.subst B (_≃_.right-inverse-of I≃J
+                          (_≃_.to I≃J x))
+              (≡.subst B (≡.sym (_≃_.right-inverse-of I≃J
+                                    (_≃_.to I≃J x)))
+                 (to A↔B y)))                   ≡⟨ ≡.cong (from A↔B)
+                                                                   (≡.subst-subst-sym (_≃_.right-inverse-of I≃J _)) ⟩
+
+         from A↔B (to A↔B y)      ≡⟨ Inverse.strictlyInverseʳ A↔B _ ⟩
 
          y                                                    ∎)
       )
 
-private
 
-  swap-coercions : ∀ {k a₁ a₂ b₁ b₂} {A₁ : Set a₁} {A₂ : Set a₂}
-    {B₁ : A₁ → Set b₁} (B₂ : A₂ → Set b₂)
-    (A₁↔A₂ : _↔_ A₁ A₂) →
-    (∀ {x} → B₁ x ∼[ k ] B₂ (Inverse.to A₁↔A₂ ⟨$⟩ x)) →
-    ∀ {x} → B₁ (Inverse.from A₁↔A₂ ⟨$⟩ x) ∼[ k ] B₂ x
-  swap-coercions {k} {B₁ = B₁} B₂ A₁↔A₂ eq {x} =
-    B₁ (Inverse.from A₁↔A₂ ⟨$⟩ x)
-      ∼⟨ eq ⟩
-    B₂ (Inverse.to A₁↔A₂ ⟨$⟩ (Inverse.from A₁↔A₂ ⟨$⟩ x))
-      ↔⟨ K-reflexive
-         (P.cong B₂ $ Inverse.right-inverse-of A₁↔A₂ x) ⟩
-    B₂ x
-      ∎
+private module _ where
+  open Inverse
+
+  swap-coercions : ∀ {k} (B : J → Set b)
+    (I↔J : _↔_ I J) →
+    (∀ {x} → A x ∼[ k ] B (to I↔J x)) →
+    ∀ {x} → A (from I↔J x) ∼[ k ] B x
+  swap-coercions {A = A} B I↔J eq {x} =
+    A (from I↔J x)           ∼⟨ eq ⟩
+    B (to I↔J (from I↔J x)) ↔⟨ K-reflexive (≡.cong B $ strictlyInverseˡ I↔J x) ⟩
+    B x                       ∎
     where open EquationalReasoning
 
-cong : ∀ {k a₁ a₂ b₁ b₂}
-         {A₁ : Set a₁} {A₂ : Set a₂}
-         {B₁ : A₁ → Set b₁} {B₂ : A₂ → Set b₂}
-       (A₁↔A₂ : _↔_ A₁ A₂) →
-       (∀ {x} → B₁ x ∼[ k ] B₂ (Inverse.to A₁↔A₂ ⟨$⟩ x)) →
-       Σ A₁ B₁ ∼[ k ] Σ A₂ B₂
-cong {implication}                   =
-  λ A₁↔A₂ → map (_⟨$⟩_ (Inverse.to A₁↔A₂))
-cong {reverse-implication} {B₂ = B₂} =
-  λ A₁↔A₂ B₁←B₂ → lam (map (_⟨$⟩_ (Inverse.from A₁↔A₂))
-    (app-← (swap-coercions B₂ A₁↔A₂ B₁←B₂)))
-cong {equivalence}                   = ⇔-↠ ∘ Inverse.surjection
-cong {injection}                     = ↣
-cong {reverse-injection}   {B₂ = B₂} =
-  λ A₁↔A₂ B₁↢B₂ → lam (↣ (Inv.sym A₁↔A₂)
-    (app-↢ (swap-coercions B₂ A₁↔A₂ B₁↢B₂)))
-cong {left-inverse}                  =
-  λ A₁↔A₂ → ↞ (Inverse.left-inverse A₁↔A₂) ∘ swap-coercions _ A₁↔A₂
-cong {surjection}                    = ↠ ∘ Inverse.surjection
-cong {bijection}                     = ↔
+
+cong : ∀ {k} (I↔J : I ↔ J) →
+       (∀ {x} → A x ∼[ k ] B (Inverse.to I↔J x)) →
+       Σ I A ∼[ k ] Σ J B
+cong {k = implication}                I↔J A⟶B = Σ-⟶ (↔⇒⟶ I↔J) A⟶B
+cong {B = B} {k = reverseImplication} I↔J A⟵B = Σ-⟶ (↔⇒⟵ I↔J) (swap-coercions {k = reverseImplication} B I↔J A⟵B)
+cong {k = equivalence}                I↔J A⇔B = Σ-⇔ (↔⇒↠ I↔J) A⇔B
+cong {k = injection}                  I↔J A↣B = Σ-↣ I↔J A↣B
+cong {B = B} {k = reverseInjection}   I↔J A↢B = Σ-↣ (↔-sym I↔J) (swap-coercions {k = reverseInjection} B I↔J A↢B)
+cong {B = B} {k = leftInverse}        I↔J A↩B = ↩⇒↪ (Σ-↩ (↔⇒↩ (↔-sym I↔J)) (↪⇒↩ (swap-coercions {k = leftInverse} B I↔J A↩B)))
+cong {k = surjection}                 I↔J A↠B = Σ-↠ (↔⇒↠ I↔J) A↠B
+cong {k = bijection}                  I↔J A↔B = Σ-↔ I↔J A↔B
diff --git a/src/Data/Product/Function/Dependent/Propositional/WithK.agda b/src/Data/Product/Function/Dependent/Propositional/WithK.agda
index 0b3838e12f..0e0f63268b 100644
--- a/src/Data/Product/Function/Dependent/Propositional/WithK.agda
+++ b/src/Data/Product/Function/Dependent/Propositional/WithK.agda
@@ -9,30 +9,40 @@
 
 module Data.Product.Function.Dependent.Propositional.WithK where
 
-open import Data.Product
-open import Data.Product.Function.Dependent.Setoid
+open import Data.Product.Base
+open import Data.Product.Properties
+open import Data.Product.Function.Dependent.Setoid using (injection)
 open import Data.Product.Relation.Binary.Pointwise.Dependent
 open import Data.Product.Relation.Binary.Pointwise.Dependent.WithK
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Injection as Inj using (_↣_; module Injection)
-open import Function.Inverse as Inv using (_↔_; module Inverse)
-import Relation.Binary.HeterogeneousEquality as H
+open import Relation.Binary.Indexed.Heterogeneous.Construct.At using (_atₛ_)
+open import Relation.Binary.HeterogeneousEquality as H
+open import Level using (Level)
+open import Function
+open import Function.Properties.Injection
+open import Function.Properties.Inverse as Inverse
+
+private
+  variable
+    i a : Level
+    I J : Set i
+    A B : I → Set a
 
 ------------------------------------------------------------------------
 -- Combinator for Injection
 
-module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
-         {b₁ b₂} {B₁ : A₁ → Set b₁} {B₂ : A₂ → Set b₂}
-         where
+module _ where
+  open Injection
 
-  ↣ : ∀ (A₁↣A₂ : A₁ ↣ A₂) →
-      (∀ {x} → B₁ x ↣ B₂ (Injection.to A₁↣A₂ ⟨$⟩ x)) →
-      Σ A₁ B₁ ↣ Σ A₂ B₂
-  ↣ A₁↣A₂ B₁↣B₂ =
-    Inverse.injection Pointwise-≡↔≡ ⟨∘⟩
-    injection (H.indexedSetoid B₂) A₁↣A₂
-      (Inverse.injection (H.≡↔≅ B₂) ⟨∘⟩
-       B₁↣B₂ ⟨∘⟩
-       Inverse.injection (Inv.sym (H.≡↔≅ B₁))) ⟨∘⟩
-    Inverse.injection (Inv.sym Pointwise-≡↔≡)
-    where open Inj using () renaming (_∘_ to _⟨∘⟩_)
+  Σ-↣ : (I↣J : I ↣ J) →
+         (∀ {i} → A i ↣ B (to I↣J i)) →
+         Σ I A ↣ Σ J B
+  Σ-↣ {A = A} {B = B} I↣J A↣B =
+    ↣-trans (Inverse⇒Injection (Inverse.sym Pointwise-≡↔≡)) $
+      ↣-trans (injection I↣J Aᵢ↣Bᵢ) $
+        Inverse⇒Injection Pointwise-≡↔≡
+    where
+    Aᵢ↣Bᵢ : (∀ {i} → Injection (H.indexedSetoid A atₛ i) (H.indexedSetoid B atₛ (Injection.to I↣J i)))
+    Aᵢ↣Bᵢ =
+      ↣-trans (Inverse⇒Injection (Inverse.sym (H.≡↔≅ A))) $
+        ↣-trans A↣B $
+          Inverse⇒Injection (H.≡↔≅ B)
diff --git a/src/Data/Product/Function/Dependent/Setoid.agda b/src/Data/Product/Function/Dependent/Setoid.agda
index f6629e048a..0ad3785ed7 100644
--- a/src/Data/Product/Function/Dependent/Setoid.agda
+++ b/src/Data/Product/Function/Dependent/Setoid.agda
@@ -2,196 +2,253 @@
 -- The Agda standard library
 --
 -- Dependent product combinators for setoid equality preserving
--- functions
+-- functions.
+--
+-- NOTE: the first component of the equality is propositional equality.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Data.Product.Function.Dependent.Setoid where
 
-open import Data.Product
-open import Data.Product.Relation.Binary.Pointwise.Dependent
-open import Function.Base
-open import Function.Equality as F using (_⟶_; _⟨$⟩_)
-open import Function.Equivalence as Eq
-  using (Equivalence; _⇔_; module Equivalence)
-open import Function.Injection as Inj
-  using (Injection; Injective; _↣_; module Injection)
-open import Function.Inverse as Inv
-  using (Inverse; _↔_; module Inverse)
-open import Function.LeftInverse as LeftInv
-  using (LeftInverse; _↞_; _LeftInverseOf_; _RightInverseOf_; module LeftInverse)
-open import Function.Surjection as Surj
-  using (Surjection; _↠_; module Surjection)
-open import Relation.Binary as B hiding (_⇔_)
+open import Data.Product.Base using (map; _,_; proj₁; proj₂)
+open import Data.Product.Relation.Binary.Pointwise.Dependent as Σ
+open import Level using (Level)
+open import Function
+open import Function.Consequences.Setoid
+open import Function.Properties.Injection using (mkInjection)
+open import Function.Properties.Surjection using (mkSurjection; ↠⇒⇔)
+open import Function.Properties.Equivalence using (mkEquivalence; ⇔⇒⟶; ⇔⇒⟵)
+open import Function.Properties.RightInverse using (mkRightInverse)
+open import Relation.Binary.Core using (_=[_]⇒_)
+open import Relation.Binary.Bundles as B
 open import Relation.Binary.Indexed.Heterogeneous
   using (IndexedSetoid)
 open import Relation.Binary.Indexed.Heterogeneous.Construct.At
   using (_atₛ_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
+
+private
+  variable
+    i a b ℓ₁ ℓ₂ : Level
+    I J : Set i
+    A B : IndexedSetoid I a ℓ₁
 
 ------------------------------------------------------------------------
 -- Properties related to "relatedness"
 ------------------------------------------------------------------------
 
+private module _ (A : IndexedSetoid I a ℓ₁) where
+  open IndexedSetoid A
+
+  cast : ∀ {i j} → j ≡ i → Carrier i → Carrier j
+  cast j≡i = ≡.subst Carrier (≡.sym $ j≡i)
+
+  cast-cong : ∀ {i j} {x y : Carrier i}
+               (j≡i : j ≡ i) →
+               x ≈ y →
+               cast j≡i x ≈ cast j≡i y
+  cast-cong ≡.refl p = p
+
+  cast-eq : ∀ {i j x} (eq : i ≡ j) → cast eq x ≈ x
+  cast-eq ≡.refl = IndexedSetoid.refl A
+
 private
+  _×ₛ_ : (I : Set i) → IndexedSetoid I a ℓ₁ → Setoid _ _
+  I ×ₛ A = Σ.setoid (≡.setoid I) A
 
-  subst-cong : ∀ {i a p} {I : Set i} {A : I → Set a}
-               (P : ∀ {i} → A i → A i → Set p) {i i′} {x y : A i}
-               (i≡i′ : i ≡ i′) →
-               P x y → P (P.subst A i≡i′ x) (P.subst A i≡i′ y)
-  subst-cong P P.refl p = p
-
-⟶ : ∀ {a₁ a₂ b₁ b₁′ b₂ b₂′}
-      {A₁ : Set a₁} {A₂ : Set a₂}
-      {B₁ : IndexedSetoid A₁ b₁ b₁′} (B₂ : IndexedSetoid A₂ b₂ b₂′)
-    (f : A₁ → A₂) → (∀ {x} → (B₁ atₛ x) ⟶ (B₂ atₛ (f x))) →
-    setoid (P.setoid A₁) B₁ ⟶ setoid (P.setoid A₂) B₂
-⟶ {A₁ = A₁} {A₂} {B₁} B₂ f g = record
-  { _⟨$⟩_ = fg
-  ; cong  = fg-cong
-  }
-  where
-  open B.Setoid (setoid (P.setoid A₁) B₁)
-    using () renaming (_≈_ to _≈₁_)
-  open B.Setoid (setoid (P.setoid A₂) B₂)
-    using () renaming (_≈_ to _≈₂_)
-  open B using (_=[_]⇒_)
-
-  fg = map f (_⟨$⟩_ g)
-
-  fg-cong : _≈₁_ =[ fg ]⇒ _≈₂_
-  fg-cong (P.refl , ∼) = (P.refl , F.cong g ∼)
-
-
-module _ {a₁ a₂ b₁ b₁′ b₂ b₂′} {A₁ : Set a₁} {A₂ : Set a₂} where
-
-  equivalence : {B₁ : IndexedSetoid A₁ b₁ b₁′} {B₂ : IndexedSetoid A₂ b₂ b₂′}
-    (A₁⇔A₂ : A₁ ⇔ A₂) →
-    (∀ {x} → _⟶_ (B₁ atₛ x) (B₂ atₛ (Equivalence.to   A₁⇔A₂ ⟨$⟩ x))) →
-    (∀ {y} → _⟶_ (B₂ atₛ y) (B₁ atₛ (Equivalence.from A₁⇔A₂ ⟨$⟩ y))) →
-    Equivalence (setoid (P.setoid A₁) B₁) (setoid (P.setoid A₂) B₂)
-  equivalence {B₁} {B₂} A₁⇔A₂ B-to B-from = record
-    { to   = ⟶ B₂ (_⟨$⟩_ (to   A₁⇔A₂)) B-to
-    ; from = ⟶ B₁ (_⟨$⟩_ (from A₁⇔A₂)) B-from
-    } where open Equivalence
-
-  equivalence-↞ : (B₁ : IndexedSetoid A₁ b₁ b₁′) {B₂ : IndexedSetoid A₂ b₂ b₂′}
-    (A₁↞A₂ : A₁ ↞ A₂) →
-    (∀ {x} → Equivalence (B₁ atₛ (LeftInverse.from A₁↞A₂ ⟨$⟩ x))
-                         (B₂ atₛ x)) →
-    Equivalence (setoid (P.setoid A₁) B₁) (setoid (P.setoid A₂) B₂)
-  equivalence-↞ B₁ {B₂} A₁↞A₂ B₁⇔B₂ =
-    equivalence (LeftInverse.equivalence A₁↞A₂) B-to B-from
+------------------------------------------------------------------------
+-- Functions
+
+module _ where
+  open Func
+  open Setoid
+
+  function :
+    (f : I ⟶ J) →
+    (∀ {i} → Func (A atₛ i) (B atₛ (to f i))) →
+    Func (I ×ₛ A) (J ×ₛ B)
+  function {I = I} {J = J} {A = A} {B = B} I⟶J A⟶B = record
+    { to    = to′
+    ; cong  = cong′
+    }
     where
-    B-to : ∀ {x} → _⟶_ (B₁ atₛ x) (B₂ atₛ (LeftInverse.to A₁↞A₂ ⟨$⟩ x))
-    B-to = record
-      { _⟨$⟩_ = λ x → Equivalence.to B₁⇔B₂ ⟨$⟩
-                      P.subst (IndexedSetoid.Carrier B₁)
-                         (P.sym $ LeftInverse.left-inverse-of A₁↞A₂ _)
-                         x
-      ; cong  = F.cong (Equivalence.to B₁⇔B₂) ∘
-              subst-cong (λ {x} → IndexedSetoid._≈_ B₁ {x} {x})
-                         (P.sym (LeftInverse.left-inverse-of A₁↞A₂ _))
-      }
+    to′ = map (to I⟶J) (to A⟶B)
+
+    cong′ : Congruent (_≈_ (I ×ₛ A)) (_≈_ (J ×ₛ B)) to′
+    cong′ (≡.refl , ∼) = (≡.refl , cong A⟶B ∼)
 
-    B-from : ∀ {y} → _⟶_ (B₂ atₛ y) (B₁ atₛ (LeftInverse.from A₁↞A₂ ⟨$⟩ y))
-    B-from = Equivalence.from B₁⇔B₂
+------------------------------------------------------------------------
+-- Equivalences
+
+module _ where
+  open Equivalence
+
+  equivalence :
+    (I⇔J : I ⇔ J) →
+    (∀ {i} → Func (A atₛ i) (B atₛ (to   I⇔J i))) →
+    (∀ {j} → Func (B atₛ j) (A atₛ (from I⇔J j))) →
+    Equivalence (I ×ₛ A) (J ×ₛ B)
+  equivalence I⇔J A⟶B B⟶A = mkEquivalence
+    (function (⇔⇒⟶ I⇔J) A⟶B)
+    (function (⇔⇒⟵ I⇔J) B⟶A)
+
+  equivalence-↪ :
+    (I↪J : I ↪ J) →
+    (∀ {i} → Equivalence (A atₛ (RightInverse.from I↪J i)) (B atₛ i)) →
+    Equivalence (I ×ₛ A) (J ×ₛ B)
+  equivalence-↪ {A = A} {B = B} I↪J A⇔B =
+    equivalence (RightInverse.equivalence I↪J) A→B (fromFunction A⇔B)
+    where
+    A→B : ∀ {i} → Func (A atₛ i) (B atₛ (RightInverse.to I↪J i))
+    A→B = record
+      { to   = to      A⇔B ∘ cast      A (RightInverse.strictlyInverseʳ I↪J _)
+      ; cong = to-cong A⇔B ∘ cast-cong A (RightInverse.strictlyInverseʳ I↪J _)
+      }
 
-  equivalence-↠ : {B₁ : IndexedSetoid A₁ b₁ b₁′} (B₂ : IndexedSetoid A₂ b₂ b₂′)
-    (A₁↠A₂ : A₁ ↠ A₂) →
-    (∀ {x} → Equivalence (B₁ atₛ x) (B₂ atₛ (Surjection.to A₁↠A₂ ⟨$⟩ x))) →
-    Equivalence (setoid (P.setoid A₁) B₁) (setoid (P.setoid A₂) B₂)
-  equivalence-↠ {B₁ = B₁} B₂ A₁↠A₂ B₁⇔B₂ =
-    equivalence (Surjection.equivalence A₁↠A₂) B-to B-from
+  equivalence-↠ :
+    (I↠J : I ↠ J) →
+    (∀ {x} → Equivalence (A atₛ x) (B atₛ (Surjection.to I↠J x))) →
+    Equivalence (I ×ₛ A) (J ×ₛ B)
+  equivalence-↠ {A = A} {B = B} I↠J A⇔B =
+    equivalence (↠⇒⇔ I↠J) B-to B-from
     where
-    B-to : ∀ {x} → _⟶_ (B₁ atₛ x) (B₂ atₛ (Surjection.to A₁↠A₂ ⟨$⟩ x))
-    B-to = Equivalence.to B₁⇔B₂
+    B-to : ∀ {x} → Func (A atₛ x) (B atₛ (Surjection.to I↠J x))
+    B-to = toFunction A⇔B
 
-    B-from : ∀ {y} → _⟶_ (B₂ atₛ y) (B₁ atₛ (Surjection.from A₁↠A₂ ⟨$⟩ y))
+    B-from : ∀ {y} → Func (B atₛ y) (A atₛ (Surjection.to⁻ I↠J y))
     B-from = record
-      { _⟨$⟩_ = λ x → Equivalence.from B₁⇔B₂ ⟨$⟩
-                      P.subst (IndexedSetoid.Carrier B₂)
-                         (P.sym $ Surjection.right-inverse-of A₁↠A₂ _)
-                         x
-      ; cong  = F.cong (Equivalence.from B₁⇔B₂) ∘
-              subst-cong (λ {x} → IndexedSetoid._≈_ B₂ {x} {x})
-                         (P.sym (Surjection.right-inverse-of A₁↠A₂ _))
+      { to   = from      A⇔B ∘ cast      B (Surjection.to∘to⁻ I↠J _)
+      ; cong = from-cong A⇔B ∘ cast-cong B (Surjection.to∘to⁻ I↠J _)
       }
 
-  injection : {B₁ : IndexedSetoid A₁ b₁ b₁′} (B₂ : IndexedSetoid A₂ b₂ b₂′) →
-    (A₁↣A₂ : A₁ ↣ A₂) →
-    (∀ {x} → Injection (B₁ atₛ x) (B₂ atₛ (Injection.to A₁↣A₂ ⟨$⟩ x))) →
-    Injection (setoid (P.setoid A₁) B₁) (setoid (P.setoid A₂) B₂)
-  injection {B₁ = B₁} B₂ A₁↣A₂ B₁↣B₂ = record
-    { to        = to
-    ; injective = inj
-    }
+------------------------------------------------------------------------
+-- Injections
+
+module _ where
+  open Injection hiding (function)
+  open IndexedSetoid
+
+  injection :
+    (I↣J : I ↣ J) →
+    (∀ {i} → Injection (A atₛ i) (B atₛ (Injection.to I↣J i))) →
+    Injection (I ×ₛ A) (J ×ₛ B)
+  injection {I = I} {J = J} {A = A} {B = B} I↣J A↣B = mkInjection func inj
     where
-    to = ⟶ B₂ (Injection.to A₁↣A₂ ⟨$⟩_) (Injection.to B₁↣B₂)
+    func : Func (I ×ₛ A) (J ×ₛ B)
+    func = function (Injection.function I↣J) (Injection.function A↣B)
 
-    inj : Injective to
-    inj (x , y) =
-      Injection.injective A₁↣A₂ x ,
-      lemma (Injection.injective A₁↣A₂ x) y
+    inj : Injective (Func.Eq₁._≈_ func) (Func.Eq₂._≈_ func) (Func.to func)
+    inj (to[i]≡to[j] , y) =
+      injective I↣J to[i]≡to[j] ,
+      lemma (injective I↣J to[i]≡to[j]) y
       where
       lemma :
-        ∀ {x x′}
-          {y : IndexedSetoid.Carrier B₁ x} {y′ : IndexedSetoid.Carrier B₁ x′} →
-        x ≡ x′ →
-        (eq : IndexedSetoid._≈_ B₂ (Injection.to B₁↣B₂ ⟨$⟩ y)
-                              (Injection.to B₁↣B₂ ⟨$⟩ y′)) →
-        IndexedSetoid._≈_ B₁ y y′
-      lemma P.refl = Injection.injective B₁↣B₂
-
-  left-inverse : (B₁ : IndexedSetoid A₁ b₁ b₁′) {B₂ : IndexedSetoid A₂ b₂ b₂′} →
-    (A₁↞A₂ : A₁ ↞ A₂) →
-    (∀ {x} → LeftInverse (B₁ atₛ (LeftInverse.from A₁↞A₂ ⟨$⟩ x))
-                         (B₂ atₛ x)) →
-    LeftInverse (setoid (P.setoid A₁) B₁) (setoid (P.setoid A₂) B₂)
-  left-inverse B₁ {B₂} A₁↞A₂ B₁↞B₂ = record
-    { to              = Equivalence.to   eq
-    ; from            = Equivalence.from eq
-    ; left-inverse-of = left
-    }
+        ∀ {i j} {x : Carrier A i} {y : Carrier A j} →
+          i ≡ j →
+          (_≈_ B (to A↣B x) (to A↣B y)) →
+          _≈_ A x y
+      lemma ≡.refl = Injection.injective A↣B
+
+------------------------------------------------------------------------
+-- Surjections
+
+module _ where
+  open Surjection hiding (function)
+  open Setoid
+
+  surjection :
+    (I↠J : I ↠ J) →
+    (∀ {x} → Surjection (A atₛ x) (B atₛ (to I↠J x))) →
+    Surjection (I ×ₛ A) (J ×ₛ B)
+  surjection {I = I} {J = J} {A = A} {B = B} I↠J A↠B =
+    mkSurjection func surj
     where
-    eq = equivalence-↞ B₁ A₁↞A₂ (LeftInverse.equivalence B₁↞B₂)
-
-    left : Equivalence.from eq LeftInverseOf Equivalence.to eq
-    left (x , y) =
-      LeftInverse.left-inverse-of A₁↞A₂ x ,
-      IndexedSetoid.trans B₁
-        (LeftInverse.left-inverse-of B₁↞B₂ _)
-        (lemma (P.sym (LeftInverse.left-inverse-of A₁↞A₂ x)))
-      where
-      lemma :
-        ∀ {x x′ y} (eq : x ≡ x′) →
-        IndexedSetoid._≈_ B₁ (P.subst (IndexedSetoid.Carrier B₁) eq y) y
-      lemma P.refl = IndexedSetoid.refl B₁
-
-  surjection : {B₁ : IndexedSetoid A₁ b₁ b₁′} (B₂ : IndexedSetoid A₂ b₂ b₂′) →
-    (A₁↠A₂ : A₁ ↠ A₂) →
-    (∀ {x} → Surjection (B₁ atₛ x) (B₂ atₛ (Surjection.to A₁↠A₂ ⟨$⟩ x))) →
-    Surjection (setoid (P.setoid A₁) B₁) (setoid (P.setoid A₂) B₂)
-  surjection B₂ A₁↠A₂ B₁↠B₂ = record
-    { to         = Equivalence.to eq
-    ; surjective = record
-      { from             = Equivalence.from eq
-      ; right-inverse-of = right
-      }
+    func : Func (I ×ₛ A) (J ×ₛ B)
+    func = function (Surjection.function I↠J) (Surjection.function A↠B)
+
+    to⁻′ : Carrier (J ×ₛ B) → Carrier (I ×ₛ A)
+    to⁻′ (j , y) = to⁻ I↠J j , to⁻ A↠B (cast B (Surjection.to∘to⁻ I↠J _) y)
+
+    strictlySurj : StrictlySurjective (Func.Eq₂._≈_ func) (Func.to func)
+    strictlySurj (j , y) = to⁻′ (j , y) ,
+      to∘to⁻ I↠J j , IndexedSetoid.trans B (to∘to⁻ A↠B _) (cast-eq B (to∘to⁻ I↠J j))
+
+    surj : Surjective (Func.Eq₁._≈_ func) (Func.Eq₂._≈_ func) (Func.to func)
+    surj = strictlySurjective⇒surjective (I ×ₛ A) (J ×ₛ B) (Func.cong func) strictlySurj
+
+------------------------------------------------------------------------
+-- LeftInverse
+
+module _ where
+  open RightInverse
+  open Setoid
+
+  left-inverse :
+    (I↪J : I ↪ J) →
+    (∀ {j} → RightInverse (A atₛ (from I↪J j)) (B atₛ j)) →
+    RightInverse (I ×ₛ A) (J ×ₛ B)
+  left-inverse {I = I} {J = J} {A = A} {B = B} I↪J A↪B =
+    mkRightInverse equiv invʳ
+    where
+    equiv : Equivalence (I ×ₛ A) (J ×ₛ B)
+    equiv = equivalence-↪ I↪J (RightInverse.equivalence A↪B)
+
+    strictlyInvʳ : StrictlyInverseʳ (_≈_ (I ×ₛ A)) (Equivalence.to equiv) (Equivalence.from equiv)
+    strictlyInvʳ (i , x) = strictlyInverseʳ I↪J i , IndexedSetoid.trans A (strictlyInverseʳ A↪B _) (cast-eq A (strictlyInverseʳ I↪J i))
+
+    invʳ : Inverseʳ (_≈_ (I ×ₛ A)) (_≈_ (J ×ₛ B)) (Equivalence.to equiv) (Equivalence.from equiv)
+    invʳ = strictlyInverseʳ⇒inverseʳ (I ×ₛ A) (J ×ₛ B) (Equivalence.from-cong equiv) strictlyInvʳ
+
+
+------------------------------------------------------------------------
+-- Inverses
+
+module _ where
+  open Inverse hiding (inverse)
+  open Setoid
+
+  inverse : (I↔J : I ↔ J) →
+            (∀ {i} → Inverse (A atₛ i) (B atₛ (to I↔J i))) →
+            Inverse (I ×ₛ A) (J ×ₛ B)
+  inverse {I = I} {J = J} {A = A} {B = B} I↔J A↔B = record
+    { to = to′
+    ; from = from′
+    ; to-cong = to′-cong
+    ; from-cong = from′-cong
+    ; inverse = invˡ , invʳ
     }
     where
-    eq = equivalence-↠ B₂ A₁↠A₂ (Surjection.equivalence B₁↠B₂)
-
-    right : Equivalence.from eq RightInverseOf Equivalence.to eq
-    right (x , y) =
-      Surjection.right-inverse-of A₁↠A₂ x ,
-      IndexedSetoid.trans B₂
-        (Surjection.right-inverse-of B₁↠B₂ _)
-        (lemma (P.sym $ Surjection.right-inverse-of A₁↠A₂ x))
-      where
-      lemma : ∀ {x x′ y} (eq : x ≡ x′) →
-              IndexedSetoid._≈_ B₂ (P.subst (IndexedSetoid.Carrier B₂) eq y) y
-      lemma P.refl = IndexedSetoid.refl B₂
+    to′ : Carrier (I ×ₛ A) → Carrier (J ×ₛ B)
+    to′ (i , x) = to I↔J i , to A↔B x
+
+    to′-cong : Congruent (_≈_ (I ×ₛ A)) (_≈_ (J ×ₛ B)) to′
+    to′-cong (≡.refl , x≈y) = to-cong I↔J ≡.refl , to-cong A↔B x≈y
+
+    from′ : Carrier (J ×ₛ B) → Carrier (I ×ₛ A)
+    from′ (j , y) = from I↔J j , from A↔B (cast B (strictlyInverseˡ I↔J _) y)
+
+    from′-cong : Congruent (_≈_ (J ×ₛ B)) (_≈_ (I ×ₛ A)) from′
+    from′-cong (≡.refl , x≈y) = from-cong I↔J ≡.refl , from-cong A↔B (cast-cong B (strictlyInverseˡ I↔J _) x≈y)
+
+    strictlyInvˡ : StrictlyInverseˡ (_≈_ (J ×ₛ B)) to′ from′
+    strictlyInvˡ (i , x) = strictlyInverseˡ I↔J i ,
+        IndexedSetoid.trans B (strictlyInverseˡ A↔B _)
+          (cast-eq B (strictlyInverseˡ I↔J i))
+
+    invˡ : Inverseˡ (_≈_ (I ×ₛ A)) (_≈_ (J ×ₛ B)) to′ from′
+    invˡ = strictlyInverseˡ⇒inverseˡ (I ×ₛ A) (J ×ₛ B) to′-cong strictlyInvˡ
+
+    lem : ∀ {i j} → i ≡ j → ∀ {x : IndexedSetoid.Carrier B (to I↔J i)} {y : IndexedSetoid.Carrier B (to I↔J j)} →
+          IndexedSetoid._≈_ B x y →
+          IndexedSetoid._≈_ A (from A↔B x) (from A↔B y)
+    lem ≡.refl x≈y = from-cong A↔B x≈y
+
+    strictlyInvʳ : StrictlyInverseʳ (_≈_ (I ×ₛ A)) to′ from′
+    strictlyInvʳ (i , x) = strictlyInverseʳ I↔J i ,
+      IndexedSetoid.trans A (lem (strictlyInverseʳ I↔J _) (cast-eq B (strictlyInverseˡ I↔J _))) (strictlyInverseʳ A↔B _)
+
+    invʳ : Inverseʳ (_≈_ (I ×ₛ A)) (_≈_ (J ×ₛ B)) to′ from′
+    invʳ = strictlyInverseʳ⇒inverseʳ (I ×ₛ A) (J ×ₛ B) from′-cong strictlyInvʳ
 
-  -- See also Data.Product.Function.Dependent.Setoid.WithK.inverse.
diff --git a/src/Data/Product/Function/Dependent/Setoid/WithK.agda b/src/Data/Product/Function/Dependent/Setoid/WithK.agda
index a343e22b43..75a3ff4ed1 100644
--- a/src/Data/Product/Function/Dependent/Setoid/WithK.agda
+++ b/src/Data/Product/Function/Dependent/Setoid/WithK.agda
@@ -1,71 +1,17 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Dependent product combinators for setoid equality preserving
--- functions
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --with-K --safe #-}
 
 module Data.Product.Function.Dependent.Setoid.WithK where
 
-open import Data.Product
-open import Data.Product.Function.Dependent.Setoid using (surjection)
-open import Data.Product.Relation.Binary.Pointwise.Dependent
-open import Relation.Binary
-open import Function.Base
-open import Function.Equality as F using (_⟶_; _⟨$⟩_)
-open import Function.Equivalence as Eq
-  using (Equivalence; _⇔_; module Equivalence)
-open import Function.Injection as Inj
-  using (Injection; Injective; _↣_; module Injection)
-open import Function.Inverse as Inv
-  using (Inverse; _↔_; module Inverse)
-open import Function.LeftInverse as LeftInv
-  using (LeftInverse; _↞_; _LeftInverseOf_; _RightInverseOf_; module LeftInverse)
-open import Function.Surjection as Surj
-  using (Surjection; _↠_; module Surjection)
-open import Relation.Binary as B
-open import Relation.Binary.Indexed.Heterogeneous
-  using (IndexedSetoid)
-open import Relation.Binary.Indexed.Heterogeneous.Construct.At
-  using (_atₛ_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Data.Product.Function.Dependent.Setoid public
+  using (inverse)
 
-------------------------------------------------------------------------
--- Combinator for Inverse
-
-module _ {a₁ a₂ b₁ b₁′ b₂ b₂′} {A₁ : Set a₁} {A₂ : Set a₂} where
-
-  inverse : {B₁ : IndexedSetoid A₁ b₁ b₁′} (B₂ : IndexedSetoid A₂ b₂ b₂′) →
-    (A₁↔A₂ : A₁ ↔ A₂) →
-    (∀ {x} → Inverse (B₁ atₛ x) (B₂ atₛ (Inverse.to A₁↔A₂ ⟨$⟩ x))) →
-    Inverse (setoid (P.setoid A₁) B₁) (setoid (P.setoid A₂) B₂)
-  inverse {B₁} B₂ A₁↔A₂ B₁↔B₂ = record
-    { to         = Surjection.to   surj
-    ; from       = Surjection.from surj
-    ; inverse-of = record
-      { left-inverse-of  = left
-      ; right-inverse-of = Surjection.right-inverse-of surj
-      }
-    }
-    where
-    surj = surjection B₂ (Inverse.surjection A₁↔A₂)
-                         (Inverse.surjection B₁↔B₂)
-
-    left : Surjection.from surj LeftInverseOf Surjection.to surj
-    left (x , y) =
-      Inverse.left-inverse-of A₁↔A₂ x ,
-      IndexedSetoid.trans B₁
-        (lemma (P.sym (Inverse.left-inverse-of A₁↔A₂ x))
-               (P.sym (Inverse.right-inverse-of A₁↔A₂
-                       (Inverse.to A₁↔A₂ ⟨$⟩ x))))
-        (Inverse.left-inverse-of B₁↔B₂ y)
-      where
-      lemma :
-        ∀ {x x′ y} → x ≡ x′ →
-        (eq : (Inverse.to A₁↔A₂ ⟨$⟩ x) ≡ (Inverse.to A₁↔A₂ ⟨$⟩ x′)) →
-        IndexedSetoid._≈_ B₁
-          (Inverse.from B₁↔B₂ ⟨$⟩ P.subst (IndexedSetoid.Carrier B₂) eq y)
-          (Inverse.from B₁↔B₂ ⟨$⟩ y)
-      lemma P.refl P.refl = IndexedSetoid.refl B₁
+{-# WARNING_ON_IMPORT
+"Data.Product.Function.Dependent.Setoid.WithK was deprecated in v2.0.
+Use Data.Product.Function.Dependent.Setoid instead."
+#-}
diff --git a/src/Data/Product/Function/NonDependent/Propositional.agda b/src/Data/Product/Function/NonDependent/Propositional.agda
index f5b4973184..1552564ed0 100644
--- a/src/Data/Product/Function/NonDependent/Propositional.agda
+++ b/src/Data/Product/Function/NonDependent/Propositional.agda
@@ -9,67 +9,79 @@
 
 module Data.Product.Function.NonDependent.Propositional where
 
-open import Data.Product
+open import Data.Product.Base using (_×_; map)
 open import Data.Product.Function.NonDependent.Setoid
 open import Data.Product.Relation.Binary.Pointwise.NonDependent
+  using (_×ₛ_; Pointwise-≡↔≡)
+open import Function.Base using (id)
+open import Function.Bundles
+  using (Inverse; _⟶_; _⇔_; _↣_; _↠_; _⤖_; _↩_; _↪_; _↔_)
+open import Function.Properties.Inverse as Inv
+  using (Inverse⇒Equivalence; Inverse⇒Injection; Inverse⇒Surjection;
+         Inverse⇒Bijection)
+open import Function.Related.Propositional
+  using (_∼[_]_; implication; reverseImplication; equivalence; injection;
+         reverseInjection; leftInverse; surjection; bijection)
+import Function.Construct.Composition as Compose
+open import Level using (Level; _⊔_)
 open import Relation.Binary hiding (_⇔_)
-open import Function.Equality using (_⟶_)
-open import Function.Equivalence as Eq using (_⇔_; module Equivalence)
-open import Function.Injection as Inj using (_↣_; module Injection)
-open import Function.Inverse as Inv using (_↔_; module Inverse)
-open import Function.LeftInverse as LeftInv
-  using (_↞_; _LeftInverseOf_; module LeftInverse)
-open import Function.Related
-open import Function.Surjection as Surj using (_↠_; module Surjection)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
+
+private
+  variable
+    a b c d : Level
+    A B C D : Set a
+
+------------------------------------------------------------------------
+-- Helper lemma
+
+private
+  liftViaInverse : {R : ∀ {a b ℓ₁ ℓ₂} → REL (Setoid a ℓ₁) (Setoid b ℓ₂) (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)} →
+                   (∀ {a b c ℓ₁ ℓ₂ ℓ₃} {S : Setoid a ℓ₁} {T : Setoid b ℓ₂} {U : Setoid c ℓ₃} → R S T → R T U → R S U) →
+                   (∀ {a b ℓ₁ ℓ₂} {S : Setoid a ℓ₁} {T : Setoid b ℓ₂} → Inverse S T → R S T) →
+                   (R (setoid A) (setoid C) → R (setoid B) (setoid D) → R (setoid A ×ₛ setoid B) (setoid C ×ₛ setoid D)) →
+                   R (setoid A) (setoid C) → R (setoid B) (setoid D) →
+                   R (setoid (A × B)) (setoid (C × D))
+  liftViaInverse trans inv⇒R lift RAC RBD =
+    Inv.transportVia trans inv⇒R (Inv.sym Pointwise-≡↔≡) (lift RAC RBD) Pointwise-≡↔≡
 
 ------------------------------------------------------------------------
 -- Combinators for various function types
 
-module _ {a b c d} {A : Set a} {B : Set b} {C : Set c} {D : Set d} where
-
-  _×-⇔_ : A ⇔ B → C ⇔ D → (A × C) ⇔ (B × D)
-  _×-⇔_ A⇔B C⇔D =
-    Inverse.equivalence Pointwise-≡↔≡           ⟨∘⟩
-    (A⇔B ×-equivalence C⇔D)                     ⟨∘⟩
-    Eq.sym (Inverse.equivalence Pointwise-≡↔≡)
-    where open Eq using () renaming (_∘_ to _⟨∘⟩_)
-
-  _×-↣_ : A ↣ B → C ↣ D → (A × C) ↣ (B × D)
-  _×-↣_ A↣B C↣D =
-    Inverse.injection Pointwise-≡↔≡           ⟨∘⟩
-    (A↣B ×-injection C↣D)                     ⟨∘⟩
-    Inverse.injection (Inv.sym Pointwise-≡↔≡)
-    where open Inj using () renaming (_∘_ to _⟨∘⟩_)
-
-  _×-↞_ : A ↞ B → C ↞ D → (A × C) ↞ (B × D)
-  _×-↞_ A↞B C↞D =
-    Inverse.left-inverse Pointwise-≡↔≡           ⟨∘⟩
-    (A↞B ×-left-inverse C↞D)                     ⟨∘⟩
-    Inverse.left-inverse (Inv.sym Pointwise-≡↔≡)
-    where open LeftInv using () renaming (_∘_ to _⟨∘⟩_)
-
-  _×-↠_ : A ↠ B → C ↠ D → (A × C) ↠ (B × D)
-  _×-↠_ A↠B C↠D =
-    Inverse.surjection Pointwise-≡↔≡           ⟨∘⟩
-    (A↠B ×-surjection C↠D)                     ⟨∘⟩
-    Inverse.surjection (Inv.sym Pointwise-≡↔≡)
-    where open Surj using () renaming (_∘_ to _⟨∘⟩_)
-
-  _×-↔_ : A ↔ B → C ↔ D → (A × C) ↔ (B × D)
-  _×-↔_ A↔B C↔D =
-    Pointwise-≡↔≡          ⟨∘⟩
-    (A↔B ×-inverse C↔D)    ⟨∘⟩
-    Inv.sym Pointwise-≡↔≡
-    where open Inv using () renaming (_∘_ to _⟨∘⟩_)
-
-module _ {a b c d} {A : Set a} {B : Set b} {C : Set c} {D : Set d} where
-
-  _×-cong_ : ∀ {k} → A ∼[ k ] B → C ∼[ k ] D → (A × C) ∼[ k ] (B × D)
-  _×-cong_ {implication}         = λ f g →      map        f         g
-  _×-cong_ {reverse-implication} = λ f g → lam (map (app-← f) (app-← g))
-  _×-cong_ {equivalence}         = _×-⇔_
-  _×-cong_ {injection}           = _×-↣_
-  _×-cong_ {reverse-injection}   = λ f g → lam (app-↢ f ×-↣ app-↢ g)
-  _×-cong_ {left-inverse}        = _×-↞_
-  _×-cong_ {surjection}          = _×-↠_
-  _×-cong_ {bijection}           = _×-↔_
+infixr 2 _×-⟶_ _×-⇔_ _×-↣_ _×-↠_ _×-⤖_ _×-↩_ _×-↪_ _×-↔_
+
+_×-⟶_ : A ⟶ B → C ⟶ D → (A × C) ⟶ (B × D)
+_×-⟶_ = liftViaInverse Compose.function Inv.toFunction _×-function_
+
+_×-⇔_ : A ⇔ B → C ⇔ D → (A × C) ⇔ (B × D)
+_×-⇔_ = liftViaInverse Compose.equivalence Inverse⇒Equivalence _×-equivalence_
+
+_×-↣_ : A ↣ B → C ↣ D → (A × C) ↣ (B × D)
+_×-↣_ = liftViaInverse Compose.injection Inverse⇒Injection _×-injection_
+
+_×-↠_ : A ↠ B → C ↠ D → (A × C) ↠ (B × D)
+_×-↠_ = liftViaInverse Compose.surjection Inverse⇒Surjection _×-surjection_
+
+_×-⤖_ : A ⤖ B → C ⤖ D → (A × C) ⤖ (B × D)
+_×-⤖_ = liftViaInverse Compose.bijection Inverse⇒Bijection _×-bijection_
+
+_×-↩_ : A ↩ B → C ↩ D → (A × C) ↩ (B × D)
+_×-↩_ = liftViaInverse Compose.leftInverse Inverse.leftInverse _×-leftInverse_
+
+_×-↪_ : A ↪ B → C ↪ D → (A × C) ↪ (B × D)
+_×-↪_ = liftViaInverse Compose.rightInverse Inverse.rightInverse _×-rightInverse_
+
+_×-↔_ : A ↔ B → C ↔ D → (A × C) ↔ (B × D)
+_×-↔_ = liftViaInverse Compose.inverse id _×-inverse_
+
+infixr 2 _×-cong_
+
+_×-cong_ : ∀ {k} → A ∼[ k ] B → C ∼[ k ] D → (A × C) ∼[ k ] (B × D)
+_×-cong_ {k = implication}         = _×-⟶_
+_×-cong_ {k = reverseImplication}  = _×-⟶_
+_×-cong_ {k = equivalence}         = _×-⇔_
+_×-cong_ {k = injection}           = _×-↣_
+_×-cong_ {k = reverseInjection}    = _×-↣_
+_×-cong_ {k = leftInverse}         = _×-↪_
+_×-cong_ {k = surjection}          = _×-↠_
+_×-cong_ {k = bijection}           = _×-↔_
diff --git a/src/Data/Product/Function/NonDependent/Setoid.agda b/src/Data/Product/Function/NonDependent/Setoid.agda
index 830e25864b..861b960c36 100644
--- a/src/Data/Product/Function/NonDependent/Setoid.agda
+++ b/src/Data/Product/Function/NonDependent/Setoid.agda
@@ -9,133 +9,128 @@
 
 module Data.Product.Function.NonDependent.Setoid where
 
-open import Data.Product
-open import Data.Product.Relation.Binary.Pointwise.NonDependent
-open import Relation.Binary
-open import Function.Equality as F using (_⟶_; _⟨$⟩_)
-open import Function.Equivalence as Eq
-  using (Equivalence; _⇔_; module Equivalence)
-open import Function.Injection as Inj
-  using (Injection; _↣_; module Injection)
-open import Function.Inverse as Inv
-  using (Inverse; _↔_; module Inverse)
-open import Function.LeftInverse as LeftInv
-  using (LeftInverse; _↞_; _LeftInverseOf_; module LeftInverse)
-open import Function.Related
-open import Function.Surjection as Surj
-  using (Surjection; _↠_; module Surjection)
+open import Data.Product.Base as Product
+open import Data.Product.Relation.Binary.Pointwise.NonDependent using (_×ₛ_)
+open import Level using (Level)
+open import Relation.Binary.Bundles using (Setoid)
+open import Function.Bundles
+  using (Func; Equivalence; Injection; Surjection; Bijection; LeftInverse;
+         RightInverse; Inverse)
+
+private
+  variable
+    a₁ a₂ b₁ b₂ c₁ c₂ d₁ d₂ : Level
+    a ℓ : Level
+    A B C D : Setoid a ℓ
 
 ------------------------------------------------------------------------
 -- Combinators for equality preserving functions
 
-module _  {a₁ a₂ b₁ b₂ c₁ c₂ d₁ d₂}
-          {A : Setoid a₁ a₂} {B : Setoid b₁ b₂}
-          {C : Setoid c₁ c₂} {D : Setoid d₁ d₂}
-          where
+proj₁ₛ : Func (A ×ₛ B) A
+proj₁ₛ = record { to = proj₁ ; cong = proj₁ }
 
-  _×-⟶_ : (A ⟶ B) → (C ⟶ D) → (A ×ₛ C) ⟶ (B ×ₛ D)
-  _×-⟶_ f g = record
-    { _⟨$⟩_ = fg
-    ; cong  = fg-cong
-    }
-    where
-    open Setoid (A ×ₛ C) using () renaming (_≈_ to _≈AC_)
-    open Setoid (B ×ₛ D) using () renaming (_≈_ to _≈BD_)
+proj₂ₛ : Func (A ×ₛ B) B
+proj₂ₛ = record { to = proj₂ ; cong = proj₂ }
 
-    fg = map (f ⟨$⟩_) (g ⟨$⟩_)
+<_,_>ₛ : Func A B → Func A C → Func A (B ×ₛ C)
+< f , g >ₛ = record
+  { to   = < to   f , to   g >
+  ; cong = < cong f , cong g >
+  } where open Func
 
-    fg-cong : _≈AC_ =[ fg ]⇒ _≈BD_
-    fg-cong (_∼₁_ , _∼₂_) = (F.cong f _∼₁_ , F.cong g _∼₂_)
+swapₛ : Func (A ×ₛ B) (B ×ₛ A)
+swapₛ = < proj₂ₛ , proj₁ₛ >ₛ
 
-module _ {a₁ a₂ b₁ b₂ c₁ c₂}
-         {A : Setoid a₁ a₂} {B : Setoid b₁ b₂} {C : Setoid c₁ c₂}
-         where
-
-  <_,_>ₛ : (A ⟶ B) → (A ⟶ C) → A ⟶ (B ×ₛ C)
-  < f , g >ₛ = record
-    { _⟨$⟩_ = < f ⟨$⟩_ , g ⟨$⟩_ >
-    ; cong = < F.cong f , F.cong g >
-    }
+------------------------------------------------------------------------
+-- Function bundles
+
+_×-function_ : Func A B → Func C D → Func (A ×ₛ C) (B ×ₛ D)
+f ×-function g = record
+  { to    = Product.map (to f) (to g)
+  ; cong  = Product.map (cong f) (cong g)
+  } where open Func
+
+infixr 2 _×-equivalence_ _×-injection_ _×-left-inverse_
+
+_×-equivalence_ : Equivalence A B → Equivalence C D →
+                  Equivalence (A ×ₛ C) (B ×ₛ D)
+_×-equivalence_ f g = record
+  { to        = Product.map (to f) (to g)
+  ; from      = Product.map (from f) (from g)
+  ; to-cong   = Product.map (to-cong f) (to-cong g)
+  ; from-cong = Product.map (from-cong f) (from-cong g)
+  } where open Equivalence
+
+_×-injection_ : Injection A B → Injection C D →
+                Injection (A ×ₛ C) (B ×ₛ D)
+f ×-injection g = record
+  { to        = Product.map (to f) (to g)
+  ; cong      = Product.map (cong f) (cong g)
+  ; injective = Product.map (injective f) (injective g)
+  } where open Injection
+
+_×-surjection_ : Surjection A B → Surjection C D →
+                 Surjection (A ×ₛ C) (B ×ₛ D)
+f ×-surjection g = record
+  { to         = Product.map (to f) (to g)
+  ; cong       = Product.map (cong f) (cong g)
+  ; surjective = λ y → Product.zip _,_ (λ ff gg x₂ → (ff (proj₁ x₂)) , (gg (proj₂ x₂))) (surjective f (proj₁ y)) (surjective g (proj₂ y))
+  } where open Surjection
+
+_×-bijection_ : Bijection A B → Bijection C D →
+                Bijection (A ×ₛ C) (B ×ₛ D)
+f ×-bijection g = record
+  { to         = Product.map (to f) (to g)
+  ; cong       = Product.map (cong f) (cong g)
+  ; bijective  = Product.map (injective f) (injective g) ,
+                 λ { (y₀ , y₁) → Product.zip _,_ (λ {ff gg (x₀ , x₁) → ff x₀ , gg x₁}) (surjective f y₀) (surjective g y₁)}
+  } where open Bijection
+
+_×-leftInverse_ : LeftInverse A B → LeftInverse C D →
+                  LeftInverse (A ×ₛ C) (B ×ₛ D)
+f ×-leftInverse g = record
+  { to        = Product.map (to f) (to g)
+  ; from      = Product.map (from f) (from g)
+  ; to-cong   = Product.map (to-cong f) (to-cong g)
+  ; from-cong = Product.map (from-cong f) (from-cong g)
+  ; inverseˡ   = λ x → inverseˡ f (proj₁ x) , inverseˡ g (proj₂ x)
+  } where open LeftInverse
+
+_×-rightInverse_ : RightInverse A B → RightInverse C D →
+                   RightInverse (A ×ₛ C) (B ×ₛ D)
+f ×-rightInverse g = record
+  { to        = Product.map (to f) (to g)
+  ; from      = Product.map (from f) (from g)
+  ; to-cong   = Product.map (to-cong f) (to-cong g)
+  ; from-cong = Product.map (from-cong f) (from-cong g)
+  ; inverseʳ   = λ x → inverseʳ f (proj₁ x) , inverseʳ g (proj₂ x)
+  } where open RightInverse
+
+infixr 2 _×-surjection_ _×-inverse_
+
+_×-inverse_ : Inverse A B → Inverse C D →
+              Inverse (A ×ₛ C) (B ×ₛ D)
+f ×-inverse g = record
+  { to        = Product.map (to f) (to g)
+  ; from      = Product.map (from f) (from g)
+  ; to-cong   = Product.map (to-cong f) (to-cong g)
+  ; from-cong = Product.map (from-cong f) (from-cong g)
+  ; inverse   = (λ x → inverseˡ f (proj₁ x) , inverseˡ g (proj₂ x)) ,
+                (λ x → inverseʳ f (proj₁ x) , inverseʳ g (proj₂ x))
+  } where open Inverse
 
-module _ {a₁ a₂ b₁ b₂} {A : Setoid a₁ a₂} {B : Setoid b₁ b₂} where
 
-  proj₁ₛ : (A ×ₛ B) ⟶ A
-  proj₁ₛ = record { _⟨$⟩_ = proj₁ ; cong = proj₁ }
 
-  proj₂ₛ : (A ×ₛ B) ⟶ B
-  proj₂ₛ = record { _⟨$⟩_ = proj₂ ; cong = proj₂ }
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
 
-  swapₛ : (A ×ₛ B) ⟶ (B ×ₛ A)
-  swapₛ = < proj₂ₛ , proj₁ₛ >ₛ
+-- Version 2.0
 
-------------------------------------------------------------------------
--- Combinators for more complex function types
-
-module _  {a₁ a₂ b₁ b₂ c₁ c₂ d₁ d₂}
-          {A : Setoid a₁ a₂} {B : Setoid b₁ b₂}
-          {C : Setoid c₁ c₂} {D : Setoid d₁ d₂}
-          where
-
-  _×-equivalence_ : Equivalence A B → Equivalence C D →
-                    Equivalence (A ×ₛ C) (B ×ₛ D)
-  _×-equivalence_ A⇔B C⇔D = record
-    { to   = to   A⇔B ×-⟶ to   C⇔D
-    ; from = from A⇔B ×-⟶ from C⇔D
-    } where open Equivalence
-
-  _×-injection_ : Injection A B → Injection C D →
-                  Injection (A ×ₛ C) (B ×ₛ D)
-  A↣B ×-injection C↣D = record
-    { to        = to A↣B ×-⟶ to C↣D
-    ; injective = map (injective A↣B) (injective C↣D)
-    } where open Injection
-
-  _×-left-inverse_ : LeftInverse A B → LeftInverse C D →
-                     LeftInverse (A ×ₛ C) (B ×ₛ D)
-  A↞B ×-left-inverse C↞D = record
-    { to              = Equivalence.to eq
-    ; from            = Equivalence.from eq
-    ; left-inverse-of = left
-    }
-    where
-    open LeftInverse
-    eq = LeftInverse.equivalence A↞B ×-equivalence
-         LeftInverse.equivalence C↞D
-
-    left : Equivalence.from eq LeftInverseOf Equivalence.to eq
-    left (x , y) = (left-inverse-of A↞B x , left-inverse-of C↞D y)
-
-module _ {a₁ a₂ b₁ b₂ c₁ c₂ d₁ d₂}
-  {A : Setoid a₁ a₂} {B : Setoid b₁ b₂}
-  {C : Setoid c₁ c₂} {D : Setoid d₁ d₂}
-  where
-
-  _×-surjection_ : Surjection A B → Surjection C D →
-                   Surjection (A ×ₛ C) (B ×ₛ D)
-  A↠B ×-surjection C↠D = record
-    { to         = LeftInverse.from inv
-    ; surjective = record
-      { from             = LeftInverse.to inv
-      ; right-inverse-of = LeftInverse.left-inverse-of inv
-      }
-    }
-    where
-    open Surjection
-    inv = right-inverse A↠B ×-left-inverse right-inverse C↠D
-
-  _×-inverse_ : Inverse A B → Inverse C D →
-                Inverse (A ×ₛ C) (B ×ₛ D)
-  A↔B ×-inverse C↔D = record
-    { to         = Surjection.to   surj
-    ; from       = Surjection.from surj
-    ; inverse-of = record
-      { left-inverse-of  = LeftInverse.left-inverse-of inv
-      ; right-inverse-of = Surjection.right-inverse-of surj
-      }
-    }
-    where
-    open Inverse
-    surj = Inverse.surjection   A↔B ×-surjection
-           Inverse.surjection   C↔D
-    inv  = Inverse.left-inverse A↔B ×-left-inverse
-           Inverse.left-inverse C↔D
+_×-left-inverse_ = _×-leftInverse_
+{-# WARNING_ON_USAGE _×-left-inverse_
+"Warning: _×-left-inverse_ was deprecated in v2.0.
+Please use _×-leftInverse_ instead."
+#-}
diff --git a/src/Data/Product/Instances.agda b/src/Data/Product/Instances.agda
index 222a254b0b..93794c3c58 100644
--- a/src/Data/Product/Instances.agda
+++ b/src/Data/Product/Instances.agda
@@ -8,7 +8,7 @@
 
 module Data.Product.Instances where
 
-open import Data.Product
+open import Data.Product.Base
   using (Σ)
 open import Data.Product.Properties
 open import Level
diff --git a/src/Data/Product/Nary/NonDependent.agda b/src/Data/Product/Nary/NonDependent.agda
index 1d5678e00c..6a04492a5d 100644
--- a/src/Data/Product/Nary/NonDependent.agda
+++ b/src/Data/Product/Nary/NonDependent.agda
@@ -14,27 +14,28 @@ module Data.Product.Nary.NonDependent where
 -- behind the design decisions.
 ------------------------------------------------------------------------
 
-open import Level as L using (Level; _⊔_; Lift; 0ℓ)
+open import Level using (Level)
 open import Agda.Builtin.Unit
-open import Data.Product as Prod
+open import Data.Product.Base as Prod
 import Data.Product.Properties as Prodₚ
 open import Data.Sum.Base using (_⊎_)
 open import Data.Nat.Base using (ℕ; zero; suc; pred)
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Function.Base using (const; _∘′_; _∘_)
-open import Relation.Nullary.Decidable using (Dec; yes; no; _×-dec_)
-open import Relation.Binary using (Rel)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong₂)
+open import Relation.Nullary.Decidable.Core using (Dec; yes; no; _×-dec_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong₂)
 
 open import Function.Nary.NonDependent.Base
 
--- Provided n Levels and a corresponding "vector" of `n` Sets, we can build a big
--- right-nested product type packing a value for each one of these Sets.
+-- Provided n Levels and a corresponding "vector" of `n` Sets, we can
+-- build a big right-nested product type packing a value for each one
+-- of these Sets.
 -- We have two distinct but equivalent definitions:
 -- the first which is always ⊤-terminated
--- the other which has a special case for n = 1 because we want our `(un)curryₙ`
--- functions to work for user-written functions and products and they rarely are
--- ⊤-terminated.
+-- the other which has a special case for n = 1 because we want our
+-- `(un)curryₙ` functions to work for user-written functions and
+-- products and they rarely are ⊤-terminated.
 
 Product⊤ : ∀ n {ls} → Sets n ls → Set (⨆ n ls)
 Product⊤ zero    as       = ⊤
@@ -143,8 +144,8 @@ fromEqualₙ (suc n@(suc _)) eq = uncurry (cong₂ _,_) (Prod.map₂ (fromEqual
 ------------------------------------------------------------------------
 -- projection of the k-th component
 
--- To know at which Set level the k-th projection out of an n-ary product
--- lives, we need to extract said level, by induction on k.
+-- To know at which Set level the k-th projection out of an n-ary
+-- product lives, we need to extract said level, by induction on k.
 
 Levelₙ : ∀ {n} → Levels n → Fin n → Level
 Levelₙ (l , _)  zero    = l
@@ -157,10 +158,11 @@ Projₙ : ∀ {n ls} → Sets n ls → ∀ k → Set (Levelₙ ls k)
 Projₙ (a , _)  zero    = a
 Projₙ (_ , as) (suc k) = Projₙ as k
 
--- Finally, provided a Product of these sets, we can extract the k-th value.
--- `projₙ` takes both `n` and `k` explicitly because we expect the user will
--- be using a concrete `k` (potentially manufactured using `Data.Fin`'s `#_`)
--- and it will not be possible to infer `n` from it.
+-- Finally, provided a Product of these sets, we can extract the k-th
+-- value. `projₙ` takes both `n` and `k` explicitly because we expect
+-- the user will be using a concrete `k` (potentially manufactured
+-- using `Data.Fin`'s `#_`) and it will not be possible to infer `n`
+-- from it.
 
 projₙ : ∀ n {ls} {as : Sets n ls} k → Product n as → Projₙ as k
 projₙ 1               zero    v        = v
diff --git a/src/Data/Product/Properties.agda b/src/Data/Product/Properties.agda
index fa4909e955..0bfa3166df 100644
--- a/src/Data/Product/Properties.agda
+++ b/src/Data/Product/Properties.agda
@@ -8,12 +8,14 @@
 
 module Data.Product.Properties where
 
-open import Axiom.UniquenessOfIdentityProofs
-open import Data.Product
-open import Function
+open import Axiom.UniquenessOfIdentityProofs using (UIP; module Decidable⇒UIP)
+open import Data.Product.Base using (_,_; Σ; _×_; map; swap; ∃; ∃₂)
+open import Function.Base using (_∋_; _∘_; id)
+open import Function.Bundles using (_↔_; mk↔ₛ′)
 open import Level using (Level)
-open import Relation.Binary using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Definitions using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; _≗_; subst; cong; cong₂; cong′)
 open import Relation.Nullary.Decidable as Dec using (Dec; yes; no)
 
 private
@@ -81,7 +83,7 @@ module _ {A : Set a} {B : A → Set b} {p₁@(a₁ , b₁) p₂@(a₂ , b₂) :
     right-inverse-of refl = refl
 
   Σ-≡,≡↔≡ : (∃ λ (p : a₁ ≡ a₂) → subst B p b₁ ≡ b₂) ↔ p₁ ≡ p₂
-  Σ-≡,≡↔≡ = mk↔′ Σ-≡,≡→≡ Σ-≡,≡←≡ right-inverse-of left-inverse-of
+  Σ-≡,≡↔≡ = mk↔ₛ′ Σ-≡,≡→≡ Σ-≡,≡←≡ right-inverse-of left-inverse-of
 
 -- the non-dependent case. Proofs are exactly as above, and straightforward.
 module _ {p₁@(a₁ , b₁) p₂@(a₂ , b₂) : A × B} where
@@ -92,7 +94,7 @@ module _ {p₁@(a₁ , b₁) p₂@(a₂ , b₂) : A × B} where
   ×-≡,≡←≡ refl = refl , refl
 
   ×-≡,≡↔≡ : (a₁ ≡ a₂ × b₁ ≡ b₂) ↔ p₁ ≡ p₂
-  ×-≡,≡↔≡ = mk↔′
+  ×-≡,≡↔≡ = mk↔ₛ′
     ×-≡,≡→≡
     ×-≡,≡←≡
     (λ { refl          → refl        })
@@ -102,7 +104,7 @@ module _ {p₁@(a₁ , b₁) p₂@(a₂ , b₂) : A × B} where
 -- The order of ∃₂ can be swapped
 
 ∃∃↔∃∃ : (R : A → B → Set ℓ) → (∃₂ λ x y → R x y) ↔ (∃₂ λ y x → R x y)
-∃∃↔∃∃ R = mk↔′ to from cong′ cong′
+∃∃↔∃∃ R = mk↔ₛ′ to from cong′ cong′
   where
   to : (∃₂ λ x y → R x y) → (∃₂ λ y x → R x y)
   to (x , y , Rxy) = (y , x , Rxy)
diff --git a/src/Data/Product/Properties/Dependent.agda b/src/Data/Product/Properties/Dependent.agda
new file mode 100644
index 0000000000..122b4e3f12
--- /dev/null
+++ b/src/Data/Product/Properties/Dependent.agda
@@ -0,0 +1,53 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Properties of 'very dependent' map / zipWith over products
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Product.Properties.Dependent where
+
+open import Data.Product using (Σ; _×_; _,_; map-Σ; map-Σ′; zipWith)
+open import Function.Base using (id; flip)
+open import Level using (Level)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≗_; cong₂; refl)
+
+private
+  variable
+    a b p q r s : Level
+    A B C : Set a
+
+------------------------------------------------------------------------
+-- map-Σ
+
+module _ {B : A → Set b} {P : A → Set p} {Q : {x : A} → P x → B x → Set q} where
+
+  map-Σ-cong : {f g : (x : A) → B x} → {h k : ∀ {x} → (y : P x) → Q y (f x)} →
+     (∀ x → f x ≡ g x) →
+     (∀ {x} → (y : P x) → h y ≡ k y) →
+     (v : Σ A P) → map-Σ f h v ≡ map-Σ g k v
+  map-Σ-cong f≗g h≗k (x , y) = cong₂ _,_ (f≗g x) (h≗k y)
+
+------------------------------------------------------------------------
+-- map-Σ′
+
+module _ {B : A → Set b} {P : Set p} {Q : P → Set q} where
+
+  map-Σ′-cong : {f g : (x : A) → B x} → {h k : (x : P) → Q x} →
+     (∀ x → f x ≡ g x) →
+     ((y : P) → h y ≡ k y) →
+     (v : A × P) → map-Σ′ f h v ≡ map-Σ′ g k v
+  map-Σ′-cong f≗g h≗k (x , y) = cong₂ _,_ (f≗g x) (h≗k y)
+
+------------------------------------------------------------------------
+-- zipWith
+
+module _ {P : A → Set p} {Q : B → Set q} {R : C → Set r} {S : (x : C) → R x → Set s} where
+
+  zipWith-flip : (_∙_ : A → B → C) → (_∘_ : ∀ {x y} → P x → Q y → R (x ∙ y)) →
+    (_*_ : (x : C) → (y : R x) → S x y) →
+    {x : Σ A P} → {y : Σ B Q} →
+    zipWith _∙_ _∘_ _*_ x y ≡ zipWith (flip _∙_) (flip _∘_) _*_ y x
+  zipWith-flip _∙_ _∘_ _*_ = refl
diff --git a/src/Data/Product/Properties/WithK.agda b/src/Data/Product/Properties/WithK.agda
index 2218ec4ca3..593f18ab37 100644
--- a/src/Data/Product/Properties/WithK.agda
+++ b/src/Data/Product/Properties/WithK.agda
@@ -8,9 +8,10 @@
 
 module Data.Product.Properties.WithK where
 
-open import Data.Product
-open import Function
-open import Relation.Binary.PropositionalEquality
+open import Data.Product.Base using (Σ; _,_)
+open import Function.Base using (_∋_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl)
 
 ------------------------------------------------------------------------
 -- Equality
diff --git a/src/Data/Product/Relation/Binary/Lex/NonStrict.agda b/src/Data/Product/Relation/Binary/Lex/NonStrict.agda
index 259bc36789..534ddd6bdc 100644
--- a/src/Data/Product/Relation/Binary/Lex/NonStrict.agda
+++ b/src/Data/Product/Relation/Binary/Lex/NonStrict.agda
@@ -11,10 +11,16 @@
 
 module Data.Product.Relation.Binary.Lex.NonStrict where
 
-open import Data.Product using (_×_; _,_; proj₁; proj₂)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂)
 open import Data.Sum.Base using (inj₁; inj₂)
 open import Level using (Level)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (Poset; DecTotalOrder; TotalOrder)
+open import Relation.Binary.Structures
+  using (IsPartialOrder; IsEquivalence; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Transitive; Symmetric; Decidable; Antisymmetric; Total; Trichotomous; Irreflexive; Asymmetric; _Respects₂_; tri<; tri>; tri≈)
 open import Relation.Binary.Consequences
 import Relation.Binary.Construct.NonStrictToStrict as Conv
 open import Data.Product.Relation.Binary.Pointwise.NonDependent as Pointwise
diff --git a/src/Data/Product/Relation/Binary/Lex/Strict.agda b/src/Data/Product/Relation/Binary/Lex/Strict.agda
index 5c7c117a4b..39d86602f2 100644
--- a/src/Data/Product/Relation/Binary/Lex/Strict.agda
+++ b/src/Data/Product/Relation/Binary/Lex/Strict.agda
@@ -20,9 +20,15 @@ open import Function.Base
 open import Induction.WellFounded
 open import Level
 open import Relation.Nullary.Decidable
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (Preorder; StrictPartialOrder; StrictTotalOrder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsPreorder; IsStrictPartialOrder; IsStrictTotalOrder)
+open import Relation.Binary.Definitions
+  using (Transitive; Symmetric; Irreflexive; Asymmetric; Total; Decidable; Antisymmetric; Trichotomous; _Respects₂_; _Respectsʳ_; _Respectsˡ_; tri<; tri>; tri≈)
 open import Relation.Binary.Consequences
-open import Relation.Binary.PropositionalEquality as ≡ using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 private
   variable
@@ -186,23 +192,24 @@ module _ {_≈₁_ : Rel A ℓ₁} {_<₁_ : Rel A ℓ₂} {_<₂_ : Rel B ℓ
   private
     _<ₗₑₓ_ = ×-Lex _≈₁_ _<₁_ _<₂_
 
-  ×-wellFounded' : Symmetric _≈₁_ → Transitive _≈₁_ →
+  ×-wellFounded' : Transitive _≈₁_ →
                    _<₁_ Respectsʳ _≈₁_ →
                    WellFounded _<₁_ →
                    WellFounded _<₂_ →
                    WellFounded _<ₗₑₓ_
-  ×-wellFounded' sym trans resp wf₁ wf₂ (x , y) = acc (×-acc (wf₁ x) (wf₂ y))
+  ×-wellFounded' trans resp wf₁ wf₂ (x , y) = acc (×-acc (wf₁ x) (wf₂ y))
     where
     ×-acc : ∀ {x y} →
             Acc _<₁_ x → Acc _<₂_ y →
             WfRec _<ₗₑₓ_ (Acc _<ₗₑₓ_) (x , y)
-    ×-acc (acc rec₁) acc₂ (u , v) (inj₁ u<x)
-      = acc (×-acc (rec₁ u u<x) (wf₂ v))
-    ×-acc {x₁} acc₁ (acc rec₂) (u , v) (inj₂ (u≈x , v<y))
-      = Acc-resp-≈ (Pointwise.×-symmetric {_∼₁_ = _≈₁_} {_∼₂_ = _≡_ } sym ≡.sym)
-                   (×-respectsʳ {_<₁_ = _<₁_} {_<₂_ = _<₂_} trans resp (≡.respʳ _<₂_))
-                   (sym u≈x , _≡_.refl)
-                   (acc (×-acc acc₁ (rec₂ v v<y)))
+    ×-acc (acc rec₁) acc₂ (inj₁ u<x)
+      = acc (×-acc (rec₁ u<x) (wf₂ _))
+    ×-acc acc₁ (acc rec₂) (inj₂ (u≈x , v<y))
+      = Acc-resp-flip-≈
+        (×-respectsʳ {_<₁_ = _<₁_} {_<₂_ = _<₂_} trans resp (≡.respʳ _<₂_))
+        (u≈x , ≡.refl)
+        (acc (×-acc acc₁ (rec₂ v<y)))
+
 
 module _ {_<₁_ : Rel A ℓ₁} {_<₂_ : Rel B ℓ₂} where
 
@@ -212,7 +219,7 @@ module _ {_<₁_ : Rel A ℓ₁} {_<₂_ : Rel B ℓ₂} where
   ×-wellFounded : WellFounded _<₁_ →
                   WellFounded _<₂_ →
                   WellFounded _<ₗₑₓ_
-  ×-wellFounded = ×-wellFounded' ≡.sym ≡.trans (≡.respʳ _<₁_)
+  ×-wellFounded = ×-wellFounded' ≡.trans (≡.respʳ _<₁_)
 
 ------------------------------------------------------------------------
 -- Collections of properties which are preserved by ×-Lex.
@@ -233,7 +240,7 @@ module _ {_≈₁_ : Rel A ℓ₁} {_<₁_ : Rel A ℓ₂}
                           (isEquivalence pre₁) (isEquivalence pre₂)
       ; reflexive     = ×-reflexive _≈₁_ _<₁_ _<₂_ (reflexive pre₂)
       ; trans         = ×-transitive {_<₂_ = _<₂_}
-                          (isEquivalence pre₁) (∼-resp-≈ pre₁)
+                          (isEquivalence pre₁) (≲-resp-≈ pre₁)
                           (trans pre₁) (trans pre₂)
       }
     where open IsPreorder
@@ -262,12 +269,9 @@ module _ {_≈₁_ : Rel A ℓ₁} {_<₁_ : Rel A ℓ₂}
                          IsStrictTotalOrder _≋_ _<ₗₑₓ_
   ×-isStrictTotalOrder spo₁ spo₂ =
     record
-      { isEquivalence = Pointwise.×-isEquivalence
-                          (isEquivalence spo₁) (isEquivalence spo₂)
-      ; trans         = ×-transitive {_<₁_ = _<₁_} {_<₂_ = _<₂_}
-                          (isEquivalence spo₁)
-                          (<-resp-≈ spo₁) (trans spo₁)
-                          (trans spo₂)
+      { isStrictPartialOrder = ×-isStrictPartialOrder
+                                 (isStrictPartialOrder spo₁)
+                                 (isStrictPartialOrder spo₂)
       ; compare       = ×-compare (Eq.sym spo₁) (compare spo₁)
                                                 (compare spo₂)
       }
diff --git a/src/Data/Product/Relation/Binary/Pointwise/Dependent.agda b/src/Data/Product/Relation/Binary/Pointwise/Dependent.agda
index 5f6953071a..7050e8bd3a 100644
--- a/src/Data/Product/Relation/Binary/Pointwise/Dependent.agda
+++ b/src/Data/Product/Relation/Binary/Pointwise/Dependent.agda
@@ -8,14 +8,16 @@
 
 module Data.Product.Relation.Binary.Pointwise.Dependent where
 
-open import Data.Product as Prod
+open import Data.Product.Base as Product
 open import Level
 open import Function.Base
-open import Relation.Binary as B
-  using (_⇒_; Setoid; IsEquivalence)
+open import Relation.Binary.Core using (Rel; REL; _⇒_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions as B
 open import Relation.Binary.Indexed.Heterogeneous as I
   using (IREL; IRel; IndexedSetoid; IsIndexedEquivalence)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 ------------------------------------------------------------------------
 -- Pointwise lifting
@@ -25,7 +27,7 @@ infixr 4 _,_
 record POINTWISE {a₁ a₂ b₁ b₂ ℓ₁ ℓ₂}
                  {A₁ : Set a₁} (B₁ : A₁ → Set b₁)
                  {A₂ : Set a₂} (B₂ : A₂ → Set b₂)
-                 (_R₁_ : B.REL A₁ A₂ ℓ₁) (_R₂_ : IREL B₁ B₂ ℓ₂)
+                 (_R₁_ : REL A₁ A₂ ℓ₁) (_R₂_ : IREL B₁ B₂ ℓ₂)
                  (xy₁ : Σ A₁ B₁) (xy₂ : Σ A₂ B₂)
                  : Set (a₁ ⊔ a₂ ⊔ b₁ ⊔ b₂ ⊔ ℓ₁ ⊔ ℓ₂) where
   constructor _,_
@@ -36,14 +38,14 @@ record POINTWISE {a₁ a₂ b₁ b₂ ℓ₁ ℓ₂}
 open POINTWISE public
 
 Pointwise : ∀ {a b ℓ₁ ℓ₂} {A : Set a} (B : A → Set b)
-            (_R₁_ : B.Rel A ℓ₁) (_R₂_ : IRel B ℓ₂) → B.Rel (Σ A B) _
+            (_R₁_ : Rel A ℓ₁) (_R₂_ : IRel B ℓ₂) → Rel (Σ A B) _
 Pointwise B = POINTWISE B B
 
 ------------------------------------------------------------------------
 -- Pointwise preserves many relational properties
 
 module _ {a b ℓ₁ ℓ₂} {A : Set a} {B : A → Set b}
-         {R : B.Rel A ℓ₁} {S : IRel B ℓ₂} where
+         {R : Rel A ℓ₁} {S : IRel B ℓ₂} where
 
   private
     R×S = Pointwise B R S
diff --git a/src/Data/Product/Relation/Binary/Pointwise/Dependent/WithK.agda b/src/Data/Product/Relation/Binary/Pointwise/Dependent/WithK.agda
index c1228b5a91..cc6f36372f 100644
--- a/src/Data/Product/Relation/Binary/Pointwise/Dependent/WithK.agda
+++ b/src/Data/Product/Relation/Binary/Pointwise/Dependent/WithK.agda
@@ -9,34 +9,38 @@
 
 module Data.Product.Relation.Binary.Pointwise.Dependent.WithK where
 
-open import Data.Product
+open import Data.Product.Base using (Σ; uncurry; _,_)
 open import Data.Product.Relation.Binary.Pointwise.Dependent
 open import Function.Base
-open import Function.Inverse using (Inverse)
-open import Relation.Binary using (_⇒_)
-open import Relation.Binary.HeterogeneousEquality as H using (_≅_)
+open import Function.Bundles using (Inverse)
+open import Level using (Level)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.HeterogeneousEquality as ≅ using (_≅_)
 open import Relation.Binary.Indexed.Heterogeneous using (IndexedSetoid)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
+
+private
+  variable
+    a b : Level
+    I : Set a
+    A : I → Set a
 
 ------------------------------------------------------------------------
 -- The propositional equality setoid over sigma types can be
 -- decomposed using Pointwise
 
-module _ {a b} {A : Set a} {B : A → Set b} where
-
-  Pointwise-≡⇒≡ : Pointwise B _≡_ (λ x y → x ≅ y) ⇒ _≡_
-  Pointwise-≡⇒≡ (P.refl , H.refl) = P.refl
+Pointwise-≡⇒≡ : Pointwise A _≡_ (λ x y → x ≅ y) ⇒ _≡_
+Pointwise-≡⇒≡ (≡.refl , ≅.refl) = ≡.refl
 
-  ≡⇒Pointwise-≡ : _≡_ ⇒ Pointwise B _≡_ (λ x y → x ≅ y)
-  ≡⇒Pointwise-≡ P.refl = (P.refl , H.refl)
+≡⇒Pointwise-≡ : _≡_ ⇒ Pointwise A _≡_ (λ x y → x ≅ y)
+≡⇒Pointwise-≡ ≡.refl = (≡.refl , ≅.refl)
 
-  Pointwise-≡↔≡ : Inverse (setoid (P.setoid A) (H.indexedSetoid B))
-                  (P.setoid (Σ A B))
-  Pointwise-≡↔≡ = record
-    { to         = record { _⟨$⟩_ = id; cong = Pointwise-≡⇒≡ }
-    ; from       = record { _⟨$⟩_ = id; cong = ≡⇒Pointwise-≡ }
-    ; inverse-of = record
-      { left-inverse-of  = uncurry (λ _ _ → (P.refl , H.refl))
-      ; right-inverse-of = λ _ → P.refl
-      }
-    }
+Pointwise-≡↔≡ : Inverse (setoid (≡.setoid I) (≅.indexedSetoid A)) (≡.setoid (Σ I A))
+Pointwise-≡↔≡ = record
+  { to         = id
+  ; to-cong    = Pointwise-≡⇒≡
+  ; from       = id
+  ; from-cong  = ≡⇒Pointwise-≡
+  ; inverse    = (λ {(≡.refl , ≅.refl) → ≡.refl}) , λ {≡.refl → (≡.refl , ≅.refl)}
+  }
diff --git a/src/Data/Product/Relation/Binary/Pointwise/NonDependent.agda b/src/Data/Product/Relation/Binary/Pointwise/NonDependent.agda
index 1bbf5981e1..5e1c5c5c80 100644
--- a/src/Data/Product/Relation/Binary/Pointwise/NonDependent.agda
+++ b/src/Data/Product/Relation/Binary/Pointwise/NonDependent.agda
@@ -8,238 +8,199 @@
 
 module Data.Product.Relation.Binary.Pointwise.NonDependent where
 
-open import Data.Product as Prod
-open import Data.Product.Properties using (≡-dec)
-open import Data.Sum.Base
-open import Data.Unit.Base using (⊤)
-open import Function.Base
-open import Function.Equality as F using (_⟶_; _⟨$⟩_)
-open import Function.Equivalence as Eq
-  using (Equivalence; _⇔_; module Equivalence)
-open import Function.Injection as Inj
-  using (Injection; _↣_; module Injection)
-open import Function.Inverse as Inv
-  using (Inverse; _↔_; module Inverse)
-open import Function.LeftInverse as LeftInv
-  using (LeftInverse; _↞_; _LeftInverseOf_; module LeftInverse)
-open import Function.Related
-open import Function.Surjection as Surj
-  using (Surjection; _↠_; module Surjection)
+open import Data.Product.Base as Product
+open import Data.Sum.Base using (inj₁; inj₂)
+open import Level using (Level; _⊔_; 0ℓ)
+open import Function.Base using (id)
+open import Function.Bundles using (Inverse)
 open import Relation.Nullary.Decidable using (_×-dec_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
-
-module _ {a₁ a₂ ℓ₁ ℓ₂} {A₁ : Set a₁} {A₂ : Set a₂} where
+open import Relation.Binary.Core using (REL; Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (Setoid; DecSetoid; Preorder; Poset; StrictPartialOrder)
+open import Relation.Binary.Definitions
+open import Relation.Binary.Structures
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
+
+private
+  variable
+    a b ℓ₁ ℓ₂ ℓ₃ ℓ₄ : Level
+    A B C D : Set a
+    R S ≈₁ ≈₂ : Rel A ℓ₁
 
 ------------------------------------------------------------------------
--- Pointwise lifting
+-- Definition
 
-  Pointwise : Rel A₁ ℓ₁ → Rel A₂ ℓ₂ → Rel (A₁ × A₂) _
-  Pointwise _∼₁_ _∼₂_ = (_∼₁_ on proj₁) -×- (_∼₂_ on proj₂)
+Pointwise : REL A B ℓ₁ → REL C D ℓ₂ → REL (A × C) (B × D) (ℓ₁ ⊔ ℓ₂)
+Pointwise R S (a , c) (b , d) = (R a b) × (S c d)
 
 ------------------------------------------------------------------------
 -- Pointwise preserves many relational properties
 
-  ×-reflexive : ∀ {_≈₁_ _∼₁_ _≈₂_ _∼₂_} →
-    _≈₁_ ⇒ _∼₁_ → _≈₂_ ⇒ _∼₂_ →
-    (Pointwise _≈₁_ _≈₂_) ⇒ (Pointwise _∼₁_ _∼₂_)
-  ×-reflexive refl₁ refl₂ (x∼y₁ , x∼y₂) = refl₁ x∼y₁ , refl₂ x∼y₂
-
-  ×-refl : ∀ {_∼₁_ _∼₂_} →
-    Reflexive _∼₁_ → Reflexive _∼₂_ →
-    Reflexive (Pointwise _∼₁_ _∼₂_)
-  ×-refl refl₁ refl₂ = refl₁ , refl₂
-
-  ×-irreflexive₁ : ∀ {_≈₁_ _<₁_ _≈₂_ _<₂_} →
-    Irreflexive _≈₁_ _<₁_ →
-    Irreflexive (Pointwise _≈₁_ _≈₂_) (Pointwise _<₁_ _<₂_)
-  ×-irreflexive₁ ir x≈y x<y = ir (proj₁ x≈y) (proj₁ x<y)
-
-  ×-irreflexive₂ : ∀ {_≈₁_ _<₁_ _≈₂_ _<₂_} →
-    Irreflexive _≈₂_ _<₂_ →
-    Irreflexive (Pointwise _≈₁_ _≈₂_) (Pointwise _<₁_ _<₂_)
-  ×-irreflexive₂ ir x≈y x<y = ir (proj₂ x≈y) (proj₂ x<y)
-
-  ×-symmetric : ∀ {_∼₁_ _∼₂_} → Symmetric _∼₁_ → Symmetric _∼₂_ →
-    Symmetric (Pointwise _∼₁_ _∼₂_)
-  ×-symmetric sym₁ sym₂ (x∼y₁ , x∼y₂) = sym₁ x∼y₁ , sym₂ x∼y₂
-
-  ×-transitive : ∀ {_∼₁_ _∼₂_} → Transitive _∼₁_ → Transitive _∼₂_ →
-    Transitive (Pointwise _∼₁_ _∼₂_)
-  ×-transitive trans₁ trans₂ x∼y y∼z =
-    trans₁ (proj₁ x∼y) (proj₁ y∼z) ,
-    trans₂ (proj₂ x∼y) (proj₂ y∼z)
-
-  ×-antisymmetric : ∀ {_≈₁_ _≤₁_ _≈₂_ _≤₂_} →
-    Antisymmetric _≈₁_ _≤₁_ → Antisymmetric _≈₂_ _≤₂_ →
-    Antisymmetric (Pointwise _≈₁_ _≈₂_) (Pointwise _≤₁_ _≤₂_)
-  ×-antisymmetric antisym₁ antisym₂ (x≤y₁ , x≤y₂) (y≤x₁ , y≤x₂) =
-    (antisym₁ x≤y₁ y≤x₁ , antisym₂ x≤y₂ y≤x₂)
-
-  ×-asymmetric₁ : ∀ {_<₁_ _∼₂_} → Asymmetric _<₁_ →
-    Asymmetric (Pointwise _<₁_ _∼₂_)
-  ×-asymmetric₁ asym₁ x<y y<x = asym₁ (proj₁ x<y) (proj₁ y<x)
-
-  ×-asymmetric₂ : ∀ {_∼₁_ _<₂_} → Asymmetric _<₂_ →
-    Asymmetric (Pointwise _∼₁_ _<₂_)
-  ×-asymmetric₂ asym₂ x<y y<x = asym₂ (proj₂ x<y) (proj₂ y<x)
-
-  ×-respects₂ : ∀ {_≈₁_ _∼₁_ _≈₂_ _∼₂_} →
-    _∼₁_ Respects₂ _≈₁_ → _∼₂_ Respects₂ _≈₂_ →
-    (Pointwise _∼₁_ _∼₂_) Respects₂ (Pointwise _≈₁_ _≈₂_)
-  ×-respects₂ {_≈₁_} {_∼₁_} {_≈₂_} {_∼₂_} resp₁ resp₂ = resp¹ , resp²
-    where
-    _∼_ = Pointwise _∼₁_ _∼₂_
-    _≈_ = Pointwise _≈₁_ _≈₂_
-
-    resp¹ : ∀ {x} → (x ∼_) Respects _≈_
-    resp¹ y≈y′ x∼y = proj₁ resp₁ (proj₁ y≈y′) (proj₁ x∼y) ,
-                     proj₁ resp₂ (proj₂ y≈y′) (proj₂ x∼y)
-
-    resp² : ∀ {y} → (_∼ y) Respects _≈_
-    resp² x≈x′ x∼y = proj₂ resp₁ (proj₁ x≈x′) (proj₁ x∼y) ,
-                     proj₂ resp₂ (proj₂ x≈x′) (proj₂ x∼y)
-
-  ×-total : ∀ {_∼₁_ _∼₂_} → Symmetric _∼₁_ →
-    Total _∼₁_ → Total _∼₂_ →
-    Total (Pointwise _∼₁_ _∼₂_)
-  ×-total sym₁ total₁ total₂ (x₁ , x₂) (y₁ , y₂)
-    with total₁ x₁ y₁ | total₂ x₂ y₂
-  ... | inj₁ x₁∼y₁ | inj₁ x₂∼y₂ = inj₁ (     x₁∼y₁ , x₂∼y₂)
-  ... | inj₁ x₁∼y₁ | inj₂ y₂∼x₂ = inj₂ (sym₁ x₁∼y₁ , y₂∼x₂)
-  ... | inj₂ y₁∼x₁ | inj₂ y₂∼x₂ = inj₂ (     y₁∼x₁ , y₂∼x₂)
-  ... | inj₂ y₁∼x₁ | inj₁ x₂∼y₂ = inj₁ (sym₁ y₁∼x₁ , x₂∼y₂)
-
-  ×-decidable : ∀ {_∼₁_ _∼₂_} →
-    Decidable _∼₁_ → Decidable _∼₂_ →
-    Decidable (Pointwise _∼₁_ _∼₂_)
-  ×-decidable _≟₁_ _≟₂_ (x₁ , x₂) (y₁ , y₂) =
-    (x₁ ≟₁ y₁) ×-dec (x₂ ≟₂ y₂)
-
-  -- Some collections of properties which are preserved by ×-Rel.
-
-  ×-isEquivalence : ∀ {_≈₁_ _≈₂_} →
-    IsEquivalence _≈₁_ → IsEquivalence _≈₂_ →
-    IsEquivalence (Pointwise _≈₁_ _≈₂_)
-  ×-isEquivalence {_≈₁_ = _≈₁_} {_≈₂_ = _≈₂_} eq₁ eq₂ = record
-    { refl  = ×-refl        {_∼₁_ = _≈₁_} {_∼₂_ = _≈₂_}
-                            (refl  eq₁) (refl  eq₂)
-    ; sym   = ×-symmetric   {_∼₁_ = _≈₁_} {_∼₂_ = _≈₂_}
-                            (sym   eq₁) (sym   eq₂)
-    ; trans = ×-transitive  {_∼₁_ = _≈₁_} {_∼₂_ = _≈₂_}
-                            (trans eq₁) (trans eq₂)
-    }
-    where open IsEquivalence
-
-  ×-isDecEquivalence : ∀ {_≈₁_ _≈₂_} →
-    IsDecEquivalence _≈₁_ → IsDecEquivalence _≈₂_ →
-    IsDecEquivalence (Pointwise _≈₁_ _≈₂_)
-  ×-isDecEquivalence eq₁ eq₂ = record
-    { isEquivalence = ×-isEquivalence
-                        (isEquivalence eq₁) (isEquivalence eq₂)
-    ; _≟_           = ×-decidable (_≟_ eq₁) (_≟_ eq₂)
-    }
-    where open IsDecEquivalence
-
-  ×-isPreorder : ∀ {_≈₁_ _∼₁_ _≈₂_ _∼₂_} →
-    IsPreorder _≈₁_ _∼₁_ → IsPreorder _≈₂_ _∼₂_ →
-    IsPreorder (Pointwise _≈₁_ _≈₂_) (Pointwise _∼₁_ _∼₂_)
-  ×-isPreorder {_∼₁_ = _∼₁_} {_∼₂_ = _∼₂_} pre₁ pre₂ = record
-    { isEquivalence = ×-isEquivalence
-                        (isEquivalence pre₁) (isEquivalence pre₂)
-    ; reflexive     = ×-reflexive {_∼₁_ = _∼₁_} {_∼₂_ = _∼₂_}
-                        (reflexive pre₁) (reflexive pre₂)
-    ; trans         = ×-transitive {_∼₁_ = _∼₁_} {_∼₂_ = _∼₂_}
-                        (trans pre₁) (trans pre₂)
-    }
-    where open IsPreorder
-
-  ×-isPartialOrder : ∀ {_≈₁_ _≤₁_ _≈₂_ _≤₂_} →
-    IsPartialOrder _≈₁_ _≤₁_ → IsPartialOrder _≈₂_ _≤₂_ →
-    IsPartialOrder (Pointwise _≈₁_ _≈₂_) (Pointwise _≤₁_ _≤₂_)
-  ×-isPartialOrder {_≤₁_ = _≤₁_} {_≤₂_ = _≤₂_} po₁ po₂ = record
-    { isPreorder = ×-isPreorder (isPreorder po₁) (isPreorder po₂)
-    ; antisym    = ×-antisymmetric {_≤₁_ = _≤₁_} {_≤₂_ = _≤₂_}
-                     (antisym po₁) (antisym po₂)
-    }
-    where open IsPartialOrder
-
-  ×-isStrictPartialOrder : ∀ {_≈₁_ _<₁_ _≈₂_ _<₂_} →
-    IsStrictPartialOrder _≈₁_ _<₁_ → IsStrictPartialOrder _≈₂_ _<₂_ →
-    IsStrictPartialOrder (Pointwise _≈₁_ _≈₂_) (Pointwise _<₁_ _<₂_)
-  ×-isStrictPartialOrder {_<₁_ = _<₁_} {_≈₂_ = _≈₂_} {_<₂_ = _<₂_}
-                           spo₁ spo₂ =
-    record
-      { isEquivalence = ×-isEquivalence
-                          (isEquivalence spo₁) (isEquivalence spo₂)
-      ; irrefl        = ×-irreflexive₁ {_<₁_ = _<₁_} {_≈₂_} {_<₂_}
-                          (irrefl spo₁)
-      ; trans         = ×-transitive {_∼₁_ = _<₁_} {_<₂_}
-                          (trans spo₁) (trans spo₂)
-      ; <-resp-≈      = ×-respects₂ (<-resp-≈ spo₁) (<-resp-≈ spo₂)
-      }
-    where open IsStrictPartialOrder
+×-reflexive : ≈₁ ⇒ R → ≈₂ ⇒ S → Pointwise ≈₁ ≈₂ ⇒ Pointwise R S
+×-reflexive refl₁ refl₂ = Product.map refl₁ refl₂
+
+×-refl : Reflexive R → Reflexive S → Reflexive (Pointwise R S)
+×-refl refl₁ refl₂ = refl₁ , refl₂
+
+×-irreflexive₁ : Irreflexive ≈₁ R →
+                 Irreflexive (Pointwise ≈₁ ≈₂) (Pointwise R S)
+×-irreflexive₁ ir x≈y x<y = ir (proj₁ x≈y) (proj₁ x<y)
+
+×-irreflexive₂ : Irreflexive ≈₂ S →
+                 Irreflexive (Pointwise ≈₁ ≈₂) (Pointwise R S)
+×-irreflexive₂ ir x≈y x<y = ir (proj₂ x≈y) (proj₂ x<y)
+
+×-symmetric : Symmetric R → Symmetric S → Symmetric (Pointwise R S)
+×-symmetric sym₁ sym₂ = Product.map sym₁ sym₂
+
+×-transitive : Transitive R → Transitive S → Transitive (Pointwise R S)
+×-transitive trans₁ trans₂ = Product.zip trans₁ trans₂
+
+×-antisymmetric : Antisymmetric ≈₁ R → Antisymmetric ≈₂ S →
+                  Antisymmetric (Pointwise ≈₁ ≈₂) (Pointwise R S)
+×-antisymmetric antisym₁ antisym₂ = Product.zip antisym₁ antisym₂
+
+×-asymmetric₁ : Asymmetric R → Asymmetric (Pointwise R S)
+×-asymmetric₁ asym₁ x<y y<x = asym₁ (proj₁ x<y) (proj₁ y<x)
+
+×-asymmetric₂ : Asymmetric S → Asymmetric (Pointwise R S)
+×-asymmetric₂ asym₂ x<y y<x = asym₂ (proj₂ x<y) (proj₂ y<x)
+
+×-respectsʳ : R Respectsʳ ≈₁ → S Respectsʳ ≈₂ →
+             (Pointwise R S) Respectsʳ (Pointwise ≈₁ ≈₂)
+×-respectsʳ resp₁ resp₂ = Product.zip resp₁ resp₂
+
+×-respectsˡ : R Respectsˡ ≈₁ → S Respectsˡ ≈₂ →
+             (Pointwise R S) Respectsˡ (Pointwise ≈₁ ≈₂)
+×-respectsˡ resp₁ resp₂ = Product.zip resp₁ resp₂
+
+×-respects₂ : R Respects₂ ≈₁ → S Respects₂ ≈₂ →
+              (Pointwise R S) Respects₂ (Pointwise ≈₁ ≈₂)
+×-respects₂ = Product.zip ×-respectsʳ ×-respectsˡ
+
+×-total : Symmetric R → Total R → Total S → Total (Pointwise R S)
+×-total sym₁ total₁ total₂ (x₁ , x₂) (y₁ , y₂)
+  with total₁ x₁ y₁ | total₂ x₂ y₂
+... | inj₁ x₁∼y₁ | inj₁ x₂∼y₂ = inj₁ (     x₁∼y₁ , x₂∼y₂)
+... | inj₁ x₁∼y₁ | inj₂ y₂∼x₂ = inj₂ (sym₁ x₁∼y₁ , y₂∼x₂)
+... | inj₂ y₁∼x₁ | inj₂ y₂∼x₂ = inj₂ (     y₁∼x₁ , y₂∼x₂)
+... | inj₂ y₁∼x₁ | inj₁ x₂∼y₂ = inj₁ (sym₁ y₁∼x₁ , x₂∼y₂)
+
+×-decidable : Decidable R → Decidable S → Decidable (Pointwise R S)
+×-decidable _≟₁_ _≟₂_ (x₁ , x₂) (y₁ , y₂) = (x₁ ≟₁ y₁) ×-dec (x₂ ≟₂ y₂)
+
+------------------------------------------------------------------------
+-- Structures can also be combined.
+
+-- Some collections of properties which are preserved by ×-Rel.
+
+×-isEquivalence : IsEquivalence R → IsEquivalence S →
+                  IsEquivalence (Pointwise R S)
+×-isEquivalence {R = R} {S = S} eq₁ eq₂ = record
+  { refl  = ×-refl {R = R} {S = S} (refl eq₁) (refl eq₂)
+  ; sym   = ×-symmetric {R = R} {S = S} (sym eq₁) (sym eq₂)
+  ; trans = ×-transitive {R = R} {S = S} (trans eq₁) (trans eq₂)
+  } where open IsEquivalence
+
+×-isDecEquivalence : IsDecEquivalence R → IsDecEquivalence S →
+                     IsDecEquivalence (Pointwise R S)
+×-isDecEquivalence eq₁ eq₂ = record
+  { isEquivalence = ×-isEquivalence
+                      (isEquivalence eq₁) (isEquivalence eq₂)
+  ; _≟_           = ×-decidable (_≟_ eq₁) (_≟_ eq₂)
+  } where open IsDecEquivalence
+
+×-isPreorder : IsPreorder ≈₁ R → IsPreorder ≈₂ S →
+               IsPreorder (Pointwise ≈₁ ≈₂) (Pointwise R S)
+×-isPreorder {R = R} {S = S} pre₁ pre₂ = record
+  { isEquivalence = ×-isEquivalence
+                      (isEquivalence pre₁) (isEquivalence pre₂)
+  ; reflexive     = ×-reflexive {R = R} {S = S}
+                      (reflexive pre₁) (reflexive pre₂)
+  ; trans         = ×-transitive {R = R} {S = S}
+                      (trans pre₁) (trans pre₂)
+  } where open IsPreorder
+
+×-isPartialOrder : IsPartialOrder ≈₁ R → IsPartialOrder ≈₂ S →
+                   IsPartialOrder (Pointwise ≈₁ ≈₂) (Pointwise R S)
+×-isPartialOrder {R = R} {S = S} po₁ po₂ = record
+  { isPreorder = ×-isPreorder (isPreorder po₁) (isPreorder po₂)
+  ; antisym    = ×-antisymmetric {R = R} {S = S}
+                   (antisym po₁) (antisym po₂)
+  } where open IsPartialOrder
+
+×-isStrictPartialOrder : IsStrictPartialOrder ≈₁ R →
+                         IsStrictPartialOrder ≈₂ S →
+                         IsStrictPartialOrder (Pointwise ≈₁ ≈₂) (Pointwise R S)
+×-isStrictPartialOrder {R = R} {≈₂ = ≈₂} {S = S} spo₁ spo₂ = record
+  { isEquivalence = ×-isEquivalence
+                      (isEquivalence spo₁) (isEquivalence spo₂)
+  ; irrefl        = ×-irreflexive₁ {R = R} {≈₂ = ≈₂} {S = S}
+                      (irrefl spo₁)
+  ; trans         = ×-transitive {R = R} {S = S}
+                      (trans spo₁) (trans spo₂)
+  ; <-resp-≈      = ×-respects₂ (<-resp-≈ spo₁) (<-resp-≈ spo₂)
+  } where open IsStrictPartialOrder
 
 ------------------------------------------------------------------------
--- "Bundles" can also be combined.
-
-module _ {ℓ₁ ℓ₂ ℓ₃ ℓ₄} where
-
-  ×-preorder : Preorder ℓ₁ ℓ₂ _ → Preorder ℓ₃ ℓ₄ _ → Preorder _ _ _
-  ×-preorder p₁ p₂ = record
-    { isPreorder = ×-isPreorder (isPreorder p₁) (isPreorder p₂)
-    } where open Preorder
-
-  ×-setoid : Setoid ℓ₁ ℓ₂ → Setoid ℓ₃ ℓ₄ → Setoid _ _
-  ×-setoid s₁ s₂ = record
-    { isEquivalence =
-        ×-isEquivalence (isEquivalence s₁) (isEquivalence s₂)
-    } where open Setoid
-
-  ×-decSetoid : DecSetoid ℓ₁ ℓ₂ → DecSetoid ℓ₃ ℓ₄ → DecSetoid _ _
-  ×-decSetoid s₁ s₂ = record
-    { isDecEquivalence =
-        ×-isDecEquivalence (isDecEquivalence s₁) (isDecEquivalence s₂)
-    } where open DecSetoid
-
-  ×-poset : Poset ℓ₁ ℓ₂ _ → Poset ℓ₃ ℓ₄ _ → Poset _ _ _
-  ×-poset s₁ s₂ = record
-    { isPartialOrder = ×-isPartialOrder (isPartialOrder s₁)
-                       (isPartialOrder s₂)
-    } where open Poset
-
-  ×-strictPartialOrder :
-    StrictPartialOrder ℓ₁ ℓ₂ _ → StrictPartialOrder ℓ₃ ℓ₄ _ →
-    StrictPartialOrder _ _ _
-  ×-strictPartialOrder s₁ s₂ = record
-    { isStrictPartialOrder = ×-isStrictPartialOrder
-                               (isStrictPartialOrder s₁)
-                               (isStrictPartialOrder s₂)
-    } where open StrictPartialOrder
-
-  -- A piece of infix notation for combining setoids
-  infix 4 _×ₛ_
-  _×ₛ_ : Setoid ℓ₁ ℓ₂ → Setoid ℓ₃ ℓ₄ → Setoid _ _
-  _×ₛ_ = ×-setoid
+-- Bundles
+
+×-setoid : Setoid a ℓ₁ → Setoid b ℓ₂ → Setoid _ _
+×-setoid s₁ s₂ = record
+  { isEquivalence =
+      ×-isEquivalence (isEquivalence s₁) (isEquivalence s₂)
+  } where open Setoid
+
+×-decSetoid : DecSetoid a ℓ₁ → DecSetoid b ℓ₂ → DecSetoid _ _
+×-decSetoid s₁ s₂ = record
+  { isDecEquivalence =
+      ×-isDecEquivalence (isDecEquivalence s₁) (isDecEquivalence s₂)
+  } where open DecSetoid
+
+×-preorder : Preorder a ℓ₁ ℓ₂ → Preorder b ℓ₃ ℓ₄ → Preorder _ _ _
+×-preorder p₁ p₂ = record
+  { isPreorder = ×-isPreorder (isPreorder p₁) (isPreorder p₂)
+  } where open Preorder
+
+×-poset : Poset a ℓ₁ ℓ₂ → Poset b ℓ₃ ℓ₄ → Poset _ _ _
+×-poset s₁ s₂ = record
+  { isPartialOrder = ×-isPartialOrder (isPartialOrder s₁)
+                     (isPartialOrder s₂)
+  } where open Poset
+
+×-strictPartialOrder : StrictPartialOrder a ℓ₁ ℓ₂ →
+                       StrictPartialOrder b ℓ₃ ℓ₄ →
+                       StrictPartialOrder _ _ _
+×-strictPartialOrder s₁ s₂ = record
+  { isStrictPartialOrder = ×-isStrictPartialOrder
+                             (isStrictPartialOrder s₁)
+                             (isStrictPartialOrder s₂)
+  } where open StrictPartialOrder
+
+------------------------------------------------------------------------
+-- Additional notation
+
+-- Infix combining setoids
+infix 4 _×ₛ_
+_×ₛ_ : Setoid a ℓ₁ → Setoid b ℓ₂ → Setoid _ _
+_×ₛ_ = ×-setoid
 
 ------------------------------------------------------------------------
 -- The propositional equality setoid over products can be
 -- decomposed using ×-Rel
 
-module _ {a b} {A : Set a} {B : Set b} where
-
-  ≡×≡⇒≡ : Pointwise _≡_ _≡_ ⇒ _≡_ {A = A × B}
-  ≡×≡⇒≡ (P.refl , P.refl) = P.refl
+≡×≡⇒≡ : Pointwise _≡_ _≡_ ⇒ _≡_ {A = A × B}
+≡×≡⇒≡ (≡.refl , ≡.refl) = ≡.refl
 
-  ≡⇒≡×≡ : _≡_ {A = A × B} ⇒ Pointwise _≡_ _≡_
-  ≡⇒≡×≡ P.refl = (P.refl , P.refl)
+≡⇒≡×≡ : _≡_ {A = A × B} ⇒ Pointwise _≡_ _≡_
+≡⇒≡×≡ ≡.refl = (≡.refl , ≡.refl)
 
-  Pointwise-≡↔≡ : Inverse (P.setoid A ×ₛ P.setoid B) (P.setoid (A × B))
-  Pointwise-≡↔≡ = record
-    { to         = record { _⟨$⟩_ = id; cong = ≡×≡⇒≡ }
-    ; from       = record { _⟨$⟩_ = id; cong = ≡⇒≡×≡ }
-    ; inverse-of = record
-      { left-inverse-of  = λ _ → (P.refl , P.refl)
-      ; right-inverse-of = λ _ → P.refl
-      }
-    }
+Pointwise-≡↔≡ : Inverse (≡.setoid A ×ₛ ≡.setoid B) (≡.setoid (A × B))
+Pointwise-≡↔≡ = record
+  { to         = id
+  ; from       = id
+  ; to-cong    = ≡×≡⇒≡
+  ; from-cong  = ≡⇒≡×≡
+  ; inverse    = ≡×≡⇒≡ , ≡⇒≡×≡
+  }
diff --git a/src/Data/Product/Relation/Unary/All.agda b/src/Data/Product/Relation/Unary/All.agda
index 8c1b67dc50..1257de57c2 100644
--- a/src/Data/Product/Relation/Unary/All.agda
+++ b/src/Data/Product/Relation/Unary/All.agda
@@ -8,10 +8,8 @@
 
 module Data.Product.Relation.Unary.All where
 
-open import Level
-open import Data.Product
-open import Function.Base
-open import Relation.Unary
+open import Level using (Level; _⊔_)
+open import Data.Product.Base using (_×_; _,_)
 
 private
   variable
diff --git a/src/Data/Rational.agda b/src/Data/Rational.agda
index 260aa44951..2345466dcb 100644
--- a/src/Data/Rational.agda
+++ b/src/Data/Rational.agda
@@ -26,7 +26,7 @@ open import Data.Rational.Properties public
 -- Version 1.5
 
 import Data.Integer.Show as ℤ
-open import Data.String using (String; _++_)
+open import Data.String.Base using (String; _++_)
 
 show : ℚ → String
 show p = ℤ.show (↥ p) ++ "/" ++ ℤ.show (↧ p)
diff --git a/src/Data/Rational/Base.agda b/src/Data/Rational/Base.agda
index 666cac3dc9..cfde351ac1 100644
--- a/src/Data/Rational/Base.agda
+++ b/src/Data/Rational/Base.agda
@@ -10,17 +10,19 @@ module Data.Rational.Base where
 
 open import Algebra.Bundles.Raw
 open import Data.Bool.Base using (Bool; true; false; if_then_else_)
-open import Data.Integer.Base as ℤ using (ℤ; +_; +0; +[1+_]; -[1+_])
+open import Data.Integer.Base as ℤ
+  using (ℤ; +_; +0; +[1+_]; -[1+_])
+  hiding (module ℤ)
 open import Data.Nat.GCD
-open import Data.Nat.Coprimality as C
+open import Data.Nat.Coprimality as ℕ
   using (Coprime; Bézout-coprime; coprime-/gcd; coprime?; ¬0-coprimeTo-2+)
-open import Data.Nat.Base as ℕ using (ℕ; zero; suc) hiding (module ℕ)
+open import Data.Nat.Base as ℕ using (ℕ; zero; suc; 2+) hiding (module ℕ)
 open import Data.Rational.Unnormalised.Base as ℚᵘ using (ℚᵘ; mkℚᵘ)
 open import Data.Sum.Base using (inj₂)
 open import Function.Base using (id)
 open import Level using (0ℓ)
-open import Relation.Nullary using (¬_; recompute)
-open import Relation.Nullary.Negation using (contradiction)
+open import Relation.Nullary.Decidable.Core using (recompute)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
 open import Relation.Unary using (Pred)
 open import Relation.Binary.Core using (Rel)
 open import Relation.Binary.PropositionalEquality.Core
@@ -64,8 +66,11 @@ mkℚ+ n (suc d) coprime = mkℚ (+ n) d coprime
 
 infix 4 _≃_
 
-_≃_ : Rel ℚ 0ℓ
-p ≃ q = (↥ p ℤ.* ↧ q) ≡ (↥ q ℤ.* ↧ p)
+data _≃_ : Rel ℚ 0ℓ where
+  *≡* : ∀ {p q} → (↥ p ℤ.* ↧ q) ≡ (↥ q ℤ.* ↧ p) → p ≃ q
+
+_≄_ : Rel ℚ 0ℓ
+p ≄ q = ¬ (p ≃ q)
 
 ------------------------------------------------------------------------
 -- Ordering of rationals
@@ -143,7 +148,7 @@ toℚᵘ (mkℚ n d-1 _) = mkℚᵘ n d-1
 fromℚᵘ : ℚᵘ → ℚ
 fromℚᵘ (mkℚᵘ n d-1) = n / suc d-1
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Some constants
 
 0ℚ : ℚ
@@ -176,13 +181,19 @@ NonPositive p = ℚᵘ.NonPositive (toℚᵘ p)
 NonNegative : Pred ℚ 0ℓ
 NonNegative p = ℚᵘ.NonNegative (toℚᵘ p)
 
+-- Instances
+
+open ℤ public
+  using (nonZero; pos; nonNeg; nonPos0; nonPos; neg)
+
 -- Constructors
 
 ≢-nonZero : ∀ {p} → p ≢ 0ℚ → NonZero p
-≢-nonZero {mkℚ -[1+ _ ] _       _} _   = _
-≢-nonZero {mkℚ +[1+ _ ] _       _} _   = _
-≢-nonZero {mkℚ +0       zero    _} p≢0 = contradiction refl p≢0
-≢-nonZero {mkℚ +0       (suc d) c} p≢0 = contradiction (λ {i} → C.recompute c {i}) ¬0-coprimeTo-2+
+≢-nonZero {mkℚ -[1+ _ ] _         _} _   = _
+≢-nonZero {mkℚ +[1+ _ ] _         _} _   = _
+≢-nonZero {mkℚ +0       zero      _} p≢0 = contradiction refl p≢0
+≢-nonZero {mkℚ +0       d@(suc m) c} p≢0 =
+  contradiction (λ {d} → ℕ.recompute c {d}) (¬0-coprimeTo-2+ {{ℕ.nonTrivial {m}}})
 
 >-nonZero : ∀ {p} → p > 0ℚ → NonZero p
 >-nonZero {p@(mkℚ _ _ _)} (*<* p<q) = ℚᵘ.>-nonZero {toℚᵘ p} (ℚᵘ.*<* p<q)
@@ -202,11 +213,11 @@ nonPositive {p@(mkℚ _ _ _)} (*≤* p≤q) = ℚᵘ.nonPositive {toℚᵘ p} (
 nonNegative : ∀ {p} → p ≥ 0ℚ → NonNegative p
 nonNegative {p@(mkℚ _ _ _)} (*≤* p≤q) = ℚᵘ.nonNegative {toℚᵘ p} (ℚᵘ.*≤* p≤q)
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Operations on rationals
 
--- For explanation of the `@record{}` annotations see notes in the equivalent
--- place in `Data.Rational.Unnormalised.Base`.
+-- For explanation of the `@record{}` annotations see notes in the
+-- equivalent place in `Data.Rational.Unnormalised.Base`.
 
 infix  8 -_ 1/_
 infixl 7 _*_ _÷_ _⊓_
@@ -226,8 +237,8 @@ p - q = p + (- q)
 
 -- reciprocal: requires a proof that the numerator is not zero
 1/_ : (p : ℚ) → .{{_ : NonZero p}} → ℚ
-1/ mkℚ +[1+ n ] d prf = mkℚ +[1+ d ] n (C.sym prf)
-1/ mkℚ -[1+ n ] d prf = mkℚ -[1+ d ] n (C.sym prf)
+1/ mkℚ +[1+ n ] d prf = mkℚ +[1+ d ] n (ℕ.sym prf)
+1/ mkℚ -[1+ n ] d prf = mkℚ -[1+ d ] n (ℕ.sym prf)
 
 -- division: requires a proof that the denominator is not zero
 _÷_ : (p q : ℚ) → .{{_ : NonZero q}} → ℚ
@@ -258,15 +269,11 @@ ceiling p@record{} = ℤ.- floor (- p)
 
 -- Truncate  (round towards 0)
 truncate : ℚ → ℤ
-truncate p with p ≤ᵇ 0ℚ
-... | true  = ceiling p
-... | false = floor p
+truncate p = if p ≤ᵇ 0ℚ then ceiling p else floor p
 
 -- Round (to nearest integer)
 round : ℚ → ℤ
-round p with p ≤ᵇ 0ℚ
-... | true  = ceiling (p - ½)
-... | false = floor (p + ½)
+round p = if p ≤ᵇ 0ℚ then ceiling (p - ½) else floor (p + ½)
 
 -- Fractional part (remainder after floor)
 fracPart : ℚ → ℚ
diff --git a/src/Data/Rational/Literals.agda b/src/Data/Rational/Literals.agda
index 089ed20db0..4162468058 100644
--- a/src/Data/Rational/Literals.agda
+++ b/src/Data/Rational/Literals.agda
@@ -8,9 +8,9 @@
 
 module Data.Rational.Literals where
 
-open import Agda.Builtin.FromNat
-open import Agda.Builtin.FromNeg
-open import Data.Unit using (⊤)
+open import Agda.Builtin.FromNat using (Number)
+open import Agda.Builtin.FromNeg using (Negative)
+open import Data.Unit.Base using (⊤)
 open import Data.Nat.Base using (ℕ; zero)
 open import Data.Nat.Coprimality using (sym; 1-coprimeTo)
 open import Data.Integer.Base using (ℤ; ∣_∣; +_; -_)
diff --git a/src/Data/Rational/Properties.agda b/src/Data/Rational/Properties.agda
index b9d18fab34..fb186be08d 100644
--- a/src/Data/Rational/Properties.agda
+++ b/src/Data/Rational/Properties.agda
@@ -9,6 +9,7 @@
 
 module Data.Rational.Properties where
 
+open import Algebra.Apartness
 open import Algebra.Construct.NaturalChoice.Base
 import Algebra.Construct.NaturalChoice.MinMaxOp as MinMaxOp
 import Algebra.Lattice.Construct.NaturalChoice.MinMaxOp as LatticeMinMaxOp
@@ -21,6 +22,7 @@ import Algebra.Morphism.GroupMonomorphism  as GroupMonomorphisms
 import Algebra.Morphism.RingMonomorphism   as RingMonomorphisms
 import Algebra.Lattice.Morphism.LatticeMonomorphism as LatticeMonomorphisms
 import Algebra.Properties.CommutativeSemigroup as CommSemigroupProperties
+import Algebra.Properties.Group as GroupProperties
 open import Data.Bool.Base using (T; true; false)
 open import Data.Integer.Base as ℤ using (ℤ; +_; -[1+_]; +[1+_]; +0; 0ℤ; 1ℤ; _◃_)
 open import Data.Integer.Coprimality using (coprime-divisor)
@@ -30,10 +32,10 @@ open import Data.Integer.Solver renaming (module +-*-Solver to ℤ-solver)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
 import Data.Nat.Properties as ℕ
 open import Data.Nat.Coprimality as C using (Coprime; coprime?)
-open import Data.Nat.Divisibility
+open import Data.Nat.Divisibility using (_∣_; divides; ∣-antisym; *-pres-∣)
 import Data.Nat.GCD as ℕ
 import Data.Nat.DivMod as ℕ
-open import Data.Product using (proj₁; proj₂; _×_; _,_; uncurry)
+open import Data.Product.Base using (proj₁; proj₂; _×_; _,_; uncurry)
 open import Data.Rational.Base
 open import Data.Rational.Unnormalised.Base as ℚᵘ
   using (ℚᵘ; mkℚᵘ; *≡*; *≤*; *<*)
@@ -43,19 +45,24 @@ open import Data.Rational.Unnormalised.Base as ℚᵘ
   ; _+_ to _+ᵘ_
   )
 import Data.Rational.Unnormalised.Properties as ℚᵘ
-open import Data.Sum.Base as Sum
-open import Data.Unit using (tt)
-import Data.Sign as S
+open import Data.Sum.Base as Sum using (inj₁; inj₂; [_,_]′; _⊎_)
+import Data.Sign.Base as Sign
 open import Function.Base using (_∘_; _∘′_; _∘₂_; _$_; flip)
 open import Function.Definitions using (Injective)
 open import Level using (0ℓ)
 open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
 open import Relation.Binary.Morphism.Structures
 import Relation.Binary.Morphism.OrderMonomorphism as OrderMonomorphisms
-open import Relation.Nullary.Decidable as Dec
-  using (True; False; fromWitness; fromWitnessFalse; toWitnessFalse; yes; no; recompute; map′; _×-dec_)
-open import Relation.Nullary.Negation using (¬_; contradiction; contraposition)
+import Relation.Binary.Properties.DecSetoid as DecSetoidProperties
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂; sym; trans; _≢_; subst; subst₂; resp₂)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (setoid; decSetoid; module ≡-Reasoning; isEquivalence)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
+open import Relation.Binary.Reasoning.Syntax using (module ≃-syntax)
+open import Relation.Nullary.Decidable.Core as Dec
+  using (yes; no; recompute; map′; _×-dec_)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
 
 open import Algebra.Definitions {A = ℚ} _≡_
 open import Algebra.Structures  {A = ℚ} _≡_
@@ -94,6 +101,9 @@ mkℚ n₁ d₁ _ ≟ mkℚ n₂ d₂ _ = map′
 ≡-decSetoid : DecSetoid 0ℓ 0ℓ
 ≡-decSetoid = decSetoid _≟_
 
+1≢0 : 1ℚ ≢ 0ℚ
+1≢0 = λ ()
+
 ------------------------------------------------------------------------
 -- mkℚ+
 ------------------------------------------------------------------------
@@ -130,11 +140,14 @@ mkℚ+-pos (suc n) (suc d) = _
 -- Numerator and denominator equality
 ------------------------------------------------------------------------
 
+drop-*≡* : p ≃ q → ↥ p ℤ.* ↧ q ≡ ↥ q ℤ.* ↧ p
+drop-*≡* (*≡* eq) = eq
+
 ≡⇒≃ : _≡_ ⇒ _≃_
-≡⇒≃ refl = refl
+≡⇒≃ refl = *≡* refl
 
 ≃⇒≡ : _≃_ ⇒ _≡_
-≃⇒≡ {x = mkℚ n₁ d₁ c₁} {y = mkℚ n₂ d₂ c₂} eq = helper
+≃⇒≡ {x = mkℚ n₁ d₁ c₁} {y = mkℚ n₂ d₂ c₂} (*≡* eq) = helper
   where
   open ≡-Reasoning
 
@@ -159,6 +172,9 @@ mkℚ+-pos (suc n) (suc d) = _
   ... | refl with ℤ.*-cancelʳ-≡ n₁ n₂ (+ suc d₁) eq
   ...   | refl = refl
 
+≃-sym : Symmetric _≃_
+≃-sym = ≡⇒≃ ∘′ sym ∘′ ≃⇒≡
+
 ------------------------------------------------------------------------
 -- Properties of ↥
 ------------------------------------------------------------------------
@@ -170,6 +186,9 @@ mkℚ+-pos (suc n) (suc d) = _
 p≡0⇒↥p≡0 : ∀ p → p ≡ 0ℚ → ↥ p ≡ 0ℤ
 p≡0⇒↥p≡0 p refl = refl
 
+↥p≡↥q≡0⇒p≡q : ∀ p q → ↥ p ≡ 0ℤ → ↥ q ≡ 0ℤ → p ≡ q
+↥p≡↥q≡0⇒p≡q p q ↥p≡0 ↥q≡0 = trans (↥p≡0⇒p≡0 p ↥p≡0) (sym (↥p≡0⇒p≡0 q ↥q≡0))
+
 ------------------------------------------------------------------------
 -- Basic properties of sign predicates
 ------------------------------------------------------------------------
@@ -245,8 +264,8 @@ normalize-coprime {n} {d-1} c = begin
 ↥-normalize i n = begin
   ↥ (normalize i n) ℤ.* + g  ≡⟨ cong (ℤ._* + g) (↥-mkℚ+ _ (n ℕ./ g)) ⟩
   + i/g     ℤ.* + g          ≡⟨⟩
-  S.+ ◃ i/g ℕ.* g            ≡⟨ cong (S.+ ◃_) (ℕ.m/n*n≡m (ℕ.gcd[m,n]∣m i n)) ⟩
-  S.+ ◃ i                    ≡⟨ ℤ.+◃n≡+n i ⟩
+  Sign.+ ◃ i/g ℕ.* g         ≡⟨ cong (Sign.+ ◃_) (ℕ.m/n*n≡m (ℕ.gcd[m,n]∣m i n)) ⟩
+  Sign.+ ◃ i                 ≡⟨ ℤ.+◃n≡+n i ⟩
   + i                        ∎
   where
   open ≡-Reasoning
@@ -259,8 +278,8 @@ normalize-coprime {n} {d-1} c = begin
 ↧-normalize i n = begin
   ↧ (normalize i n) ℤ.* + g  ≡⟨ cong (ℤ._* + g) (↧-mkℚ+ _ (n ℕ./ g)) ⟩
   + (n ℕ./ g)       ℤ.* + g  ≡⟨⟩
-  S.+ ◃ n ℕ./ g     ℕ.* g    ≡⟨ cong (S.+ ◃_) (ℕ.m/n*n≡m (ℕ.gcd[m,n]∣n i n)) ⟩
-  S.+ ◃ n                    ≡⟨ ℤ.+◃n≡+n n ⟩
+  Sign.+ ◃ n ℕ./ g     ℕ.* g ≡⟨ cong (Sign.+ ◃_) (ℕ.m/n*n≡m (ℕ.gcd[m,n]∣n i n)) ⟩
+  Sign.+ ◃ n                 ≡⟨ ℤ.+◃n≡+n n ⟩
   + n                        ∎
   where
   open ≡-Reasoning
@@ -301,12 +320,12 @@ normalize-injective-≃ : ∀ m n c d {{_ : ℕ.NonZero c}} {{_ : ℕ.NonZero d}
 normalize-injective-≃ m n c d eq = ℕ./-cancelʳ-≡
   md∣gcd[m,c]gcd[n,d]
   nc∣gcd[m,c]gcd[n,d]
-  (begin
+  $ begin
     (m ℕ.* d) ℕ./ (gcd[m,c] ℕ.* gcd[n,d]) ≡⟨  ℕ./-*-interchange gcd[m,c]∣m gcd[n,d]∣d ⟩
     (m ℕ./ gcd[m,c]) ℕ.* (d ℕ./ gcd[n,d]) ≡⟨  cong₂ ℕ._*_ m/gcd[m,c]≡n/gcd[n,d] (sym c/gcd[m,c]≡d/gcd[n,d]) ⟩
-    (n ℕ./ gcd[n,d]) ℕ.* (c ℕ./ gcd[m,c]) ≡˘⟨ ℕ./-*-interchange gcd[n,d]∣n gcd[m,c]∣c ⟩
-    (n ℕ.* c) ℕ./ (gcd[n,d] ℕ.* gcd[m,c]) ≡⟨  ℕ./-congʳ (ℕ.*-comm gcd[n,d] gcd[m,c]) ⟩
-    (n ℕ.* c) ℕ./ (gcd[m,c] ℕ.* gcd[n,d]) ∎)
+    (n ℕ./ gcd[n,d]) ℕ.* (c ℕ./ gcd[m,c]) ≡⟨ ℕ./-*-interchange gcd[n,d]∣n gcd[m,c]∣c ⟨
+    (n ℕ.* c) ℕ./ (gcd[n,d] ℕ.* gcd[m,c]) ≡⟨ ℕ./-congʳ (ℕ.*-comm gcd[n,d] gcd[m,c]) ⟩
+    (n ℕ.* c) ℕ./ (gcd[m,c] ℕ.* gcd[n,d]) ∎
   where
   open ≡-Reasoning
   gcd[m,c]   = ℕ.gcd m c
@@ -321,14 +340,13 @@ normalize-injective-≃ m n c d eq = ℕ./-cancelʳ-≡
 
   gcd[m,c]≢0′          = ℕ.gcd[m,n]≢0 m c (inj₂ (ℕ.≢-nonZero⁻¹ c))
   gcd[n,d]≢0′          = ℕ.gcd[m,n]≢0 n d (inj₂ (ℕ.≢-nonZero⁻¹ d))
-  gcd[m,c]*gcd[n,d]≢0′ = Sum.[ gcd[m,c]≢0′ , gcd[n,d]≢0′ ] ∘ ℕ.m*n≡0⇒m≡0∨n≡0 _
   instance
     gcd[m,c]≢0   = ℕ.≢-nonZero gcd[m,c]≢0′
     gcd[n,d]≢0   = ℕ.≢-nonZero gcd[n,d]≢0′
     c/gcd[m,c]≢0 = ℕ.≢-nonZero (ℕ.n/gcd[m,n]≢0 m c {{gcd≢0 = gcd[m,c]≢0}})
     d/gcd[n,d]≢0 = ℕ.≢-nonZero (ℕ.n/gcd[m,n]≢0 n d {{gcd≢0 = gcd[n,d]≢0}})
-    gcd[m,c]*gcd[n,d]≢0 = ℕ.≢-nonZero gcd[m,c]*gcd[n,d]≢0′
-    gcd[n,d]*gcd[m,c]≢0 = ℕ.≢-nonZero (subst (_≢ 0) (ℕ.*-comm gcd[m,c] gcd[n,d]) gcd[m,c]*gcd[n,d]≢0′)
+    gcd[m,c]*gcd[n,d]≢0 = ℕ.m*n≢0 gcd[m,c] gcd[n,d]
+    gcd[n,d]*gcd[m,c]≢0 = ℕ.m*n≢0 gcd[n,d] gcd[m,c]
 
   div = mkℚ+-injective eq
   m/gcd[m,c]≡n/gcd[n,d] = proj₁ div
@@ -344,7 +362,7 @@ normalize-injective-≃ m n c d eq = ℕ./-cancelʳ-≡
   ↥ (- norm)   ℤ.* + g  ≡⟨ cong (ℤ._* + g) (↥-neg norm) ⟩
   ℤ.- (↥ norm) ℤ.* + g  ≡⟨ sym (ℤ.neg-distribˡ-* (↥ norm) (+ g)) ⟩
   ℤ.- (↥ norm  ℤ.* + g) ≡⟨ cong (ℤ.-_) (↥-normalize (suc m) n) ⟩
-  S.- ◃ suc m           ≡⟨⟩
+  Sign.- ◃ suc m        ≡⟨⟩
   -[1+ m ]              ∎
   where
   open ℤ.≤-Reasoning
@@ -393,13 +411,13 @@ private
 
 /-injective-≃ : ∀ p q → ↥ᵘ p / ↧ₙᵘ p ≡ ↥ᵘ q / ↧ₙᵘ q → p ≃ᵘ q
 /-injective-≃ (mkℚᵘ (+ m)    c-1) (mkℚᵘ (+ n)    d-1) eq =
-  *≡* (cong (S.+ ◃_) (normalize-injective-≃ m n _ _ eq))
+  *≡* (cong (Sign.+ ◃_) (normalize-injective-≃ m n _ _ eq))
 /-injective-≃ (mkℚᵘ (+ m)    c-1) (mkℚᵘ -[1+ n ] d-1) eq =
   ℚᵘ.≃-sym (/-injective-≃-helper (sym eq))
 /-injective-≃ (mkℚᵘ -[1+ m ] c-1) (mkℚᵘ (+ n)    d-1) eq =
   /-injective-≃-helper eq
 /-injective-≃ (mkℚᵘ -[1+ m ] c-1) (mkℚᵘ -[1+ n ] d-1) eq =
-  *≡* (cong (S.- ◃_) (normalize-injective-≃ (suc m) (suc n) _ _ (neg-injective eq)))
+  *≡* (cong (Sign.- ◃_) (normalize-injective-≃ (suc m) (suc n) _ _ (neg-injective eq)))
 
 ------------------------------------------------------------------------
 -- Properties of toℚ/fromℚ
@@ -412,7 +430,7 @@ private
 ↧ᵘ-toℚᵘ p@record{} = refl
 
 toℚᵘ-injective : Injective _≡_ _≃ᵘ_ toℚᵘ
-toℚᵘ-injective {x@record{}} {y@record{}} (*≡* eq) = ≃⇒≡ eq
+toℚᵘ-injective {x@record{}} {y@record{}} (*≡* eq) = ≃⇒≡ (*≡* eq)
 
 fromℚᵘ-injective : Injective _≃ᵘ_ _≡_ fromℚᵘ
 fromℚᵘ-injective {p@record{}} {q@record{}} = /-injective-≃ p q
@@ -431,7 +449,7 @@ fromℚᵘ-cong : fromℚᵘ Preserves _≃ᵘ_ ⟶ _≡_
 fromℚᵘ-cong {p} {q} p≃q = toℚᵘ-injective (begin-equality
   toℚᵘ (fromℚᵘ p)  ≃⟨  toℚᵘ-fromℚᵘ p ⟩
   p                ≃⟨  p≃q ⟩
-  q                ≃˘⟨ toℚᵘ-fromℚᵘ q ⟩
+  q                ≃⟨ toℚᵘ-fromℚᵘ q ⟨
   toℚᵘ (fromℚᵘ q)  ∎)
   where open ℚᵘ.≤-Reasoning
 
@@ -491,7 +509,7 @@ private
 ≤-trans = ≤-Monomorphism.trans ℚᵘ.≤-trans
 
 ≤-antisym : Antisymmetric _≡_ _≤_
-≤-antisym (*≤* le₁) (*≤* le₂) = ≃⇒≡ (ℤ.≤-antisym le₁ le₂)
+≤-antisym (*≤* le₁) (*≤* le₂) = ≃⇒≡ (*≡* (ℤ.≤-antisym le₁ le₂))
 
 ≤-total : Total _≤_
 ≤-total p q = [ inj₁ ∘ *≤* , inj₂ ∘ *≤* ]′ (ℤ.≤-total (↥ p ℤ.* ↧ q) (↥ q ℤ.* ↧ p))
@@ -600,7 +618,7 @@ toℚᵘ-isOrderMonomorphism-< = record
 ≰⇒> {p} {q} p≰q = *<* (ℤ.≰⇒> (p≰q ∘ *≤*))
 
 <⇒≢ : _<_ ⇒ _≢_
-<⇒≢ {p} {q} (*<* p<q) = ℤ.<⇒≢ p<q ∘ ≡⇒≃
+<⇒≢ {p} {q} (*<* p<q) = ℤ.<⇒≢ p<q ∘ drop-*≡* ∘ ≡⇒≃
 
 <-irrefl : Irreflexive _≡_ _<_
 <-irrefl refl (*<* p<p) = ℤ.<-irrefl refl p<p
@@ -608,6 +626,20 @@ toℚᵘ-isOrderMonomorphism-< = record
 <-asym : Asymmetric _<_
 <-asym (*<* p<q) (*<* q<p) = ℤ.<-asym p<q q<p
 
+<-dense : Dense _<_
+<-dense {p} {q} p<q = let
+    m , p<ᵘm , m<ᵘq = ℚᵘ.<-dense (toℚᵘ-mono-< p<q)
+
+    m≃m : m ≃ᵘ toℚᵘ (fromℚᵘ m)
+    m≃m = ℚᵘ.≃-sym (toℚᵘ-fromℚᵘ m)
+
+    p<m : p < fromℚᵘ m
+    p<m = toℚᵘ-cancel-< (ℚᵘ.<-respʳ-≃ m≃m p<ᵘm)
+
+    m<q : fromℚᵘ m < q
+    m<q = toℚᵘ-cancel-< (ℚᵘ.<-respˡ-≃ m≃m m<ᵘq)
+  in fromℚᵘ m , p<m , m<q
+
 <-≤-trans : Trans _<_ _≤_ _<_
 <-≤-trans {p} {q} {r} (*<* p<q) (*≤* q≤r) = *<*
   (ℤ.*-cancelʳ-<-nonNeg _ (begin-strict
@@ -653,9 +685,9 @@ _>?_ = flip _<?_
 
 <-cmp : Trichotomous _≡_ _<_
 <-cmp p q with ℤ.<-cmp (↥ p ℤ.* ↧ q) (↥ q ℤ.* ↧ p)
-... | tri< < ≢ ≯ = tri< (*<* <)        (≢ ∘ ≡⇒≃) (≯ ∘ drop-*<*)
-... | tri≈ ≮ ≡ ≯ = tri≈ (≮ ∘ drop-*<*) (≃⇒≡ ≡)   (≯ ∘ drop-*<*)
-... | tri> ≮ ≢ > = tri> (≮ ∘ drop-*<*) (≢ ∘ ≡⇒≃) (*<* >)
+... | tri< < ≢ ≯ = tri< (*<* <)        (≢ ∘ drop-*≡* ∘ ≡⇒≃) (≯ ∘ drop-*<*)
+... | tri≈ ≮ ≡ ≯ = tri≈ (≮ ∘ drop-*<*) (≃⇒≡ (*≡* ≡))   (≯ ∘ drop-*<*)
+... | tri> ≮ ≢ > = tri> (≮ ∘ drop-*<*) (≢ ∘ drop-*≡* ∘ ≡⇒≃) (*<* >)
 
 <-irrelevant : Irrelevant _<_
 <-irrelevant (*<* p<q₁) (*<* p<q₂) = cong *<* (ℤ.<-irrelevant p<q₁ p<q₂)
@@ -682,9 +714,14 @@ _>?_ = flip _<?_
 
 <-isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_
 <-isStrictTotalOrder = record
-  { isEquivalence = isEquivalence
-  ; trans         = <-trans
-  ; compare       = <-cmp
+  { isStrictPartialOrder = <-isStrictPartialOrder
+  ; compare              = <-cmp
+  }
+
+<-isDenseLinearOrder : IsDenseLinearOrder _≡_ _<_
+<-isDenseLinearOrder = record
+  { isStrictTotalOrder = <-isStrictTotalOrder
+  ; dense              = <-dense
   }
 
 ------------------------------------------------------------------------
@@ -700,6 +737,11 @@ _>?_ = flip _<?_
   { isStrictTotalOrder = <-isStrictTotalOrder
   }
 
+<-denseLinearOrder : DenseLinearOrder 0ℓ 0ℓ 0ℓ
+<-denseLinearOrder = record
+  { isDenseLinearOrder = <-isDenseLinearOrder
+  }
+
 ------------------------------------------------------------------------
 -- A specialised module for reasoning about the _≤_ and _<_ relations
 ------------------------------------------------------------------------
@@ -707,22 +749,21 @@ _>?_ = flip _<?_
 module ≤-Reasoning where
   import Relation.Binary.Reasoning.Base.Triple
     ≤-isPreorder
+    <-asym
     <-trans
     (resp₂ _<_)
     <⇒≤
     <-≤-trans
     ≤-<-trans
     as Triple
-  open Triple public hiding (step-≈; step-≈˘)
 
-  infixr 2 step-≃ step-≃˘
+  open Triple public
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨)
 
-  step-≃  = Triple.step-≈
-  step-≃˘ = Triple.step-≈˘
-
-  syntax step-≃  x y∼z x≃y = x ≃⟨  x≃y ⟩ y∼z
-  syntax step-≃˘ x y∼z y≃x = x ≃˘⟨ y≃x ⟩ y∼z
+  ≃-go : Trans _≃_ _IsRelatedTo_ _IsRelatedTo_
+  ≃-go = Triple.≈-go ∘′ ≃⇒≡
 
+  open ≃-syntax _IsRelatedTo_ _IsRelatedTo_ ≃-go (λ {x y} → ≃-sym {x} {y}) public
 
 ------------------------------------------------------------------------
 -- Properties of Positive/NonPositive/Negative/NonNegative and _≤_/_<_
@@ -816,14 +857,14 @@ toℚᵘ-homo-+ p@record{} q@record{} with +-nf p q ℤ.≟ 0ℤ
   eq : ↥ (p + q) ≡ 0ℤ
   eq rewrite eq2 = cong ↥_ (0/n≡0 (↧ₙ p ℕ.* ↧ₙ q))
 
-... | no  nf[p,q]≢0 = *≡* $ ℤ.*-cancelʳ-≡ _ _ (+-nf p q) {{ℤ.≢-nonZero nf[p,q]≢0}} $ begin
+... | no  nf[p,q]≢0 = *≡* (ℤ.*-cancelʳ-≡ _ _ (+-nf p q) {{ℤ.≢-nonZero nf[p,q]≢0}} $ begin
     (↥ᵘ (toℚᵘ (p + q))) ℤ.* ↧+ᵘ p q  ℤ.* +-nf p q ≡⟨ cong (λ v → v ℤ.* ↧+ᵘ p q ℤ.* +-nf p q) (↥ᵘ-toℚᵘ (p + q)) ⟩
     ↥ (p + q) ℤ.* ↧+ᵘ p q ℤ.* +-nf p q            ≡⟨ xy∙z≈xz∙y (↥ (p + q)) _ _ ⟩
     ↥ (p + q) ℤ.* +-nf p q ℤ.* ↧+ᵘ p q            ≡⟨ cong (ℤ._* ↧+ᵘ p q) (↥-+ p q) ⟩
     ↥+ᵘ p q ℤ.* ↧+ᵘ p q                           ≡⟨ cong (↥+ᵘ p q ℤ.*_) (sym (↧-+ p q)) ⟩
     ↥+ᵘ p q ℤ.* (↧ (p + q) ℤ.* +-nf p q)          ≡⟨ x∙yz≈xy∙z (↥+ᵘ p q) _ _ ⟩
-    ↥+ᵘ p q ℤ.* ↧ (p + q)  ℤ.* +-nf p q           ≡˘⟨ cong (λ v → ↥+ᵘ p q ℤ.* v ℤ.* +-nf p q) (↧ᵘ-toℚᵘ (p + q)) ⟩
-    ↥+ᵘ p q ℤ.* ↧ᵘ (toℚᵘ (p + q)) ℤ.* +-nf p q    ∎
+    ↥+ᵘ p q ℤ.* ↧ (p + q)  ℤ.* +-nf p q           ≡⟨ cong (λ v → ↥+ᵘ p q ℤ.* v ℤ.* +-nf p q) (↧ᵘ-toℚᵘ (p + q)) ⟨
+    ↥+ᵘ p q ℤ.* ↧ᵘ (toℚᵘ (p + q)) ℤ.* +-nf p q    ∎)
   where open ≡-Reasoning; open CommSemigroupProperties ℤ.*-commutativeSemigroup
 
 toℚᵘ-isMagmaHomomorphism-+ : IsMagmaHomomorphism +-rawMagma ℚᵘ.+-rawMagma toℚᵘ
@@ -1027,14 +1068,14 @@ toℚᵘ-homo-* p@record{} q@record{} with *-nf p q ℤ.≟ 0ℤ
 
   eq : ↥ (p * q) ≡ 0ℤ
   eq rewrite eq2 = cong ↥_ (0/n≡0 (↧ₙ p ℕ.* ↧ₙ q))
-... | no nf[p,q]≢0 = *≡* $ ℤ.*-cancelʳ-≡ _ _ (*-nf p q) {{ℤ.≢-nonZero nf[p,q]≢0}} $ begin
+... | no nf[p,q]≢0 = *≡* (ℤ.*-cancelʳ-≡ _ _ (*-nf p q) {{ℤ.≢-nonZero nf[p,q]≢0}} $ begin
   ↥ᵘ (toℚᵘ (p * q)) ℤ.* (↧ p ℤ.* ↧ q) ℤ.* *-nf p q     ≡⟨ cong (λ v → v ℤ.* (↧ p ℤ.* ↧ q) ℤ.* *-nf p q) (↥ᵘ-toℚᵘ (p * q)) ⟩
   ↥ (p * q)         ℤ.* (↧ p ℤ.* ↧ q) ℤ.* *-nf p q     ≡⟨ xy∙z≈xz∙y (↥ (p * q)) _ _ ⟩
   ↥ (p * q)         ℤ.* *-nf p q ℤ.* (↧ p ℤ.* ↧ q)     ≡⟨ cong (ℤ._* (↧ p ℤ.* ↧ q)) (↥-* p q) ⟩
   (↥ p ℤ.* ↥ q)     ℤ.* (↧ p ℤ.* ↧ q)                  ≡⟨ cong ((↥ p ℤ.* ↥ q) ℤ.*_) (sym (↧-* p q)) ⟩
   (↥ p ℤ.* ↥ q)     ℤ.* (↧ (p * q) ℤ.* *-nf p q)       ≡⟨ x∙yz≈xy∙z (↥ p ℤ.* ↥ q) _ _ ⟩
-  (↥ p ℤ.* ↥ q)     ℤ.* ↧ (p * q)  ℤ.* *-nf p q        ≡˘⟨ cong (λ v → (↥ p ℤ.* ↥ q) ℤ.* v ℤ.* *-nf p q) (↧ᵘ-toℚᵘ (p * q)) ⟩
-  (↥ p ℤ.* ↥ q)     ℤ.* ↧ᵘ (toℚᵘ (p * q)) ℤ.* *-nf p q ∎
+  (↥ p ℤ.* ↥ q)     ℤ.* ↧ (p * q)  ℤ.* *-nf p q        ≡⟨ cong (λ v → (↥ p ℤ.* ↥ q) ℤ.* v ℤ.* *-nf p q) (↧ᵘ-toℚᵘ (p * q)) ⟨
+  (↥ p ℤ.* ↥ q)     ℤ.* ↧ᵘ (toℚᵘ (p * q)) ℤ.* *-nf p q ∎)
   where open ≡-Reasoning; open CommSemigroupProperties ℤ.*-commutativeSemigroup
 
 toℚᵘ-homo-1/ : ∀ p .{{_ : NonZero p}} → toℚᵘ (1/ p) ℚᵘ.≃ (ℚᵘ.1/ toℚᵘ p)
@@ -1205,12 +1246,59 @@ neg-distribʳ-* = +-*-Monomorphism.neg-distribʳ-* ℚᵘ.+-0-isGroup ℚᵘ.*-i
   { isCommutativeRing = +-*-isCommutativeRing
   }
 
+
+------------------------------------------------------------------------
+-- HeytingField structures and bundles
+
+module _ where
+  open CommutativeRing +-*-commutativeRing
+    using (+-group; zeroˡ; *-congʳ; isCommutativeRing)
+
+  open GroupProperties +-group
+  open DecSetoidProperties ≡-decSetoid
+
+  #⇒invertible : p ≢ q → Invertible 1ℚ _*_ (p - q)
+  #⇒invertible {p} {q} p≢q = let r = p - q in 1/ r , *-inverseˡ r , *-inverseʳ r
+    where instance _ = ≢-nonZero (p≢q ∘ (x∙y⁻¹≈ε⇒x≈y p q))
+
+  invertible⇒# : Invertible 1ℚ _*_ (p - q) → p ≢ q
+  invertible⇒# {p} {q} (1/[p-q] , _ , [p-q]/[p-q]≡1) p≡q = contradiction 1≡0 1≢0
+    where
+    open ≈-Reasoning ≡-setoid
+    1≡0 : 1ℚ ≡ 0ℚ
+    1≡0 = begin
+      1ℚ                 ≈⟨ [p-q]/[p-q]≡1 ⟨
+      (p - q) * 1/[p-q]  ≈⟨ *-congʳ (x≈y⇒x∙y⁻¹≈ε p≡q) ⟩
+      0ℚ * 1/[p-q]       ≈⟨ zeroˡ 1/[p-q] ⟩
+      0ℚ                 ∎
+
+  isHeytingCommutativeRing : IsHeytingCommutativeRing _≡_ _≢_ _+_ _*_ -_ 0ℚ 1ℚ
+  isHeytingCommutativeRing = record
+    { isCommutativeRing = isCommutativeRing
+    ; isApartnessRelation = ≉-isApartnessRelation
+    ; #⇒invertible = #⇒invertible
+    ; invertible⇒# = invertible⇒#
+    }
+
+  isHeytingField : IsHeytingField _≡_ _≢_ _+_ _*_ -_ 0ℚ 1ℚ
+  isHeytingField = record
+    { isHeytingCommutativeRing = isHeytingCommutativeRing
+    ; tight = ≉-tight
+    }
+
+  heytingCommutativeRing : HeytingCommutativeRing 0ℓ 0ℓ 0ℓ
+  heytingCommutativeRing = record { isHeytingCommutativeRing = isHeytingCommutativeRing }
+
+  heytingField : HeytingField 0ℓ 0ℓ 0ℓ
+  heytingField = record { isHeytingField = isHeytingField }
+
+
 ------------------------------------------------------------------------
 -- Properties of _*_ and _≤_
 
 *-cancelʳ-≤-pos : ∀ r .{{_ : Positive r}} → p * r ≤ q * r → p ≤ q
 *-cancelʳ-≤-pos {p} {q} r pr≤qr = toℚᵘ-cancel-≤ (ℚᵘ.*-cancelʳ-≤-pos (toℚᵘ r) (begin
-  toℚᵘ p ℚᵘ.* toℚᵘ r  ≃˘⟨ toℚᵘ-homo-* p r ⟩
+  toℚᵘ p ℚᵘ.* toℚᵘ r  ≃⟨ toℚᵘ-homo-* p r ⟨
   toℚᵘ (p * r)        ≤⟨  toℚᵘ-mono-≤ pr≤qr ⟩
   toℚᵘ (q * r)        ≃⟨  toℚᵘ-homo-* q r ⟩
   toℚᵘ q ℚᵘ.* toℚᵘ r  ∎))
@@ -1223,7 +1311,7 @@ neg-distribʳ-* = +-*-Monomorphism.neg-distribʳ-* ℚᵘ.+-0-isGroup ℚᵘ.*-i
 *-monoʳ-≤-nonNeg r {p} {q} p≤q = toℚᵘ-cancel-≤ (begin
   toℚᵘ (p * r)        ≃⟨  toℚᵘ-homo-* p r ⟩
   toℚᵘ p ℚᵘ.* toℚᵘ r  ≤⟨  ℚᵘ.*-monoˡ-≤-nonNeg (toℚᵘ r) (toℚᵘ-mono-≤ p≤q) ⟩
-  toℚᵘ q ℚᵘ.* toℚᵘ r  ≃˘⟨ toℚᵘ-homo-* q r ⟩
+  toℚᵘ q ℚᵘ.* toℚᵘ r  ≃⟨ toℚᵘ-homo-* q r ⟨
   toℚᵘ (q * r)        ∎)
   where open ℚᵘ.≤-Reasoning
 
@@ -1234,7 +1322,7 @@ neg-distribʳ-* = +-*-Monomorphism.neg-distribʳ-* ℚᵘ.+-0-isGroup ℚᵘ.*-i
 *-monoʳ-≤-nonPos r {p} {q} p≤q = toℚᵘ-cancel-≤ (begin
   toℚᵘ (q * r)        ≃⟨ toℚᵘ-homo-* q r ⟩
   toℚᵘ q ℚᵘ.* toℚᵘ r  ≤⟨ ℚᵘ.*-monoˡ-≤-nonPos (toℚᵘ r) (toℚᵘ-mono-≤ p≤q) ⟩
-  toℚᵘ p ℚᵘ.* toℚᵘ r  ≃˘⟨ toℚᵘ-homo-* p r ⟩
+  toℚᵘ p ℚᵘ.* toℚᵘ r  ≃⟨ toℚᵘ-homo-* p r ⟨
   toℚᵘ (p * r)        ∎)
   where open ℚᵘ.≤-Reasoning
 
@@ -1243,9 +1331,9 @@ neg-distribʳ-* = +-*-Monomorphism.neg-distribʳ-* ℚᵘ.+-0-isGroup ℚᵘ.*-i
 
 *-cancelʳ-≤-neg : ∀ r .{{_ : Negative r}} → p * r ≤ q * r → p ≥ q
 *-cancelʳ-≤-neg {p} {q} r pr≤qr = toℚᵘ-cancel-≤ (ℚᵘ.*-cancelʳ-≤-neg _ (begin
-  toℚᵘ p ℚᵘ.* toℚᵘ r  ≃˘⟨ toℚᵘ-homo-* p r ⟩
-  toℚᵘ (p * r)        ≤⟨  toℚᵘ-mono-≤ pr≤qr ⟩
-  toℚᵘ (q * r)        ≃⟨  toℚᵘ-homo-* q r ⟩
+  toℚᵘ p ℚᵘ.* toℚᵘ r  ≃⟨ toℚᵘ-homo-* p r ⟨
+  toℚᵘ (p * r)        ≤⟨ toℚᵘ-mono-≤ pr≤qr ⟩
+  toℚᵘ (q * r)        ≃⟨ toℚᵘ-homo-* q r ⟩
   toℚᵘ q ℚᵘ.* toℚᵘ r  ∎))
   where open ℚᵘ.≤-Reasoning
 
@@ -1259,7 +1347,7 @@ neg-distribʳ-* = +-*-Monomorphism.neg-distribʳ-* ℚᵘ.+-0-isGroup ℚᵘ.*-i
 *-monoˡ-<-pos r {p} {q} p<q = toℚᵘ-cancel-< (begin-strict
   toℚᵘ (p * r)        ≃⟨ toℚᵘ-homo-* p r ⟩
   toℚᵘ p ℚᵘ.* toℚᵘ r  <⟨ ℚᵘ.*-monoˡ-<-pos (toℚᵘ r) (toℚᵘ-mono-< p<q) ⟩
-  toℚᵘ q ℚᵘ.* toℚᵘ r  ≃˘⟨ toℚᵘ-homo-* q r ⟩
+  toℚᵘ q ℚᵘ.* toℚᵘ r  ≃⟨ toℚᵘ-homo-* q r ⟨
   toℚᵘ (q * r)        ∎)
   where open ℚᵘ.≤-Reasoning
 
@@ -1268,7 +1356,7 @@ neg-distribʳ-* = +-*-Monomorphism.neg-distribʳ-* ℚᵘ.+-0-isGroup ℚᵘ.*-i
 
 *-cancelˡ-<-nonNeg : ∀ r .{{_ : NonNegative r}} → ∀ {p q} → r * p < r * q → p < q
 *-cancelˡ-<-nonNeg r {p} {q} rp<rq = toℚᵘ-cancel-< (ℚᵘ.*-cancelˡ-<-nonNeg (toℚᵘ r) (begin-strict
-  toℚᵘ r ℚᵘ.* toℚᵘ p  ≃˘⟨ toℚᵘ-homo-* r p ⟩
+  toℚᵘ r ℚᵘ.* toℚᵘ p  ≃⟨ toℚᵘ-homo-* r p ⟨
   toℚᵘ (r * p)        <⟨ toℚᵘ-mono-< rp<rq ⟩
   toℚᵘ (r * q)        ≃⟨ toℚᵘ-homo-* r q ⟩
   toℚᵘ r ℚᵘ.* toℚᵘ q  ∎))
@@ -1281,7 +1369,7 @@ neg-distribʳ-* = +-*-Monomorphism.neg-distribʳ-* ℚᵘ.+-0-isGroup ℚᵘ.*-i
 *-monoˡ-<-neg r {p} {q} p<q = toℚᵘ-cancel-< (begin-strict
   toℚᵘ (q * r)        ≃⟨ toℚᵘ-homo-* q r ⟩
   toℚᵘ q ℚᵘ.* toℚᵘ r  <⟨ ℚᵘ.*-monoˡ-<-neg (toℚᵘ r) (toℚᵘ-mono-< p<q) ⟩
-  toℚᵘ p ℚᵘ.* toℚᵘ r  ≃˘⟨ toℚᵘ-homo-* p r ⟩
+  toℚᵘ p ℚᵘ.* toℚᵘ r  ≃⟨ toℚᵘ-homo-* p r ⟨
   toℚᵘ (p * r)        ∎)
   where open ℚᵘ.≤-Reasoning
 
@@ -1290,7 +1378,7 @@ neg-distribʳ-* = +-*-Monomorphism.neg-distribʳ-* ℚᵘ.+-0-isGroup ℚᵘ.*-i
 
 *-cancelˡ-<-nonPos : ∀ r .{{_ : NonPositive r}} → r * p < r * q → p > q
 *-cancelˡ-<-nonPos {p} {q} r rp<rq = toℚᵘ-cancel-< (ℚᵘ.*-cancelˡ-<-nonPos (toℚᵘ r) (begin-strict
-  toℚᵘ r ℚᵘ.* toℚᵘ p  ≃˘⟨ toℚᵘ-homo-* r p ⟩
+  toℚᵘ r ℚᵘ.* toℚᵘ p  ≃⟨ toℚᵘ-homo-* r p ⟨
   toℚᵘ (r * p)        <⟨  toℚᵘ-mono-< rp<rq ⟩
   toℚᵘ (r * q)        ≃⟨  toℚᵘ-homo-* r q ⟩
   toℚᵘ r ℚᵘ.* toℚᵘ q  ∎))
@@ -1304,24 +1392,24 @@ neg-distribʳ-* = +-*-Monomorphism.neg-distribʳ-* ℚᵘ.+-0-isGroup ℚᵘ.*-i
 ------------------------------------------------------------------------
 
 p≤q⇒p⊔q≡q : p ≤ q → p ⊔ q ≡ q
-p≤q⇒p⊔q≡q {p@record{}} {q@record{}} p≤q with p ≤ᵇ q | inspect (p ≤ᵇ_) q
-... | true  | _       = refl
-... | false | [ p≰q ] = contradiction (≤⇒≤ᵇ p≤q) (subst (¬_ ∘ T) (sym p≰q) λ())
+p≤q⇒p⊔q≡q {p@record{}} {q@record{}} p≤q with p ≤ᵇ q in p≰q
+... | true  = refl
+... | false = contradiction (≤⇒≤ᵇ p≤q) (subst (¬_ ∘ T) (sym p≰q) λ())
 
 p≥q⇒p⊔q≡p : p ≥ q → p ⊔ q ≡ p
-p≥q⇒p⊔q≡p {p@record{}} {q@record{}} p≥q with p ≤ᵇ q | inspect (p ≤ᵇ_) q
-... | true  | [ p≤q ] = ≤-antisym p≥q (≤ᵇ⇒≤ (subst T (sym p≤q) _))
-... | false | [ p≤q ] = refl
+p≥q⇒p⊔q≡p {p@record{}} {q@record{}} p≥q with p ≤ᵇ q in p≤q
+... | true  = ≤-antisym p≥q (≤ᵇ⇒≤ (subst T (sym p≤q) _))
+... | false = refl
 
 p≤q⇒p⊓q≡p : p ≤ q → p ⊓ q ≡ p
-p≤q⇒p⊓q≡p {p@record{}} {q@record{}} p≤q with p ≤ᵇ q | inspect (p ≤ᵇ_) q
-... | true  | _       = refl
-... | false | [ p≰q ] = contradiction (≤⇒≤ᵇ p≤q) (subst (¬_ ∘ T) (sym p≰q) λ())
+p≤q⇒p⊓q≡p {p@record{}} {q@record{}} p≤q with p ≤ᵇ q in p≰q
+... | true  = refl
+... | false = contradiction (≤⇒≤ᵇ p≤q) (subst (¬_ ∘ T) (sym p≰q) λ())
 
 p≥q⇒p⊓q≡q : p ≥ q → p ⊓ q ≡ q
-p≥q⇒p⊓q≡q {p@record{}} {q@record{}} p≥q with p ≤ᵇ q | inspect (p ≤ᵇ_) q
-... | true  | [ p≤q ] = ≤-antisym (≤ᵇ⇒≤ (subst T (sym p≤q) _)) p≥q
-... | false | [ p≤q ] = refl
+p≥q⇒p⊓q≡q {p@record{}} {q@record{}} p≥q with p ≤ᵇ q in p≤q
+... | true  = ≤-antisym (≤ᵇ⇒≤ (subst T (sym p≤q) _)) p≥q
+... | false = refl
 
 ⊓-operator : MinOperator ≤-totalPreorder
 ⊓-operator = record
@@ -1456,17 +1544,17 @@ mono-<-distrib-⊓ : ∀ {f} → f Preserves _<_ ⟶ _<_ →
 mono-<-distrib-⊓ {f} f-mono-< p q with <-cmp p q
 ... | tri< p<q p≢r  p≯q = begin
   f (p ⊓ q)  ≡⟨ cong f (p≤q⇒p⊓q≡p (<⇒≤ p<q)) ⟩
-  f p        ≡˘⟨ p≤q⇒p⊓q≡p (<⇒≤ (f-mono-< p<q)) ⟩
+  f p        ≡⟨ p≤q⇒p⊓q≡p (<⇒≤ (f-mono-< p<q)) ⟨
   f p ⊓ f q  ∎
   where open ≡-Reasoning
 ... | tri≈ p≮q refl p≯q = begin
   f (p ⊓ q)  ≡⟨ cong f (⊓-idem p) ⟩
-  f p        ≡˘⟨ ⊓-idem (f p) ⟩
+  f p        ≡⟨ ⊓-idem (f p) ⟨
   f p ⊓ f q  ∎
   where open ≡-Reasoning
 ... | tri> p≮q p≡r  p>q = begin
   f (p ⊓ q)  ≡⟨ cong f (p≥q⇒p⊓q≡q (<⇒≤ p>q)) ⟩
-  f q        ≡˘⟨ p≥q⇒p⊓q≡q (<⇒≤ (f-mono-< p>q)) ⟩
+  f q        ≡⟨ p≥q⇒p⊓q≡q (<⇒≤ (f-mono-< p>q)) ⟨
   f p ⊓ f q  ∎
   where open ≡-Reasoning
 
@@ -1475,17 +1563,17 @@ mono-<-distrib-⊔ : ∀ {f} → f Preserves _<_ ⟶ _<_ →
 mono-<-distrib-⊔ {f} f-mono-< p q with <-cmp p q
 ... | tri< p<q p≢r  p≯q = begin
   f (p ⊔ q)  ≡⟨ cong f (p≤q⇒p⊔q≡q (<⇒≤ p<q)) ⟩
-  f q        ≡˘⟨ p≤q⇒p⊔q≡q (<⇒≤ (f-mono-< p<q)) ⟩
+  f q        ≡⟨ p≤q⇒p⊔q≡q (<⇒≤ (f-mono-< p<q)) ⟨
   f p ⊔ f q  ∎
   where open ≡-Reasoning
 ... | tri≈ p≮q refl p≯q = begin
   f (p ⊔ q)  ≡⟨ cong f (⊔-idem p) ⟩
-  f q        ≡˘⟨ ⊔-idem (f p) ⟩
+  f q        ≡⟨ ⊔-idem (f p) ⟨
   f p ⊔ f q  ∎
   where open ≡-Reasoning
 ... | tri> p≮q p≡r  p>q = begin
   f (p ⊔ q)  ≡⟨ cong f (p≥q⇒p⊔q≡p (<⇒≤ p>q)) ⟩
-  f p        ≡˘⟨ p≥q⇒p⊔q≡p (<⇒≤ (f-mono-< p>q)) ⟩
+  f p        ≡⟨ p≥q⇒p⊔q≡p (<⇒≤ (f-mono-< p>q)) ⟨
   f p ⊔ f q  ∎
   where open ≡-Reasoning
 
@@ -1573,7 +1661,7 @@ toℚᵘ-homo-∣-∣ (mkℚ -[1+ _ ] _ _) = *≡* refl
 0≤∣p∣ p@record{} = *≤* (begin
   (↥ 0ℚ) ℤ.* (↧ ∣ p ∣)  ≡⟨ ℤ.*-zeroˡ (↧ ∣ p ∣) ⟩
   0ℤ                    ≤⟨ ℤ.+≤+ ℕ.z≤n ⟩
-  ↥ ∣ p ∣               ≡˘⟨ ℤ.*-identityʳ (↥ ∣ p ∣) ⟩
+  ↥ ∣ p ∣               ≡⟨ ℤ.*-identityʳ (↥ ∣ p ∣) ⟨
   ↥ ∣ p ∣ ℤ.* 1ℤ        ∎)
   where open ℤ.≤-Reasoning
 
@@ -1601,8 +1689,8 @@ toℚᵘ-homo-∣-∣ (mkℚ -[1+ _ ] _ _) = *≡* refl
   toℚᵘ ∣ p + q ∣                    ≃⟨ toℚᵘ-homo-∣-∣ (p + q) ⟩
   ℚᵘ.∣ toℚᵘ (p + q) ∣               ≃⟨ ℚᵘ.∣-∣-cong (toℚᵘ-homo-+ p q) ⟩
   ℚᵘ.∣ toℚᵘ p ℚᵘ.+ toℚᵘ q ∣         ≤⟨ ℚᵘ.∣p+q∣≤∣p∣+∣q∣ (toℚᵘ p) (toℚᵘ q) ⟩
-  ℚᵘ.∣ toℚᵘ p ∣ ℚᵘ.+ ℚᵘ.∣ toℚᵘ q ∣  ≃˘⟨ ℚᵘ.+-cong (toℚᵘ-homo-∣-∣ p) (toℚᵘ-homo-∣-∣ q) ⟩
-  toℚᵘ ∣ p ∣ ℚᵘ.+ toℚᵘ ∣ q ∣        ≃˘⟨ toℚᵘ-homo-+ ∣ p ∣ ∣ q ∣ ⟩
+  ℚᵘ.∣ toℚᵘ p ∣ ℚᵘ.+ ℚᵘ.∣ toℚᵘ q ∣  ≃⟨ ℚᵘ.+-cong (toℚᵘ-homo-∣-∣ p) (toℚᵘ-homo-∣-∣ q) ⟨
+  toℚᵘ ∣ p ∣ ℚᵘ.+ toℚᵘ ∣ q ∣        ≃⟨ toℚᵘ-homo-+ ∣ p ∣ ∣ q ∣ ⟨
   toℚᵘ (∣ p ∣ + ∣ q ∣)              ∎)
   where open ℚᵘ.≤-Reasoning
 
@@ -1618,8 +1706,8 @@ toℚᵘ-homo-∣-∣ (mkℚ -[1+ _ ] _ _) = *≡* refl
   toℚᵘ ∣ p * q ∣                    ≃⟨ toℚᵘ-homo-∣-∣ (p * q) ⟩
   ℚᵘ.∣ toℚᵘ (p * q) ∣               ≃⟨ ℚᵘ.∣-∣-cong (toℚᵘ-homo-* p q) ⟩
   ℚᵘ.∣ toℚᵘ p ℚᵘ.* toℚᵘ q ∣         ≃⟨ ℚᵘ.∣p*q∣≃∣p∣*∣q∣ (toℚᵘ p) (toℚᵘ q) ⟩
-  ℚᵘ.∣ toℚᵘ p ∣ ℚᵘ.* ℚᵘ.∣ toℚᵘ q ∣  ≃˘⟨ ℚᵘ.*-cong (toℚᵘ-homo-∣-∣ p) (toℚᵘ-homo-∣-∣ q) ⟩
-  toℚᵘ ∣ p ∣ ℚᵘ.* toℚᵘ ∣ q ∣        ≃˘⟨ toℚᵘ-homo-* ∣ p ∣ ∣ q ∣ ⟩
+  ℚᵘ.∣ toℚᵘ p ∣ ℚᵘ.* ℚᵘ.∣ toℚᵘ q ∣  ≃⟨ ℚᵘ.*-cong (toℚᵘ-homo-∣-∣ p) (toℚᵘ-homo-∣-∣ q) ⟨
+  toℚᵘ ∣ p ∣ ℚᵘ.* toℚᵘ ∣ q ∣        ≃⟨ toℚᵘ-homo-* ∣ p ∣ ∣ q ∣ ⟨
   toℚᵘ (∣ p ∣ * ∣ q ∣)              ∎)
   where open ℚᵘ.≤-Reasoning
 
diff --git a/src/Data/Rational/Unnormalised/Base.agda b/src/Data/Rational/Unnormalised/Base.agda
index c03041650c..5714ed2181 100644
--- a/src/Data/Rational/Unnormalised/Base.agda
+++ b/src/Data/Rational/Unnormalised/Base.agda
@@ -9,13 +9,14 @@
 module Data.Rational.Unnormalised.Base where
 
 open import Algebra.Bundles.Raw
+  using (RawMagma; RawMonoid; RawGroup; RawNearSemiring; RawSemiring; RawRing)
 open import Data.Bool.Base using (Bool; true; false; if_then_else_)
 open import Data.Integer.Base as ℤ
   using (ℤ; +_; +0; +[1+_]; -[1+_]; +<+; +≤+)
+  hiding (module ℤ)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
 open import Level using (0ℓ)
-open import Relation.Nullary.Negation using (¬_)
-open import Relation.Nullary.Negation using (contradiction)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
 open import Relation.Unary using (Pred)
 open import Relation.Binary.Core using (Rel)
 open import Relation.Binary.PropositionalEquality.Core
@@ -66,8 +67,8 @@ infix 4 _≃_ _≠_
 data _≃_ : Rel ℚᵘ 0ℓ where
   *≡* : ∀ {p q} → (↥ p ℤ.* ↧ q) ≡ (↥ q ℤ.* ↧ p) → p ≃ q
 
-_≠_ : Rel ℚᵘ 0ℓ
-p ≠ q = ¬ (p ≃ q)
+_≄_ : Rel ℚᵘ 0ℓ
+p ≄ q = ¬ (p ≃ q)
 
 ------------------------------------------------------------------------
 -- Ordering of rationals
@@ -117,7 +118,7 @@ infixl 7 _/_
 _/_ : (n : ℤ) (d : ℕ) .{{_ : ℕ.NonZero d}} → ℚᵘ
 n / suc d = mkℚᵘ n d
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Some constants
 
 0ℚᵘ : ℚᵘ
@@ -150,13 +151,18 @@ NonPositive p = ℤ.NonPositive (↥ p)
 NonNegative : Pred ℚᵘ 0ℓ
 NonNegative p = ℤ.NonNegative (↥ p)
 
+-- Instances
+
+open ℤ public
+  using (nonZero; pos; nonNeg; nonPos0; nonPos; neg)
+
 -- Constructors and destructors
 
 -- Note: these could be proved more elegantly using the constructors
 -- from ℤ but it requires importing `Data.Integer.Properties` which
 -- we would like to avoid doing.
 
-≢-nonZero : ∀ {p} → p ≠ 0ℚᵘ → NonZero p
+≢-nonZero : ∀ {p} → p ≄ 0ℚᵘ → NonZero p
 ≢-nonZero {mkℚᵘ -[1+ _ ] _      } _   = _
 ≢-nonZero {mkℚᵘ +[1+ _ ] _      } _   = _
 ≢-nonZero {mkℚᵘ +0       zero   } p≢0 = contradiction (*≡* refl) p≢0
@@ -190,24 +196,25 @@ nonNegative : ∀ {p} → p ≥ 0ℚᵘ → NonNegative p
 nonNegative {mkℚᵘ +0       _} (*≤* _) = _
 nonNegative {mkℚᵘ +[1+ n ] _} (*≤* _) = _
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Operations on rationals
 
--- Explanation for `@record{}` everywhere: combined with no-eta-equality on
--- the record definition of ℚᵘ above, these annotations prevent the operations
--- from automatically expanding unless their arguments are explicitly pattern
--- matched on.
+-- Explanation for `@record{}` everywhere: combined with no-eta-equality
+-- on the record definition of ℚᵘ above, these annotations prevent the
+-- operations from automatically expanding unless their arguments are
+-- explicitly pattern matched on.
 --
--- For example prior to their addition, `p + q` would often be normalised by
--- Agda to `(↥ p ℤ.* ↧ q ℤ.+ ↥ q ℤ.* ↧ p) / (↧ₙ p ℕ.* ↧ₙ q)`. While in this
--- small example this isn't a big problem, it leads to an exponential blowup
--- when you have large arithmetic expressions which would often choke
--- both type-checking and the display code. For example, the normalised
--- form of `p + q + r + s + t + u` would be ~300 lines long.
+-- For example prior to their addition, `p + q` would often be
+-- normalised by Agda to `(↥ p ℤ.* ↧ q ℤ.+ ↥ q ℤ.* ↧ p) / (↧ₙ p ℕ.* ↧ₙ q)`.
+-- While in this small example this isn't a big problem, it leads to an
+-- exponential blowup when you have large arithmetic expressions which
+-- would often choke both type-checking and the display code. For
+-- example, the normalised form of `p + q + r + s + t + u` would be
+-- ~300 lines long.
 --
--- This is fundementally a problem with Agda, so if over-eager normalisation
--- is ever fixed in Agda (e.g. with glued representation of terms) these
--- annotations can be removed.
+-- This is fundementally a problem with Agda, so if over-eager
+-- normalisation is ever fixed in Agda (e.g. with glued representation
+-- of terms) these annotations can be removed.
 
 infix  8 -_ 1/_
 infixl 7 _*_ _÷_ _⊓_
@@ -269,15 +276,11 @@ ceiling p@record{} = ℤ.- floor (- p)
 
 -- Truncate  (round towards 0)
 truncate : ℚᵘ → ℤ
-truncate p with p ≤ᵇ 0ℚᵘ
-... | true  = ceiling p
-... | false = floor p
+truncate p = if p ≤ᵇ 0ℚᵘ then ceiling p else floor p
 
 -- Round (to nearest integer)
 round : ℚᵘ → ℤ
-round p with p ≤ᵇ 0ℚᵘ
-... | true  = ceiling (p - ½)
-... | false = floor (p + ½)
+round p = if p ≤ᵇ 0ℚᵘ then ceiling (p - ½) else floor (p + ½)
 
 -- Fractional part (remainder after floor)
 fracPart : ℚᵘ → ℚᵘ
@@ -377,3 +380,8 @@ Please use +-0-rawMonoid instead."
 "Warning: *-rawMonoid was deprecated in v2.0
 Please use *-1-rawMonoid instead."
 #-}
+_≠_ = _≄_
+{-# WARNING_ON_USAGE _≠_
+"Warning: _≠_ was deprecated in v2.0
+Please use _≄_ instead."
+#-}
diff --git a/src/Data/Rational/Unnormalised/Properties.agda b/src/Data/Rational/Unnormalised/Properties.agda
index d1eb0fe609..181e4a6189 100644
--- a/src/Data/Rational/Unnormalised/Properties.agda
+++ b/src/Data/Rational/Unnormalised/Properties.agda
@@ -1,4 +1,4 @@
-------------------------------------------------------------------------
+-----------------------------------------------------------------------
 -- The Agda standard library
 --
 -- Properties of unnormalized Rational numbers
@@ -10,6 +10,7 @@
 module Data.Rational.Unnormalised.Properties where
 
 open import Algebra
+open import Algebra.Apartness
 open import Algebra.Lattice
 import Algebra.Consequences.Setoid as Consequences
 open import Algebra.Consequences.Propositional
@@ -19,23 +20,29 @@ import Algebra.Lattice.Construct.NaturalChoice.MinMaxOp as LatticeMinMaxOp
 open import Data.Bool.Base using (T; true; false)
 open import Data.Nat.Base as ℕ using (suc; pred)
 import Data.Nat.Properties as ℕ
-open import Data.Nat.Solver renaming (module +-*-Solver to ℕ-solver)
 open import Data.Integer.Base as ℤ using (ℤ; +0; +[1+_]; -[1+_]; 0ℤ; 1ℤ; -1ℤ)
 open import Data.Integer.Solver renaming (module +-*-Solver to ℤ-solver)
 import Data.Integer.Properties as ℤ
 open import Data.Rational.Unnormalised.Base
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Data.Sum.Base using (_⊎_; [_,_]′; inj₁; inj₂)
 import Data.Sign as Sign
 open import Function.Base using (_on_; _$_; _∘_; flip)
 open import Level using (0ℓ)
-open import Relation.Nullary using (¬_; yes; no)
-import Relation.Nullary.Decidable as Dec
-open import Relation.Nullary.Negation using (contradiction; contraposition)
-open import Relation.Binary
+open import Relation.Nullary.Decidable.Core as Dec using (yes; no)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
+open import Relation.Binary.Core using (_⇒_; _Preserves_⟶_; _Preserves₂_⟶_⟶_)
+open import Relation.Binary.Bundles
+  using (Setoid; DecSetoid; Preorder; TotalPreorder; Poset; TotalOrder; DecTotalOrder; StrictPartialOrder; StrictTotalOrder; DenseLinearOrder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence; IsApartnessRelation; IsTotalPreorder; IsPreorder; IsPartialOrder; IsTotalOrder; IsDecTotalOrder; IsStrictPartialOrder; IsStrictTotalOrder; IsDenseLinearOrder)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Cotransitive; Tight; Decidable; Antisymmetric; Asymmetric; Dense; Total; Trans; Trichotomous; Irreflexive; Irrelevant; _Respectsˡ_; _Respectsʳ_; _Respects₂_; tri≈; tri<; tri>)
 import Relation.Binary.Consequences as BC
 open import Relation.Binary.PropositionalEquality
 import Relation.Binary.Properties.Poset as PosetProperties
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
+open import Relation.Binary.Reasoning.Syntax
 
 open import Algebra.Properties.CommutativeSemigroup ℤ.*-commutativeSemigroup
 
@@ -91,9 +98,26 @@ drop-*≡* (*≡* eq) = eq
      ↥ z ℤ.* ↧ x ℤ.* ↧ y ∎))
   where open ≡-Reasoning
 
+infix 4 _≃?_
+
 _≃?_ : Decidable _≃_
 p ≃? q = Dec.map′ *≡* drop-*≡* (↥ p ℤ.* ↧ q ℤ.≟ ↥ q ℤ.* ↧ p)
 
+0≄1 : 0ℚᵘ ≄ 1ℚᵘ
+0≄1 = Dec.from-no (0ℚᵘ ≃? 1ℚᵘ)
+
+≃-≄-irreflexive : Irreflexive _≃_ _≄_
+≃-≄-irreflexive x≃y x≄y = x≄y x≃y
+
+≄-symmetric : Symmetric _≄_
+≄-symmetric x≄y y≃x = x≄y (≃-sym y≃x)
+
+≄-cotransitive : Cotransitive _≄_
+≄-cotransitive {x} {y} x≄y z with x ≃? z | z ≃? y
+... | no  x≄z | _       = inj₁ x≄z
+... | yes _   | no z≄y  = inj₂ z≄y
+... | yes x≃z | yes z≃y = contradiction (≃-trans x≃z z≃y) x≄y
+
 ≃-isEquivalence : IsEquivalence _≃_
 ≃-isEquivalence = record
   { refl  = ≃-refl
@@ -107,6 +131,17 @@ p ≃? q = Dec.map′ *≡* drop-*≡* (↥ p ℤ.* ↧ q ℤ.≟ ↥ q ℤ.* 
   ; _≟_           = _≃?_
   }
 
+≄-isApartnessRelation : IsApartnessRelation _≃_ _≄_
+≄-isApartnessRelation = record
+  { irrefl  = ≃-≄-irreflexive
+  ; sym     = ≄-symmetric
+  ; cotrans = ≄-cotransitive
+  }
+
+≄-tight : Tight _≃_ _≄_
+proj₁ (≄-tight p q) ¬p≄q = Dec.decidable-stable (p ≃? q) ¬p≄q
+proj₂ (≄-tight p q) p≃q p≄q = p≄q p≃q
+
 ≃-setoid : Setoid 0ℓ 0ℓ
 ≃-setoid = record
   { isEquivalence = ≃-isEquivalence
@@ -117,6 +152,21 @@ p ≃? q = Dec.map′ *≡* drop-*≡* (↥ p ℤ.* ↧ q ℤ.≟ ↥ q ℤ.* 
   { isDecEquivalence = ≃-isDecEquivalence
   }
 
+module ≃-Reasoning = ≈-Reasoning ≃-setoid
+
+↥p≡0⇒p≃0 : ∀ p → ↥ p ≡ 0ℤ → p ≃ 0ℚᵘ
+↥p≡0⇒p≃0 p ↥p≡0 = *≡* (cong (ℤ._* (↧ 0ℚᵘ)) ↥p≡0)
+
+p≃0⇒↥p≡0 : ∀ p → p ≃ 0ℚᵘ → ↥ p ≡ 0ℤ
+p≃0⇒↥p≡0 p (*≡* eq) = begin
+  ↥ p          ≡⟨ ℤ.*-identityʳ (↥ p) ⟨
+  ↥ p ℤ.* 1ℤ  ≡⟨ eq ⟩
+  0ℤ           ∎
+  where open ≡-Reasoning
+
+↥p≡↥q≡0⇒p≃q : ∀ p q → ↥ p ≡ 0ℤ → ↥ q ≡ 0ℤ → p ≃ q
+↥p≡↥q≡0⇒p≃q p q ↥p≡0 ↥q≡0 = ≃-trans (↥p≡0⇒p≃0 p ↥p≡0) (≃-sym (↥p≡0⇒p≃0 _ ↥q≡0))
+
 ------------------------------------------------------------------------
 -- Properties of -_
 ------------------------------------------------------------------------
@@ -129,14 +179,14 @@ neg-involutive p rewrite neg-involutive-≡ p = ≃-refl
 
 -‿cong : Congruent₁ _≃_ (-_)
 -‿cong {p@record{}} {q@record{}} (*≡* p≡q) = *≡* (begin
-  ↥(- p) ℤ.* ↧ q            ≡˘⟨ ℤ.*-identityˡ (ℤ.- (↥ p) ℤ.* ↧ q) ⟩
-  1ℤ ℤ.* (↥(- p) ℤ.* ↧ q)   ≡˘⟨ ℤ.*-assoc 1ℤ (↥ (- p)) (↧ q) ⟩
-  (1ℤ ℤ.* ℤ.-(↥ p)) ℤ.* ↧ q ≡˘⟨ cong (ℤ._* ↧ q) (ℤ.neg-distribʳ-* 1ℤ (↥ p)) ⟩
+  ↥(- p) ℤ.* ↧ q            ≡⟨ ℤ.*-identityˡ (ℤ.- (↥ p) ℤ.* ↧ q) ⟨
+  1ℤ ℤ.* (↥(- p) ℤ.* ↧ q)   ≡⟨ ℤ.*-assoc 1ℤ (↥ (- p)) (↧ q) ⟨
+  (1ℤ ℤ.* ℤ.-(↥ p)) ℤ.* ↧ q ≡⟨ cong (ℤ._* ↧ q) (ℤ.neg-distribʳ-* 1ℤ (↥ p)) ⟨
   ℤ.-(1ℤ ℤ.* ↥ p) ℤ.* ↧ q   ≡⟨  cong (ℤ._* ↧ q) (ℤ.neg-distribˡ-* 1ℤ (↥ p)) ⟩
   (-1ℤ ℤ.* ↥ p) ℤ.* ↧ q     ≡⟨  ℤ.*-assoc ℤ.-1ℤ (↥ p) (↧ q) ⟩
   -1ℤ ℤ.* (↥ p ℤ.* ↧ q)     ≡⟨  cong (ℤ.-1ℤ ℤ.*_) p≡q ⟩
-  -1ℤ ℤ.* (↥ q ℤ.* ↧ p)     ≡˘⟨ ℤ.*-assoc ℤ.-1ℤ (↥ q) (↧ p) ⟩
-  (-1ℤ ℤ.* ↥ q) ℤ.* ↧ p     ≡˘⟨ cong (ℤ._* ↧ p) (ℤ.neg-distribˡ-* 1ℤ (↥ q)) ⟩
+  -1ℤ ℤ.* (↥ q ℤ.* ↧ p)     ≡⟨ ℤ.*-assoc ℤ.-1ℤ (↥ q) (↧ p) ⟨
+  (-1ℤ ℤ.* ↥ q) ℤ.* ↧ p     ≡⟨ cong (ℤ._* ↧ p) (ℤ.neg-distribˡ-* 1ℤ (↥ q)) ⟨
   ℤ.-(1ℤ ℤ.* ↥ q) ℤ.* ↧ p   ≡⟨  cong (ℤ._* ↧ p) (ℤ.neg-distribʳ-* 1ℤ (↥ q)) ⟩
   (1ℤ ℤ.* ↥(- q)) ℤ.* ↧ p   ≡⟨  ℤ.*-assoc 1ℤ (ℤ.- (↥ q)) (↧ p) ⟩
   1ℤ ℤ.* (↥(- q) ℤ.* ↧ p)   ≡⟨  ℤ.*-identityˡ (↥ (- q) ℤ.* ↧ p) ⟩
@@ -145,7 +195,7 @@ neg-involutive p rewrite neg-involutive-≡ p = ≃-refl
 
 neg-mono-< : -_ Preserves  _<_ ⟶ _>_
 neg-mono-< {p@record{}} {q@record{}} (*<* p<q) = *<* $ begin-strict
-  ℤ.-  ↥ q ℤ.* ↧ p     ≡˘⟨ ℤ.neg-distribˡ-* (↥ q) (↧ p) ⟩
+  ℤ.-  ↥ q ℤ.* ↧ p     ≡⟨ ℤ.neg-distribˡ-* (↥ q) (↧ p) ⟨
   ℤ.- (↥ q ℤ.* ↧ p)    <⟨ ℤ.neg-mono-< p<q ⟩
   ℤ.- (↥ p ℤ.* ↧ q)    ≡⟨ ℤ.neg-distribˡ-* (↥ p) (↧ q) ⟩
   ↥ (- p) ℤ.* ↧ (- q)  ∎
@@ -153,10 +203,10 @@ neg-mono-< {p@record{}} {q@record{}} (*<* p<q) = *<* $ begin-strict
 
 neg-cancel-< : ∀ {p q} → - p < - q → q < p
 neg-cancel-< {p@record{}} {q@record{}} (*<* -↥p↧q<-↥q↧p) = *<* $ begin-strict
-  ↥ q ℤ.* ↧ p              ≡˘⟨ ℤ.neg-involutive (↥ q ℤ.* ↧ p) ⟩
+  ↥ q ℤ.* ↧ p              ≡⟨ ℤ.neg-involutive (↥ q ℤ.* ↧ p) ⟨
   ℤ.- ℤ.- (↥ q ℤ.* ↧ p)    ≡⟨ cong ℤ.-_ (ℤ.neg-distribˡ-* (↥ q) (↧ p)) ⟩
   ℤ.- ((ℤ.- ↥ q) ℤ.* ↧ p)  <⟨ ℤ.neg-mono-< -↥p↧q<-↥q↧p ⟩
-  ℤ.- ((ℤ.- ↥ p) ℤ.* ↧ q)  ≡˘⟨ cong ℤ.-_ (ℤ.neg-distribˡ-* (↥ p) (↧ q)) ⟩
+  ℤ.- ((ℤ.- ↥ p) ℤ.* ↧ q)  ≡⟨ cong ℤ.-_ (ℤ.neg-distribˡ-* (↥ p) (↧ q)) ⟨
   ℤ.- ℤ.- (↥ p ℤ.* ↧ q)    ≡⟨ ℤ.neg-involutive (↥ p ℤ.* ↧ q) ⟩
   ↥ p ℤ.* ↧ q              ∎
   where open ℤ.≤-Reasoning
@@ -184,12 +234,12 @@ drop-*≤* (*≤* pq≤qp) = pq≤qp
   ℤ.*-cancelʳ-≤-pos (n₁ ℤ.* d₃) (n₃ ℤ.* d₁) d₂ $ begin
   (n₁  ℤ.* d₃) ℤ.* d₂  ≡⟨ ℤ.*-assoc n₁ d₃ d₂ ⟩
   n₁   ℤ.* (d₃ ℤ.* d₂) ≡⟨ cong (n₁ ℤ.*_) (ℤ.*-comm d₃ d₂) ⟩
-  n₁   ℤ.* (d₂ ℤ.* d₃) ≡˘⟨ ℤ.*-assoc n₁ d₂ d₃ ⟩
+  n₁   ℤ.* (d₂ ℤ.* d₃) ≡⟨ ℤ.*-assoc n₁ d₂ d₃ ⟨
   (n₁  ℤ.* d₂) ℤ.* d₃  ≤⟨ ℤ.*-monoʳ-≤-nonNeg d₃ eq₁ ⟩
   (n₂  ℤ.* d₁) ℤ.* d₃  ≡⟨ cong (ℤ._* d₃) (ℤ.*-comm n₂ d₁) ⟩
   (d₁ ℤ.* n₂)  ℤ.* d₃  ≡⟨ ℤ.*-assoc d₁ n₂ d₃ ⟩
   d₁  ℤ.* (n₂  ℤ.* d₃) ≤⟨ ℤ.*-monoˡ-≤-nonNeg d₁ eq₂ ⟩
-  d₁  ℤ.* (n₃  ℤ.* d₂) ≡˘⟨ ℤ.*-assoc d₁ n₃ d₂ ⟩
+  d₁  ℤ.* (n₃  ℤ.* d₂) ≡⟨ ℤ.*-assoc d₁ n₃ d₂ ⟨
   (d₁ ℤ.* n₃)  ℤ.* d₂  ≡⟨ cong (ℤ._* d₂) (ℤ.*-comm d₁ n₃) ⟩
   (n₃  ℤ.* d₁) ℤ.* d₂  ∎ where open ℤ.≤-Reasoning
 
@@ -372,17 +422,50 @@ drop-*<* (*<* pq<qp) = pq<qp
 <-asym : Asymmetric _<_
 <-asym (*<* x<y) = ℤ.<-asym x<y ∘ drop-*<*
 
+<-dense : Dense _<_
+<-dense {p} {q} (*<* p<q) = m , p<m , m<q
+  where
+  open ℤ.≤-Reasoning
+  m : ℚᵘ
+  m = mkℚᵘ (↥ p ℤ.+ ↥ q) (pred (↧ₙ p ℕ.+ ↧ₙ q))
+
+  p<m : p < m
+  p<m = *<* (begin-strict
+    ↥ p ℤ.* ↧ m
+      ≡⟨⟩
+    ↥ p ℤ.* (↧ p ℤ.+ ↧ q)
+      ≡⟨ ℤ.*-distribˡ-+ (↥ p) (↧ p) (↧ q) ⟩
+    ↥ p ℤ.* ↧ p ℤ.+ ↥ p ℤ.* ↧ q
+      <⟨ ℤ.+-monoʳ-< (↥ p ℤ.* ↧ p) p<q ⟩
+    ↥ p ℤ.* ↧ p ℤ.+ ↥ q ℤ.* ↧ p
+      ≡⟨ ℤ.*-distribʳ-+ (↧ p) (↥ p) (↥ q) ⟨
+    (↥ p ℤ.+ ↥ q) ℤ.* ↧ p
+      ≡⟨⟩
+    ↥ m ℤ.* ↧ p ∎)
+
+  m<q : m < q
+  m<q = *<* (begin-strict
+    ↥ m ℤ.* ↧ q
+      ≡⟨ ℤ.*-distribʳ-+ (↧ q) (↥ p) (↥ q) ⟩
+    ↥ p ℤ.* ↧ q ℤ.+ ↥ q ℤ.* ↧ q
+      <⟨ ℤ.+-monoˡ-< (↥ q ℤ.* ↧ q) p<q ⟩
+    ↥ q ℤ.* ↧ p ℤ.+ ↥ q ℤ.* ↧ q
+      ≡⟨ ℤ.*-distribˡ-+ (↥ q) (↧ p) (↧ q) ⟨
+    ↥ q ℤ.* (↧ p ℤ.+ ↧ q)
+      ≡⟨⟩
+    ↥ q ℤ.* ↧ m ∎)
+
 ≤-<-trans : Trans _≤_ _<_ _<_
 ≤-<-trans {p} {q} {r} (*≤* p≤q) (*<* q<r) = *<* $
   ℤ.*-cancelʳ-<-nonNeg _ $ begin-strict
   n₁ ℤ.*  d₃ ℤ.* d₂  ≡⟨ ℤ.*-assoc n₁ d₃ d₂ ⟩
   n₁ ℤ.* (d₃ ℤ.* d₂) ≡⟨ cong (n₁ ℤ.*_) (ℤ.*-comm d₃ d₂) ⟩
-  n₁ ℤ.* (d₂ ℤ.* d₃) ≡˘⟨ ℤ.*-assoc n₁ d₂ d₃ ⟩
+  n₁ ℤ.* (d₂ ℤ.* d₃) ≡⟨ ℤ.*-assoc n₁ d₂ d₃ ⟨
   n₁ ℤ.*  d₂ ℤ.* d₃  ≤⟨ ℤ.*-monoʳ-≤-nonNeg (↧ r) p≤q ⟩
   n₂ ℤ.*  d₁ ℤ.* d₃  ≡⟨ cong (ℤ._* d₃) (ℤ.*-comm n₂ d₁) ⟩
   d₁ ℤ.*  n₂ ℤ.* d₃  ≡⟨ ℤ.*-assoc d₁ n₂ d₃ ⟩
   d₁ ℤ.* (n₂ ℤ.* d₃) <⟨ ℤ.*-monoˡ-<-pos (↧ p) q<r ⟩
-  d₁ ℤ.* (n₃ ℤ.* d₂) ≡˘⟨ ℤ.*-assoc d₁ n₃ d₂ ⟩
+  d₁ ℤ.* (n₃ ℤ.* d₂) ≡⟨ ℤ.*-assoc d₁ n₃ d₂ ⟨
   d₁ ℤ.*  n₃ ℤ.* d₂  ≡⟨ cong (ℤ._* d₂) (ℤ.*-comm d₁ n₃) ⟩
   n₃ ℤ.*  d₁ ℤ.* d₂  ∎
   where open ℤ.≤-Reasoning
@@ -393,12 +476,12 @@ drop-*<* (*<* pq<qp) = pq<qp
   ℤ.*-cancelʳ-<-nonNeg _ $ begin-strict
   n₁ ℤ.*  d₃ ℤ.* d₂  ≡⟨ ℤ.*-assoc n₁ d₃ d₂ ⟩
   n₁ ℤ.* (d₃ ℤ.* d₂) ≡⟨ cong (n₁ ℤ.*_) (ℤ.*-comm d₃ d₂) ⟩
-  n₁ ℤ.* (d₂ ℤ.* d₃) ≡˘⟨ ℤ.*-assoc n₁ d₂ d₃ ⟩
+  n₁ ℤ.* (d₂ ℤ.* d₃) ≡⟨ ℤ.*-assoc n₁ d₂ d₃ ⟨
   n₁ ℤ.*  d₂ ℤ.* d₃  <⟨ ℤ.*-monoʳ-<-pos (↧ r) p<q ⟩
   n₂ ℤ.*  d₁ ℤ.* d₃  ≡⟨ cong (ℤ._* d₃) (ℤ.*-comm n₂ d₁) ⟩
   d₁ ℤ.*  n₂ ℤ.* d₃  ≡⟨ ℤ.*-assoc d₁ n₂ d₃ ⟩
   d₁ ℤ.* (n₂ ℤ.* d₃) ≤⟨ ℤ.*-monoˡ-≤-nonNeg (↧ p) q≤r ⟩
-  d₁ ℤ.* (n₃ ℤ.* d₂) ≡˘⟨ ℤ.*-assoc d₁ n₃ d₂ ⟩
+  d₁ ℤ.* (n₃ ℤ.* d₂) ≡⟨ ℤ.*-assoc d₁ n₃ d₂ ⟨
   d₁ ℤ.*  n₃ ℤ.* d₂  ≡⟨ cong (ℤ._* d₂) (ℤ.*-comm d₁ n₃) ⟩
   n₃ ℤ.*  d₁ ℤ.* d₂  ∎
   where open ℤ.≤-Reasoning
@@ -429,15 +512,15 @@ _>?_ = flip _<?_
   ℤ.*-cancelʳ-<-nonNeg _ $ begin-strict
   n₁ ℤ.*  d₃ ℤ.* d₂  ≡⟨ ℤ.*-assoc n₁ d₃ d₂ ⟩
   n₁ ℤ.* (d₃ ℤ.* d₂) ≡⟨ cong (n₁ ℤ.*_) (ℤ.*-comm d₃ d₂) ⟩
-  n₁ ℤ.* (d₂ ℤ.* d₃) ≡˘⟨ ℤ.*-assoc n₁ d₂ d₃ ⟩
+  n₁ ℤ.* (d₂ ℤ.* d₃) ≡⟨ ℤ.*-assoc n₁ d₂ d₃ ⟨
   n₁ ℤ.*  d₂ ℤ.* d₃  <⟨ ℤ.*-monoʳ-<-pos (↧ r) p<q ⟩
   n₂ ℤ.*  d₁ ℤ.* d₃  ≡⟨ ℤ.*-assoc n₂ d₁ d₃ ⟩
   n₂ ℤ.* (d₁ ℤ.* d₃) ≡⟨ cong (n₂ ℤ.*_) (ℤ.*-comm d₁ d₃) ⟩
-  n₂ ℤ.* (d₃ ℤ.* d₁) ≡˘⟨ ℤ.*-assoc n₂ d₃ d₁ ⟩
+  n₂ ℤ.* (d₃ ℤ.* d₁) ≡⟨ ℤ.*-assoc n₂ d₃ d₁ ⟨
   n₂ ℤ.*  d₃ ℤ.* d₁  ≡⟨ cong (ℤ._* d₁) q≡r ⟩
   n₃ ℤ.*  d₂ ℤ.* d₁  ≡⟨ ℤ.*-assoc n₃ d₂ d₁ ⟩
   n₃ ℤ.* (d₂ ℤ.* d₁) ≡⟨ cong (n₃ ℤ.*_) (ℤ.*-comm d₂ d₁) ⟩
-  n₃ ℤ.* (d₁ ℤ.* d₂) ≡˘⟨ ℤ.*-assoc n₃ d₁ d₂ ⟩
+  n₃ ℤ.* (d₁ ℤ.* d₂) ≡⟨ ℤ.*-assoc n₃ d₁ d₂ ⟨
   n₃ ℤ.*  d₁ ℤ.* d₂  ∎
   where open ℤ.≤-Reasoning
         n₁ = ↥ p; n₂ = ↥ q; n₃ = ↥ r; d₁ = ↧ p; d₂ = ↧ q; d₃ = ↧ r
@@ -472,9 +555,14 @@ _>?_ = flip _<?_
 
 <-isStrictTotalOrder : IsStrictTotalOrder _≃_ _<_
 <-isStrictTotalOrder = record
-  { isEquivalence = ≃-isEquivalence
-  ; trans         = <-trans
-  ; compare       = <-cmp
+  { isStrictPartialOrder = <-isStrictPartialOrder
+  ; compare              = <-cmp
+  }
+
+<-isDenseLinearOrder : IsDenseLinearOrder _≃_ _<_
+<-isDenseLinearOrder = record
+  { isStrictTotalOrder = <-isStrictTotalOrder
+  ; dense              = <-dense
   }
 
 ------------------------------------------------------------------------
@@ -495,6 +583,11 @@ _>?_ = flip _<?_
   { isStrictTotalOrder = <-isStrictTotalOrder
   }
 
+<-denseLinearOrder : DenseLinearOrder 0ℓ 0ℓ 0ℓ
+<-denseLinearOrder = record
+  { isDenseLinearOrder = <-isDenseLinearOrder
+  }
+
 ------------------------------------------------------------------------
 -- A specialised module for reasoning about the _≤_ and _<_ relations
 ------------------------------------------------------------------------
@@ -502,22 +595,19 @@ _>?_ = flip _<?_
 module ≤-Reasoning where
   import Relation.Binary.Reasoning.Base.Triple
     ≤-isPreorder
+    <-asym
     <-trans
     <-resp-≃
     <⇒≤
     <-≤-trans
     ≤-<-trans
     as Triple
-  open Triple public hiding (step-≈; step-≈˘)
 
-  infixr 2 step-≃ step-≃˘
-
-  step-≃  = Triple.step-≈
-  step-≃˘ = Triple.step-≈˘
-
-  syntax step-≃  x y∼z x≃y = x ≃⟨  x≃y ⟩ y∼z
-  syntax step-≃˘ x y∼z y≃x = x ≃˘⟨ y≃x ⟩ y∼z
+  open Triple public
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨)
+    renaming (≈-go to ≃-go)
 
+  open ≃-syntax _IsRelatedTo_ _IsRelatedTo_ ≃-go ≃-sym public
 
 ------------------------------------------------------------------------
 -- Properties of ↥_/↧_
@@ -670,14 +760,14 @@ neg⇒nonZero (mkℚᵘ (-[1+ _ ]) _) = _
 +-inverseˡ : LeftInverse _≃_ 0ℚᵘ -_ _+_
 +-inverseˡ p@record{} = *≡* let n = ↥ p; d = ↧ p in
   ((ℤ.- n) ℤ.* d ℤ.+ n ℤ.* d) ℤ.* 1ℤ ≡⟨ ℤ.*-identityʳ ((ℤ.- n) ℤ.* d ℤ.+ n ℤ.* d) ⟩
-  (ℤ.- n) ℤ.* d ℤ.+ n ℤ.* d          ≡˘⟨ cong (ℤ._+ (n ℤ.* d)) (ℤ.neg-distribˡ-* n d) ⟩
+  (ℤ.- n) ℤ.* d ℤ.+ n ℤ.* d          ≡⟨ cong (ℤ._+ (n ℤ.* d)) (ℤ.neg-distribˡ-* n d) ⟨
   ℤ.- (n ℤ.* d) ℤ.+ n ℤ.* d          ≡⟨ ℤ.+-inverseˡ (n ℤ.* d) ⟩
   0ℤ                                 ∎ where open ≡-Reasoning
 
 +-inverseʳ : RightInverse _≃_ 0ℚᵘ -_ _+_
 +-inverseʳ p@record{} = *≡* let n = ↥ p; d = ↧ p in
   (n ℤ.* d ℤ.+ (ℤ.- n) ℤ.* d) ℤ.* 1ℤ ≡⟨ ℤ.*-identityʳ (n ℤ.* d ℤ.+ (ℤ.- n) ℤ.* d) ⟩
-  n ℤ.* d ℤ.+ (ℤ.- n) ℤ.* d          ≡˘⟨ cong (λ n+d → n ℤ.* d ℤ.+ n+d) (ℤ.neg-distribˡ-* n d) ⟩
+  n ℤ.* d ℤ.+ (ℤ.- n) ℤ.* d          ≡⟨ cong (λ n+d → n ℤ.* d ℤ.+ n+d) (ℤ.neg-distribˡ-* n d) ⟨
   n ℤ.* d ℤ.+ ℤ.- (n ℤ.* d)          ≡⟨ ℤ.+-inverseʳ (n ℤ.* d) ⟩
   0ℤ                                 ∎ where open ≡-Reasoning
 
@@ -686,9 +776,9 @@ neg⇒nonZero (mkℚᵘ (-[1+ _ ]) _) = _
 
 +-cancelˡ : ∀ {r p q} → r + p ≃ r + q → p ≃ q
 +-cancelˡ {r} {p} {q} r+p≃r+q = begin-equality
-  p            ≃˘⟨ +-identityʳ p ⟩
-  p + 0ℚᵘ      ≃˘⟨ +-congʳ p (+-inverseʳ r) ⟩
-  p + (r - r)  ≃˘⟨ +-assoc p r (- r) ⟩
+  p            ≃⟨ +-identityʳ p ⟨
+  p + 0ℚᵘ      ≃⟨ +-congʳ p (+-inverseʳ r) ⟨
+  p + (r - r)  ≃⟨ +-assoc p r (- r) ⟨
   (p + r) - r  ≃⟨ +-congˡ (- r) (+-comm p r) ⟩
   (r + p) - r  ≃⟨ +-congˡ (- r) r+p≃r+q ⟩
   (r + q) - r  ≃⟨ +-congˡ (- r) (+-comm r q) ⟩
@@ -792,7 +882,7 @@ p≤p+q p q rewrite +-comm-≡ p q = p≤q+p p q
 +-mono-<-≤ : _+_ Preserves₂ _<_ ⟶ _≤_ ⟶ _<_
 +-mono-<-≤ {p} {q} {r} p<q q≤r = <-≤-trans (+-monoˡ-< r p<q) (+-monoʳ-≤ q q≤r)
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _+_ and predicates
 
 pos+pos⇒pos : ∀ p .{{_ : Positive p}} →
@@ -806,7 +896,7 @@ nonNeg+nonNeg⇒nonNeg : ∀ p .{{_ : NonNegative p}} →
 nonNeg+nonNeg⇒nonNeg p q = nonNegative
   (+-mono-≤ (nonNegative⁻¹ p) (nonNegative⁻¹ q))
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _-_
 
 +-minus-telescope : ∀ p q r → (p - q) + (q - r) ≃ p - r
@@ -825,26 +915,26 @@ p≃q⇒p-q≃0 p q p≃q = begin-equality
 
 p-q≃0⇒p≃q : ∀ p q → p - q ≃ 0ℚᵘ → p ≃ q
 p-q≃0⇒p≃q p q p-q≃0 = begin-equality
-  p             ≡˘⟨ +-identityʳ-≡ p ⟩
+  p             ≡⟨ +-identityʳ-≡ p ⟨
   p + 0ℚᵘ       ≃⟨ +-congʳ p (≃-sym (+-inverseˡ q)) ⟩
-  p + (- q + q) ≡˘⟨ +-assoc-≡ p (- q) q ⟩
+  p + (- q + q) ≡⟨ +-assoc-≡ p (- q) q ⟨
   (p - q) + q   ≃⟨ +-congˡ q p-q≃0 ⟩
   0ℚᵘ + q       ≡⟨ +-identityˡ-≡ q ⟩
   q             ∎ where open ≤-Reasoning
 
 neg-mono-≤ : -_ Preserves _≤_ ⟶ _≥_
 neg-mono-≤ {p@record{}} {q@record{}} (*≤* p≤q) = *≤* $ begin
-  ℤ.- ↥ q ℤ.* ↧ p   ≡˘⟨ ℤ.neg-distribˡ-* (↥ q) (↧ p) ⟩
+  ℤ.- ↥ q ℤ.* ↧ p   ≡⟨ ℤ.neg-distribˡ-* (↥ q) (↧ p) ⟨
   ℤ.- (↥ q ℤ.* ↧ p) ≤⟨ ℤ.neg-mono-≤ p≤q ⟩
   ℤ.- (↥ p ℤ.* ↧ q) ≡⟨ ℤ.neg-distribˡ-* (↥ p) (↧ q) ⟩
   ℤ.- ↥ p ℤ.* ↧ q   ∎ where open ℤ.≤-Reasoning
 
 neg-cancel-≤ : ∀ {p q} → - p ≤ - q → q ≤ p
 neg-cancel-≤ {p@record{}} {q@record{}} (*≤* -↥p↧q≤-↥q↧p) = *≤* $ begin
-  ↥ q ℤ.* ↧ p             ≡˘⟨ ℤ.neg-involutive (↥ q ℤ.* ↧ p) ⟩
+  ↥ q ℤ.* ↧ p             ≡⟨ ℤ.neg-involutive (↥ q ℤ.* ↧ p) ⟨
   ℤ.- ℤ.- (↥ q ℤ.* ↧ p)   ≡⟨ cong ℤ.-_ (ℤ.neg-distribˡ-* (↥ q) (↧ p)) ⟩
   ℤ.- ((ℤ.- ↥ q) ℤ.* ↧ p) ≤⟨ ℤ.neg-mono-≤ -↥p↧q≤-↥q↧p ⟩
-  ℤ.- ((ℤ.- ↥ p) ℤ.* ↧ q) ≡˘⟨ cong ℤ.-_ (ℤ.neg-distribˡ-* (↥ p) (↧ q)) ⟩
+  ℤ.- ((ℤ.- ↥ p) ℤ.* ↧ q) ≡⟨ cong ℤ.-_ (ℤ.neg-distribˡ-* (↥ p) (↧ q)) ⟨
   ℤ.- ℤ.- (↥ p ℤ.* ↧ q)   ≡⟨ ℤ.neg-involutive (↥ p ℤ.* ↧ q) ⟩
   ↥ p ℤ.* ↧ q             ∎
   where
@@ -858,9 +948,9 @@ p≤q⇒p-q≤0 {p} {q} p≤q = begin
 
 p-q≤0⇒p≤q : ∀ {p q} → p - q ≤ 0ℚᵘ → p ≤ q
 p-q≤0⇒p≤q {p} {q} p-q≤0 = begin
-  p             ≡˘⟨ +-identityʳ-≡ p ⟩
+  p             ≡⟨ +-identityʳ-≡ p ⟨
   p + 0ℚᵘ       ≃⟨ +-congʳ p (≃-sym (+-inverseˡ q)) ⟩
-  p + (- q + q) ≡˘⟨ +-assoc-≡ p (- q) q ⟩
+  p + (- q + q) ≡⟨ +-assoc-≡ p (- q) q ⟨
   (p - q) + q   ≤⟨ +-monoˡ-≤ q p-q≤0 ⟩
   0ℚᵘ + q       ≡⟨ +-identityˡ-≡ q ⟩
   q             ∎ where open ≤-Reasoning
@@ -873,7 +963,7 @@ p≤q⇒0≤q-p {p} {q} p≤q = begin
 
 0≤q-p⇒p≤q : ∀ {p q} → 0ℚᵘ ≤ q - p → p ≤ q
 0≤q-p⇒p≤q {p} {q} 0≤p-q = begin
-  p             ≡˘⟨ +-identityˡ-≡ p ⟩
+  p             ≡⟨ +-identityˡ-≡ p ⟨
   0ℚᵘ + p       ≤⟨ +-monoˡ-≤ p 0≤p-q ⟩
   q - p + p     ≡⟨ +-assoc-≡ q (- p) p ⟩
   q + (- p + p) ≃⟨ +-congʳ q (+-inverseˡ p) ⟩
@@ -1032,16 +1122,24 @@ p≤q⇒0≤q-p {p} {q} p≤q = begin
 *-inverseˡ p@(mkℚᵘ -[1+ n ] d) = *-inverseˡ (mkℚᵘ +[1+ n ] d)
 *-inverseˡ p@(mkℚᵘ +[1+ n ] d) = *≡* $ cong +[1+_] $ begin
   (n ℕ.+ d ℕ.* suc n) ℕ.* 1 ≡⟨ ℕ.*-identityʳ _ ⟩
-  (n ℕ.+ d ℕ.* suc n)       ≡⟨ cong (n ℕ.+_) (ℕ.*-suc d n) ⟩
-  (n ℕ.+ (d ℕ.+ d ℕ.* n))   ≡⟨ solve 2 (λ n d → n :+ (d :+ d :* n) := d :+ (n :+ n :* d)) refl n d ⟩
-  (d ℕ.+ (n ℕ.+ n ℕ.* d))   ≡⟨ cong (d ℕ.+_) (sym (ℕ.*-suc n d)) ⟩
-  d ℕ.+ n ℕ.* suc d         ≡˘⟨ ℕ.+-identityʳ _ ⟩
+  n ℕ.+ d ℕ.* suc n         ≡⟨ cong (n ℕ.+_) (ℕ.*-suc d n) ⟩
+  n ℕ.+ (d ℕ.+ d ℕ.* n)     ≡⟨ trans (sym $ ℕ.+-assoc n d _) (trans
+                                      (cong₂ ℕ._+_ (ℕ.+-comm n d) (ℕ.*-comm d n))
+                                      (ℕ.+-assoc d n _)) ⟩
+  d ℕ.+ (n ℕ.+ n ℕ.* d)     ≡⟨ cong (d ℕ.+_) (sym (ℕ.*-suc n d)) ⟩
+  d ℕ.+ n ℕ.* suc d         ≡⟨ ℕ.+-identityʳ _ ⟨
   d ℕ.+ n ℕ.* suc d ℕ.+ 0   ∎
-  where open ≡-Reasoning; open ℕ-solver
+  where open ≡-Reasoning
 
 *-inverseʳ : ∀ p .{{_ : NonZero p}} → p * 1/ p ≃ 1ℚᵘ
 *-inverseʳ p = ≃-trans (*-comm p (1/ p)) (*-inverseˡ p)
 
+≄⇒invertible : p ≄ q → Invertible _≃_ 1ℚᵘ _*_ (p - q)
+≄⇒invertible {p} {q} p≄q = _ , *-inverseˡ (p - q) , *-inverseʳ (p - q)
+  where instance
+  _ : NonZero (p - q)
+  _ = ≢-nonZero (p≄q ∘ p-q≃0⇒p≃q p q)
+
 *-zeroˡ : LeftZero _≃_ 0ℚᵘ _*_
 *-zeroˡ p@record{} = *≡* refl
 
@@ -1051,6 +1149,14 @@ p≤q⇒0≤q-p {p} {q} p≤q = begin
 *-zero : Zero _≃_ 0ℚᵘ _*_
 *-zero = *-zeroˡ , *-zeroʳ
 
+invertible⇒≄ : Invertible _≃_ 1ℚᵘ _*_ (p - q) → p ≄ q
+invertible⇒≄ {p} {q} (1/p-q , 1/x*x≃1 , x*1/x≃1) p≃q = 0≄1 (begin
+  0ℚᵘ             ≈⟨ *-zeroˡ 1/p-q ⟨
+  0ℚᵘ * 1/p-q     ≈⟨ *-congʳ (p≃q⇒p-q≃0 p q p≃q) ⟨
+  (p - q) * 1/p-q ≈⟨ x*1/x≃1 ⟩
+  1ℚᵘ             ∎)
+  where open ≃-Reasoning
+
 *-distribˡ-+ : _DistributesOverˡ_ _≃_ _*_ _+_
 *-distribˡ-+ p@record{} q@record{} r@record{} =
   let ↥p = ↥ p; ↧p = ↧ p
@@ -1090,9 +1196,9 @@ neg-distribʳ-* p@record{} q@record{} =
   (↥ ((ℤ.+ p ℤ.* q) / (p ℕ.* r))) ℤ.* (↧ (q / r)) ≡⟨  cong (ℤ._* ↧ (q / r)) (↥[n/d]≡n (ℤ.+ p ℤ.* q) (p ℕ.* r)) ⟩
   (ℤ.+ p ℤ.* q) ℤ.* (↧ (q / r))                   ≡⟨  cong ((ℤ.+ p ℤ.* q) ℤ.*_) (↧[n/d]≡d q r) ⟩
   (ℤ.+ p ℤ.* q) ℤ.* ℤ.+ r                         ≡⟨  xy∙z≈y∙xz (ℤ.+ p) q (ℤ.+ r) ⟩
-  (q ℤ.* (ℤ.+ p ℤ.* ℤ.+ r))                       ≡˘⟨ cong (ℤ._* (ℤ.+ p ℤ.* ℤ.+ r)) (↥[n/d]≡n q r) ⟩
-  (↥ (q / r)) ℤ.* (ℤ.+ p ℤ.* ℤ.+ r)               ≡˘⟨  cong (↥ (q / r) ℤ.*_) (ℤ.pos-* p r) ⟩
-  (↥ (q / r)) ℤ.* (ℤ.+ (p ℕ.* r))                 ≡˘⟨ cong (↥ (q / r) ℤ.*_) (↧[n/d]≡d (ℤ.+ p ℤ.* q) (p ℕ.* r)) ⟩
+  (q ℤ.* (ℤ.+ p ℤ.* ℤ.+ r))                       ≡⟨ cong (ℤ._* (ℤ.+ p ℤ.* ℤ.+ r)) (↥[n/d]≡n q r) ⟨
+  (↥ (q / r)) ℤ.* (ℤ.+ p ℤ.* ℤ.+ r)               ≡⟨  cong (↥ (q / r) ℤ.*_) (ℤ.pos-* p r) ⟨
+  (↥ (q / r)) ℤ.* (ℤ.+ (p ℕ.* r))                 ≡⟨ cong (↥ (q / r) ℤ.*_) (↧[n/d]≡d (ℤ.+ p ℤ.* q) (p ℕ.* r)) ⟨
   (↥ (q / r)) ℤ.* (↧ ((ℤ.+ p ℤ.* q) / (p ℕ.* r))) ∎)
   where open ℤ.≤-Reasoning
 
@@ -1129,11 +1235,11 @@ private
 
 *-cancelʳ-≤-neg : ∀ r .{{_ : Negative r}} → p * r ≤ q * r → q ≤ p
 *-cancelʳ-≤-neg {p} {q} r@(mkℚᵘ -[1+ _ ] _) pr≤qr = neg-cancel-≤ (*-cancelʳ-≤-pos (- r) (begin
-  - p * - r    ≃˘⟨ neg-distribˡ-* p (- r) ⟩
-  - (p * - r)  ≃˘⟨ -‿cong (neg-distribʳ-* p r) ⟩
+  - p * - r    ≃⟨ neg-distribˡ-* p (- r) ⟨
+  - (p * - r)  ≃⟨ -‿cong (neg-distribʳ-* p r) ⟨
   - - (p * r)  ≃⟨ neg-involutive (p * r) ⟩
   p * r        ≤⟨ pr≤qr ⟩
-  q * r        ≃˘⟨ neg-involutive (q * r) ⟩
+  q * r        ≃⟨ neg-involutive (q * r) ⟨
   - - (q * r)  ≃⟨ -‿cong (neg-distribʳ-* q r) ⟩
   - (q * - r)  ≃⟨ neg-distribˡ-* q (- r) ⟩
   - q * - r    ∎))
@@ -1145,7 +1251,7 @@ private
 *-monoˡ-≤-nonNeg : ∀ r .{{_ : NonNegative r}} → (_* r) Preserves _≤_ ⟶ _≤_
 *-monoˡ-≤-nonNeg r@(mkℚᵘ (ℤ.+ n) _) {p@record{}} {q@record{}} (*≤* x<y) = *≤* $ begin
   ↥ p ℤ.* ↥ r ℤ.* (↧ q   ℤ.* ↧ r)  ≡⟨  reorder₂ (↥ p) _ _ _ ⟩
-  l₁          ℤ.* (ℤ.+ n ℤ.* ↧ r)  ≡˘⟨  cong (l₁ ℤ.*_) (ℤ.pos-* n _) ⟩
+  l₁          ℤ.* (ℤ.+ n ℤ.* ↧ r)  ≡⟨  cong (l₁ ℤ.*_) (ℤ.pos-* n _) ⟨
   l₁          ℤ.* ℤ.+ (n ℕ.* ↧ₙ r) ≤⟨  ℤ.*-monoʳ-≤-nonNeg (ℤ.+ (n ℕ.* ↧ₙ r)) x<y ⟩
   l₂          ℤ.* ℤ.+ (n ℕ.* ↧ₙ r) ≡⟨ cong (l₂ ℤ.*_) (ℤ.pos-* n _) ⟩
   l₂          ℤ.* (ℤ.+ n ℤ.* ↧ r)  ≡⟨  reorder₂ (↥ q) _ _ _ ⟩
@@ -1165,10 +1271,10 @@ private
 
 *-monoˡ-≤-nonPos : ∀ r .{{_ : NonPositive r}} → (_* r) Preserves _≤_ ⟶ _≥_
 *-monoˡ-≤-nonPos r {p} {q} p≤q = begin
-  q * r        ≃˘⟨ neg-involutive (q * r) ⟩
+  q * r        ≃⟨ neg-involutive (q * r) ⟨
   - - (q * r)  ≃⟨  -‿cong (neg-distribʳ-* q r) ⟩
   - (q * - r)  ≤⟨  neg-mono-≤ (*-monoˡ-≤-nonNeg (- r) {{ -r≥0}} p≤q) ⟩
-  - (p * - r)  ≃˘⟨ -‿cong (neg-distribʳ-* p r) ⟩
+  - (p * - r)  ≃⟨ -‿cong (neg-distribʳ-* p r) ⟨
   - - (p * r)  ≃⟨  neg-involutive (p * r) ⟩
   p * r        ∎
   where open ≤-Reasoning; -r≥0 = nonNegative (neg-mono-≤ (nonPositive⁻¹ r))
@@ -1183,7 +1289,7 @@ private
 *-monoˡ-<-pos r@record{} {p@record{}} {q@record{}} (*<* x<y) = *<* $ begin-strict
   ↥ p ℤ.*  ↥ r ℤ.* (↧ q  ℤ.* ↧ r) ≡⟨ reorder₁ (↥ p) _ _ _ ⟩
   ↥ p ℤ.*  ↧ q ℤ.*  ↥ r  ℤ.* ↧ r  <⟨ ℤ.*-monoʳ-<-pos (↧ r) (ℤ.*-monoʳ-<-pos (↥ r) x<y) ⟩
-  ↥ q ℤ.*  ↧ p ℤ.*  ↥ r  ℤ.* ↧ r  ≡˘⟨ reorder₁ (↥ q) _ _ _ ⟩
+  ↥ q ℤ.*  ↧ p ℤ.*  ↥ r  ℤ.* ↧ r  ≡⟨ reorder₁ (↥ q) _ _ _ ⟨
   ↥ q ℤ.*  ↥ r ℤ.* (↧ p  ℤ.* ↧ r) ∎ where open ℤ.≤-Reasoning
 
 *-monoʳ-<-pos : ∀ r .{{_ : Positive r}} → (r *_) Preserves _<_ ⟶ _<_
@@ -1210,10 +1316,10 @@ private
 
 *-monoˡ-<-neg : ∀ r .{{_ :  Negative r}} → (_* r) Preserves _<_ ⟶ _>_
 *-monoˡ-<-neg r {p} {q} p<q = begin-strict
-  q * r        ≃˘⟨ neg-involutive (q * r) ⟩
+  q * r        ≃⟨ neg-involutive (q * r) ⟨
   - - (q * r)  ≃⟨ -‿cong (neg-distribʳ-* q r) ⟩
   - (q * - r)  <⟨ neg-mono-< (*-monoˡ-<-pos (- r) {{ -r>0}} p<q) ⟩
-  - (p * - r)  ≃˘⟨ -‿cong (neg-distribʳ-* p r) ⟩
+  - (p * - r)  ≃⟨ -‿cong (neg-distribʳ-* p r) ⟨
   - - (p * r)  ≃⟨ neg-involutive (p * r) ⟩
   p * r        ∎
   where open ≤-Reasoning; -r>0 = positive (neg-mono-< (negative⁻¹ r))
@@ -1224,7 +1330,7 @@ private
 *-cancelˡ-<-nonPos : ∀ r .{{_ : NonPositive r}} → r * p < r * q → q < p
 *-cancelˡ-<-nonPos {p} {q} r rp<rq =
   *-cancelˡ-<-nonNeg (- r) {{ -r≥0}} $ begin-strict
-    - r * q    ≃˘⟨ neg-distribˡ-* r q ⟩
+    - r * q    ≃⟨ neg-distribˡ-* r q ⟨
     - (r * q)  <⟨ neg-mono-< rp<rq ⟩
     - (r * p)  ≃⟨ neg-distribˡ-* r p ⟩
     - r * p    ∎
@@ -1233,7 +1339,7 @@ private
 *-cancelʳ-<-nonPos : ∀ r .{{_ : NonPositive r}} → p * r < q * r → q < p
 *-cancelʳ-<-nonPos {p} {q} r rewrite *-comm-≡ p r | *-comm-≡ q r = *-cancelˡ-<-nonPos r
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _*_ and predicates
 
 pos*pos⇒pos : ∀ p .{{_ : Positive p}} →
@@ -1282,7 +1388,6 @@ nonNeg*nonNeg⇒nonNeg p q = nonNegative
   ; *-assoc          = *-assoc
   ; *-identity       = *-identity
   ; distrib          = *-distrib-+
-  ; zero             = *-zero
   }
 
 +-*-isCommutativeRing : IsCommutativeRing _≃_ _+_ _*_ -_ 0ℚᵘ 1ℚᵘ
@@ -1291,6 +1396,20 @@ nonNeg*nonNeg⇒nonNeg p q = nonNegative
   ; *-comm = *-comm
   }
 
++-*-isHeytingCommutativeRing : IsHeytingCommutativeRing _≃_ _≄_ _+_ _*_ -_ 0ℚᵘ 1ℚᵘ
++-*-isHeytingCommutativeRing = record
+  { isCommutativeRing   = +-*-isCommutativeRing
+  ; isApartnessRelation = ≄-isApartnessRelation
+  ; #⇒invertible        = ≄⇒invertible
+  ; invertible⇒#        = invertible⇒≄
+  }
+
++-*-isHeytingField : IsHeytingField _≃_ _≄_ _+_ _*_ -_ 0ℚᵘ 1ℚᵘ
++-*-isHeytingField = record
+  { isHeytingCommutativeRing = +-*-isHeytingCommutativeRing
+  ; tight                    = ≄-tight
+  }
+
 ------------------------------------------------------------------------
 -- Algebraic bundles
 
@@ -1324,6 +1443,16 @@ nonNeg*nonNeg⇒nonNeg p q = nonNegative
   { isCommutativeRing = +-*-isCommutativeRing
   }
 
++-*-heytingCommutativeRing : HeytingCommutativeRing 0ℓ 0ℓ 0ℓ
++-*-heytingCommutativeRing = record
+  { isHeytingCommutativeRing = +-*-isHeytingCommutativeRing
+  }
+
++-*-heytingField : HeytingField 0ℓ 0ℓ 0ℓ
++-*-heytingField = record
+  { isHeytingField = +-*-isHeytingField
+  }
+
 ------------------------------------------------------------------------
 -- Properties of 1/_
 ------------------------------------------------------------------------
@@ -1367,8 +1496,8 @@ p>1⇒1/p<1 {p} p>1 = lemma′ p (p>1⇒p≢0 p>1) p>1
 1/-antimono-≤-pos : ∀ {p q} .{{_ : Positive p}} .{{_ : Positive q}} →
                     p ≤ q → (1/ q) {{pos⇒nonZero q}} ≤ (1/ p) {{pos⇒nonZero p}}
 1/-antimono-≤-pos {p} {q} p≤q = begin
-  1/q              ≃˘⟨ *-identityˡ 1/q ⟩
-  1ℚᵘ * 1/q        ≃˘⟨ *-congʳ (*-inverseˡ p) ⟩
+  1/q              ≃⟨ *-identityˡ 1/q ⟨
+  1ℚᵘ * 1/q        ≃⟨ *-congʳ (*-inverseˡ p) ⟨
   (1/p * p) * 1/q  ≤⟨  *-monoˡ-≤-nonNeg 1/q (*-monoʳ-≤-nonNeg 1/p p≤q) ⟩
   (1/p * q) * 1/q  ≃⟨  *-assoc 1/p q 1/q ⟩
   1/p * (q * 1/q)  ≃⟨  *-congˡ {1/p} (*-inverseʳ q) ⟩
@@ -1647,7 +1776,7 @@ pos⊔pos⇒pos p q = positive (⊔-mono-< (positive⁻¹ p) (positive⁻¹ q))
   ℤ.- ℤ.- (↥ ∣ p ∣ ℤ.* ↧ q)  ≡⟨ cong ℤ.-_ (ℤ.neg-distribˡ-* (↥ ∣ p ∣) (↧ q)) ⟩
   ℤ.- (↥ p ℤ.* ↧ q)          ≡⟨ cong ℤ.-_ ↥p↧q≡↥q↧p ⟩
   ℤ.- (↥ q ℤ.* ↧ p)          ≡⟨ cong ℤ.-_ (ℤ.neg-distribˡ-* (↥ ∣ q ∣) (↧ p)) ⟩
-  ℤ.- ℤ.- (↥ ∣ q ∣ ℤ.* ↧ p)  ≡˘⟨ ℤ.neg-involutive _ ⟩
+  ℤ.- ℤ.- (↥ ∣ q ∣ ℤ.* ↧ p)  ≡⟨ ℤ.neg-involutive _ ⟨
   ↥ ∣ q ∣ ℤ.* ↧ p            ∎)
   where open ≡-Reasoning
 
@@ -1679,7 +1808,7 @@ pos⊔pos⇒pos p q = positive (⊔-mono-< (positive⁻¹ p) (positive⁻¹ q))
 ∣p∣≡p⇒0≤p {mkℚᵘ (ℤ.+ n) d-1} ∣p∣≡p = *≤* (begin
   0ℤ ℤ.* +[1+ d-1 ]  ≡⟨ ℤ.*-zeroˡ (ℤ.+ d-1) ⟩
   0ℤ                 ≤⟨ ℤ.+≤+ ℕ.z≤n ⟩
-  ℤ.+ n              ≡˘⟨ ℤ.*-identityʳ (ℤ.+ n) ⟩
+  ℤ.+ n              ≡⟨ ℤ.*-identityʳ (ℤ.+ n) ⟨
   ℤ.+ n ℤ.* 1ℤ       ∎)
   where open ℤ.≤-Reasoning
 
@@ -1698,7 +1827,7 @@ pos⊔pos⇒pos p q = positive (⊔-mono-< (positive⁻¹ p) (positive⁻¹ q))
   ↥ ∣ (↥p↧q ℤ.+ ↥q↧p) / ↧p↧q ∣ ℤ.* ℤ.+ ↧p↧q        ≡⟨⟩
   ↥ (ℤ.+ ℤ.∣ ↥p↧q ℤ.+ ↥q↧p ∣ / ↧p↧q) ℤ.* ℤ.+ ↧p↧q  ≡⟨ cong (ℤ._* ℤ.+ ↧p↧q) (↥[n/d]≡n (ℤ.+ ℤ.∣ ↥p↧q ℤ.+ ↥q↧p ∣) ↧p↧q) ⟩
   ℤ.+ ℤ.∣ ↥p↧q ℤ.+ ↥q↧p ∣ ℤ.* ℤ.+ ↧p↧q             ≤⟨ ℤ.*-monoʳ-≤-nonNeg (ℤ.+ ↧p↧q) (ℤ.+≤+ (ℤ.∣i+j∣≤∣i∣+∣j∣ ↥p↧q ↥q↧p)) ⟩
-  (ℤ.+ ℤ.∣ ↥p↧q ∣ ℤ.+ ℤ.+ ℤ.∣ ↥q↧p ∣) ℤ.* ℤ.+ ↧p↧q ≡˘⟨ cong₂ (λ h₁ h₂ → (h₁ ℤ.+ h₂) ℤ.* ℤ.+ ↧p↧q) ∣↥p∣↧q≡∣↥p↧q∣ ∣↥q∣↧p≡∣↥q↧p∣ ⟩
+  (ℤ.+ ℤ.∣ ↥p↧q ∣ ℤ.+ ℤ.+ ℤ.∣ ↥q↧p ∣) ℤ.* ℤ.+ ↧p↧q ≡⟨ cong₂ (λ h₁ h₂ → (h₁ ℤ.+ h₂) ℤ.* ℤ.+ ↧p↧q) ∣↥p∣↧q≡∣↥p↧q∣ ∣↥q∣↧p≡∣↥q↧p∣ ⟨
   (∣↥p∣↧q ℤ.+ ∣↥q∣↧p) ℤ.* ℤ.+ ↧p↧q                 ≡⟨⟩
   (↥∣p∣↧q ℤ.+ ↥∣q∣↧p) ℤ.* ℤ.+ ↧p↧q                 ≡⟨ cong (ℤ._* ℤ.+ ↧p↧q) (↥[n/d]≡n (↥∣p∣↧q ℤ.+ ↥∣q∣↧p) ↧p↧q) ⟩
   ↥ ((↥∣p∣↧q ℤ.+ ↥∣q∣↧p) / ↧p↧q) ℤ.* ℤ.+ ↧p↧q      ≡⟨⟩
@@ -1715,9 +1844,9 @@ pos⊔pos⇒pos p q = positive (⊔-mono-< (positive⁻¹ p) (positive⁻¹ q))
     ∣m∣n≡∣mn∣ : ∀ m n → ℤ.+ ℤ.∣ m ∣ ℤ.* ℤ.+ n ≡ ℤ.+ ℤ.∣ m ℤ.* ℤ.+ n ∣
     ∣m∣n≡∣mn∣ m n = begin-equality
       ℤ.+ ℤ.∣ m ∣ ℤ.* ℤ.+ n                        ≡⟨⟩
-      ℤ.+ ℤ.∣ m ∣ ℤ.* ℤ.+ ℤ.∣ ℤ.+ n ∣              ≡˘⟨ ℤ.pos-* ℤ.∣ m ∣ ℤ.∣ ℤ.+ n ∣ ⟩
+      ℤ.+ ℤ.∣ m ∣ ℤ.* ℤ.+ ℤ.∣ ℤ.+ n ∣              ≡⟨ ℤ.pos-* ℤ.∣ m ∣ ℤ.∣ ℤ.+ n ∣ ⟨
       ℤ.+ (ℤ.∣ m ∣ ℕ.* n)                          ≡⟨⟩
-      ℤ.+ (ℤ.∣ m ∣ ℕ.* ℤ.∣ ℤ.+ n ∣)                ≡˘⟨ cong ℤ.+_ (ℤ.∣i*j∣≡∣i∣*∣j∣ m (ℤ.+ n)) ⟩
+      ℤ.+ (ℤ.∣ m ∣ ℕ.* ℤ.∣ ℤ.+ n ∣)                ≡⟨ cong ℤ.+_ (ℤ.∣i*j∣≡∣i∣*∣j∣ m (ℤ.+ n)) ⟨
       ℤ.+ (ℤ.∣ m ℤ.* ℤ.+ n ∣)                      ∎
     ∣↥p∣↧q≡∣↥p↧q∣ : ∣↥p∣↧q ≡ ℤ.+ ℤ.∣ ↥p↧q ∣
     ∣↥p∣↧q≡∣↥p↧q∣ = ∣m∣n≡∣mn∣ (↥ p) (↧ₙ q)
diff --git a/src/Data/Record.agda b/src/Data/Record.agda
index b2328e89ad..709ce69a67 100644
--- a/src/Data/Record.agda
+++ b/src/Data/Record.agda
@@ -10,21 +10,19 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Data.Bool.Base using (true; false; if_then_else_)
-open import Data.Empty
-open import Data.List.Base
-open import Data.Product hiding (proj₁; proj₂)
-open import Data.Unit.Polymorphic
-open import Function
-open import Level
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
-open import Relation.Nullary
-open import Relation.Nullary.Decidable
+open import Data.Empty using (⊥)
+open import Data.List.Base using (List; []; _∷_; foldr)
+open import Data.Product.Base hiding (proj₁; proj₂)
+open import Data.Unit.Polymorphic using (⊤)
+open import Function.Base using (id; _∘_)
+open import Level using (suc; _⊔_)
+open import Relation.Binary.Definitions using (DecidableEquality)
+open import Relation.Nullary.Decidable using (does)
 
 -- The module is parametrised by the type of labels, which should come
 -- with decidable equality.
 
-module Data.Record {ℓ} (Label : Set ℓ) (_≟_ : Decidable {A = Label} _≡_) where
+module Data.Record {ℓ} (Label : Set ℓ) (_≟_ : DecidableEquality Label) where
 
 ------------------------------------------------------------------------
 -- A Σ-type with a manifest field
diff --git a/src/Data/Refinement.agda b/src/Data/Refinement.agda
index 8671e8593d..dd63e0918a 100644
--- a/src/Data/Refinement.agda
+++ b/src/Data/Refinement.agda
@@ -23,6 +23,7 @@ record Refinement {a p} (A : Set a) (P : A → Set p) : Set (a ⊔ p) where
   constructor _,_
   field value : A
         proof : Irrelevant (P value)
+infixr 4 _,_
 open Refinement public
 
 -- The syntax declaration below is meant to mimick set comprehension.
diff --git a/src/Data/Sign/Properties.agda b/src/Data/Sign/Properties.agda
index ccaa33f0d1..f72f5ce476 100644
--- a/src/Data/Sign/Properties.agda
+++ b/src/Data/Sign/Properties.agda
@@ -8,16 +8,21 @@
 
 module Data.Sign.Properties where
 
-open import Algebra.Bundles
-open import Data.Empty
-open import Data.Sign.Base
-open import Data.Product using (_,_)
-open import Function hiding (Inverse)
+open import Algebra.Bundles using (Magma; Semigroup; CommutativeSemigroup;
+  Monoid; CommutativeMonoid; Group; AbelianGroup)
+open import Data.Sign.Base using (Sign; opposite; _*_; +; -)
+open import Data.Product.Base using (_,_)
+open import Function.Base using (_$_; id)
+open import Function.Definitions using (Injective)
 open import Level using (0ℓ)
 open import Relation.Binary
   using (Decidable; DecidableEquality; Setoid; DecSetoid; IsDecEquivalence)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; _≢_; sym; cong₂)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (setoid; decSetoid; isDecEquivalence; isEquivalence)
 open import Relation.Nullary.Decidable using (yes; no)
+open import Relation.Nullary.Negation.Core using (contradiction)
 
 open import Algebra.Structures {A = Sign} _≡_
 open import Algebra.Definitions {A = Sign} _≡_
@@ -101,8 +106,8 @@ s*s≡+ - = refl
 
 *-cancelʳ-≡ : RightCancellative _*_
 *-cancelʳ-≡ _ - - _  = refl
-*-cancelʳ-≡ _ - + eq = ⊥-elim (s≢opposite[s] _ $ sym eq)
-*-cancelʳ-≡ _ + - eq = ⊥-elim (s≢opposite[s] _ eq)
+*-cancelʳ-≡ _ - + eq = contradiction (sym eq) (s≢opposite[s] _)
+*-cancelʳ-≡ _ + - eq = contradiction eq (s≢opposite[s] _)
 *-cancelʳ-≡ _ + + _  = refl
 
 *-cancelˡ-≡ : LeftCancellative _*_
diff --git a/src/Data/Star/BoundedVec.agda b/src/Data/Star/BoundedVec.agda
index bae0c52f2d..11f2585e40 100644
--- a/src/Data/Star/BoundedVec.agda
+++ b/src/Data/Star/BoundedVec.agda
@@ -11,15 +11,17 @@
 module Data.Star.BoundedVec where
 
 import Data.Maybe.Base as Maybe
-open import Data.Star.Nat
-open import Data.Star.Decoration
+open import Data.Star.Nat using (ℕ; suc; length)
+open import Data.Star.Decoration using (decoration)
 open import Data.Star.Pointer
+  using (Any; this; that; Pointer; step; done; init)
 open import Data.Star.List using (List)
-open import Data.Unit
-open import Function
-open import Relation.Binary
-open import Relation.Binary.Consequences
+open import Data.Unit.Base using (⊤; tt)
+open import Function.Base using (const)
+open import Relation.Binary.Core using (_=[_]⇒_)
+open import Relation.Binary.Consequences using (map-NonEmpty)
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive
+  using (gmap; ε; _◅_)
 
 ------------------------------------------------------------------------
 -- The type
diff --git a/src/Data/Star/Decoration.agda b/src/Data/Star/Decoration.agda
index 24428a5843..ce3ef5f7cd 100644
--- a/src/Data/Star/Decoration.agda
+++ b/src/Data/Star/Decoration.agda
@@ -8,10 +8,11 @@
 
 module Data.Star.Decoration where
 
-open import Data.Unit
-open import Function
-open import Level
-open import Relation.Binary
+open import Data.Unit.Base using (⊤; tt)
+open import Function.Base using (flip)
+open import Level using (Level; suc; _⊔_)
+open import Relation.Binary.Core using (Rel; _=[_]⇒_; _⇒_)
+open import Relation.Binary.Definitions using (NonEmpty; nonEmpty)
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive
 
 -- A predicate on relation "edges" (think of the relation as a graph).
@@ -19,7 +20,6 @@ open import Relation.Binary.Construct.Closure.ReflexiveTransitive
 EdgePred : {ℓ r : Level} (p : Level) {I : Set ℓ} → Rel I r → Set (suc p ⊔ ℓ ⊔ r)
 EdgePred p T = ∀ {i j} → T i j → Set p
 
-
 data NonEmptyEdgePred {ℓ r p : Level} {I : Set ℓ} (T : Rel I r)
                       (P : EdgePred p T) : Set (ℓ ⊔ r ⊔ p) where
   nonEmptyEdgePred : ∀ {i j} {x : T i j}
@@ -28,7 +28,7 @@ data NonEmptyEdgePred {ℓ r p : Level} {I : Set ℓ} (T : Rel I r)
 -- Decorating an edge with more information.
 
 data DecoratedWith {ℓ r p : Level} {I : Set ℓ} {T : Rel I r} (P : EdgePred p T)
-       : Rel (NonEmpty (Star T)) p where
+       : Rel (NonEmpty (Star T)) (ℓ ⊔ r ⊔ p) where
   ↦ : ∀ {i j k} {x : T i j} {xs : Star T j k}
       (p : P x) → DecoratedWith P (nonEmpty (x ◅ xs)) (nonEmpty xs)
 
diff --git a/src/Data/Star/Environment.agda b/src/Data/Star/Environment.agda
index 65fcbd4818..77c7eff384 100644
--- a/src/Data/Star/Environment.agda
+++ b/src/Data/Star/Environment.agda
@@ -8,14 +8,15 @@
 
 module Data.Star.Environment {ℓ} (Ty : Set ℓ) where
 
-open import Level
-open import Data.Star.List
-open import Data.Star.Decoration
-open import Data.Star.Pointer as Pointer hiding (lookup)
-open import Data.Unit
-open import Function hiding (_∋_)
-open import Relation.Binary.PropositionalEquality
+open import Level using (_⊔_)
+open import Data.Star.List using (List)
+open import Data.Star.Decoration using (All)
+open import Data.Star.Pointer as Pointer using (Any; this; that; result)
+open import Data.Unit.Polymorphic.Base using (⊤)
+open import Function.Base using (const; case_of_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive
+  using (_▻_)
 
 -- Contexts, listing the types of all the elements in an environment.
 
@@ -27,7 +28,7 @@ Ctxt = List Ty
 infix 4 _∋_
 
 _∋_ : Ctxt → Ty → Set ℓ
-Γ ∋ σ = Any (const (Lift ℓ ⊤)) (σ ≡_) Γ
+Γ ∋ σ = Any (const (⊤ {ℓ})) (σ ≡_) Γ
 
 vz : ∀ {Γ σ} → Γ ▻ σ ∋ σ
 vz = this refl
@@ -43,5 +44,4 @@ Env T Γ = All T Γ
 -- A safe lookup function for environments.
 
 lookup : ∀ {Γ σ} {T : Ty → Set} → Env T Γ → Γ ∋ σ → T σ
-lookup ρ i with Pointer.lookup ρ i
-... | result refl x = x
+lookup ρ i with result refl x ← Pointer.lookup ρ i = x
diff --git a/src/Data/Star/Fin.agda b/src/Data/Star/Fin.agda
index 9ed437f95f..ded64da4bb 100644
--- a/src/Data/Star/Fin.agda
+++ b/src/Data/Star/Fin.agda
@@ -9,8 +9,8 @@
 module Data.Star.Fin where
 
 open import Data.Star.Nat as ℕ using (ℕ)
-open import Data.Star.Pointer
-open import Data.Unit
+open import Data.Star.Pointer using (Any; this; that)
+open import Data.Unit.Base using (⊤; tt)
 
 -- Finite sets are undecorated pointers into natural numbers.
 
diff --git a/src/Data/Star/List.agda b/src/Data/Star/List.agda
index 358ea7281e..bcc9870375 100644
--- a/src/Data/Star/List.agda
+++ b/src/Data/Star/List.agda
@@ -8,11 +8,12 @@
 
 module Data.Star.List where
 
-open import Data.Star.Nat
-open import Data.Unit
+open import Data.Star.Nat using (ℕ; _+_; zero)
+open import Data.Unit.Base using (tt)
 open import Relation.Binary.Construct.Always using (Always)
 open import Relation.Binary.Construct.Constant using (Const)
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive
+  using (Star; ε; _◅_; fold)
 
 -- Lists.
 
diff --git a/src/Data/Star/Nat.agda b/src/Data/Star/Nat.agda
index 42cf1e6b9f..960537c593 100644
--- a/src/Data/Star/Nat.agda
+++ b/src/Data/Star/Nat.agda
@@ -8,9 +8,9 @@
 
 module Data.Star.Nat where
 
-open import Data.Unit
-open import Function
-open import Relation.Binary
+open import Data.Unit.Base using (tt)
+open import Function.Base using (const)
+open import Relation.Binary.Core using (Rel)
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive
 open import Relation.Binary.Construct.Always using (Always)
 
diff --git a/src/Data/Star/Pointer.agda b/src/Data/Star/Pointer.agda
index ed606807ce..c193cd776e 100644
--- a/src/Data/Star/Pointer.agda
+++ b/src/Data/Star/Pointer.agda
@@ -11,7 +11,7 @@ module Data.Star.Pointer {ℓ} {I : Set ℓ} where
 open import Data.Maybe.Base using (Maybe; nothing; just)
 open import Data.Star.Decoration
 open import Data.Unit.Base
-open import Function.Base using (const)
+open import Function.Base using (const; case_of_)
 open import Level
 open import Relation.Binary.Core using (Rel)
 open import Relation.Binary.Definitions using (NonEmpty; nonEmpty)
@@ -26,7 +26,7 @@ private
 
 data Pointer {T : Rel I r}
              (P : EdgePred p T) (Q : EdgePred q T)
-             : Rel (Maybe (NonEmpty (Star T))) (p ⊔ q) where
+             : Rel (Maybe (NonEmpty (Star T))) (ℓ ⊔ r ⊔ p ⊔ q) where
   step : ∀ {i j k} {x : T i j} {xs : Star T j k}
          (p : P x) → Pointer P Q (just (nonEmpty (x ◅ xs)))
                                  (just (nonEmpty xs))
@@ -92,5 +92,5 @@ module _ {T : Rel I r} {P : EdgePred p T} {Q : EdgePred q T} where
 
   last : ∀ {i j} {xs : Star T i j} →
          Any P Q xs → NonEmptyEdgePred T Q
-  last ps with lookup {r = p} (decorate (const (lift tt)) _) ps
-  ... | result q _ = nonEmptyEdgePred q
+  last ps with result q _ ← lookup {r = p} (decorate (const (lift tt)) _) ps =
+    nonEmptyEdgePred q
diff --git a/src/Data/Star/Vec.agda b/src/Data/Star/Vec.agda
index 2fd96ee75b..b7187ae36a 100644
--- a/src/Data/Star/Vec.agda
+++ b/src/Data/Star/Vec.agda
@@ -8,16 +8,16 @@
 
 module Data.Star.Vec where
 
-open import Data.Star.Nat
+open import Data.Star.Nat using (ℕ; zero; suc; 1#; _+_; length)
 open import Data.Star.Fin using (Fin)
-open import Data.Star.Decoration
-open import Data.Star.Pointer as Pointer hiding (lookup)
+open import Data.Star.Decoration using (All; ↦; _◅◅◅_; decoration)
+open import Data.Star.Pointer as Pointer using (result)
 open import Data.Star.List using (List)
 open import Level using (Level)
-open import Relation.Binary
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive
-open import Function.Base
-open import Data.Unit
+  using (ε; _◅_; gmap)
+open import Function.Base using (const; case_of_)
+open import Data.Unit.Base using (tt)
 
 private
   variable
@@ -58,8 +58,7 @@ _++_ = _◅◅◅_
 -- Safe lookup.
 
 lookup : ∀ {n} → Vec A n → Fin n → A
-lookup xs i with Pointer.lookup xs i
-... | result _ x = x
+lookup xs i with result _ x ← Pointer.lookup xs i = x
 
 ------------------------------------------------------------------------
 -- Conversions
diff --git a/src/Data/String.agda b/src/Data/String.agda
index 98814b1909..98b01b3b5f 100644
--- a/src/Data/String.agda
+++ b/src/Data/String.agda
@@ -8,29 +8,21 @@
 
 module Data.String where
 
-open import Data.Bool using (true; false; T?)
-open import Data.Char as Char using (Char)
-open import Function.Base
-open import Data.Nat.Base as ℕ using (ℕ; _∸_; ⌊_/2⌋; ⌈_/2⌉)
-import Data.Nat.Properties as ℕₚ
-open import Data.List.Base as List using (List; _∷_; []; [_])
-open import Data.List.NonEmpty as NE using (List⁺)
-open import Data.List.Extrema ℕₚ.≤-totalOrder
-open import Data.List.Relation.Binary.Pointwise using (Pointwise)
-open import Data.List.Relation.Binary.Lex.Strict using (Lex-<; Lex-≤)
+open import Data.Bool.Base using (if_then_else_)
+open import Data.Char.Base as Char using (Char)
+open import Function.Base using (_∘_; _$_)
+open import Data.Nat.Base as ℕ using (ℕ)
+import Data.Nat.Properties as ℕ
+open import Data.List.Base as List using (List)
+open import Data.List.Extrema ℕ.≤-totalOrder
 open import Data.Vec.Base as Vec using (Vec)
 open import Data.Char.Base as Char using (Char)
 import Data.Char.Properties as Char using (_≟_)
-open import Function
-open import Relation.Binary using (Rel)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
-open import Relation.Nullary.Decidable using (does)
-open import Relation.Unary using (Pred; Decidable)
+open import Relation.Nullary.Decidable.Core using (does)
 
 open import Data.List.Membership.DecPropositional Char._≟_
 
 
-
 ------------------------------------------------------------------------
 -- Re-export contents of base, and decidability of equality
 
@@ -49,9 +41,7 @@ fromVec = fromList ∘ Vec.toList
 
 -- enclose string with parens if it contains a space character
 parensIfSpace : String → String
-parensIfSpace s with does (' ' ∈? toList s)
-... | true  = parens s
-... | false = s
+parensIfSpace s = if does (' ' ∈? toList s) then parens s else s
 
 
 ------------------------------------------------------------------------
@@ -71,10 +61,10 @@ rectangle pads cells = Vec.zipWith (λ p c → p width c) pads cells where
 -- Special cases for left, center, and right alignment
 
 rectangleˡ : ∀ {n} → Char → Vec String n → Vec String n
-rectangleˡ c = rectangle (Vec.replicate $ padLeft c)
+rectangleˡ c = rectangle (Vec.replicate _ $ padLeft c)
 
 rectangleʳ : ∀ {n} → Char → Vec String n → Vec String n
-rectangleʳ c = rectangle (Vec.replicate $ padRight c)
+rectangleʳ c = rectangle (Vec.replicate _ $ padRight c)
 
 rectangleᶜ : ∀ {n} → Char → Char → Vec String n → Vec String n
-rectangleᶜ cₗ cᵣ = rectangle (Vec.replicate $ padBoth cₗ cᵣ)
+rectangleᶜ cₗ cᵣ = rectangle (Vec.replicate _ $ padBoth cₗ cᵣ)
diff --git a/src/Data/String/Base.agda b/src/Data/String/Base.agda
index b3556026db..43ff59c732 100644
--- a/src/Data/String/Base.agda
+++ b/src/Data/String/Base.agda
@@ -8,22 +8,21 @@
 
 module Data.String.Base where
 
-open import Level using (zero)
-open import Data.Bool.Base using (Bool; true; false)
+open import Data.Bool.Base using (Bool; true; false; if_then_else_)
 open import Data.Char.Base as Char using (Char)
 open import Data.List.Base as List using (List; [_]; _∷_; [])
 open import Data.List.NonEmpty.Base as NE using (List⁺)
 open import Data.List.Relation.Binary.Pointwise.Base using (Pointwise)
 open import Data.List.Relation.Binary.Lex.Core using (Lex-<; Lex-≤)
 open import Data.Maybe.Base as Maybe using (Maybe)
-open import Data.Nat.Base using (ℕ; _∸_; ⌊_/2⌋; ⌈_/2⌉)
-open import Data.Product using (proj₁; proj₂)
+open import Data.Nat.Base using (ℕ; _∸_; ⌊_/2⌋; ⌈_/2⌉; _≡ᵇ_)
+open import Data.Product.Base using (proj₁; proj₂)
 open import Function.Base using (_on_; _∘′_; _∘_)
-open import Level using (Level)
+open import Level using (Level; 0ℓ)
 open import Relation.Binary.Core using (Rel)
 open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 open import Relation.Unary using (Pred; Decidable)
-open import Relation.Nullary.Decidable using (does)
+open import Relation.Nullary.Decidable.Core using (does; T?)
 
 ------------------------------------------------------------------------
 -- From Agda.Builtin: type and renamed primitives
@@ -47,17 +46,17 @@ open String public using ( String )
 -- Pointwise equality on Strings
 
 infix 4 _≈_
-_≈_ : Rel String zero
+_≈_ : Rel String 0ℓ
 _≈_ = Pointwise _≡_ on toList
 
 -- Lexicographic ordering on Strings
 
 infix 4 _<_
-_<_ : Rel String zero
+_<_ : Rel String 0ℓ
 _<_ = Lex-< _≡_ Char._<_ on toList
 
 infix 4 _≤_
-_≤_ : Rel String zero
+_≤_ : Rel String 0ℓ
 _≤_ = Lex-≤ _≡_ Char._<_ on toList
 
 ------------------------------------------------------------------------
@@ -103,11 +102,14 @@ unwords = intersperse " "
 unlines : List String → String
 unlines = intersperse "\n"
 
+between : String → String → String → String
+between left right middle = left ++ middle ++ right
+
 parens : String → String
-parens s = "(" ++ s ++ ")"
+parens = between "(" ")"
 
 braces : String → String
-braces s = "{" ++ s ++ "}"
+braces = between "{" "}"
 
 -- append that also introduces spaces, if necessary
 infixr 5 _<+>_
@@ -130,19 +132,19 @@ a <+> b = a ++ " " ++ b
 -- it is equal to 0.
 
 padLeft : Char → ℕ → String → String
-padLeft c n str with n ∸ length str
-... | 0 = str
-... | l = replicate l c ++ str
+padLeft c n str =
+  let l = n ∸ length str in
+  if l ≡ᵇ 0 then str else replicate l c ++ str
 
 padRight : Char → ℕ → String → String
-padRight c n str with n ∸ length str
-... | 0 = str
-... | l = str ++ replicate l c
+padRight c n str =
+  let l = n ∸ length str in
+  if l ≡ᵇ 0 then str else str ++ replicate l c
 
 padBoth : Char → Char → ℕ → String → String
-padBoth cₗ cᵣ n str with n ∸ length str
-... | 0 = str
-... | l = replicate ⌊ l /2⌋ cₗ ++ str ++ replicate ⌈ l /2⌉ cᵣ
+padBoth cₗ cᵣ n str =
+  let l = n ∸ length str in
+  if l ≡ᵇ 0 then str else replicate ⌊ l /2⌋ cₗ ++ str ++ replicate ⌈ l /2⌉ cᵣ
 
 ------------------------------------------------------------------------
 -- Alignment
@@ -161,11 +163,11 @@ fromAlignment Right  = padLeft ' '
 ------------------------------------------------------------------------
 -- Splitting strings
 
-wordsByᵇ : (Char → Bool) → String → List String
-wordsByᵇ p = List.map fromList ∘ List.wordsByᵇ p ∘ toList
-
 wordsBy : ∀ {p} {P : Pred Char p} → Decidable P → String → List String
-wordsBy P? = wordsByᵇ (does ∘ P?)
+wordsBy P? = List.map fromList ∘ List.wordsBy P? ∘ toList
+
+wordsByᵇ : (Char → Bool) → String → List String
+wordsByᵇ p = wordsBy (T? ∘ p)
 
 words : String → List String
 words = wordsByᵇ Char.isSpace
@@ -174,11 +176,11 @@ words = wordsByᵇ Char.isSpace
 _ : words " abc  b   " ≡ "abc" ∷ "b" ∷ []
 _ = refl
 
-linesByᵇ : (Char → Bool) → String → List String
-linesByᵇ p = List.map fromList ∘ List.linesByᵇ p ∘ toList
-
 linesBy : ∀ {p} {P : Pred Char p} → Decidable P → String → List String
-linesBy P? = linesByᵇ (does ∘ P?)
+linesBy P? = List.map fromList ∘ List.linesBy P? ∘ toList
+
+linesByᵇ : (Char → Bool) → String → List String
+linesByᵇ p = linesBy (T? ∘ p)
 
 lines : String → List String
 lines = linesByᵇ ('\n' Char.≈ᵇ_)
@@ -186,3 +188,9 @@ lines = linesByᵇ ('\n' Char.≈ᵇ_)
 -- `lines` preserves empty lines
 _ : lines "\nabc\n\nb\n\n\n" ≡ "" ∷ "abc" ∷ "" ∷ "b" ∷ "" ∷ "" ∷ []
 _ = refl
+
+map : (Char → Char) → String → String
+map f = fromList ∘ List.map f ∘ toList
+
+_ : map Char.toUpper "abc" ≡ "ABC"
+_ = refl
diff --git a/src/Data/String/Literals.agda b/src/Data/String/Literals.agda
index 9995ceb133..f376958da9 100644
--- a/src/Data/String/Literals.agda
+++ b/src/Data/String/Literals.agda
@@ -8,9 +8,9 @@
 
 module Data.String.Literals where
 
-open import Agda.Builtin.FromString
-open import Data.Unit
-open import Agda.Builtin.String
+open import Agda.Builtin.FromString using (IsString)
+open import Data.Unit.Base using (⊤)
+open import Agda.Builtin.String using (String)
 
 isString : IsString String
 isString = record
diff --git a/src/Data/String/Properties.agda b/src/Data/String/Properties.agda
index e0f47fa175..06406af94d 100644
--- a/src/Data/String/Properties.agda
+++ b/src/Data/String/Properties.agda
@@ -9,18 +9,24 @@
 module Data.String.Properties where
 
 open import Data.Bool.Base using (Bool)
-import Data.Char.Properties as Charₚ
-import Data.List.Properties as Listₚ
+import Data.Char.Properties as Char
+import Data.List.Properties as List
 import Data.List.Relation.Binary.Pointwise as Pointwise
 import Data.List.Relation.Binary.Lex.Strict as StrictLex
 open import Data.String.Base
 open import Function.Base
 open import Relation.Nullary.Decidable using (yes; no)
 open import Relation.Nullary.Decidable using (map′; isYes)
-open import Relation.Binary
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Bundles
+  using (Setoid; DecSetoid; StrictPartialOrder; StrictTotalOrder; DecTotalOrder; DecPoset)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence; IsStrictPartialOrder; IsStrictTotalOrder; IsDecPartialOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Substitutive; Decidable; DecidableEquality)
 open import Relation.Binary.PropositionalEquality.Core
 import Relation.Binary.Construct.On as On
-import Relation.Binary.PropositionalEquality as PropEq
+import Relation.Binary.PropositionalEquality.Properties as PropEq
 
 ------------------------------------------------------------------------
 -- Primitive properties
@@ -53,7 +59,7 @@ open import Agda.Builtin.String.Properties public
 
 infix 4 _≈?_
 _≈?_ : Decidable _≈_
-x ≈? y = Pointwise.decidable Charₚ._≟_ (toList x) (toList y)
+x ≈? y = Pointwise.decidable Char._≟_ (toList x) (toList y)
 
 ≈-isEquivalence : IsEquivalence _≈_
 ≈-isEquivalence = record
@@ -78,12 +84,12 @@ x ≈? y = Pointwise.decidable Charₚ._≟_ (toList x) (toList y)
   { isDecEquivalence = ≈-isDecEquivalence
   }
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _≡_
 
 infix 4 _≟_
 
-_≟_ : Decidable _≡_
+_≟_ : DecidableEquality String
 x ≟ y = map′ ≈⇒≡ ≈-reflexive $ x ≈? y
 
 ≡-setoid : Setoid _ _
@@ -97,54 +103,54 @@ x ≟ y = map′ ≈⇒≡ ≈-reflexive $ x ≈? y
 
 infix 4 _<?_
 _<?_ : Decidable _<_
-x <? y = StrictLex.<-decidable Charₚ._≟_ Charₚ._<?_ (toList x) (toList y)
+x <? y = StrictLex.<-decidable Char._≟_ Char._<?_ (toList x) (toList y)
 
 <-isStrictPartialOrder-≈ : IsStrictPartialOrder _≈_ _<_
 <-isStrictPartialOrder-≈ =
   On.isStrictPartialOrder
     toList
-    (StrictLex.<-isStrictPartialOrder Charₚ.<-isStrictPartialOrder)
+    (StrictLex.<-isStrictPartialOrder Char.<-isStrictPartialOrder)
 
 <-isStrictTotalOrder-≈ : IsStrictTotalOrder _≈_ _<_
 <-isStrictTotalOrder-≈ =
   On.isStrictTotalOrder
     toList
-    (StrictLex.<-isStrictTotalOrder Charₚ.<-isStrictTotalOrder)
+    (StrictLex.<-isStrictTotalOrder Char.<-isStrictTotalOrder)
 
 <-strictPartialOrder-≈ : StrictPartialOrder _ _ _
 <-strictPartialOrder-≈ =
   On.strictPartialOrder
-    (StrictLex.<-strictPartialOrder Charₚ.<-strictPartialOrder)
+    (StrictLex.<-strictPartialOrder Char.<-strictPartialOrder)
     toList
 
 <-strictTotalOrder-≈ : StrictTotalOrder _ _ _
 <-strictTotalOrder-≈ =
   On.strictTotalOrder
-    (StrictLex.<-strictTotalOrder Charₚ.<-strictTotalOrder)
+    (StrictLex.<-strictTotalOrder Char.<-strictTotalOrder)
     toList
 
 ≤-isDecPartialOrder-≈ : IsDecPartialOrder _≈_ _≤_
 ≤-isDecPartialOrder-≈ =
   On.isDecPartialOrder
     toList
-    (StrictLex.≤-isDecPartialOrder Charₚ.<-isStrictTotalOrder)
+    (StrictLex.≤-isDecPartialOrder Char.<-isStrictTotalOrder)
 
 ≤-isDecTotalOrder-≈ : IsDecTotalOrder _≈_ _≤_
 ≤-isDecTotalOrder-≈ =
   On.isDecTotalOrder
     toList
-    (StrictLex.≤-isDecTotalOrder Charₚ.<-isStrictTotalOrder)
+    (StrictLex.≤-isDecTotalOrder Char.<-isStrictTotalOrder)
 
 ≤-decTotalOrder-≈ :  DecTotalOrder _ _ _
 ≤-decTotalOrder-≈ =
   On.decTotalOrder
-    (StrictLex.≤-decTotalOrder Charₚ.<-strictTotalOrder)
+    (StrictLex.≤-decTotalOrder Char.<-strictTotalOrder)
     toList
 
 ≤-decPoset-≈ : DecPoset _ _ _
 ≤-decPoset-≈ =
   On.decPoset
-    (StrictLex.≤-decPoset Charₚ.<-strictTotalOrder)
+    (StrictLex.≤-decPoset Char.<-strictTotalOrder)
     toList
 
 ------------------------------------------------------------------------
diff --git a/src/Data/String/Unsafe.agda b/src/Data/String/Unsafe.agda
index 91a62a61d1..35b408f131 100644
--- a/src/Data/String/Unsafe.agda
+++ b/src/Data/String/Unsafe.agda
@@ -12,12 +12,15 @@ import Data.List.Base as List
 import Data.List.Properties as Listₚ
 open import Data.Maybe.Base using (maybe′)
 open import Data.Nat.Base using (zero; suc; _+_)
-open import Data.Product using (proj₂)
+open import Data.Product.Base using (proj₂)
 open import Data.String.Base
 open import Function.Base using (_∘′_)
 
-open import Relation.Binary.PropositionalEquality; open ≡-Reasoning
+open import Relation.Binary.PropositionalEquality.Core
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Relation.Binary.PropositionalEquality.TrustMe using (trustMe)
+open ≡-Reasoning
 
 ------------------------------------------------------------------------
 -- Properties of tail
diff --git a/src/Data/Sum.agda b/src/Data/Sum.agda
index 99cdbd3620..41e46fa8ae 100644
--- a/src/Data/Sum.agda
+++ b/src/Data/Sum.agda
@@ -8,15 +8,10 @@
 
 module Data.Sum where
 
-open import Agda.Builtin.Equality
-
-open import Data.Bool.Base using (true; false)
 open import Data.Unit.Polymorphic.Base using (⊤; tt)
 open import Data.Maybe.Base using (Maybe; just; nothing)
-open import Function.Base
 open import Level
-open import Relation.Nullary.Reflects using (invert)
-open import Relation.Nullary using (Dec; yes; no; _because_; ¬_)
+import Relation.Nullary.Decidable.Core as Dec
 
 private
   variable
@@ -31,7 +26,7 @@ open import Data.Sum.Base public
 ------------------------------------------------------------------------
 -- Additional functions
 
-module _ {a b} {A : Set a} {B : Set b} where
+module _ {A : Set a} {B : Set b} where
 
   isInj₁ : A ⊎ B → Maybe A
   isInj₁ (inj₁ x) = just x
@@ -57,12 +52,13 @@ module _ {a b} {A : Set a} {B : Set b} where
   from-inj₂ (inj₁ _) = _
   from-inj₂ (inj₂ x) = x
 
--- Conversion back and forth with Dec
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.1
 
-fromDec : Dec A → A ⊎ ¬ A
-fromDec ( true because  [p]) = inj₁ (invert  [p])
-fromDec (false because [¬p]) = inj₂ (invert [¬p])
+open Dec public using (fromDec; toDec)
 
-toDec : A ⊎ ¬ A → Dec A
-toDec (inj₁ p)  = yes p
-toDec (inj₂ ¬p) = no ¬p
diff --git a/src/Data/Sum/Algebra.agda b/src/Data/Sum/Algebra.agda
index 717bc347c1..ab51bece88 100644
--- a/src/Data/Sum/Algebra.agda
+++ b/src/Data/Sum/Algebra.agda
@@ -8,15 +8,19 @@
 
 module Data.Sum.Algebra where
 
-open import Algebra
+open import Algebra.Bundles
+  using (Magma; Semigroup; Monoid; CommutativeMonoid)
+open import Algebra.Definitions
+open import Algebra.Structures
+  using (IsMagma; IsSemigroup; IsMonoid; IsCommutativeMonoid)
 open import Data.Empty.Polymorphic using (⊥)
-open import Data.Product using (_,_)
-open import Data.Sum.Base
-open import Data.Sum.Properties
-open import Data.Unit.Polymorphic using (⊤; tt)
+open import Data.Product.Base using (_,_)
+open import Data.Sum.Base using (_⊎_; inj₁; inj₂; map; [_,_]; swap; assocʳ; assocˡ)
+open import Data.Sum.Properties using (swap-involutive)
+open import Data.Unit.Polymorphic.Base using (⊤; tt)
 open import Function.Base using (id; _∘_)
 open import Function.Properties.Inverse using (↔-isEquivalence)
-open import Function.Bundles using (_↔_; Inverse; mk↔′)
+open import Function.Bundles using (_↔_; Inverse; mk↔ₛ′)
 open import Level using (Level; suc)
 open import Relation.Binary.PropositionalEquality.Core
   using (_≡_; refl; cong; cong′)
@@ -29,14 +33,7 @@ import Function.Definitions as FuncDef
 private
   variable
     a b c d : Level
-    A : Set a
-    B : Set b
-    C : Set c
-    D : Set d
-
-  -- The module is needed because we need to pass `A` and `B` to `FuncDef`
-  module _ {A : Set a} {B : Set b} where
-    open FuncDef {A = A} {B} _≡_ _≡_
+    A B C D : Set a
 
   ♯ : {B : ⊥ {a} → Set b} → (w : ⊥) → B w
   ♯ ()
@@ -45,29 +42,29 @@ private
 -- Algebraic properties
 
 ⊎-cong : A ↔ B → C ↔ D → (A ⊎ C) ↔ (B ⊎ D)
-⊎-cong i j = mk↔′ (map I.to J.to) (map I.from J.from)
-  [ cong inj₁ ∘ I.inverseˡ , cong inj₂ ∘ J.inverseˡ ]
-  [ cong inj₁ ∘ I.inverseʳ , cong inj₂ ∘ J.inverseʳ ]
+⊎-cong i j = mk↔ₛ′ (map I.to J.to) (map I.from J.from)
+  [ cong inj₁ ∘ I.strictlyInverseˡ , cong inj₂ ∘ J.strictlyInverseˡ ]
+  [ cong inj₁ ∘ I.strictlyInverseʳ , cong inj₂ ∘ J.strictlyInverseʳ ]
   where module I = Inverse i; module J = Inverse j
 
 -- ⊎ is commutative.
 -- We don't use Commutative because it isn't polymorphic enough.
 ⊎-comm : (A : Set a) (B : Set b) → (A ⊎ B) ↔ (B ⊎ A)
-⊎-comm _ _ = mk↔′ swap swap swap-involutive swap-involutive
+⊎-comm _ _ = mk↔ₛ′ swap swap swap-involutive swap-involutive
 
 module _ (ℓ : Level) where
 
   -- ⊎ is associative
   ⊎-assoc : Associative {ℓ = ℓ} _↔_ _⊎_
-  ⊎-assoc _ _ _ = mk↔′ assocʳ assocˡ
+  ⊎-assoc _ _ _ = mk↔ₛ′ assocʳ assocˡ
     [ cong′ , [ cong′ , cong′ ] ] [ [ cong′ , cong′ ] , cong′ ]
 
   -- ⊥ is an identity for ⊎
   ⊎-identityˡ : LeftIdentity {ℓ = ℓ} _↔_ ⊥ _⊎_
-  ⊎-identityˡ A = mk↔′ [ ♯ , id ] inj₂ cong′ [ ♯ , cong′ ]
+  ⊎-identityˡ A = mk↔ₛ′ [ ♯ , id ] inj₂ cong′ [ ♯ , cong′ ]
 
   ⊎-identityʳ : RightIdentity {ℓ = ℓ} _↔_ ⊥ _⊎_
-  ⊎-identityʳ _ = mk↔′ [ id , ♯ ] inj₁ cong′ [ cong′ , ♯ ]
+  ⊎-identityʳ _ = mk↔ₛ′ [ id , ♯ ] inj₁ cong′ [ cong′ , ♯ ]
 
   ⊎-identity : Identity _↔_ ⊥ _⊎_
   ⊎-identity = ⊎-identityˡ , ⊎-identityʳ
diff --git a/src/Data/Sum/Categorical/Examples.agda b/src/Data/Sum/Categorical/Examples.agda
new file mode 100644
index 0000000000..5a74842598
--- /dev/null
+++ b/src/Data/Sum/Categorical/Examples.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Sum.Categorical.Examples` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Sum.Categorical.Examples where
+
+open import Data.Sum.Effectful.Examples public
+
+{-# WARNING_ON_IMPORT
+"Data.Sum.Categorical.Examples was deprecated in v2.0.
+Use Data.Sum.Effectful.Examples instead."
+#-}
diff --git a/src/Data/Sum/Categorical/Left.agda b/src/Data/Sum/Categorical/Left.agda
new file mode 100644
index 0000000000..b1a26c995d
--- /dev/null
+++ b/src/Data/Sum/Categorical/Left.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Sum.Categorical.Left` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Sum.Categorical.Left where
+
+open import Data.Sum.Effectful.Left public
+
+{-# WARNING_ON_IMPORT
+"Data.Sum.Categorical.Left was deprecated in v2.0.
+Use Data.Sum.Effectful.Left instead."
+#-}
diff --git a/src/Data/Sum/Categorical/Left/Transformer.agda b/src/Data/Sum/Categorical/Left/Transformer.agda
new file mode 100644
index 0000000000..de39522246
--- /dev/null
+++ b/src/Data/Sum/Categorical/Left/Transformer.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Sum.Categorical.Left.Transformer` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Sum.Categorical.Left.Transformer where
+
+open import Data.Sum.Effectful.Left.Transformer public
+
+{-# WARNING_ON_IMPORT
+"Data.Sum.Categorical.Left.Transformer was deprecated in v2.0.
+Use Data.Sum.Effectful.Left.Transformer instead."
+#-}
diff --git a/src/Data/Sum/Categorical/Right.agda b/src/Data/Sum/Categorical/Right.agda
new file mode 100644
index 0000000000..724d6a5b3a
--- /dev/null
+++ b/src/Data/Sum/Categorical/Right.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Sum.Categorical.Right` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Sum.Categorical.Right where
+
+open import Data.Sum.Effectful.Right public
+
+{-# WARNING_ON_IMPORT
+"Data.Sum.Categorical.Right was deprecated in v2.0.
+Use Data.Sum.Effectful.Right instead."
+#-}
diff --git a/src/Data/Sum/Categorical/Right/Transformer.agda b/src/Data/Sum/Categorical/Right/Transformer.agda
new file mode 100644
index 0000000000..52fbb16f11
--- /dev/null
+++ b/src/Data/Sum/Categorical/Right/Transformer.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Sum.Categorical.Right.Transformer` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Sum.Categorical.Right.Transformer where
+
+open import Data.Sum.Effectful.Right.Transformer public
+
+{-# WARNING_ON_IMPORT
+"Data.Sum.Categorical.Right.Transformer was deprecated in v2.0.
+Use Data.Sum.Effectful.Right.Transformer instead."
+#-}
diff --git a/src/Data/Sum/Effectful/Examples.agda b/src/Data/Sum/Effectful/Examples.agda
index f6850c7e19..c05f334421 100644
--- a/src/Data/Sum/Effectful/Examples.agda
+++ b/src/Data/Sum/Effectful/Examples.agda
@@ -21,13 +21,13 @@ private
   module Examplesₗ {a b} {A : Set a} {B : Set b} where
 
     open import Agda.Builtin.Equality
-    open import Function
+    open import Function.Base using (id)
     module Sₗ = Sumₗ A b
 
     open RawFunctor Sₗ.functor
 
-    -- This type to the right of ⊎ needs to be a "lifted" version of (B : Set b)
-    -- that lives in the universe (Set (a ⊔ b)).
+    -- This type to the right of ⊎ needs to be a "lifted" version of
+    -- (B : Set b) that lives in the universe (Set (a ⊔ b)).
     fmapId : (x : A ⊎ (Lift a B)) → (id <$> x) ≡ x
     fmapId (inj₁ x) = refl
     fmapId (inj₂ y) = refl
@@ -35,9 +35,9 @@ private
 
     open RawMonad   Sₗ.monad
 
-    -- Now, let's show that "pure" is a unit for >>=. We use Lift in exactly
-    -- the same way as above. The data (x : B) then needs to be "lifted" to
-    -- this new type (Lift B).
+    -- Now, let's show that "pure" is a unit for >>=. We use Lift in
+    -- exactly the same way as above. The data (x : B) then needs to be
+    -- "lifted" to this new type (Lift B).
     pureUnitL : ∀ {x : B} {f : Lift a B → A ⊎ (Lift a B)}
                   → (pure (lift x) >>= f) ≡ f (lift x)
     pureUnitL = refl
diff --git a/src/Data/Sum/Effectful/Left.agda b/src/Data/Sum/Effectful/Left.agda
index d86a7de26f..68c632afe4 100644
--- a/src/Data/Sum/Effectful/Left.agda
+++ b/src/Data/Sum/Effectful/Left.agda
@@ -18,9 +18,9 @@ open import Effect.Applicative
 open import Effect.Monad
 open import Function.Base
 
--- To minimize the universe level of the RawFunctor, we require that elements of
--- B are "lifted" to a copy of B at a higher universe level (a ⊔ b). See the
--- examples for how this is done.
+-- To minimize the universe level of the RawFunctor, we require that
+-- elements of B are "lifted" to a copy of B at a higher universe level
+-- (a ⊔ b). See the examples for how this is done.
 
 ------------------------------------------------------------------------
 -- Left-biased monad instance for _⊎_
@@ -62,6 +62,9 @@ monad = record
   ; _>>=_ = [ const ∘′ inj₁ , _|>′_ ]′
   }
 
+join : {B : Set (a ⊔ b)} → Sumₗ (Sumₗ B) → Sumₗ B
+join = Join.join monad
+
 ------------------------------------------------------------------------
 -- Get access to other monadic functions
 
diff --git a/src/Data/Sum/Effectful/Left/Transformer.agda b/src/Data/Sum/Effectful/Left/Transformer.agda
index cb45478f11..2d12a229fa 100644
--- a/src/Data/Sum/Effectful/Left/Transformer.agda
+++ b/src/Data/Sum/Effectful/Left/Transformer.agda
@@ -22,9 +22,9 @@ private
   variable
     M : Set (a ⊔ b) → Set (a ⊔ b)
 
--- To minimize the universe level of the RawFunctor, we require that elements of
--- B are "lifted" to a copy of B at a higher universe level (a ⊔ b). See the
--- examples for how this is done.
+-- To minimize the universe level of the RawFunctor, we require that
+-- elements of B are "lifted" to a copy of B at a higher universe level
+-- (a ⊔ b). See the examples for how this is done.
 
 open import Data.Sum.Effectful.Left A b using (Sumₗ)
 
diff --git a/src/Data/Sum/Effectful/Right.agda b/src/Data/Sum/Effectful/Right.agda
index 19b4995b1e..7658967128 100644
--- a/src/Data/Sum/Effectful/Right.agda
+++ b/src/Data/Sum/Effectful/Right.agda
@@ -56,6 +56,9 @@ monad = record
   ; _>>=_ = [ _|>′_ , const ∘′ inj₂ ]′
   }
 
+join : {A : Set (a ⊔ b)} → Sumᵣ (Sumᵣ A) → Sumᵣ A
+join = Join.join monad
+
 monadZero : B → RawMonadZero Sumᵣ
 monadZero b = record
   { rawMonad = monad
diff --git a/src/Data/Sum/Effectful/Right/Transformer.agda b/src/Data/Sum/Effectful/Right/Transformer.agda
index 8fffb29c80..576d6fb379 100644
--- a/src/Data/Sum/Effectful/Right/Transformer.agda
+++ b/src/Data/Sum/Effectful/Right/Transformer.agda
@@ -22,9 +22,9 @@ private
   variable
     M : Set (a ⊔ b) → Set (a ⊔ b)
 
--- To minimize the universe level of the RawFunctor, we require that elements of
--- B are "lifted" to a copy of B at a higher universe level (a ⊔ b). See the
--- examples for how this is done.
+-- To minimize the universe level of the RawFunctor, we require that
+-- elements of B are "lifted" to a copy of B at a higher universe level
+-- (a ⊔ b). See the examples for how this is done.
 
 open import Data.Sum.Effectful.Right a B using (Sumᵣ)
 
diff --git a/src/Data/Sum/Function/Propositional.agda b/src/Data/Sum/Function/Propositional.agda
index e754ee2356..e2b1b10000 100644
--- a/src/Data/Sum/Function/Propositional.agda
+++ b/src/Data/Sum/Function/Propositional.agda
@@ -8,65 +8,79 @@
 
 module Data.Sum.Function.Propositional where
 
-open import Data.Sum.Base
+open import Data.Sum.Base using (_⊎_)
 open import Data.Sum.Function.Setoid
-open import Data.Sum.Relation.Binary.Pointwise using (Pointwise-≡↔≡)
-open import Function.Equivalence as Eq using (_⇔_; module Equivalence)
-open import Function.Injection as Inj using (_↣_; module Injection)
-open import Function.Inverse as Inv using (_↔_; module Inverse)
-open import Function.LeftInverse as LeftInv
-  using (_↞_; _LeftInverseOf_; module LeftInverse)
-open import Function.Related
-open import Function.Surjection as Surj using (_↠_; module Surjection)
+open import Data.Sum.Relation.Binary.Pointwise using (Pointwise-≡↔≡; _⊎ₛ_)
+open import Function.Construct.Composition as Compose
+open import Function.Related.Propositional
+  using (_∼[_]_; implication; reverseImplication; equivalence; injection;
+    reverseInjection; leftInverse; surjection; bijection)
+open import Function.Base using (id)
+open import Function.Bundles
+  using (Inverse; _⟶_; _⇔_; _↣_; _↠_; _↩_; _↪_; _⤖_; _↔_)
+open import Function.Properties.Inverse as Inv
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
+
+private
+  variable
+    a b c d : Level
+    A B C D : Set a
+
+
+------------------------------------------------------------------------
+-- Helper lemma
+
+private
+  liftViaInverse : {R : ∀ {a b ℓ₁ ℓ₂} → REL (Setoid a ℓ₁) (Setoid b ℓ₂) (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)} →
+                   (∀ {a b c ℓ₁ ℓ₂ ℓ₃} {S : Setoid a ℓ₁} {T : Setoid b ℓ₂} {U : Setoid c ℓ₃} → R S T → R T U → R S U) →
+                   (∀ {a b ℓ₁ ℓ₂} {S : Setoid a ℓ₁} {T : Setoid b ℓ₂} → Inverse S T → R S T) →
+                   (R (setoid A) (setoid C) → R (setoid B) (setoid D) → R (setoid A ⊎ₛ setoid B) (setoid C ⊎ₛ setoid D)) →
+                   R (setoid A) (setoid C) → R (setoid B) (setoid D) →
+                   R (setoid (A ⊎ B)) (setoid (C ⊎ D))
+  liftViaInverse trans inv⇒R lift RAC RBD =
+    Inv.transportVia trans inv⇒R (Inv.sym (Pointwise-≡↔≡ _ _)) (lift RAC RBD) (Pointwise-≡↔≡ _ _)
 
 ------------------------------------------------------------------------
 -- Combinators for various function types
 
-module _ {a b c d} {A : Set a} {B : Set b} {C : Set c} {D : Set d} where
-
-  _⊎-⇔_ : A ⇔ B → C ⇔ D → (A ⊎ C) ⇔ (B ⊎ D)
-  _⊎-⇔_ A⇔B C⇔D =
-    Inverse.equivalence (Pointwise-≡↔≡ B D) ⟨∘⟩
-    (A⇔B ⊎-equivalence C⇔D) ⟨∘⟩
-    Eq.sym (Inverse.equivalence (Pointwise-≡↔≡ A C))
-    where open Eq using () renaming (_∘_ to _⟨∘⟩_)
-
-  _⊎-↣_ : A ↣ B → C ↣ D → (A ⊎ C) ↣ (B ⊎ D)
-  _⊎-↣_ A↣B C↣D =
-    Inverse.injection (Pointwise-≡↔≡ B D) ⟨∘⟩
-    (A↣B ⊎-injection C↣D) ⟨∘⟩
-    Inverse.injection (Inv.sym (Pointwise-≡↔≡ A C))
-    where open Inj using () renaming (_∘_ to _⟨∘⟩_)
-
-  _⊎-↞_ : A ↞ B → C ↞ D → (A ⊎ C) ↞ (B ⊎ D)
-  _⊎-↞_ A↞B C↞D =
-    Inverse.left-inverse (Pointwise-≡↔≡ B D) ⟨∘⟩
-    (A↞B ⊎-left-inverse C↞D) ⟨∘⟩
-    Inverse.left-inverse (Inv.sym (Pointwise-≡↔≡ A C))
-    where open LeftInv using () renaming (_∘_ to _⟨∘⟩_)
-
-  _⊎-↠_ : A ↠ B → C ↠ D → (A ⊎ C) ↠ (B ⊎ D)
-  _⊎-↠_ A↠B C↠D =
-    Inverse.surjection (Pointwise-≡↔≡ B D) ⟨∘⟩
-    (A↠B ⊎-surjection C↠D) ⟨∘⟩
-    Inverse.surjection (Inv.sym (Pointwise-≡↔≡ A C))
-    where open Surj using () renaming (_∘_ to _⟨∘⟩_)
-
-  _⊎-↔_ : A ↔ B → C ↔ D → (A ⊎ C) ↔ (B ⊎ D)
-  _⊎-↔_ A↔B C↔D =
-    Pointwise-≡↔≡ B D ⟨∘⟩
-    (A↔B ⊎-inverse C↔D) ⟨∘⟩
-    Inv.sym (Pointwise-≡↔≡ A C)
-    where open Inv using () renaming (_∘_ to _⟨∘⟩_)
-
-module _ {a b c d} {A : Set a} {B : Set b} {C : Set c} {D : Set d} where
-
-  _⊎-cong_ : ∀ {k} → A ∼[ k ] B → C ∼[ k ] D → (A ⊎ C) ∼[ k ] (B ⊎ D)
-  _⊎-cong_ {implication}         = map
-  _⊎-cong_ {reverse-implication} = λ f g → lam (map (app-← f) (app-← g))
-  _⊎-cong_ {equivalence}         = _⊎-⇔_
-  _⊎-cong_ {injection}           = _⊎-↣_
-  _⊎-cong_ {reverse-injection}   = λ f g → lam (app-↢ f ⊎-↣ app-↢ g)
-  _⊎-cong_ {left-inverse}        = _⊎-↞_
-  _⊎-cong_ {surjection}          = _⊎-↠_
-  _⊎-cong_ {bijection}           = _⊎-↔_
+infixr 1 _⊎-⟶_ _⊎-⇔_ _⊎-↣_ _⊎-↩_ _⊎-↪_ _⊎-↔_
+
+_⊎-⟶_ : A ⟶ B → C ⟶ D → (A ⊎ C) ⟶ (B ⊎ D)
+_⊎-⟶_ = liftViaInverse Compose.function Inv.toFunction _⊎-function_
+
+
+_⊎-⇔_ : A ⇔ B → C ⇔ D → (A ⊎ C) ⇔ (B ⊎ D)
+_⊎-⇔_ = liftViaInverse Compose.equivalence Inverse⇒Equivalence _⊎-equivalence_
+
+_⊎-↣_ : A ↣ B → C ↣ D → (A ⊎ C) ↣ (B ⊎ D)
+_⊎-↣_ = liftViaInverse Compose.injection Inverse⇒Injection _⊎-injection_
+
+_⊎-↠_ : A ↠ B → C ↠ D → (A ⊎ C) ↠ (B ⊎ D)
+_⊎-↠_ = liftViaInverse Compose.surjection Inverse⇒Surjection _⊎-surjection_
+
+_⊎-↩_ : A ↩ B → C ↩ D → (A ⊎ C) ↩ (B ⊎ D)
+_⊎-↩_ = liftViaInverse Compose.leftInverse Inverse.leftInverse _⊎-leftInverse_
+
+_⊎-↪_ : A ↪ B → C ↪ D → (A ⊎ C) ↪ (B ⊎ D)
+_⊎-↪_ = liftViaInverse Compose.rightInverse Inverse.rightInverse _⊎-rightInverse_
+
+_⊎-⤖_ : A ⤖ B → C ⤖ D → (A ⊎ C) ⤖ (B ⊎ D)
+_⊎-⤖_ = liftViaInverse Compose.bijection Inverse⇒Bijection _⊎-bijection_
+
+_⊎-↔_ : A ↔ B → C ↔ D → (A ⊎ C) ↔ (B ⊎ D)
+_⊎-↔_ = liftViaInverse Compose.inverse id _⊎-inverse_
+
+infixr 1 _⊎-cong_
+
+_⊎-cong_ : ∀ {k} → A ∼[ k ] B → C ∼[ k ] D → (A ⊎ C) ∼[ k ] (B ⊎ D)
+_⊎-cong_ {k = implication}         = _⊎-⟶_
+_⊎-cong_ {k = reverseImplication}  = _⊎-⟶_
+_⊎-cong_ {k = equivalence}         = _⊎-⇔_
+_⊎-cong_ {k = injection}           = _⊎-↣_
+_⊎-cong_ {k = reverseInjection}    = _⊎-↣_
+_⊎-cong_ {k = leftInverse}         = _⊎-↪_
+_⊎-cong_ {k = surjection}          = _⊎-↠_
+_⊎-cong_ {k = bijection}           = _⊎-↔_
diff --git a/src/Data/Sum/Function/Setoid.agda b/src/Data/Sum/Function/Setoid.agda
index e024dc0939..659bad1ef3 100644
--- a/src/Data/Sum/Function/Setoid.agda
+++ b/src/Data/Sum/Function/Setoid.agda
@@ -8,143 +8,167 @@
 
 module Data.Sum.Function.Setoid where
 
-open import Data.Sum.Base
-open import Data.Sum.Relation.Binary.Pointwise
+open import Data.Product.Base as Product using (_,_)
+open import Data.Sum.Base as Sum
+open import Data.Sum.Relation.Binary.Pointwise as Pointwise
 open import Relation.Binary
-open import Function.Equality as F using (_⟶_; _⟨$⟩_)
-open import Function.Equivalence as Eq
-  using (Equivalence; _⇔_; module Equivalence)
-open import Function.Injection as Inj
-  using (Injection; _↣_; module Injection)
-open import Function.Inverse as Inv
-  using (Inverse; _↔_; module Inverse)
-open import Function.LeftInverse as LeftInv
-  using (LeftInverse; _↞_; _LeftInverseOf_; module LeftInverse)
-open import Function.Related
-open import Function.Surjection as Surj
-  using (Surjection; _↠_; module Surjection)
+open import Function.Base
+open import Function.Bundles
+open import Function.Definitions
+open import Level
+
+private
+  variable
+    a₁ a₂ b₁ b₂ c₁ c₂ d₁ d₂ : Level
+    a ℓ : Level
+    A B C D : Set a
+    ≈₁ ≈₂ ≈₃ ≈₄ : Rel A ℓ
+    S T U V : Setoid a ℓ
 
 ------------------------------------------------------------------------
 -- Combinators for equality preserving functions
 
-module _  {a₁ a₂ b₁ b₂ c₁ c₂ d₁ d₂}
-          {A : Setoid a₁ a₂} {B : Setoid b₁ b₂}
-          {C : Setoid c₁ c₂} {D : Setoid d₁ d₂}
-          where
+inj₁ₛ : Func S (S ⊎ₛ T)
+inj₁ₛ = record { to = inj₁ ; cong = inj₁ }
 
-  _⊎-⟶_ : (A ⟶ B) → (C ⟶ D) → (A ⊎ₛ C) ⟶ (B ⊎ₛ D)
-  _⊎-⟶_ f g = record
-    { _⟨$⟩_ = fg
-    ; cong  = fg-cong
-    }
-    where
-    open Setoid (A ⊎ₛ C) using () renaming (_≈_ to _≈AC_)
-    open Setoid (B ⊎ₛ D) using () renaming (_≈_ to _≈BD_)
+inj₂ₛ : Func T (S ⊎ₛ T)
+inj₂ₛ = record { to = inj₂ ; cong = inj₂ }
 
-    fg = map (_⟨$⟩_ f) (_⟨$⟩_ g)
+[_,_]ₛ : Func S U → Func T U → Func (S ⊎ₛ T) U
+[ f , g ]ₛ = record
+  { to   = [ to f , to g ]
+  ; cong = λ where
+    (inj₁ x∼₁y) → cong f x∼₁y
+    (inj₂ x∼₂y) → cong g x∼₂y
+  } where open Func
 
-    fg-cong : _≈AC_ =[ fg ]⇒ _≈BD_
-    fg-cong (inj₁ x∼₁y) = inj₁ (F.cong f x∼₁y)
-    fg-cong (inj₂ x∼₂y) = inj₂ (F.cong g x∼₂y)
+swapₛ : Func (S ⊎ₛ T) (T ⊎ₛ S)
+swapₛ = [ inj₂ₛ , inj₁ₛ ]ₛ
 
-module _ {a₁ a₂ b₁ b₂} {A : Setoid a₁ a₂} {B : Setoid b₁ b₂} where
+------------------------------------------------------------------------
+-- Definitions
+
+⊎-injective : ∀ {f g} →
+              Injective ≈₁ ≈₂ f →
+              Injective ≈₃ ≈₄ g →
+              Injective (Pointwise ≈₁ ≈₃) (Pointwise ≈₂ ≈₄) (Sum.map f g)
+⊎-injective f-inj g-inj {inj₁ x} {inj₁ y} (inj₁ x∼₁y) = inj₁ (f-inj x∼₁y)
+⊎-injective f-inj g-inj {inj₂ x} {inj₂ y} (inj₂ x∼₂y) = inj₂ (g-inj x∼₂y)
+
+⊎-strictlySurjective : ∀ {f : A → B} {g : C → D} →
+              StrictlySurjective ≈₁ f →
+              StrictlySurjective ≈₂ g →
+              StrictlySurjective (Pointwise ≈₁ ≈₂) (Sum.map f g)
+⊎-strictlySurjective f-sur g-sur =
+  [ Product.map inj₁ inj₁ ∘ f-sur
+  , Product.map inj₂ inj₂ ∘ g-sur
+  ]
+
+⊎-surjective : ∀ {f : A → B} {g : C → D} →
+              Surjective ≈₁ ≈₂ f →
+              Surjective ≈₃ ≈₄ g →
+              Surjective (Pointwise ≈₁ ≈₃) (Pointwise ≈₂ ≈₄) (Sum.map f g)
+⊎-surjective f-sur g-sur =
+  [ Product.map inj₁ (λ { fwd (inj₁ x) → inj₁ (fwd x)}) ∘ f-sur
+  , Product.map inj₂ (λ { fwd (inj₂ y) → inj₂ (fwd y)}) ∘ g-sur
+  ]
+
+
+infixr 1 _⊎-equivalence_ _⊎-injection_ _⊎-left-inverse_
 
-  inj₁ₛ : A ⟶ (A ⊎ₛ B)
-  inj₁ₛ = record { _⟨$⟩_ = inj₁ ; cong = inj₁ }
+------------------------------------------------------------------------
+-- Function bundles
+
+_⊎-function_ : Func S T → Func U V → Func (S ⊎ₛ U) (T ⊎ₛ V)
+S→T ⊎-function U→V = record
+  { to    = Sum.map (to S→T) (to U→V)
+  ; cong  = Pointwise.map (cong S→T) (cong U→V)
+  } where open Func
+
+_⊎-equivalence_ : Equivalence S T → Equivalence U V →
+                  Equivalence (S ⊎ₛ U) (T ⊎ₛ V)
+S⇔T ⊎-equivalence U⇔V = record
+  { to        = Sum.map (to S⇔T) (to U⇔V)
+  ; from      = Sum.map (from S⇔T) (from U⇔V)
+  ; to-cong   = Pointwise.map (to-cong S⇔T) (to-cong U⇔V)
+  ; from-cong = Pointwise.map (from-cong S⇔T) (from-cong U⇔V)
+  } where open Equivalence
+
+_⊎-injection_ : Injection S T → Injection U V →
+                Injection (S ⊎ₛ U) (T ⊎ₛ V)
+S↣T ⊎-injection U↣V = record
+  { to        = Sum.map (to S↣T) (to U↣V)
+  ; cong      = Pointwise.map (cong S↣T) (cong U↣V)
+  ; injective = ⊎-injective (injective S↣T) (injective U↣V)
+  } where open Injection
+
+infixr 1 _⊎-surjection_ _⊎-inverse_
+_⊎-surjection_ : Surjection S T → Surjection U V →
+                 Surjection (S ⊎ₛ U) (T ⊎ₛ V)
+S↠T ⊎-surjection U↠V = record
+  { to              = Sum.map (to S↠T) (to U↠V)
+  ; cong            = Pointwise.map (cong S↠T) (cong U↠V)
+  ; surjective      = ⊎-surjective (surjective S↠T) (surjective U↠V)
+  } where open Surjection
+
+_⊎-bijection_ : Bijection S T → Bijection U V →
+                 Bijection (S ⊎ₛ U) (T ⊎ₛ V)
+S⤖T ⊎-bijection U⤖V = record
+  { to        = Sum.map (to S⤖T) (to U⤖V)
+  ; cong      = Pointwise.map (cong S⤖T) (cong U⤖V)
+  ; bijective = ⊎-injective (injective S⤖T) (injective U⤖V) ,
+                ⊎-surjective (surjective S⤖T) (surjective U⤖V)
+  } where open Bijection
+
+_⊎-leftInverse_ : LeftInverse S T → LeftInverse U V →
+                  LeftInverse (S ⊎ₛ U) (T ⊎ₛ V)
+S↩T ⊎-leftInverse U↩V = record
+  { to              = Sum.map (to S↩T) (to U↩V)
+  ; from            = Sum.map (from S↩T) (from U↩V)
+  ; to-cong         = Pointwise.map (to-cong S↩T) (to-cong U↩V)
+  ; from-cong       = Pointwise.map (from-cong S↩T) (from-cong U↩V)
+  ; inverseˡ        = λ { {inj₁ _} {.(inj₁ _)} (inj₁ x) → inj₁ (inverseˡ S↩T x)
+                        ; {inj₂ _} {.(inj₂ _)} (inj₂ x) → inj₂ (inverseˡ U↩V x)}
+  } where open LeftInverse
+
+_⊎-rightInverse_ : RightInverse S T → RightInverse U V →
+                   RightInverse (S ⊎ₛ U) (T ⊎ₛ V)
+S↪T ⊎-rightInverse U↪V = record
+  { to              = Sum.map (to S↪T) (to U↪V)
+  ; from            = Sum.map (from S↪T) (from U↪V)
+  ; to-cong         = Pointwise.map (to-cong S↪T) (to-cong U↪V)
+  ; from-cong       = Pointwise.map (from-cong S↪T) (from-cong U↪V)
+  ; inverseʳ        = λ { {inj₁ _} (inj₁ x) → inj₁ (inverseʳ S↪T x)
+                        ; {inj₂ _} (inj₂ x) → inj₂ (inverseʳ U↪V x)
+                        }
+  } where open RightInverse
+
+_⊎-inverse_ : Inverse S T → Inverse U V →
+              Inverse (S ⊎ₛ U) (T ⊎ₛ V)
+S↔T ⊎-inverse U↔V = record
+  { to        = Sum.map (to S↔T) (to U↔V)
+  ; from      = Sum.map (from S↔T) (from U↔V)
+  ; to-cong   = Pointwise.map (to-cong S↔T) (to-cong U↔V)
+  ; from-cong = Pointwise.map (from-cong S↔T) (from-cong U↔V)
+  ; inverse   = (λ { {inj₁ _} (inj₁ x) → inj₁ (inverseˡ S↔T x)
+                   ; {inj₂ _} (inj₂ x) → inj₂ (inverseˡ U↔V x)}) ,
+                 λ { {inj₁ _} (inj₁ x) → inj₁ (inverseʳ S↔T x)
+                   ; {inj₂ _} (inj₂ x) → inj₂ (inverseʳ U↔V x)
+                   }
+  } where open Inverse
 
-  inj₂ₛ : B ⟶ (A ⊎ₛ B)
-  inj₂ₛ = record { _⟨$⟩_ = inj₂ ; cong = inj₂ }
 
-  [_,_]ₛ : ∀ {c₁ c₂} {C : Setoid c₁ c₂} →
-           (A ⟶ C) → (B ⟶ C) → (A ⊎ₛ B) ⟶ C
-  [ f , g ]ₛ = record
-    { _⟨$⟩_ = [ f ⟨$⟩_ , g ⟨$⟩_ ]
-    ; cong = λ where
-      (inj₁ x∼₁y) → F.cong f x∼₁y
-      (inj₂ x∼₂y) → F.cong g x∼₂y
-    }
 
-module _ {a₁ a₂ b₁ b₂} {A : Setoid a₁ a₂} {B : Setoid b₁ b₂} where
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
 
-  swapₛ : (A ⊎ₛ B) ⟶ (B ⊎ₛ A)
-  swapₛ = [ inj₂ₛ , inj₁ₛ ]ₛ
+-- Version 2.0
 
-------------------------------------------------------------------------
--- Combinators for more complex function types
-
-module _  {a₁ a₂ b₁ b₂ c₁ c₂ d₁ d₂}
-          {A : Setoid a₁ a₂} {B : Setoid b₁ b₂}
-          {C : Setoid c₁ c₂} {D : Setoid d₁ d₂}
-          where
-
-  _⊎-equivalence_ : Equivalence A B → Equivalence C D →
-                    Equivalence (A ⊎ₛ C) (B ⊎ₛ D)
-  A⇔B ⊎-equivalence C⇔D = record
-    { to   = to   A⇔B ⊎-⟶ to   C⇔D
-    ; from = from A⇔B ⊎-⟶ from C⇔D
-    } where open Equivalence
-
-  _⊎-injection_ : Injection A B → Injection C D →
-                  Injection (A ⊎ₛ C) (B ⊎ₛ D)
-  _⊎-injection_ A↣B C↣D = record
-    { to        = to A↣B ⊎-⟶ to C↣D
-    ; injective = inj _ _
-    }
-    where
-    open Injection
-    open Setoid (A ⊎ₛ C) using () renaming (_≈_ to _≈AC_)
-    open Setoid (B ⊎ₛ D) using () renaming (_≈_ to _≈BD_)
-
-    inj : ∀ x y →
-          (to A↣B ⊎-⟶ to C↣D) ⟨$⟩ x ≈BD (to A↣B ⊎-⟶ to C↣D) ⟨$⟩ y →
-          x ≈AC y
-    inj (inj₁ x) (inj₁ y) (inj₁ x∼₁y) = inj₁ (injective A↣B x∼₁y)
-    inj (inj₂ x) (inj₂ y) (inj₂ x∼₂y) = inj₂ (injective C↣D x∼₂y)
-
-  _⊎-left-inverse_ : LeftInverse A B → LeftInverse C D →
-                     LeftInverse (A ⊎ₛ C) (B ⊎ₛ D)
-  A↞B ⊎-left-inverse C↞D = record
-    { to              = Equivalence.to   eq
-    ; from            = Equivalence.from eq
-    ; left-inverse-of = [ (λ x → inj₁ (left-inverse-of A↞B x))
-                        , (λ x → inj₂ (left-inverse-of C↞D x)) ]
-    }
-    where
-    open LeftInverse
-    eq = LeftInverse.equivalence A↞B ⊎-equivalence
-         LeftInverse.equivalence C↞D
-
-module _ {a₁ a₂ b₁ b₂ c₁ c₂ d₁ d₂}
-         {A : Setoid a₁ a₂} {B : Setoid b₁ b₂}
-         {C : Setoid c₁ c₂} {D : Setoid d₁ d₂}
-         where
-
-  _⊎-surjection_ : Surjection A B → Surjection C D →
-                   Surjection (A ⊎ₛ C) (B ⊎ₛ D)
-  A↠B ⊎-surjection C↠D = record
-    { to         = LeftInverse.from inv
-    ; surjective = record
-      { from             = LeftInverse.to inv
-      ; right-inverse-of = LeftInverse.left-inverse-of inv
-      }
-    }
-    where
-    open Surjection
-    inv = right-inverse A↠B ⊎-left-inverse right-inverse C↠D
-
-  _⊎-inverse_ : Inverse A B → Inverse C D →
-                Inverse (A ⊎ₛ C) (B ⊎ₛ D)
-  A↔B ⊎-inverse C↔D = record
-    { to         = Surjection.to   surj
-    ; from       = Surjection.from surj
-    ; inverse-of = record
-      { left-inverse-of  = LeftInverse.left-inverse-of inv
-      ; right-inverse-of = Surjection.right-inverse-of surj
-      }
-    }
-    where
-    open Inverse
-    surj = Inverse.surjection   A↔B ⊎-surjection
-           Inverse.surjection   C↔D
-    inv  = Inverse.left-inverse A↔B ⊎-left-inverse
-           Inverse.left-inverse C↔D
+_⊎-left-inverse_ = _⊎-leftInverse_
+{-# WARNING_ON_USAGE _⊎-left-inverse_
+"Warning: _⊎-left-inverse_ was deprecated in v2.0.
+Please use _⊎-leftInverse_ instead."
+#-}
diff --git a/src/Data/Sum/Properties.agda b/src/Data/Sum/Properties.agda
index 3fede95b06..a19a1daae6 100644
--- a/src/Data/Sum/Properties.agda
+++ b/src/Data/Sum/Properties.agda
@@ -8,15 +8,15 @@
 
 module Data.Sum.Properties where
 
-open import Level
-open import Data.Sum.Base
-open import Function
-open import Function.Bundles using (mk↔′)
-open import Relation.Binary using (Decidable)
-open import Relation.Binary.PropositionalEquality
-open import Relation.Nullary.Decidable using (yes; no)
-open import Relation.Nullary.Decidable using (map′)
-
+open import Level using (Level)
+open import Data.Sum.Base using (_⊎_; inj₁; inj₂; swap; [_,_]; map;
+  map₁; map₂; assocˡ; assocʳ)
+open import Function.Base using (_∋_; _∘_; id)
+open import Function.Bundles using (mk↔ₛ′; _↔_)
+open import Relation.Binary.Definitions using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≗_; refl; cong)
+open import Relation.Nullary.Decidable.Core using (yes; no; map′)
 
 private
   variable
@@ -34,10 +34,10 @@ inj₁-injective refl = refl
 inj₂-injective : ∀ {x y} → (A ⊎ B ∋ inj₂ x) ≡ inj₂ y → x ≡ y
 inj₂-injective refl = refl
 
-module _ (dec₁ : Decidable {A = A} {B = A} _≡_)
-         (dec₂ : Decidable {A = B} {B = B} _≡_) where
+module _ (dec₁ : DecidableEquality A)
+         (dec₂ : DecidableEquality B) where
 
-  ≡-dec : Decidable {A = A ⊎ B} _≡_
+  ≡-dec : DecidableEquality (A ⊎ B)
   ≡-dec (inj₁ x) (inj₁ y) = map′ (cong inj₁) inj₁-injective (dec₁ x y)
   ≡-dec (inj₁ x) (inj₂ y) = no λ()
   ≡-dec (inj₂ x) (inj₁ y) = no λ()
@@ -47,7 +47,7 @@ swap-involutive : swap {A = A} {B = B} ∘ swap ≗ id
 swap-involutive = [ (λ _ → refl) , (λ _ → refl) ]
 
 swap-↔ : (A ⊎ B) ↔ (B ⊎ A)
-swap-↔ = mk↔′ swap swap swap-involutive swap-involutive
+swap-↔ = mk↔ₛ′ swap swap swap-involutive swap-involutive
 
 map-id : map {A = A} {B = B} id id ≗ id
 map-id (inj₁ _) = refl
diff --git a/src/Data/Sum/Relation/Binary/LeftOrder.agda b/src/Data/Sum/Relation/Binary/LeftOrder.agda
index a5d0327af2..d29a6a96ed 100644
--- a/src/Data/Sum/Relation/Binary/LeftOrder.agda
+++ b/src/Data/Sum/Relation/Binary/LeftOrder.agda
@@ -11,17 +11,22 @@ module Data.Sum.Relation.Binary.LeftOrder where
 open import Data.Sum.Base as Sum
 open import Data.Sum.Relation.Binary.Pointwise as PW
   using (Pointwise; inj₁; inj₂)
-open import Data.Product
+open import Data.Product.Base using (_,_)
 open import Data.Empty
-open import Function
-open import Induction.WellFounded
+open import Function.Base using (_$_; _∘_)
 open import Level
 open import Relation.Nullary
 import Relation.Nullary.Decidable as Dec
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (Preorder; Poset; StrictPartialOrder; TotalOrder; DecTotalOrder; StrictTotalOrder)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsStrictPartialOrder; IsTotalOrder; IsDecTotalOrder; IsStrictTotalOrder)
+open import Relation.Binary.Definitions
+  using (Reflexive; Transitive; Asymmetric; Total; Decidable; Irreflexive; Antisymmetric; Trichotomous; _Respectsʳ_; _Respectsˡ_; _Respects₂_; tri<; tri>; tri≈)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Definition
 
 infixr 1 _⊎-<_
@@ -33,7 +38,7 @@ data _⊎-<_ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
   ₁∼₁ : ∀ {x y} (x∼₁y : x ∼₁ y) → (_∼₁_ ⊎-< _∼₂_) (inj₁ x) (inj₁ y)
   ₂∼₂ : ∀ {x y} (x∼₂y : x ∼₂ y) → (_∼₁_ ⊎-< _∼₂_) (inj₂ x) (inj₂ y)
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Some properties which are preserved by _⊎-<_
 
 module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
@@ -79,20 +84,6 @@ module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
   ⊎-<-decidable dec₁ dec₂ (inj₂ x) (inj₁ y) = no λ()
   ⊎-<-decidable dec₁ dec₂ (inj₂ x) (inj₂ y) = Dec.map′ ₂∼₂ drop-inj₂ (dec₂ x y)
 
-  ⊎-<-wellFounded : WellFounded ∼₁ → WellFounded ∼₂ → WellFounded (∼₁ ⊎-< ∼₂)
-  ⊎-<-wellFounded wf₁ wf₂ x = acc (⊎-<-acc x)
-    where
-    ⊎-<-acc₁ : ∀ {x} → Acc ∼₁ x → WfRec (∼₁ ⊎-< ∼₂) (Acc (∼₁ ⊎-< ∼₂)) (inj₁ x)
-    ⊎-<-acc₁ (acc rec) (inj₁ y) (₁∼₁ x∼₁y) = acc (⊎-<-acc₁ (rec y x∼₁y))
-
-    ⊎-<-acc₂ : ∀ {x} → Acc ∼₂ x → WfRec (∼₁ ⊎-< ∼₂) (Acc (∼₁ ⊎-< ∼₂)) (inj₂ x)
-    ⊎-<-acc₂ (acc rec) (inj₁ y) ₁∼₂ = acc (⊎-<-acc₁ (wf₁ y))
-    ⊎-<-acc₂ (acc rec) (inj₂ y) (₂∼₂ x∼₂y) = acc (⊎-<-acc₂ (rec y x∼₂y))
-
-    ⊎-<-acc  : ∀ x → WfRec (∼₁ ⊎-< ∼₂) (Acc (∼₁ ⊎-< ∼₂)) x
-    ⊎-<-acc (inj₁ x) = ⊎-<-acc₁ (wf₁ x)
-    ⊎-<-acc (inj₂ x) = ⊎-<-acc₂ (wf₂ x)
-
 module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
          {ℓ₁ ℓ₂} {∼₁ : Rel A₁ ℓ₁} {≈₁ : Rel A₁ ℓ₂}
          {ℓ₃ ℓ₄} {∼₂ : Rel A₂ ℓ₃} {≈₂ : Rel A₂ ℓ₄}
@@ -142,7 +133,7 @@ module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
   ... | tri≈ x≮y x≈y x≯y = tri≈ (x≮y ∘ drop-inj₂) (inj₂ x≈y) (x≯y ∘ drop-inj₂)
   ... | tri> x≮y x≉y x>y = tri> (x≮y ∘ drop-inj₂) (x≉y ∘ PW.drop-inj₂) (₂∼₂ x>y)
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Some collections of properties which are preserved
 
 module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
@@ -201,9 +192,8 @@ module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
                            IsStrictTotalOrder ≈₂ ∼₂ →
                            IsStrictTotalOrder (Pointwise ≈₁ ≈₂) (∼₁ ⊎-< ∼₂)
   ⊎-<-isStrictTotalOrder sto₁ sto₂ = record
-    { isEquivalence = PW.⊎-isEquivalence (isEquivalence sto₁) (isEquivalence sto₂)
-    ; trans         = ⊎-<-transitive (trans sto₁) (trans sto₂)
-    ; compare       = ⊎-<-trichotomous (compare sto₁) (compare sto₂)
+    { isStrictPartialOrder = ⊎-<-isStrictPartialOrder (isStrictPartialOrder sto₁) (isStrictPartialOrder sto₂)
+    ; compare              = ⊎-<-trichotomous (compare sto₁) (compare sto₂)
     }
     where open IsStrictTotalOrder
 
diff --git a/src/Data/Sum/Relation/Binary/Pointwise.agda b/src/Data/Sum/Relation/Binary/Pointwise.agda
index ac196828c6..6d6c84a253 100644
--- a/src/Data/Sum/Relation/Binary/Pointwise.agda
+++ b/src/Data/Sum/Relation/Binary/Pointwise.agda
@@ -8,238 +8,211 @@
 
 module Data.Sum.Relation.Binary.Pointwise where
 
-open import Data.Product using (_,_)
-open import Data.Sum.Base as Sum
+open import Data.Product.Base using (_,_)
+open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
 open import Data.Sum.Properties
-open import Induction.WellFounded
-open import Level using (_⊔_)
-open import Function.Base using (_∘_; id)
-open import Function.Inverse using (Inverse)
+open import Level using (Level; _⊔_)
+open import Function.Base using (const; _∘_; id)
+open import Function.Bundles using (Inverse; mk↔)
 open import Relation.Nullary
 import Relation.Nullary.Decidable as Dec
 open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
-----------------------------------------------------------------------
+private
+  variable
+    a b c d ℓ₁ ℓ₂ ℓ₃ ℓ : Level
+    A B C D : Set ℓ
+    R S T U : REL A B ℓ
+    ≈₁ ≈₂ : Rel A ℓ
+
+------------------------------------------------------------------------
 -- Definition
 
-data Pointwise {a b c d r s}
-               {A : Set a} {B : Set b} {C : Set c} {D : Set d}
-               (R : REL A C r) (S : REL B D s)
-               : REL (A ⊎ B) (C ⊎ D) (a ⊔ b ⊔ c ⊔ d ⊔ r ⊔ s) where
+data Pointwise {A : Set a} {B : Set b} {C : Set c} {D : Set d}
+               (R : REL A C ℓ₁) (S : REL B D ℓ₂)
+               : REL (A ⊎ B) (C ⊎ D) (a ⊔ b ⊔ c ⊔ d ⊔ ℓ₁ ⊔ ℓ₂) where
   inj₁ : ∀ {a c} → R a c → Pointwise R S (inj₁ a) (inj₁ c)
   inj₂ : ∀ {b d} → S b d → Pointwise R S (inj₂ b) (inj₂ d)
 
 ----------------------------------------------------------------------
+-- Functions
+
+map : ∀ {f : A → C} {g : B → D} →
+      R =[ f ]⇒ T → S =[ g ]⇒ U →
+      Pointwise R S =[ Sum.map f g ]⇒ Pointwise T U
+map R⇒T _ (inj₁ x) = inj₁ (R⇒T x)
+map _ S⇒U (inj₂ x) = inj₂ (S⇒U x)
+
+------------------------------------------------------------------------
 -- Relational properties
 
-module _ {a₁ a₂ ℓ₁ ℓ₂} {A₁ : Set a₁} {A₂ : Set a₂}
-         {∼₁ : Rel A₁ ℓ₁} {∼₂ : Rel A₂ ℓ₂}
-         where
-
-  drop-inj₁ : ∀ {x y} → Pointwise ∼₁ ∼₂ (inj₁ x) (inj₁ y) → ∼₁ x y
-  drop-inj₁ (inj₁ x) = x
-
-  drop-inj₂ : ∀ {x y} → Pointwise ∼₁ ∼₂ (inj₂ x) (inj₂ y) → ∼₂ x y
-  drop-inj₂ (inj₂ x) = x
-
-  ⊎-refl : Reflexive ∼₁ → Reflexive ∼₂ →
-           Reflexive (Pointwise ∼₁ ∼₂)
-  ⊎-refl refl₁ refl₂ {inj₁ x} = inj₁ refl₁
-  ⊎-refl refl₁ refl₂ {inj₂ y} = inj₂ refl₂
-
-  ⊎-symmetric : Symmetric ∼₁ → Symmetric ∼₂ →
-                Symmetric (Pointwise ∼₁ ∼₂)
-  ⊎-symmetric sym₁ sym₂ (inj₁ x) = inj₁ (sym₁ x)
-  ⊎-symmetric sym₁ sym₂ (inj₂ x) = inj₂ (sym₂ x)
-
-  ⊎-transitive : Transitive ∼₁ → Transitive ∼₂ →
-                 Transitive (Pointwise ∼₁ ∼₂)
-  ⊎-transitive trans₁ trans₂ (inj₁ x) (inj₁ y) = inj₁ (trans₁ x y)
-  ⊎-transitive trans₁ trans₂ (inj₂ x) (inj₂ y) = inj₂ (trans₂ x y)
-
-  ⊎-asymmetric : Asymmetric ∼₁ → Asymmetric ∼₂ →
-                 Asymmetric (Pointwise ∼₁ ∼₂)
-  ⊎-asymmetric asym₁ asym₂ (inj₁ x) = λ { (inj₁ y) → asym₁ x y }
-  ⊎-asymmetric asym₁ asym₂ (inj₂ x) = λ { (inj₂ y) → asym₂ x y }
-
-  ⊎-substitutive : ∀ {ℓ₃} → Substitutive ∼₁ ℓ₃ → Substitutive ∼₂ ℓ₃ →
-                   Substitutive (Pointwise ∼₁ ∼₂) ℓ₃
-  ⊎-substitutive subst₁ subst₂ P (inj₁ x) = subst₁ (P ∘ inj₁) x
-  ⊎-substitutive subst₁ subst₂ P (inj₂ x) = subst₂ (P ∘ inj₂) x
-
-  ⊎-decidable : Decidable ∼₁ → Decidable ∼₂ →
-                Decidable (Pointwise ∼₁ ∼₂)
-  ⊎-decidable _≟₁_ _≟₂_ (inj₁ x) (inj₁ y) = Dec.map′ inj₁ drop-inj₁ (x ≟₁ y)
-  ⊎-decidable _≟₁_ _≟₂_ (inj₁ x) (inj₂ y) = no λ()
-  ⊎-decidable _≟₁_ _≟₂_ (inj₂ x) (inj₁ y) = no λ()
-  ⊎-decidable _≟₁_ _≟₂_ (inj₂ x) (inj₂ y) = Dec.map′ inj₂ drop-inj₂ (x ≟₂ y)
-
-  ⊎-wellFounded : WellFounded ∼₁ → WellFounded ∼₂ → WellFounded (Pointwise ∼₁ ∼₂)
-  ⊎-wellFounded wf₁ wf₂ x = acc (⊎-acc x)
-    where
-    ⊎-acc₁ : ∀ {x} → Acc ∼₁ x → WfRec (Pointwise ∼₁ ∼₂) (Acc (Pointwise ∼₁ ∼₂)) (inj₁ x)
-    ⊎-acc₁ (acc rec) (inj₁ y) (inj₁ x∼₁y) = acc (⊎-acc₁ (rec y x∼₁y))
-
-    ⊎-acc₂ : ∀ {x} → Acc ∼₂ x → WfRec (Pointwise ∼₁ ∼₂) (Acc (Pointwise ∼₁ ∼₂)) (inj₂ x)
-    ⊎-acc₂ (acc rec) (inj₂ y) (inj₂ x∼₂y) = acc (⊎-acc₂ (rec y x∼₂y))
-    ⊎-acc  : ∀ x → WfRec (Pointwise ∼₁ ∼₂) (Acc (Pointwise ∼₁ ∼₂)) x
-
-    ⊎-acc (inj₁ x) = ⊎-acc₁ (wf₁ x)
-    ⊎-acc (inj₂ x) = ⊎-acc₂ (wf₂ x)
-
-module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
-         {ℓ₁ ℓ₂} {∼₁ : Rel A₁ ℓ₁} {≈₁ : Rel A₁ ℓ₂}
-         {ℓ₃ ℓ₄} {∼₂ : Rel A₂ ℓ₃} {≈₂ : Rel A₂ ℓ₄} where
-
-  ⊎-reflexive : ≈₁ ⇒ ∼₁ → ≈₂ ⇒ ∼₂ →
-                (Pointwise ≈₁ ≈₂) ⇒ (Pointwise ∼₁ ∼₂)
-  ⊎-reflexive refl₁ refl₂ (inj₁ x) = inj₁ (refl₁ x)
-  ⊎-reflexive refl₁ refl₂ (inj₂ x) = inj₂ (refl₂ x)
-
-  ⊎-irreflexive : Irreflexive ≈₁ ∼₁ → Irreflexive ≈₂ ∼₂ →
-                  Irreflexive (Pointwise ≈₁ ≈₂) (Pointwise ∼₁ ∼₂)
-  ⊎-irreflexive irrefl₁ irrefl₂ (inj₁ x) (inj₁ y) = irrefl₁ x y
-  ⊎-irreflexive irrefl₁ irrefl₂ (inj₂ x) (inj₂ y) = irrefl₂ x y
-
-  ⊎-antisymmetric : Antisymmetric ≈₁ ∼₁ → Antisymmetric ≈₂ ∼₂ →
-                    Antisymmetric (Pointwise ≈₁ ≈₂) (Pointwise ∼₁ ∼₂)
-  ⊎-antisymmetric antisym₁ antisym₂ (inj₁ x) (inj₁ y) = inj₁ (antisym₁ x y)
-  ⊎-antisymmetric antisym₁ antisym₂ (inj₂ x) (inj₂ y) = inj₂ (antisym₂ x y)
-
-  ⊎-respectsˡ : ∼₁ Respectsˡ ≈₁ → ∼₂ Respectsˡ ≈₂ →
-                (Pointwise ∼₁ ∼₂) Respectsˡ (Pointwise ≈₁ ≈₂)
-  ⊎-respectsˡ resp₁ resp₂ (inj₁ x) (inj₁ y) = inj₁ (resp₁ x y)
-  ⊎-respectsˡ resp₁ resp₂ (inj₂ x) (inj₂ y) = inj₂ (resp₂ x y)
-
-  ⊎-respectsʳ : ∼₁ Respectsʳ ≈₁ → ∼₂ Respectsʳ ≈₂ →
-                (Pointwise ∼₁ ∼₂) Respectsʳ (Pointwise ≈₁ ≈₂)
-  ⊎-respectsʳ resp₁ resp₂ (inj₁ x) (inj₁ y) = inj₁ (resp₁ x y)
-  ⊎-respectsʳ resp₁ resp₂ (inj₂ x) (inj₂ y) = inj₂ (resp₂ x y)
-
-  ⊎-respects₂ : ∼₁ Respects₂ ≈₁ → ∼₂ Respects₂ ≈₂ →
-                (Pointwise ∼₁ ∼₂) Respects₂ (Pointwise ≈₁ ≈₂)
-  ⊎-respects₂ (r₁ , l₁) (r₂ , l₂) = ⊎-respectsʳ r₁ r₂ , ⊎-respectsˡ l₁ l₂
+drop-inj₁ : ∀ {x y} → Pointwise R S (inj₁ x) (inj₁ y) → R x y
+drop-inj₁ (inj₁ x) = x
+
+drop-inj₂ : ∀ {x y} → Pointwise R S (inj₂ x) (inj₂ y) → S x y
+drop-inj₂ (inj₂ x) = x
+
+⊎-refl : Reflexive R → Reflexive S → Reflexive (Pointwise R S)
+⊎-refl refl₁ refl₂ {inj₁ x} = inj₁ refl₁
+⊎-refl refl₁ refl₂ {inj₂ y} = inj₂ refl₂
+
+⊎-symmetric : Symmetric R → Symmetric S →
+              Symmetric (Pointwise R S)
+⊎-symmetric sym₁ sym₂ (inj₁ x) = inj₁ (sym₁ x)
+⊎-symmetric sym₁ sym₂ (inj₂ x) = inj₂ (sym₂ x)
+
+⊎-transitive : Transitive R → Transitive S →
+               Transitive (Pointwise R S)
+⊎-transitive trans₁ trans₂ (inj₁ x) (inj₁ y) = inj₁ (trans₁ x y)
+⊎-transitive trans₁ trans₂ (inj₂ x) (inj₂ y) = inj₂ (trans₂ x y)
+
+⊎-asymmetric : Asymmetric R → Asymmetric S →
+               Asymmetric (Pointwise R S)
+⊎-asymmetric asym₁ asym₂ (inj₁ x) = λ { (inj₁ y) → asym₁ x y }
+⊎-asymmetric asym₁ asym₂ (inj₂ x) = λ { (inj₂ y) → asym₂ x y }
+
+⊎-substitutive : Substitutive R ℓ₃ → Substitutive S ℓ₃ →
+                 Substitutive (Pointwise R S) ℓ₃
+⊎-substitutive subst₁ subst₂ P (inj₁ x) = subst₁ (P ∘ inj₁) x
+⊎-substitutive subst₁ subst₂ P (inj₂ x) = subst₂ (P ∘ inj₂) x
+
+⊎-decidable : Decidable R → Decidable S → Decidable (Pointwise R S)
+⊎-decidable _≟₁_ _≟₂_ (inj₁ x) (inj₁ y) = Dec.map′ inj₁ drop-inj₁ (x ≟₁ y)
+⊎-decidable _≟₁_ _≟₂_ (inj₁ x) (inj₂ y) = no λ()
+⊎-decidable _≟₁_ _≟₂_ (inj₂ x) (inj₁ y) = no λ()
+⊎-decidable _≟₁_ _≟₂_ (inj₂ x) (inj₂ y) = Dec.map′ inj₂ drop-inj₂ (x ≟₂ y)
+
+⊎-reflexive : ≈₁ ⇒ R → ≈₂ ⇒ S →
+              (Pointwise ≈₁ ≈₂) ⇒ (Pointwise R S)
+⊎-reflexive refl₁ refl₂ (inj₁ x) = inj₁ (refl₁ x)
+⊎-reflexive refl₁ refl₂ (inj₂ x) = inj₂ (refl₂ x)
+
+⊎-irreflexive : Irreflexive ≈₁ R → Irreflexive ≈₂ S →
+                Irreflexive (Pointwise ≈₁ ≈₂) (Pointwise R S)
+⊎-irreflexive irrefl₁ irrefl₂ (inj₁ x) (inj₁ y) = irrefl₁ x y
+⊎-irreflexive irrefl₁ irrefl₂ (inj₂ x) (inj₂ y) = irrefl₂ x y
+
+⊎-antisymmetric : Antisymmetric ≈₁ R → Antisymmetric ≈₂ S →
+                  Antisymmetric (Pointwise ≈₁ ≈₂) (Pointwise R S)
+⊎-antisymmetric antisym₁ antisym₂ (inj₁ x) (inj₁ y) = inj₁ (antisym₁ x y)
+⊎-antisymmetric antisym₁ antisym₂ (inj₂ x) (inj₂ y) = inj₂ (antisym₂ x y)
+
+⊎-respectsˡ : R Respectsˡ ≈₁ → S Respectsˡ ≈₂ →
+              (Pointwise R S) Respectsˡ (Pointwise ≈₁ ≈₂)
+⊎-respectsˡ resp₁ resp₂ (inj₁ x) (inj₁ y) = inj₁ (resp₁ x y)
+⊎-respectsˡ resp₁ resp₂ (inj₂ x) (inj₂ y) = inj₂ (resp₂ x y)
+
+⊎-respectsʳ : R Respectsʳ ≈₁ → S Respectsʳ ≈₂ →
+              (Pointwise R S) Respectsʳ (Pointwise ≈₁ ≈₂)
+⊎-respectsʳ resp₁ resp₂ (inj₁ x) (inj₁ y) = inj₁ (resp₁ x y)
+⊎-respectsʳ resp₁ resp₂ (inj₂ x) (inj₂ y) = inj₂ (resp₂ x y)
+
+⊎-respects₂ : R Respects₂ ≈₁ → S Respects₂ ≈₂ →
+              (Pointwise R S) Respects₂ (Pointwise ≈₁ ≈₂)
+⊎-respects₂ (r₁ , l₁) (r₂ , l₂) = ⊎-respectsʳ r₁ r₂ , ⊎-respectsˡ l₁ l₂
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Structures
 
-module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
-         {ℓ₁ ℓ₂} {≈₁ : Rel A₁ ℓ₁} {≈₂ : Rel A₂ ℓ₂}
-         where
-
-  ⊎-isEquivalence : IsEquivalence ≈₁ → IsEquivalence ≈₂ →
-                    IsEquivalence (Pointwise ≈₁ ≈₂)
-  ⊎-isEquivalence eq₁ eq₂ = record
-    { refl  = ⊎-refl       (refl  eq₁) (refl  eq₂)
-    ; sym   = ⊎-symmetric  (sym   eq₁) (sym   eq₂)
-    ; trans = ⊎-transitive (trans eq₁) (trans eq₂)
-    }
-    where open IsEquivalence
-
-  ⊎-isDecEquivalence : IsDecEquivalence ≈₁ → IsDecEquivalence ≈₂ →
-                       IsDecEquivalence (Pointwise ≈₁ ≈₂)
-  ⊎-isDecEquivalence eq₁ eq₂ = record
-    { isEquivalence =
-        ⊎-isEquivalence (isEquivalence eq₁) (isEquivalence eq₂)
-    ; _≟_           = ⊎-decidable (_≟_ eq₁) (_≟_ eq₂)
-    }
-    where open IsDecEquivalence
-
-module _ {a₁ a₂} {A₁ : Set a₁} {A₂ : Set a₂}
-         {ℓ₁ ℓ₂} {≈₁ : Rel A₁ ℓ₁} {∼₁ : Rel A₁ ℓ₂}
-         {ℓ₃ ℓ₄} {≈₂ : Rel A₂ ℓ₃} {∼₂ : Rel A₂ ℓ₄} where
-
-  ⊎-isPreorder : IsPreorder ≈₁ ∼₁ → IsPreorder ≈₂ ∼₂ →
-                 IsPreorder (Pointwise ≈₁ ≈₂) (Pointwise ∼₁ ∼₂)
-  ⊎-isPreorder pre₁ pre₂ = record
-    { isEquivalence =
-        ⊎-isEquivalence (isEquivalence pre₁) (isEquivalence pre₂)
-    ; reflexive     = ⊎-reflexive (reflexive pre₁) (reflexive pre₂)
-    ; trans         = ⊎-transitive (trans pre₁) (trans pre₂)
-    }
-    where open IsPreorder
-
-  ⊎-isPartialOrder : IsPartialOrder ≈₁ ∼₁ →
-                     IsPartialOrder ≈₂ ∼₂ →
-                     IsPartialOrder
-                       (Pointwise ≈₁ ≈₂) (Pointwise ∼₁ ∼₂)
-  ⊎-isPartialOrder po₁ po₂ = record
-    { isPreorder = ⊎-isPreorder (isPreorder po₁) (isPreorder po₂)
-    ; antisym    = ⊎-antisymmetric (antisym po₁) (antisym    po₂)
-    }
-    where open IsPartialOrder
-
-  ⊎-isStrictPartialOrder : IsStrictPartialOrder ≈₁ ∼₁ →
-                           IsStrictPartialOrder ≈₂ ∼₂ →
-                           IsStrictPartialOrder
-                             (Pointwise ≈₁ ≈₂) (Pointwise ∼₁ ∼₂)
-  ⊎-isStrictPartialOrder spo₁ spo₂ = record
-    { isEquivalence =
-        ⊎-isEquivalence (isEquivalence spo₁) (isEquivalence spo₂)
-    ; irrefl        = ⊎-irreflexive (irrefl   spo₁) (irrefl   spo₂)
-    ; trans         = ⊎-transitive  (trans    spo₁) (trans    spo₂)
-    ; <-resp-≈      = ⊎-respects₂   (<-resp-≈ spo₁) (<-resp-≈ spo₂)
-    }
-    where open IsStrictPartialOrder
+⊎-isEquivalence : IsEquivalence ≈₁ → IsEquivalence ≈₂ →
+                  IsEquivalence (Pointwise ≈₁ ≈₂)
+⊎-isEquivalence eq₁ eq₂ = record
+  { refl  = ⊎-refl       (refl  eq₁) (refl  eq₂)
+  ; sym   = ⊎-symmetric  (sym   eq₁) (sym   eq₂)
+  ; trans = ⊎-transitive (trans eq₁) (trans eq₂)
+  } where open IsEquivalence
+
+⊎-isDecEquivalence : IsDecEquivalence ≈₁ → IsDecEquivalence ≈₂ →
+                     IsDecEquivalence (Pointwise ≈₁ ≈₂)
+⊎-isDecEquivalence eq₁ eq₂ = record
+  { isEquivalence =
+      ⊎-isEquivalence (isEquivalence eq₁) (isEquivalence eq₂)
+  ; _≟_           = ⊎-decidable (_≟_ eq₁) (_≟_ eq₂)
+  } where open IsDecEquivalence
+
+⊎-isPreorder : IsPreorder ≈₁ R → IsPreorder ≈₂ S →
+               IsPreorder (Pointwise ≈₁ ≈₂) (Pointwise R S)
+⊎-isPreorder pre₁ pre₂ = record
+  { isEquivalence =
+      ⊎-isEquivalence (isEquivalence pre₁) (isEquivalence pre₂)
+  ; reflexive     = ⊎-reflexive (reflexive pre₁) (reflexive pre₂)
+  ; trans         = ⊎-transitive (trans pre₁) (trans pre₂)
+  } where open IsPreorder
+
+⊎-isPartialOrder : IsPartialOrder ≈₁ R → IsPartialOrder ≈₂ S →
+                   IsPartialOrder
+                     (Pointwise ≈₁ ≈₂) (Pointwise R S)
+⊎-isPartialOrder po₁ po₂ = record
+  { isPreorder = ⊎-isPreorder (isPreorder po₁) (isPreorder po₂)
+  ; antisym    = ⊎-antisymmetric (antisym po₁) (antisym    po₂)
+  } where open IsPartialOrder
+
+⊎-isStrictPartialOrder : IsStrictPartialOrder ≈₁ R →
+                         IsStrictPartialOrder ≈₂ S →
+                         IsStrictPartialOrder
+                           (Pointwise ≈₁ ≈₂) (Pointwise R S)
+⊎-isStrictPartialOrder spo₁ spo₂ = record
+  { isEquivalence =
+      ⊎-isEquivalence (isEquivalence spo₁) (isEquivalence spo₂)
+  ; irrefl        = ⊎-irreflexive (irrefl   spo₁) (irrefl   spo₂)
+  ; trans         = ⊎-transitive  (trans    spo₁) (trans    spo₂)
+  ; <-resp-≈      = ⊎-respects₂   (<-resp-≈ spo₁) (<-resp-≈ spo₂)
+  } where open IsStrictPartialOrder
 
 ------------------------------------------------------------------------
 -- Bundles
 
-module _ {a b c d} where
-
-  ⊎-setoid : Setoid a b → Setoid c d → Setoid _ _
-  ⊎-setoid s₁ s₂ = record
-    { isEquivalence =
-        ⊎-isEquivalence (isEquivalence s₁) (isEquivalence s₂)
-    } where open Setoid
-
-  ⊎-decSetoid : DecSetoid a b → DecSetoid c d → DecSetoid _ _
-  ⊎-decSetoid ds₁ ds₂ = record
-    { isDecEquivalence =
-        ⊎-isDecEquivalence (isDecEquivalence ds₁) (isDecEquivalence ds₂)
-    } where open DecSetoid
-
-  -- Some additional notation for combining setoids
-  infix 4 _⊎ₛ_
-  _⊎ₛ_ : Setoid a b → Setoid c d → Setoid _ _
-  _⊎ₛ_ = ⊎-setoid
+⊎-setoid : Setoid a b → Setoid c d → Setoid _ _
+⊎-setoid s₁ s₂ = record
+  { isEquivalence =
+      ⊎-isEquivalence (isEquivalence s₁) (isEquivalence s₂)
+  } where open Setoid
+
+⊎-decSetoid : DecSetoid a b → DecSetoid c d → DecSetoid _ _
+⊎-decSetoid ds₁ ds₂ = record
+  { isDecEquivalence =
+      ⊎-isDecEquivalence (isDecEquivalence ds₁) (isDecEquivalence ds₂)
+  } where open DecSetoid
+
+⊎-preorder : Preorder a b ℓ₁ → Preorder c d ℓ₂ → Preorder _ _ _
+⊎-preorder p₁ p₂ = record
+  { isPreorder   =
+      ⊎-isPreorder (isPreorder p₁) (isPreorder p₂)
+  } where open Preorder
+
+⊎-poset : Poset a b c → Poset a b c → Poset _ _ _
+⊎-poset po₁ po₂ = record
+  { isPartialOrder =
+      ⊎-isPartialOrder (isPartialOrder po₁) (isPartialOrder po₂)
+  } where open Poset
 
-module _ {a b c d e f} where
-
-  ⊎-preorder : Preorder a b c → Preorder d e f → Preorder _ _ _
-  ⊎-preorder p₁ p₂ = record
-    { isPreorder   =
-        ⊎-isPreorder (isPreorder p₁) (isPreorder p₂)
-    } where open Preorder
+------------------------------------------------------------------------
+-- Additional notation
 
-  ⊎-poset : Poset a b c → Poset a b c → Poset _ _ _
-  ⊎-poset po₁ po₂ = record
-    { isPartialOrder =
-        ⊎-isPartialOrder (isPartialOrder po₁) (isPartialOrder po₂)
-    } where open Poset
+-- Infix combining setoids
+infix 4 _⊎ₛ_
+_⊎ₛ_ : Setoid a b → Setoid c d → Setoid _ _
+_⊎ₛ_ = ⊎-setoid
 
 ------------------------------------------------------------------------
 -- The propositional equality setoid over products can be
 -- decomposed using Pointwise
 
-module _ {a b} {A : Set a} {B : Set b} where
-
-  Pointwise-≡⇒≡ : (Pointwise _≡_ _≡_) ⇒ _≡_ {A = A ⊎ B}
-  Pointwise-≡⇒≡ (inj₁ x) = P.cong inj₁ x
-  Pointwise-≡⇒≡ (inj₂ x) = P.cong inj₂ x
+Pointwise-≡⇒≡ : (Pointwise _≡_ _≡_) ⇒ _≡_ {A = A ⊎ B}
+Pointwise-≡⇒≡ (inj₁ x) = ≡.cong inj₁ x
+Pointwise-≡⇒≡ (inj₂ x) = ≡.cong inj₂ x
 
-  ≡⇒Pointwise-≡ : _≡_ {A = A ⊎ B} ⇒ (Pointwise _≡_ _≡_)
-  ≡⇒Pointwise-≡ P.refl = ⊎-refl P.refl P.refl
+≡⇒Pointwise-≡ : _≡_ {A = A ⊎ B} ⇒ (Pointwise _≡_ _≡_)
+≡⇒Pointwise-≡ ≡.refl = ⊎-refl ≡.refl ≡.refl
 
-Pointwise-≡↔≡ : ∀ {a b} (A : Set a) (B : Set b) →
-                Inverse (P.setoid A ⊎ₛ P.setoid B)
-                        (P.setoid (A ⊎ B))
+Pointwise-≡↔≡ : (A : Set a) (B : Set b) →
+                 Inverse (≡.setoid A ⊎ₛ ≡.setoid B) (≡.setoid (A ⊎ B))
 Pointwise-≡↔≡ _ _ = record
-  { to         = record { _⟨$⟩_ = id; cong = Pointwise-≡⇒≡ }
-  ; from       = record { _⟨$⟩_ = id; cong = ≡⇒Pointwise-≡ }
-  ; inverse-of = record
-    { left-inverse-of  = λ _ → ⊎-refl P.refl P.refl
-    ; right-inverse-of = λ _ → P.refl
-    }
+  { to        = id
+  ; from      = id
+  ; to-cong   = Pointwise-≡⇒≡
+  ; from-cong = ≡⇒Pointwise-≡
+  ; inverse   = Pointwise-≡⇒≡ , ≡⇒Pointwise-≡
   }
diff --git a/src/Data/These.agda b/src/Data/These.agda
index c8d042c8e9..45024ec599 100644
--- a/src/Data/These.agda
+++ b/src/Data/These.agda
@@ -11,7 +11,7 @@ module Data.These where
 open import Level
 open import Data.Maybe.Base using (Maybe; just; nothing; maybe′)
 open import Data.Sum.Base using (_⊎_; [_,_]′)
-open import Function
+open import Function.Base using (const; _∘′_; id; constᵣ)
 
 
 ------------------------------------------------------------------------
diff --git a/src/Data/These/Categorical/Left.agda b/src/Data/These/Categorical/Left.agda
new file mode 100644
index 0000000000..73576b3bd0
--- /dev/null
+++ b/src/Data/These/Categorical/Left.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.These.Categorical.Left` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.These.Categorical.Left where
+
+open import Data.These.Effectful.Left public
+
+{-# WARNING_ON_IMPORT
+"Data.These.Categorical.Left was deprecated in v2.0.
+Use Data.These.Effectful.Left instead."
+#-}
diff --git a/src/Data/These/Categorical/Left/Base.agda b/src/Data/These/Categorical/Left/Base.agda
new file mode 100644
index 0000000000..7c7e3add7d
--- /dev/null
+++ b/src/Data/These/Categorical/Left/Base.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.These.Categorical.Left.Base` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.These.Categorical.Left.Base where
+
+open import Data.These.Effectful.Left.Base public
+
+{-# WARNING_ON_IMPORT
+"Data.These.Categorical.Left.Base was deprecated in v2.0.
+Use Data.These.Effectful.Left.Base instead."
+#-}
diff --git a/src/Data/These/Categorical/Right.agda b/src/Data/These/Categorical/Right.agda
new file mode 100644
index 0000000000..2e42e8d4a8
--- /dev/null
+++ b/src/Data/These/Categorical/Right.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.These.Categorical.Right` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.These.Categorical.Right where
+
+open import Data.These.Effectful.Right public
+
+{-# WARNING_ON_IMPORT
+"Data.These.Categorical.Right was deprecated in v2.0.
+Use Data.These.Effectful.Right instead."
+#-}
diff --git a/src/Data/These/Categorical/Right/Base.agda b/src/Data/These/Categorical/Right/Base.agda
new file mode 100644
index 0000000000..05acbcf139
--- /dev/null
+++ b/src/Data/These/Categorical/Right/Base.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.These.Categorical.Right.Base` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.These.Categorical.Right.Base where
+
+open import Data.These.Effectful.Right.Base public
+
+{-# WARNING_ON_IMPORT
+"Data.These.Categorical.Right.Base was deprecated in v2.0.
+Use Data.These.Effectful.Right.Base instead."
+#-}
diff --git a/src/Data/These/Effectful/Left/Base.agda b/src/Data/These/Effectful/Left/Base.agda
index 04f569abdf..8f8f3c48bc 100644
--- a/src/Data/These/Effectful/Left/Base.agda
+++ b/src/Data/These/Effectful/Left/Base.agda
@@ -21,7 +21,7 @@ open import Data.These.Base
 open import Effect.Functor
 open import Effect.Applicative
 open import Effect.Monad
-open import Function
+open import Function.Base using (_∘_; flip)
 
 Theseₗ : Set (a ⊔ b) → Set (a ⊔ b)
 Theseₗ B = These A B
diff --git a/src/Data/These/Effectful/Right/Base.agda b/src/Data/These/Effectful/Right/Base.agda
index 91da52ab02..721426ae68 100644
--- a/src/Data/These/Effectful/Right/Base.agda
+++ b/src/Data/These/Effectful/Right/Base.agda
@@ -21,7 +21,7 @@ open import Data.These.Base
 open import Effect.Functor
 open import Effect.Applicative
 open import Effect.Monad
-open import Function
+open import Function.Base using (flip; _∘_)
 
 Theseᵣ : Set (a ⊔ b) → Set (a ⊔ b)
 Theseᵣ A = These A B
diff --git a/src/Data/These/Properties.agda b/src/Data/These/Properties.agda
index 62257ed1ad..79d35e53a6 100644
--- a/src/Data/These/Properties.agda
+++ b/src/Data/These/Properties.agda
@@ -8,11 +8,12 @@
 
 module Data.These.Properties where
 
-open import Data.Product
-open import Data.These.Base
+open import Data.Product.Base using (_×_; _,_; <_,_>; uncurry)
+open import Data.These.Base using (These; this; that; these)
 open import Function.Base using (_∘_)
-open import Relation.Binary using (Decidable)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Definitions using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂)
 open import Relation.Nullary.Decidable using (yes; no; map′; _×-dec_)
 
 ------------------------------------------------------------------------
@@ -35,7 +36,7 @@ module _ {a b} {A : Set a} {B : Set b} where
   these-injective : ∀ {x y : A} {a b : B} → these x a ≡ these y b → x ≡ y × a ≡ b
   these-injective = < these-injectiveˡ , these-injectiveʳ >
 
-  ≡-dec : Decidable _≡_ → Decidable _≡_ → Decidable {A = These A B} _≡_
+  ≡-dec : DecidableEquality A → DecidableEquality B → DecidableEquality (These A B)
   ≡-dec dec₁ dec₂ (this x)    (this y) =
     map′ (cong this) this-injective (dec₁ x y)
   ≡-dec dec₁ dec₂ (this x)    (that y)    = no λ()
diff --git a/src/Data/Tree/AVL.agda b/src/Data/Tree/AVL.agda
index d897161019..63d6067a9d 100644
--- a/src/Data/Tree/AVL.agda
+++ b/src/Data/Tree/AVL.agda
@@ -13,7 +13,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
@@ -24,7 +24,7 @@ import Data.DifferenceList as DiffList
 open import Data.List.Base as List using (List; []; _∷_)
 open import Data.Maybe.Base using (Maybe; nothing; just; is-just)
 open import Data.Nat.Base using (ℕ; suc)
-open import Data.Product hiding (map)
+open import Data.Product.Base hiding (map)
 open import Function.Base as F
 open import Level using (Level; _⊔_)
 open import Relation.Unary using (IUniversal; _⇒_)
@@ -92,13 +92,13 @@ module _ {v} {V : Value v} where
 
   headTail : Tree V → Maybe (K& V × Tree V)
   headTail (tree (Indexed.leaf _)) = nothing
-  headTail (tree {h = suc _} t)    with Indexed.headTail t
-  ... | (k , _ , _ , t′) = just (k , tree (Indexed.castˡ ⊥⁺<[ _ ] t′))
+  headTail (tree {h = suc _} t) with (k , _ , _ , t′) ← Indexed.headTail t
+    = just (k , tree (Indexed.castˡ ⊥⁺<[ _ ] t′))
 
   initLast : Tree V → Maybe (Tree V × K& V)
   initLast (tree (Indexed.leaf _)) = nothing
-  initLast (tree {h = suc _} t)    with Indexed.initLast t
-  ... | (k , _ , _ , t′) = just (tree (Indexed.castʳ t′ [ _ ]<⊤⁺) , k)
+  initLast (tree {h = suc _} t) with (k , _ , _ , t′) ← Indexed.initLast t
+    = just (tree (Indexed.castʳ t′ [ _ ]<⊤⁺) , k)
 
   foldr : (∀ {k} → Val k → A → A) → A → Tree V → A
   foldr cons nil (tree t) = Indexed.foldr cons nil t
diff --git a/src/Data/Tree/AVL/Indexed.agda b/src/Data/Tree/AVL/Indexed.agda
index 8cd4fc49bd..94d1b0782b 100644
--- a/src/Data/Tree/AVL/Indexed.agda
+++ b/src/Data/Tree/AVL/Indexed.agda
@@ -6,21 +6,21 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Indexed
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂) where
 
 open import Level using (Level; _⊔_)
 open import Data.Nat.Base using (ℕ; zero; suc; _+_)
-open import Data.Product using (Σ; ∃; _×_; _,_; proj₁)
+open import Data.Product.Base using (Σ; ∃; _×_; _,_; proj₁)
 open import Data.Maybe.Base using (Maybe; just; nothing)
 open import Data.List.Base as List using (List)
 open import Data.DifferenceList using (DiffList; []; _∷_; _++_)
 open import Function.Base as F hiding (const)
 open import Relation.Unary
-open import Relation.Binary using (_Respects_; Tri; tri<; tri≈; tri>)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.Definitions using (_Respects_; Tri; tri<; tri≈; tri>)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 private
   variable
diff --git a/src/Data/Tree/AVL/Indexed/Relation/Unary/All.agda b/src/Data/Tree/AVL/Indexed/Relation/Unary/All.agda
index e37c7f9b34..545a925f00 100644
--- a/src/Data/Tree/AVL/Indexed/Relation/Unary/All.agda
+++ b/src/Data/Tree/AVL/Indexed/Relation/Unary/All.agda
@@ -6,21 +6,21 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Indexed.Relation.Unary.All
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
   where
 
 open import Data.Nat.Base using (ℕ)
-open import Data.Product using (_,_; _×_)
+open import Data.Product.Base using (_,_; _×_)
 open import Data.Product.Nary.NonDependent
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 open import Function.Base
 open import Function.Nary.NonDependent using (congₙ)
 open import Level using (Level; _⊔_)
 
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 open import Relation.Nullary.Decidable using (Dec; yes; map′; _×-dec_)
 open import Relation.Unary using (Pred; Decidable; Universal; Irrelevant; _⊆_; _∪_)
 
diff --git a/src/Data/Tree/AVL/Indexed/Relation/Unary/Any.agda b/src/Data/Tree/AVL/Indexed/Relation/Unary/Any.agda
index 2b0d6f98a7..f8c270f1a1 100644
--- a/src/Data/Tree/AVL/Indexed/Relation/Unary/Any.agda
+++ b/src/Data/Tree/AVL/Indexed/Relation/Unary/Any.agda
@@ -6,14 +6,14 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Indexed.Relation.Unary.Any
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
   where
 
 open import Data.Nat.Base using (ℕ)
-open import Data.Product using (_,_; ∃; -,_; proj₁; proj₂)
+open import Data.Product.Base using (_,_; ∃; -,_; proj₁; proj₂)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_]′)
 open import Function.Base using (_∘′_; _∘_)
 open import Level using (Level; _⊔_)
diff --git a/src/Data/Tree/AVL/Indexed/Relation/Unary/Any/Properties.agda b/src/Data/Tree/AVL/Indexed/Relation/Unary/Any/Properties.agda
index 8b5b195d42..49da62b10b 100644
--- a/src/Data/Tree/AVL/Indexed/Relation/Unary/Any/Properties.agda
+++ b/src/Data/Tree/AVL/Indexed/Relation/Unary/Any/Properties.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Indexed.Relation.Unary.Any.Properties
   {a ℓ₁ ℓ₂} (sto : StrictTotalOrder a ℓ₁ ℓ₂)
@@ -16,13 +16,13 @@ open import Data.Maybe.Base as Maybe using (Maybe; nothing; just; maybe′)
 open import Data.Maybe.Properties using (just-injective)
 open import Data.Maybe.Relation.Unary.All as Maybe using (nothing; just)
 open import Data.Nat.Base using (ℕ)
-open import Data.Product as Prod using (∃; ∃-syntax; _×_; _,_; proj₁; proj₂)
-open import Data.Sum as Sum using (_⊎_; inj₁; inj₂)
+open import Data.Product.Base as Prod using (∃; ∃-syntax; _×_; _,_; proj₁; proj₂)
+open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
 open import Function.Base as F
 open import Level using (Level)
 
-open import Relation.Binary using (_Respects_; tri<; tri≈; tri>)
-open import Relation.Binary.PropositionalEquality using (_≡_) renaming (refl to ≡-refl)
+open import Relation.Binary.Definitions using (_Respects_; tri<; tri≈; tri>)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_) renaming (refl to ≡-refl)
 open import Relation.Nullary using (¬_; Dec; yes; no)
 open import Relation.Nullary.Negation using (contradiction)
 open import Relation.Unary using (Pred; _∩_)
@@ -35,7 +35,6 @@ open import Relation.Binary.Construct.Add.Extrema.Strict _<_ using ([<]-injectiv
 
 import Relation.Binary.Reasoning.StrictPartialOrder as <-Reasoning
 
-
 private
   variable
     v p q : Level
@@ -244,7 +243,7 @@ module _ {V : Value v} where
                Any P (singleton k v l<k<u) → P (k , v)
   singleton⁻ k v l<k<u (here Pkv) = Pkv
 
-  ------------------------------------------------------------------------
+  ----------------------------------------------------------------------
   -- insert
 
   module _ (k : Key) (f : Maybe (Val k) → Val k) where
@@ -278,33 +277,33 @@ module _ {V : Value v} where
                                      joinʳ⁺-right⁺ kv lk ku′ bal (Any-insertWith-just ku seg′ pr rp)
 
     -- impossible cases
-    ... | here eq  | tri< k<k′ _ _ = flip contradiction (irrefl⁺ [ k ]) $ begin-strict
+    ... | here eq  | tri< k<k′ _ _ = begin-contradiction
       [ k  ] <⟨ [ k<k′ ]ᴿ ⟩
       [ k′ ] ≈⟨ [ sym eq ]ᴱ ⟩
       [ k  ] ∎
-    ... | here eq  | tri> _ _ k>k′ = flip contradiction (irrefl⁺ [ k ]) $ begin-strict
+    ... | here eq  | tri> _ _ k>k′ = begin-contradiction
       [ k  ] ≈⟨ [ eq ]ᴱ ⟩
       [ k′ ] <⟨ [ k>k′ ]ᴿ ⟩
       [ k  ] ∎
-    ... | left lp  | tri≈ _ k≈k′ _ = flip contradiction (irrefl⁺ [ k ]) $ begin-strict
+    ... | left lp  | tri≈ _ k≈k′ _ = begin-contradiction
       let k″ = Any.lookup lp .key; k≈k″ = lookup-result lp; (_ , k″<k′) = lookup-bounded lp in
       [ k  ] ≈⟨ [ k≈k″ ]ᴱ ⟩
       [ k″ ] <⟨ k″<k′ ⟩
       [ k′ ] ≈⟨ [ sym k≈k′ ]ᴱ ⟩
       [ k  ] ∎
-    ... | left lp  | tri> _ _ k>k′ = flip contradiction (irrefl⁺ [ k ]) $ begin-strict
+    ... | left lp  | tri> _ _ k>k′ = begin-contradiction
       let k″ = Any.lookup lp .key; k≈k″ = lookup-result lp; (_ , k″<k′) = lookup-bounded lp in
       [ k  ] ≈⟨ [ k≈k″ ]ᴱ ⟩
       [ k″ ] <⟨ k″<k′ ⟩
       [ k′ ] <⟨ [ k>k′ ]ᴿ ⟩
       [ k  ] ∎
-    ... | right rp | tri< k<k′ _ _ = flip contradiction (irrefl⁺ [ k ]) $ begin-strict
+    ... | right rp | tri< k<k′ _ _ = begin-contradiction
       let k″ = Any.lookup rp .key; k≈k″ = lookup-result rp; (k′<k″ , _) = lookup-bounded rp in
       [ k  ] <⟨ [ k<k′ ]ᴿ ⟩
       [ k′ ] <⟨ k′<k″ ⟩
       [ k″ ] ≈⟨ [ sym k≈k″ ]ᴱ ⟩
       [ k  ] ∎
-    ... | right rp | tri≈ _ k≈k′ _ = flip contradiction (irrefl⁺ [ k ]) $ begin-strict
+    ... | right rp | tri≈ _ k≈k′ _ = begin-contradiction
       let k″ = Any.lookup rp .key; k≈k″ = lookup-result rp; (k′<k″ , _) = lookup-bounded rp in
       [ k  ] ≈⟨ [ k≈k′ ]ᴱ ⟩
       [ k′ ] <⟨ k′<k″ ⟩
diff --git a/src/Data/Tree/AVL/Indexed/WithK.agda b/src/Data/Tree/AVL/Indexed/WithK.agda
index 2ef4ec3544..607d63a5a8 100644
--- a/src/Data/Tree/AVL/Indexed/WithK.agda
+++ b/src/Data/Tree/AVL/Indexed/WithK.agda
@@ -6,16 +6,18 @@
 
 {-# OPTIONS --with-K --safe #-}
 
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; subst)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsStrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; subst)
 
 module Data.Tree.AVL.Indexed.WithK
        {k r} (Key : Set k) {_<_ : Rel Key r}
        (isStrictTotalOrder : IsStrictTotalOrder _≡_ _<_) where
 
+strictTotalOrder : StrictTotalOrder _ _ _
 strictTotalOrder = record { isStrictTotalOrder = isStrictTotalOrder }
 
-open import Data.Product
 open import Data.Tree.AVL.Indexed strictTotalOrder as AVL hiding (Value)
 
 module _ {v} {V′ : Key → Set v} where
diff --git a/src/Data/Tree/AVL/IndexedMap.agda b/src/Data/Tree/AVL/IndexedMap.agda
index 21413e0478..54e4d73bbb 100644
--- a/src/Data/Tree/AVL/IndexedMap.agda
+++ b/src/Data/Tree/AVL/IndexedMap.agda
@@ -6,9 +6,11 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Product as Prod
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality using (_≡_; cong; subst)
+open import Data.Product.Base
+  using (map₁; map₂; ∃; _×_; Σ-syntax; proj₁; _,_; -,_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsStrictTotalOrder)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong; subst)
 import Data.Tree.AVL.Value
 
 module Data.Tree.AVL.IndexedMap
@@ -76,10 +78,10 @@ member : ∀ {i} → Key i → Map → Bool
 member k = AVL.member (-, k)
 
 headTail : Map → Maybe (KV × Map)
-headTail m = Maybe.map (Prod.map₁ (toKV ∘′ AVL.toPair)) (AVL.headTail m)
+headTail m = Maybe.map (map₁ (toKV ∘′ AVL.toPair)) (AVL.headTail m)
 
 initLast : Map → Maybe (Map × KV)
-initLast m = Maybe.map (Prod.map₂ (toKV ∘′ AVL.toPair)) (AVL.initLast m)
+initLast m = Maybe.map (map₂ (toKV ∘′ AVL.toPair)) (AVL.initLast m)
 
 foldr : (∀ {k} → Value k → A → A) → A → Map → A
 foldr cons = AVL.foldr cons
diff --git a/src/Data/Tree/AVL/Key.agda b/src/Data/Tree/AVL/Key.agda
index dc7e77824d..1c32ef88d7 100644
--- a/src/Data/Tree/AVL/Key.agda
+++ b/src/Data/Tree/AVL/Key.agda
@@ -3,22 +3,22 @@
 --
 -- Keys for AVL trees -- the original key type extended with a new
 -- minimum and maximum.
------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles
+  using (StrictTotalOrder; StrictPartialOrder)
 
 module Data.Tree.AVL.Key
   {a ℓ₁ ℓ₂} (sto : StrictTotalOrder a ℓ₁ ℓ₂)
   where
 
-open import Level
-open import Data.Empty
-open import Data.Unit
-open import Data.Product
-open import Relation.Binary.PropositionalEquality using (_≡_ ; refl)
-open import Relation.Nullary.Negation using (¬_)
+open import Level using (Level; _⊔_)
+open import Data.Product.Base using (_×_; _,_)
+open import Relation.Binary.Definitions using (Reflexive)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_ ; refl)
+open import Relation.Nullary.Negation.Core using (¬_)
 open import Relation.Nullary.Construct.Add.Extrema
   as AddExtremaToSet using (_±)
 import Relation.Binary.Construct.Add.Extrema.Equality
@@ -29,7 +29,7 @@ import Relation.Binary.Construct.Add.Extrema.Strict
 open StrictTotalOrder sto renaming (Carrier to Key)
   using (_≈_; _<_; trans; irrefl; module Eq)
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Keys are augmented with new extrema (i.e. an artificial minimum and
 -- maximum)
 
@@ -43,7 +43,7 @@ open AddExtremaToSet public
   ; ⊤± to ⊤⁺
   )
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The equality is extended in a corresponding manner
 
 open AddExtremaToEquality _≈_ public
@@ -53,7 +53,7 @@ open AddExtremaToEquality _≈_ public
   ; [_]  to [_]ᴱ
   )
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The order is extended in a corresponding manner
 
 open AddExtremaToOrder _<_ public
diff --git a/src/Data/Tree/AVL/Map.agda b/src/Data/Tree/AVL/Map.agda
index 65731a8f29..254c965241 100644
--- a/src/Data/Tree/AVL/Map.agda
+++ b/src/Data/Tree/AVL/Map.agda
@@ -8,7 +8,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Map
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
@@ -18,7 +18,7 @@ open import Data.Bool.Base using (Bool)
 open import Data.List.Base as List using (List)
 open import Data.Maybe.Base as Maybe using (Maybe)
 open import Data.Nat.Base using (ℕ)
-open import Data.Product as Prod using (_×_)
+open import Data.Product.Base as Prod using (_×_)
 open import Function.Base using (_∘′_)
 open import Level using (Level; _⊔_)
 
diff --git a/src/Data/Tree/AVL/Map/Membership/Propositional.agda b/src/Data/Tree/AVL/Map/Membership/Propositional.agda
index a353ddf4ad..7f5151600f 100644
--- a/src/Data/Tree/AVL/Map/Membership/Propositional.agda
+++ b/src/Data/Tree/AVL/Map/Membership/Propositional.agda
@@ -7,7 +7,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Map.Membership.Propositional
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
@@ -15,16 +15,16 @@ module Data.Tree.AVL.Map.Membership.Propositional
 
 open import Data.Bool.Base using (true; false)
 open import Data.Maybe.Base using (just; nothing; is-just)
-open import Data.Product as Prod using (_×_; ∃-syntax; _,_; proj₁; proj₂)
+open import Data.Product.Base using (_×_; ∃-syntax; _,_; proj₁; proj₂)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent renaming (Pointwise to _×ᴿ_)
-open import Data.Sum using (_⊎_; inj₁; inj₂)
+open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 open import Function.Base using (_∘_; _∘′_)
 open import Level using (Level)
 
-open import Relation.Binary using (Transitive; Symmetric; _Respectsˡ_)
+open import Relation.Binary.Definitions using (Transitive; Symmetric; _Respectsˡ_)
 open import Relation.Binary.Core using (Rel)
 open import Relation.Binary.Construct.Intersection using (_∩_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
   using (_≡_; cong) renaming (refl to ≡-refl; sym to ≡-sym; trans to ≡-trans)
 open import Relation.Nullary using (Reflects; ¬_; yes; no)
 open import Relation.Nullary.Negation using (contradiction)
@@ -49,6 +49,8 @@ private
     x x′ y y′ : V
     kx : Key × V
 
+infix 4 _≈ₖᵥ_
+
 _≈ₖᵥ_ : Rel (Key × V) _
 _≈ₖᵥ_ = _≈_ ×ᴿ _≡_
 
diff --git a/src/Data/Tree/AVL/Map/Membership/Propositional/Properties.agda b/src/Data/Tree/AVL/Map/Membership/Propositional/Properties.agda
index 91df2a1c0c..fefb27764f 100644
--- a/src/Data/Tree/AVL/Map/Membership/Propositional/Properties.agda
+++ b/src/Data/Tree/AVL/Map/Membership/Propositional/Properties.agda
@@ -1,13 +1,13 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Properties of the membership relation for AVL Maps identifying values up to
--- propositional equality.
+-- Properties of the membership relation for AVL Maps identifying values
+-- up to propositional equality.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Map.Membership.Propositional.Properties
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
@@ -15,16 +15,16 @@ module Data.Tree.AVL.Map.Membership.Propositional.Properties
 
 open import Data.Bool.Base using (true; false)
 open import Data.Maybe.Base using (just; nothing; is-just)
-open import Data.Product as Prod using (_×_; ∃-syntax; _,_; proj₁; proj₂)
+open import Data.Product.Base as Product using (_×_; ∃-syntax; _,_; proj₁; proj₂)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent renaming (Pointwise to _×ᴿ_)
-open import Data.Sum using (_⊎_; inj₁; inj₂)
+open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 open import Function.Base using (_∘_; _∘′_)
 open import Level using (Level)
 
-open import Relation.Binary using (Transitive; Symmetric; _Respectsˡ_)
+open import Relation.Binary.Definitions using (Transitive; Symmetric; _Respectsˡ_)
 open import Relation.Binary.Core using (Rel)
 open import Relation.Binary.Construct.Intersection using (_∩_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
   using (_≡_; cong) renaming (refl to ≡-refl; sym to ≡-sym; trans to ≡-trans)
 open import Relation.Nullary using (Reflects; ¬_; yes; no)
 open import Relation.Nullary.Negation using (contradiction)
@@ -37,7 +37,7 @@ import Data.Tree.AVL.Indexed.Relation.Unary.Any strictTotalOrder as IAny
 import Data.Tree.AVL.Indexed.Relation.Unary.Any.Properties strictTotalOrder as IAnyₚ
 open import Data.Tree.AVL.Key strictTotalOrder using (⊥⁺<[_]<⊤⁺)
 open import Data.Tree.AVL.Map strictTotalOrder
-open import Data.Tree.AVL.Map.Relation.Unary.Any strictTotalOrder as Mapₚ using (Any)
+open import Data.Tree.AVL.Map.Relation.Unary.Any strictTotalOrder as Map using (Any)
 open import Data.Tree.AVL.Map.Membership.Propositional strictTotalOrder
 open import Data.Tree.AVL.Relation.Unary.Any strictTotalOrder as Any using (tree)
 
@@ -113,7 +113,7 @@ private
 
 ∈ₖᵥ-lookup⁻ : lookup m k ≡ just x → (k , x) ∈ₖᵥ m
 ∈ₖᵥ-lookup⁻ {m = tree t} {k = k} {x = x} eq
-  = tree (IAny.map (Prod.map sym ≡-sym) (IAnyₚ.lookup⁻ t k x (⊥⁺<[ _ ]<⊤⁺) eq))
+  = tree (IAny.map (Product.map sym ≡-sym) (IAnyₚ.lookup⁻ t k x (⊥⁺<[ _ ]<⊤⁺) eq))
 
 ∈ₖᵥ-lookup-nothing⁺ : (∀ x → (k , x) ∉ₖᵥ m) → lookup m k ≡ nothing
 ∈ₖᵥ-lookup-nothing⁺ {k = k} {m = m@(tree t)} k∉m with lookup m k in eq
diff --git a/src/Data/Tree/AVL/Map/Relation/Unary/Any.agda b/src/Data/Tree/AVL/Map/Relation/Unary/Any.agda
index 4bd6961c3d..a6e16267c4 100644
--- a/src/Data/Tree/AVL/Map/Relation/Unary/Any.agda
+++ b/src/Data/Tree/AVL/Map/Relation/Unary/Any.agda
@@ -6,13 +6,13 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Map.Relation.Unary.Any
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
   where
 
-open import Data.Product as Prod using (_×_; ∃; _,_)
+open import Data.Product.Base as Product using (_×_; ∃; _,_)
 open import Function.Base using (_∘_; _∘′_; id)
 open import Level using (Level; _⊔_)
 
@@ -21,7 +21,7 @@ open import Relation.Unary
 open StrictTotalOrder strictTotalOrder renaming (Carrier to Key)
 open import Data.Tree.AVL.Map strictTotalOrder using (Map)
 open import Data.Tree.AVL.Indexed strictTotalOrder using (toPair)
-import Data.Tree.AVL.Relation.Unary.Any strictTotalOrder as Mapₚ
+import Data.Tree.AVL.Relation.Unary.Any strictTotalOrder as Map
 
 private
   variable
@@ -39,30 +39,30 @@ private
 -- See `Relation.Unary` for an explanation of predicates.
 
 Any : {V : Set v} → Pred (Key × V) p → Pred (Map V) (a ⊔ ℓ₂ ⊔ v ⊔ p)
-Any P = Mapₚ.Any (P ∘′ toPair)
+Any P = Map.Any (P ∘′ toPair)
 
 ------------------------------------------------------------------------
 -- Operations on Any
 
 map : P ⊆ Q → Any P ⊆ Any Q
-map f = Mapₚ.map f
+map f = Map.map f
 
 lookup : Any {V = V} P m → Key × V
-lookup = toPair ∘′ Mapₚ.lookup
+lookup = toPair ∘′ Map.lookup
 
 lookupKey : Any P m → Key
-lookupKey = Mapₚ.lookupKey
+lookupKey = Map.lookupKey
 
 -- If any element satisfies P, then P is satisfied.
 
 satisfied : Any P m → ∃ P
-satisfied = Prod.map toPair id ∘′ Mapₚ.satisfied
+satisfied = Product.map toPair id ∘′ Map.satisfied
 
 ------------------------------------------------------------------------
 -- Properties of predicates preserved by Any
 
 any? : Decidable P → Decidable (Any P)
-any? P? = Mapₚ.any? (P? ∘ toPair)
+any? P? = Map.any? (P? ∘ toPair)
 
 satisfiable : Satisfiable P → Satisfiable (Any P)
-satisfiable ((k , v) , p) = Mapₚ.satisfiable k (v , p)
+satisfiable ((k , v) , p) = Map.satisfiable k (v , p)
diff --git a/src/Data/Tree/AVL/NonEmpty.agda b/src/Data/Tree/AVL/NonEmpty.agda
index 622e2b4a58..ac013e65a7 100644
--- a/src/Data/Tree/AVL/NonEmpty.agda
+++ b/src/Data/Tree/AVL/NonEmpty.agda
@@ -11,21 +11,19 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.NonEmpty
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂) where
 
 open import Data.Bool.Base using (Bool)
-open import Data.Empty
 open import Data.List.NonEmpty as List⁺ using (List⁺; _∷_; _++⁺_)
 open import Data.Maybe.Base hiding (map)
 open import Data.Nat.Base hiding (_<_; _⊔_; compare)
-open import Data.Product hiding (map)
-open import Data.Unit
-open import Function
-open import Level using (_⊔_; Lift; lift)
-open import Relation.Unary
+open import Data.Product.Base hiding (map)
+open import Function.Base using (_$_; _∘′_)
+open import Level using (_⊔_)
+open import Relation.Unary using (IUniversal; _⇒_)
 
 open StrictTotalOrder strictTotalOrder renaming (Carrier to Key)
 open import Data.Tree.AVL.Value Eq.setoid
@@ -35,8 +33,8 @@ open Indexed using (⊥⁺; ⊤⁺; ⊥⁺<⊤⁺; ⊥⁺<[_]<⊤⁺; ⊥⁺<[_]
 ------------------------------------------------------------------------
 -- Types and functions with hidden indices
 
--- NB: the height is non-zero thus guaranteeing that the AVL tree contains
--- at least one value.
+-- NB: the height is non-zero thus guaranteeing that the AVL tree
+-- contains at least one value.
 
 data Tree⁺ {v} (V : Value v) : Set (a ⊔ v ⊔ ℓ₂) where
   tree : ∀ {h} → Indexed.Tree V ⊥⁺ ⊤⁺ (suc h) → Tree⁺ V
diff --git a/src/Data/Tree/AVL/NonEmpty/Propositional.agda b/src/Data/Tree/AVL/NonEmpty/Propositional.agda
index f537b1c673..c449e4fb70 100644
--- a/src/Data/Tree/AVL/NonEmpty/Propositional.agda
+++ b/src/Data/Tree/AVL/NonEmpty/Propositional.agda
@@ -6,8 +6,10 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; IsStrictTotalOrder; StrictTotalOrder)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; subst)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsStrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; subst)
 
 module Data.Tree.AVL.NonEmpty.Propositional
   {k r} {Key : Set k} {_<_ : Rel Key r}
@@ -15,7 +17,9 @@ module Data.Tree.AVL.NonEmpty.Propositional
 
 open import Level
 
-private strictTotalOrder = record { isStrictTotalOrder = isStrictTotalOrder}
+private
+  strictTotalOrder : StrictTotalOrder _ _ _
+  strictTotalOrder = record { isStrictTotalOrder = isStrictTotalOrder}
 open import Data.Tree.AVL.Value (StrictTotalOrder.Eq.setoid strictTotalOrder)
 import Data.Tree.AVL.NonEmpty strictTotalOrder as AVL⁺
 
diff --git a/src/Data/Tree/AVL/Relation/Unary/Any.agda b/src/Data/Tree/AVL/Relation/Unary/Any.agda
index e0dbadfa83..5efc9363a3 100644
--- a/src/Data/Tree/AVL/Relation/Unary/Any.agda
+++ b/src/Data/Tree/AVL/Relation/Unary/Any.agda
@@ -6,13 +6,13 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Relation.Unary.Any
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
   where
 
-open import Data.Product as Prod using (∃)
+open import Data.Product.Base as Product using (∃)
 open import Function.Base using (_∘_; _$_)
 open import Level using (Level; _⊔_)
 
@@ -68,5 +68,5 @@ any? : Decidable P → Decidable (Any {V = V} P)
 any? P? (tree p) = map′ tree (λ where (tree p) → p) (AVLₚ.any? P? p)
 
 satisfiable : (k : Key) → Satisfiable (P ∘ (k ,_)) → Satisfiable (Any {V = V} P)
-satisfiable k sat = Prod.map tree tree
+satisfiable k sat = Product.map tree tree
                   $ AVLₚ.satisfiable Indexed.⊥⁺<[ k ] Indexed.[ k ]<⊤⁺ sat
diff --git a/src/Data/Tree/AVL/Sets.agda b/src/Data/Tree/AVL/Sets.agda
index b533605b95..6065671a41 100644
--- a/src/Data/Tree/AVL/Sets.agda
+++ b/src/Data/Tree/AVL/Sets.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Sets
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
@@ -16,7 +16,7 @@ open import Data.Bool.Base using (Bool)
 open import Data.List.Base as List using (List)
 open import Data.Maybe.Base as Maybe
 open import Data.Nat.Base using (ℕ)
-open import Data.Product as Prod using (_×_; _,_; proj₁)
+open import Data.Product.Base as Product using (_×_; _,_; proj₁)
 open import Data.Unit.Base
 open import Function.Base
 open import Level using (Level; _⊔_)
@@ -54,10 +54,10 @@ member : A → ⟨Set⟩ → Bool
 member = AVL.member
 
 headTail : ⟨Set⟩ → Maybe (A × ⟨Set⟩)
-headTail s = Maybe.map (Prod.map₁ proj₁) (AVL.headTail s)
+headTail s = Maybe.map (Product.map₁ proj₁) (AVL.headTail s)
 
 initLast : ⟨Set⟩ → Maybe (⟨Set⟩ × A)
-initLast s = Maybe.map (Prod.map₂ proj₁) (AVL.initLast s)
+initLast s = Maybe.map (Product.map₂ proj₁) (AVL.initLast s)
 
 fromList : List A → ⟨Set⟩
 fromList = AVL.fromList ∘ List.map (_, _)
diff --git a/src/Data/Tree/AVL/Sets/Membership.agda b/src/Data/Tree/AVL/Sets/Membership.agda
index 947036500c..ba6a231227 100644
--- a/src/Data/Tree/AVL/Sets/Membership.agda
+++ b/src/Data/Tree/AVL/Sets/Membership.agda
@@ -6,19 +6,18 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Sets.Membership
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
   where
 
 open import Data.Bool.Base using (true; false)
-open import Data.Product as Prod using (_,_; proj₁; proj₂)
+open import Data.Product.Base as Product using (_,_; proj₁; proj₂)
 open import Data.Sum.Base as Sum using (_⊎_)
 open import Data.Unit.Base using (tt)
 open import Function.Base using (_∘_; _∘′_; const)
 
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
 open import Relation.Nullary using (¬_; yes; no; Reflects)
 open import Relation.Nullary.Reflects using (fromEquivalence)
 
diff --git a/src/Data/Tree/AVL/Sets/Membership/Properties.agda b/src/Data/Tree/AVL/Sets/Membership/Properties.agda
index 7c1f27a1d1..8b46933af5 100644
--- a/src/Data/Tree/AVL/Sets/Membership/Properties.agda
+++ b/src/Data/Tree/AVL/Sets/Membership/Properties.agda
@@ -6,19 +6,19 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Tree.AVL.Sets.Membership.Properties
   {a ℓ₁ ℓ₂} (strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂)
   where
 
 open import Data.Bool.Base using (true; false)
-open import Data.Product as Prod using (_,_; proj₁; proj₂)
+open import Data.Product.Base as Product using (_,_; proj₁; proj₂)
 open import Data.Sum.Base as Sum using (_⊎_)
 open import Data.Unit.Base using (tt)
 open import Function.Base using (_∘_; _∘′_; const)
 
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 open import Relation.Nullary using (¬_; yes; no; Reflects)
 open import Relation.Nullary.Reflects using (fromEquivalence)
 
diff --git a/src/Data/Tree/AVL/Value.agda b/src/Data/Tree/AVL/Value.agda
index 91633bfb6d..6305bd5c2c 100644
--- a/src/Data/Tree/AVL/Value.agda
+++ b/src/Data/Tree/AVL/Value.agda
@@ -3,20 +3,21 @@
 --
 -- Values for AVL trees
 -- Values must respect the underlying equivalence on keys
------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Setoid; _Respects_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (_Respects_)
 
 module Data.Tree.AVL.Value {a ℓ} (S : Setoid a ℓ) where
 
-open import Data.Product using (Σ; _,_)
+open import Data.Product.Base using (Σ; _,_)
 open import Level using (suc; _⊔_)
-import Function as F
+import Function.Base as F
 open Setoid S renaming (Carrier to Key)
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- A Value
 
 record Value v : Set (a ⊔ ℓ ⊔ suc v) where
@@ -25,7 +26,7 @@ record Value v : Set (a ⊔ ℓ ⊔ suc v) where
     family   : Key → Set v
     respects : family Respects _≈_
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- A Key together with its value
 
 record K&_ {v} (V : Value v) : Set (a ⊔ v) where
@@ -33,6 +34,7 @@ record K&_ {v} (V : Value v) : Set (a ⊔ v) where
   field
     key   : Key
     value : Value.family V key
+infixr 4 _,_
 open K&_ public
 
 module _ {v} {V : Value v} where
@@ -43,7 +45,7 @@ module _ {v} {V : Value v} where
   fromPair : Σ Key (Value.family V) → K& V
   fromPair (k , v) = k , v
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The constant family of values
 
 -- The function `const` is defined using copatterns to prevent eager
diff --git a/src/Data/Tree/Binary/Properties.agda b/src/Data/Tree/Binary/Properties.agda
index c3dc189f8d..270e6c66a2 100644
--- a/src/Data/Tree/Binary/Properties.agda
+++ b/src/Data/Tree/Binary/Properties.agda
@@ -8,13 +8,14 @@
 
 module Data.Tree.Binary.Properties where
 
-open import Function using (_∘_)
+open import Function.Base using (_∘_)
 open import Function.Nary.NonDependent using (congₙ)
 open import Level using (Level)
 open import Data.Nat.Base using (suc; _+_)
 open import Data.Tree.Binary
-open import Function.Base
-open import Relation.Binary.PropositionalEquality
+open import Function.Base using (id; flip)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂; _≗_)
 
 private
   variable
diff --git a/src/Data/Tree/Binary/Relation/Unary/All/Properties.agda b/src/Data/Tree/Binary/Relation/Unary/All/Properties.agda
index 198964ef4d..08361f8476 100644
--- a/src/Data/Tree/Binary/Relation/Unary/All/Properties.agda
+++ b/src/Data/Tree/Binary/Relation/Unary/All/Properties.agda
@@ -12,7 +12,7 @@ open import Level
 open import Data.Tree.Binary as Tree using (Tree; leaf; node)
 open import Data.Tree.Binary.Relation.Unary.All
 open import Relation.Unary
-open import Function
+open import Function.Base using (id)
 
 private
   variable
diff --git a/src/Data/Tree/Binary/Zipper.agda b/src/Data/Tree/Binary/Zipper.agda
index 76b2d9fd8e..3024b125ca 100644
--- a/src/Data/Tree/Binary/Zipper.agda
+++ b/src/Data/Tree/Binary/Zipper.agda
@@ -10,10 +10,10 @@ module Data.Tree.Binary.Zipper where
 
 open import Level using (Level; _⊔_)
 open import Data.Tree.Binary as BT using (Tree; node; leaf)
-open import Data.List as List using (List; []; _∷_; sum; _++_; [_])
-open import Data.Maybe using (Maybe; nothing; just)
+open import Data.List.Base as List using (List; []; _∷_; sum; _++_; [_])
+open import Data.Maybe.Base using (Maybe; nothing; just)
 open import Data.Nat.Base using (ℕ; suc; _+_)
-open import Function
+open import Function.Base using (_$_; _∘_)
 
 private
   variable
diff --git a/src/Data/Tree/Binary/Zipper/Properties.agda b/src/Data/Tree/Binary/Zipper/Properties.agda
index 20017ad162..03a88b09d2 100644
--- a/src/Data/Tree/Binary/Zipper/Properties.agda
+++ b/src/Data/Tree/Binary/Zipper/Properties.agda
@@ -8,17 +8,22 @@
 
 module Data.Tree.Binary.Zipper.Properties where
 
-open import Data.Tree.Binary as BT using (Tree; node; leaf)
-open import Data.Tree.Binary.Zipper
-open import Data.Nat using (ℕ; suc; _+_)
-open import Data.Nat.Properties
 open import Data.List.Base as List using (List ; [] ; _∷_; sum)
 open import Data.Maybe.Base using (Maybe; just; nothing)
 open import Data.Maybe.Relation.Unary.All using (All; just; nothing)
-open import Relation.Binary.PropositionalEquality
-open ≡-Reasoning
-open import Function
+open import Data.Nat.Base using (ℕ; suc; _+_)
+open import Data.Nat.Properties using (+-identityʳ; +-comm; +-assoc)
+open import Data.Tree.Binary as BT using (Tree; node; leaf)
+open import Data.Tree.Binary.Zipper using (Zipper; toTree; up; mkZipper;
+  leftBranch; rightBranch; left; right; #nodes; Crumb; getTree; #leaves;
+  map; foldr; _⟪_⟫ˡ_; _⟪_⟫ʳ_)
+open import Function.Base using (_on_; _∘_; _$_)
 open import Level using (Level)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
+open ≡-Reasoning
 
 private
   variable
@@ -60,9 +65,9 @@ toTree-#nodes (mkZipper c v) = helper c v
       #ctx = sum (List.map (suc ∘ BT.#nodes ∘ getTree) ctx)
       #foc = BT.#nodes foc
       #l = BT.#nodes l in begin
-      #foc + (1 + (#l + #ctx))             ≡˘⟨ +-assoc #foc 1 (#l + #ctx) ⟩
+      #foc + (1 + (#l + #ctx))             ≡⟨ +-assoc #foc 1 (#l + #ctx) ⟨
       #foc + 1 + (#l + #ctx)               ≡⟨ cong (_+ (#l + #ctx)) (+-comm #foc 1) ⟩
-      1 + #foc + (#l + #ctx)               ≡˘⟨ +-assoc (1 + #foc) #l #ctx ⟩
+      1 + #foc + (#l + #ctx)               ≡⟨ +-assoc (1 + #foc) #l #ctx ⟨
       1 + #foc + #l + #ctx                 ≡⟨ cong (_+ #ctx) (+-comm (1 + #foc) #l) ⟩
       #nodes (mkZipper ctx (node l m foc)) ≡⟨ helper ctx (node l m foc) ⟩
       BT.#nodes (toTree (mkZipper cs foc)) ∎
@@ -70,8 +75,8 @@ toTree-#nodes (mkZipper c v) = helper c v
       #ctx = sum (List.map (suc ∘ BT.#nodes ∘ getTree) ctx)
       #foc = BT.#nodes foc
       #r = BT.#nodes r in begin
-      #foc + (1 + (#r + #ctx))             ≡˘⟨ cong (#foc +_) (+-assoc 1 #r #ctx) ⟩
-      #foc + (1 + #r + #ctx)               ≡˘⟨ +-assoc #foc (suc #r) #ctx ⟩
+      #foc + (1 + (#r + #ctx))             ≡⟨ cong (#foc +_) (+-assoc 1 #r #ctx) ⟨
+      #foc + (1 + #r + #ctx)               ≡⟨ +-assoc #foc (suc #r) #ctx ⟨
       #nodes (mkZipper ctx (node foc m r)) ≡⟨ helper ctx (node foc m r) ⟩
       BT.#nodes (toTree (mkZipper cs foc)) ∎
 
@@ -86,7 +91,7 @@ toTree-#leaves (mkZipper c v) = helper c v
       #ctx = sum (List.map (BT.#leaves ∘ getTree) ctx)
       #foc = BT.#leaves foc
       #l = BT.#leaves l in begin
-      #foc + (#l + #ctx)                    ≡˘⟨ +-assoc #foc #l #ctx ⟩
+      #foc + (#l + #ctx)                    ≡⟨ +-assoc #foc #l #ctx ⟨
       #foc + #l + #ctx                      ≡⟨ cong (_+ #ctx) (+-comm #foc #l) ⟩
       #leaves (mkZipper ctx (node l m foc)) ≡⟨ helper ctx (node l m foc) ⟩
       BT.#leaves (toTree (mkZipper cs foc)) ∎
@@ -94,7 +99,7 @@ toTree-#leaves (mkZipper c v) = helper c v
       #ctx = sum (List.map (BT.#leaves ∘ getTree) ctx)
       #foc = BT.#leaves foc
       #r = BT.#leaves r in begin
-      #foc + (#r + #ctx)                    ≡˘⟨ +-assoc #foc #r #ctx ⟩
+      #foc + (#r + #ctx)                    ≡⟨ +-assoc #foc #r #ctx ⟨
       #leaves (mkZipper ctx (node foc m r)) ≡⟨ helper ctx (node foc m r) ⟩
       BT.#leaves (toTree (mkZipper cs foc)) ∎
 
diff --git a/src/Data/Tree/Rose/Properties.agda b/src/Data/Tree/Rose/Properties.agda
index 749bdb5748..da86ca31ad 100644
--- a/src/Data/Tree/Rose/Properties.agda
+++ b/src/Data/Tree/Rose/Properties.agda
@@ -11,12 +11,15 @@ module Data.Tree.Rose.Properties where
 open import Level using (Level)
 open import Size
 open import Data.List.Base as List using (List)
-open import Data.List.Extrema.Nat
-import Data.List.Properties as Listₚ
+open import Data.List.Extrema.Nat using (max)
+import Data.List.Properties as List
 open import Data.Nat.Base using (ℕ; zero; suc)
-open import Data.Tree.Rose
-open import Function.Base
-open import Relation.Binary.PropositionalEquality
+open import Data.Tree.Rose using (Rose; node; map; depth; foldr)
+open import Function.Base using (_∘′_; _$_; _∘_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≗_; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open ≡-Reasoning
 
 private
@@ -33,14 +36,14 @@ private
 map-∘ : (f : A → B) (g : B → C) →
               map {i = i} (g ∘′ f) ≗ map {i = i} g ∘′ map {i = i} f
 map-∘ f g (node a ts) = cong (node (g (f a))) $ begin
-  List.map (map (g ∘′ f)) ts             ≡⟨ Listₚ.map-cong (map-∘ f g) ts ⟩
-  List.map (map g ∘ map f) ts            ≡⟨ Listₚ.map-∘ ts ⟩
+  List.map (map (g ∘′ f)) ts             ≡⟨ List.map-cong (map-∘ f g) ts ⟩
+  List.map (map g ∘ map f) ts            ≡⟨ List.map-∘ ts ⟩
   List.map (map g) (List.map (map f) ts) ∎
 
 depth-map : (f : A → B) (t : Rose A i) → depth {i = i} (map {i = i} f t) ≡ depth {i = i} t
 depth-map f (node a ts) = cong (suc ∘′ max 0) $ begin
-  List.map depth (List.map (map f) ts) ≡˘⟨ Listₚ.map-∘ ts ⟩
-  List.map (depth ∘′ map f) ts         ≡⟨ Listₚ.map-cong (depth-map f) ts ⟩
+  List.map depth (List.map (map f) ts) ≡⟨ List.map-∘ ts ⟨
+  List.map (depth ∘′ map f) ts         ≡⟨ List.map-cong (depth-map f) ts ⟩
   List.map depth ts ∎
 
 ------------------------------------------------------------------------
@@ -49,8 +52,8 @@ depth-map f (node a ts) = cong (suc ∘′ max 0) $ begin
 foldr-map : (f : A → B) (n : B → List C → C) (ts : Rose A i) →
             foldr {i = i} n (map {i = i} f ts) ≡ foldr {i = i} (n ∘′ f) ts
 foldr-map f n (node a ts) = cong (n (f a)) $ begin
-  List.map (foldr n) (List.map (map f) ts) ≡˘⟨ Listₚ.map-∘ ts ⟩
-  List.map (foldr n ∘′ map f) ts           ≡⟨ Listₚ.map-cong (foldr-map f n) ts ⟩
+  List.map (foldr n) (List.map (map f) ts) ≡⟨ List.map-∘ ts ⟨
+  List.map (foldr n ∘′ map f) ts           ≡⟨ List.map-cong (foldr-map f n) ts ⟩
   List.map (foldr (n ∘′ f)) ts             ∎
 
 ------------------------------------------------------------------------
diff --git a/src/Data/Tree/Rose/Show.agda b/src/Data/Tree/Rose/Show.agda
index a0e9631622..1aa0509aae 100644
--- a/src/Data/Tree/Rose/Show.agda
+++ b/src/Data/Tree/Rose/Show.agda
@@ -14,8 +14,8 @@ open import Data.Bool.Base using (Bool; true; false; if_then_else_; _∧_)
 open import Data.DifferenceList as DList renaming (DiffList to DList) using ()
 open import Data.List.Base as List using (List; []; [_]; _∷_; _∷ʳ_)
 open import Data.Nat.Base using (ℕ; _∸_)
-open import Data.Product using (_×_; _,_)
-open import Data.String.Base hiding (show)
+open import Data.Product.Base using (_×_; _,_)
+open import Data.String.Base using (String; _++_)
 open import Data.Tree.Rose using (Rose; node; map; fromBinary)
 open import Function.Base using (flip; _∘′_; id)
 
diff --git a/src/Data/Trie.agda b/src/Data/Trie.agda
index 2ea6b2f963..3c2de5daf1 100644
--- a/src/Data/Trie.agda
+++ b/src/Data/Trie.agda
@@ -9,7 +9,8 @@
 
 {-# OPTIONS --cubical-compatible --sized-types #-}
 
-open import Relation.Binary using (Rel; StrictTotalOrder)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Trie {k e r} (S : StrictTotalOrder k e r) where
 
@@ -18,9 +19,9 @@ open import Size
 open import Data.List.Base using (List; []; _∷_; _++_)
 import Data.List.NonEmpty as List⁺
 open import Data.Maybe.Base as Maybe using (Maybe; just; nothing; maybe′)
-open import Data.Product as Prod using (∃)
+open import Data.Product.Base using (∃)
 open import Data.These.Base as These using (These)
-open import Function
+open import Function.Base using (_∘′_; const)
 open import Relation.Unary using (IUniversal; _⇒_)
 
 open StrictTotalOrder S
diff --git a/src/Data/Trie/NonEmpty.agda b/src/Data/Trie/NonEmpty.agda
index 6de3c53313..3bdc550a68 100644
--- a/src/Data/Trie/NonEmpty.agda
+++ b/src/Data/Trie/NonEmpty.agda
@@ -6,19 +6,19 @@
 
 {-# OPTIONS --cubical-compatible --sized-types #-}
 
-open import Relation.Binary using (StrictTotalOrder)
+open import Relation.Binary.Bundles using (StrictTotalOrder)
 
 module Data.Trie.NonEmpty {k e r} (S : StrictTotalOrder k e r) where
 
 open import Level
 open import Size
 open import Effect.Monad
-open import Data.Product as Prod using (∃; uncurry; -,_)
+open import Data.Product.Base as Product using (∃; uncurry; -,_)
 open import Data.List.Base as List using (List; []; _∷_; _++_)
 open import Data.List.NonEmpty as List⁺ using (List⁺; [_]; concatMap)
 open import Data.Maybe.Base as Maybe using (Maybe; nothing; just; maybe′) hiding (module Maybe)
 open import Data.These as These using (These; this; that; these)
-open import Function as F
+open import Function.Base as F
 import Function.Identity.Effectful as Identity
 open import Relation.Unary using (_⇒_; IUniversal)
 
@@ -35,10 +35,10 @@ open Value
 ------------------------------------------------------------------------
 -- Definition
 
--- A Trie⁺ is a tree branching over an alphabet of Keys. It stores values
--- indexed over the Word (i.e. List Key) that was read to reach them.
--- Each node in the Trie⁺ contains either a value, a non-empty Tree of
--- sub-Trie⁺ reached by reading an extra letter, or both.
+-- A Trie⁺ is a tree branching over an alphabet of Keys. It stores
+-- values indexed over the Word (i.e. List Key) that was read to reach
+-- them. Each node in the Trie⁺ contains either a value, a non-empty
+-- Tree of sub-Trie⁺ reached by reading an extra letter, or both.
 
 Word : Set k
 Word = List Key
@@ -125,7 +125,7 @@ toList⁺ (node nd) = These.mergeThese List⁺._⁺++⁺_
   where
 
   fromVal    = [_] ∘′ -,_
-  fromTrie⁺  = λ (k , v) → List⁺.map (Prod.map (k ∷_) id) (toList⁺ v)
+  fromTrie⁺  = λ (k , v) → List⁺.map (Product.map (k ∷_) id) (toList⁺ v)
   fromTries⁺ = concatMap fromTrie⁺ ∘′ Tree⁺.toList⁺
 
 ------------------------------------------------------------------------
diff --git a/src/Data/Unit.agda b/src/Data/Unit.agda
index 2e3464c7f4..73f269d9d6 100644
--- a/src/Data/Unit.agda
+++ b/src/Data/Unit.agda
@@ -1,7 +1,7 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- The unit type
+-- The unit type, Level-monomorphic version
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
diff --git a/src/Data/Unit/Polymorphic/Properties.agda b/src/Data/Unit/Polymorphic/Properties.agda
index 8513229ba1..f5e9fb9be0 100644
--- a/src/Data/Unit/Polymorphic/Properties.agda
+++ b/src/Data/Unit/Polymorphic/Properties.agda
@@ -9,15 +9,23 @@
 
 module Data.Unit.Polymorphic.Properties where
 
-open import Level
+open import Level using (Level)
 open import Function.Bundles using (_↔_; mk↔)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Data.Sum.Base using (inj₁)
 open import Data.Unit.Base renaming (⊤ to ⊤*)
 open import Data.Unit.Polymorphic.Base using (⊤; tt)
-open import Relation.Nullary
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
+open import Relation.Nullary.Decidable using (yes)
+open import Relation.Binary.Bundles
+  using (Setoid; DecSetoid; Preorder; Poset; TotalOrder; DecTotalOrder)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (DecidableEquality; Antisymmetric; Total)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; trans)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (decSetoid; setoid; isEquivalence)
 
 private
   variable
@@ -29,7 +37,7 @@ private
 
 infix 4 _≟_
 
-_≟_ : Decidable {A = ⊤ {ℓ}} _≡_
+_≟_ : DecidableEquality (⊤ {ℓ})
 _ ≟ _ = yes refl
 
 ≡-setoid : ∀ ℓ → Setoid ℓ ℓ
diff --git a/src/Data/Unit/Properties.agda b/src/Data/Unit/Properties.agda
index b31d8feb3d..05cf0fbb94 100644
--- a/src/Data/Unit/Properties.agda
+++ b/src/Data/Unit/Properties.agda
@@ -8,12 +8,19 @@
 
 module Data.Unit.Properties where
 
-open import Data.Sum.Base
-open import Data.Unit.Base
+open import Data.Sum.Base using (inj₁)
+open import Data.Unit.Base using (⊤)
 open import Level using (0ℓ)
-open import Relation.Nullary
-open import Relation.Binary hiding (Irrelevant)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Nullary using (Irrelevant; yes)
+open import Relation.Binary.Bundles
+  using (Setoid; DecSetoid; Poset; DecTotalOrder)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions using (DecidableEquality; Total; Antisymmetric)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; trans)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (setoid; decSetoid; isEquivalence)
 
 ------------------------------------------------------------------------
 -- Irrelevancy
@@ -26,7 +33,7 @@ open import Relation.Binary.PropositionalEquality
 
 infix 4 _≟_
 
-_≟_ : Decidable {A = ⊤} _≡_
+_≟_ : DecidableEquality ⊤
 _ ≟ _ = yes refl
 
 ≡-setoid : Setoid 0ℓ 0ℓ
diff --git a/src/Data/Universe.agda b/src/Data/Universe.agda
index 516e0bd2a4..9bbfb4620b 100644
--- a/src/Data/Universe.agda
+++ b/src/Data/Universe.agda
@@ -8,7 +8,6 @@
 
 module Data.Universe where
 
-open import Data.Product
 open import Level
 
 ------------------------------------------------------------------------
diff --git a/src/Data/Universe/Indexed.agda b/src/Data/Universe/Indexed.agda
index a11958e16f..9807e38eb5 100644
--- a/src/Data/Universe/Indexed.agda
+++ b/src/Data/Universe/Indexed.agda
@@ -8,9 +8,9 @@
 
 module Data.Universe.Indexed where
 
-open import Data.Product
+open import Data.Product.Base using (∃; proj₂)
 open import Data.Universe
-open import Function
+open import Function.Base using (_∘_)
 open import Level
 
 ------------------------------------------------------------------------
diff --git a/src/Data/Vec.agda b/src/Data/Vec.agda
index d9f1b89664..aa6435e445 100644
--- a/src/Data/Vec.agda
+++ b/src/Data/Vec.agda
@@ -9,7 +9,7 @@
 
 -- See `Data.Vec.Functional` for an alternative implementation as
 -- functions from finite sets, which is more suitable for reasoning
--- about fixed sized vectors and for when ease of retrevial is
+-- about fixed sized vectors and for when ease of retrieval is
 -- important.
 
 {-# OPTIONS --cubical-compatible --safe #-}
@@ -18,9 +18,10 @@ module Data.Vec where
 
 open import Level
 open import Data.Bool.Base
-import Data.Nat.Properties as ℕₚ
+import Data.Nat.Properties as ℕ
 open import Data.Vec.Bounded.Base as Vec≤
   using (Vec≤; ≤-cast; fromVec)
+open import Function.Base using (_$_)
 open import Relation.Nullary
 open import Relation.Unary
 
@@ -41,18 +42,14 @@ module _ {P : A → Set p} (P? : Decidable P) where
 
   filter : ∀ {n} → Vec A n → Vec≤ A n
   filter []       = Vec≤.[]
-  filter (a ∷ as) with does (P? a)
-  ... | true  = a Vec≤.∷ filter as
-  ... | false = ≤-cast (ℕₚ.n≤1+n _) (filter as)
+  filter (a ∷ as) = if does (P? a) then a Vec≤.∷_ else ≤-cast (ℕ.n≤1+n _) $ filter as
 
   takeWhile : ∀ {n} → Vec A n → Vec≤ A n
   takeWhile []       = Vec≤.[]
-  takeWhile (a ∷ as) with does (P? a)
-  ... | true  = a Vec≤.∷ takeWhile as
-  ... | false = Vec≤.[]
+  takeWhile (a ∷ as) = if does (P? a) then a Vec≤.∷ takeWhile as else Vec≤.[]
 
   dropWhile : ∀ {n} → Vec A n → Vec≤ A n
   dropWhile Vec.[]       = Vec≤.[]
-  dropWhile (a Vec.∷ as) with does (P? a)
-  ... | true  = ≤-cast (ℕₚ.n≤1+n _) (dropWhile as)
-  ... | false = fromVec (a Vec.∷ as)
+  dropWhile (a Vec.∷ as) =
+    if does (P? a) then ≤-cast (ℕ.n≤1+n _) (dropWhile as)
+    else fromVec (a Vec.∷ as)
diff --git a/src/Data/Vec/Base.agda b/src/Data/Vec/Base.agda
index 911766496a..8c03fb8a83 100644
--- a/src/Data/Vec/Base.agda
+++ b/src/Data/Vec/Base.agda
@@ -12,12 +12,12 @@ open import Data.Bool.Base using (Bool; true; false; if_then_else_)
 open import Data.Nat.Base
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.List.Base as List using (List)
-open import Data.Product as Prod using (∃; ∃₂; _×_; _,_)
+open import Data.Product.Base as Product using (∃; ∃₂; _×_; _,_; proj₁; proj₂)
 open import Data.These.Base as These using (These; this; that; these)
-open import Function.Base using (const; _∘′_; id; _∘_)
+open import Function.Base using (const; _∘′_; id; _∘_; _$_)
 open import Level using (Level)
-open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
-open import Relation.Nullary.Decidable using (does)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; trans; cong)
+open import Relation.Nullary.Decidable.Core using (does; T?)
 open import Relation.Unary using (Pred; Decidable)
 
 private
@@ -60,39 +60,39 @@ lookup : Vec A n → Fin n → A
 lookup (x ∷ xs) zero    = x
 lookup (x ∷ xs) (suc i) = lookup xs i
 
-iterate : (A → A) → A → ∀ {n} → Vec A n
-iterate s z {zero}  = []
-iterate s z {suc n} = z ∷ iterate s (s z)
+iterate : (A → A) → A → ∀ n → Vec A n
+iterate s z zero    = []
+iterate s z (suc n) = z ∷ iterate s (s z) n
 
-insert : Vec A n → Fin (suc n) → A → Vec A (suc n)
-insert xs       zero     v = v ∷ xs
-insert (x ∷ xs) (suc i)  v = x ∷ insert xs i v
+insertAt : Vec A n → Fin (suc n) → A → Vec A (suc n)
+insertAt xs       zero     v = v ∷ xs
+insertAt (x ∷ xs) (suc i)  v = x ∷ insertAt xs i v
 
-remove : Vec A (suc n) → Fin (suc n) → Vec A n
-remove (_ ∷ xs)     zero     = xs
-remove (x ∷ y ∷ xs) (suc i)  = x ∷ remove (y ∷ xs) i
+removeAt : Vec A (suc n) → Fin (suc n) → Vec A n
+removeAt (x ∷ xs)         zero    = xs
+removeAt (x ∷ xs@(_ ∷ _)) (suc i) = x ∷ removeAt xs i
 
-updateAt : Fin n → (A → A) → Vec A n → Vec A n
-updateAt zero    f (x ∷ xs) = f x ∷ xs
-updateAt (suc i) f (x ∷ xs) = x   ∷ updateAt i f xs
+updateAt : Vec A n → Fin n → (A → A) → Vec A n
+updateAt (x ∷ xs) zero    f = f x ∷ xs
+updateAt (x ∷ xs) (suc i) f = x   ∷ updateAt xs i f
 
 -- xs [ i ]%= f  modifies the i-th element of xs according to f
 
-infixl 6 _[_]%=_
+infixl 6 _[_]%=_ _[_]≔_
 
 _[_]%=_ : Vec A n → Fin n → (A → A) → Vec A n
-xs [ i ]%= f = updateAt i f xs
+xs [ i ]%= f = updateAt xs i f
 
 -- xs [ i ]≔ y  overwrites the i-th element of xs with y
 
-infixl 6 _[_]≔_
-
 _[_]≔_ : Vec A n → Fin n → A → Vec A n
 xs [ i ]≔ y = xs [ i ]%= const y
 
 ------------------------------------------------------------------------
 -- Operations for transforming vectors
 
+-- See README.Data.Vec.Relation.Binary.Equality.Cast for the reasoning
+-- system of `cast`-ed equality.
 cast : .(eq : m ≡ n) → Vec A m → Vec A n
 cast {n = zero}  eq []       = []
 cast {n = suc _} eq (x ∷ xs) = x ∷ cast (cong pred eq) xs
@@ -131,7 +131,7 @@ zipWith f (x ∷ xs) (y ∷ ys) = f x y ∷ zipWith f xs ys
 
 unzipWith : (A → B × C) → Vec A n → Vec B n × Vec C n
 unzipWith f []       = [] , []
-unzipWith f (a ∷ as) = Prod.zip _∷_ _∷_ (f a) (unzipWith f as)
+unzipWith f (a ∷ as) = Product.zip _∷_ _∷_ (f a) (unzipWith f as)
 
 align : Vec A m → Vec B n → Vec (These A B) (m ⊔ n)
 align = alignWith id
@@ -189,8 +189,6 @@ module DiagonalBind where
   _>>=_ : Vec A n → (A → Vec B n) → Vec B n
   xs >>= f = diagonal (map f xs)
 
-  join : Vec (Vec A n) n → Vec A n
-  join = _>>= id
 
 ------------------------------------------------------------------------
 -- Operations for reducing vectors
@@ -232,12 +230,12 @@ foldl₁ _⊕_ (x ∷ xs) = foldl _ _⊕_ x xs
 sum : Vec ℕ n → ℕ
 sum = foldr _ _+_ 0
 
-countᵇ : (A → Bool) → Vec A n → ℕ
-countᵇ p []       = zero
-countᵇ p (x ∷ xs) = if p x then suc (countᵇ p xs) else countᵇ p xs
-
 count : ∀ {P : Pred A p} → Decidable P → Vec A n → ℕ
-count P? = countᵇ (does ∘ P?)
+count P? []       = zero
+count P? (x ∷ xs) = if does (P? x) then suc else id $ count P? xs
+
+countᵇ : (A → Bool) → Vec A n → ℕ
+countᵇ p = count (T? ∘ p)
 
 ------------------------------------------------------------------------
 -- Operations for building vectors
@@ -245,9 +243,9 @@ count P? = countᵇ (does ∘ P?)
 [_] : A → Vec A 1
 [ x ] = x ∷ []
 
-replicate : A → Vec A n
-replicate {n = zero}  x = []
-replicate {n = suc n} x = x ∷ replicate x
+replicate : (n : ℕ) → A → Vec A n
+replicate zero    x = []
+replicate (suc n) x = x ∷ replicate n x
 
 tabulate : (Fin n → A) → Vec A n
 tabulate {n = zero}  f = []
@@ -261,31 +259,28 @@ allFin _ = tabulate id
 
 splitAt : ∀ m {n} (xs : Vec A (m + n)) →
           ∃₂ λ (ys : Vec A m) (zs : Vec A n) → xs ≡ ys ++ zs
-splitAt zero    xs                = ([] , xs , refl)
-splitAt (suc m) (x ∷ xs)          with splitAt m xs
-splitAt (suc m) (x ∷ .(ys ++ zs)) | (ys , zs , refl) =
-  ((x ∷ ys) , zs , refl)
+splitAt zero    xs                = [] , xs , refl
+splitAt (suc m) (x ∷ xs) =
+  let ys , zs , eq = splitAt m xs in x ∷ ys , zs , cong (x ∷_) eq
 
 take : ∀ m {n} → Vec A (m + n) → Vec A m
-take m xs          with splitAt m xs
-take m .(ys ++ zs) | (ys , zs , refl) = ys
+take m xs = proj₁ (splitAt m xs)
 
 drop : ∀ m {n} → Vec A (m + n) → Vec A n
-drop m xs          with splitAt m xs
-drop m .(ys ++ zs) | (ys , zs , refl) = zs
+drop m xs = proj₁ (proj₂ (splitAt m xs))
 
 group : ∀ n k (xs : Vec A (n * k)) →
         ∃ λ (xss : Vec (Vec A k) n) → xs ≡ concat xss
 group zero    k []                  = ([] , refl)
-group (suc n) k xs                  with splitAt k xs
-group (suc n) k .(ys ++ zs)         | (ys , zs , refl) with group n k zs
-group (suc n) k .(ys ++ concat zss) | (ys , ._ , refl) | (zss , refl) =
-  ((ys ∷ zss) , refl)
+group (suc n) k xs  =
+  let ys , zs , eq-split = splitAt k xs in
+  let zss , eq-group     = group n k zs in
+   (ys ∷ zss) , trans eq-split (cong (ys ++_) eq-group)
 
 split : Vec A n → Vec A ⌈ n /2⌉ × Vec A ⌊ n /2⌋
 split []           = ([]     , [])
 split (x ∷ [])     = (x ∷ [] , [])
-split (x ∷ y ∷ xs) = Prod.map (x ∷_) (y ∷_) (split xs)
+split (x ∷ y ∷ xs) = Product.map (x ∷_) (y ∷_) (split xs)
 
 uncons : Vec A (suc n) → A × Vec A n
 uncons (x ∷ xs) = x , xs
@@ -295,12 +290,12 @@ uncons (x ∷ xs) = x , xs
 
 -- Take the first 'm' elements of a vector.
 truncate : ∀ {m n} → m ≤ n → Vec A n → Vec A m
-truncate z≤n      _        = []
+truncate {m = zero} _ _    = []
 truncate (s≤s le) (x ∷ xs) = x ∷ (truncate le xs)
 
 -- Pad out a vector with extra elements.
 padRight : ∀ {m n} → m ≤ n → A → Vec A m → Vec A n
-padRight z≤n      a xs       = replicate a
+padRight z≤n      a xs       = replicate _ a
 padRight (s≤s le) a (x ∷ xs) = x ∷ padRight le a xs
 
 ------------------------------------------------------------------------
@@ -340,21 +335,39 @@ xs ʳ++ ys = foldl (Vec _ ∘ (_+ _)) (λ rev x → x ∷ rev) ys xs
 -- init and last
 
 initLast : ∀ (xs : Vec A (1 + n)) → ∃₂ λ ys y → xs ≡ ys ∷ʳ y
-initLast {n = zero}  (x ∷ []) = ([] , x , refl)
-initLast {n = suc n} (x ∷ xs) with initLast xs
-... | (ys , y , refl) = (x ∷ ys , y , refl)
+initLast {n = zero}  (x ∷ []) = [] , x , refl
+initLast {n = suc n} (x ∷ xs) =
+  let ys , y , eq = initLast xs in
+  x ∷ ys , y , cong (x ∷_) eq
 
 init : Vec A (1 + n) → Vec A n
-init xs with initLast xs
-... | (ys , y , refl) = ys
+init xs = proj₁ (initLast xs)
 
 last : Vec A (1 + n) → A
-last xs with initLast xs
-... | (ys , y , refl) = y
+last xs = proj₁ (proj₂ (initLast xs))
 
 ------------------------------------------------------------------------
 -- Other operations
 
 transpose : Vec (Vec A n) m → Vec (Vec A m) n
-transpose []         = replicate []
-transpose (as ∷ ass) = replicate _∷_ ⊛ as ⊛ transpose ass
+transpose {n = n} []          = replicate n []
+transpose {n = n} (as ∷ ass) = ((replicate n _∷_) ⊛ as) ⊛ transpose ass
+
+------------------------------------------------------------------------
+-- DEPRECATED
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
+
+remove = removeAt
+{-# WARNING_ON_USAGE remove
+"Warning: remove was deprecated in v2.0.
+Please use removeAt instead."
+#-}
+insert = insertAt
+{-# WARNING_ON_USAGE insert
+"Warning: insert was deprecated in v2.0.
+Please use insertAt instead."
+#-}
diff --git a/src/Data/Vec/Bounded.agda b/src/Data/Vec/Bounded.agda
index 2e1f286419..410e3bebcc 100644
--- a/src/Data/Vec/Bounded.agda
+++ b/src/Data/Vec/Bounded.agda
@@ -9,10 +9,11 @@
 module Data.Vec.Bounded where
 
 open import Level using (Level)
-open import Data.Nat.Base
-open import Data.Vec as Vec using (Vec)
-open import Function
-open import Relation.Binary using (_Preserves_⟶_)
+open import Data.Nat.Base using (_≤_)
+open import Data.Vec.Base using (Vec)
+import Data.Vec as Vec using (filter; takeWhile; dropWhile)
+open import Function.Base using (id)
+open import Relation.Binary.Core using (_Preserves_⟶_)
 open import Relation.Unary using (Pred; Decidable)
 
 private
diff --git a/src/Data/Vec/Bounded/Base.agda b/src/Data/Vec/Bounded/Base.agda
index 9c874ec89e..fa7eb758ed 100644
--- a/src/Data/Vec/Bounded/Base.agda
+++ b/src/Data/Vec/Bounded/Base.agda
@@ -8,21 +8,22 @@
 
 module Data.Vec.Bounded.Base where
 
-open import Level using (Level)
 open import Data.Nat.Base
-import Data.Nat.Properties as ℕₚ
+import Data.Nat.Properties as ℕ
 open import Data.List.Base as List using (List)
-open import Data.List.Extrema ℕₚ.≤-totalOrder
+open import Data.List.Extrema ℕ.≤-totalOrder
 open import Data.List.Relation.Unary.All as All using (All)
-import Data.List.Relation.Unary.All.Properties as Allₚ
+import Data.List.Relation.Unary.All.Properties as All
 open import Data.List.Membership.Propositional using (mapWith∈)
-open import Data.Product using (∃; _×_; _,_; proj₁; proj₂)
+open import Data.Product.Base using (∃; _×_; _,_; proj₁; proj₂)
 open import Data.Vec.Base as Vec using (Vec)
 open import Data.These.Base as These using (These)
-open import Function
-open import Relation.Nullary
-open import Relation.Unary
-open import Relation.Binary.PropositionalEquality as P using (_≡_; refl)
+open import Function.Base using (_∘_; id; _$_)
+open import Level using (Level)
+open import Relation.Nullary.Decidable.Core using (recompute)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 
 private
   variable
@@ -30,6 +31,7 @@ private
     A : Set a
     B : Set b
     C : Set c
+    m n : ℕ
 
 ------------------------------------------------------------------------
 -- Types
@@ -41,103 +43,108 @@ record Vec≤ (A : Set a) (n : ℕ) : Set a where
         vec      : Vec A length
         .bound   : length ≤ n
 
+-- projection to recompute irrelevant field
+isBounded : (as : Vec≤ A n) → Vec≤.length as ≤ n
+isBounded as@(_ , m≤n) = recompute (_ ℕ.≤? _) m≤n
+
 ------------------------------------------------------------------------
 -- Conversion functions
 
-fromVec : ∀ {n} → Vec A n → Vec≤ A n
-fromVec v = v , ℕₚ.≤-refl
+toVec : (as : Vec≤ A n) → Vec A (Vec≤.length as)
+toVec as@(vs , _) = vs
+
+fromVec : Vec A n → Vec≤ A n
+fromVec v = v , ℕ.≤-refl
 
-padRight : ∀ {n} → A → Vec≤ A n → Vec A n
-padRight a (vs , m≤n)
-  with recompute (_ ℕₚ.≤″? _) (ℕₚ.≤⇒≤″ m≤n)
-... | less-than-or-equal refl = vs Vec.++ Vec.replicate a
+padRight : A → Vec≤ A n → Vec A n
+padRight a as@(vs , m≤n)
+  with k , refl ← ℕ.m≤n⇒∃[o]m+o≡n m≤n
+  = vs Vec.++ Vec.replicate k a
 
-padLeft : ∀ {n} → A → Vec≤ A n → Vec A n
-padLeft a as@(vs , m≤n)
-  with recompute (_ ℕₚ.≤″? _) (ℕₚ.≤⇒≤″ m≤n)
-... | less-than-or-equal {k} ∣as∣+k≡n
-  with P.trans (ℕₚ.+-comm k (Vec≤.length as)) ∣as∣+k≡n
-... | refl = Vec.replicate a Vec.++ vs
+padLeft : A → Vec≤ A n → Vec A n
+padLeft a record { length = m ; vec = vs ; bound = m≤n }
+  with k , refl ← ℕ.m≤n⇒∃[o]m+o≡n m≤n
+  rewrite ℕ.+-comm m k
+  = Vec.replicate k a Vec.++ vs
 
 private
-  split : ∀ {m n} k → m + k ≡ n → ⌊ k /2⌋ + (m + ⌈ k /2⌉) ≡ n
-  split {m} {n} k eq = begin
-    ⌊ k /2⌋ + (m + ⌈ k /2⌉) ≡⟨ ℕₚ.+-comm ⌊ k /2⌋ _ ⟩
-    m + ⌈ k /2⌉ + ⌊ k /2⌋   ≡⟨ ℕₚ.+-assoc m ⌈ k /2⌉ ⌊ k /2⌋ ⟩
-    m + (⌈ k /2⌉ + ⌊ k /2⌋) ≡⟨ P.cong (m +_) (ℕₚ.+-comm ⌈ k /2⌉ ⌊ k /2⌋) ⟩
-    m + (⌊ k /2⌋ + ⌈ k /2⌉) ≡⟨ P.cong (m +_) (ℕₚ.⌊n/2⌋+⌈n/2⌉≡n k) ⟩
-    m + k                   ≡⟨ eq ⟩
-    n                       ∎ where open P.≡-Reasoning
-
-padBoth : ∀ {n} → A → A → Vec≤ A n → Vec A n
-padBoth aₗ aᵣ as@(vs , m≤n)
-  with recompute (_ ℕₚ.≤″? _) (ℕₚ.≤⇒≤″ m≤n)
-... | less-than-or-equal {k} ∣as∣+k≡n
-  with split k ∣as∣+k≡n
-... | refl = Vec.replicate {n = ⌊ k /2⌋} aₗ
+  split : ∀ m k → m + k ≡ ⌊ k /2⌋ + (m + ⌈ k /2⌉)
+  split m k = begin
+    m + k                   ≡⟨ ≡.cong (m +_) (ℕ.⌊n/2⌋+⌈n/2⌉≡n k) ⟨
+    m + (⌊ k /2⌋ + ⌈ k /2⌉) ≡⟨ ≡.cong (m +_) (ℕ.+-comm ⌊ k /2⌋ ⌈ k /2⌉) ⟩
+    m + (⌈ k /2⌉ + ⌊ k /2⌋) ≡⟨ ℕ.+-assoc m ⌈ k /2⌉ ⌊ k /2⌋ ⟨
+    m + ⌈ k /2⌉ + ⌊ k /2⌋   ≡⟨ ℕ.+-comm _ ⌊ k /2⌋ ⟩
+    ⌊ k /2⌋ + (m + ⌈ k /2⌉) ∎
+    where open ≡-Reasoning
+
+padBoth : A → A → Vec≤ A n → Vec A n
+padBoth aₗ aᵣ record { length = m ; vec = vs ; bound = m≤n }
+  with k , refl ← ℕ.m≤n⇒∃[o]m+o≡n m≤n
+  rewrite split m k
+  = Vec.replicate ⌊ k /2⌋ aₗ
       Vec.++ vs
-      Vec.++ Vec.replicate {n = ⌈ k /2⌉} aᵣ
+      Vec.++ Vec.replicate ⌈ k /2⌉ aᵣ
 
 
 fromList : (as : List A) → Vec≤ A (List.length as)
 fromList = fromVec ∘ Vec.fromList
 
-toList : ∀ {n} → Vec≤ A n → List A
-toList = Vec.toList ∘ Vec≤.vec
+toList : Vec≤ A n → List A
+toList = Vec.toList ∘ toVec
 
 ------------------------------------------------------------------------
 -- Creating new Vec≤ vectors
 
-replicate : ∀ {m n} .(m≤n : m ≤ n) → A → Vec≤ A n
-replicate m≤n a = Vec.replicate a , m≤n
+replicate : .(m≤n : m ≤ n) → A → Vec≤ A n
+replicate m≤n a = Vec.replicate _ a , m≤n
 
-[] : ∀ {n} → Vec≤ A n
+[] : Vec≤ A n
 [] = Vec.[] , z≤n
 
 infixr 5 _∷_
-_∷_ : ∀ {n} → A → Vec≤ A n → Vec≤ A (suc n)
+_∷_ : A → Vec≤ A n → Vec≤ A (suc n)
 a ∷ (as , p) = a Vec.∷ as , s≤s p
 
 ------------------------------------------------------------------------
 -- Modifying Vec≤ vectors
 
-≤-cast : ∀ {m n} → .(m≤n : m ≤ n) → Vec≤ A m → Vec≤ A n
-≤-cast m≤n (v , p) = v , ℕₚ.≤-trans p m≤n
+≤-cast : .(m≤n : m ≤ n) → Vec≤ A m → Vec≤ A n
+≤-cast m≤n (v , p) = v , ℕ.≤-trans p m≤n
 
-≡-cast : ∀ {m n} → .(eq : m ≡ n) → Vec≤ A m → Vec≤ A n
-≡-cast m≡n = ≤-cast (ℕₚ.≤-reflexive m≡n)
+≡-cast : .(eq : m ≡ n) → Vec≤ A m → Vec≤ A n
+≡-cast m≡n = ≤-cast (ℕ.≤-reflexive m≡n)
 
-map : (A → B) → ∀ {n} → Vec≤ A n → Vec≤ B n
+map : (A → B) → Vec≤ A n → Vec≤ B n
 map f (v , p) = Vec.map f v , p
 
-reverse : ∀ {n} → Vec≤ A n → Vec≤ A n
+reverse : Vec≤ A n → Vec≤ A n
 reverse (v , p) = Vec.reverse v , p
 
 -- Align and Zip.
 
-alignWith : (These A B → C) → ∀ {n} → Vec≤ A n → Vec≤ B n → Vec≤ C n
-alignWith f (as , p) (bs , q) = Vec.alignWith f as bs , ℕₚ.⊔-lub p q
+alignWith : (These A B → C) → Vec≤ A n → Vec≤ B n → Vec≤ C n
+alignWith f (as , p) (bs , q) = Vec.alignWith f as bs , ℕ.⊔-lub p q
 
-zipWith : (A → B → C) → ∀ {n} → Vec≤ A n → Vec≤ B n → Vec≤ C n
-zipWith f (as , p) (bs , q) = Vec.restrictWith f as bs , ℕₚ.m≤n⇒m⊓o≤n _ p
+zipWith : (A → B → C) → Vec≤ A n → Vec≤ B n → Vec≤ C n
+zipWith f (as , p) (bs , q) = Vec.restrictWith f as bs , ℕ.m≤n⇒m⊓o≤n _ p
 
-zip : ∀ {n} → Vec≤ A n → Vec≤ B n → Vec≤ (A × B) n
+zip : Vec≤ A n → Vec≤ B n → Vec≤ (A × B) n
 zip = zipWith _,_
 
-align : ∀ {n} → Vec≤ A n → Vec≤ B n → Vec≤ (These A B) n
+align : Vec≤ A n → Vec≤ B n → Vec≤ (These A B) n
 align = alignWith id
 
 -- take and drop
 
-take : ∀ {m} n → Vec≤ A m → Vec≤ A (n ⊓ m)
+take : ∀ n → Vec≤ A m → Vec≤ A (n ⊓ m)
 take             zero    _                = []
 take             (suc n) (Vec.[] , p)     = []
-take {m = suc m} (suc n) (a Vec.∷ as , p) = a ∷ take n (as , ℕₚ.≤-pred p)
+take {m = suc m} (suc n) (a Vec.∷ as , p) = a ∷ take n (as , s≤s⁻¹ p)
 
-drop : ∀ {m} n → Vec≤ A m → Vec≤ A (m ∸ n)
+drop : ∀ n → Vec≤ A m → Vec≤ A (m ∸ n)
 drop             zero    v                = v
 drop             (suc n) (Vec.[] , p)     = []
-drop {m = suc m} (suc n) (a Vec.∷ as , p) = drop n (as , ℕₚ.≤-pred p)
+drop {m = suc m} (suc n) (a Vec.∷ as , p) = drop n (as , s≤s⁻¹ p)
 
 ------------------------------------------------------------------------
 -- Lifting a collection of bounded vectors to the same size
@@ -149,7 +156,7 @@ rectangle {A = A} rows = width , padded where
   width = max 0 sizes
 
   all≤ : All (λ v → proj₁ v ≤ width) rows
-  all≤ = Allₚ.map⁻ (xs≤max 0 sizes)
+  all≤ = All.map⁻ (xs≤max 0 sizes)
 
   padded : List (Vec≤ A width)
   padded = mapWith∈ rows $ λ {x} x∈rows →
diff --git a/src/Data/Vec/Bounded/Show.agda b/src/Data/Vec/Bounded/Show.agda
new file mode 100644
index 0000000000..dae5f6ec3d
--- /dev/null
+++ b/src/Data/Vec/Bounded/Show.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Showing bounded vectors
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Vec.Bounded.Show where
+
+open import Data.String.Base using (String)
+open import Data.Vec.Bounded.Base using (Vec≤)
+import Data.Vec.Show as Vec
+open import Function.Base using (_∘_)
+
+show : ∀ {a} {A : Set a} {n} → (A → String) → (Vec≤ A n → String)
+show s = Vec.show s ∘ Vec≤.vec
diff --git a/src/Data/Vec/Categorical.agda b/src/Data/Vec/Categorical.agda
new file mode 100644
index 0000000000..aaad325cac
--- /dev/null
+++ b/src/Data/Vec/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Vec.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Vec.Categorical where
+
+open import Data.Vec.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Data.Vec.Categorical was deprecated in v2.0.
+Use Data.Vec.Effectful instead."
+#-}
diff --git a/src/Data/Vec/Categorical/Transformer.agda b/src/Data/Vec/Categorical/Transformer.agda
new file mode 100644
index 0000000000..9d90b030f7
--- /dev/null
+++ b/src/Data/Vec/Categorical/Transformer.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Vec.Effectful.Transformer` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Vec.Categorical.Transformer where
+
+open import Data.Vec.Effectful.Transformer public
+
+{-# WARNING_ON_IMPORT
+"Data.Vec.Categorical.Transformer was deprecated in v2.0.
+Use Data.Vec.Effectful.Transformer instead."
+#-}
diff --git a/src/Data/Vec/Effectful.agda b/src/Data/Vec/Effectful.agda
index aa1f6dcba7..1ff96bd03c 100644
--- a/src/Data/Vec/Effectful.agda
+++ b/src/Data/Vec/Effectful.agda
@@ -14,9 +14,9 @@ open import Data.Vec.Base as Vec hiding (_⊛_)
 open import Data.Vec.Properties
 open import Effect.Applicative as App using (RawApplicative)
 open import Effect.Functor as Fun using (RawFunctor)
-open import Effect.Monad using (RawMonad; RawMonadT; mkRawMonad)
+open import Effect.Monad using (RawMonad; module Join; RawMonadT; mkRawMonad)
 import Function.Identity.Effectful as Id
-open import Function hiding (Morphism)
+open import Function.Base
 open import Level using (Level)
 
 private
@@ -34,9 +34,9 @@ functor = record
   }
 
 applicative : RawApplicative (λ (A : Set a) → Vec A n)
-applicative = record
+applicative {n = n} = record
   { rawFunctor = functor
-  ; pure = replicate
+  ; pure = replicate n
   ; _<*>_  = Vec._⊛_
   }
 
@@ -46,6 +46,9 @@ monad = record
   ; _>>=_ = DiagonalBind._>>=_
   }
 
+join : Vec (Vec A n) n → Vec A n
+join = Join.join monad
+
 ------------------------------------------------------------------------
 -- Get access to other monadic functions
 
diff --git a/src/Data/Vec/Effectful/Transformer.agda b/src/Data/Vec/Effectful/Transformer.agda
index 9c3847f40e..637ec0b2ec 100644
--- a/src/Data/Vec/Effectful/Transformer.agda
+++ b/src/Data/Vec/Effectful/Transformer.agda
@@ -40,7 +40,7 @@ functor M = record
 applicative : RawApplicative M → RawApplicative {f} (VecT n M)
 applicative M = record
   { rawFunctor = functor rawFunctor
-  ; pure = mkVecT ∘′ pure ∘′ Vec.replicate
+  ; pure = mkVecT ∘′ pure ∘′ Vec.replicate _
   ; _<*>_  = λ mf ma → mkVecT (Vec.zipWith _$_ <$> runVecT mf <*> runVecT ma)
   } where open RawApplicative M
 
@@ -50,11 +50,11 @@ monad {f} {g} M = record
   ; _>>=_ = λ ma k → mkVecT $ do
                       a ← runVecT ma
                       bs ← mapM {a = f} (runVecT ∘′ k) a
-                      pure (Vec.DiagonalBind.join bs)
+                      pure (Vec.diagonal bs)
   } where open RawMonad M; open Vec.TraversableM {m = f} {n = g} M
 
 monadT : RawMonadT {f} {g} (VecT n)
 monadT M = record
-  { lift = mkVecT ∘′ (Vec.replicate <$>_)
+  { lift = mkVecT ∘′ (Vec.replicate _ <$>_)
   ; rawMonad = monad M
   } where open RawMonad M
diff --git a/src/Data/Vec/Functional.agda b/src/Data/Vec/Functional.agda
index 26e8f32160..776fedee3b 100644
--- a/src/Data/Vec/Functional.agda
+++ b/src/Data/Vec/Functional.agda
@@ -18,10 +18,10 @@ module Data.Vec.Functional where
 open import Data.Fin.Base
 open import Data.List.Base as L using (List)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc; NonZero; pred)
-open import Data.Product using (Σ; ∃; _×_; _,_; proj₁; proj₂; uncurry)
+open import Data.Product.Base using (Σ; ∃; _×_; _,_; proj₁; proj₂; uncurry)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_])
 open import Data.Vec.Base as V using (Vec)
-open import Function.Base
+open import Function.Base using (_∘_; const; flip; _ˢ_; id)
 open import Level using (Level)
 
 infixr 5 _∷_ _++_
@@ -31,9 +31,8 @@ infixl 1 _>>=_
 private
   variable
     a b c : Level
-    A : Set a
-    B : Set b
-    C : Set c
+    A B C : Set a
+    m n : ℕ
 
 ------------------------------------------------------------------------
 -- Definition
@@ -44,13 +43,13 @@ Vector A n = Fin n → A
 ------------------------------------------------------------------------
 -- Conversion
 
-toVec : ∀ {n} → Vector A n → Vec A n
+toVec : Vector A n → Vec A n
 toVec = V.tabulate
 
-fromVec : ∀ {n} → Vec A n → Vector A n
+fromVec : Vec A n → Vector A n
 fromVec = V.lookup
 
-toList : ∀ {n} → Vector A n → List A
+toList : Vector A n → List A
 toList = L.tabulate
 
 fromList : ∀ (xs : List A) → Vector A (L.length xs)
@@ -62,39 +61,39 @@ fromList = L.lookup
 [] : Vector A zero
 [] ()
 
-_∷_ : ∀ {n} → A → Vector A n → Vector A (suc n)
+_∷_ : A → Vector A n → Vector A (suc n)
 (x ∷ xs) zero    = x
 (x ∷ xs) (suc i) = xs i
 
-length : ∀ {n} → Vector A n → ℕ
+length : Vector A n → ℕ
 length {n = n} _ = n
 
-head : ∀ {n} → Vector A (suc n) → A
+head : Vector A (suc n) → A
 head xs = xs zero
 
-tail : ∀ {n} → Vector A (suc n) → Vector A n
+tail : Vector A (suc n) → Vector A n
 tail xs = xs ∘ suc
 
-uncons : ∀ {n} → Vector A (suc n) → A × Vector A n
+uncons : Vector A (suc n) → A × Vector A n
 uncons xs = head xs , tail xs
 
-replicate : ∀ {n} → A → Vector A n
-replicate = const
+replicate : (n : ℕ) → A → Vector A n
+replicate n = const
 
-insert : ∀ {n} → Vector A n → Fin (suc n) → A → Vector A (suc n)
-insert {n = n}     xs zero    v zero    = v
-insert {n = n}     xs zero    v (suc j) = xs j
-insert {n = suc n} xs (suc i) v zero    = head xs
-insert {n = suc n} xs (suc i) v (suc j) = insert (tail xs) i v j
+insertAt : Vector A n → Fin (suc n) → A → Vector A (suc n)
+insertAt {n = n}     xs zero    v zero    = v
+insertAt {n = n}     xs zero    v (suc j) = xs j
+insertAt {n = suc n} xs (suc i) v zero    = head xs
+insertAt {n = suc n} xs (suc i) v (suc j) = insertAt (tail xs) i v j
 
-remove : ∀ {n} → Fin (suc n) → Vector A (suc n) → Vector A n
-remove i t = t ∘ punchIn i
+removeAt : Vector A (suc n) → Fin (suc n) → Vector A n
+removeAt t i = t ∘ punchIn i
 
-updateAt : ∀ {n} → Fin n → (A → A) → Vector A n → Vector A n
-updateAt {n = suc n} zero    f xs zero    = f (head xs)
-updateAt {n = suc n} zero    f xs (suc j) = xs (suc j)
-updateAt {n = suc n} (suc i) f xs zero    = head xs
-updateAt {n = suc n} (suc i) f xs (suc j) = updateAt i f (tail xs) j
+updateAt : Vector A n → Fin n → (A → A) → Vector A n
+updateAt {n = suc n} xs zero    f zero    = f (head xs)
+updateAt {n = suc n} xs zero    f (suc j) = xs (suc j)
+updateAt {n = suc n} xs (suc i) f zero    = head xs
+updateAt {n = suc n} xs (suc i) f (suc j) = updateAt (tail xs) i f j
 
 ------------------------------------------------------------------------
 -- Transformations
@@ -102,10 +101,10 @@ updateAt {n = suc n} (suc i) f xs (suc j) = updateAt i f (tail xs) j
 map : (A → B) → ∀ {n} → Vector A n → Vector B n
 map f xs = f ∘ xs
 
-_++_ : ∀ {m n} → Vector A m → Vector A n → Vector A (m ℕ.+ n)
+_++_ : Vector A m → Vector A n → Vector A (m ℕ.+ n)
 _++_ {m = m} xs ys i = [ xs , ys ] (splitAt m i)
 
-concat : ∀ {m n} → Vector (Vector A m) n → Vector A (n ℕ.* m)
+concat : Vector (Vector A m) n → Vector A (n ℕ.* m)
 concat {m = m} xss i = uncurry (flip xss) (quotRem m i)
 
 foldr : (A → B → B) → B → ∀ {n} → Vector A n → B
@@ -116,25 +115,25 @@ foldl : (B → A → B) → B → ∀ {n} → Vector A n → B
 foldl f z {n = zero}  xs = z
 foldl f z {n = suc n} xs = foldl f (f z (head xs)) (tail xs)
 
-rearrange : ∀ {m n} → (Fin m → Fin n) → Vector A n → Vector A m
+rearrange : (Fin m → Fin n) → Vector A n → Vector A m
 rearrange r xs = xs ∘ r
 
-_⊛_ : ∀ {n} → Vector (A → B) n → Vector A n → Vector B n
+_⊛_ : Vector (A → B) n → Vector A n → Vector B n
 _⊛_ = _ˢ_
 
-_>>=_ : ∀ {m n} → Vector A m → (A → Vector B n) → Vector B (m ℕ.* n)
+_>>=_ : Vector A m → (A → Vector B n) → Vector B (m ℕ.* n)
 xs >>= f = concat (map f xs)
 
 zipWith : (A → B → C) → ∀ {n} → Vector A n → Vector B n → Vector C n
 zipWith f xs ys i = f (xs i) (ys i)
 
-unzipWith : ∀ {n} → (A → B × C) → Vector A n → Vector B n × Vector C n
+unzipWith : (A → B × C) → Vector A n → Vector B n × Vector C n
 unzipWith f xs = proj₁ ∘ f ∘ xs , proj₂ ∘ f ∘ xs
 
-zip : ∀ {n} → Vector A n → Vector B n → Vector (A × B) n
+zip : Vector A n → Vector B n → Vector (A × B) n
 zip = zipWith _,_
 
-unzip : ∀ {n} → Vector (A × B) n → Vector A n × Vector B n
+unzip : Vector (A × B) n → Vector A n × Vector B n
 unzip = unzipWith id
 
 take : ∀ m {n} → Vector A (m ℕ.+ n) → Vector A m
@@ -143,14 +142,35 @@ take _ {n = n} xs = xs ∘ (_↑ˡ n)
 drop : ∀ m {n} → Vector A (m ℕ.+ n) → Vector A n
 drop m xs = xs ∘ (m ↑ʳ_)
 
-reverse : ∀ {n} → Vector A n → Vector A n
+reverse : Vector A n → Vector A n
 reverse xs = xs ∘ opposite
 
-init : ∀ {n} → Vector A (suc n) → Vector A n
+init : Vector A (suc n) → Vector A n
 init xs = xs ∘ inject₁
 
-last : ∀ {n} → Vector A (suc n) → A
+last : Vector A (suc n) → A
 last {n = n} xs = xs (fromℕ n)
 
-transpose : ∀ {m n} → Vector (Vector A n) m → Vector (Vector A m) n
+transpose : Vector (Vector A n) m → Vector (Vector A m) n
 transpose = flip
+
+------------------------------------------------------------------------
+-- DEPRECATED
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
+
+remove : Fin (suc n) → Vector A (suc n) → Vector A n
+remove = flip removeAt
+{-# WARNING_ON_USAGE remove
+"Warning: remove was deprecated in v2.0.
+Please use removeAt instead.
+NOTE: argument order has been flipped."
+#-}
+insert = insertAt
+{-# WARNING_ON_USAGE insert
+"Warning: insert was deprecated in v2.0.
+Please use insertAt instead."
+#-}
diff --git a/src/Data/Vec/Functional/Properties.agda b/src/Data/Vec/Functional/Properties.agda
index 0d2d08da83..954f56c0d3 100644
--- a/src/Data/Vec/Functional/Properties.agda
+++ b/src/Data/Vec/Functional/Properties.agda
@@ -9,20 +9,25 @@
 module Data.Vec.Functional.Properties where
 
 open import Data.Empty using (⊥-elim)
-open import Data.Fin.Base
-open import Data.Nat as ℕ
-import Data.Nat.Properties as ℕₚ
-open import Data.Product as Product using (_×_; _,_; proj₁; proj₂)
-open import Data.List as L using (List)
-import Data.List.Properties as Lₚ
+open import Data.Fin.Base using (Fin; zero; suc; toℕ; fromℕ<; reduce≥;
+  _↑ˡ_; _↑ʳ_; punchIn; punchOut)
+open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
+import Data.Nat.Properties as ℕ
+open import Data.Product.Base as Product using (_×_; _,_; proj₁; proj₂)
+open import Data.List.Base as List using (List)
+import Data.List.Properties as List
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
-open import Data.Vec as V using (Vec)
-import Data.Vec.Properties as Vₚ
-open import Data.Vec.Functional
-open import Function.Base
+open import Data.Vec.Base as Vec using (Vec)
+import Data.Vec.Properties as Vec
+open import Data.Vec.Functional using (Vector; head; tail; updateAt;
+  map; _++_; insertAt; removeAt; toVec; fromVec; toList; fromList)
+open import Function.Base using (_∘_; id)
 open import Level using (Level)
-open import Relation.Binary as B
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Definitions using (DecidableEquality; Decidable)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≗_; refl; _≢_; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Relation.Nullary.Decidable
   using (Dec; does; yes; no; map′; _×-dec_)
 
@@ -31,13 +36,12 @@ import Data.Fin.Properties as Finₚ
 private
   variable
     a b c : Level
-    A : Set a
-    B : Set b
-    C : Set c
+    A B C : Set a
+    m n : ℕ
 
 ------------------------------------------------------------------------
 
-module _ {n} {xs ys : Vector A (suc n)} where
+module _ {xs ys : Vector A (suc n)} where
 
   ∷-cong : head xs ≡ head ys → tail xs ≗ tail ys → xs ≗ ys
   ∷-cong eq _ zero    = eq
@@ -46,10 +50,9 @@ module _ {n} {xs ys : Vector A (suc n)} where
   ∷-injective : xs ≗ ys → head xs ≡ head ys × tail xs ≗ tail ys
   ∷-injective eq = eq zero , eq ∘ suc
 
-≗-dec : B.DecidableEquality A →
-        ∀ {n} → B.Decidable {A = Vector A n} _≗_
-≗-dec _≟_ {zero}  xs ys = yes λ ()
-≗-dec _≟_ {suc n} xs ys =
+≗-dec : DecidableEquality A → Decidable {A = Vector A n} _≗_
+≗-dec {n = zero}  _≟_ xs ys = yes λ ()
+≗-dec {n = suc n} _≟_ xs ys =
   map′ (Product.uncurry ∷-cong) ∷-injective
        (head xs ≟ head ys ×-dec ≗-dec _≟_ (tail xs) (tail ys))
 
@@ -58,15 +61,15 @@ module _ {n} {xs ys : Vector A (suc n)} where
 
 -- (+) updateAt i actually updates the element at index i.
 
-updateAt-updates : ∀ {n} (i : Fin n) {f : A → A} (xs : Vector A n) →
-                   updateAt i f xs i ≡ f (xs i)
+updateAt-updates : ∀ (i : Fin n) {f : A → A} (xs : Vector A n) →
+                   updateAt xs i f i ≡ f (xs i)
 updateAt-updates zero    xs = refl
 updateAt-updates (suc i) xs = updateAt-updates i (tail xs)
 
 -- (-) updateAt i does not touch the elements at other indices.
 
-updateAt-minimal : ∀ {n} (i j : Fin n) {f : A → A} (xs : Vector A n) →
-                   i ≢ j → updateAt j f xs i ≡ xs i
+updateAt-minimal : ∀ (i j : Fin n) {f : A → A} (xs : Vector A n) →
+                   i ≢ j → updateAt xs j f i ≡ xs i
 updateAt-minimal zero    zero    xs 0≢0 = ⊥-elim (0≢0 refl)
 updateAt-minimal zero    (suc j) xs _   = refl
 updateAt-minimal (suc i) zero    xs _   = refl
@@ -74,46 +77,46 @@ updateAt-minimal (suc i) (suc j) xs i≢j = updateAt-minimal i j (tail xs) (i≢
 
 -- updateAt i is a monoid morphism from A → A to Vector A n → Vector A n.
 
-updateAt-id-local : ∀ {n} (i : Fin n) {f : A → A} (xs : Vector A n) →
+updateAt-id-local : ∀ (i : Fin n) {f : A → A} (xs : Vector A n) →
                     f (xs i) ≡ xs i →
-                    updateAt i f xs ≗ xs
+                    updateAt xs i f ≗ xs
 updateAt-id-local zero    xs eq zero    = eq
 updateAt-id-local zero    xs eq (suc j) = refl
 updateAt-id-local (suc i) xs eq zero    = refl
 updateAt-id-local (suc i) xs eq (suc j) = updateAt-id-local i (tail xs) eq j
 
-updateAt-id : ∀ {n} (i : Fin n) (xs : Vector A n) →
-              updateAt i id xs ≗ xs
+updateAt-id : ∀ (i : Fin n) (xs : Vector A n) →
+              updateAt xs i id ≗ xs
 updateAt-id i xs = updateAt-id-local i xs refl
 
-updateAt-∘-local : ∀ {n} (i : Fin n) {f g h : A → A} (xs : Vector A n) →
-                   f (g (xs i)) ≡ h (xs i) →
-                   updateAt i f (updateAt i g xs) ≗ updateAt i h xs
-updateAt-∘-local zero    xs eq zero    = eq
-updateAt-∘-local zero    xs eq (suc j) = refl
-updateAt-∘-local (suc i) xs eq zero    = refl
-updateAt-∘-local (suc i) xs eq (suc j) = updateAt-∘-local i (tail xs) eq j
+updateAt-updateAt-local : ∀ (i : Fin n) {f g h : A → A} (xs : Vector A n) →
+                          f (g (xs i)) ≡ h (xs i) →
+                          updateAt (updateAt xs i g) i f ≗ updateAt xs i h
+updateAt-updateAt-local zero    xs eq zero    = eq
+updateAt-updateAt-local zero    xs eq (suc j) = refl
+updateAt-updateAt-local (suc i) xs eq zero    = refl
+updateAt-updateAt-local (suc i) xs eq (suc j) = updateAt-updateAt-local i (tail xs) eq j
 
-updateAt-∘ : ∀ {n} (i : Fin n) {f g : A → A} (xs : Vector A n) →
-             updateAt i f (updateAt i g xs) ≗ updateAt i (f ∘ g) xs
-updateAt-∘ i xs = updateAt-∘-local i xs refl
+updateAt-updateAt : ∀ (i : Fin n) {f g : A → A} (xs : Vector A n) →
+                    updateAt (updateAt xs i g) i f ≗ updateAt xs i (f ∘ g)
+updateAt-updateAt i xs = updateAt-updateAt-local i xs refl
 
-updateAt-cong-local : ∀ {n} (i : Fin n) {f g : A → A} (xs : Vector A n) →
+updateAt-cong-local : ∀ (i : Fin n) {f g : A → A} (xs : Vector A n) →
                       f (xs i) ≡ g (xs i) →
-                      updateAt i f xs ≗ updateAt i g xs
+                      updateAt xs i f ≗ updateAt xs i g
 updateAt-cong-local zero    xs eq zero    = eq
 updateAt-cong-local zero    xs eq (suc j) = refl
 updateAt-cong-local (suc i) xs eq zero    = refl
 updateAt-cong-local (suc i) xs eq (suc j) = updateAt-cong-local i (tail xs) eq j
 
-updateAt-cong : ∀ {n} (i : Fin n) {f g : A → A} →
-                f ≗ g → (xs : Vector A n) → updateAt i f xs ≗ updateAt i g xs
+updateAt-cong : ∀ (i : Fin n) {f g : A → A} → f ≗ g → (xs : Vector A n) →
+                updateAt xs i f ≗ updateAt xs i g
 updateAt-cong i eq xs = updateAt-cong-local i xs (eq (xs i))
 
 -- The order of updates at different indices i ≢ j does not matter.
 
-updateAt-commutes : ∀ {n} (i j : Fin n) {f g : A → A} → i ≢ j → (xs : Vector A n) →
-                    updateAt i f (updateAt j g xs) ≗ updateAt j g (updateAt i f xs)
+updateAt-commutes : ∀ (i j : Fin n) {f g : A → A} → i ≢ j → (xs : Vector A n) →
+                    updateAt (updateAt xs j g) i f ≗ updateAt (updateAt xs i f) j g
 updateAt-commutes zero    zero    0≢0 xs k       = ⊥-elim (0≢0 refl)
 updateAt-commutes zero    (suc j) _   xs zero    = refl
 updateAt-commutes zero    (suc j) _   xs (suc k) = refl
@@ -125,146 +128,145 @@ updateAt-commutes (suc i) (suc j) i≢j xs (suc k) = updateAt-commutes i j (i≢
 ------------------------------------------------------------------------
 -- map
 
-map-id : ∀ {n} → (xs : Vector A n) → map id xs ≗ xs
+map-id : (xs : Vector A n) → map id xs ≗ xs
 map-id xs = λ _ → refl
 
-map-cong : ∀ {n} {f g : A → B} → f ≗ g → (xs : Vector A n) → map f xs ≗ map g xs
+map-cong : ∀ {f g : A → B} → f ≗ g → (xs : Vector A n) → map f xs ≗ map g xs
 map-cong f≗g xs = f≗g ∘ xs
 
-map-∘ : ∀ {n} {f : B → C} {g : A → B} →
-        (xs : Vector A n) → map (f ∘ g) xs ≗ map f (map g xs)
+map-∘ : ∀ {f : B → C} {g : A → B} (xs : Vector A n) →
+        map (f ∘ g) xs ≗ map f (map g xs)
 map-∘ xs = λ _ → refl
 
-lookup-map : ∀ {n} (i : Fin n) (f : A → B) (xs : Vector A n) →
+lookup-map : ∀ (i : Fin n) (f : A → B) (xs : Vector A n) →
              map f xs i ≡ f (xs i)
 lookup-map i f xs = refl
 
-map-updateAt-local : ∀ {n} {f : A → B} {g : A → A} {h : B → B}
+map-updateAt-local : ∀ {f : A → B} {g : A → A} {h : B → B}
                      (xs : Vector A n) (i : Fin n) →
                      f (g (xs i)) ≡ h (f (xs i)) →
-                     map f (updateAt i g xs) ≗ updateAt i h (map f xs)
+                     map f (updateAt xs i g) ≗ updateAt (map f xs) i h
 map-updateAt-local {n = suc n}       {f = f} xs zero    eq zero    = eq
 map-updateAt-local {n = suc n}       {f = f} xs zero    eq (suc j) = refl
 map-updateAt-local {n = suc (suc n)} {f = f} xs (suc i) eq zero    = refl
 map-updateAt-local {n = suc (suc n)} {f = f} xs (suc i) eq (suc j) = map-updateAt-local {f = f} (tail xs) i eq j
 
-map-updateAt : ∀ {n} {f : A → B} {g : A → A} {h : B → B} →
+map-updateAt : ∀ {f : A → B} {g : A → A} {h : B → B} →
                f ∘ g ≗ h ∘ f →
                (xs : Vector A n) (i : Fin n) →
-               map f (updateAt i g xs) ≗ updateAt i h (map f xs)
+               map f (updateAt xs i g) ≗ updateAt (map f xs) i h
 map-updateAt {f = f} {g = g} f∘g≗h∘f xs i = map-updateAt-local {f = f} {g = g} xs i (f∘g≗h∘f (xs i))
 
 ------------------------------------------------------------------------
 -- _++_
 
-lookup-++-< : ∀ {m n} (xs : Vector A m) (ys : Vector A n) →
+lookup-++-< : ∀ (xs : Vector A m) (ys : Vector A n) →
               ∀ i (i<m : toℕ i ℕ.< m) →
               (xs ++ ys) i ≡ xs (fromℕ< i<m)
 lookup-++-< {m = m} xs ys i i<m = cong Sum.[ xs , ys ] (Finₚ.splitAt-< m i i<m)
 
-lookup-++-≥ : ∀ {m n} (xs : Vector A m) (ys : Vector A n) →
+lookup-++-≥ : ∀ (xs : Vector A m) (ys : Vector A n) →
               ∀ i (i≥m : toℕ i ℕ.≥ m) →
               (xs ++ ys) i ≡ ys (reduce≥ i i≥m)
 lookup-++-≥ {m = m} xs ys i i≥m = cong Sum.[ xs , ys ] (Finₚ.splitAt-≥ m i i≥m)
 
-lookup-++ˡ : ∀ {m n} (xs : Vector A m) (ys : Vector A n) i →
+lookup-++ˡ : ∀ (xs : Vector A m) (ys : Vector A n) i →
              (xs ++ ys) (i ↑ˡ n) ≡ xs i
 lookup-++ˡ {m = m} {n = n} xs ys i = cong Sum.[ xs , ys ] (Finₚ.splitAt-↑ˡ m i n)
 
-lookup-++ʳ : ∀ {m n} (xs : Vector A m) (ys : Vector A n) i →
+lookup-++ʳ : ∀ (xs : Vector A m) (ys : Vector A n) i →
              (xs ++ ys) (m ↑ʳ i) ≡ ys i
 lookup-++ʳ {m = m} {n = n} xs ys i = cong Sum.[ xs , ys ] (Finₚ.splitAt-↑ʳ m n i)
 
-module _ {m} {ys ys′ : Vector A m} where
+module _ {ys ys′ : Vector A m} where
 
-  ++-cong : ∀ {n} (xs xs′ : Vector A n) →
+  ++-cong : ∀ (xs xs′ : Vector A n) →
             xs ≗ xs′ → ys ≗ ys′ → xs ++ ys ≗ xs′ ++ ys′
-  ++-cong {n} xs xs′ eq₁ eq₂ i with toℕ i ℕₚ.<? n
+  ++-cong {n} xs xs′ eq₁ eq₂ i with toℕ i ℕ.<? n
   ... | yes i<n = begin
     (xs ++ ys) i      ≡⟨ lookup-++-< xs ys i i<n ⟩
     xs (fromℕ< i<n)   ≡⟨ eq₁ (fromℕ< i<n) ⟩
-    xs′ (fromℕ< i<n)  ≡˘⟨ lookup-++-< xs′ ys′ i i<n ⟩
+    xs′ (fromℕ< i<n)  ≡⟨ lookup-++-< xs′ ys′ i i<n ⟨
     (xs′ ++ ys′) i    ∎
     where open ≡-Reasoning
   ... | no i≮n = begin
-    (xs ++ ys) i               ≡⟨ lookup-++-≥ xs ys i (ℕₚ.≮⇒≥ i≮n) ⟩
-    ys (reduce≥ i (ℕₚ.≮⇒≥ i≮n))   ≡⟨ eq₂ (reduce≥ i (ℕₚ.≮⇒≥ i≮n)) ⟩
-    ys′ (reduce≥ i (ℕₚ.≮⇒≥ i≮n))  ≡˘⟨ lookup-++-≥ xs′ ys′ i (ℕₚ.≮⇒≥ i≮n) ⟩
+    (xs ++ ys) i               ≡⟨ lookup-++-≥ xs ys i (ℕ.≮⇒≥ i≮n) ⟩
+    ys (reduce≥ i (ℕ.≮⇒≥ i≮n))   ≡⟨ eq₂ (reduce≥ i (ℕ.≮⇒≥ i≮n)) ⟩
+    ys′ (reduce≥ i (ℕ.≮⇒≥ i≮n))  ≡⟨ lookup-++-≥ xs′ ys′ i (ℕ.≮⇒≥ i≮n) ⟨
     (xs′ ++ ys′) i             ∎
     where open ≡-Reasoning
 
-  ++-injectiveˡ : ∀ {n} (xs xs′ : Vector A n) →
+  ++-injectiveˡ : ∀ (xs xs′ : Vector A n) →
                   xs ++ ys ≗ xs′ ++ ys′ → xs ≗ xs′
   ++-injectiveˡ xs xs′ eq i = begin
-    xs i                   ≡˘⟨ lookup-++ˡ xs ys i ⟩
+    xs i                   ≡⟨ lookup-++ˡ xs ys i ⟨
     (xs ++ ys) (i ↑ˡ m)    ≡⟨ eq (i ↑ˡ m) ⟩
     (xs′ ++ ys′) (i ↑ˡ m)  ≡⟨ lookup-++ˡ xs′ ys′ i ⟩
     xs′ i                  ∎
     where open ≡-Reasoning
 
-  ++-injectiveʳ : ∀ {n} (xs xs′ : Vector A n) →
-                  xs ++ ys ≗ xs′ ++ ys′ → ys ≗ ys′
+  ++-injectiveʳ : ∀ (xs xs′ : Vector A n) → xs ++ ys ≗ xs′ ++ ys′ → ys ≗ ys′
   ++-injectiveʳ {n} xs xs′ eq i = begin
-    ys i                   ≡˘⟨ lookup-++ʳ xs ys i ⟩
+    ys i                   ≡⟨ lookup-++ʳ xs ys i ⟨
     (xs ++ ys) (n ↑ʳ i)    ≡⟨ eq (n ↑ʳ i)   ⟩
     (xs′ ++ ys′) (n ↑ʳ i)  ≡⟨ lookup-++ʳ xs′ ys′ i ⟩
     ys′ i                  ∎
     where open ≡-Reasoning
 
-  ++-injective : ∀ {n} (xs xs′ : Vector A n) →
+  ++-injective : ∀ (xs xs′ : Vector A n) →
                  xs ++ ys ≗ xs′ ++ ys′ → xs ≗ xs′ × ys ≗ ys′
   ++-injective xs xs′ eq = ++-injectiveˡ xs xs′ eq , ++-injectiveʳ xs xs′ eq
 
 ------------------------------------------------------------------------
--- insert
+-- insertAt
 
-insert-lookup : ∀ {n} (xs : Vector A n) (i : Fin (suc n)) (v : A) →
-                insert xs i v i ≡ v
-insert-lookup {n = n}     xs zero    v = refl
-insert-lookup {n = suc n} xs (suc i) v = insert-lookup (tail xs) i v
+insertAt-lookup : ∀ (xs : Vector A n) (i : Fin (suc n)) (v : A) →
+                  insertAt xs i v i ≡ v
+insertAt-lookup {n = n}     xs zero    v = refl
+insertAt-lookup {n = suc n} xs (suc i) v = insertAt-lookup (tail xs) i v
 
-insert-punchIn : ∀ {n} (xs : Vector A n) (i : Fin (suc n)) (v : A)
-                 (j : Fin n) →
-                 insert xs i v (punchIn i j) ≡ xs j
-insert-punchIn {n = suc n} xs zero    v j       = refl
-insert-punchIn {n = suc n} xs (suc i) v zero    = refl
-insert-punchIn {n = suc n} xs (suc i) v (suc j) = insert-punchIn (tail xs) i v j
+insertAt-punchIn : ∀ (xs : Vector A n) (i : Fin (suc n)) (v : A)
+                   (j : Fin n) →
+                   insertAt xs i v (punchIn i j) ≡ xs j
+insertAt-punchIn {n = suc n} xs zero    v j       = refl
+insertAt-punchIn {n = suc n} xs (suc i) v zero    = refl
+insertAt-punchIn {n = suc n} xs (suc i) v (suc j) = insertAt-punchIn (tail xs) i v j
 
 ------------------------------------------------------------------------
--- remove
+-- removeAt
 
-remove-punchOut : ∀ {n} (xs : Vector A (suc n))
+removeAt-punchOut : ∀ (xs : Vector A (suc n))
                   {i : Fin (suc n)} {j : Fin (suc n)} (i≢j : i ≢ j) →
-                  remove i xs (punchOut i≢j) ≡ xs j
-remove-punchOut {n = n}     xs {zero}  {zero}  i≢j = ⊥-elim (i≢j refl)
-remove-punchOut {n = suc n} xs {zero}  {suc j} i≢j = refl
-remove-punchOut {n = suc n} xs {suc i} {zero}  i≢j = refl
-remove-punchOut {n = suc n} xs {suc i} {suc j} i≢j = remove-punchOut (tail xs) (i≢j ∘ cong suc)
-
-remove-insert : ∀ {n} (xs : Vector A n) (i : Fin (suc n)) (v : A) →
-                remove i (insert xs i v) ≗ xs
-remove-insert xs zero    v j       = refl
-remove-insert xs (suc i) v zero    = refl
-remove-insert xs (suc i) v (suc j) = remove-insert (tail xs) i v j
-
-insert-remove : ∀ {n} (xs : Vector A (suc n)) (i : Fin (suc n)) →
-                insert (remove i xs) i (xs i) ≗ xs
-insert-remove {n = n}     xs zero    zero    = refl
-insert-remove {n = n}     xs zero    (suc j) = refl
-insert-remove {n = suc n} xs (suc i) zero    = refl
-insert-remove {n = suc n} xs (suc i) (suc j) = insert-remove (tail xs) i j
+                  removeAt xs i (punchOut i≢j) ≡ xs j
+removeAt-punchOut {n = n}     xs {zero}  {zero}  i≢j = ⊥-elim (i≢j refl)
+removeAt-punchOut {n = suc n} xs {zero}  {suc j} i≢j = refl
+removeAt-punchOut {n = suc n} xs {suc i} {zero}  i≢j = refl
+removeAt-punchOut {n = suc n} xs {suc i} {suc j} i≢j = removeAt-punchOut (tail xs) (i≢j ∘ cong suc)
+
+removeAt-insertAt : ∀ (xs : Vector A n) (i : Fin (suc n)) (v : A) →
+                    removeAt (insertAt xs i v) i ≗ xs
+removeAt-insertAt xs zero    v j       = refl
+removeAt-insertAt xs (suc i) v zero    = refl
+removeAt-insertAt xs (suc i) v (suc j) = removeAt-insertAt (tail xs) i v j
+
+insertAt-removeAt : ∀ (xs : Vector A (suc n)) (i : Fin (suc n)) →
+                    insertAt (removeAt xs i) i (xs i) ≗ xs
+insertAt-removeAt {n = n}     xs zero    zero    = refl
+insertAt-removeAt {n = n}     xs zero    (suc j) = refl
+insertAt-removeAt {n = suc n} xs (suc i) zero    = refl
+insertAt-removeAt {n = suc n} xs (suc i) (suc j) = insertAt-removeAt (tail xs) i j
 
 ------------------------------------------------------------------------
 -- Conversion functions
 
-toVec∘fromVec : ∀ {n} → (xs : Vec A n) → toVec (fromVec xs) ≡ xs
-toVec∘fromVec = Vₚ.tabulate∘lookup
+toVec∘fromVec : (xs : Vec A n) → toVec (fromVec xs) ≡ xs
+toVec∘fromVec = Vec.tabulate∘lookup
 
-fromVec∘toVec : ∀ {n} → (xs : Vector A n) → fromVec (toVec xs) ≗ xs
-fromVec∘toVec = Vₚ.lookup∘tabulate
+fromVec∘toVec : (xs : Vector A n) → fromVec (toVec xs) ≗ xs
+fromVec∘toVec = Vec.lookup∘tabulate
 
 toList∘fromList : (xs : List A) → toList (fromList xs) ≡ xs
-toList∘fromList = Lₚ.tabulate-lookup
+toList∘fromList = List.tabulate-lookup
 
 ------------------------------------------------------------------------
 -- DEPRECATED NAMES
@@ -279,21 +281,44 @@ updateAt-id-relative = updateAt-id-local
 "Warning: updateAt-id-relative was deprecated in v2.0.
 Please use updateAt-id-local instead."
 #-}
-
-updateAt-compose-relative = updateAt-∘-local
+updateAt-compose-relative = updateAt-updateAt-local
 {-# WARNING_ON_USAGE updateAt-compose-relative
 "Warning: updateAt-compose-relative was deprecated in v2.0.
-Please use updateAt-∘-local instead."
+Please use updateAt-updateAt-local instead."
 #-}
-
-updateAt-compose = updateAt-∘
+updateAt-compose = updateAt-updateAt
 {-# WARNING_ON_USAGE updateAt-compose
 "Warning: updateAt-compose was deprecated in v2.0.
-Please use updateAt-∘ instead."
+Please use updateAt-updateAt instead."
 #-}
-
 updateAt-cong-relative = updateAt-cong-local
 {-# WARNING_ON_USAGE updateAt-cong-relative
 "Warning: updateAt-cong-relative was deprecated in v2.0.
 Please use updateAt-cong-local instead."
 #-}
+
+insert-lookup = insertAt-lookup
+{-# WARNING_ON_USAGE insert-lookup
+"Warning: insert-lookup was deprecated in v2.0.
+Please use insertAt-lookup instead."
+#-}
+insert-punchIn = insertAt-punchIn
+{-# WARNING_ON_USAGE insert-punchIn
+"Warning: insert-punchIn was deprecated in v2.0.
+Please use insertAt-punchIn instead."
+#-}
+remove-punchOut = removeAt-punchOut
+{-# WARNING_ON_USAGE remove-punchOut
+"Warning: remove-punchOut was deprecated in v2.0.
+Please use removeAt-punchOut instead."
+#-}
+remove-insert = removeAt-insertAt
+{-# WARNING_ON_USAGE remove-insert
+"Warning: remove-insert was deprecated in v2.0.
+Please use removeAt-insertAt instead."
+#-}
+insert-remove = insertAt-removeAt
+{-# WARNING_ON_USAGE insert-remove
+"Warning: insert-remove was deprecated in v2.0.
+Please use insertAt-removeAt instead."
+#-}
diff --git a/src/Data/Vec/Functional/Relation/Binary/Equality/Setoid.agda b/src/Data/Vec/Functional/Relation/Binary/Equality/Setoid.agda
index 932ac19c95..1102985013 100644
--- a/src/Data/Vec/Functional/Relation/Binary/Equality/Setoid.agda
+++ b/src/Data/Vec/Functional/Relation/Binary/Equality/Setoid.agda
@@ -7,13 +7,17 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Data.Nat.Base using (ℕ)
-open import Data.Vec.Functional as VF hiding (map)
+open import Data.Vec.Functional hiding (map)
 open import Data.Vec.Functional.Relation.Binary.Pointwise
   using (Pointwise)
 import Data.Vec.Functional.Relation.Binary.Pointwise.Properties as PW
 open import Level using (Level)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 module Data.Vec.Functional.Relation.Binary.Equality.Setoid
   {a ℓ} (S : Setoid a ℓ) where
@@ -24,6 +28,8 @@ open Setoid S renaming (Carrier to A)
 -- Definition
 ------------------------------------------------------------------------
 
+infix 4 _≋_
+
 _≋_ : ∀ {n} → Vector A n → Vector A n → Set ℓ
 _≋_ = Pointwise _≈_
 
@@ -35,7 +41,7 @@ _≋_ = Pointwise _≈_
 ≋-refl {n} = PW.refl {R = _≈_} refl
 
 ≋-reflexive : ∀ {n} → _≡_ ⇒ (_≋_ {n = n})
-≋-reflexive P.refl = ≋-refl
+≋-reflexive ≡.refl = ≋-refl
 
 ≋-sym : ∀ {n} → Symmetric (_≋_ {n = n})
 ≋-sym = PW.sym {R = _≈_} sym
diff --git a/src/Data/Vec/Functional/Relation/Binary/Permutation.agda b/src/Data/Vec/Functional/Relation/Binary/Permutation.agda
new file mode 100644
index 0000000000..bc4052f215
--- /dev/null
+++ b/src/Data/Vec/Functional/Relation/Binary/Permutation.agda
@@ -0,0 +1,26 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Permutation relations over Vector
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Vec.Functional.Relation.Binary.Permutation where
+
+open import Level using (Level)
+open import Data.Product.Base using (Σ-syntax)
+open import Data.Fin.Permutation using (Permutation; _⟨$⟩ʳ_)
+open import Data.Vec.Functional using (Vector)
+open import Relation.Binary.Indexed.Heterogeneous.Core using (IRel)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+
+private
+  variable
+    a : Level
+    A : Set a
+
+infix 3 _↭_
+
+_↭_ : IRel (Vector A) _
+xs ↭ ys = Σ[ ρ ∈ Permutation _ _ ] (∀ i → xs (ρ ⟨$⟩ʳ i) ≡ ys i)
diff --git a/src/Data/Vec/Functional/Relation/Binary/Permutation/Properties.agda b/src/Data/Vec/Functional/Relation/Binary/Permutation/Properties.agda
new file mode 100644
index 0000000000..83d65ab5bb
--- /dev/null
+++ b/src/Data/Vec/Functional/Relation/Binary/Permutation/Properties.agda
@@ -0,0 +1,72 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Properties of permutation
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Vec.Functional.Relation.Binary.Permutation.Properties where
+
+open import Level using (Level)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
+open import Data.Nat.Base using (ℕ)
+open import Data.Fin.Permutation using (id; flip; _⟨$⟩ʳ_; inverseʳ; _∘ₚ_)
+open import Data.Vec.Functional using (Vector)
+open import Data.Vec.Functional.Relation.Binary.Permutation using (_↭_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; trans; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
+open import Relation.Binary.Indexed.Heterogeneous
+  using (Reflexive; Symmetric; Transitive; IsIndexedEquivalence; IndexedSetoid)
+
+private
+  variable
+    a : Level
+    A : Set a
+    n : ℕ
+    xs ys : Vector A n
+
+
+------------------------------------------------------------------------
+-- Basics
+
+↭-refl : Reflexive (Vector A) _↭_
+↭-refl = id , λ _ → refl
+
+↭-reflexive : xs ≡ ys → xs ↭ ys
+↭-reflexive refl = ↭-refl
+
+↭-sym : Symmetric (Vector A) _↭_
+proj₁ (↭-sym (xs↭ys , _)) = flip xs↭ys
+proj₂ (↭-sym {x = xs} {ys} (xs↭ys , xs↭ys≡)) i = begin
+  ys (flip xs↭ys ⟨$⟩ʳ i)              ≡⟨ xs↭ys≡ _ ⟨
+  xs (xs↭ys ⟨$⟩ʳ (flip xs↭ys ⟨$⟩ʳ i)) ≡⟨ cong xs (inverseʳ xs↭ys) ⟩
+  xs i                                ∎
+  where open ≡-Reasoning
+
+↭-trans : Transitive (Vector A) _↭_
+proj₁ (↭-trans (xs↭ys , _) (ys↭zs , _))   = ys↭zs ∘ₚ xs↭ys
+proj₂ (↭-trans (_ , xs↭ys) (_ , ys↭zs)) _ = trans (xs↭ys _) (ys↭zs _)
+
+------------------------------------------------------------------------
+-- Structure
+
+isIndexedEquivalence : IsIndexedEquivalence (Vector A) _↭_
+isIndexedEquivalence {A = A} = record
+  { refl = ↭-refl
+  ; sym = ↭-sym
+  ; trans = λ {n₁ n₂ n₃} {xs : Vector A n₁} {ys : Vector A n₂} {zs : Vector A n₃}
+              xs↭ys ys↭zs → ↭-trans {i = n₁} {i = xs} xs↭ys ys↭zs
+  }
+
+------------------------------------------------------------------------
+-- Bundle
+
+indexedSetoid : {A : Set a} → IndexedSetoid ℕ a _
+indexedSetoid {A = A} = record
+  { Carrier = Vector A
+  ; _≈_ = _↭_
+  ; isEquivalence = isIndexedEquivalence
+  }
diff --git a/src/Data/Vec/Functional/Relation/Binary/Pointwise.agda b/src/Data/Vec/Functional/Relation/Binary/Pointwise.agda
index a954853bc6..c238293aae 100644
--- a/src/Data/Vec/Functional/Relation/Binary/Pointwise.agda
+++ b/src/Data/Vec/Functional/Relation/Binary/Pointwise.agda
@@ -10,7 +10,7 @@ module Data.Vec.Functional.Relation.Binary.Pointwise where
 
 open import Data.Vec.Functional as VF hiding (map)
 open import Level using (Level)
-open import Relation.Binary
+open import Relation.Binary.Core using (REL; _⇒_)
 
 private
   variable
diff --git a/src/Data/Vec/Functional/Relation/Binary/Pointwise/Properties.agda b/src/Data/Vec/Functional/Relation/Binary/Pointwise/Properties.agda
index c0ae709b0f..777c19d745 100644
--- a/src/Data/Vec/Functional/Relation/Binary/Pointwise/Properties.agda
+++ b/src/Data/Vec/Functional/Relation/Binary/Pointwise/Properties.agda
@@ -11,7 +11,7 @@ module Data.Vec.Functional.Relation.Binary.Pointwise.Properties where
 open import Data.Fin.Base using (zero; suc; _↑ˡ_; _↑ʳ_; splitAt)
 open import Data.Fin.Properties using (all?; splitAt-↑ˡ; splitAt-↑ʳ)
 open import Data.Nat.Base using (ℕ; zero; suc)
-open import Data.Product using (_×_; _,_; proj₁; proj₂)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent
   using () renaming (Pointwise to ×-Pointwise)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_])
@@ -19,8 +19,13 @@ open import Data.Vec.Functional as VF hiding (map)
 open import Data.Vec.Functional.Relation.Binary.Pointwise
 open import Function.Base
 open import Level using (Level)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)
+open import Relation.Binary.Core using (Rel; REL)
+open import Relation.Binary.Bundles using (Setoid; DecSetoid)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Transitive; Symmetric; Decidable)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 private
   variable
@@ -137,7 +142,7 @@ module _ (R : REL A B r) where
 
 module _ {R : REL A B r} {x y n} where
 
-  replicate⁺ : R x y → Pointwise R {n = n} (replicate x) (replicate y)
+  replicate⁺ : R x y → Pointwise R {n = n} (replicate n x) (replicate n y)
   replicate⁺ = const
 
 ------------------------------------------------------------------------
@@ -167,12 +172,10 @@ module _ {R : REL A B r} {S : REL A′ B′ s} {T : REL A″ B″ t} where
 module _ {R : REL A B r} {S : REL A′ B′ s} {n xs ys xs′ ys′} where
 
   zip⁺ : Pointwise R xs ys → Pointwise S xs′ ys′ →
-         Pointwise (λ xx yy → R (proj₁ xx) (proj₁ yy) × S (proj₂ xx) (proj₂ yy))
-                   (zip xs xs′) (zip {n = n} ys ys′)
+         Pointwise (×-Pointwise R S) (zip xs xs′) (zip {n = n} ys ys′)
   zip⁺ rs ss i = rs i , ss i
 
-  zip⁻ : Pointwise (λ xx yy → R (proj₁ xx) (proj₁ yy) × S (proj₂ xx) (proj₂ yy))
-                   (zip xs xs′) (zip {n = n} ys ys′) →
+  zip⁻ : Pointwise (×-Pointwise R S) (zip xs xs′) (zip {n = n} ys ys′) →
          Pointwise R xs ys × Pointwise S xs′ ys′
   zip⁻ rss = proj₁ ∘ rss , proj₂ ∘ rss
 
diff --git a/src/Data/Vec/Functional/Relation/Unary/All.agda b/src/Data/Vec/Functional/Relation/Unary/All.agda
index 84c00eb687..56c385fae8 100644
--- a/src/Data/Vec/Functional/Relation/Unary/All.agda
+++ b/src/Data/Vec/Functional/Relation/Unary/All.agda
@@ -9,7 +9,7 @@
 module Data.Vec.Functional.Relation.Unary.All where
 
 open import Data.Fin.Properties using (all?)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Data.Vec.Functional as VF hiding (map)
 open import Level using (Level)
 open import Relation.Unary
diff --git a/src/Data/Vec/Functional/Relation/Unary/All/Properties.agda b/src/Data/Vec/Functional/Relation/Unary/All/Properties.agda
index 3de5f61679..be031a1070 100644
--- a/src/Data/Vec/Functional/Relation/Unary/All/Properties.agda
+++ b/src/Data/Vec/Functional/Relation/Unary/All/Properties.agda
@@ -8,92 +8,86 @@
 
 module Data.Vec.Functional.Relation.Unary.All.Properties where
 
+open import Data.Nat.Base using (ℕ)
 open import Data.Fin.Base using (zero; suc; _↑ˡ_; _↑ʳ_; splitAt)
 open import Data.Fin.Properties using (splitAt-↑ˡ; splitAt-↑ʳ)
-open import Data.Product as Σ using (_×_; _,_; proj₁; proj₂; uncurry)
+open import Data.Product.Base as Σ using (_×_; _,_; proj₁; proj₂; uncurry)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_])
 open import Data.Vec.Functional as VF hiding (map)
 open import Data.Vec.Functional.Relation.Unary.All
-open import Function
+open import Function.Base using (const; _∘_)
 open import Level using (Level)
 open import Relation.Unary
 
 private
   variable
-    a b c p q r ℓ : Level
-    A : Set a
-    B : Set b
-    C : Set c
+    a p ℓ : Level
+    A B C : Set a
+    P Q R : Pred A p
+    m n : ℕ
+    x y : A
+    xs ys : Vector A n
 
 ------------------------------------------------------------------------
 -- map
 
-module _ {P : Pred A p} {Q : Pred B q} {f : A → B} where
-
-  map⁺ :  (∀ {x} → P x → Q (f x)) →
-          ∀ {n xs} → All P {n = n} xs → All Q (VF.map f xs)
-  map⁺ pq ps i = pq (ps i)
+map⁺ :  ∀ {f : A → B} → (∀ {x} → P x → Q (f x)) →
+        All P xs → All Q (VF.map f xs)
+map⁺ pq ps i = pq (ps i)
 
 ------------------------------------------------------------------------
 -- replicate
 
-module _ {P : Pred A p} {x : A} {n} where
-
-  replicate⁺ : P x → All P (replicate {n = n} x)
-  replicate⁺ = const
+replicate⁺ : P x → All P (replicate n x)
+replicate⁺ = const
 
 ------------------------------------------------------------------------
 -- _⊛_
 
-module _ {P : Pred A p} {Q : Pred B q} where
-
-  ⊛⁺ : ∀ {n} {fs : Vector (A → B) n} {xs} →
-       All (λ f → ∀ {x} → P x → Q (f x)) fs → All P xs → All Q (fs ⊛ xs)
-  ⊛⁺ pqs ps i = (pqs i) (ps i)
+⊛⁺ : ∀ {fs : Vector (A → B) n} →
+     All (λ f → ∀ {x} → P x → Q (f x)) fs →
+     All P xs → All Q (fs ⊛ xs)
+⊛⁺ pqs ps i = (pqs i) (ps i)
 
 ------------------------------------------------------------------------
 -- zipWith
 
-module _ {P : Pred A p} {Q : Pred B q} {R : Pred C r} where
-
-  zipWith⁺ : ∀ {f} → (∀ {x y} → P x → Q y → R (f x y)) → ∀ {n xs ys} →
-             All P xs → All Q ys → All R (zipWith f {n = n} xs ys)
-  zipWith⁺ pqr ps qs i = pqr (ps i) (qs i)
+zipWith⁺ : ∀ {f} → (∀ {x y} → P x → Q y → R (f x y)) →
+           All P xs → All Q ys → All R (zipWith f xs ys)
+zipWith⁺ pqr ps qs i = pqr (ps i) (qs i)
 
 ------------------------------------------------------------------------
 -- zip
 
-module _ {P : Pred A p} {Q : Pred B q} {n} {xs : Vector A n} {ys} where
-
-  zip⁺ : All P xs → All Q ys → All (P ⟨×⟩ Q) (zip xs ys)
-  zip⁺ ps qs i = ps i , qs i
+zip⁺ : All P xs → All Q ys → All (P ⟨×⟩ Q) (zip xs ys)
+zip⁺ ps qs i = ps i , qs i
 
-  zip⁻ : All (P ⟨×⟩ Q) (zip xs ys) → All P xs × All Q ys
-  zip⁻ pqs = proj₁ ∘ pqs , proj₂ ∘ pqs
+zip⁻ : All (P ⟨×⟩ Q) (zip xs ys) → All P xs × All Q ys
+zip⁻ pqs = proj₁ ∘ pqs , proj₂ ∘ pqs
 
 ------------------------------------------------------------------------
 -- head
 
-head⁺ : ∀ (P : Pred A p) {n v} → All P v → P (head {n = n} v)
+head⁺ : ∀ (P : Pred A p) → All P xs → P (head xs)
 head⁺ P ps = ps zero
 
 ------------------------------------------------------------------------
 -- tail
 
-tail⁺ : ∀ (P : Pred A p) {n v} → All P v → All P (tail {n = n} v)
-tail⁺ P ps = ps ∘ suc
+tail⁺ : ∀ (P : Pred A p) → All P xs → All P (tail xs)
+tail⁺ P xs = xs ∘ suc
 
 ------------------------------------------------------------------------
 -- ++
 
-module _ (P : Pred A p) {m n} {xs : Vector A m} {ys : Vector A n} where
+module _ (P : Pred A p) {xs : Vector A m} {ys : Vector A n} where
 
   ++⁺ : All P xs → All P ys → All P (xs ++ ys)
   ++⁺ pxs pys i with splitAt m i
   ... | inj₁ i′ = pxs i′
   ... | inj₂ j′ = pys j′
 
-module _ (P : Pred A p) {m n} (xs : Vector A m) {ys : Vector A n} where
+module _ (P : Pred A p) (xs : Vector A m) {ys : Vector A n} where
 
   ++⁻ˡ : All P (xs ++ ys) → All P xs
   ++⁻ˡ ps i with ps (i ↑ˡ n)
diff --git a/src/Data/Vec/Functional/Relation/Unary/Any.agda b/src/Data/Vec/Functional/Relation/Unary/Any.agda
index 83e0e6dfb3..f41295bf04 100644
--- a/src/Data/Vec/Functional/Relation/Unary/Any.agda
+++ b/src/Data/Vec/Functional/Relation/Unary/Any.agda
@@ -11,9 +11,9 @@ module Data.Vec.Functional.Relation.Unary.Any where
 open import Data.Fin.Base using (zero; suc)
 open import Data.Fin.Properties using (any?)
 open import Data.Nat.Base
-open import Data.Product as Σ using (Σ; ∃; _×_; _,_; proj₁; proj₂)
+open import Data.Product.Base as Σ using (Σ; ∃; _×_; _,_; proj₁; proj₂)
 open import Data.Vec.Functional as VF hiding (map)
-open import Function
+open import Function.Base using (id)
 open import Level using (Level)
 open import Relation.Unary
 
diff --git a/src/Data/Vec/Membership/DecPropositional.agda b/src/Data/Vec/Membership/DecPropositional.agda
index 0b20505b4b..f7b028e11f 100644
--- a/src/Data/Vec/Membership/DecPropositional.agda
+++ b/src/Data/Vec/Membership/DecPropositional.agda
@@ -6,11 +6,12 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Decidable)
-open import Relation.Binary.PropositionalEquality using (_≡_; decSetoid)
+open import Relation.Binary.Definitions using (DecidableEquality)
 
 module Data.Vec.Membership.DecPropositional
-  {a} {A : Set a} (_≟_ : Decidable (_≡_ {A = A})) where
+  {a} {A : Set a} (_≟_ : DecidableEquality A) where
+
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
 
 ------------------------------------------------------------------------
 -- Re-export contents of propositional membership
diff --git a/src/Data/Vec/Membership/DecSetoid.agda b/src/Data/Vec/Membership/DecSetoid.agda
index 10efd977d7..fac9138660 100644
--- a/src/Data/Vec/Membership/DecSetoid.agda
+++ b/src/Data/Vec/Membership/DecSetoid.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (DecSetoid)
+open import Relation.Binary.Bundles using (DecSetoid)
 
 module Data.Vec.Membership.DecSetoid {c ℓ} (DS : DecSetoid c ℓ) where
 
diff --git a/src/Data/Vec/Membership/Propositional.agda b/src/Data/Vec/Membership/Propositional.agda
index d76cedd1d3..21213e679d 100644
--- a/src/Data/Vec/Membership/Propositional.agda
+++ b/src/Data/Vec/Membership/Propositional.agda
@@ -11,7 +11,8 @@ module Data.Vec.Membership.Propositional {a} {A : Set a} where
 
 open import Data.Vec.Base using (Vec)
 open import Data.Vec.Relation.Unary.Any using (Any)
-open import Relation.Binary.PropositionalEquality using (setoid; subst)
+open import Relation.Binary.PropositionalEquality.Core using (subst)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 
 import Data.Vec.Membership.Setoid as SetoidMembership
 
diff --git a/src/Data/Vec/Membership/Propositional/Properties.agda b/src/Data/Vec/Membership/Propositional/Properties.agda
index 8efef380d4..7ebca867ad 100644
--- a/src/Data/Vec/Membership/Propositional/Properties.agda
+++ b/src/Data/Vec/Membership/Propositional/Properties.agda
@@ -9,11 +9,11 @@
 module Data.Vec.Membership.Propositional.Properties where
 
 open import Data.Fin.Base using (Fin; zero; suc)
-open import Data.Product as Prod using (_,_; ∃; _×_; -,_)
-open import Data.Vec hiding (here; there)
+open import Data.Product.Base using (_,_; ∃; _×_; -,_; map₁; map₂)
+open import Data.Vec.Base
 open import Data.Vec.Relation.Unary.Any using (here; there)
 open import Data.List.Base using ([]; _∷_)
-open import Data.List.Relation.Unary.Any using (here; there)
+open import Data.List.Relation.Unary.Any as ListAny using (here; there)
 open import Data.Vec.Relation.Unary.Any as Any using (Any; here; there)
 open import Data.Vec.Membership.Propositional
 open import Data.List.Membership.Propositional
@@ -21,7 +21,7 @@ open import Data.List.Membership.Propositional
 open import Level using (Level)
 open import Function.Base using (_∘_; id)
 open import Relation.Unary using (Pred)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
 
 private
   variable
@@ -102,6 +102,11 @@ index-∈-lookup (suc i) (x ∷ xs) = cong suc (index-∈-lookup i xs)
 ∈-fromList⁻ {xs = _ ∷ _} (here refl)  = here refl
 ∈-fromList⁻ {xs = _ ∷ _} (there v∈xs) = there (∈-fromList⁻ v∈xs)
 
+index-∈-fromList⁺ : ∀ {v : A} {xs} → (v∈xs : v ∈ₗ xs) →
+                    Any.index (∈-fromList⁺ v∈xs) ≡ ListAny.index v∈xs
+index-∈-fromList⁺ (here refl) = refl
+index-∈-fromList⁺ (there v∈xs) = cong suc (index-∈-fromList⁺ v∈xs)
+
 ------------------------------------------------------------------------
 -- Relationship to Any
 
@@ -109,7 +114,7 @@ module _ {P : Pred A p} where
 
   fromAny : ∀ {n} {xs : Vec A n} → Any P xs → ∃ λ x → x ∈ xs × P x
   fromAny (here px) = -, here refl , px
-  fromAny (there v) = Prod.map₂ (Prod.map₁ there) (fromAny v)
+  fromAny (there v) = map₂ (map₁ there) (fromAny v)
 
   toAny : ∀ {n x} {xs : Vec A n} → x ∈ xs → P x → Any P xs
   toAny (here refl) px = here px
diff --git a/src/Data/Vec/Membership/Setoid.agda b/src/Data/Vec/Membership/Setoid.agda
index 42b4b6ffd0..cfa69e591b 100644
--- a/src/Data/Vec/Membership/Setoid.agda
+++ b/src/Data/Vec/Membership/Setoid.agda
@@ -6,15 +6,16 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Setoid; _Respects_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (_Respects_)
 
 module Data.Vec.Membership.Setoid {c ℓ} (S : Setoid c ℓ) where
 
-open import Function
+open import Function.Base using (_∘_; flip)
 open import Data.Vec.Base as Vec using (Vec; []; _∷_)
 open import Data.Vec.Relation.Unary.Any as Any
   using (Any; here; there; index)
-open import Data.Product using (∃; _×_; _,_)
+open import Data.Product.Base using (∃; _×_; _,_)
 open import Relation.Nullary.Negation using (¬_)
 open import Relation.Unary using (Pred)
 
@@ -39,6 +40,8 @@ mapWith∈ : ∀ {b} {B : Set b} {n}
 mapWith∈ []       f = []
 mapWith∈ (x ∷ xs) f = f (here refl) ∷ mapWith∈ xs (f ∘ there)
 
+infixr 5 _∷=_
+
 _∷=_ : ∀ {n} {xs : Vec A n} {x} → x ∈ xs → A → Vec A n
 _∷=_ {xs = xs} x∈xs v = xs Vec.[ index x∈xs ]≔ v
 
@@ -48,9 +51,8 @@ _∷=_ {xs = xs} x∈xs v = xs Vec.[ index x∈xs ]≔ v
 module _ {p} {P : Pred A p} where
 
   find : ∀ {n} {xs : Vec A n} → Any P xs → ∃ λ x → x ∈ xs × P x
-  find (here px)   = (_ , here refl , px)
-  find (there pxs) with find pxs
-  ... | (x , x∈xs , px) = (x , there x∈xs , px)
+  find (here px)   = _ , here refl , px
+  find (there pxs) = let x , x∈xs , px = find pxs in x , there x∈xs , px
 
   lose : P Respects _≈_ → ∀ {x n} {xs : Vec A n} → x ∈ xs → P x → Any P xs
   lose resp x∈xs px = Any.map (flip resp px) x∈xs
diff --git a/src/Data/Vec/N-ary.agda b/src/Data/Vec/N-ary.agda
index 02b6e704ba..fa8fc7589c 100644
--- a/src/Data/Vec/N-ary.agda
+++ b/src/Data/Vec/N-ary.agda
@@ -9,16 +9,15 @@
 module Data.Vec.N-ary where
 
 open import Axiom.Extensionality.Propositional using (Extensionality)
-open import Function.Bundles using (_↔_; Inverse; mk↔′)
+open import Function.Bundles using (_↔_; Inverse; mk↔ₛ′)
 open import Data.Nat.Base hiding (_⊔_)
-open import Data.Product as Prod
-open import Data.Vec.Base
-open import Function.Base
+open import Data.Product.Base as Product using (∃; _,_)
+open import Data.Vec.Base using (Vec; []; _∷_; head; tail)
+open import Function.Base using (_∘_; id; flip; constᵣ)
 open import Function.Bundles using (_⇔_; mk⇔)
 open import Level using (Level; _⊔_)
-open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality
-open import Relation.Nullary.Decidable
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
 
 private
   variable
@@ -45,6 +44,8 @@ curryⁿ : ∀ {n} → (Vec A n → B) → N-ary n A B
 curryⁿ {n = zero}  f = f []
 curryⁿ {n = suc n} f = λ x → curryⁿ (f ∘ _∷_ x)
 
+infix -1 _$ⁿ_
+
 _$ⁿ_ : ∀ {n} → N-ary n A B → (Vec A n → B)
 f $ⁿ []       = f
 f $ⁿ (x ∷ xs) = f x $ⁿ xs
@@ -125,7 +126,7 @@ uncurry-∃ⁿ {a} {A} {ℓ} n = mk⇔ (⇒ n) (⇐ n)
   ⇒ : ∀ n {P : N-ary n A (Set ℓ)} →
       ∃ⁿ n P → (∃ λ (xs : Vec A n) → P $ⁿ xs)
   ⇒ zero    p       = ([] , p)
-  ⇒ (suc n) (x , p) = Prod.map (_∷_ x) id (⇒ n p)
+  ⇒ (suc n) (x , p) = Product.map (_∷_ x) id (⇒ n p)
 
   ⇐ : ∀ n {P : N-ary n A (Set ℓ)} →
       (∃ λ (xs : Vec A n) → P $ⁿ xs) → ∃ⁿ n P
@@ -178,10 +179,10 @@ Eqʰ-to-Eq (suc n) _∼_ eq = λ _ → Eqʰ-to-Eq n _∼_ eq
 module _ (ext : ∀ {a b} → Extensionality a b) where
 
   Vec↔N-ary : ∀ n → (Vec A n → B) ↔ N-ary n A B
-  Vec↔N-ary zero = mk↔′ (λ vxs → vxs []) (flip constᵣ) (λ _ → refl)
+  Vec↔N-ary zero = mk↔ₛ′ (λ vxs → vxs []) (flip constᵣ) (λ _ → refl)
     (λ vxs → ext λ where [] → refl)
   Vec↔N-ary (suc n) = let open Inverse (Vec↔N-ary n) in
-    mk↔′ (λ vxs x → to λ xs → vxs (x ∷ xs))
+    mk↔ₛ′ (λ vxs x → to λ xs → vxs (x ∷ xs))
     (λ any xs → from (any (head xs)) (tail xs))
-    (λ any → ext λ x → inverseˡ _)
-    (λ vxs → ext λ where (x ∷ xs) → cong (λ f → f xs) (inverseʳ (λ ys → vxs (x ∷ ys))))
+    (λ any → ext λ x → strictlyInverseˡ _)
+    (λ vxs → ext λ where (x ∷ xs) → cong (λ f → f xs) (strictlyInverseʳ (λ ys → vxs (x ∷ ys))))
diff --git a/src/Data/Vec/Properties.agda b/src/Data/Vec/Properties.agda
index ad356c78a8..bea3cfea95 100644
--- a/src/Data/Vec/Properties.agda
+++ b/src/Data/Vec/Properties.agda
@@ -10,27 +10,33 @@ module Data.Vec.Properties where
 
 open import Algebra.Definitions
 open import Data.Bool.Base using (true; false)
-open import Data.Fin.Base as Fin using (Fin; zero; suc; toℕ; fromℕ<; _↑ˡ_; _↑ʳ_)
+open import Data.Fin.Base as Fin
+  using (Fin; zero; suc; toℕ; fromℕ<; _↑ˡ_; _↑ʳ_)
 open import Data.List.Base as List using (List)
-open import Data.Nat.Base
+import Data.List.Properties as List
+open import Data.Nat.Base using (ℕ; zero; suc; _+_; _≤_; _<_; s≤s; pred; s<s⁻¹; _≥_;
+  s≤s⁻¹; z≤n)
 open import Data.Nat.Properties
-  using (+-assoc; m≤n⇒m≤1+n; ≤-refl; ≤-trans; suc-injective)
-open import Data.Product as Prod
+  using (+-assoc; m≤n⇒m≤1+n; m≤m+n; ≤-refl; ≤-trans; ≤-irrelevant; ≤⇒≤″; suc-injective; +-comm; +-suc)
+open import Data.Product.Base as Product
   using (_×_; _,_; proj₁; proj₂; <_,_>; uncurry)
 open import Data.Sum.Base using ([_,_]′)
 open import Data.Sum.Properties using ([,]-map)
 open import Data.Vec.Base
-open import Function.Base
-open import Function.Inverse using (_↔_; inverse)
+open import Data.Vec.Relation.Binary.Equality.Cast as VecCast
+  using (_≈[_]_; ≈-sym; module CastReasoning)
+open import Function.Base using (_∘_; id; _$_; const; _ˢ_; flip)
+open import Function.Bundles using (_↔_; mk↔ₛ′)
 open import Level using (Level)
-open import Relation.Binary hiding (Decidable)
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; _≢_; _≗_; refl; sym; trans; cong; cong₂; subst; module ≡-Reasoning)
+open import Relation.Binary.Definitions using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; _≢_; _≗_; refl; sym; trans; cong; cong₂; subst)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Relation.Unary using (Pred; Decidable)
-open import Relation.Nullary.Decidable using (Dec; does; yes; no; _×-dec_; map′)
-open import Relation.Nullary.Negation using (contradiction)
-
-open ≡-Reasoning
+open import Relation.Nullary.Decidable.Core using (Dec; does; yes; _×-dec_; map′)
+open import Relation.Nullary.Negation.Core using (contradiction)
+import Data.Nat.GeneralisedArithmetic as ℕ
 
 private
   variable
@@ -49,7 +55,7 @@ private
 ∷-injectiveʳ : x ∷ xs ≡ y ∷ ys → xs ≡ ys
 ∷-injectiveʳ refl = refl
 
-∷-injective : (x ∷ xs) ≡ (y ∷ ys) → x ≡ y × xs ≡ ys
+∷-injective : x ∷ xs ≡ y ∷ ys → x ≡ y × xs ≡ ys
 ∷-injective refl = refl , refl
 
 ≡-dec : DecidableEquality A → DecidableEquality (Vec A n)
@@ -70,88 +76,45 @@ private
 -- take
 
 unfold-take : ∀ n x (xs : Vec A (n + m)) → take (suc n) (x ∷ xs) ≡ x ∷ take n xs
-unfold-take n x xs with splitAt n xs
-... | xs , ys , refl = refl
-
-take-distr-zipWith : ∀ (f : A → B → C) →
-                     (xs : Vec A (m + n)) (ys : Vec B (m + n)) →
-                     take m (zipWith f xs ys) ≡ zipWith f (take m xs) (take m ys)
-take-distr-zipWith {m = zero}  f xs       ys       = refl
-take-distr-zipWith {m = suc m} f (x ∷ xs) (y ∷ ys) = begin
-    take (suc m) (zipWith f (x ∷ xs) (y ∷ ys))
-  ≡⟨⟩
-    take (suc m) (f x y ∷ (zipWith f xs ys))
-  ≡⟨ unfold-take m (f x y) (zipWith f xs ys) ⟩
-    f x y ∷ take m (zipWith f xs ys)
-  ≡⟨ cong (f x y ∷_) (take-distr-zipWith f xs ys) ⟩
-    f x y ∷ (zipWith f (take m xs) (take m ys))
-  ≡⟨⟩
-    zipWith f (x ∷ (take m xs)) (y ∷ (take m ys))
-  ≡˘⟨ cong₂ (zipWith f) (unfold-take m x xs) (unfold-take m y ys) ⟩
-    zipWith f (take (suc m) (x ∷ xs)) (take (suc m) (y ∷ ys))
-  ∎
-
-take-distr-map : ∀ (f : A → B) (m : ℕ) (xs : Vec A (m + n)) →
-                 take m (map f xs) ≡ map f (take m xs)
-take-distr-map f zero xs = refl
-take-distr-map f (suc m) (x ∷ xs) = begin
-  take (suc m) (map f (x ∷ xs)) ≡⟨⟩
-  take (suc m) (f x ∷ map f xs) ≡⟨ unfold-take m (f x) (map f xs) ⟩
-  f x ∷ (take m (map f xs))     ≡⟨ cong (f x ∷_) (take-distr-map f m xs) ⟩
-  f x ∷ (map f (take m xs))     ≡⟨⟩
-  map f (x ∷ take m xs)         ≡˘⟨ cong (map f) (unfold-take m x xs) ⟩
-  map f (take (suc m) (x ∷ xs)) ∎
+unfold-take n x xs = refl
+
+take-zipWith : ∀ (f : A → B → C) →
+               (xs : Vec A (m + n)) (ys : Vec B (m + n)) →
+               take m (zipWith f xs ys) ≡ zipWith f (take m xs) (take m ys)
+take-zipWith {m = zero}  f xs       ys       = refl
+take-zipWith {m = suc m} f (x ∷ xs) (y ∷ ys) = cong (f x y ∷_) (take-zipWith f xs ys)
+
+take-map : ∀ (f : A → B) (m : ℕ) (xs : Vec A (m + n)) →
+           take m (map f xs) ≡ map f (take m xs)
+take-map f zero    xs       = refl
+take-map f (suc m) (x ∷ xs) = cong (f x ∷_) (take-map f m xs)
 
 ------------------------------------------------------------------------
 -- drop
 
 unfold-drop : ∀ n x (xs : Vec A (n + m)) →
               drop (suc n) (x ∷ xs) ≡ drop n xs
-unfold-drop n x xs with splitAt n xs
-... | xs , ys , refl = refl
-
-drop-distr-zipWith : (f : A → B → C) →
-                     (x : Vec A (m + n)) (y : Vec B (m + n)) →
-                     drop m (zipWith f x y) ≡ zipWith f (drop m x) (drop m y)
-drop-distr-zipWith {m = zero} f   xs       ys = refl
-drop-distr-zipWith {m = suc m} f (x ∷ xs) (y ∷ ys) = begin
-    drop (suc m) (zipWith f (x ∷ xs) (y ∷ ys))
-  ≡⟨⟩
-    drop (suc m) (f x y ∷ (zipWith f xs ys))
-  ≡⟨ unfold-drop m (f x y) (zipWith f xs ys) ⟩
-    drop m (zipWith f xs ys)
-  ≡⟨ drop-distr-zipWith f xs ys ⟩
-    zipWith f (drop m xs) (drop m ys)
-  ≡˘⟨ cong₂ (zipWith f) (unfold-drop m x xs) (unfold-drop m y ys) ⟩
-    zipWith f (drop (suc m) (x ∷ xs)) (drop (suc m) (y ∷ ys))
-  ∎
-
-drop-distr-map : ∀ (f : A → B) (m : ℕ) (x : Vec A (m + n)) →
-                 drop m (map f x) ≡ map f (drop m x)
-drop-distr-map f zero x = refl
-drop-distr-map f (suc m) (x ∷ xs) = begin
-  drop (suc m) (map f (x ∷ xs)) ≡⟨⟩
-  drop (suc m) (f x ∷ map f xs) ≡⟨  unfold-drop m (f x) (map f xs) ⟩
-  drop m (map f xs)             ≡⟨  drop-distr-map f m xs ⟩
-  map f (drop m xs)             ≡˘⟨ cong (map f) (unfold-drop m x xs) ⟩
-  map f (drop (suc m) (x ∷ xs)) ∎
+unfold-drop n x xs = refl
+
+drop-zipWith : (f : A → B → C) →
+               (xs : Vec A (m + n)) (ys : Vec B (m + n)) →
+               drop m (zipWith f xs ys) ≡ zipWith f (drop m xs) (drop m ys)
+drop-zipWith {m = zero}  f   xs       ys     = refl
+drop-zipWith {m = suc m} f (x ∷ xs) (y ∷ ys) = drop-zipWith f xs ys
+
+drop-map : ∀ (f : A → B) (m : ℕ) (xs : Vec A (m + n)) →
+           drop m (map f xs) ≡ map f (drop m xs)
+drop-map f zero    xs       = refl
+drop-map f (suc m) (x ∷ xs) = drop-map f m xs
 
 ------------------------------------------------------------------------
 -- take and drop together
 
-take-drop-id : ∀ (m : ℕ) (x : Vec A (m + n)) → take m x ++ drop m x ≡ x
-take-drop-id zero x = refl
-take-drop-id (suc m) (x ∷ xs) = begin
-    take (suc m) (x ∷ xs) ++ drop (suc m) (x ∷ xs)
-  ≡⟨ cong₂ _++_ (unfold-take m x xs) (unfold-drop m x xs) ⟩
-    (x ∷ take m xs) ++ (drop m xs)
-  ≡⟨⟩
-    x ∷ (take m xs ++ drop m xs)
-  ≡⟨ cong (x ∷_) (take-drop-id m xs) ⟩
-    x ∷ xs
-  ∎
-
---------------------------------------------------------------------------------
+take++drop≡id : ∀ (m : ℕ) (xs : Vec A (m + n)) → take m xs ++ drop m xs ≡ xs
+take++drop≡id zero    xs       = refl
+take++drop≡id (suc m) (x ∷ xs) = cong (x ∷_) (take++drop≡id m xs)
+
+------------------------------------------------------------------------
 -- truncate
 
 truncate-refl : (xs : Vec A n) → truncate ≤-refl xs ≡ xs
@@ -163,14 +126,27 @@ truncate-trans : ∀ {p} (m≤n : m ≤ n) (n≤p : n ≤ p) (xs : Vec A p) →
 truncate-trans z≤n       n≤p       xs = refl
 truncate-trans (s≤s m≤n) (s≤s n≤p) (x ∷ xs) = cong (x ∷_) (truncate-trans m≤n n≤p xs)
 
---------------------------------------------------------------------------------
+truncate-irrelevant : (m≤n₁ m≤n₂ : m ≤ n) → truncate {A = A} m≤n₁ ≗ truncate m≤n₂
+truncate-irrelevant m≤n₁ m≤n₂ xs = cong (λ m≤n → truncate m≤n xs) (≤-irrelevant m≤n₁ m≤n₂)
+
+truncate≡take : (m≤n : m ≤ n) (xs : Vec A n) .(eq : n ≡ m + o) →
+                truncate m≤n xs ≡ take m (cast eq xs)
+truncate≡take z≤n       _        eq = refl
+truncate≡take (s≤s m≤n) (x ∷ xs) eq = cong (x ∷_) (truncate≡take m≤n xs (suc-injective eq))
+
+take≡truncate : ∀ m (xs : Vec A (m + n)) →
+                take m xs ≡ truncate (m≤m+n m n) xs
+take≡truncate zero    _        = refl
+take≡truncate (suc m) (x ∷ xs) = cong (x ∷_) (take≡truncate m xs)
+
+------------------------------------------------------------------------
 -- pad
 
 padRight-refl : (a : A) (xs : Vec A n) → padRight ≤-refl a xs ≡ xs
 padRight-refl a []       = refl
 padRight-refl a (x ∷ xs) = cong (x ∷_) (padRight-refl a xs)
 
-padRight-replicate : (m≤n : m ≤ n) (a : A) → replicate a ≡ padRight m≤n a (replicate a)
+padRight-replicate : (m≤n : m ≤ n) (a : A) → replicate n a ≡ padRight m≤n a (replicate m a)
 padRight-replicate z≤n       a = refl
 padRight-replicate (s≤s m≤n) a = cong (a ∷_) (padRight-replicate m≤n a)
 
@@ -179,7 +155,7 @@ padRight-trans : ∀ {p} (m≤n : m ≤ n) (n≤p : n ≤ p) (a : A) (xs : Vec A
 padRight-trans z≤n       n≤p       a []       = padRight-replicate n≤p a
 padRight-trans (s≤s m≤n) (s≤s n≤p) a (x ∷ xs) = cong (x ∷_) (padRight-trans m≤n n≤p a xs)
 
---------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- truncate and padRight together
 
 truncate-padRight : (m≤n : m ≤ n) (a : A) (xs : Vec A m) →
@@ -199,9 +175,8 @@ lookup⇒[]= zero    (_ ∷ _)  refl = here
 lookup⇒[]= (suc i) (_ ∷ xs) p    = there (lookup⇒[]= i xs p)
 
 []=↔lookup : ∀ {i} → xs [ i ]= x ↔ lookup xs i ≡ x
-[]=↔lookup {i = i} =
-  inverse []=⇒lookup (lookup⇒[]= _ _)
-          lookup⇒[]=∘[]=⇒lookup ([]=⇒lookup∘lookup⇒[]= _ i)
+[]=↔lookup {xs = ys} {i = i} =
+  mk↔ₛ′ []=⇒lookup (lookup⇒[]= i ys) ([]=⇒lookup∘lookup⇒[]= _ i) lookup⇒[]=∘[]=⇒lookup
   where
   lookup⇒[]=∘[]=⇒lookup : ∀ {i} (p : xs [ i ]= x) →
                           lookup⇒[]= i xs ([]=⇒lookup p) ≡ p
@@ -213,14 +188,20 @@ lookup⇒[]= (suc i) (_ ∷ xs) p    = there (lookup⇒[]= i xs p)
   []=⇒lookup∘lookup⇒[]= (x ∷ xs) zero    refl = refl
   []=⇒lookup∘lookup⇒[]= (x ∷ xs) (suc i) p    = []=⇒lookup∘lookup⇒[]= xs i p
 
-lookup-inject≤-take : ∀ m (m≤m+n : m ≤ m + n) (i : Fin m) (xs : Vec A (m + n)) →
-                      lookup xs (Fin.inject≤ i m≤m+n) ≡ lookup (take m xs) i
-lookup-inject≤-take (suc m) m≤m+n zero (x ∷ xs)
-  rewrite unfold-take m x xs = refl
-lookup-inject≤-take (suc (suc m)) (s≤s m≤m+n) (suc zero) (x ∷ y ∷ xs)
-  rewrite unfold-take (suc m) x (y ∷ xs) | unfold-take m y xs = refl
-lookup-inject≤-take (suc (suc m)) (s≤s (s≤s m≤m+n)) (suc (suc i)) (x ∷ y ∷ xs)
-  rewrite unfold-take (suc m) x (y ∷ xs) | unfold-take m y xs = lookup-inject≤-take m m≤m+n i xs
+lookup-truncate : (m≤n : m ≤ n) (xs : Vec A n) (i : Fin m) →
+                  lookup (truncate m≤n xs) i ≡ lookup xs (Fin.inject≤ i m≤n)
+lookup-truncate (s≤s m≤m+n) (_ ∷ _)  zero    = refl
+lookup-truncate (s≤s m≤m+n) (_ ∷ xs) (suc i) = lookup-truncate m≤m+n xs i
+
+lookup-take-inject≤ : (xs : Vec A (m + n)) (i : Fin m) →
+                      lookup (take m xs) i ≡ lookup xs (Fin.inject≤ i (m≤m+n m n))
+lookup-take-inject≤ {m = m} {n = n} xs i = begin
+  lookup (take _ xs) i
+    ≡⟨ cong (λ ys → lookup ys i) (take≡truncate m xs) ⟩
+  lookup (truncate _ xs) i
+    ≡⟨ lookup-truncate (m≤m+n m n) xs i ⟩
+  lookup xs (Fin.inject≤ i (m≤m+n m n))
+    ∎ where open ≡-Reasoning
 
 ------------------------------------------------------------------------
 -- updateAt (_[_]%=_)
@@ -228,14 +209,14 @@ lookup-inject≤-take (suc (suc m)) (s≤s (s≤s m≤m+n)) (suc (suc i)) (x ∷
 -- (+) updateAt i actually updates the element at index i.
 
 updateAt-updates : ∀ (i : Fin n) {f : A → A} (xs : Vec A n) →
-                   xs [ i ]= x → (updateAt i f xs) [ i ]= f x
+                   xs [ i ]= x → (updateAt xs i f) [ i ]= f x
 updateAt-updates zero    (x ∷ xs) here        = here
 updateAt-updates (suc i) (x ∷ xs) (there loc) = there (updateAt-updates i xs loc)
 
 -- (-) updateAt i does not touch the elements at other indices.
 
 updateAt-minimal : ∀ (i j : Fin n) {f : A → A} (xs : Vec A n) →
-                   i ≢ j → xs [ i ]= x → (updateAt j f xs) [ i ]= x
+                   i ≢ j → xs [ i ]= x → (updateAt xs j f) [ i ]= x
 updateAt-minimal zero    zero    (x ∷ xs) 0≢0 here        = contradiction refl 0≢0
 updateAt-minimal zero    (suc j) (x ∷ xs) _   here        = here
 updateAt-minimal (suc i) zero    (x ∷ xs) _   (there loc) = there loc
@@ -258,29 +239,29 @@ updateAt-minimal (suc i) (suc j) (x ∷ xs) i≢j (there loc) =
 
 updateAt-id-local : ∀ (i : Fin n) {f : A → A} (xs : Vec A n) →
                     f (lookup xs i) ≡ lookup xs i →
-                    updateAt i f xs ≡ xs
+                    updateAt xs i f ≡ xs
 updateAt-id-local zero    (x ∷ xs) eq = cong (_∷ xs) eq
 updateAt-id-local (suc i) (x ∷ xs) eq = cong (x ∷_) (updateAt-id-local i xs eq)
 
 -- 1b. identity:  updateAt i id ≗ id
 
-updateAt-id : ∀ (i : Fin n) (xs : Vec A n) → updateAt i id xs ≡ xs
+updateAt-id : ∀ (i : Fin n) (xs : Vec A n) → updateAt xs i id ≡ xs
 updateAt-id i xs = updateAt-id-local i xs refl
 
 -- 2a. local composition:  f ∘ g = h ↾ (lookup xs i)
 --                implies  updateAt i f ∘ updateAt i g = updateAt i h ↾ xs
 
-updateAt-∘-local : ∀ (i : Fin n) {f g h : A → A} (xs : Vec A n) →
-                         f (g (lookup xs i)) ≡ h (lookup xs i) →
-                         updateAt i f (updateAt i g xs) ≡ updateAt i h xs
-updateAt-∘-local zero    (x ∷ xs) fg=h = cong (_∷ xs) fg=h
-updateAt-∘-local (suc i) (x ∷ xs) fg=h = cong (x ∷_) (updateAt-∘-local i xs fg=h)
+updateAt-updateAt-local : ∀ (i : Fin n) {f g h : A → A} (xs : Vec A n) →
+                          f (g (lookup xs i)) ≡ h (lookup xs i) →
+                          updateAt (updateAt xs i g) i f ≡ updateAt xs i h
+updateAt-updateAt-local zero    (x ∷ xs) fg=h = cong (_∷ xs) fg=h
+updateAt-updateAt-local (suc i) (x ∷ xs) fg=h = cong (x ∷_) (updateAt-updateAt-local i xs fg=h)
 
 -- 2b. composition:  updateAt i f ∘ updateAt i g ≗ updateAt i (f ∘ g)
 
-updateAt-∘ : ∀ (i : Fin n) {f g : A → A} →
-                   updateAt i f ∘ updateAt i g ≗ updateAt i (f ∘ g)
-updateAt-∘ i xs = updateAt-∘-local i xs refl
+updateAt-updateAt : ∀ (i : Fin n) {f g : A → A} (xs : Vec A n) →
+                    updateAt (updateAt xs i g) i f ≡ updateAt xs i (f ∘ g)
+updateAt-updateAt i xs = updateAt-updateAt-local i xs refl
 
 -- 3. congruence:  updateAt i  is a congruence wrt. extensional equality.
 
@@ -289,14 +270,14 @@ updateAt-∘ i xs = updateAt-∘-local i xs refl
 
 updateAt-cong-local : ∀ (i : Fin n) {f g : A → A} (xs : Vec A n) →
                       f (lookup xs i) ≡ g (lookup xs i) →
-                      updateAt i f xs ≡ updateAt i g xs
+                      updateAt xs i f ≡ updateAt xs i g
 updateAt-cong-local zero    (x ∷ xs) f=g = cong (_∷ xs) f=g
 updateAt-cong-local (suc i) (x ∷ xs) f=g = cong (x ∷_) (updateAt-cong-local i xs f=g)
 
 -- 3b. congruence:  f ≗ g → updateAt i f ≗ updateAt i g
 
-updateAt-cong : ∀ (i : Fin n) {f g : A → A} →
-                f ≗ g → updateAt i f ≗ updateAt i g
+updateAt-cong : ∀ (i : Fin n) {f g : A → A} → f ≗ g → (xs : Vec A n) →
+                updateAt xs i f ≡ updateAt xs i g
 updateAt-cong i f≗g xs = updateAt-cong-local i xs (f≗g (lookup xs i))
 
 -- The order of updates at different indices i ≢ j does not matter.
@@ -304,13 +285,13 @@ updateAt-cong i f≗g xs = updateAt-cong-local i xs (f≗g (lookup xs i))
 -- This a consequence of updateAt-updates and updateAt-minimal
 -- but easier to prove inductively.
 
-updateAt-commutes : ∀ (i j : Fin n) {f g : A → A} → i ≢ j →
-                    updateAt i f ∘ updateAt j g ≗ updateAt j g ∘ updateAt i f
+updateAt-commutes : ∀ (i j : Fin n) {f g : A → A} → i ≢ j → (xs : Vec A n) →
+                    updateAt (updateAt xs j g) i f ≡ updateAt (updateAt xs i f) j g
 updateAt-commutes zero    zero    0≢0 (x ∷ xs) = contradiction refl 0≢0
 updateAt-commutes zero    (suc j) i≢j (x ∷ xs) = refl
 updateAt-commutes (suc i) zero    i≢j (x ∷ xs) = refl
 updateAt-commutes (suc i) (suc j) i≢j (x ∷ xs) =
-  cong (x ∷_) (updateAt-commutes i j (i≢j ∘ cong suc) xs)
+   cong (x ∷_) (updateAt-commutes i j (i≢j ∘ cong suc) xs)
 
 -- lookup after updateAt reduces.
 
@@ -318,14 +299,14 @@ updateAt-commutes (suc i) (suc j) i≢j (x ∷ xs) =
 -- using []=↔lookup.
 
 lookup∘updateAt : ∀ (i : Fin n) {f : A → A} xs →
-                  lookup (updateAt i f xs) i ≡ f (lookup xs i)
+                  lookup (updateAt xs i f) i ≡ f (lookup xs i)
 lookup∘updateAt i xs =
   []=⇒lookup (updateAt-updates i xs (lookup⇒[]= i _ refl))
 
 -- For different indices it easily follows from updateAt-minimal.
 
 lookup∘updateAt′ : ∀ (i j : Fin n) {f : A → A} → i ≢ j → ∀ xs →
-                   lookup (updateAt j f xs) i ≡ lookup xs i
+                   lookup (updateAt xs j f) i ≡ lookup xs i
 lookup∘updateAt′ i j xs i≢j =
   []=⇒lookup (updateAt-minimal i j i≢j xs (lookup⇒[]= i _ refl))
 
@@ -335,10 +316,10 @@ lookup∘updateAt′ i j xs i≢j =
 []%=-id xs i = updateAt-id i xs
 
 []%=-∘ : ∀ (xs : Vec A n) (i : Fin n) {f g : A → A} →
-     xs [ i ]%= f
-        [ i ]%= g
-   ≡ xs [ i ]%= g ∘ f
-[]%=-∘ xs i = updateAt-∘ i xs
+      xs [ i ]%= f
+         [ i ]%= g
+    ≡ xs [ i ]%= g ∘ f
+[]%=-∘ xs i = updateAt-updateAt i xs
 
 
 ------------------------------------------------------------------------
@@ -348,11 +329,11 @@ lookup∘updateAt′ i j xs i≢j =
 -- are special cases of the ones for updateAt.
 
 []≔-idempotent : ∀ (xs : Vec A n) (i : Fin n) →
-                 (xs [ i ]≔ x) [ i ]≔ y ≡ xs [ i ]≔ y
-[]≔-idempotent xs i = updateAt-∘ i xs
+                  (xs [ i ]≔ x) [ i ]≔ y ≡ xs [ i ]≔ y
+[]≔-idempotent xs i = updateAt-updateAt i xs
 
 []≔-commutes : ∀ (xs : Vec A n) (i j : Fin n) → i ≢ j →
-               (xs [ i ]≔ x) [ j ]≔ y ≡ (xs [ j ]≔ y) [ i ]≔ x
+                (xs [ i ]≔ x) [ j ]≔ y ≡ (xs [ j ]≔ y) [ i ]≔ x
 []≔-commutes xs i j i≢j = updateAt-commutes j i (i≢j ∘ sym) xs
 
 []≔-updates : ∀ (xs : Vec A n) (i : Fin n) → (xs [ i ]≔ x) [ i ]= x
@@ -387,23 +368,18 @@ lookup∘update′ {i = i} {j} i≢j xs y = lookup∘updateAt′ i j i≢j xs
 ------------------------------------------------------------------------
 -- cast
 
-toList-cast : ∀ .(eq : m ≡ n) (xs : Vec A m) → toList (cast eq xs) ≡ toList xs
-toList-cast {n = zero}  eq []       = refl
-toList-cast {n = suc _} eq (x ∷ xs) =
-  cong (x List.∷_) (toList-cast (cong pred eq) xs)
-
-cast-is-id : .(eq : m ≡ m) (xs : Vec A m) → cast eq xs ≡ xs
-cast-is-id eq []       = refl
-cast-is-id eq (x ∷ xs) = cong (x ∷_) (cast-is-id (suc-injective eq) xs)
+open VecCast public
+  using (cast-is-id; cast-trans)
 
 subst-is-cast : (eq : m ≡ n) (xs : Vec A m) → subst (Vec A) eq xs ≡ cast eq xs
 subst-is-cast refl xs = sym (cast-is-id refl xs)
 
-cast-trans : .(eq₁ : m ≡ n) (eq₂ : n ≡ o) (xs : Vec A m) →
-             cast eq₂ (cast eq₁ xs) ≡ cast (trans eq₁ eq₂) xs
-cast-trans {m = zero}  {n = zero}  {o = zero}  eq₁ eq₂ [] = refl
-cast-trans {m = suc _} {n = suc _} {o = suc _} eq₁ eq₂ (x ∷ xs) =
-  cong (x ∷_) (cast-trans (suc-injective eq₁) (suc-injective eq₂) xs)
+cast-sym : .(eq : m ≡ n) {xs : Vec A m} {ys : Vec A n} →
+           cast eq xs ≡ ys → cast (sym eq) ys ≡ xs
+cast-sym eq {xs = []}     {ys = []}     _ = refl
+cast-sym eq {xs = x ∷ xs} {ys = y ∷ ys} xxs[eq]≡yys =
+  let x≡y , xs[eq]≡ys = ∷-injective xxs[eq]≡yys
+  in cong₂ _∷_ (sym x≡y) (cast-sym (suc-injective eq) xs[eq]≡ys)
 
 ------------------------------------------------------------------------
 -- map
@@ -412,7 +388,7 @@ map-id : map id ≗ id {A = Vec A n}
 map-id []       = refl
 map-id (x ∷ xs) = cong (x ∷_) (map-id xs)
 
-map-const : ∀ (xs : Vec A n) (y : B) → map (const y) xs ≡ replicate y
+map-const : ∀ (xs : Vec A n) (y : B) → map (const y) xs ≡ replicate n y
 map-const []       _ = refl
 map-const (_ ∷ xs) y = cong (y ∷_) (map-const xs y)
 
@@ -444,10 +420,16 @@ lookup-map (suc i) f (x ∷ xs) = lookup-map i f xs
 map-updateAt : ∀ {f : A → B} {g : A → A} {h : B → B}
                (xs : Vec A n) (i : Fin n) →
                f (g (lookup xs i)) ≡ h (f (lookup xs i)) →
-               map f (updateAt i g xs) ≡ updateAt i h (map f xs)
+               map f (updateAt xs i g) ≡ updateAt (map f xs) i h
 map-updateAt (x ∷ xs) zero    eq = cong (_∷ _) eq
 map-updateAt (x ∷ xs) (suc i) eq = cong (_ ∷_) (map-updateAt xs i eq)
 
+map-insertAt : ∀ (f : A → B) (x : A) (xs : Vec A n) (i : Fin (suc n)) →
+             map f (insertAt xs i x) ≡ insertAt (map f xs) i (f x)
+map-insertAt f _ []        Fin.zero = refl
+map-insertAt f _ (x' ∷ xs) Fin.zero = refl
+map-insertAt f x (x' ∷ xs) (Fin.suc i) = cong (_ ∷_) (map-insertAt f x xs i)
+
 map-[]≔ : ∀ (f : A → B) (xs : Vec A n) (i : Fin n) →
           map f (xs [ i ]≔ x) ≡ map f xs [ i ]≔ f x
 map-[]≔ f xs i = map-updateAt xs i refl
@@ -457,6 +439,11 @@ map-⊛ : ∀ (f : A → B → C) (g : A → B) (xs : Vec A n) →
 map-⊛ f g []       = refl
 map-⊛ f g (x ∷ xs) = cong (f x (g x) ∷_) (map-⊛ f g xs)
 
+toList-map : ∀ (f : A → B) (xs : Vec A n) →
+             toList (map f xs) ≡ List.map f (toList xs)
+toList-map f [] = refl
+toList-map f (x ∷ xs) = cong (f x List.∷_) (toList-map f xs)
+
 ------------------------------------------------------------------------
 -- _++_
 
@@ -477,17 +464,36 @@ map-⊛ f g (x ∷ xs) = cong (f x (g x) ∷_) (map-⊛ f g xs)
 ++-injective ws xs eq =
   (++-injectiveˡ ws xs eq , ++-injectiveʳ ws xs eq)
 
+++-assoc : ∀ .(eq : (m + n) + o ≡ m + (n + o)) (xs : Vec A m) (ys : Vec A n) (zs : Vec A o) →
+           cast eq ((xs ++ ys) ++ zs) ≡ xs ++ (ys ++ zs)
+++-assoc eq []       ys zs = cast-is-id eq (ys ++ zs)
+++-assoc eq (x ∷ xs) ys zs = cong (x ∷_) (++-assoc (cong pred eq) xs ys zs)
+
+++-identityʳ : ∀ .(eq : n + zero ≡ n) (xs : Vec A n) → cast eq (xs ++ []) ≡ xs
+++-identityʳ eq []       = refl
+++-identityʳ eq (x ∷ xs) = cong (x ∷_) (++-identityʳ (cong pred eq) xs)
+
+cast-++ˡ : ∀ .(eq : m ≡ o) (xs : Vec A m) {ys : Vec A n} →
+           cast (cong (_+ n) eq) (xs ++ ys) ≡ cast eq xs ++ ys
+cast-++ˡ {o = zero}  eq []       {ys} = cast-is-id refl (cast eq [] ++ ys)
+cast-++ˡ {o = suc o} eq (x ∷ xs) {ys} = cong (x ∷_) (cast-++ˡ (cong pred eq) xs)
+
+cast-++ʳ : ∀ .(eq : n ≡ o) (xs : Vec A m) {ys : Vec A n} →
+           cast (cong (m +_) eq) (xs ++ ys) ≡ xs ++ cast eq ys
+cast-++ʳ {m = zero}  eq []       {ys} = refl
+cast-++ʳ {m = suc m} eq (x ∷ xs) {ys} = cong (x ∷_) (cast-++ʳ eq xs)
+
 lookup-++-< : ∀ (xs : Vec A m) (ys : Vec A n) →
               ∀ i (i<m : toℕ i < m) →
               lookup (xs ++ ys) i  ≡ lookup xs (Fin.fromℕ< i<m)
-lookup-++-< (x ∷ xs) ys zero    z<s       = refl
-lookup-++-< (x ∷ xs) ys (suc i) (s<s i<m) = lookup-++-< xs ys i i<m
+lookup-++-< (x ∷ xs) ys zero    _     = refl
+lookup-++-< (x ∷ xs) ys (suc i) si<sm = lookup-++-< xs ys i (s<s⁻¹ si<sm)
 
 lookup-++-≥ : ∀ (xs : Vec A m) (ys : Vec A n) →
               ∀ i (i≥m : toℕ i ≥ m) →
               lookup (xs ++ ys) i ≡ lookup ys (Fin.reduce≥ i i≥m)
-lookup-++-≥ []       ys i       i≥m       = refl
-lookup-++-≥ (x ∷ xs) ys (suc i) (s≤s i≥m) = lookup-++-≥ xs ys i i≥m
+lookup-++-≥ []       ys i       _     = refl
+lookup-++-≥ (x ∷ xs) ys (suc i) si≥sm = lookup-++-≥ xs ys i (s≤s⁻¹ si≥sm)
 
 lookup-++ˡ : ∀ (xs : Vec A m) (ys : Vec A n) i →
              lookup (xs ++ ys) (i ↑ˡ n) ≡ lookup xs i
@@ -509,6 +515,11 @@ lookup-splitAt (suc m) (x ∷ xs) ys (suc i) = trans
   (lookup-splitAt m xs ys i)
   (sym ([,]-map (Fin.splitAt m i)))
 
+toList-++ : (xs : Vec A n) (ys : Vec A m) →
+            toList (xs ++ ys) ≡ toList xs List.++ toList ys
+toList-++ []       ys = refl
+toList-++ (x ∷ xs) ys = cong (x List.∷_) (toList-++ xs ys)
+
 ------------------------------------------------------------------------
 -- concat
 
@@ -561,25 +572,25 @@ module _ {f : A → A → A} where
 module _ {f : A → A → A} {e : A} where
 
   zipWith-identityˡ : LeftIdentity _≡_ e f →
-                      LeftIdentity _≡_ (replicate e) (zipWith {n = n} f)
+                      LeftIdentity _≡_ (replicate n e) (zipWith f)
   zipWith-identityˡ idˡ []       = refl
   zipWith-identityˡ idˡ (x ∷ xs) =
     cong₂ _∷_ (idˡ x) (zipWith-identityˡ idˡ xs)
 
   zipWith-identityʳ : RightIdentity _≡_ e f →
-                      RightIdentity _≡_ (replicate e) (zipWith {n = n} f)
+                      RightIdentity _≡_ (replicate n e) (zipWith f)
   zipWith-identityʳ idʳ []       = refl
   zipWith-identityʳ idʳ (x ∷ xs) =
     cong₂ _∷_ (idʳ x) (zipWith-identityʳ idʳ xs)
 
   zipWith-zeroˡ : LeftZero _≡_ e f →
-                  LeftZero _≡_ (replicate e) (zipWith {n = n} f)
+                  LeftZero _≡_ (replicate n e) (zipWith f)
   zipWith-zeroˡ zeˡ []       = refl
   zipWith-zeroˡ zeˡ (x ∷ xs) =
     cong₂ _∷_ (zeˡ x) (zipWith-zeroˡ zeˡ xs)
 
   zipWith-zeroʳ : RightZero _≡_ e f →
-                  RightZero _≡_ (replicate e) (zipWith {n = n} f)
+                  RightZero _≡_ (replicate n e) (zipWith f)
   zipWith-zeroʳ zeʳ []       = refl
   zipWith-zeroʳ zeʳ (x ∷ xs) =
     cong₂ _∷_ (zeʳ x) (zipWith-zeroʳ zeʳ xs)
@@ -587,13 +598,13 @@ module _ {f : A → A → A} {e : A} where
 module _ {f : A → A → A} {e : A} {⁻¹ : A → A} where
 
   zipWith-inverseˡ : LeftInverse _≡_ e ⁻¹ f →
-                     LeftInverse _≡_ (replicate {n = n} e) (map ⁻¹) (zipWith f)
+                     LeftInverse _≡_ (replicate n e) (map ⁻¹) (zipWith f)
   zipWith-inverseˡ invˡ []       = refl
   zipWith-inverseˡ invˡ (x ∷ xs) =
     cong₂ _∷_ (invˡ x) (zipWith-inverseˡ invˡ xs)
 
   zipWith-inverseʳ : RightInverse _≡_ e ⁻¹ f →
-                     RightInverse _≡_ (replicate {n = n} e) (map ⁻¹) (zipWith f)
+                     RightInverse _≡_ (replicate n e) (map ⁻¹) (zipWith f)
   zipWith-inverseʳ invʳ []       = refl
   zipWith-inverseʳ invʳ (x ∷ xs) =
     cong₂ _∷_ (invʳ x) (zipWith-inverseʳ invʳ xs)
@@ -645,6 +656,15 @@ lookup-zipWith : ∀ (f : A → B → C) (i : Fin n) xs ys →
 lookup-zipWith _ zero    (x ∷ _)  (y ∷ _)   = refl
 lookup-zipWith _ (suc i) (_ ∷ xs) (_ ∷ ys)  = lookup-zipWith _ i xs ys
 
+zipWith-++ : ∀ (f : A → B → C)
+             (xs : Vec A n) (ys : Vec A m)
+             (xs' : Vec B n) (ys' : Vec B m) →
+             zipWith f (xs ++ ys) (xs' ++ ys') ≡
+             zipWith f xs xs' ++ zipWith f ys ys'
+zipWith-++ f []       ys []         ys' = refl
+zipWith-++ f (x ∷ xs) ys (x' ∷ xs') ys' =
+  cong (_ ∷_) (zipWith-++ f xs ys xs' ys')
+
 ------------------------------------------------------------------------
 -- zip
 
@@ -672,7 +692,7 @@ map-<,>-zip f g []       = refl
 map-<,>-zip f g (x ∷ xs) = cong (_ ∷_) (map-<,>-zip f g xs)
 
 map-zip : ∀ (f : A → B) (g : C → D) (xs : Vec A n) (ys : Vec C n) →
-          map (Prod.map f g) (zip xs ys) ≡ zip (map f xs) (map g ys)
+          map (Product.map f g) (zip xs ys) ≡ zip (map f xs) (map g ys)
 map-zip f g []       []       = refl
 map-zip f g (x ∷ xs) (y ∷ ys) = cong (_ ∷_) (map-zip f g xs ys)
 
@@ -688,10 +708,10 @@ lookup-unzip (suc i) ((x , y) ∷ xys) = lookup-unzip i xys
 
 map-unzip : ∀ (f : A → B) (g : C → D) (xys : Vec (A × C) n) →
             let xs , ys = unzip xys
-            in (map f xs , map g ys) ≡ unzip (map (Prod.map f g) xys)
+            in (map f xs , map g ys) ≡ unzip (map (Product.map f g) xys)
 map-unzip f g []              = refl
 map-unzip f g ((x , y) ∷ xys) =
-  cong (Prod.map (f x ∷_) (g y ∷_)) (map-unzip f g xys)
+  cong (Product.map (f x ∷_) (g y ∷_)) (map-unzip f g xys)
 
 -- Products of vectors are isomorphic to vectors of products.
 
@@ -699,14 +719,14 @@ unzip∘zip : ∀ (xs : Vec A n) (ys : Vec B n) →
             unzip (zip xs ys) ≡ (xs , ys)
 unzip∘zip [] []             = refl
 unzip∘zip (x ∷ xs) (y ∷ ys) =
-  cong (Prod.map (x ∷_) (y ∷_)) (unzip∘zip xs ys)
+  cong (Product.map (x ∷_) (y ∷_)) (unzip∘zip xs ys)
 
 zip∘unzip : ∀ (xys : Vec (A × B) n) → uncurry zip (unzip xys) ≡ xys
 zip∘unzip []         = refl
 zip∘unzip (xy ∷ xys) = cong (xy ∷_) (zip∘unzip xys)
 
 ×v↔v× : (Vec A n × Vec B n) ↔ Vec (A × B) n
-×v↔v× = inverse (uncurry zip) unzip (uncurry unzip∘zip) zip∘unzip
+×v↔v× = mk↔ₛ′ (uncurry zip) unzip zip∘unzip (uncurry unzip∘zip)
 
 ------------------------------------------------------------------------
 -- _⊛_
@@ -717,7 +737,7 @@ lookup-⊛ zero    (f ∷ fs) (x ∷ xs) = refl
 lookup-⊛ (suc i) (f ∷ fs) (x ∷ xs) = lookup-⊛ i fs xs
 
 map-is-⊛ : ∀ (f : A → B) (xs : Vec A n) →
-           map f xs ≡ (replicate f ⊛ xs)
+           map f xs ≡ (replicate n f ⊛ xs)
 map-is-⊛ f []       = refl
 map-is-⊛ f (x ∷ xs) = cong (_ ∷_) (map-is-⊛ f xs)
 
@@ -727,7 +747,7 @@ map-is-⊛ f (x ∷ xs) = cong (_ ∷_) (map-is-⊛ f xs)
 ⊛-is-zipWith (f ∷ fs) (x ∷ xs) = cong (f x ∷_) (⊛-is-zipWith fs xs)
 
 zipWith-is-⊛ : ∀ (f : A → B → C) (xs : Vec A n) (ys : Vec B n) →
-               zipWith f xs ys ≡ (replicate f ⊛ xs ⊛ ys)
+               zipWith f xs ys ≡ (replicate n f ⊛ xs ⊛ ys)
 zipWith-is-⊛ f []       []       = refl
 zipWith-is-⊛ f (x ∷ xs) (y ∷ ys) = cong (_ ∷_) (zipWith-is-⊛ f xs ys)
 
@@ -739,6 +759,7 @@ zipWith-is-⊛ f (x ∷ xs) (y ∷ ys) = cong (_ ∷_) (zipWith-is-⊛ f xs ys)
   diagonal (map (flip map xs) fs)                  ≡⟨⟩
   diagonal (map (tail ∘ flip map (x ∷ xs)) fs)     ≡⟨ cong diagonal (map-∘ _ _ _) ⟩
   diagonal (map tail (map (flip map (x ∷ xs)) fs)) ∎
+  where open ≡-Reasoning
 
 ------------------------------------------------------------------------
 -- _⊛*_
@@ -766,6 +787,7 @@ foldl-universal B f e h base step (x ∷ xs) = begin
   h (B ∘ suc) f (f e x) xs     ≡⟨ foldl-universal _ f (f e x) h base step xs ⟩
   foldl (B ∘ suc) f (f e x) xs ≡⟨⟩
   foldl B f e (x ∷ xs)         ∎
+  where open ≡-Reasoning
 
 foldl-fusion : ∀ {B : ℕ → Set b} {C : ℕ → Set c}
                (h : ∀ {n} → B n → C n) →
@@ -778,6 +800,7 @@ foldl-fusion h {f} {d} {g} {e} base fuse []       = base
 foldl-fusion h {f} {d} {g} {e} base fuse (x ∷ xs) =
   foldl-fusion h eq fuse xs
   where
+    open ≡-Reasoning
     eq : h (f d x) ≡ g e x
     eq = begin
       h (f d x) ≡⟨ fuse d x ⟩
@@ -805,6 +828,7 @@ module _ (B : ℕ → Set b) (f : FoldrOp A B) {e : B zero} where
     h (x ∷ xs)           ≡⟨ step x xs ⟩
     f x (h xs)           ≡⟨ cong (f x) (foldr-universal h base step xs) ⟩
     f x (foldr B f e xs) ∎
+    where open ≡-Reasoning
 
   foldr-[] : foldr B f e [] ≡ e
   foldr-[] = refl
@@ -839,10 +863,16 @@ map-is-foldr f = foldr-universal (Vec _) (λ x ys → f x ∷ ys) (map f) refl (
 ------------------------------------------------------------------------
 -- _∷ʳ_
 
+-- snoc is snoc
+
+unfold-∷ʳ : ∀ .(eq : suc n ≡ n + 1) x (xs : Vec A n) → cast eq (xs ∷ʳ x) ≡ xs ++ [ x ]
+unfold-∷ʳ eq x []       = refl
+unfold-∷ʳ eq x (y ∷ xs) = cong (y ∷_) (unfold-∷ʳ (cong pred eq) x xs)
+
 ∷ʳ-injective : ∀ (xs ys : Vec A n) → xs ∷ʳ x ≡ ys ∷ʳ y → xs ≡ ys × x ≡ y
 ∷ʳ-injective []       []        refl = (refl , refl)
 ∷ʳ-injective (x ∷ xs) (y  ∷ ys) eq   with ∷-injective eq
-... | refl , eq′ = Prod.map₁ (cong (x ∷_)) (∷ʳ-injective xs ys eq′)
+... | refl , eq′ = Product.map₁ (cong (x ∷_)) (∷ʳ-injective xs ys eq′)
 
 ∷ʳ-injectiveˡ : ∀ (xs ys : Vec A n) → xs ∷ʳ x ≡ ys ∷ʳ y → xs ≡ ys
 ∷ʳ-injectiveˡ xs ys eq = proj₁ (∷ʳ-injective xs ys eq)
@@ -860,12 +890,42 @@ foldr-∷ʳ : ∀ (B : ℕ → Set b) (f : FoldrOp A B) {e} y (ys : Vec A n) →
 foldr-∷ʳ B f y []       = refl
 foldr-∷ʳ B f y (x ∷ xs) = cong (f x) (foldr-∷ʳ B f y xs)
 
+-- init, last and _∷ʳ_
+
+init-∷ʳ : ∀ x (xs : Vec A n) → init (xs ∷ʳ x) ≡ xs
+init-∷ʳ x []       = refl
+init-∷ʳ x (y ∷ xs) = cong (y ∷_) (init-∷ʳ x xs)
+
+last-∷ʳ : ∀ x (xs : Vec A n) → last (xs ∷ʳ x) ≡ x
+last-∷ʳ x []       = refl
+last-∷ʳ x (y ∷ xs) = last-∷ʳ x xs
+
 -- map and _∷ʳ_
 
 map-∷ʳ : ∀ (f : A → B) x (xs : Vec A n) → map f (xs ∷ʳ x) ≡ map f xs ∷ʳ f x
 map-∷ʳ f x []       = refl
 map-∷ʳ f x (y ∷ xs) = cong (f y ∷_) (map-∷ʳ f x xs)
 
+-- cast and _∷ʳ_
+
+cast-∷ʳ : ∀ .(eq : suc n ≡ suc m) x (xs : Vec A n) →
+          cast eq (xs ∷ʳ x) ≡ (cast (cong pred eq) xs) ∷ʳ x
+cast-∷ʳ {m = zero}  eq x []       = refl
+cast-∷ʳ {m = suc m} eq x (y ∷ xs) = cong (y ∷_) (cast-∷ʳ (cong pred eq) x xs)
+
+-- _++_ and _∷ʳ_
+
+++-∷ʳ : ∀ .(eq : suc (m + n) ≡ m + suc n) z (xs : Vec A m) (ys : Vec A n) →
+        cast eq ((xs ++ ys) ∷ʳ z) ≡ xs ++ (ys ∷ʳ z)
+++-∷ʳ {m = zero}  eq z []       []       = refl
+++-∷ʳ {m = zero}  eq z []       (y ∷ ys) = cong (y ∷_) (++-∷ʳ refl z [] ys)
+++-∷ʳ {m = suc m} eq z (x ∷ xs) ys       = cong (x ∷_) (++-∷ʳ (cong pred eq) z xs ys)
+
+∷ʳ-++ : ∀ .(eq : (suc n) + m ≡ n + suc m) a (xs : Vec A n) {ys} →
+        cast eq ((xs ∷ʳ a) ++ ys) ≡ xs ++ (a ∷ ys)
+∷ʳ-++ eq a []       {ys} = cong (a ∷_) (cast-is-id (cong pred eq) ys)
+∷ʳ-++ eq a (x ∷ xs) {ys} = cong (x ∷_) (∷ʳ-++ (cong pred eq) a xs)
+
 ------------------------------------------------------------------------
 -- reverse
 
@@ -885,6 +945,7 @@ foldl-reverse B f {e} (x ∷ xs) = begin
   f (foldl B f e (reverse xs)) x ≡⟨ cong (flip f x) (foldl-reverse B f xs) ⟩
   f (foldr B (flip f) e xs) x    ≡⟨⟩
   foldr B (flip f) e (x ∷ xs)    ∎
+  where open ≡-Reasoning
 
 -- foldr after a reverse is a foldl
 
@@ -897,22 +958,41 @@ foldr-reverse B f {e} xs = foldl-fusion (foldr B f e) refl (λ _ _ → refl) xs
 reverse-involutive : Involutive {A = Vec A n} _≡_ reverse
 reverse-involutive xs = begin
   reverse (reverse xs)    ≡⟨  foldl-reverse (Vec _) (flip _∷_) xs ⟩
-  foldr (Vec _) _∷_ [] xs ≡˘⟨ id-is-foldr xs ⟩
+  foldr (Vec _) _∷_ [] xs ≡⟨ id-is-foldr xs ⟨
   xs                      ∎
+  where open ≡-Reasoning
 
 reverse-reverse : reverse xs ≡ ys → reverse ys ≡ xs
 reverse-reverse {xs = xs} {ys} eq =  begin
-  reverse ys           ≡˘⟨ cong reverse eq ⟩
+  reverse ys           ≡⟨ cong reverse eq ⟨
   reverse (reverse xs) ≡⟨  reverse-involutive xs ⟩
   xs                   ∎
+  where open ≡-Reasoning
 
 -- reverse is injective.
 
 reverse-injective : reverse xs ≡ reverse ys → xs ≡ ys
 reverse-injective {xs = xs} {ys} eq = begin
-  xs                   ≡˘⟨ reverse-reverse eq ⟩
+  xs                   ≡⟨ reverse-reverse eq ⟨
   reverse (reverse ys) ≡⟨  reverse-involutive ys ⟩
   ys                   ∎
+  where open ≡-Reasoning
+
+-- init and last of reverse
+
+init-reverse : init ∘ reverse ≗ reverse ∘ tail {A = A} {n = n}
+init-reverse (x ∷ xs) = begin
+  init (reverse (x ∷ xs))   ≡⟨ cong init (reverse-∷ x xs) ⟩
+  init (reverse xs ∷ʳ x)    ≡⟨ init-∷ʳ x (reverse xs) ⟩
+  reverse xs                ∎
+  where open ≡-Reasoning
+
+last-reverse : last ∘ reverse ≗ head {A = A} {n = n}
+last-reverse (x ∷ xs) = begin
+  last (reverse (x ∷ xs))   ≡⟨ cong last (reverse-∷ x xs) ⟩
+  last (reverse xs ∷ʳ x)    ≡⟨ last-∷ʳ x (reverse xs) ⟩
+  x                         ∎
+  where open ≡-Reasoning
 
 -- map and reverse
 
@@ -923,9 +1003,35 @@ map-reverse f (x ∷ xs) = begin
   map f (reverse (x ∷ xs))  ≡⟨  cong (map f) (reverse-∷ x xs) ⟩
   map f (reverse xs ∷ʳ x)   ≡⟨  map-∷ʳ f x (reverse xs) ⟩
   map f (reverse xs) ∷ʳ f x ≡⟨  cong (_∷ʳ f x) (map-reverse f xs ) ⟩
-  reverse (map f xs) ∷ʳ f x ≡˘⟨ reverse-∷ (f x) (map f xs) ⟩
+  reverse (map f xs) ∷ʳ f x ≡⟨ reverse-∷ (f x) (map f xs) ⟨
   reverse (f x ∷ map f xs)  ≡⟨⟩
   reverse (map f (x ∷ xs))  ∎
+  where open ≡-Reasoning
+
+-- append and reverse
+
+reverse-++ : ∀ .(eq : m + n ≡ n + m) (xs : Vec A m) (ys : Vec A n) →
+             cast eq (reverse (xs ++ ys)) ≡ reverse ys ++ reverse xs
+reverse-++ {m = zero}  {n = n} eq []       ys = ≈-sym (++-identityʳ (sym eq) (reverse ys))
+reverse-++ {m = suc m} {n = n} eq (x ∷ xs) ys = begin
+  reverse (x ∷ xs ++ ys)              ≂⟨ reverse-∷ x (xs ++ ys) ⟩
+  reverse (xs ++ ys) ∷ʳ x             ≈⟨ ≈-cong (_∷ʳ x) (cast-∷ʳ (cong suc (+-comm m n)) x (reverse (xs ++ ys)))
+                                                (reverse-++ _ xs ys) ⟩
+  (reverse ys ++ reverse xs) ∷ʳ x     ≈⟨ ++-∷ʳ (sym (+-suc n m)) x (reverse ys) (reverse xs) ⟩
+  reverse ys ++ (reverse xs ∷ʳ x)     ≂⟨ cong (reverse ys ++_) (reverse-∷ x xs) ⟨
+  reverse ys ++ (reverse (x ∷ xs))    ∎
+  where open CastReasoning
+
+cast-reverse : ∀ .(eq : m ≡ n) → cast eq ∘ reverse {A = A} {n = m} ≗ reverse ∘ cast eq
+cast-reverse {n = zero}  eq []       = refl
+cast-reverse {n = suc n} eq (x ∷ xs) = begin
+  reverse (x ∷ xs)           ≂⟨ reverse-∷ x xs ⟩
+  reverse xs ∷ʳ x            ≈⟨ ≈-cong (_∷ʳ x) (cast-∷ʳ eq x (reverse xs))
+                                       (cast-reverse (cong pred eq) xs) ⟩
+  reverse (cast _ xs) ∷ʳ x   ≂⟨ reverse-∷ x (cast (cong pred eq) xs) ⟨
+  reverse (x ∷ cast _ xs)    ≈⟨⟩
+  reverse (cast eq (x ∷ xs)) ∎
+  where open CastReasoning
 
 ------------------------------------------------------------------------
 -- _ʳ++_
@@ -951,8 +1057,44 @@ map-ʳ++ {ys = ys} f xs = begin
   map f (xs ʳ++ ys)              ≡⟨  cong (map f) (unfold-ʳ++ xs ys) ⟩
   map f (reverse xs ++ ys)       ≡⟨  map-++ f (reverse xs) ys ⟩
   map f (reverse xs) ++ map f ys ≡⟨  cong (_++ map f ys) (map-reverse f xs) ⟩
-  reverse (map f xs) ++ map f ys ≡˘⟨ unfold-ʳ++ (map f xs) (map f ys) ⟩
+  reverse (map f xs) ++ map f ys ≡⟨ unfold-ʳ++ (map f xs) (map f ys) ⟨
   map f xs ʳ++ map f ys          ∎
+  where open ≡-Reasoning
+
+∷-ʳ++ : ∀ .(eq : (suc m) + n ≡ m + suc n) a (xs : Vec A m) {ys} →
+        cast eq ((a ∷ xs) ʳ++ ys) ≡ xs ʳ++ (a ∷ ys)
+∷-ʳ++ eq a xs {ys} = begin
+  (a ∷ xs) ʳ++ ys         ≂⟨ unfold-ʳ++ (a ∷ xs) ys ⟩
+  reverse (a ∷ xs) ++ ys  ≂⟨ cong (_++ ys) (reverse-∷ a xs) ⟩
+  (reverse xs ∷ʳ a) ++ ys ≈⟨ ∷ʳ-++ eq a (reverse xs) ⟩
+  reverse xs ++ (a ∷ ys)  ≂⟨ unfold-ʳ++ xs (a ∷ ys) ⟨
+  xs ʳ++ (a ∷ ys)         ∎
+  where open CastReasoning
+
+++-ʳ++ : ∀ .(eq : m + n + o ≡ n + (m + o)) (xs : Vec A m) {ys : Vec A n} {zs : Vec A o} →
+         cast eq ((xs ++ ys) ʳ++ zs) ≡ ys ʳ++ (xs ʳ++ zs)
+++-ʳ++ {m = m} {n} {o} eq xs {ys} {zs} = begin
+  ((xs ++ ys) ʳ++ zs)              ≂⟨ unfold-ʳ++ (xs ++ ys) zs ⟩
+  reverse (xs ++ ys) ++ zs         ≈⟨ ≈-cong (_++ zs) (cast-++ˡ (+-comm m n) (reverse (xs ++ ys)))
+                                             (reverse-++ (+-comm m n) xs ys) ⟩
+  (reverse ys ++ reverse xs) ++ zs ≈⟨ ++-assoc (trans (cong (_+ o) (+-comm n m)) eq) (reverse ys) (reverse xs) zs ⟩
+  reverse ys ++ (reverse xs ++ zs) ≂⟨ cong (reverse ys ++_) (unfold-ʳ++ xs zs) ⟨
+  reverse ys ++ (xs ʳ++ zs)        ≂⟨ unfold-ʳ++ ys (xs ʳ++ zs) ⟨
+  ys ʳ++ (xs ʳ++ zs)               ∎
+  where open CastReasoning
+
+ʳ++-ʳ++ : ∀ .(eq : (m + n) + o ≡ n + (m + o)) (xs : Vec A m) {ys : Vec A n} {zs} →
+          cast eq ((xs ʳ++ ys) ʳ++ zs) ≡ ys ʳ++ (xs ++ zs)
+ʳ++-ʳ++ {m = m} {n} {o} eq xs {ys} {zs} = begin
+  (xs ʳ++ ys) ʳ++ zs                         ≂⟨ cong (_ʳ++ zs) (unfold-ʳ++ xs ys) ⟩
+  (reverse xs ++ ys) ʳ++ zs                  ≂⟨ unfold-ʳ++ (reverse xs ++ ys) zs ⟩
+  reverse (reverse xs ++ ys) ++ zs           ≈⟨ ≈-cong (_++ zs) (cast-++ˡ (+-comm m n) (reverse (reverse xs ++ ys)))
+                                                       (reverse-++ (+-comm m n) (reverse xs) ys) ⟩
+  (reverse ys ++ reverse (reverse xs)) ++ zs ≂⟨ cong ((_++ zs) ∘ (reverse ys ++_)) (reverse-involutive xs) ⟩
+  (reverse ys ++ xs) ++ zs                   ≈⟨ ++-assoc (+-assoc n m o) (reverse ys) xs zs ⟩
+  reverse ys ++ (xs ++ zs)                   ≂⟨ unfold-ʳ++ ys (xs ++ zs) ⟨
+  ys ʳ++ (xs ++ zs)                          ∎
+  where open CastReasoning
 
 ------------------------------------------------------------------------
 -- sum
@@ -961,47 +1103,77 @@ sum-++ : ∀ (xs : Vec ℕ m) → sum (xs ++ ys) ≡ sum xs + sum ys
 sum-++ {_}       []       = refl
 sum-++ {ys = ys} (x ∷ xs) = begin
   x + sum (xs ++ ys)     ≡⟨  cong (x +_) (sum-++ xs) ⟩
-  x + (sum xs + sum ys)  ≡˘⟨ +-assoc x (sum xs) (sum ys) ⟩
+  x + (sum xs + sum ys)  ≡⟨ +-assoc x (sum xs) (sum ys) ⟨
   sum (x ∷ xs) + sum ys  ∎
+  where open ≡-Reasoning
 
 ------------------------------------------------------------------------
 -- replicate
 
-lookup-replicate : ∀ (i : Fin n) (x : A) → lookup (replicate x) i ≡ x
+lookup-replicate : ∀ (i : Fin n) (x : A) → lookup (replicate n x) i ≡ x
 lookup-replicate zero    x = refl
 lookup-replicate (suc i) x = lookup-replicate i x
 
 map-replicate :  ∀ (f : A → B) (x : A) n →
-                 map f (replicate x) ≡ replicate {n = n} (f x)
+                 map f (replicate n x) ≡ replicate n (f x)
 map-replicate f x zero = refl
 map-replicate f x (suc n) = cong (f x ∷_) (map-replicate f x n)
 
 transpose-replicate : ∀ (xs : Vec A m) →
-                      transpose (replicate {n = n} xs) ≡ map replicate xs
+                      transpose (replicate n xs) ≡ map (replicate n) xs
 transpose-replicate {n = zero}  _  = sym (map-const _ [])
 transpose-replicate {n = suc n} xs = begin
-  transpose (replicate xs)                        ≡⟨⟩
-  (replicate _∷_ ⊛ xs ⊛ transpose (replicate xs)) ≡⟨ cong₂ _⊛_ (sym (map-is-⊛ _∷_ xs)) (transpose-replicate xs) ⟩
-  (map _∷_ xs ⊛ map replicate xs)                 ≡⟨ map-⊛ _∷_ replicate xs ⟩
-  map replicate xs                                ∎
+  transpose (replicate (suc n) xs)                    ≡⟨⟩
+  (replicate _ _∷_ ⊛ xs ⊛ transpose (replicate _ xs)) ≡⟨ cong₂ _⊛_ (sym (map-is-⊛ _∷_ xs)) (transpose-replicate xs) ⟩
+  (map _∷_ xs ⊛ map (replicate n) xs)                 ≡⟨ map-⊛ _∷_ (replicate n) xs ⟩
+  map (replicate (suc n)) xs                          ∎
+  where open ≡-Reasoning
 
 zipWith-replicate : ∀ (_⊕_ : A → B → C) (x : A) (y : B) →
-                    zipWith {n = n} _⊕_ (replicate x) (replicate y) ≡ replicate (x ⊕ y)
+                    zipWith _⊕_ (replicate n x) (replicate n y) ≡ replicate n (x ⊕ y)
 zipWith-replicate {n = zero}  _⊕_ x y = refl
 zipWith-replicate {n = suc n} _⊕_ x y = cong (x ⊕ y ∷_) (zipWith-replicate _⊕_ x y)
 
 zipWith-replicate₁ : ∀ (_⊕_ : A → B → C) (x : A) (ys : Vec B n) →
-                     zipWith _⊕_ (replicate x) ys ≡ map (x ⊕_) ys
+                     zipWith _⊕_ (replicate n x) ys ≡ map (x ⊕_) ys
 zipWith-replicate₁ _⊕_ x []       = refl
 zipWith-replicate₁ _⊕_ x (y ∷ ys) =
   cong (x ⊕ y ∷_) (zipWith-replicate₁ _⊕_ x ys)
 
 zipWith-replicate₂ : ∀ (_⊕_ : A → B → C) (xs : Vec A n) (y : B) →
-                     zipWith _⊕_ xs (replicate y) ≡ map (_⊕ y) xs
+                     zipWith _⊕_ xs (replicate n y) ≡ map (_⊕ y) xs
 zipWith-replicate₂ _⊕_ []       y = refl
 zipWith-replicate₂ _⊕_ (x ∷ xs) y =
   cong (x ⊕ y ∷_) (zipWith-replicate₂ _⊕_ xs y)
 
+toList-replicate : ∀ (n : ℕ) (x : A) →
+                   toList (replicate n x) ≡ List.replicate n x
+toList-replicate zero    x = refl
+toList-replicate (suc n) x = cong (_ List.∷_) (toList-replicate n x)
+
+------------------------------------------------------------------------
+-- iterate
+
+iterate-id : ∀ (x : A) n → iterate id x n ≡ replicate n x
+iterate-id x zero    = refl
+iterate-id x (suc n) = cong (_ ∷_) (iterate-id (id x) n)
+
+take-iterate : ∀ n f (x : A) → take n (iterate f x (n + m)) ≡ iterate f x n
+take-iterate zero    f x = refl
+take-iterate (suc n) f x = cong (_ ∷_) (take-iterate n f (f x))
+
+drop-iterate : ∀ n f (x : A) → drop n (iterate f x (n + zero)) ≡ []
+drop-iterate zero    f x = refl
+drop-iterate (suc n) f x = drop-iterate n f (f x)
+
+lookup-iterate :  ∀ f (x : A) (i : Fin n) → lookup (iterate f x n) i ≡ ℕ.iterate f x (toℕ i)
+lookup-iterate f x zero    = refl
+lookup-iterate f x (suc i) = lookup-iterate f (f x) i
+
+toList-iterate : ∀ f (x : A) n → toList (iterate f x n) ≡ List.iterate f x n
+toList-iterate f x zero    = refl
+toList-iterate f x (suc n) = cong (_ List.∷_) (toList-iterate f (f x) n)
+
 ------------------------------------------------------------------------
 -- tabulate
 
@@ -1040,9 +1212,10 @@ tabulate-allFin f = tabulate-∘ f id
 
 map-lookup-allFin : ∀ (xs : Vec A n) → map (lookup xs) (allFin n) ≡ xs
 map-lookup-allFin {n = n} xs = begin
-  map (lookup xs) (allFin n) ≡˘⟨ tabulate-∘ (lookup xs) id ⟩
+  map (lookup xs) (allFin n) ≡⟨ tabulate-∘ (lookup xs) id ⟨
   tabulate (lookup xs)       ≡⟨ tabulate∘lookup xs ⟩
   xs                         ∎
+  where open ≡-Reasoning
 
 ------------------------------------------------------------------------
 -- count
@@ -1056,42 +1229,57 @@ module _ {P : Pred A p} (P? : Decidable P) where
   ... | false = m≤n⇒m≤1+n (count≤n xs)
 
 ------------------------------------------------------------------------
--- insert
-
-insert-lookup : ∀ (xs : Vec A n) (i : Fin (suc n)) (v : A) →
-                lookup (insert xs i v) i ≡ v
-insert-lookup xs       zero     v = refl
-insert-lookup (x ∷ xs) (suc i)  v = insert-lookup xs i v
-
-insert-punchIn : ∀ (xs : Vec A n) (i : Fin (suc n)) (v : A) (j : Fin n) →
-                 lookup (insert xs i v) (Fin.punchIn i j) ≡ lookup xs j
-insert-punchIn xs       zero     v j       = refl
-insert-punchIn (x ∷ xs) (suc i)  v zero    = refl
-insert-punchIn (x ∷ xs) (suc i)  v (suc j) = insert-punchIn xs i v j
-
-remove-punchOut : ∀ (xs : Vec A (suc n)) {i} {j} (i≢j : i ≢ j) →
-                  lookup (remove xs i) (Fin.punchOut i≢j) ≡ lookup xs j
-remove-punchOut (x ∷ xs)     {zero}  {zero}  i≢j = contradiction refl i≢j
-remove-punchOut (x ∷ xs)     {zero}  {suc j} i≢j = refl
-remove-punchOut (x ∷ y ∷ xs) {suc i} {zero}  i≢j = refl
-remove-punchOut (x ∷ y ∷ xs) {suc i} {suc j} i≢j =
-  remove-punchOut (y ∷ xs) (i≢j ∘ cong suc)
+-- length
+
+length-toList : (xs : Vec A n) → List.length (toList xs) ≡ length xs
+length-toList []       = refl
+length-toList (x ∷ xs) = cong suc (length-toList xs)
+
+------------------------------------------------------------------------
+-- insertAt
+
+insertAt-lookup : ∀ (xs : Vec A n) (i : Fin (suc n)) (v : A) →
+                  lookup (insertAt xs i v) i ≡ v
+insertAt-lookup xs       zero     v = refl
+insertAt-lookup (x ∷ xs) (suc i)  v = insertAt-lookup xs i v
+
+insertAt-punchIn : ∀ (xs : Vec A n) (i : Fin (suc n)) (v : A) (j : Fin n) →
+                   lookup (insertAt xs i v) (Fin.punchIn i j) ≡ lookup xs j
+insertAt-punchIn xs       zero     v j       = refl
+insertAt-punchIn (x ∷ xs) (suc i)  v zero    = refl
+insertAt-punchIn (x ∷ xs) (suc i)  v (suc j) = insertAt-punchIn xs i v j
+
+toList-insertAt : ∀ (xs : Vec A n) (i : Fin (suc n)) (v : A) →
+                  toList (insertAt xs i v) ≡ List.insertAt (toList xs) (Fin.cast (cong suc (sym (length-toList xs))) i) v
+toList-insertAt xs       zero    v = refl
+toList-insertAt (x ∷ xs) (suc i) v = cong (_ List.∷_) (toList-insertAt xs i v)
+
+------------------------------------------------------------------------
+-- removeAt
+
+removeAt-punchOut : ∀ (xs : Vec A (suc n)) {i} {j} (i≢j : i ≢ j) →
+                  lookup (removeAt xs i) (Fin.punchOut i≢j) ≡ lookup xs j
+removeAt-punchOut (x ∷ xs)     {zero}  {zero}  i≢j = contradiction refl i≢j
+removeAt-punchOut (x ∷ xs)     {zero}  {suc j} i≢j = refl
+removeAt-punchOut (x ∷ y ∷ xs) {suc i} {zero}  i≢j = refl
+removeAt-punchOut (x ∷ y ∷ xs) {suc i} {suc j} i≢j =
+  removeAt-punchOut (y ∷ xs) (i≢j ∘ cong suc)
 
 ------------------------------------------------------------------------
--- remove
+-- insertAt and removeAt
 
-remove-insert : ∀ (xs : Vec A n) (i : Fin (suc n)) (v : A) →
-                remove (insert xs i v) i ≡ xs
-remove-insert xs           zero           v = refl
-remove-insert (x ∷ xs)     (suc zero)     v = refl
-remove-insert (x ∷ y ∷ xs) (suc (suc i))  v =
-  cong (x ∷_) (remove-insert (y ∷ xs) (suc i) v)
+removeAt-insertAt : ∀ (xs : Vec A n) (i : Fin (suc n)) (v : A) →
+                    removeAt (insertAt xs i v) i ≡ xs
+removeAt-insertAt xs               zero           v = refl
+removeAt-insertAt (x ∷ xs)         (suc zero)     v = refl
+removeAt-insertAt (x ∷ xs@(_ ∷ _)) (suc (suc i))  v =
+  cong (x ∷_) (removeAt-insertAt xs (suc i) v)
 
-insert-remove : ∀ (xs : Vec A (suc n)) (i : Fin (suc n)) →
-                insert (remove xs i) i (lookup xs i) ≡ xs
-insert-remove (x ∷ xs)     zero     = refl
-insert-remove (x ∷ y ∷ xs) (suc i)  =
-  cong (x ∷_) (insert-remove (y ∷ xs) i)
+insertAt-removeAt : ∀ (xs : Vec A (suc n)) (i : Fin (suc n)) →
+                    insertAt (removeAt xs i) i (lookup xs i) ≡ xs
+insertAt-removeAt (x ∷ xs)         zero     = refl
+insertAt-removeAt (x ∷ xs@(_ ∷ _)) (suc i)  =
+  cong (x ∷_) (insertAt-removeAt xs i)
 
 ------------------------------------------------------------------------
 -- Conversion function
@@ -1100,6 +1288,43 @@ toList∘fromList : (xs : List A) → toList (fromList xs) ≡ xs
 toList∘fromList List.[]       = refl
 toList∘fromList (x List.∷ xs) = cong (x List.∷_) (toList∘fromList xs)
 
+toList-cast : ∀ .(eq : m ≡ n) (xs : Vec A m) → toList (cast eq xs) ≡ toList xs
+toList-cast {n = zero}  eq []       = refl
+toList-cast {n = suc _} eq (x ∷ xs) =
+  cong (x List.∷_) (toList-cast (cong pred eq) xs)
+
+cast-fromList : ∀ {xs ys : List A} (eq : xs ≡ ys) →
+                cast (cong List.length eq) (fromList xs) ≡ fromList ys
+cast-fromList {xs = List.[]}     {ys = List.[]}     eq = refl
+cast-fromList {xs = x List.∷ xs} {ys = y List.∷ ys} eq =
+  let x≡y , xs≡ys = List.∷-injective eq in begin
+  x ∷ cast (cong (pred ∘ List.length) eq) (fromList xs) ≡⟨ cong (_ ∷_) (cast-fromList xs≡ys) ⟩
+  x ∷ fromList ys                                       ≡⟨ cong (_∷ _) x≡y ⟩
+  y ∷ fromList ys                                       ∎
+  where open ≡-Reasoning
+
+fromList-map : ∀ (f : A → B) (xs : List A) →
+               cast (List.length-map f xs) (fromList (List.map f xs)) ≡ map f (fromList xs)
+fromList-map f List.[]       = refl
+fromList-map f (x List.∷ xs) = cong (f x ∷_) (fromList-map f xs)
+
+fromList-++ : ∀ (xs : List A) {ys : List A} →
+              cast (List.length-++ xs) (fromList (xs List.++ ys)) ≡ fromList xs ++ fromList ys
+fromList-++ List.[]       {ys} = cast-is-id refl (fromList ys)
+fromList-++ (x List.∷ xs) {ys} = cong (x ∷_) (fromList-++ xs)
+
+fromList-reverse : (xs : List A) → cast (List.length-reverse xs) (fromList (List.reverse xs)) ≡ reverse (fromList xs)
+fromList-reverse List.[] = refl
+fromList-reverse (x List.∷ xs) = begin
+  fromList (List.reverse (x List.∷ xs))         ≈⟨ cast-fromList (List.ʳ++-defn xs) ⟩
+  fromList (List.reverse xs List.++ List.[ x ]) ≈⟨ fromList-++ (List.reverse xs) ⟩
+  fromList (List.reverse xs) ++ [ x ]           ≈⟨ unfold-∷ʳ (+-comm 1 _) x (fromList (List.reverse xs)) ⟨
+  fromList (List.reverse xs) ∷ʳ x               ≈⟨ ≈-cong (_∷ʳ x) (cast-∷ʳ (cong suc (List.length-reverse xs)) _ _)
+                                                          (fromList-reverse xs) ⟩
+  reverse (fromList xs) ∷ʳ x                    ≂⟨ reverse-∷ x (fromList xs) ⟨
+  reverse (x ∷ fromList xs)                     ≈⟨⟩
+  reverse (fromList (x List.∷ xs))              ∎
+  where open CastReasoning
 
 ------------------------------------------------------------------------
 -- DEPRECATED NAMES
@@ -1115,16 +1340,16 @@ updateAt-id-relative = updateAt-id-local
 Please use updateAt-id-local instead."
 #-}
 
-updateAt-compose-relative = updateAt-∘-local
+updateAt-compose-relative = updateAt-updateAt-local
 {-# WARNING_ON_USAGE updateAt-compose-relative
 "Warning: updateAt-compose-relative was deprecated in v2.0.
-Please use updateAt-∘-local instead."
+Please use updateAt-updateAt-local instead."
 #-}
 
-updateAt-compose = updateAt-∘
+updateAt-compose = updateAt-updateAt
 {-# WARNING_ON_USAGE updateAt-compose
 "Warning: updateAt-compose was deprecated in v2.0.
-Please use updateAt-∘ instead."
+Please use updateAt-updateAt instead."
 #-}
 
 updateAt-cong-relative = updateAt-cong-local
@@ -1156,3 +1381,73 @@ sum-++-commute = sum-++
 "Warning: sum-++-commute was deprecated in v2.0.
 Please use sum-++ instead."
 #-}
+take-drop-id = take++drop≡id
+{-# WARNING_ON_USAGE take-drop-id
+"Warning: take-drop-id was deprecated in v2.0.
+Please use take++drop≡id instead."
+#-}
+take-distr-zipWith = take-zipWith
+{-# WARNING_ON_USAGE take-distr-zipWith
+"Warning: take-distr-zipWith was deprecated in v2.0.
+Please use take-zipWith instead."
+#-}
+take-distr-map = take-map
+{-# WARNING_ON_USAGE take-distr-map
+"Warning: take-distr-map was deprecated in v2.0.
+Please use take-map instead."
+#-}
+drop-distr-zipWith = drop-zipWith
+{-# WARNING_ON_USAGE drop-distr-zipWith
+"Warning: drop-distr-zipWith was deprecated in v2.0.
+Please use drop-zipWith instead."
+#-}
+drop-distr-map = drop-map
+{-# WARNING_ON_USAGE drop-distr-map
+"Warning: drop-distr-map was deprecated in v2.0.
+Please use drop-map instead."
+#-}
+
+map-insert = map-insertAt
+{-# WARNING_ON_USAGE map-insert
+"Warning: map-insert was deprecated in v2.0.
+Please use map-insertAt instead."
+#-}
+insert-lookup = insertAt-lookup
+{-# WARNING_ON_USAGE insert-lookup
+"Warning: insert-lookup was deprecated in v2.0.
+Please use insertAt-lookup instead."
+#-}
+insert-punchIn = insertAt-punchIn
+{-# WARNING_ON_USAGE insert-punchIn
+"Warning: insert-punchIn was deprecated in v2.0.
+Please use insertAt-punchIn instead."
+#-}
+remove-PunchOut = removeAt-punchOut
+{-# WARNING_ON_USAGE remove-PunchOut
+"Warning: remove-PunchOut was deprecated in v2.0.
+Please use removeAt-punchOut instead."
+#-}
+remove-insert = removeAt-insertAt
+{-# WARNING_ON_USAGE remove-insert
+"Warning: remove-insert was deprecated in v2.0.
+Please use removeAt-insertAt instead."
+#-}
+insert-remove = insertAt-removeAt
+{-# WARNING_ON_USAGE insert-remove
+"Warning: insert-remove was deprecated in v2.0.
+Please use insertAt-removeAt instead."
+#-}
+
+lookup-inject≤-take : ∀ m (m≤m+n : m ≤ m + n) (i : Fin m) (xs : Vec A (m + n)) →
+                      lookup xs (Fin.inject≤ i m≤m+n) ≡ lookup (take m xs) i
+lookup-inject≤-take m m≤m+n i xs = sym (begin
+  lookup (take m xs) i
+    ≡⟨ lookup-take-inject≤ xs i ⟩
+  lookup xs (Fin.inject≤ i _)
+    ≡⟨⟩
+  lookup xs (Fin.inject≤ i m≤m+n)
+    ∎) where open ≡-Reasoning
+{-# WARNING_ON_USAGE lookup-inject≤-take
+"Warning: lookup-inject≤-take was deprecated in v2.0.
+Please use lookup-take-inject≤ or lookup-truncate, take≡truncate instead."
+#-}
diff --git a/src/Data/Vec/Properties/WithK.agda b/src/Data/Vec/Properties/WithK.agda
index 8d3bd95aee..f587d16b64 100644
--- a/src/Data/Vec/Properties/WithK.agda
+++ b/src/Data/Vec/Properties/WithK.agda
@@ -12,8 +12,8 @@ module Data.Vec.Properties.WithK where
 open import Data.Nat.Base
 open import Data.Nat.Properties using (+-assoc)
 open import Data.Vec.Base
-open import Relation.Binary.PropositionalEquality as P using (_≡_; refl)
-open import Relation.Binary.HeterogeneousEquality as H using (_≅_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
+open import Relation.Binary.HeterogeneousEquality as ≅ using (_≅_; refl)
 
 ------------------------------------------------------------------------
 -- _[_]=_
@@ -24,7 +24,7 @@ module _ {a} {A : Set a} where
                     (p q : xs [ i ]= x) → p ≡ q
   []=-irrelevant here            here             = refl
   []=-irrelevant (there xs[i]=x) (there xs[i]=x′) =
-    P.cong there ([]=-irrelevant xs[i]=x xs[i]=x′)
+    cong there ([]=-irrelevant xs[i]=x xs[i]=x′)
 
 ------------------------------------------------------------------------
 -- _++_
@@ -35,7 +35,7 @@ module _ {a} {A : Set a} where
              (xs ++ ys) ++ zs ≅ xs ++ (ys ++ zs)
   ++-assoc         []       ys zs = refl
   ++-assoc {suc m} (x ∷ xs) ys zs =
-    H.icong (Vec A) (+-assoc m _ _) (x ∷_) (++-assoc xs ys zs)
+    ≅.icong (Vec A) (+-assoc m _ _) (x ∷_) (++-assoc xs ys zs)
 
 ------------------------------------------------------------------------
 -- foldr
diff --git a/src/Data/Vec/Recursive.agda b/src/Data/Vec/Recursive.agda
index 765db00991..0eb04b264b 100644
--- a/src/Data/Vec/Recursive.agda
+++ b/src/Data/Vec/Recursive.agda
@@ -4,27 +4,24 @@
 -- Vectors defined by recursion
 ------------------------------------------------------------------------
 
--- What is the point of this module? The n-ary products below are intended
--- to be used with a fixed n, in which case the nil constructor can be
--- avoided: pairs are represented as pairs (x , y), not as triples
--- (x , y , unit).
--- Additionally, vectors defined by recursion enjoy η-rules. That is to say
--- that two vectors of known length are definitionally equal whenever their
--- elements are.
+-- What is the point of this module? The n-ary products below are
+-- intended to be used with a fixed n, in which case the nil constructor
+-- can be avoided: pairs are represented as pairs (x , y), not as
+-- triples (x , y , unit).
+-- Additionally, vectors defined by recursion enjoy η-rules. That is to
+-- say that two vectors of known length are definitionally equal
+-- whenever their elements are.
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Data.Vec.Recursive where
 
-open import Level using (Level; lift)
-open import Function.Bundles using (mk↔′)
-open import Function.Properties.Inverse using (↔-isEquivalence; ↔-refl; ↔-sym; ↔-trans)
 open import Data.Nat.Base as Nat using (ℕ; zero; suc; NonZero; pred)
 open import Data.Nat.Properties using (+-comm; *-comm)
 open import Data.Empty.Polymorphic
 open import Data.Fin.Base as Fin using (Fin; zero; suc)
 open import Data.Fin.Properties using (1↔⊤; *↔×)
-open import Data.Product as Prod using (_×_; _,_; proj₁; proj₂)
+open import Data.Product.Base as Product using (_×_; _,_; proj₁; proj₂)
 open import Data.Product.Algebra using (×-cong)
 open import Data.Sum.Base as Sum using (_⊎_)
 open import Data.Unit.Base using (tt)
@@ -32,8 +29,11 @@ open import Data.Unit.Polymorphic.Base using (⊤)
 open import Data.Unit.Polymorphic.Properties using (⊤↔⊤*)
 open import Data.Vec.Base as Vec using (Vec; _∷_)
 open import Data.Vec.N-ary using (N-ary)
-open import Function
-open import Relation.Unary
+open import Function.Base using (_∘′_; _∘_; id; const)
+open import Function.Bundles using (_↔_; mk↔ₛ′; mk↔)
+open import Function.Properties.Inverse using (↔-isEquivalence; ↔-refl; ↔-sym; ↔-trans)
+open import Level using (Level; lift)
+open import Relation.Unary using (IUniversal; Universal; _⇒_)
 open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; sym; trans; cong; subst)
 open import Relation.Binary.Structures using (IsEquivalence)
 
@@ -44,8 +44,8 @@ private
     B : Set b
     C : Set c
 
--- Types and patterns
 ------------------------------------------------------------------------
+-- Types and patterns
 
 infix 8 _^_
 _^_ : Set a → ℕ → Set a
@@ -61,8 +61,8 @@ a ∈[ 0    ] as               = ⊥
 a ∈[ 1    ] a′               = a ≡ a′
 a ∈[ suc n@(suc _) ] a′ , as = a ≡ a′ ⊎ a ∈[ n ] as
 
--- Basic operations
 ------------------------------------------------------------------------
+-- Basic operations
 
 cons : ∀ n → A → A ^ n → A ^ suc n
 cons 0       a _  = a
@@ -90,7 +90,7 @@ lookup as (zero {n})  = head n as
 lookup as (suc {n} k) = lookup (tail n as) k
 
 replicate : ∀ n → A → A ^ n
-replicate n a = fromVec (Vec.replicate a)
+replicate n a = fromVec (Vec.replicate n a)
 
 tabulate : ∀ n → (Fin n → A) → A ^ n
 tabulate n f = fromVec (Vec.tabulate f)
@@ -106,9 +106,8 @@ splitAt (suc m) n xs =
   let (ys , zs) = splitAt m n (tail (m Nat.+ n) xs) in
   cons m (head (m Nat.+ n) xs) ys , zs
 
-
--- Manipulating N-ary products
 ------------------------------------------------------------------------
+-- Manipulating N-ary products
 
 map : (A → B) → ∀ n → A ^ n → B ^ n
 map f 0      as       = lift tt
@@ -147,7 +146,7 @@ zipWith f ((suc n@(suc _))) (a , as) (b , bs) = f a b , zipWith f n as bs
 unzipWith : (A → B × C) → ∀ n → A ^ n → B ^ n × C ^ n
 unzipWith f 0               as       = [] , []
 unzipWith f 1               a        = f a
-unzipWith f (suc n@(suc _)) (a , as) = Prod.zip _,_ _,_ (f a) (unzipWith f n as)
+unzipWith f (suc n@(suc _)) (a , as) = Product.zip _,_ _,_ (f a) (unzipWith f n as)
 
 zip : ∀ n → A ^ n → B ^ n → (A × B) ^ n
 zip = zipWith _,_
@@ -156,7 +155,7 @@ unzip : ∀ n → (A × B) ^ n → A ^ n × B ^ n
 unzip = unzipWith id
 
 lift↔ : ∀ n → A ↔ B → A ^ n ↔ B ^ n
-lift↔ 0               A↔B = mk↔ ((λ { [] → refl }) , (λ{ [] → refl }))
+lift↔ 0               A↔B = mk↔ₛ′ _ _ (const refl) (const refl)
 lift↔ 1               A↔B = A↔B
 lift↔ (suc n@(suc _)) A↔B = ×-cong A↔B (lift↔ n A↔B)
 
diff --git a/src/Data/Vec/Recursive/Categorical.agda b/src/Data/Vec/Recursive/Categorical.agda
new file mode 100644
index 0000000000..1dba5fd7b0
--- /dev/null
+++ b/src/Data/Vec/Recursive/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Data.Vec.Recursive.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Vec.Recursive.Categorical where
+
+open import Data.Vec.Recursive.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Data.Vec.Recursive.Categorical was deprecated in v2.0.
+Use Data.Vec.Recursive.Effectful instead."
+#-}
diff --git a/src/Data/Vec/Recursive/Effectful.agda b/src/Data/Vec/Recursive/Effectful.agda
index 567020352a..97aaa5b053 100644
--- a/src/Data/Vec/Recursive/Effectful.agda
+++ b/src/Data/Vec/Recursive/Effectful.agda
@@ -9,12 +9,12 @@
 module Data.Vec.Recursive.Effectful where
 
 open import Agda.Builtin.Nat
-open import Data.Product hiding (map)
+open import Data.Product.Base hiding (map)
 open import Data.Vec.Recursive
 open import Effect.Functor
 open import Effect.Applicative
 open import Effect.Monad
-open import Function
+open import Function.Base using (_∘_; flip)
 
 ------------------------------------------------------------------------
 -- Functor and applicative
diff --git a/src/Data/Vec/Recursive/Properties.agda b/src/Data/Vec/Recursive/Properties.agda
index 745681a617..3f25aa19d1 100644
--- a/src/Data/Vec/Recursive/Properties.agda
+++ b/src/Data/Vec/Recursive/Properties.agda
@@ -10,11 +10,14 @@ module Data.Vec.Recursive.Properties where
 
 open import Level using (Level)
 open import Data.Nat.Base hiding (_^_)
-open import Data.Product
+open import Data.Product.Base
 open import Data.Vec.Recursive
 open import Data.Vec.Base using (Vec; _∷_)
-open import Function.Inverse using (_↔_; inverse)
-open import Relation.Binary.PropositionalEquality as P
+open import Function.Bundles using (_↔_; mk↔ₛ′)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open ≡-Reasoning
 
 private
@@ -26,31 +29,31 @@ private
 -- Basic proofs
 
 cons-head-tail-identity : ∀ n (as : A ^ suc n) → cons n (head n as) (tail n as) ≡ as
-cons-head-tail-identity 0       as = P.refl
-cons-head-tail-identity (suc n) as = P.refl
+cons-head-tail-identity 0       as = refl
+cons-head-tail-identity (suc n) as = refl
 
 head-cons-identity : ∀ n a (as : A ^ n) → head n (cons n a as) ≡ a
-head-cons-identity 0       a as = P.refl
-head-cons-identity (suc n) a as = P.refl
+head-cons-identity 0       a as = refl
+head-cons-identity (suc n) a as = refl
 
 tail-cons-identity : ∀ n a (as : A ^ n) → tail n (cons n a as) ≡ as
-tail-cons-identity 0       a as = P.refl
-tail-cons-identity (suc n) a as = P.refl
+tail-cons-identity 0       a as = refl
+tail-cons-identity (suc n) a as = refl
 
 append-cons : ∀ m n a (xs : A ^ m) ys →
   append (suc m) n (cons m a xs) ys ≡ cons (m + n) a (append m n xs ys)
-append-cons 0       n a xs ys = P.refl
-append-cons (suc m) n a xs ys = P.refl
+append-cons 0       n a xs ys = refl
+append-cons (suc m) n a xs ys = refl
 
 append-splitAt-identity : ∀ m n (as : A ^ (m + n)) → uncurry (append m n) (splitAt m n as) ≡ as
-append-splitAt-identity 0       n as = P.refl
+append-splitAt-identity 0       n as = refl
 append-splitAt-identity (suc m) n as = begin
   let x         = head (m + n) as in
   let (xs , ys) = splitAt m n (tail (m + n) as) in
   append (suc m) n (cons m (head (m + n) as) xs) ys
     ≡⟨ append-cons m n x xs ys ⟩
   cons (m + n) x (append m n xs ys)
-    ≡⟨ P.cong (cons (m + n) x) (append-splitAt-identity m n (tail (m + n) as)) ⟩
+    ≡⟨ cong (cons (m + n) x) (append-splitAt-identity m n (tail (m + n) as)) ⟩
   cons (m + n) x (tail (m + n) as)
     ≡⟨ cons-head-tail-identity (m + n) as ⟩
   as
@@ -60,21 +63,21 @@ append-splitAt-identity (suc m) n as = begin
 -- Conversion to and from Vec
 
 fromVec∘toVec : ∀ n (xs : A ^ n) → fromVec (toVec n xs) ≡ xs
-fromVec∘toVec 0       _  = P.refl
+fromVec∘toVec 0       _  = refl
 fromVec∘toVec (suc n) xs = begin
   cons n (head n xs) (fromVec (toVec n (tail n xs)))
-    ≡⟨ P.cong (cons n (head n xs)) (fromVec∘toVec n (tail n xs)) ⟩
+    ≡⟨ cong (cons n (head n xs)) (fromVec∘toVec n (tail n xs)) ⟩
   cons n (head n xs) (tail n xs)
     ≡⟨ cons-head-tail-identity n xs ⟩
   xs ∎
 
 toVec∘fromVec : ∀ {n} (xs : Vec A n) → toVec n (fromVec xs) ≡ xs
-toVec∘fromVec             Vec.[]       = P.refl
+toVec∘fromVec             Vec.[]       = refl
 toVec∘fromVec {n = suc n} (x Vec.∷ xs) = begin
   head n (cons n x (fromVec xs)) Vec.∷ toVec n (tail n (cons n x (fromVec xs)))
-    ≡⟨ P.cong₂ (λ x xs → x Vec.∷ toVec n xs) hd-prf tl-prf ⟩
+    ≡⟨ cong₂ (λ x xs → x Vec.∷ toVec n xs) hd-prf tl-prf ⟩
   x Vec.∷ toVec n (fromVec xs)
-    ≡⟨ P.cong (x Vec.∷_) (toVec∘fromVec xs) ⟩
+    ≡⟨ cong (x Vec.∷_) (toVec∘fromVec xs) ⟩
   x Vec.∷ xs
     ∎ where
 
@@ -82,7 +85,7 @@ toVec∘fromVec {n = suc n} (x Vec.∷ xs) = begin
   tl-prf = tail-cons-identity _ x (fromVec xs)
 
 ↔Vec : ∀ n → A ^ n ↔ Vec A n
-↔Vec n = inverse (toVec n) fromVec (fromVec∘toVec n) toVec∘fromVec
+↔Vec n = mk↔ₛ′ (toVec n) fromVec toVec∘fromVec (fromVec∘toVec n)
 
 ------------------------------------------------------------------------
 -- DEPRECATED NAMES
diff --git a/src/Data/Vec/Reflection.agda b/src/Data/Vec/Reflection.agda
index 91d5579c94..0ea6473ff2 100644
--- a/src/Data/Vec/Reflection.agda
+++ b/src/Data/Vec/Reflection.agda
@@ -8,7 +8,7 @@
 
 module Data.Vec.Reflection where
 
-import Data.List as List
+import Data.List.Base as List
 open import Data.Vec.Base
 open import Reflection.AST.Term
 open import Reflection.AST.Argument
@@ -25,6 +25,8 @@ open import Reflection.AST.Argument
 `[] : Term
 `[] = con (quote []) (2 ⋯⟅∷⟆ List.[])
 
+infixr 5 _`∷_
+
 _`∷_ : Term → Term → Term
 _`∷_ x xs = con (quote _∷_) (3 ⋯⟅∷⟆ x ⟨∷⟩ xs ⟨∷⟩ List.[])
 
diff --git a/src/Data/Vec/Relation/Binary/Equality/Cast.agda b/src/Data/Vec/Relation/Binary/Equality/Cast.agda
new file mode 100644
index 0000000000..cc18556ea7
--- /dev/null
+++ b/src/Data/Vec/Relation/Binary/Equality/Cast.agda
@@ -0,0 +1,128 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- An equational reasoning library for propositional equality over
+-- vectors of different indices using cast.
+--
+-- See README.Data.Vec.Relation.Binary.Equality.Cast for
+-- documentation and examples.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Vec.Relation.Binary.Equality.Cast {a} {A : Set a} where
+
+open import Data.Nat.Base using (ℕ; zero; suc)
+open import Data.Nat.Properties using (suc-injective)
+open import Data.Vec.Base
+open import Relation.Binary.Core using (REL; _⇒_)
+open import Relation.Binary.Definitions using (Sym; Trans)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; trans; sym; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
+
+private
+  variable
+    l m n o : ℕ
+    xs ys zs : Vec A n
+
+
+cast-is-id : .(eq : m ≡ m) (xs : Vec A m) → cast eq xs ≡ xs
+cast-is-id eq []       = refl
+cast-is-id eq (x ∷ xs) = cong (x ∷_) (cast-is-id (suc-injective eq) xs)
+
+cast-trans : .(eq₁ : m ≡ n) .(eq₂ : n ≡ o) (xs : Vec A m) →
+             cast eq₂ (cast eq₁ xs) ≡ cast (trans eq₁ eq₂) xs
+cast-trans {m = zero}  {n = zero}  {o = zero}  eq₁ eq₂ [] = refl
+cast-trans {m = suc _} {n = suc _} {o = suc _} eq₁ eq₂ (x ∷ xs) =
+  cong (x ∷_) (cast-trans (suc-injective eq₁) (suc-injective eq₂) xs)
+
+
+infix 3 _≈[_]_
+
+_≈[_]_ : ∀ {n m} → Vec A n → .(eq : n ≡ m) → Vec A m → Set a
+xs ≈[ eq ] ys = cast eq xs ≡ ys
+
+------------------------------------------------------------------------
+-- _≈[_]_ is ‘reflexive’, ‘symmetric’ and ‘transitive’
+
+≈-reflexive : ∀ {n} → _≡_ ⇒ (λ xs ys → _≈[_]_ {n} xs refl ys)
+≈-reflexive {x = x} eq = trans (cast-is-id refl x) eq
+
+≈-sym : .{m≡n : m ≡ n} → Sym _≈[ m≡n ]_ _≈[ sym m≡n ]_
+≈-sym {m≡n = m≡n} {xs} {ys} xs≈ys = begin
+  cast (sym m≡n) ys             ≡⟨ cong (cast (sym m≡n)) xs≈ys ⟨
+  cast (sym m≡n) (cast m≡n xs)  ≡⟨ cast-trans m≡n (sym m≡n) xs ⟩
+  cast (trans m≡n (sym m≡n)) xs ≡⟨ cast-is-id (trans m≡n (sym m≡n)) xs ⟩
+  xs                            ∎
+  where open ≡-Reasoning
+
+≈-trans : ∀ .{m≡n : m ≡ n} .{n≡o : n ≡ o} → Trans _≈[ m≡n ]_ _≈[ n≡o ]_ _≈[ trans m≡n n≡o ]_
+≈-trans {m≡n = m≡n} {n≡o} {xs} {ys} {zs} xs≈ys ys≈zs = begin
+  cast (trans m≡n n≡o) xs ≡⟨ cast-trans m≡n n≡o xs ⟨
+  cast n≡o (cast m≡n xs)  ≡⟨ cong (cast n≡o) xs≈ys ⟩
+  cast n≡o ys             ≡⟨ ys≈zs ⟩
+  zs                      ∎
+  where open ≡-Reasoning
+
+------------------------------------------------------------------------
+-- Reasoning combinators
+
+module CastReasoning where
+
+  open ≡-Reasoning public
+    renaming (begin_ to begin-≡_; _∎ to _≡-∎)
+
+  begin_ : ∀ .{m≡n : m ≡ n} {xs : Vec A m} {ys} → xs ≈[ m≡n ] ys → cast m≡n xs ≡ ys
+  begin xs≈ys = xs≈ys
+
+  _∎ : (xs : Vec A n) → cast refl xs ≡ xs
+  _∎ xs = ≈-reflexive refl
+
+  _≈⟨⟩_ : ∀ .{m≡n : m ≡ n} (xs : Vec A m) {ys} → xs ≈[ m≡n ] ys → xs ≈[ m≡n ] ys
+  xs ≈⟨⟩ xs≈ys = xs≈ys
+
+  -- composition of _≈[_]_
+  step-≈-⟩ : ∀ .{m≡n : m ≡ n}.{m≡o : m ≡ o} (xs : Vec A m) {ys : Vec A n} {zs : Vec A o} →
+           ys ≈[ trans (sym m≡n) m≡o ] zs → xs ≈[ m≡n ] ys → xs ≈[ m≡o ] zs
+  step-≈-⟩ xs ys≈zs xs≈ys = ≈-trans xs≈ys ys≈zs
+
+  step-≈-⟨ : ∀ .{n≡m : n ≡ m}.{m≡o : m ≡ o} (xs : Vec A m) {ys : Vec A n} {zs : Vec A o} →
+           ys ≈[ trans n≡m m≡o ] zs → ys ≈[ n≡m ] xs → xs ≈[ m≡o ] zs
+  step-≈-⟨ xs ys≈zs ys≈xs = step-≈-⟩ xs ys≈zs (≈-sym ys≈xs)
+
+  -- composition of the equality type on the right-hand side of _≈[_]_,
+  -- or escaping to ordinary _≡_
+  step-≃-⟩ : ∀ .{m≡n : m ≡ n} (xs : Vec A m) {ys zs} → ys ≡ zs → xs ≈[ m≡n ] ys → xs ≈[ m≡n ] zs
+  step-≃-⟩ xs ys≡zs xs≈ys = ≈-trans xs≈ys (≈-reflexive ys≡zs)
+
+  step-≃-⟨ : ∀ .{m≡n : m ≡ n} (xs : Vec A m) {ys zs} → ys ≡ zs → ys ≈[ sym m≡n ] xs → xs ≈[ m≡n ] zs
+  step-≃-⟨ xs ys≡zs ys≈xs = step-≃-⟩ xs ys≡zs (≈-sym ys≈xs)
+
+  -- composition of the equality type on the left-hand side of _≈[_]_
+  step-≂-⟩ : ∀ .{m≡n : m ≡ n} (xs : Vec A m) {ys zs} → ys ≈[ m≡n ] zs → xs ≡ ys → xs ≈[ m≡n ] zs
+  step-≂-⟩ xs ys≈zs xs≡ys = ≈-trans (≈-reflexive xs≡ys) ys≈zs
+
+  step-≂-⟨ : ∀ .{m≡n : m ≡ n} (xs : Vec A m) {ys zs} → ys ≈[ m≡n ] zs → ys ≡ xs → xs ≈[ m≡n ] zs
+  step-≂-⟨ xs ys≈zs ys≡xs = step-≂-⟩ xs ys≈zs (sym ys≡xs)
+
+  -- `cong` after a `_≈[_]_` step that exposes the `cast` to the `cong`
+  -- operation
+  ≈-cong : ∀ .{l≡o : l ≡ o} .{m≡n : m ≡ n} {xs : Vec A m} {ys zs} (f : Vec A o → Vec A n) →
+           xs ≈[ m≡n ] f (cast l≡o ys) → ys ≈[ l≡o ] zs → xs ≈[ m≡n ] f zs
+  ≈-cong f xs≈fys ys≈zs = trans xs≈fys (cong f ys≈zs)
+
+  ------------------------------------------------------------------------
+  -- convenient syntax for ‘equational’ reasoning
+
+  infix 1 begin_
+  infixr 2 step-≃-⟩ step-≃-⟨ step-≂-⟩ step-≂-⟨ step-≈-⟩ step-≈-⟨ _≈⟨⟩_ ≈-cong
+  infix 3 _∎
+
+  syntax step-≃-⟩ xs ys≡zs xs≈ys  = xs ≃⟨ xs≈ys ⟩ ys≡zs
+  syntax step-≃-⟨ xs ys≡zs xs≈ys  = xs ≃⟨ xs≈ys ⟨ ys≡zs
+  syntax step-≂-⟩ xs ys≈zs xs≡ys  = xs ≂⟨ xs≡ys ⟩ ys≈zs
+  syntax step-≂-⟨ xs ys≈zs ys≡xs  = xs ≂⟨ ys≡xs ⟨ ys≈zs
+  syntax step-≈-⟩ xs ys≈zs xs≈ys  = xs ≈⟨ xs≈ys ⟩ ys≈zs
+  syntax step-≈-⟨ xs ys≈zs ys≈xs  = xs ≈⟨ ys≈xs ⟨ ys≈zs
diff --git a/src/Data/Vec/Relation/Binary/Equality/DecPropositional.agda b/src/Data/Vec/Relation/Binary/Equality/DecPropositional.agda
index da50443c31..e8a288b338 100644
--- a/src/Data/Vec/Relation/Binary/Equality/DecPropositional.agda
+++ b/src/Data/Vec/Relation/Binary/Equality/DecPropositional.agda
@@ -6,14 +6,14 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Definitions using (DecidableEquality)
 
 module Data.Vec.Relation.Binary.Equality.DecPropositional
-  {a} {A : Set a} (_≟_ : Decidable {A = A} _≡_) where
+  {a} {A : Set a} (_≟_ : DecidableEquality A) where
 
 import Data.Vec.Relation.Binary.Equality.Propositional as PEq
 import Data.Vec.Relation.Binary.Equality.DecSetoid as DSEq
+open import Relation.Binary.PropositionalEquality.Properties using (decSetoid)
 
 ------------------------------------------------------------------------
 -- Publicly re-export everything from decSetoid and propositional
diff --git a/src/Data/Vec/Relation/Binary/Equality/DecSetoid.agda b/src/Data/Vec/Relation/Binary/Equality/DecSetoid.agda
index 5614602219..01fd39b051 100644
--- a/src/Data/Vec/Relation/Binary/Equality/DecSetoid.agda
+++ b/src/Data/Vec/Relation/Binary/Equality/DecSetoid.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (DecSetoid)
+open import Relation.Binary.Structures using (IsDecEquivalence)
 
 module Data.Vec.Relation.Binary.Equality.DecSetoid
   {a ℓ} (DS : DecSetoid a ℓ) where
@@ -15,7 +16,7 @@ open import Data.Nat.Base using (ℕ)
 import Data.Vec.Relation.Binary.Equality.Setoid as Equality
 import Data.Vec.Relation.Binary.Pointwise.Inductive as PW
 open import Level using (_⊔_)
-open import Relation.Binary using (Decidable)
+open import Relation.Binary.Definitions using (Decidable)
 
 open DecSetoid DS
 
diff --git a/src/Data/Vec/Relation/Binary/Equality/Propositional.agda b/src/Data/Vec/Relation/Binary/Equality/Propositional.agda
index 15e85a6bcf..09107d6b3e 100644
--- a/src/Data/Vec/Relation/Binary/Equality/Propositional.agda
+++ b/src/Data/Vec/Relation/Binary/Equality/Propositional.agda
@@ -6,16 +6,15 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
-
 module Data.Vec.Relation.Binary.Equality.Propositional {a} {A : Set a} where
 
 open import Data.Nat.Base using (ℕ; zero; suc; _+_)
-open import Data.Vec.Base
+open import Data.Vec.Base using (Vec)
 open import Data.Vec.Relation.Binary.Pointwise.Inductive
   using (Pointwise-≡⇒≡; ≡⇒Pointwise-≡)
 import Data.Vec.Relation.Binary.Equality.Setoid as SEq
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 
 ------------------------------------------------------------------------
 -- Publically re-export everything from setoid equality
diff --git a/src/Data/Vec/Relation/Binary/Equality/Propositional/WithK.agda b/src/Data/Vec/Relation/Binary/Equality/Propositional/WithK.agda
index a86a09e942..61763b3c49 100644
--- a/src/Data/Vec/Relation/Binary/Equality/Propositional/WithK.agda
+++ b/src/Data/Vec/Relation/Binary/Equality/Propositional/WithK.agda
@@ -10,12 +10,11 @@
 module Data.Vec.Relation.Binary.Equality.Propositional.WithK
   {a} {A : Set a} where
 
-open import Data.Vec.Base
+open import Data.Vec.Base using (Vec)
 open import Data.Vec.Relation.Binary.Equality.Propositional {A = A}
-open import Relation.Binary.PropositionalEquality
-open import Relation.Binary.HeterogeneousEquality as H using (_≅_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
+open import Relation.Binary.HeterogeneousEquality using (_≅_; ≡-to-≅)
 
 ≋⇒≅ : ∀ {m n} {xs : Vec A m} {ys : Vec A n} →
       xs ≋ ys → xs ≅ ys
-≋⇒≅ p with length-equal p
-... | refl = H.≡-to-≅ (≋⇒≡ p)
+≋⇒≅ p with refl <- length-equal p = ≡-to-≅ (≋⇒≡ p)
diff --git a/src/Data/Vec/Relation/Binary/Equality/Setoid.agda b/src/Data/Vec/Relation/Binary/Equality/Setoid.agda
index 86ed09b93d..f0cefce5c7 100644
--- a/src/Data/Vec/Relation/Binary/Equality/Setoid.agda
+++ b/src/Data/Vec/Relation/Binary/Equality/Setoid.agda
@@ -6,19 +6,20 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.Vec.Relation.Binary.Equality.Setoid
   {a ℓ} (S : Setoid a ℓ) where
 
 open import Data.Nat.Base using (ℕ; zero; suc; _+_)
+open import Data.Fin.Base using (zero; suc)
 open import Data.Vec.Base
 open import Data.Vec.Relation.Binary.Pointwise.Inductive as PW
   using (Pointwise)
-open import Function.Base
 open import Level using (_⊔_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions using (Reflexive; Sym; Trans)
 
 open Setoid S renaming (Carrier to A)
 
@@ -79,6 +80,12 @@ map-++ : ∀ {b m n} {B : Set b}
 map-++ f []       = ≋-refl
 map-++ f (x ∷ xs) = refl ∷ map-++ f xs
 
+map-[]≔ : ∀ {b n} {B : Set b}
+          (f : B → A) (xs : Vec B n) i p →
+          map f (xs [ i ]≔ p) ≋ map f xs [ i ]≔ f p
+map-[]≔ f (x ∷ xs) zero    p = refl ∷ ≋-refl
+map-[]≔ f (x ∷ xs) (suc i) p = refl ∷ map-[]≔ f xs i p
+
 ------------------------------------------------------------------------
 -- concat
 
@@ -88,8 +95,8 @@ open PW public using (concat⁺; concat⁻)
 -- replicate
 
 replicate-shiftʳ : ∀ {m} n x (xs : Vec A m) →
-                  replicate {n = n}     x ++ (x ∷ xs) ≋
-                  replicate {n = 1 + n} x ++      xs
+                  replicate n       x ++ (x ∷ xs) ≋
+                  replicate (1 + n) x ++       xs
 replicate-shiftʳ zero    x xs = ≋-refl
 replicate-shiftʳ (suc n) x xs = refl ∷ (replicate-shiftʳ n x xs)
 
diff --git a/src/Data/Vec/Relation/Binary/Lex/Core.agda b/src/Data/Vec/Relation/Binary/Lex/Core.agda
index 4ac943401e..92237d4f18 100644
--- a/src/Data/Vec/Relation/Binary/Lex/Core.agda
+++ b/src/Data/Vec/Relation/Binary/Lex/Core.agda
@@ -9,17 +9,20 @@
 module Data.Vec.Relation.Binary.Lex.Core {a} {A : Set a} where
 
 open import Data.Empty
-open import Data.Nat using (ℕ; suc)
+open import Data.Nat.Base using (ℕ; suc)
 import Data.Nat.Properties as ℕ
-open import Data.Product using (_×_; _,_; proj₁; proj₂; uncurry)
-open import Data.Sum using (_⊎_; inj₁; inj₂; [_,_])
-open import Data.Vec using (Vec; []; _∷_)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂; uncurry)
+open import Data.Vec.Base using (Vec; []; _∷_)
+open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_])
 open import Data.Vec.Relation.Binary.Pointwise.Inductive using (Pointwise; []; _∷_)
 open import Function.Base using (flip)
 open import Function.Bundles using (_⇔_; mk⇔)
 open import Level using (Level; _⊔_)
-open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.Core using (Rel; REL)
+open import Relation.Binary.Definitions
+  using (Transitive; Symmetric; Asymmetric; Antisymmetric; Irreflexive; Trans; _Respects₂_; _Respectsˡ_; _Respectsʳ_; Decidable; Irrelevant)
+open import Relation.Binary.Structures using (IsPartialEquivalence)
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; refl; cong)
 import Relation.Nullary as Nullary
 open import Relation.Nullary.Decidable as Dec using (Dec; yes; no; _×-dec_; _⊎-dec_)
@@ -98,9 +101,9 @@ module _ {P : Set} {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
 
     transitive′ : ∀ {m n o P₂} → Trans (Lex P _≈_ _≺_ {m} {n}) (Lex P₂ _≈_ _≺_ {n} {o}) (Lex (P × P₂) _≈_ _≺_)
     transitive′ (base p₁)        (base p₂)        = base (p₁ , p₂)
-    transitive′ (this x≺y m≡n)   (this y≺z n≡o)   = this (≺-trans x≺y y≺z) (P.trans m≡n n≡o)
-    transitive′ (this x≺y m≡n)   (next y≈z ys<zs) = this (≺-respʳ-≈ y≈z x≺y) (P.trans m≡n (length-equal ys<zs))
-    transitive′ (next x≈y xs<ys) (this y≺z n≡o)   = this (≺-respˡ-≈ (sym x≈y) y≺z) (P.trans (length-equal xs<ys) n≡o)
+    transitive′ (this x≺y m≡n)   (this y≺z n≡o)   = this (≺-trans x≺y y≺z) (≡.trans m≡n n≡o)
+    transitive′ (this x≺y m≡n)   (next y≈z ys<zs) = this (≺-respʳ-≈ y≈z x≺y) (≡.trans m≡n (length-equal ys<zs))
+    transitive′ (next x≈y xs<ys) (this y≺z n≡o)   = this (≺-respˡ-≈ (sym x≈y) y≺z) (≡.trans (length-equal xs<ys) n≡o)
     transitive′ (next x≈y xs<ys) (next y≈z ys<zs) = next (trans x≈y y≈z) (transitive′ xs<ys ys<zs)
 
     transitive : ∀ {m n o} → Trans (_<ₗₑₓ_ {m} {n}) (_<ₗₑₓ_ {n} {o}) _<ₗₑₓ_
@@ -133,7 +136,7 @@ module _ {P : Set} {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
   module _ (P? : Dec P) (_≈?_ : Decidable _≈_) (_≺?_ : Decidable _≺_) where
 
     decidable : ∀ {m n} → Decidable (_<ₗₑₓ_ {m} {n})
-    decidable {m} {n} xs ys with m Data.Nat.≟ n
+    decidable {m} {n} xs ys with m ℕ.≟ n
     decidable {_} {_} []       []       | yes refl = Dec.map P⇔[]<[] P?
     decidable {_} {_} (x ∷ xs) (y ∷ ys) | yes refl = Dec.map ∷<∷-⇔ ((x ≺? y) ⊎-dec (x ≈? y) ×-dec (decidable xs ys))
     decidable {_} {_} _        _        | no  m≢n    = no (λ xs<ys → contradiction (length-equal xs<ys) m≢n)
diff --git a/src/Data/Vec/Relation/Binary/Lex/NonStrict.agda b/src/Data/Vec/Relation/Binary/Lex/NonStrict.agda
index 409732dc0b..57f05fa211 100644
--- a/src/Data/Vec/Relation/Binary/Lex/NonStrict.agda
+++ b/src/Data/Vec/Relation/Binary/Lex/NonStrict.agda
@@ -12,19 +12,24 @@
 module Data.Vec.Relation.Binary.Lex.NonStrict where
 
 open import Data.Empty
-open import Data.Unit using (⊤; tt)
-open import Data.Product using (proj₁; proj₂)
-open import Data.Nat using (ℕ)
-open import Data.Vec using (Vec; []; _∷_)
+open import Data.Unit.Base using (⊤; tt)
+open import Data.Product.Base using (proj₁; proj₂)
+open import Data.Nat.Base using (ℕ)
+open import Data.Vec.Base using (Vec; []; _∷_)
 import Data.Vec.Relation.Binary.Lex.Strict as Strict
 open import Data.Vec.Relation.Binary.Pointwise.Inductive as Pointwise
   using (Pointwise; []; _∷_; head; tail)
-open import Function using (id)
-open import Relation.Binary
+open import Function.Base using (id)
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Core using (REL; Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (Poset; StrictPartialOrder; DecPoset; DecStrictPartialOrder; DecTotalOrder; StrictTotalOrder; Preorder; TotalOrder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsPartialOrder; IsStrictPartialOrder; IsDecPartialOrder; IsDecStrictPartialOrder; IsDecTotalOrder; IsStrictTotalOrder; IsPreorder; IsTotalOrder)
+open import Relation.Binary.Definitions
+  using (Irreflexive; _Respects₂_; Antisymmetric; Asymmetric; Symmetric; Trans; Decidable; Total; Trichotomous)
 import Relation.Binary.Construct.NonStrictToStrict as Conv
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
 open import Relation.Nullary hiding (Irrelevant)
-open import Level using (Level; _⊔_)
 
 private
   variable
@@ -256,6 +261,7 @@ module ≤-Reasoning  {_≈_ : Rel A ℓ₁} {_≼_ : Rel A ℓ₂}
 
   open import Relation.Binary.Reasoning.Base.Triple
     (≤-isPreorder ≼-po {n})
+    (<-asym isEquivalence ≤-resp-≈ antisym)
     (<-trans ≼-po)
     (<-resp₂ isEquivalence ≤-resp-≈)
     <⇒≤
diff --git a/src/Data/Vec/Relation/Binary/Lex/Strict.agda b/src/Data/Vec/Relation/Binary/Lex/Strict.agda
index 7e4052476b..52f529aec9 100644
--- a/src/Data/Vec/Relation/Binary/Lex/Strict.agda
+++ b/src/Data/Vec/Relation/Binary/Lex/Strict.agda
@@ -15,7 +15,7 @@ open import Data.Empty using (⊥; ⊥-elim)
 open import Data.Unit.Base using (⊤; tt)
 open import Data.Unit.Properties using (⊤-irrelevant)
 open import Data.Nat.Base using (ℕ; suc)
-open import Data.Product using (_×_; _,_; proj₁; proj₂)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂)
 open import Data.Product.Relation.Binary.Lex.Strict
 open import Data.Sum.Base using (inj₁; inj₂)
 open import Data.Vec.Base using (Vec; []; _∷_; uncons)
@@ -24,10 +24,16 @@ open import Data.Vec.Relation.Binary.Pointwise.Inductive as Pointwise
 open import Function.Base using (id; _on_; _∘_)
 open import Induction.WellFounded
 open import Relation.Nullary using (yes; no; ¬_)
-open import Relation.Binary
+open import Relation.Binary.Core using (REL; Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (Poset; StrictPartialOrder; DecPoset; DecStrictPartialOrder; DecTotalOrder; StrictTotalOrder; Preorder; TotalOrder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsPartialOrder; IsStrictPartialOrder; IsDecPartialOrder; IsDecStrictPartialOrder; IsDecTotalOrder; IsStrictTotalOrder; IsPreorder; IsTotalOrder; IsPartialEquivalence)
+open import Relation.Binary.Definitions
+  using (Irreflexive; _Respects₂_; _Respectsˡ_; _Respectsʳ_; Antisymmetric; Asymmetric; Symmetric; Trans; Decidable; Total; Trichotomous; Transitive; Irrelevant; tri≈; tri>; tri<)
 open import Relation.Binary.Consequences
 open import Relation.Binary.Construct.On as On using (wellFounded)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 open import Level using (Level; _⊔_)
 
 private
@@ -35,16 +41,16 @@ private
     a ℓ₁ ℓ₂ : Level
     A : Set a
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Re-exports
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 open import Data.Vec.Relation.Binary.Lex.Core as Core public
   using (base; this; next; ≰-this; ≰-next)
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Definitions
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 module _ {A : Set a} (_≈_ : Rel A ℓ₁) (_≺_ : Rel A ℓ₂) where
 
@@ -54,20 +60,20 @@ module _ {A : Set a} (_≈_ : Rel A ℓ₁) (_≺_ : Rel A ℓ₂) where
   Lex-≤ : ∀ {m n} → REL (Vec A m) (Vec A n) (a ⊔ ℓ₁ ⊔ ℓ₂)
   Lex-≤ = Core.Lex {A = A} ⊤ _≈_ _≺_
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of Lex-<
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
   private
     _≋_ = Pointwise _≈_
     _<_ = Lex-< _≈_ _≺_
 
-  xs≮[] : ∀ {n} (xs : Vec A n) → ¬ xs < []
-  xs≮[] _ (base ())
+  xs≮[] : ∀ {n} {xs : Vec A n} → ¬ xs < []
+  xs≮[] (base ())
 
   ¬[]<[] : ¬ [] < []
-  ¬[]<[] = xs≮[] []
+  ¬[]<[] = xs≮[]
 
   module _ (≺-irrefl : Irreflexive _≈_ _≺_) where
 
@@ -97,8 +103,8 @@ module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
     <-cmp : ∀ {n} → Trichotomous _≋_ (_<_ {n})
     <-cmp [] [] = tri≈ ¬[]<[] [] ¬[]<[]
     <-cmp (x ∷ xs) (y ∷ ys) with ≺-cmp x y
-    ... | tri< x≺y x≉y x⊁y = tri< (this x≺y P.refl) (x≉y ∘ head) (≰-this (x≉y ∘ ≈-sym) x⊁y)
-    ... | tri> x⊀y x≉y x≻y = tri> (≰-this x≉y x⊀y) (x≉y ∘ head) (this x≻y P.refl)
+    ... | tri< x≺y x≉y x⊁y = tri< (this x≺y refl) (x≉y ∘ head) (≰-this (x≉y ∘ ≈-sym) x⊁y)
+    ... | tri> x⊀y x≉y x≻y = tri> (≰-this x≉y x⊀y) (x≉y ∘ head) (this x≻y refl)
     ... | tri≈ x⊀y x≈y x⊁y with <-cmp xs ys
     ...   | tri< xs<ys xs≋̸ys xs≯ys = tri< (next x≈y xs<ys) (xs≋̸ys ∘ tail) (≰-next x⊁y xs≯ys)
     ...   | tri≈ xs≮ys xs≋ys xs≯ys = tri≈ (≰-next x⊀y xs≮ys) (x≈y ∷ xs≋ys) (≰-next x⊁y xs≯ys)
@@ -124,11 +130,12 @@ module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
                  ∀ {m n} → Irrelevant (_<_ {m} {n})
   <-irrelevant = Core.irrelevant (λ ())
 
-  module _ (≈-sym : Symmetric _≈_) (≈-trans : Transitive _≈_) (≺-respʳ : _≺_ Respectsʳ _≈_ ) (≺-wf : WellFounded _≺_)
+  module _ (≈-trans : Transitive _≈_) (≺-respʳ : _≺_ Respectsʳ _≈_ ) (≺-wf : WellFounded _≺_)
     where
 
     <-wellFounded : ∀ {n} → WellFounded (_<_ {n})
-    <-wellFounded {0}     [] = acc λ ys ys<[] → ⊥-elim (xs≮[] ys ys<[])
+    <-wellFounded {0}     [] = acc λ ys<[] → ⊥-elim (xs≮[] ys<[])
+
     <-wellFounded {suc n} xs = Subrelation.wellFounded <⇒uncons-Lex uncons-Lex-wellFounded xs
       where
         <⇒uncons-Lex : {xs ys : Vec A (suc n)} → xs < ys → (×-Lex _≈_ _≺_ _<_ on uncons) xs ys
@@ -136,9 +143,9 @@ module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
         <⇒uncons-Lex {x ∷ xs} {y ∷ ys} (next x≈y xs<ys) = inj₂ (x≈y , xs<ys)
 
         uncons-Lex-wellFounded : WellFounded (×-Lex _≈_ _≺_ _<_ on uncons)
-        uncons-Lex-wellFounded = On.wellFounded uncons (×-wellFounded' ≈-sym ≈-trans ≺-respʳ ≺-wf <-wellFounded)
+        uncons-Lex-wellFounded = On.wellFounded uncons (×-wellFounded' ≈-trans ≺-respʳ ≺-wf <-wellFounded)
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Structures
 
   <-isStrictPartialOrder : IsStrictPartialOrder _≈_ _≺_ →
@@ -161,12 +168,11 @@ module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
   <-isStrictTotalOrder : IsStrictTotalOrder _≈_ _≺_ →
                          ∀ {n} → IsStrictTotalOrder (_≋_ {n} {n}) _<_
   <-isStrictTotalOrder ≺-isStrictTotalOrder {n} = record
-    { isEquivalence = Pointwise.isEquivalence O.isEquivalence n
-    ; trans         = <-trans O.Eq.isPartialEquivalence O.<-resp-≈ O.trans
+    { isStrictPartialOrder = <-isStrictPartialOrder O.isStrictPartialOrder
     ; compare       = <-cmp O.Eq.sym O.compare
     } where module O = IsStrictTotalOrder ≺-isStrictTotalOrder
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Bundles for Lex-<
 
 <-strictPartialOrder : StrictPartialOrder a ℓ₁ ℓ₂ → ℕ → StrictPartialOrder _ _ _
@@ -184,9 +190,9 @@ module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
   { isStrictTotalOrder = <-isStrictTotalOrder isStrictTotalOrder {n = n}
   } where open StrictTotalOrder ≺-sto
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of Lex-≤
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
   private
@@ -231,8 +237,8 @@ module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
     ≤-total : ∀ {n} → Total (_≤_ {n} {n})
     ≤-total [] [] = inj₁ (base tt)
     ≤-total (x ∷ xs) (y ∷ ys) with ≺-cmp x y
-    ... | tri< x≺y _   _   = inj₁ (this x≺y P.refl)
-    ... | tri> _   _   x≻y = inj₂ (this x≻y P.refl)
+    ... | tri< x≺y _   _   = inj₁ (this x≺y refl)
+    ... | tri> _   _   x≻y = inj₂ (this x≻y refl)
     ... | tri≈ _   x≈y _ with ≤-total xs ys
     ...   | inj₁ xs<ys = inj₁ (next x≈y xs<ys)
     ...   | inj₂ xs>ys = inj₂ (next (≈-sym x≈y) xs>ys)
@@ -245,7 +251,7 @@ module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
                  ∀ {m n} → Irrelevant (_≤_ {m} {n})
   ≤-irrelevant = Core.irrelevant ⊤-irrelevant
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Structures
 
   ≤-isPreorder : IsEquivalence _≈_ → Transitive _≺_ → _≺_ Respects₂ _≈_ →
@@ -286,7 +292,7 @@ module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
     ; _≤?_         = ≤-dec _≟_ _<?_
     } where open IsStrictTotalOrder ≺-isStrictTotalOrder
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Bundles
 
 ≤-preorder : Preorder a ℓ₁ ℓ₂ → ℕ → Preorder _ _ _
@@ -314,25 +320,25 @@ module _ {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂} where
   { isDecTotalOrder = ≤-isDecTotalOrder isStrictTotalOrder {n = n}
   } where open StrictTotalOrder ≺-sto
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Equational Reasoning
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
-module ≤-Reasoning {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂}
-                   (≈-isEquivalence : IsEquivalence _≈_)
-                   (≺-trans : Transitive _≺_)
-                   (≺-resp-≈ : _≺_ Respects₂ _≈_)
-                   (n : ℕ)
-                   where
+module ≤-Reasoning
+  {_≈_ : Rel A ℓ₁} {_≺_ : Rel A ℓ₂}
+  (≺-isStrictPartialOrder : IsStrictPartialOrder _≈_ _≺_)
+  (n : ℕ)
+  where
 
-  private
-    ≈-isPartialEquivalence = IsEquivalence.isPartialEquivalence ≈-isEquivalence
+  open IsStrictPartialOrder ≺-isStrictPartialOrder
 
   open import Relation.Binary.Reasoning.Base.Triple
-    (≤-isPreorder ≈-isEquivalence ≺-trans ≺-resp-≈)
-    (<-trans ≈-isPartialEquivalence ≺-resp-≈ ≺-trans)
-    (<-respects₂ ≈-isPartialEquivalence ≺-resp-≈)
+    (≤-isPreorder isEquivalence trans <-resp-≈)
+    (<-asym Eq.sym <-resp-≈ asym)
+    (<-trans Eq.isPartialEquivalence <-resp-≈ trans)
+    (<-respects₂ Eq.isPartialEquivalence <-resp-≈)
     (<⇒≤ {m = n})
-    (<-transˡ ≈-isPartialEquivalence ≺-resp-≈ ≺-trans)
-    (<-transʳ ≈-isPartialEquivalence ≺-resp-≈ ≺-trans)
+    (<-transˡ Eq.isPartialEquivalence <-resp-≈ trans)
+    (<-transʳ Eq.isPartialEquivalence <-resp-≈ trans)
     public
+
diff --git a/src/Data/Vec/Relation/Binary/Pointwise/Extensional.agda b/src/Data/Vec/Relation/Binary/Pointwise/Extensional.agda
index ff6fd79833..928bae5176 100644
--- a/src/Data/Vec/Relation/Binary/Pointwise/Extensional.agda
+++ b/src/Data/Vec/Relation/Binary/Pointwise/Extensional.agda
@@ -18,8 +18,11 @@ open import Function.Base using (_∘_)
 open import Function.Bundles using (module Equivalence; _⇔_; mk⇔)
 open import Function.Properties.Equivalence using (⇔-setoid)
 open import Level using (Level; _⊔_; 0ℓ)
-open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (Rel; REL; _⇒_; _=[_]⇒_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence; IsDecEquivalence)
+open import Relation.Binary.Definitions using (Reflexive; Sym; Trans; Decidable)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Binary.Construct.Closure.Transitive as Plus
   hiding (equivalent; map)
 open import Relation.Nullary
@@ -131,12 +134,12 @@ isDecEquivalence decEquiv = record
 -- Pointwise _≡_ is equivalent to _≡_.
 
 Pointwise-≡⇒≡ : ∀ {n} {xs ys : Vec A n} → Pointwise _≡_ xs ys → xs ≡ ys
-Pointwise-≡⇒≡ {xs = []}     {[]}     (ext app) = P.refl
+Pointwise-≡⇒≡ {xs = []}     {[]}     (ext app) = ≡.refl
 Pointwise-≡⇒≡ {xs = x ∷ xs} {y ∷ ys} xs∼ys     =
-  P.cong₂ _∷_ (head xs∼ys) (Pointwise-≡⇒≡ (tail xs∼ys))
+  ≡.cong₂ _∷_ (head xs∼ys) (Pointwise-≡⇒≡ (tail xs∼ys))
 
 ≡⇒Pointwise-≡ : ∀ {n} {xs ys : Vec A n} → xs ≡ ys → Pointwise _≡_ xs ys
-≡⇒Pointwise-≡ P.refl = refl P.refl
+≡⇒Pointwise-≡ ≡.refl = refl ≡.refl
 
 Pointwise-≡↔≡ : ∀ {n} {xs ys : Vec A n} → Pointwise _≡_ xs ys ⇔ xs ≡ ys
 Pointwise-≡↔≡ {ℓ} {A} = mk⇔ Pointwise-≡⇒≡ ≡⇒Pointwise-≡
diff --git a/src/Data/Vec/Relation/Binary/Pointwise/Inductive.agda b/src/Data/Vec/Relation/Binary/Pointwise/Inductive.agda
index 54a85d7115..17cc144319 100644
--- a/src/Data/Vec/Relation/Binary/Pointwise/Inductive.agda
+++ b/src/Data/Vec/Relation/Binary/Pointwise/Inductive.agda
@@ -10,14 +10,19 @@ module Data.Vec.Relation.Binary.Pointwise.Inductive where
 
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.Nat.Base using (ℕ; zero; suc)
-open import Data.Product using (_×_; _,_; uncurry; <_,_>)
+open import Data.Product.Base using (_×_; _,_; uncurry; <_,_>)
 open import Data.Vec.Base as Vec hiding ([_]; head; tail; map; lookup; uncons)
 open import Data.Vec.Relation.Unary.All using (All; []; _∷_)
 open import Level using (Level; _⊔_)
 open import Function.Base using (_∘_)
 open import Function.Bundles using (_⇔_; mk⇔)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (REL; Rel; _⇒_)
+open import Relation.Binary.Bundles using (Setoid; DecSetoid)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence)
+open import Relation.Binary.Definitions
+  using (Trans; Decidable; Reflexive; Sym)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Nullary.Decidable using (yes; no; _×-dec_; map′)
 open import Relation.Unary using (Pred)
 
@@ -47,8 +52,8 @@ data Pointwise {a b ℓ} {A : Set a} {B : Set b} (_∼_ : REL A B ℓ) :
 
 length-equal : ∀ {m n} {_∼_ : REL A B ℓ} {xs : Vec A m} {ys : Vec B n} →
                Pointwise _∼_ xs ys → m ≡ n
-length-equal []          = P.refl
-length-equal (_ ∷ xs∼ys) = P.cong suc (length-equal xs∼ys)
+length-equal []          = ≡.refl
+length-equal (_ ∷ xs∼ys) = ≡.cong suc (length-equal xs∼ys)
 
 ------------------------------------------------------------------------
 -- Operations
@@ -217,6 +222,16 @@ module _ {_∼_ : REL A B ℓ} where
   tabulate⁻ (f₀∼g₀ ∷ _)   zero    = f₀∼g₀
   tabulate⁻ (_     ∷ f∼g) (suc i) = tabulate⁻ f∼g i
 
+------------------------------------------------------------------------
+-- cong
+
+module _ {_∼_ : Rel A ℓ} (refl : Reflexive _∼_) where
+  cong-[_]≔ : ∀ {n} i p {xs} {ys} →
+              Pointwise _∼_ {n} xs ys →
+              Pointwise _∼_ (xs [ i ]≔ p) (ys [ i ]≔ p)
+  cong-[ zero ]≔  p (_   ∷ eqn) = refl ∷ eqn
+  cong-[ suc i ]≔ p (x∼y ∷ eqn) = x∼y  ∷ cong-[ i ]≔ p eqn
+
 ------------------------------------------------------------------------
 -- Degenerate pointwise relations
 
@@ -246,11 +261,11 @@ module _ {P : Pred A ℓ} where
 -- Pointwise _≡_ is equivalent to _≡_
 
 Pointwise-≡⇒≡ : ∀ {n} {xs ys : Vec A n} → Pointwise _≡_ xs ys → xs ≡ ys
-Pointwise-≡⇒≡ []               = P.refl
-Pointwise-≡⇒≡ (P.refl ∷ xs∼ys) = P.cong (_ ∷_) (Pointwise-≡⇒≡ xs∼ys)
+Pointwise-≡⇒≡ []               = ≡.refl
+Pointwise-≡⇒≡ (≡.refl ∷ xs∼ys) = ≡.cong (_ ∷_) (Pointwise-≡⇒≡ xs∼ys)
 
 ≡⇒Pointwise-≡ : ∀ {n} {xs ys : Vec A n} → xs ≡ ys → Pointwise _≡_ xs ys
-≡⇒Pointwise-≡ P.refl = refl P.refl
+≡⇒Pointwise-≡ ≡.refl = refl ≡.refl
 
 Pointwise-≡↔≡ : ∀ {n} {xs ys : Vec A n} → Pointwise _≡_ xs ys ⇔ xs ≡ ys
 Pointwise-≡↔≡ = mk⇔ Pointwise-≡⇒≡ ≡⇒Pointwise-≡
diff --git a/src/Data/Vec/Relation/Unary/All.agda b/src/Data/Vec/Relation/Unary/All.agda
index 9ba434368c..1c20d9c478 100644
--- a/src/Data/Vec/Relation/Unary/All.agda
+++ b/src/Data/Vec/Relation/Unary/All.agda
@@ -9,7 +9,7 @@
 module Data.Vec.Relation.Unary.All where
 
 open import Data.Nat.Base using (ℕ; zero; suc; NonZero)
-open import Data.Product as Prod using (_×_; _,_; uncurry; <_,_>)
+open import Data.Product.Base as Product using (_×_; _,_; uncurry; <_,_>)
 open import Data.Sum.Base as Sum using (inj₁; inj₂)
 open import Data.Vec.Base as Vec using (Vec; []; _∷_)
 open import Data.Vec.Relation.Unary.Any as Any using (Any; here; there)
@@ -19,8 +19,9 @@ open import Function.Base using (_∘_)
 open import Level using (Level; _⊔_)
 open import Relation.Nullary.Decidable as Dec using (_×-dec_; yes; no)
 open import Relation.Unary hiding (_∈_)
-open import Relation.Binary using (Setoid; _Respects_)
-open import Relation.Binary.PropositionalEquality as P using (subst)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (_Respects_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong₂)
 
 private
   variable
@@ -70,7 +71,7 @@ zip (px ∷ pxs , qx ∷ qxs) = (px , qx) ∷ zip (pxs , qxs)
 
 unzip : All (P ∩ Q) {n} ⊆ All P ∩ All Q
 unzip []           = [] , []
-unzip (pqx ∷ pqxs) = Prod.zip _∷_ _∷_ pqx (unzip pqxs)
+unzip (pqx ∷ pqxs) = Product.zip _∷_ _∷_ pqx (unzip pqxs)
 
 module _ {P : Pred A p} {Q : Pred B q} {R : Pred C r} where
 
@@ -90,10 +91,10 @@ lookupAny (px ∷ pxs) (here qx) = px , qx
 lookupAny (px ∷ pxs) (there i) = lookupAny pxs i
 
 lookupWith : ∀[ P ⇒ Q ⇒ R ] → All P xs → (i : Any Q xs) → R (Any.lookup i)
-lookupWith f pxs i = Prod.uncurry f (lookupAny pxs i)
+lookupWith f pxs i = Product.uncurry f (lookupAny pxs i)
 
 lookup : All P xs → (∀ {x} → x ∈ₚ xs → P x)
-lookup pxs = lookupWith (λ { px P.refl → px }) pxs
+lookup pxs = lookupWith (λ { px refl → px }) pxs
 
 module _(S : Setoid a ℓ) {P : Pred (Setoid.Carrier S) p} where
   open Setoid S renaming (sym to sym₁)
@@ -114,13 +115,13 @@ universal u []       = []
 universal u (x ∷ xs) = u x ∷ universal u xs
 
 irrelevant : Irrelevant P → ∀ {n} → Irrelevant (All P {n})
-irrelevant irr []           []           = P.refl
+irrelevant irr []           []           = refl
 irrelevant irr (px₁ ∷ pxs₁) (px₂ ∷ pxs₂) =
-  P.cong₂ _∷_ (irr px₁ px₂) (irrelevant irr pxs₁ pxs₂)
+  cong₂ _∷_ (irr px₁ px₂) (irrelevant irr pxs₁ pxs₂)
 
 satisfiable : Satisfiable P → ∀ {n} → Satisfiable (All P {n})
 satisfiable (x , p) {zero}  = [] , []
-satisfiable (x , p) {suc n} = Prod.map (x ∷_) (p ∷_) (satisfiable (x , p))
+satisfiable (x , p) {suc n} = Product.map (x ∷_) (p ∷_) (satisfiable (x , p))
 
 ------------------------------------------------------------------------
 -- Generalised decidability procedure
diff --git a/src/Data/Vec/Relation/Unary/All/Properties.agda b/src/Data/Vec/Relation/Unary/All/Properties.agda
index 9e0f807632..3bd7a53d73 100644
--- a/src/Data/Vec/Relation/Unary/All/Properties.agda
+++ b/src/Data/Vec/Relation/Unary/All/Properties.agda
@@ -12,17 +12,17 @@ open import Data.Nat.Base using (ℕ; zero; suc; _+_)
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.List.Base using ([]; _∷_)
 open import Data.List.Relation.Unary.All as List using ([]; _∷_)
-open import Data.Product as Prod using (_×_; _,_; uncurry; uncurry′)
-open import Data.Vec.Base as Vec
-import Data.Vec.Properties as Vecₚ
+open import Data.Product.Base as Product using (_×_; _,_; uncurry; uncurry′)
+open import Data.Vec.Base as Vec using (Vec; []; _∷_; map; _++_; concat;
+  tabulate; drop; take; toList; fromList)
 open import Data.Vec.Relation.Unary.All as All using (All; []; _∷_)
 open import Level using (Level)
 open import Function.Base using (_∘_; id)
-open import Function.Inverse using (_↔_; inverse)
+open import Function.Bundles using (_↔_; mk↔ₛ′)
 open import Relation.Unary using (Pred) renaming (_⊆_ to _⋐_)
-open import Relation.Binary as B using (REL)
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; refl; cong; cong₂; →-to-⟶)
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; cong₂)
 
 private
   variable
@@ -82,7 +82,7 @@ gmap g = map⁺ ∘ All.map g
 ++⁻ : (xs : Vec A m) {ys : Vec A n} →
       All P (xs ++ ys) → All P xs × All P ys
 ++⁻ []       p          = [] , p
-++⁻ (x ∷ xs) (px ∷ pxs) = Prod.map₁ (px ∷_) (++⁻ _ pxs)
+++⁻ (x ∷ xs) (px ∷ pxs) = Product.map₁ (px ∷_) (++⁻ _ pxs)
 
 ++⁺∘++⁻ : (xs : Vec A m) {ys : Vec A n} →
           (p : All P (xs ++ ys)) →
@@ -98,7 +98,7 @@ gmap g = map⁺ ∘ All.map g
 
 ++↔ : {xs : Vec A m} {ys : Vec A n} →
       (All P xs × All P ys) ↔ All P (xs ++ ys)
-++↔ {xs = xs} = inverse (uncurry ++⁺) (++⁻ xs) ++⁻∘++⁺ (++⁺∘++⁻ xs)
+++↔ {xs = xs} = mk↔ₛ′ (uncurry ++⁺) (++⁻ xs) (++⁺∘++⁻ xs) ++⁻∘++⁺
 
 ------------------------------------------------------------------------
 -- concat
@@ -148,13 +148,11 @@ module _ {P : A → Set p} where
 
 drop⁺ : ∀ m {xs} → All P {m + n} xs → All P {n} (drop m xs)
 drop⁺ zero pxs = pxs
-drop⁺ (suc m) {x ∷ xs} (px ∷ pxs)
-  rewrite Vecₚ.unfold-drop m x xs = drop⁺ m pxs
+drop⁺ (suc m) {x ∷ xs} (px ∷ pxs) = drop⁺ m pxs
 
 take⁺ : ∀ m {xs} → All P {m + n} xs → All P {m} (take m xs)
 take⁺ zero pxs = []
-take⁺ (suc m) {x ∷ xs} (px ∷ pxs)
-  rewrite Vecₚ.unfold-take m x xs = px ∷ take⁺ m pxs
+take⁺ (suc m) {x ∷ xs} (px ∷ pxs) = px ∷ take⁺ m pxs
 
 ------------------------------------------------------------------------
 -- toList
diff --git a/src/Data/Vec/Relation/Unary/AllPairs.agda b/src/Data/Vec/Relation/Unary/AllPairs.agda
index 7c3eabcb83..9fe7ff703f 100644
--- a/src/Data/Vec/Relation/Unary/AllPairs.agda
+++ b/src/Data/Vec/Relation/Unary/AllPairs.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel)
+open import Relation.Binary.Core using (Rel; _⇒_)
 
 module Data.Vec.Relation.Unary.AllPairs
        {a ℓ} {A : Set a} {R : Rel A ℓ} where
@@ -14,12 +14,12 @@ module Data.Vec.Relation.Unary.AllPairs
 open import Data.Nat.Base using (suc)
 open import Data.Vec.Base as Vec using (Vec; []; _∷_)
 open import Data.Vec.Relation.Unary.All as All using (All; []; _∷_)
-open import Data.Product as Prod using (_,_; _×_; uncurry; <_,_>)
-open import Function using (id; _∘_)
+open import Data.Product.Base as Prod using (_,_; _×_; uncurry; <_,_>)
+open import Function.Base using (id; _∘_)
 open import Level using (_⊔_)
-open import Relation.Binary as B using (Rel; _⇒_)
+open import Relation.Binary.Definitions as B
 open import Relation.Binary.Construct.Intersection renaming (_∩_ to _∩ᵇ_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core using (refl; cong₂)
 open import Relation.Unary as U renaming (_∩_ to _∩ᵘ_) hiding (_⇒_)
 open import Relation.Nullary.Decidable as Dec using (yes; no; _×-dec_)
 
diff --git a/src/Data/Vec/Relation/Unary/AllPairs/Core.agda b/src/Data/Vec/Relation/Unary/AllPairs/Core.agda
index a101f14057..bb094cc5fb 100644
--- a/src/Data/Vec/Relation/Unary/AllPairs/Core.agda
+++ b/src/Data/Vec/Relation/Unary/AllPairs/Core.agda
@@ -12,7 +12,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel)
+open import Relation.Binary.Core using (Rel)
 
 module Data.Vec.Relation.Unary.AllPairs.Core
   {a ℓ} {A : Set a} (R : Rel A ℓ) where
diff --git a/src/Data/Vec/Relation/Unary/AllPairs/Properties.agda b/src/Data/Vec/Relation/Unary/AllPairs/Properties.agda
index 7876928cc7..32eced4f6e 100644
--- a/src/Data/Vec/Relation/Unary/AllPairs/Properties.agda
+++ b/src/Data/Vec/Relation/Unary/AllPairs/Properties.agda
@@ -8,19 +8,19 @@
 
 module Data.Vec.Relation.Unary.AllPairs.Properties where
 
-open import Data.Vec
-import Data.Vec.Properties as Vecₚ
+open import Data.Vec.Base using (_∷_; map; _++_; concat; take; drop; tabulate)
+import Data.Vec.Properties as Vec
 open import Data.Vec.Relation.Unary.All as All using (All; []; _∷_)
-import Data.Vec.Relation.Unary.All.Properties as Allₚ
+import Data.Vec.Relation.Unary.All.Properties as All
 open import Data.Vec.Relation.Unary.AllPairs as AllPairs using (AllPairs; []; _∷_)
 open import Data.Bool.Base using (true; false)
 open import Data.Fin.Base using (Fin)
 open import Data.Fin.Properties using (suc-injective)
 open import Data.Nat.Base using (zero; suc; _+_)
-open import Function using (_∘_)
+open import Function.Base using (_∘_)
 open import Level using (Level)
-open import Relation.Binary using (Rel)
-open import Relation.Binary.PropositionalEquality using (_≢_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core using (_≢_)
 
 private
   variable
@@ -39,7 +39,7 @@ module _ {R : Rel A ℓ} {f : B → A} where
   map⁺ : ∀ {n xs} → AllPairs (λ x y → R (f x) (f y)) {n} xs →
          AllPairs R {n} (map f xs)
   map⁺ []           = []
-  map⁺ (x∉xs ∷ xs!) = Allₚ.map⁺ x∉xs ∷ map⁺ xs!
+  map⁺ (x∉xs ∷ xs!) = All.map⁺ x∉xs ∷ map⁺ xs!
 
 ------------------------------------------------------------------------
 -- ++
@@ -49,7 +49,7 @@ module _ {R : Rel A ℓ} where
   ++⁺ : ∀ {n m xs ys} → AllPairs R {n} xs → AllPairs R {m} ys →
         All (λ x → All (R x) ys) xs → AllPairs R (xs ++ ys)
   ++⁺ []         Rys _              = Rys
-  ++⁺ (px ∷ Rxs) Rys (Rxys ∷ Rxsys) = Allₚ.++⁺ px Rxys ∷ ++⁺ Rxs Rys Rxsys
+  ++⁺ (px ∷ Rxs) Rys (Rxys ∷ Rxsys) = All.++⁺ px Rxys ∷ ++⁺ Rxs Rys Rxsys
 
 ------------------------------------------------------------------------
 -- concat
@@ -61,7 +61,7 @@ module _ {R : Rel A ℓ} where
             AllPairs R (concat xss)
   concat⁺ []           []              = []
   concat⁺ (pxs ∷ pxss) (Rxsxss ∷ Rxss) = ++⁺ pxs (concat⁺ pxss Rxss)
-    (All.map Allₚ.concat⁺ (Allₚ.All-swap Rxsxss))
+    (All.map All.concat⁺ (All.All-swap Rxsxss))
 
 ------------------------------------------------------------------------
 -- take and drop
@@ -70,13 +70,11 @@ module _ {R : Rel A ℓ} where
 
   take⁺ : ∀ {n} m {xs} → AllPairs R {m + n} xs → AllPairs R {m} (take m xs)
   take⁺ zero pxs = []
-  take⁺ (suc m) {x ∷ xs} (px ∷ pxs)
-    rewrite Vecₚ.unfold-take m x xs = Allₚ.take⁺ m px ∷ take⁺ m pxs
+  take⁺ (suc m) {x ∷ xs} (px ∷ pxs) = All.take⁺ m px ∷ take⁺ m pxs
 
   drop⁺ : ∀ {n} m {xs} → AllPairs R {m + n} xs → AllPairs R {n} (drop m xs)
   drop⁺ zero pxs = pxs
-  drop⁺ (suc m) {x ∷ xs} (_ ∷ pxs)
-    rewrite Vecₚ.unfold-drop m x xs = drop⁺ m pxs
+  drop⁺ (suc m) (_ ∷ pxs) = drop⁺ m pxs
 
 ------------------------------------------------------------------------
 -- tabulate
@@ -87,5 +85,5 @@ module _ {R : Rel A ℓ} where
               AllPairs R (tabulate f)
   tabulate⁺ {zero}  fᵢ~fⱼ = []
   tabulate⁺ {suc n} fᵢ~fⱼ =
-    Allₚ.tabulate⁺ (λ j → fᵢ~fⱼ λ()) ∷
+    All.tabulate⁺ (λ j → fᵢ~fⱼ λ()) ∷
     tabulate⁺ (fᵢ~fⱼ ∘ (_∘ suc-injective))
diff --git a/src/Data/Vec/Relation/Unary/Any.agda b/src/Data/Vec/Relation/Unary/Any.agda
index dcf142bcd6..bf30b01076 100644
--- a/src/Data/Vec/Relation/Unary/Any.agda
+++ b/src/Data/Vec/Relation/Unary/Any.agda
@@ -8,15 +8,14 @@
 
 module Data.Vec.Relation.Unary.Any {a} {A : Set a} where
 
-open import Data.Empty
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.Nat.Base using (ℕ; zero; suc; NonZero)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_]′)
 open import Data.Vec.Base as Vec using (Vec; []; [_]; _∷_)
-open import Data.Product as Prod using (∃; _,_)
+open import Data.Product.Base as Product using (∃; _,_)
 open import Level using (Level; _⊔_)
 open import Relation.Nullary.Negation using (¬_; contradiction)
-open import Relation.Nullary.Decidable as Dec using (yes; no; _⊎-dec_)
+open import Relation.Nullary.Decidable as Dec using (no; _⊎-dec_)
 open import Relation.Unary
 
 private
@@ -44,7 +43,7 @@ head ¬pxs (there pxs) = contradiction pxs ¬pxs
 
 -- If the head does not satisfy the predicate, then the tail will.
 tail : ∀ {x} → ¬ P x → Any P (x ∷ xs) → Any P xs
-tail ¬px (here  px)  = ⊥-elim (¬px px)
+tail ¬px (here  px)  = contradiction px ¬px
 tail ¬px (there pxs) = pxs
 
 -- Convert back and forth with sum
@@ -80,7 +79,7 @@ any? P? (x ∷ xs) = Dec.map′ fromSum toSum (P? x ⊎-dec any? P? xs)
 
 satisfiable : Satisfiable P → ∀ {n} → Satisfiable (Any P {suc n})
 satisfiable (x , p) {zero}  = x ∷ [] , here p
-satisfiable (x , p) {suc n} = Prod.map (x ∷_) there (satisfiable (x , p))
+satisfiable (x , p) {suc n} = Product.map (x ∷_) there (satisfiable (x , p))
 
 any = any?
 {-# WARNING_ON_USAGE any
diff --git a/src/Data/Vec/Relation/Unary/Any/Properties.agda b/src/Data/Vec/Relation/Unary/Any/Properties.agda
index 060f917782..0fb5512677 100644
--- a/src/Data/Vec/Relation/Unary/Any/Properties.agda
+++ b/src/Data/Vec/Relation/Unary/Any/Properties.agda
@@ -15,21 +15,23 @@ open import Data.List.Base using ([]; _∷_)
 import Data.List.Relation.Unary.Any as List
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_]′)
 open import Data.Sum.Function.Propositional using (_⊎-cong_)
-open import Data.Product as Prod using (∃; ∃₂; _×_; _,_; proj₁; proj₂)
-open import Data.Vec hiding (here; there)
+open import Data.Product.Base as Product using (∃; ∃₂; _×_; _,_; proj₁; proj₂)
+open import Data.Vec.Base hiding (here; there)
 open import Data.Vec.Relation.Unary.Any as Any using (Any; here; there)
 open import Data.Vec.Membership.Propositional
   using (_∈_; mapWith∈; find; lose)
 open import Data.Vec.Relation.Binary.Pointwise.Inductive
   using (Pointwise; []; _∷_)
 open import Function.Base
-open import Function.Inverse using (_↔_; inverse)
-  renaming (_∘_ to _∘↔_; id to id↔)
+open import Function.Bundles using (_↔_; mk↔ₛ′)
+open import Function.Properties.Inverse using (↔-refl; ↔-trans)
 open import Level using (Level)
 open import Relation.Nullary.Negation using (¬_)
 open import Relation.Unary hiding (_∈_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_; _≗_; refl)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (_Respects_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; sym; trans; cong)
 
 private
   variable
@@ -92,15 +94,15 @@ module _ {P : Pred A p} where
 map-id : ∀ {P : Pred A p} (f : P ⊆ P) {n xs} →
          (∀ {x} (p : P x) → f p ≡ p) →
          (p : Any P {n} xs) → Any.map f p ≡ p
-map-id f hyp (here  p) = P.cong here (hyp p)
-map-id f hyp (there p) = P.cong there $ map-id f hyp p
+map-id f hyp (here  p) = cong here (hyp p)
+map-id f hyp (there p) = cong there $ map-id f hyp p
 
 map-∘ : ∀ {P : Pred A p} {Q : A → Set q} {R : A → Set r}
         (f : Q ⊆ R) (g : P ⊆ Q)
         {n xs} (p : Any P {n} xs) →
         Any.map (f ∘ g) p ≡ Any.map f (Any.map g p)
 map-∘ f g (here  p) = refl
-map-∘ f g (there p) = P.cong there $ map-∘ f g p
+map-∘ f g (there p) = cong there $ map-∘ f g p
 
 ------------------------------------------------------------------------
 -- Swapping
@@ -116,7 +118,7 @@ module _ {P : A → B → Set ℓ} where
   swap-there : ∀ {n m x xs ys} → (any : Any (λ x → Any (P x) {n} ys) {m} xs) →
                swap (Any.map (there {x = x}) any) ≡ there (swap any)
   swap-there (here  pys)  = refl
-  swap-there (there pxys) = P.cong (Any.map there) (swap-there pxys)
+  swap-there (there pxys) = cong (Any.map there) (swap-there pxys)
 
 module _ {P : A → B → Set ℓ} where
 
@@ -124,27 +126,27 @@ module _ {P : A → B → Set ℓ} where
                (any : Any (λ x → Any (P x) ys) xs) →
                swap (swap any) ≡ any
   swap-invol (here (here _)) = refl
-  swap-invol (here (there pys)) = P.cong (Any.map there) (swap-invol (here pys))
-  swap-invol (there pxys) = P.trans (swap-there (swap pxys))
-                          $ P.cong there (swap-invol pxys)
+  swap-invol (here (there pys)) = cong (Any.map there) (swap-invol (here pys))
+  swap-invol (there pxys) = trans (swap-there (swap pxys))
+                          $ cong there (swap-invol pxys)
 
 module _ {P : A → B → Set ℓ} where
 
   swap↔ : ∀ {n m} {xs : Vec A n} {ys : Vec B m} →
           Any (λ x → Any (P x) ys) xs ↔ Any (λ y → Any (flip P y) xs) ys
-  swap↔ = inverse swap swap swap-invol swap-invol
+  swap↔ = mk↔ₛ′ swap swap swap-invol swap-invol
 
 ------------------------------------------------------------------------
 -- Lemmas relating Any to ⊥
 
 ⊥↔Any⊥ : ∀ {n} {xs : Vec A n} → ⊥ ↔ Any (const ⊥) xs
-⊥↔Any⊥ = inverse (λ ()) (λ p → from p) (λ ()) (λ p → from p)
+⊥↔Any⊥ = mk↔ₛ′ (λ ()) (λ p → from p) (λ p → from p) (λ ())
   where
   from : ∀ {n xs} → Any (const ⊥) {n} xs → ∀ {b} {B : Set b} → B
   from (there p) = from p
 
 ⊥↔Any[] : ∀ {P : Pred A p} → ⊥ ↔ Any P []
-⊥↔Any[] = inverse (λ()) (λ()) (λ()) (λ())
+⊥↔Any[] = mk↔ₛ′ (λ()) (λ()) (λ()) (λ())
 
 ------------------------------------------------------------------------
 -- Sums commute with Any
@@ -160,7 +162,7 @@ module _ {P : Pred A p} {Q : A → Set q} where
   Any-⊎⁻ (there p)       = Sum.map there there (Any-⊎⁻ p)
 
   ⊎↔ : ∀ {n} {xs : Vec A n} → (Any P xs ⊎ Any Q xs) ↔ Any (λ x → P x ⊎ Q x) xs
-  ⊎↔ = inverse Any-⊎⁺ Any-⊎⁻ from∘to to∘from
+  ⊎↔ = mk↔ₛ′ Any-⊎⁺ Any-⊎⁻ to∘from from∘to
     where
     from∘to : ∀ {n} {xs : Vec A n} (p : Any P xs ⊎ Any Q xs) → Any-⊎⁻ (Any-⊎⁺ p) ≡ p
     from∘to (inj₁ (here  p)) = refl
@@ -216,7 +218,7 @@ module _ {P : Pred A p} where
   singleton⁻∘singleton⁺ p = refl
 
   singleton↔ : ∀ {x} → P x ↔ Any P [ x ]
-  singleton↔ = inverse singleton⁺ singleton⁻ singleton⁻∘singleton⁺ singleton⁺∘singleton⁻
+  singleton↔ = mk↔ₛ′ singleton⁺ singleton⁻ singleton⁺∘singleton⁻ singleton⁻∘singleton⁺
 
 ------------------------------------------------------------------------
 -- map
@@ -236,16 +238,16 @@ module _ {f : A → B} where
   map⁺∘map⁻ : ∀ {P : Pred B p} {n} {xs : Vec A n} →
               (p : Any P (map f xs)) → map⁺ (map⁻ p) ≡ p
   map⁺∘map⁻ {xs = x ∷ xs} (here  p) = refl
-  map⁺∘map⁻ {xs = x ∷ xs} (there p) = P.cong there (map⁺∘map⁻ p)
+  map⁺∘map⁻ {xs = x ∷ xs} (there p) = cong there (map⁺∘map⁻ p)
 
   map⁻∘map⁺ : ∀ (P : Pred B p) {n} {xs : Vec A n} →
               (p : Any (P ∘ f) xs) → map⁻ {P = P} (map⁺ p) ≡ p
   map⁻∘map⁺ P (here  p) = refl
-  map⁻∘map⁺ P (there p) = P.cong there (map⁻∘map⁺ P p)
+  map⁻∘map⁺ P (there p) = cong there (map⁻∘map⁺ P p)
 
   map↔ : ∀ {P : Pred B p} {n} {xs : Vec A n} →
          Any (P ∘ f) xs ↔ Any P (map f xs)
-  map↔ = inverse map⁺ map⁻ (map⁻∘map⁺ _) map⁺∘map⁻
+  map↔ = mk↔ₛ′ map⁺ map⁻ map⁺∘map⁻ (map⁻∘map⁺ _)
 
 ------------------------------------------------------------------------
 -- _++_
@@ -270,8 +272,8 @@ module _ {P : Pred A p} where
   ++⁺∘++⁻ []       p         = refl
   ++⁺∘++⁻ (x ∷ xs) (here  p) = refl
   ++⁺∘++⁻ (x ∷ xs) (there p) with ++⁻ xs p | ++⁺∘++⁻ xs p
-  ++⁺∘++⁻ (x ∷ xs) (there p) | inj₁ p′ | ih = P.cong there ih
-  ++⁺∘++⁻ (x ∷ xs) (there p) | inj₂ p′ | ih = P.cong there ih
+  ++⁺∘++⁻ (x ∷ xs) (there p) | inj₁ p′ | ih = cong there ih
+  ++⁺∘++⁻ (x ∷ xs) (there p) | inj₂ p′ | ih = cong there ih
 
   ++⁻∘++⁺ : ∀ {n m} (xs : Vec A n) {ys : Vec A m} (p : Any P xs ⊎ Any P ys) →
             ++⁻ xs ([ ++⁺ˡ , ++⁺ʳ xs ]′ p) ≡ p
@@ -282,7 +284,7 @@ module _ {P : Pred A p} where
 
   ++↔ : ∀ {n m} {xs : Vec A n} {ys : Vec A m} →
         (Any P xs ⊎ Any P ys) ↔ Any P (xs ++ ys)
-  ++↔ {xs = xs} = inverse [ ++⁺ˡ , ++⁺ʳ xs ]′ (++⁻ xs) (++⁻∘++⁺ xs) (++⁺∘++⁻ xs)
+  ++↔ {xs = xs} = mk↔ₛ′ [ ++⁺ˡ , ++⁺ʳ xs ]′ (++⁻ xs) (++⁺∘++⁻ xs) (++⁻∘++⁺ xs)
 
   ++-comm : ∀ {n m} (xs : Vec A n) (ys : Vec A m) →
             Any P (xs ++ ys) → Any P (ys ++ xs)
@@ -305,8 +307,8 @@ module _ {P : Pred A p} where
             | ++⁻∘++⁺ ys {ys = x ∷ xs} (inj₁ p) = refl
 
   ++↔++ : ∀ {n m} (xs : Vec A n) (ys : Vec A m) → Any P (xs ++ ys) ↔ Any P (ys ++ xs)
-  ++↔++ xs ys = inverse (++-comm xs ys) (++-comm ys xs)
-                        (++-comm∘++-comm xs) (++-comm∘++-comm ys)
+  ++↔++ xs ys = mk↔ₛ′ (++-comm xs ys) (++-comm ys xs)
+                        (++-comm∘++-comm ys) (++-comm∘++-comm xs)
 
   ++-insert : ∀ {n m x} (xs : Vec A n) {ys : Vec A m} → P x → Any P (xs ++ [ x ] ++ ys)
   ++-insert xs Px = ++⁺ʳ xs (++⁺ˡ (singleton⁺ Px))
@@ -333,12 +335,12 @@ module _ {P : Pred A p} where
 
   concat⁺∘concat⁻ : ∀ {n m} (xss : Vec (Vec A n) m) (p : Any P (concat xss)) →
                    concat⁺ (concat⁻ xss p) ≡ p
-  concat⁺∘concat⁻ (xs ∷ xss) p  with ++⁻ xs p | P.inspect (++⁻ xs) p
-  ... | inj₁ pxs | P.[ p=inj₁ ]
-    = P.trans (P.cong [ ++⁺ˡ , ++⁺ʳ xs ]′ (P.sym p=inj₁))
+  concat⁺∘concat⁻ (xs ∷ xss) p  with ++⁻ xs p in eq
+  ... | inj₁ pxs
+    = trans (cong [ ++⁺ˡ , ++⁺ʳ xs ]′ (sym eq))
     $ ++⁺∘++⁻ xs p
-  ... | inj₂ pxss | P.[ p=inj₂ ] rewrite concat⁺∘concat⁻ xss pxss
-    = P.trans (P.cong [ ++⁺ˡ , ++⁺ʳ xs ]′ (P.sym p=inj₂))
+  ... | inj₂ pxss rewrite concat⁺∘concat⁻ xss pxss
+    = trans (cong [ ++⁺ˡ , ++⁺ʳ xs ]′ (sym eq))
     $ ++⁺∘++⁻ xs p
 
   concat⁻∘concat⁺ : ∀ {n m} {xss : Vec (Vec A n) m} (p : Any (Any P) xss) →
@@ -350,7 +352,7 @@ module _ {P : Pred A p} where
             | concat⁻∘concat⁺ p = refl
 
   concat↔ : ∀ {n m} {xss : Vec (Vec A n) m} → Any (Any P) xss ↔ Any P (concat xss)
-  concat↔ {xss = xss} = inverse concat⁺ (concat⁻ xss) concat⁻∘concat⁺ (concat⁺∘concat⁻ xss)
+  concat↔ {xss = xss} = mk↔ₛ′ concat⁺ (concat⁻ xss) (concat⁺∘concat⁻ xss) concat⁻∘concat⁺
 
 ------------------------------------------------------------------------
 -- tabulate
@@ -364,7 +366,7 @@ module _ {P : Pred A p} where
   tabulate⁻ : ∀ {n} {f : Fin n → A} →
               Any P (tabulate f) → ∃ λ i → P (f i)
   tabulate⁻ (here p)  = zero , p
-  tabulate⁻ (there p) = Prod.map suc id (tabulate⁻ p)
+  tabulate⁻ (there p) = Product.map suc id (tabulate⁻ p)
 
 ------------------------------------------------------------------------
 -- mapWith∈
@@ -383,11 +385,11 @@ module _ {P : Pred B p} where
               ∃₂ λ x (x∈xs : x ∈ xs) → P (f x∈xs)
   mapWith∈⁻ (y ∷ xs) f (here  p) = (y , here refl , p)
   mapWith∈⁻ (y ∷ xs) f (there p) =
-    Prod.map id (Prod.map there id) $ mapWith∈⁻ xs (f ∘ there) p
+    Product.map id (Product.map there id) $ mapWith∈⁻ xs (f ∘ there) p
 
   mapWith∈↔ : ∀ {n} {xs : Vec A n} {f : ∀ {x} → x ∈ xs → B} →
     (∃₂ λ x (x∈xs : x ∈ xs) → P (f x∈xs)) ↔ Any P (mapWith∈ xs f)
-  mapWith∈↔ = inverse (mapWith∈⁺ _) (mapWith∈⁻ _ _) (from∘to _) (to∘from _ _)
+  mapWith∈↔ = mk↔ₛ′ (mapWith∈⁺ _) (mapWith∈⁻ _ _) (to∘from _ _) (from∘to _)
     where
     from∘to : ∀ {n} {xs : Vec A n} (f : ∀ {x} → x ∈ xs → B)
               (p : ∃₂ λ x (x∈xs : x ∈ xs) → P (f x∈xs)) →
@@ -401,14 +403,14 @@ module _ {P : Pred B p} where
               mapWith∈⁺ f (mapWith∈⁻ xs f p) ≡ p
     to∘from (y ∷ xs) f (here  p) = refl
     to∘from (y ∷ xs) f (there p) =
-      P.cong there $ to∘from xs (f ∘ there) p
+      cong there $ to∘from xs (f ∘ there) p
 
 ------------------------------------------------------------------------
 -- _∷_
 
 ∷↔ : ∀ {n} (P : Pred A p) {x} {xs : Vec A n} →
      (P x ⊎ Any P xs) ↔ Any P (x ∷ xs)
-∷↔ P {x} {xs} = ++↔ ∘↔ (singleton↔ ⊎-cong id↔)
+∷↔ P {x} {xs} = ↔-trans (singleton↔ ⊎-cong ↔-refl) ++↔
 
 ------------------------------------------------------------------------
 -- _>>=_
@@ -418,4 +420,4 @@ module _ {A B : Set a} {P : Pred B p} {m} {f : A → Vec B m} where
   open CartesianBind
 
   >>=↔ : ∀ {n} {xs : Vec A n} → Any (Any P ∘ f) xs ↔ Any P (xs >>= f)
-  >>=↔ = concat↔ ∘↔ map↔
+  >>=↔ = ↔-trans map↔ concat↔
diff --git a/src/Data/Vec/Relation/Unary/Linked.agda b/src/Data/Vec/Relation/Unary/Linked.agda
index 2ca0182f03..c821a21263 100644
--- a/src/Data/Vec/Relation/Unary/Linked.agda
+++ b/src/Data/Vec/Relation/Unary/Linked.agda
@@ -11,12 +11,13 @@ module Data.Vec.Relation.Unary.Linked {a} {A : Set a} where
 open import Data.Nat.Base using (ℕ; zero; suc; _+_)
 open import Data.Vec.Base as Vec using (Vec; []; _∷_)
 open import Data.Vec.Relation.Unary.All as All using (All; []; _∷_)
-open import Data.Product as Prod using (_,_; _×_; uncurry; <_,_>)
+open import Data.Product.Base as Product using (_,_; _×_; uncurry; <_,_>)
 open import Function.Base using (id; _∘_)
 open import Level using (Level; _⊔_)
-open import Relation.Binary as B using (Rel; _⇒_)
+open import Relation.Binary.Core using (Rel; _⇒_)
+import Relation.Binary.Definitions as B
 open import Relation.Binary.Construct.Intersection renaming (_∩_ to _∩ᵇ_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong₂)
 open import Relation.Unary as U renaming (_∩_ to _∩ᵘ_) hiding (_⇒_)
 open import Relation.Nullary.Decidable as Dec using (yes; no; _×-dec_; map′)
 
@@ -65,7 +66,7 @@ zipWith f (px ∷ pxs , qx ∷ qxs) = f (px , qx) ∷ zipWith f (pxs , qxs)
 unzipWith : R ⇒ P ∩ᵇ Q → Linked R {n} ⊆ Linked P ∩ᵘ Linked Q
 unzipWith f []         = [] , []
 unzipWith f [-]        = [-] , [-]
-unzipWith f (rx ∷ rxs) = Prod.zip _∷_ _∷_ (f rx) (unzipWith f rxs)
+unzipWith f (rx ∷ rxs) = Product.zip _∷_ _∷_ (f rx) (unzipWith f rxs)
 
 zip : Linked P {n} ∩ᵘ Linked Q ⊆ Linked (P ∩ᵇ Q)
 zip = zipWith id
diff --git a/src/Data/Vec/Relation/Unary/Linked/Properties.agda b/src/Data/Vec/Relation/Unary/Linked/Properties.agda
index a9604e1e6a..e49cda76f6 100644
--- a/src/Data/Vec/Relation/Unary/Linked/Properties.agda
+++ b/src/Data/Vec/Relation/Unary/Linked/Properties.agda
@@ -8,21 +8,18 @@
 
 module Data.Vec.Relation.Unary.Linked.Properties where
 
-open import Data.Bool.Base using (true; false)
 open import Data.Vec.Base as Vec
 open import Data.Vec.Relation.Unary.All as All using (All; []; _∷_)
-import Data.Vec.Relation.Unary.All.Properties as Allₚ
+import Data.Vec.Relation.Unary.All.Properties as All
 open import Data.Vec.Relation.Unary.Linked as Linked
   using (Linked; []; [-]; _∷_)
 open import Data.Fin.Base using (zero; suc; _<_)
-open import Data.Nat.Base using (ℕ; zero; suc; NonZero)
-open import Data.Nat.Properties using (<-pred)
+open import Data.Nat.Base using (ℕ; zero; suc; s<s⁻¹)
 open import Level using (Level)
-open import Function.Base using (_∘_; flip; _on_)
-open import Relation.Binary using (Rel; Transitive; DecSetoid)
-open import Relation.Binary.PropositionalEquality using (_≢_)
+open import Function.Base using (_on_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Transitive)
 open import Relation.Unary using (Pred; Decidable)
-open import Relation.Nullary.Decidable using (yes; no; does)
 
 private
   variable
@@ -46,8 +43,8 @@ module _ (trans : Transitive R) where
   lookup⁺ : ∀ {i j} {xs : Vec _ n} →
            Linked R xs → i < j →
            R (lookup xs i) (lookup xs j)
-  lookup⁺ {i = zero}  {j = suc j} (rx ∷ rxs) i<j = Allₚ.lookup⁺ (Linked⇒All rx rxs) j
-  lookup⁺ {i = suc i} {j = suc j} (_  ∷ rxs) i<j = lookup⁺ rxs (<-pred i<j)
+  lookup⁺ {i = zero}  {j = suc j} (rx ∷ rxs) i<j = All.lookup⁺ (Linked⇒All rx rxs) j
+  lookup⁺ {i = suc i} {j = suc j} (_  ∷ rxs) i<j = lookup⁺ rxs (s<s⁻¹ i<j)
 
 ------------------------------------------------------------------------
 -- Introduction (⁺) and elimination (⁻) rules for vec operations
diff --git a/src/Data/Vec/Relation/Unary/Unique/Propositional.agda b/src/Data/Vec/Relation/Unary/Unique/Propositional.agda
index 836f7f5b67..20b042ef17 100644
--- a/src/Data/Vec/Relation/Unary/Unique/Propositional.agda
+++ b/src/Data/Vec/Relation/Unary/Unique/Propositional.agda
@@ -8,7 +8,7 @@
 
 module Data.Vec.Relation.Unary.Unique.Propositional {a} {A : Set a} where
 
-open import Relation.Binary.PropositionalEquality using (setoid)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 open import Data.Vec.Relation.Unary.Unique.Setoid as SetoidUnique
 
 ------------------------------------------------------------------------
diff --git a/src/Data/Vec/Relation/Unary/Unique/Propositional/Properties.agda b/src/Data/Vec/Relation/Unary/Unique/Propositional/Properties.agda
index 9ab4cd57f7..dc78ff30d3 100644
--- a/src/Data/Vec/Relation/Unary/Unique/Propositional/Properties.agda
+++ b/src/Data/Vec/Relation/Unary/Unique/Propositional/Properties.agda
@@ -8,23 +8,25 @@
 
 module Data.Vec.Relation.Unary.Unique.Propositional.Properties where
 
-open import Data.Vec.Base
+open import Data.Vec.Base using (Vec; map; take; drop; tabulate; lookup)
 open import Data.Vec.Relation.Unary.All as All using (All; []; _∷_)
 open import Data.Vec.Relation.Unary.AllPairs as AllPairs using (AllPairs)
-open import Data.Vec.Relation.Unary.Unique.Propositional
+open import Data.Vec.Relation.Unary.Unique.Propositional using (Unique)
 import Data.Vec.Relation.Unary.Unique.Setoid.Properties as Setoid
-open import Data.Fin.Base using(Fin)
-open import Data.Nat.Base
+open import Data.Fin.Base using (Fin)
+open import Data.Nat.Base using (_+_)
 open import Data.Nat.Properties using (<⇒≢)
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Data.Product.Relation.Binary.Pointwise.NonDependent using (≡⇒≡×≡)
 open import Function.Base using (id; _∘_)
 open import Level using (Level)
-open import Relation.Binary using (Rel; Setoid)
-open import Relation.Binary.PropositionalEquality
-  using (refl; _≡_; _≢_; sym; setoid)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Core
+  using (refl; _≡_; _≢_; sym)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 open import Relation.Unary using (Pred; Decidable)
-open import Relation.Nullary.Negation using (¬_)
+open import Relation.Nullary.Negation.Core using (¬_)
 
 private
   variable
diff --git a/src/Data/Vec/Relation/Unary/Unique/Setoid.agda b/src/Data/Vec/Relation/Unary/Unique/Setoid.agda
index 3f0db9d300..76610e0485 100644
--- a/src/Data/Vec/Relation/Unary/Unique/Setoid.agda
+++ b/src/Data/Vec/Relation/Unary/Unique/Setoid.agda
@@ -6,7 +6,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Rel; Setoid)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Data.Vec.Relation.Unary.Unique.Setoid {a ℓ} (S : Setoid a ℓ) where
 
diff --git a/src/Data/Vec/Relation/Unary/Unique/Setoid/Properties.agda b/src/Data/Vec/Relation/Unary/Unique/Setoid/Properties.agda
index 66371b89b5..fa19dc3e21 100644
--- a/src/Data/Vec/Relation/Unary/Unique/Setoid/Properties.agda
+++ b/src/Data/Vec/Relation/Unary/Unique/Setoid/Properties.agda
@@ -11,15 +11,16 @@ module Data.Vec.Relation.Unary.Unique.Setoid.Properties where
 open import Data.Fin.Base using (Fin; zero; suc)
 open import Data.Vec.Base as Vec
 open import Data.Vec.Relation.Unary.All as All using (All; []; _∷_)
-import Data.Vec.Relation.Unary.All.Properties as Allₚ
+import Data.Vec.Relation.Unary.All.Properties as All
 open import Data.Vec.Relation.Unary.AllPairs as AllPairs using (AllPairs)
 open import Data.Vec.Relation.Unary.Unique.Setoid
-import Data.Vec.Relation.Unary.AllPairs.Properties as AllPairsₚ
+import Data.Vec.Relation.Unary.AllPairs.Properties as AllPairs
 open import Data.Nat.Base using (ℕ; _+_)
 open import Function.Base using (_∘_; id)
 open import Level using (Level)
-open import Relation.Binary using (Rel; Setoid)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Nullary.Negation using (contradiction; contraposition)
 
 private
@@ -38,7 +39,7 @@ module _ (S : Setoid a ℓ₁) (R : Setoid b ℓ₂) where
 
   map⁺ : ∀ {f} → (∀ {x y} → f x ≈₂ f y → x ≈₁ y) →
          ∀ {n xs} → Unique S {n} xs → Unique R {n} (map f xs)
-  map⁺ inj xs! = AllPairsₚ.map⁺ (AllPairs.map (contraposition inj) xs!)
+  map⁺ inj xs! = AllPairs.map⁺ (AllPairs.map (contraposition inj) xs!)
 
 ------------------------------------------------------------------------
 -- take & drop
@@ -46,10 +47,10 @@ module _ (S : Setoid a ℓ₁) (R : Setoid b ℓ₂) where
 module _ (S : Setoid a ℓ) where
 
   drop⁺ : ∀ {n} m {xs} → Unique S {m + n} xs → Unique S {n} (drop m xs)
-  drop⁺ = AllPairsₚ.drop⁺
+  drop⁺ = AllPairs.drop⁺
 
   take⁺ : ∀ {n} m {xs} → Unique S {m + n} xs → Unique S {m} (take m xs)
-  take⁺ = AllPairsₚ.take⁺
+  take⁺ = AllPairs.take⁺
 
 ------------------------------------------------------------------------
 -- tabulate
@@ -60,7 +61,7 @@ module _ (S : Setoid a ℓ) where
 
   tabulate⁺ : ∀ {n} {f : Fin n → A} → (∀ {i j} → f i ≈ f j → i ≡ j) →
               Unique S (tabulate f)
-  tabulate⁺ f-inj = AllPairsₚ.tabulate⁺ (_∘ f-inj)
+  tabulate⁺ f-inj = AllPairs.tabulate⁺ (_∘ f-inj)
 
 ------------------------------------------------------------------------
 -- lookup
@@ -70,7 +71,7 @@ module _ (S : Setoid a ℓ) where
   open Setoid S
 
   lookup-injective : ∀ {n xs} → Unique S {n} xs → ∀ i j → lookup xs i ≈ lookup xs j → i ≡ j
-  lookup-injective (px ∷ pxs) zero zero eq = P.refl
-  lookup-injective (px ∷ pxs) zero (suc j) eq = contradiction eq (Allₚ.lookup⁺ px j)
-  lookup-injective (px ∷ pxs) (suc i) zero eq = contradiction (sym eq) (Allₚ.lookup⁺ px i)
-  lookup-injective (px ∷ pxs) (suc i) (suc j) eq = P.cong suc (lookup-injective pxs i j eq)
+  lookup-injective (px ∷ pxs) zero zero eq = ≡.refl
+  lookup-injective (px ∷ pxs) zero (suc j) eq = contradiction eq (All.lookup⁺ px j)
+  lookup-injective (px ∷ pxs) (suc i) zero eq = contradiction (sym eq) (All.lookup⁺ px i)
+  lookup-injective (px ∷ pxs) (suc i) (suc j) eq = ≡.cong suc (lookup-injective pxs i j eq)
diff --git a/src/Data/Vec/Show.agda b/src/Data/Vec/Show.agda
new file mode 100644
index 0000000000..99daee3639
--- /dev/null
+++ b/src/Data/Vec/Show.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Showing vectors
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Vec.Show where
+
+import Data.List.Show as List
+open import Data.String.Base using (String)
+open import Data.Vec.Base using (Vec; toList)
+open import Function.Base using (_∘_)
+
+show : ∀ {a} {A : Set a} {n} → (A → String) → (Vec A n → String)
+show s = List.show s ∘ toList
diff --git a/src/Data/W.agda b/src/Data/W.agda
index 3f2b35909f..159c0883a5 100644
--- a/src/Data/W.agda
+++ b/src/Data/W.agda
@@ -8,9 +8,9 @@
 
 module Data.W where
 
-open import Level
+open import Level using (Level; _⊔_)
 open import Function.Base using (_$_; _∘_; const)
-open import Data.Product using (_,_; -,_; proj₂)
+open import Data.Product.Base using (_,_; -,_; proj₂)
 open import Data.Container.Core using (Container; ⟦_⟧; Shape; Position; _⇒_; ⟪_⟫)
 open import Data.Container.Relation.Unary.All using (□; all)
 open import Relation.Nullary.Negation using (¬_)
diff --git a/src/Data/W/Indexed.agda b/src/Data/W/Indexed.agda
index b356a22533..fbf3910427 100644
--- a/src/Data/W/Indexed.agda
+++ b/src/Data/W/Indexed.agda
@@ -10,7 +10,7 @@ module Data.W.Indexed where
 
 open import Level
 open import Data.Container.Indexed.Core
-open import Data.Product
+open import Data.Product.Base using (_,_; Σ)
 open import Relation.Unary
 
 -- The family of indexed W-types.
diff --git a/src/Data/W/Sized.agda b/src/Data/W/Sized.agda
index c16b21828e..0a0b2b6e90 100644
--- a/src/Data/W/Sized.agda
+++ b/src/Data/W/Sized.agda
@@ -11,11 +11,11 @@ module Data.W.Sized where
 open import Level
 open import Size
 open import Function.Base using (_$_; _∘_; const)
-open import Data.Product using (_,_; -,_; proj₂)
+open import Data.Product.Base using (_,_; -,_; proj₂)
 open import Data.Container.Core as Container using (Container; ⟦_⟧; Shape; Position; _⇒_; ⟪_⟫)
 open import Data.Container.Relation.Unary.All using (□; all)
 open import Relation.Nullary.Negation using (¬_)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 private
   variable
diff --git a/src/Data/W/WithK.agda b/src/Data/W/WithK.agda
index 0646bfb315..e88fb7cda5 100644
--- a/src/Data/W/WithK.agda
+++ b/src/Data/W/WithK.agda
@@ -8,7 +8,7 @@
 
 module Data.W.WithK where
 
-open import Data.Product
+open import Data.Product.Base using (_,_)
 open import Data.Container.Core
 open import Data.W
 open import Agda.Builtin.Equality
diff --git a/src/Data/Word.agda b/src/Data/Word.agda
index 8c07cac9c7..df6594641c 100644
--- a/src/Data/Word.agda
+++ b/src/Data/Word.agda
@@ -1,15 +1,15 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Machine words
+-- This module is DEPRECATED. Please use Data.Word64 instead
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Data.Word where
 
-------------------------------------------------------------------------
--- Re-export base definitions and decidability of equality
+open import Data.Word64 public
 
-open import Data.Word.Base public
-open import Data.Word.Properties using (_≈?_; _<?_; _≟_; _==_) public
+{-# WARNING_ON_IMPORT
+"Data.Word was deprecated in v2.1. Use Data.Word64 instead."
+#-}
diff --git a/src/Data/Word/Base.agda b/src/Data/Word/Base.agda
index 34206371e1..f1f766885b 100644
--- a/src/Data/Word/Base.agda
+++ b/src/Data/Word/Base.agda
@@ -1,33 +1,15 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Machine words: basic type and conversion functions
+-- This module is DEPRECATED. Please use Data.Word64.Base instead
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Data.Word.Base where
 
-open import Level using (zero)
-import Data.Nat.Base as ℕ
-open import Function
-open import Relation.Binary using (Rel)
-open import Relation.Binary.PropositionalEquality
+open import Data.Word64.Base public
 
-------------------------------------------------------------------------
--- Re-export built-ins publicly
-
-open import Agda.Builtin.Word public
-  using (Word64)
-  renaming
-  ( primWord64ToNat   to toℕ
-  ; primWord64FromNat to fromℕ
-  )
-
-infix 4 _≈_
-_≈_ : Rel Word64 zero
-_≈_ = _≡_ on toℕ
-
-infix 4 _<_
-_<_ : Rel Word64 zero
-_<_ = ℕ._<_ on toℕ
+{-# WARNING_ON_IMPORT
+"Data.Word.Base was deprecated in v2.1. Use Data.Word64.Base instead."
+#-}
diff --git a/src/Data/Word/Instances.agda b/src/Data/Word/Instances.agda
index 20b630ec4b..e2df252dda 100644
--- a/src/Data/Word/Instances.agda
+++ b/src/Data/Word/Instances.agda
@@ -1,16 +1,15 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Instances for words
+-- This module is DEPRECATED. Please use Data.Word64.Instances instead
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Data.Word.Instances where
 
-open import Data.Word.Properties
-open import Relation.Binary.PropositionalEquality.Properties
-  using (isDecEquivalence)
+open import Data.Word64.Instances public
 
-instance
-  Word-≡-isDecEquivalence = isDecEquivalence _≟_
+{-# WARNING_ON_IMPORT
+"Data.Word.Instances was deprecated in v2.1. Use Data.Word64.Instances instead."
+#-}
diff --git a/src/Data/Word/Properties.agda b/src/Data/Word/Properties.agda
index 3f9ad94ef1..b053aee190 100644
--- a/src/Data/Word/Properties.agda
+++ b/src/Data/Word/Properties.agda
@@ -1,106 +1,15 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Properties of operations on machine words
+-- This module is DEPRECATED. Please use Data.Word64.Properties instead
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Data.Word.Properties where
 
-import Data.Nat.Base as ℕ
-open import Data.Bool.Base using (Bool)
-open import Data.Word.Base
-import Data.Nat.Properties as ℕₚ
-open import Function.Base
-open import Relation.Nullary.Decidable using (map′; ⌊_⌋)
-open import Relation.Binary
-  using ( _⇒_; Reflexive; Symmetric; Transitive; Substitutive
-        ; Decidable; DecidableEquality; IsEquivalence; IsDecEquivalence
-        ; Setoid; DecSetoid; StrictTotalOrder)
-import Relation.Binary.Construct.On as On
-open import Relation.Binary.PropositionalEquality
+open import Data.Word64.Properties public
 
-------------------------------------------------------------------------
--- Primitive properties
-
-open import Agda.Builtin.Word.Properties
-  renaming (primWord64ToNatInjective to toℕ-injective)
-  public
-
-------------------------------------------------------------------------
--- Properties of _≈_
-
-≈⇒≡ : _≈_ ⇒ _≡_
-≈⇒≡ = toℕ-injective _ _
-
-≈-reflexive : _≡_ ⇒ _≈_
-≈-reflexive = cong toℕ
-
-≈-refl : Reflexive _≈_
-≈-refl = refl
-
-≈-sym : Symmetric _≈_
-≈-sym = sym
-
-≈-trans : Transitive _≈_
-≈-trans = trans
-
-≈-subst : ∀ {ℓ} → Substitutive _≈_ ℓ
-≈-subst P x≈y p = subst P (≈⇒≡ x≈y) p
-
-infix 4 _≈?_
-_≈?_ : Decidable _≈_
-x ≈? y = toℕ x ℕₚ.≟ toℕ y
-
-≈-isEquivalence : IsEquivalence _≈_
-≈-isEquivalence = record
-  { refl  = λ {i} → ≈-refl {i}
-  ; sym   = λ {i j} → ≈-sym {i} {j}
-  ; trans = λ {i j k} → ≈-trans {i} {j} {k}
-  }
-
-≈-setoid : Setoid _ _
-≈-setoid = record
-  { isEquivalence = ≈-isEquivalence
-  }
-
-≈-isDecEquivalence : IsDecEquivalence _≈_
-≈-isDecEquivalence = record
-  { isEquivalence = ≈-isEquivalence
-  ; _≟_           = _≈?_
-  }
-
-≈-decSetoid : DecSetoid _ _
-≈-decSetoid = record
-  { isDecEquivalence = ≈-isDecEquivalence
-  }
-------------------------------------------------------------------------
--- Properties of _≡_
-
-infix 4 _≟_
-_≟_ : DecidableEquality Word64
-x ≟ y = map′ ≈⇒≡ ≈-reflexive (x ≈? y)
-
-≡-setoid : Setoid _ _
-≡-setoid = setoid Word64
-
-≡-decSetoid : DecSetoid _ _
-≡-decSetoid = decSetoid _≟_
-
-------------------------------------------------------------------------
--- Boolean equality test.
-
-infix 4 _==_
-_==_ : Word64 → Word64 → Bool
-w₁ == w₂ = ⌊ w₁ ≟ w₂ ⌋
-
-------------------------------------------------------------------------
--- Properties of _<_
-
-infix 4 _<?_
-_<?_ : Decidable _<_
-_<?_ = On.decidable toℕ ℕ._<_ ℕₚ._<?_
-
-<-strictTotalOrder-≈ : StrictTotalOrder _ _ _
-<-strictTotalOrder-≈ = On.strictTotalOrder ℕₚ.<-strictTotalOrder toℕ
+{-# WARNING_ON_IMPORT
+"Data.Word.Properties was deprecated in v2.1. Use Data.Word64.Properties instead."
+#-}
diff --git a/src/Data/Word64.agda b/src/Data/Word64.agda
new file mode 100644
index 0000000000..5c5004a1a4
--- /dev/null
+++ b/src/Data/Word64.agda
@@ -0,0 +1,15 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Machine words
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Word64 where
+
+------------------------------------------------------------------------
+-- Re-export base definitions and decidability of equality
+
+open import Data.Word64.Base public
+open import Data.Word64.Properties using (_≈?_; _<?_; _≟_; _==_) public
diff --git a/src/Data/Word64/Base.agda b/src/Data/Word64/Base.agda
new file mode 100644
index 0000000000..8ce6daa615
--- /dev/null
+++ b/src/Data/Word64/Base.agda
@@ -0,0 +1,41 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Machine words: basic type and conversion functions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Word64.Base where
+
+open import Algebra.Core using (Op₂)
+open import Data.Nat.Base as ℕ using (ℕ)
+open import Function.Base using (_on_; _∘₂′_)
+open import Level using (zero)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+
+------------------------------------------------------------------------
+-- Re-export built-ins publicly
+
+open import Agda.Builtin.Word public
+  using (Word64)
+  renaming
+  ( primWord64ToNat   to toℕ
+  ; primWord64FromNat to fromℕ
+  )
+
+liftOp₂ : Op₂ ℕ → Op₂ Word64
+liftOp₂ op = fromℕ ∘₂′ op on toℕ
+
+infix 4 _≈_
+_≈_ : Rel Word64 zero
+_≈_ = _≡_ on toℕ
+
+infix 4 _<_
+_<_ : Rel Word64 zero
+_<_ = ℕ._<_ on toℕ
+
+infix 4 _≤_
+_≤_ : Rel Word64 zero
+_≤_ = ℕ._≤_ on toℕ
diff --git a/src/Data/Word64/Instances.agda b/src/Data/Word64/Instances.agda
new file mode 100644
index 0000000000..b771529d13
--- /dev/null
+++ b/src/Data/Word64/Instances.agda
@@ -0,0 +1,16 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Instances for words
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Word64.Instances where
+
+open import Data.Word64.Properties
+open import Relation.Binary.PropositionalEquality.Properties
+  using (isDecEquivalence)
+
+instance
+  Word64-≡-isDecEquivalence = isDecEquivalence _≟_
diff --git a/src/Data/Word64/Literals.agda b/src/Data/Word64/Literals.agda
new file mode 100644
index 0000000000..70d1365e5f
--- /dev/null
+++ b/src/Data/Word64/Literals.agda
@@ -0,0 +1,19 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Word64 Literals
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Word64.Literals where
+
+open import Agda.Builtin.FromNat using (Number)
+open import Data.Unit.Base using (⊤)
+open import Data.Word64.Base using (Word64; fromℕ)
+
+number : Number Word64
+number = record
+  { Constraint = λ _ → ⊤
+  ; fromNat    = λ w → fromℕ w
+  }
diff --git a/src/Data/Word64/Primitive.agda b/src/Data/Word64/Primitive.agda
new file mode 100644
index 0000000000..ff92d306fa
--- /dev/null
+++ b/src/Data/Word64/Primitive.agda
@@ -0,0 +1,29 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Word64: simple bindings to Haskell types and functions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Word64.Primitive where
+
+open import Agda.Builtin.Bool using (Bool)
+open import Agda.Builtin.Nat using (Nat)
+open import Agda.Builtin.String using (String)
+open import Agda.Builtin.Word using (Word64)
+
+postulate
+  testBit : Word64 → Nat → Bool
+  setBit : Word64 → Nat → Word64
+  clearBit : Word64 → Nat → Word64
+  show : Word64 → String
+
+{-# FOREIGN GHC import GHC.Word #-}
+{-# FOREIGN GHC import qualified Data.Bits as B #-}
+{-# FOREIGN GHC import qualified Data.Text as T #-}
+
+{-# COMPILE GHC testBit = \ w -> B.testBit w . fromIntegral #-}
+{-# COMPILE GHC setBit = \ w -> B.setBit w . fromIntegral #-}
+{-# COMPILE GHC clearBit = \ w -> B.clearBit  w . fromIntegral #-}
+{-# COMPILE GHC show = T.pack . Prelude.show #-}
diff --git a/src/Data/Word64/Properties.agda b/src/Data/Word64/Properties.agda
new file mode 100644
index 0000000000..0f5b4d8fe5
--- /dev/null
+++ b/src/Data/Word64/Properties.agda
@@ -0,0 +1,108 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Properties of operations on machine words
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Data.Word64.Properties where
+
+import Data.Nat.Base as ℕ
+open import Data.Bool.Base using (Bool)
+open import Data.Word64.Base using (_≈_; toℕ; Word64; _<_)
+import Data.Nat.Properties as ℕ
+open import Relation.Nullary.Decidable.Core using (map′; ⌊_⌋)
+open import Relation.Binary
+  using ( _⇒_; Reflexive; Symmetric; Transitive; Substitutive
+        ; Decidable; DecidableEquality; IsEquivalence; IsDecEquivalence
+        ; Setoid; DecSetoid; StrictTotalOrder)
+import Relation.Binary.Construct.On as On
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong; sym; trans; subst)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (setoid; decSetoid)
+
+------------------------------------------------------------------------
+-- Primitive properties
+
+open import Agda.Builtin.Word.Properties
+  renaming (primWord64ToNatInjective to toℕ-injective)
+  public
+
+------------------------------------------------------------------------
+-- Properties of _≈_
+
+≈⇒≡ : _≈_ ⇒ _≡_
+≈⇒≡ = toℕ-injective _ _
+
+≈-reflexive : _≡_ ⇒ _≈_
+≈-reflexive = cong toℕ
+
+≈-refl : Reflexive _≈_
+≈-refl = refl
+
+≈-sym : Symmetric _≈_
+≈-sym = sym
+
+≈-trans : Transitive _≈_
+≈-trans = trans
+
+≈-subst : ∀ {ℓ} → Substitutive _≈_ ℓ
+≈-subst P x≈y p = subst P (≈⇒≡ x≈y) p
+
+infix 4 _≈?_
+_≈?_ : Decidable _≈_
+x ≈? y = toℕ x ℕ.≟ toℕ y
+
+≈-isEquivalence : IsEquivalence _≈_
+≈-isEquivalence = record
+  { refl  = λ {i} → ≈-refl {i}
+  ; sym   = λ {i j} → ≈-sym {i} {j}
+  ; trans = λ {i j k} → ≈-trans {i} {j} {k}
+  }
+
+≈-setoid : Setoid _ _
+≈-setoid = record
+  { isEquivalence = ≈-isEquivalence
+  }
+
+≈-isDecEquivalence : IsDecEquivalence _≈_
+≈-isDecEquivalence = record
+  { isEquivalence = ≈-isEquivalence
+  ; _≟_           = _≈?_
+  }
+
+≈-decSetoid : DecSetoid _ _
+≈-decSetoid = record
+  { isDecEquivalence = ≈-isDecEquivalence
+  }
+------------------------------------------------------------------------
+-- Properties of _≡_
+
+infix 4 _≟_
+_≟_ : DecidableEquality Word64
+x ≟ y = map′ ≈⇒≡ ≈-reflexive (x ≈? y)
+
+≡-setoid : Setoid _ _
+≡-setoid = setoid Word64
+
+≡-decSetoid : DecSetoid _ _
+≡-decSetoid = decSetoid _≟_
+
+------------------------------------------------------------------------
+-- Boolean equality test.
+
+infix 4 _==_
+_==_ : Word64 → Word64 → Bool
+w₁ == w₂ = ⌊ w₁ ≟ w₂ ⌋
+
+------------------------------------------------------------------------
+-- Properties of _<_
+
+infix 4 _<?_
+_<?_ : Decidable _<_
+_<?_ = On.decidable toℕ ℕ._<_ ℕ._<?_
+
+<-strictTotalOrder-≈ : StrictTotalOrder _ _ _
+<-strictTotalOrder-≈ = On.strictTotalOrder ℕ.<-strictTotalOrder toℕ
diff --git a/src/Data/Word64/Show.agda b/src/Data/Word64/Show.agda
new file mode 100644
index 0000000000..cdf9a0cf98
--- /dev/null
+++ b/src/Data/Word64/Show.agda
@@ -0,0 +1,36 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Bytes: showing bit patterns
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Word64.Show where
+
+open import Agda.Builtin.String using (String)
+
+open import Data.Bool.Show using (showBit)
+open import Data.Fin.Base as Fin using (Fin)
+import Data.Nat.Show as ℕ
+open import Data.String using (_++_; fromVec; padLeft)
+open import Data.Vec.Base as Vec using (Vec; []; _∷_)
+
+open import Data.Word64.Base
+open import Data.Word64.Unsafe
+
+open import Function.Base using (_$_)
+
+showBits : Word64 → String
+showBits w
+  = "0b" ++_
+  $ fromVec
+  $ Vec.reverse
+  $ Vec.map showBit
+  $ toBits w
+
+showHexa : Word64 → String
+showHexa w
+  = "0x" ++_
+  $ padLeft '0' 8
+  $ ℕ.showInBase 16 (toℕ w)
diff --git a/src/Data/Word64/Unsafe.agda b/src/Data/Word64/Unsafe.agda
new file mode 100644
index 0000000000..dcae0d6c61
--- /dev/null
+++ b/src/Data/Word64/Unsafe.agda
@@ -0,0 +1,45 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Machine words: unsafe functions using the FFI
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Word64.Unsafe where
+
+open import Agda.Builtin.Bool using (Bool; true; false)
+open import Data.Fin.Base as Fin using (Fin)
+open import Data.Product.Base using (proj₁)
+open import Data.Vec.Base as Vec using (Vec)
+open import Data.Word8.Base as Word8 using (Word8)
+open import Data.Word64.Base
+open import Function.Base using (_$_; _|>_)
+
+------------------------------------------------------------------------
+-- Re-export primitives publicly
+
+open import Data.Word64.Primitive as Prim public
+  using ( show )
+
+testBit : Word64 → Fin 64 → Bool
+testBit w i = Prim.testBit w (Fin.toℕ i)
+
+_[_]≔_ : Word64 → Fin 64 → Bool → Word64
+w [ i ]≔ false = Prim.clearBit w (Fin.toℕ i)
+w [ i ]≔ true  = Prim.setBit w (Fin.toℕ i)
+
+------------------------------------------------------------------------
+-- Convert to its components
+
+toBits : Word64 → Vec Bool 64
+toBits w = Vec.tabulate (testBit w)
+
+fromBits : Vec Bool 64 → Word64
+fromBits bs = Vec.foldl′ _|>_ (fromℕ 0)
+            $ Vec.zipWith (λ i b → _[ i ]≔ b) (Vec.allFin 64) bs
+
+toWord64s : Word64 → Vec Word8 8
+toWord64s w =
+  let ws = proj₁ (Vec.group 8 8 (toBits w)) in
+  Vec.map Word8.fromBits ws
diff --git a/src/Data/Word8/Base.agda b/src/Data/Word8/Base.agda
new file mode 100644
index 0000000000..142b544d78
--- /dev/null
+++ b/src/Data/Word8/Base.agda
@@ -0,0 +1,51 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Bytes: base type and functions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Word8.Base where
+
+open import Agda.Builtin.Bool using (Bool; true; false)
+open import Agda.Builtin.Char using (Char)
+open import Agda.Builtin.Nat using (Nat; _==_)
+open import Agda.Builtin.Unit using (⊤)
+
+open import Data.Fin.Base as Fin using (Fin)
+open import Data.Vec.Base as Vec using (Vec; []; _∷_)
+
+open import Function.Base using (_$_; _|>_)
+
+------------------------------------------------------------------------------
+-- Re-export type and operations
+
+open import Data.Word8.Primitive as Prim public
+  using ( Word8
+        ; _+_
+        ; show
+        )
+  renaming ( fromNat to fromℕ
+           ; toNat to toℕ
+           )
+
+testBit : Word8 → Fin 8 → Bool
+testBit w i = Prim.testBit w (Fin.toℕ i)
+
+_[_]≔_ : Word8 → Fin 8 → Bool → Word8
+w [ i ]≔ false = Prim.clearBit w (Fin.toℕ i)
+w [ i ]≔ true  = Prim.setBit w (Fin.toℕ i)
+
+------------------------------------------------------------------------------
+-- Basic functions
+
+toBits : Word8 → Vec Bool 8
+toBits w = Vec.tabulate (testBit w)
+
+fromBits : Vec Bool 8 → Word8
+fromBits bs = Vec.foldl′ _|>_ (fromℕ 0)
+            $ Vec.zipWith (λ i b → _[ i ]≔ b) (Vec.allFin 8) bs
+
+_≡ᵇ_ : Word8 → Word8 → Bool
+w ≡ᵇ w′ = toℕ w == toℕ w′
diff --git a/src/Data/Word8/Literals.agda b/src/Data/Word8/Literals.agda
new file mode 100644
index 0000000000..acc608f899
--- /dev/null
+++ b/src/Data/Word8/Literals.agda
@@ -0,0 +1,19 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Byte Literals
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Word8.Literals where
+
+open import Agda.Builtin.FromNat using (Number)
+open import Data.Unit.Base using (⊤)
+open import Data.Word8.Base using (Word8; fromℕ)
+
+number : Number Word8
+number = record
+  { Constraint = λ _ → ⊤
+  ; fromNat    = λ w → fromℕ w
+  }
diff --git a/src/Data/Word8/Primitive.agda b/src/Data/Word8/Primitive.agda
new file mode 100644
index 0000000000..e0d2ac87c7
--- /dev/null
+++ b/src/Data/Word8/Primitive.agda
@@ -0,0 +1,36 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Bytes: simple bindings to Haskell types and functions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Word8.Primitive where
+
+open import Agda.Builtin.Bool using (Bool)
+open import Agda.Builtin.Nat using (Nat)
+open import Agda.Builtin.String using (String)
+
+postulate
+  Word8 : Set
+  testBit : Word8 → Nat → Bool
+  setBit : Word8 → Nat → Word8
+  clearBit : Word8 → Nat → Word8
+  fromNat : Nat → Word8
+  toNat : Word8 → Nat
+  _+_ : Word8 → Word8 → Word8
+  show : Word8 → String
+
+{-# FOREIGN GHC import GHC.Word #-}
+{-# FOREIGN GHC import qualified Data.Bits as B #-}
+{-# FOREIGN GHC import qualified Data.Text as T #-}
+
+{-# COMPILE GHC Word8 = type Word8 #-}
+{-# COMPILE GHC testBit = \ w -> B.testBit w . fromIntegral #-}
+{-# COMPILE GHC setBit = \ w -> B.setBit w . fromIntegral #-}
+{-# COMPILE GHC clearBit = \ w -> B.clearBit  w . fromIntegral #-}
+{-# COMPILE GHC fromNat = fromIntegral #-}
+{-# COMPILE GHC toNat = fromIntegral #-}
+{-# COMPILE GHC _+_ = (+) #-}
+{-# COMPILE GHC show = T.pack . Prelude.show #-}
diff --git a/src/Data/Word8/Show.agda b/src/Data/Word8/Show.agda
new file mode 100644
index 0000000000..0cc5b5d7b5
--- /dev/null
+++ b/src/Data/Word8/Show.agda
@@ -0,0 +1,33 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Bytes: showing bit patterns
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module Data.Word8.Show where
+
+open import Agda.Builtin.String using (String)
+
+open import Data.Bool.Show using (showBit)
+open import Data.Fin.Base as Fin using (Fin)
+import Data.Nat.Show as ℕ
+open import Data.String using (_++_; fromVec; padLeft)
+open import Data.Vec.Base as Vec using (Vec; []; _∷_)
+open import Data.Word8.Base
+open import Function.Base using (_$_)
+
+showBits : Word8 → String
+showBits w
+  = "0b" ++_
+  $ fromVec
+  $ Vec.reverse
+  $ Vec.map showBit
+  $ toBits w
+
+showHexa : Word8 → String
+showHexa w
+  = "0x" ++_
+  $ padLeft '0' 2
+  $ ℕ.showInBase 16 (toℕ w)
diff --git a/src/Effect/Applicative.agda b/src/Effect/Applicative.agda
index 51f7d21368..1fde40139f 100644
--- a/src/Effect/Applicative.agda
+++ b/src/Effect/Applicative.agda
@@ -12,7 +12,7 @@
 module Effect.Applicative where
 
 open import Data.Bool.Base using (Bool; true; false)
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Data.Unit.Polymorphic.Base using (⊤)
 
 open import Effect.Choice using (RawChoice)
@@ -21,7 +21,7 @@ open import Effect.Functor as Fun using (RawFunctor)
 
 open import Function.Base using (const; flip; _∘′_)
 open import Level using (Level; suc; _⊔_)
-open import Relation.Binary.PropositionalEquality.Core as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 private
   variable
@@ -53,6 +53,10 @@ record RawApplicative (F : Set f → Set g) : Set (suc f ⊔ g) where
   zip : F A → F B → F (A × B)
   zip = zipWith _,_
 
+  -- Haskell-style alternative name for pure
+  return : A → F A
+  return = pure
+
   -- backwards compatibility: unicode variants
   _⊛_ : F (A → B) → F A → F B
   _⊛_ = _<*>_
@@ -73,7 +77,7 @@ module _ where
 
   -- Smart constructor
   mkRawApplicative :
-    (F : Set f → Set f) →
+    (F : Set f → Set g) →
     (pure : ∀ {A} → A → F A) →
     (app : ∀ {A B} → F (A → B) → F A → F B) →
     RawApplicative F
diff --git a/src/Effect/Applicative/Indexed.agda b/src/Effect/Applicative/Indexed.agda
index de2b381934..d08a515086 100644
--- a/src/Effect/Applicative/Indexed.agda
+++ b/src/Effect/Applicative/Indexed.agda
@@ -12,10 +12,12 @@
 module Effect.Applicative.Indexed where
 
 open import Effect.Functor using (RawFunctor)
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Function.Base
 open import Level
-open import Relation.Binary.PropositionalEquality.Core as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong₂)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 
 private
   variable
@@ -109,6 +111,6 @@ record Morphism {I : Set i} {F₁ F₂ : IFun I f}
            op (f A₁.<$> x) ≡ (f A₂.<$> op x)
   op-<$> f x = begin
     op (A₁._⊛_ (A₁.pure f) x)       ≡⟨ op-⊛ _ _ ⟩
-    A₂._⊛_ (op (A₁.pure f)) (op x)  ≡⟨ P.cong₂ A₂._⊛_ (op-pure _) P.refl ⟩
+    A₂._⊛_ (op (A₁.pure f)) (op x)  ≡⟨ cong₂ A₂._⊛_ (op-pure _) refl ⟩
     A₂._⊛_ (A₂.pure f) (op x)       ∎
-    where open P.≡-Reasoning
+    where open ≡-Reasoning
diff --git a/src/Effect/Applicative/Predicate.agda b/src/Effect/Applicative/Predicate.agda
index 0bfe6a9803..5d696b37b2 100644
--- a/src/Effect/Applicative/Predicate.agda
+++ b/src/Effect/Applicative/Predicate.agda
@@ -12,8 +12,8 @@
 module Effect.Applicative.Predicate where
 
 open import Effect.Functor.Predicate
-open import Data.Product
-open import Function
+open import Data.Product.Base using (_,_)
+open import Function.Base using (const; constᵣ)
 open import Level
 open import Relation.Unary
 open import Relation.Unary.PredicateTransformer using (Pt)
diff --git a/src/Effect/Comonad.agda b/src/Effect/Comonad.agda
index 67a4d7d43d..72cf07d732 100644
--- a/src/Effect/Comonad.agda
+++ b/src/Effect/Comonad.agda
@@ -11,7 +11,7 @@
 module Effect.Comonad where
 
 open import Level
-open import Function
+open import Function.Base using (id; _∘′_; flip)
 
 private
   variable
diff --git a/src/Effect/Functor/Predicate.agda b/src/Effect/Functor/Predicate.agda
index d24938b26a..70704e34c3 100644
--- a/src/Effect/Functor/Predicate.agda
+++ b/src/Effect/Functor/Predicate.agda
@@ -10,7 +10,7 @@
 
 module Effect.Functor.Predicate where
 
-open import Function
+open import Function.Base using (const)
 open import Level
 open import Relation.Unary
 open import Relation.Unary.PredicateTransformer using (PT)
diff --git a/src/Effect/Monad.agda b/src/Effect/Monad.agda
index 57e410bf3d..5979c48b43 100644
--- a/src/Effect/Monad.agda
+++ b/src/Effect/Monad.agda
@@ -16,7 +16,7 @@ open import Data.Unit.Polymorphic.Base using (⊤)
 open import Effect.Choice
 open import Effect.Empty
 open import Effect.Applicative
-open import Function.Base using (flip; _$′_; _∘′_)
+open import Function.Base using (id; flip; _$′_; _∘′_)
 open import Level using (Level; suc; _⊔_)
 
 private
@@ -58,14 +58,23 @@ record RawMonad (F : Set f → Set g) : Set (suc f ⊔ g) where
   unless : Bool → F ⊤ → F ⊤
   unless = when ∘′ not
 
+-- When level g=f, a join/μ operator is definable
+
+module Join {F : Set f → Set f} (M : RawMonad F) where
+  open RawMonad M
+
+  join : F (F A) → F A
+  join = _>>= id
+
 -- Smart constructor
+
 module _ where
 
   open RawMonad
   open RawApplicative
 
   mkRawMonad :
-    (F : Set f → Set f) →
+    (F : Set f → Set g) →
     (pure : ∀ {A} → A → F A) →
     (bind : ∀ {A B} → F A → (A → F B) → F B) →
     RawMonad F
diff --git a/src/Effect/Monad/Continuation.agda b/src/Effect/Monad/Continuation.agda
index bcc66ce265..a5764f8898 100644
--- a/src/Effect/Monad/Continuation.agda
+++ b/src/Effect/Monad/Continuation.agda
@@ -8,13 +8,12 @@
 
 module Effect.Monad.Continuation where
 
-open import Effect.Applicative
-open import Effect.Applicative.Indexed
-open import Effect.Monad
+open import Effect.Applicative.Indexed using (IFun)
+open import Effect.Monad using (RawMonad)
 open import Function.Identity.Effectful as Id using (Identity)
-open import Effect.Monad.Indexed
-open import Function
-open import Level
+open import Effect.Monad.Indexed using (RawIMonad)
+open import Function.Base using (flip)
+open import Level using (Level; _⊔_; suc)
 
 private
   variable
diff --git a/src/Effect/Monad/Error/Transformer.agda b/src/Effect/Monad/Error/Transformer.agda
index d6d5f97626..bb8128ff4e 100644
--- a/src/Effect/Monad/Error/Transformer.agda
+++ b/src/Effect/Monad/Error/Transformer.agda
@@ -6,16 +6,12 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Level
+open import Level using (Level; _⊔_; suc)
 
 module Effect.Monad.Error.Transformer {e} (E : Set e) (a : Level) where
 
-open import Effect.Choice
-open import Effect.Empty
-open import Effect.Functor
-open import Effect.Applicative
-open import Effect.Monad
-open import Function.Base
+open import Effect.Monad using (RawMonad)
+open import Function.Base using (_∘′_; _$_)
 
 private
   variable
@@ -41,7 +37,7 @@ record RawMonadError
 
 module Sumₗ where
 
-  open import Data.Sum using (inj₁; inj₂; [_,_]′)
+  open import Data.Sum.Base using (inj₁; inj₂; [_,_]′)
   open import Data.Sum.Effectful.Left.Transformer E a
 
   monadError : RawMonad M → RawMonadError (SumₗT M)
@@ -54,7 +50,7 @@ module Sumₗ where
 
 module Sumᵣ where
 
-  open import Data.Sum using (inj₁; inj₂; [_,_]′)
+  open import Data.Sum.Base using (inj₁; inj₂; [_,_]′)
   open import Data.Sum.Effectful.Right.Transformer a E
 
   monadError : RawMonad M → RawMonadError (SumᵣT M)
diff --git a/src/Effect/Monad/IO.agda b/src/Effect/Monad/IO.agda
index 8e9e820260..c0f662d6ef 100644
--- a/src/Effect/Monad/IO.agda
+++ b/src/Effect/Monad/IO.agda
@@ -6,15 +6,13 @@
 
 {-# OPTIONS --cubical-compatible --guardedness #-}
 
-open import Level
-
 module Effect.Monad.IO where
 
-open import Data.Product using (_,_)
-open import Function.Base
+open import Data.Product.Base using (_,_)
+open import Effect.Functor using (RawFunctor)
+open import Function.Base using (id)
 open import IO.Base using (IO)
-open import Effect.Functor
-open import Effect.Monad
+open import Level using (Level; suc)
 
 private
   variable
diff --git a/src/Effect/Monad/Identity.agda b/src/Effect/Monad/Identity.agda
index 3cb7bf9f21..e3b9b81069 100644
--- a/src/Effect/Monad/Identity.agda
+++ b/src/Effect/Monad/Identity.agda
@@ -8,16 +8,17 @@
 
 module Effect.Monad.Identity where
 
-open import Effect.Functor
-open import Effect.Applicative
-open import Effect.Monad
-open import Effect.Comonad
+open import Effect.Functor using (RawFunctor)
+open import Effect.Applicative using (RawApplicative)
+open import Effect.Monad using (RawMonad; module Join)
+open import Effect.Comonad using (RawComonad)
 open import Function.Base using (id; _∘′_; _|>′_; _$′_; flip)
-open import Level
+open import Level using (Level)
 
 private
   variable
     a : Level
+    A : Set a
 
 record Identity (A : Set a) : Set a where
   constructor mkIdentity
@@ -47,3 +48,6 @@ comonad = record
   { extract = runIdentity
   ; extend  = λ f a → mkIdentity (f a)
   }
+
+join : Identity (Identity A) → Identity A
+join = Join.join monad
diff --git a/src/Effect/Monad/Partiality.agda b/src/Effect/Monad/Partiality.agda
index 03f82db8bb..d2bf58cac5 100644
--- a/src/Effect/Monad/Partiality.agda
+++ b/src/Effect/Monad/Partiality.agda
@@ -8,23 +8,29 @@
 
 module Effect.Monad.Partiality where
 
-open import Codata.Musical.Notation
-open import Effect.Functor
-open import Effect.Applicative
-open import Effect.Monad
+open import Codata.Musical.Notation using (∞; ♯_; ♭)
 open import Data.Bool.Base using (Bool; false; true)
-open import Data.Nat using (ℕ; zero; suc; _+_)
-open import Data.Product as Prod hiding (map)
+open import Data.Nat.Base using (ℕ; zero; suc; _+_)
+open import Data.Product as Prod using (∃; ∄; -,_; ∃₂; _,_; _×_)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
-open import Function.Base
+open import Effect.Functor using (RawFunctor)
+open import Effect.Applicative using (RawApplicative)
+open import Effect.Monad using (RawMonad; module Join)
+open import Function.Base using (_∘′_; flip; id; _∘_; _$_; _⟨_⟩_)
 open import Function.Bundles using (_⇔_; mk⇔)
 open import Level using (Level; _⊔_)
-open import Relation.Binary as B hiding (Rel; _⇔_)
+open import Relation.Binary.Core as B hiding (Rel; _⇔_)
+open import Relation.Binary.Definitions
+  using (DecidableEquality; Reflexive; Symmetric; Transitive)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsEquivalence)
+open import Relation.Binary.Bundles
+  using (Preorder; Setoid; Poset)
 import Relation.Binary.Properties.Setoid as SetoidProperties
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
-open import Relation.Nullary
-open import Relation.Nullary.Decidable hiding (map)
-open import Relation.Nullary.Negation
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
+open import Relation.Nullary.Decidable using (yes; no; False; Dec; ¬¬-excluded-middle)
+open import Relation.Nullary.Negation using (¬_; ¬¬-Monad)
 
 private
   variable
@@ -65,6 +71,9 @@ monad = record
   ; _>>=_  = bind
   }
 
+join : (A ⊥) ⊥ → A ⊥
+join = Join.join monad
+
 private module M {f} = RawMonad (monad {f})
 
 -- Non-termination.
@@ -106,14 +115,14 @@ data Kind : Set where
 
 infix 4 _≟-Kind_
 
-_≟-Kind_ : Decidable (_≡_ {A = Kind})
-_≟-Kind_ strong       strong       = yes P.refl
+_≟-Kind_ : DecidableEquality Kind
+_≟-Kind_ strong       strong       = yes ≡.refl
 _≟-Kind_ strong       (other k)    = no λ()
 _≟-Kind_ (other k)    strong       = no λ()
-_≟-Kind_ (other geq)  (other geq)  = yes P.refl
+_≟-Kind_ (other geq)  (other geq)  = yes ≡.refl
 _≟-Kind_ (other geq)  (other weak) = no λ()
 _≟-Kind_ (other weak) (other geq)  = no λ()
-_≟-Kind_ (other weak) (other weak) = yes P.refl
+_≟-Kind_ (other weak) (other weak) = yes ≡.refl
 
 -- A predicate which is satisfied only for equalities. Note that, for
 -- concrete inputs, this predicate evaluates to ⊤ or ⊥.
@@ -291,16 +300,16 @@ module _ {A : Set a} {_∼_ : A → A → Set ℓ} where
   preorder pre k = record
     { Carrier    = A ⊥
     ; _≈_        = _≡_
-    ; _∼_        = Rel k
+    ; _≲_        = Rel k
     ; isPreorder = record
-      { isEquivalence = P.isEquivalence
+      { isEquivalence = ≡.isEquivalence
       ; reflexive     = refl′
       ; trans         = Equivalence.trans (IsPreorder.trans pre)
       }
     }
     where
     refl′ : ∀ {k} {x y : A ⊥} → x ≡ y → Rel k x y
-    refl′ P.refl = Equivalence.refl (IsPreorder.refl pre)
+    refl′ ≡.refl = Equivalence.refl (IsPreorder.refl pre)
 
   private
     preorder′ : IsEquivalence _∼_ → Kind → Preorder _ _ _
@@ -361,7 +370,7 @@ module _ {A : Set a} {_∼_ : A → A → Set ℓ} where
     infixr 2 _≡⟨_⟩_ _≅⟨_⟩_ _≳⟨_⟩_ _≈⟨_⟩_
 
     _≡⟨_⟩_ : ∀ {k} x {y z : A ⊥} → x ≡ y → Rel k y z → Rel k x z
-    _ ≡⟨ P.refl ⟩ y∼z = y∼z
+    _ ≡⟨ ≡.refl ⟩ y∼z = y∼z
 
     _≅⟨_⟩_ : ∀ {k} x {y z : A ⊥} → x ≅ y → Rel k y z → Rel k x z
     _ ≅⟨ x≅y ⟩ y∼z = Pre.trans (≅⇒ x≅y) y∼z
@@ -394,7 +403,7 @@ module _ {A : Set a} {_∼_ : A → A → Set ℓ} where
   now-or-never : Reflexive _∼_ →
                  ∀ {k} (x : A ⊥) →
                  ¬ ¬ ((∃ λ y → x ⇓[ other k ] y) ⊎ x ⇑[ other k ])
-  now-or-never refl x = helper <$> excluded-middle
+  now-or-never refl x = helper <$> ¬¬-excluded-middle
     where
     open RawMonad ¬¬-Monad
 
@@ -426,7 +435,7 @@ module _ {A : Set a} {_∼_ : A → A → Set ℓ} where
 
   ≡⇒ : Reflexive _∼_ →
        ∀ {k x y} → Equality.Rel _≡_ k x y → Rel k x y
-  ≡⇒ refl-∼ = map (flip (P.subst (_∼_ _)) refl-∼)
+  ≡⇒ refl-∼ = map (flip (≡.subst (_∼_ _)) refl-∼)
 
 ------------------------------------------------------------------------
 -- Steps
@@ -444,17 +453,17 @@ module _ {A : Set a} {_∼_ : A → A → Set ℓ} where
       ∀ {k x y} {z : A}
       (x≅y : x ≅ y) (y⇓z : y ⇓[ k ] z) →
       steps (Equivalence.trans trans-∼ (≅⇒ x≅y) y⇓z) ≡ steps y⇓z
-    left-identity (now _)     (now _)      = P.refl
+    left-identity (now _)     (now _)      = ≡.refl
     left-identity (later x≅y) (laterˡ y⇓z) =
-      P.cong suc $ left-identity (♭ x≅y) y⇓z
+      ≡.cong suc $ left-identity (♭ x≅y) y⇓z
 
     right-identity :
       ∀ {k x} {y z : A}
       (x⇓y : x ⇓[ k ] y) (y≈z : now y ⇓[ k ] z) →
       steps (Equivalence.trans trans-∼ x⇓y y≈z) ≡ steps x⇓y
-    right-identity (now x∼y)    (now y∼z) = P.refl
+    right-identity (now x∼y)    (now y∼z) = ≡.refl
     right-identity (laterˡ x∼y) (now y∼z) =
-      P.cong suc $ right-identity x∼y (now y∼z)
+      ≡.cong suc $ right-identity x∼y (now y∼z)
 
 ------------------------------------------------------------------------
 -- Laws related to bind
@@ -507,6 +516,8 @@ module _ {A B : Set s}
 
   -- Bind preserves all the relations.
 
+  infixl 1 _>>=-cong_
+
   _>>=-cong_ :
     ∀ {k} {x₁ x₂ : A ⊥} {f₁ f₂ : A → B ⊥} → let open M in
     Rel _∼A_ k x₁ x₂ →
@@ -526,9 +537,9 @@ module _ {A B : Set s}
     ∃ λ z → ∃₂ λ (x⇓ : x ⇓[ k ]A z) (fz⇓ : f z ⇓[ k ]B y) →
                  steps x⇓ + steps fz⇓ ≡ steps x>>=f⇓
   >>=-inversion-⇓ refl (now x) fx⇓ =
-    (x , now refl , fx⇓ , P.refl)
+    (x , now refl , fx⇓ , ≡.refl)
   >>=-inversion-⇓ refl (later x) (laterˡ x>>=f⇓) =
-    Prod.map id (Prod.map laterˡ (Prod.map id (P.cong suc))) $
+    Prod.map id (Prod.map laterˡ (Prod.map id (≡.cong suc))) $
       >>=-inversion-⇓ refl (♭ x) x>>=f⇓
 
   >>=-inversion-⇑ : IsEquivalence _∼A_ →
@@ -568,6 +579,8 @@ module _ {A B : Set ℓ} {_∼_ : B → B → Set ℓ} where
 
   -- A variant of _>>=-cong_.
 
+  infixl 1 _≡->>=-cong_
+
   _≡->>=-cong_ :
     ∀ {k} {x₁ x₂ : A ⊥} {f₁ f₂ : A → B ⊥} → let open M in
     Rel _≡_ k x₁ x₂ →
@@ -575,7 +588,7 @@ module _ {A B : Set ℓ} {_∼_ : B → B → Set ℓ} where
     Rel _∼_ k (x₁ >>= f₁) (x₂ >>= f₂)
   _≡->>=-cong_ {k} {f₁ = f₁} {f₂} x₁≈x₂ f₁≈f₂ =
     x₁≈x₂ >>=-cong λ {x} x≡x′ →
-    P.subst (λ y → Rel _∼_ k (f₁ x) (f₂ y)) x≡x′ (f₁≈f₂ x)
+    ≡.subst (λ y → Rel _∼_ k (f₁ x) (f₂ y)) x≡x′ (f₁≈f₂ x)
 
 ------------------------------------------------------------------------
 -- Productivity checker workaround
@@ -627,7 +640,7 @@ module Workaround {a} where
 
     private
       open module Eq {A : Set a} = Equality  {A = A} _≡_
-      open module R  {A : Set a} = Reasoning (P.isEquivalence {A = A})
+      open module R  {A : Set a} = Reasoning (≡.isEquivalence {A = A})
 
     now-hom : (x : A) → ⟦ now x ⟧P ≅ now x
     now-hom x = now x ∎
@@ -806,7 +819,7 @@ module AlternativeEquality {a ℓ} where
     whnf≅ (x₁≅x₂ >>= f₁≅f₂)   = whnf≅ x₁≅x₂ >>=W λ xRy → whnf≅ (f₁≅f₂ xRy)
     whnf≅ (x ∎)               = reflW x
     whnf≅ (sym x≅y)           = symW _ (whnf≅ x≅y)
-    whnf≅ (x ≡⟨ P.refl ⟩ y≅z) = whnf≅ y≅z
+    whnf≅ (x ≡⟨ ≡.refl ⟩ y≅z) = whnf≅ y≅z
     whnf≅ (x ≅⟨ x≅y    ⟩ y≅z) = trans≅W (whnf≅ x≅y) (whnf≅ y≅z)
 
     -- More transitivity lemmas.
@@ -839,7 +852,7 @@ module AlternativeEquality {a ℓ} where
     whnf≳ (laterˡ x≲y)         = laterˡ (whnf≳ x≲y)
     whnf≳ (x₁∼x₂ >>= f₁∼f₂)    = whnf≳ x₁∼x₂ >>=W λ xRy → whnf≳ (f₁∼f₂ xRy)
     whnf≳ (x ∎)                = reflW x
-    whnf≳ (x ≡⟨ P.refl ⟩  y≳z) = whnf≳ y≳z
+    whnf≳ (x ≡⟨ ≡.refl ⟩  y≳z) = whnf≳ y≳z
     whnf≳ (x ≅⟨ x≅y    ⟩  y≳z) = trans≅∼W (whnf≅ x≅y) (whnf≳ y≳z)
     whnf≳ (x ≳⟨ x≳y    ⟩  y≳z) = trans≳-W        x≳y  (whnf≳ y≳z)
     whnf≳ (x ≳⟨ x≳y    ⟩≅ y≅z) = trans∼≅W (whnf≳ x≳y) (whnf≅ y≅z)
@@ -865,7 +878,7 @@ module AlternativeEquality {a ℓ} where
     whnf (x₁∼x₂ >>= f₁∼f₂)    = whnf x₁∼x₂ >>=W λ xRy → whnf (f₁∼f₂ xRy)
     whnf (x ∎)                = reflW x
     whnf (sym {eq = eq} x≈y)  = symW eq (whnf x≈y)
-    whnf (x ≡⟨ P.refl ⟩  y∼z) = whnf y∼z
+    whnf (x ≡⟨ ≡.refl ⟩  y∼z) = whnf y∼z
     whnf (x ≅⟨ x≅y    ⟩  y∼z) = trans≅∼W (whnf x≅y) (whnf y∼z)
     whnf (x ≳⟨ x≳y    ⟩  y≳z) = trans≳-W       x≳y  (whnf y≳z)
     whnf (x ≳⟨ x≳y    ⟩≅ y≅z) = trans∼≅W (whnf x≳y) (whnf y≅z)
@@ -916,26 +929,7 @@ idempotent {A = A} B x f = sound (idem x)
              (x >>= λ y′ → f y′ y′)
   idem (now   x) = f x x ∎
   idem (later x) = later (♯ (
-    (♭ x >>= λ y′ → later x >>= λ y″ → f y′ y″)  ≳⟨ (refl P.refl {x = ♭ x} ≡->>=-cong λ _ →
+    (♭ x >>= λ y′ → later x >>= λ y″ → f y′ y″)  ≳⟨ (refl ≡.refl {x = ♭ x} ≡->>=-cong λ _ →
                                                      laterˡ (refl (Setoid.refl B))) ⟩
     (♭ x >>= λ y′ →     ♭ x >>= λ y″ → f y′ y″)  ≳⟨ idem (♭ x) ⟩≅
     (♭ x >>= λ y′ → f y′ y′)                     ∎))
-
-------------------------------------------------------------------------
--- Example
-
-private
- module Example where
-
-  open Data.Nat
-  open Workaround
-
-  -- McCarthy's f91:
-
-  f91′ : ℕ → ℕ ⊥P
-  f91′ n with does (n ≤? 100)
-  ... | true  = later (♯ (f91′ (11 + n) >>= f91′))
-  ... | false = now (n ∸ 10)
-
-  f91 : ℕ → ℕ ⊥
-  f91 n = ⟦ f91′ n ⟧P
diff --git a/src/Effect/Monad/Partiality/All.agda b/src/Effect/Monad/Partiality/All.agda
index 9bc5d4bc7e..6f7b30ef41 100644
--- a/src/Effect/Monad/Partiality/All.agda
+++ b/src/Effect/Monad/Partiality/All.agda
@@ -11,10 +11,11 @@ module Effect.Monad.Partiality.All where
 open import Effect.Monad
 open import Effect.Monad.Partiality as Partiality using (_⊥; ⇒≈)
 open import Codata.Musical.Notation
-open import Function
+open import Function.Base using (flip; _∘_)
 open import Level
-open import Relation.Binary using (_Respects_; IsEquivalence)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Definitions using (_Respects_)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 open Partiality._⊥
 open Partiality.Equality using (Rel)
@@ -43,6 +44,8 @@ data All {A : Set a} (P : A → Set p) : A ⊥ → Set (a ⊔ p) where
 
 -- Bind preserves All in the following way:
 
+infixl 1 _>>=-cong_
+
 _>>=-cong_ : ∀ {p q} {P : A → Set p} {Q : B → Set q}
                {x : A ⊥} {f : A → B ⊥} →
              All P x → (∀ {x} → P x → All Q (f x)) →
@@ -79,7 +82,7 @@ module Reasoning {P : A → Set p}
   infixr 2 _≡⟨_⟩_ _∼⟨_⟩_
 
   _≡⟨_⟩_ : ∀ x {y} → x ≡ y → All P y → All P x
-  _ ≡⟨ P.refl ⟩ p = p
+  _ ≡⟨ ≡.refl ⟩ p = p
 
   _∼⟨_⟩_ : ∀ {k} x {y} → Rel _∼_ k x y → All P y → All P x
   _ ∼⟨ x∼y ⟩ p = respects-flip resp (⇒≈ x∼y) p
@@ -95,7 +98,7 @@ module Reasoning {P : A → Set p}
 -- equality.
 
 module Reasoning-≡ {a p} {A : Set a} {P : A → Set p}
-  = Reasoning {P = P} {_∼_ = _≡_} (P.subst P ∘ P.sym)
+  = Reasoning {P = P} {_∼_ = _≡_} (≡.subst P ∘ ≡.sym)
 
 ------------------------------------------------------------------------
 -- An alternative, but equivalent, formulation of All
@@ -117,6 +120,8 @@ module Alternative {a p : Level} where
     _≳⟨_⟩P_     : ∀ x {y} (x≳y : x ≳ y) (p : AllP P y) → AllP P x
     _⟨_⟩P       : ∀ x (p : AllP P x) → AllP P x
 
+  infixl 1 _>>=-congP_
+
   private
 
     -- WHNFs.
@@ -135,12 +140,12 @@ module Alternative {a p : Level} where
 
     trans-≅ : {P : A → Set p} {x y : A ⊥} →
               x ≅ y → AllW P y → AllW P x
-    trans-≅ (now P.refl) (now   p) = now p
+    trans-≅ (now ≡.refl) (now   p) = now p
     trans-≅ (later  x≅y) (later p) = later (_ ≅⟨ ♭ x≅y ⟩P p)
 
     trans-≳ : {P : A → Set p} {x y : A ⊥} →
               x ≳ y → AllW P y → AllW P x
-    trans-≳ (now P.refl) (now   p) = now p
+    trans-≳ (now ≡.refl) (now   p) = now p
     trans-≳ (later  x≳y) (later p) = later (_ ≳⟨ ♭ x≳y ⟩P p)
     trans-≳ (laterˡ x≳y)        p  = later (_ ≳⟨   x≳y ⟩P program p)
 
diff --git a/src/Effect/Monad/Predicate.agda b/src/Effect/Monad/Predicate.agda
index 5593b202d8..cd97826c33 100644
--- a/src/Effect/Monad/Predicate.agda
+++ b/src/Effect/Monad/Predicate.agda
@@ -10,15 +10,12 @@
 
 module Effect.Monad.Predicate where
 
-open import Effect.Applicative.Indexed
-open import Effect.Monad
-open import Effect.Monad.Indexed
-open import Data.Unit
-open import Data.Product
-open import Function
-open import Level
-open import Relation.Binary.PropositionalEquality
-open import Relation.Unary
+open import Data.Product.Base using (_,_)
+open import Effect.Monad.Indexed using (RawIMonad)
+open import Function.Base using (const; id; _∘_)
+open import Level using (Level; _⊔_; suc)
+open import Relation.Binary.PropositionalEquality.Core using (refl)
+open import Relation.Unary using (_⊆_; _⇒_; _∈_; _∩_; ｛_｝)
 open import Relation.Unary.PredicateTransformer using (Pt)
 
 private
@@ -27,9 +24,9 @@ private
 
 ------------------------------------------------------------------------
 
-record RawPMonad {I : Set i} (M : Pt I (i ⊔ ℓ)) : Set (suc i ⊔ suc ℓ) where
+record RawPMonad {I : Set i} (M : Pt I (i ⊔ ℓ)) : Set (suc (i ⊔ ℓ)) where
 
-  infixl 1 _?>=_ _?>_ _>?>_
+  infixl 1 _?>=_ _?>_ _>?>_ _?>=′_
   infixr 1 _=<?_ _<?<_
 
   -- ``Demonic'' operations (the opponent chooses the state).
diff --git a/src/Effect/Monad/Reader.agda b/src/Effect/Monad/Reader.agda
index 79267a5ab2..e4ef78da0d 100644
--- a/src/Effect/Monad/Reader.agda
+++ b/src/Effect/Monad/Reader.agda
@@ -6,15 +6,11 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Level
-
 module Effect.Monad.Reader where
 
-open import Effect.Choice
-open import Effect.Empty
-open import Effect.Functor
-open import Effect.Applicative
-open import Effect.Monad
+open import Effect.Functor using (RawFunctor)
+open import Effect.Applicative using (RawApplicative)
+open import Effect.Monad using (RawMonad; module Join)
 open import Effect.Monad.Identity as Id using (Identity; runIdentity)
 open import Level using (Level)
 
@@ -52,6 +48,9 @@ applicative = Trans.applicative Id.applicative
 monad : RawMonad (Reader R)
 monad = Trans.monad Id.monad
 
+join : Reader R (Reader R A) → Reader R A
+join = Join.join monad
+
 ------------------------------------------------------------------------
 -- Reader monad specifics
 
diff --git a/src/Effect/Monad/Reader/Indexed.agda b/src/Effect/Monad/Reader/Indexed.agda
index 2260b07e09..0c787abcc9 100644
--- a/src/Effect/Monad/Reader/Indexed.agda
+++ b/src/Effect/Monad/Reader/Indexed.agda
@@ -6,16 +6,16 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Level
+open import Level using (Level; _⊔_; suc; Lift; lift)
 
 module Effect.Monad.Reader.Indexed {r} (R : Set r) (a : Level) where
 
-open import Function
+open import Function.Base using (const; flip; _∘_)
 open import Function.Identity.Effectful as Id using (Identity)
 open import Effect.Applicative.Indexed
-open import Effect.Monad.Indexed
-open import Effect.Monad
-open import Data.Unit
+  using (IFun; RawIApplicative; RawIApplicativeZero; RawIAlternative)
+open import Effect.Monad.Indexed using (RawIMonad; RawIMonadZero;
+  RawIMonadPlus)
 
 private
   variable
@@ -30,7 +30,7 @@ IReaderT M i j A = R → M i j A
 
 module _ {M : IFun I (r ⊔ a)} where
 
-  ------------------------------------------------------------------------
+  ----------------------------------------------------------------------
   -- Indexed reader applicative
 
   ReaderTIApplicative : RawIApplicative M → RawIApplicative (IReaderT M)
@@ -52,7 +52,7 @@ module _ {M : IFun I (r ⊔ a)} where
     ; _∣_ = λ m n r → m r ∣ n r
     } where open RawIAlternative Alt
 
-  ------------------------------------------------------------------------
+  ----------------------------------------------------------------------
   -- Indexed reader monad
 
   ReaderTIMonad : RawIMonad M → RawIMonad (IReaderT M)
diff --git a/src/Effect/Monad/Reader/Transformer.agda b/src/Effect/Monad/Reader/Transformer.agda
index 96f95ecae4..e13e3f4df1 100644
--- a/src/Effect/Monad/Reader/Transformer.agda
+++ b/src/Effect/Monad/Reader/Transformer.agda
@@ -10,11 +10,11 @@
 module Effect.Monad.Reader.Transformer where
 
 open import Algebra using (RawMonoid)
-open import Effect.Choice
-open import Effect.Empty
-open import Effect.Functor
-open import Effect.Applicative
-open import Effect.Monad
+open import Effect.Choice using (RawChoice)
+open import Effect.Empty using (RawEmpty)
+open import Effect.Functor using (RawFunctor)
+open import Effect.Applicative using (RawApplicative; RawApplicativeZero; RawAlternative)
+open import Effect.Monad using (RawMonad; RawMonadZero; RawMonadPlus; RawMonadT)
 open import Function.Base using (_∘′_; const; _$_)
 open import Level using (Level; _⊔_)
 
@@ -116,7 +116,7 @@ liftReaderT MRead = record
   ; local = λ f mx → mkReaderT (λ r₂ → local f (runReaderT mx r₂))
   } where open RawMonadReader MRead
 
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Effect.Monad.Writer.Transformer.Base
 
 liftWriterT : (MR : RawMonoid r g) →
diff --git a/src/Effect/Monad/State.agda b/src/Effect/Monad/State.agda
index 222f6e7f48..4af0b026c1 100644
--- a/src/Effect/Monad/State.agda
+++ b/src/Effect/Monad/State.agda
@@ -6,18 +6,14 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-
 module Effect.Monad.State where
 
-open import Data.Product
-open import Effect.Choice
-open import Effect.Empty
-open import Effect.Functor
-open import Effect.Applicative
-open import Effect.Monad
+open import Data.Product.Base using (_×_)
+open import Effect.Functor using (RawFunctor)
+open import Effect.Applicative using (RawApplicative)
+open import Effect.Monad using (RawMonad; module Join)
 open import Effect.Monad.Identity as Id using (Identity; runIdentity)
-open import Function.Base
-open import Level
+open import Level using (Level)
 
 import Effect.Monad.State.Transformer as Trans
 
@@ -59,6 +55,9 @@ applicative = Trans.applicative Id.monad
 monad : RawMonad (State S)
 monad = Trans.monad Id.monad
 
+join : State S (State S A) → State S A
+join = Join.join monad
+
 ------------------------------------------------------------------------
 -- State monad specifics
 
diff --git a/src/Effect/Monad/State/Indexed.agda b/src/Effect/Monad/State/Indexed.agda
index 1fc27655d8..e8345c363b 100644
--- a/src/Effect/Monad/State/Indexed.agda
+++ b/src/Effect/Monad/State/Indexed.agda
@@ -9,13 +9,15 @@
 module Effect.Monad.State.Indexed where
 
 open import Effect.Applicative.Indexed
-open import Effect.Monad
+  using (IFun; RawIApplicative; RawIApplicativeZero; RawIAlternative)
+open import Effect.Monad using (RawMonad; RawMonadZero; RawMonadPlus)
 open import Function.Identity.Effectful as Id using (Identity)
-open import Effect.Monad.Indexed
-open import Data.Product
-open import Data.Unit
-open import Function.Base
-open import Level
+open import Effect.Monad.Indexed using (RawIMonad; RawIMonadZero;
+  RawIMonadPlus)
+open import Data.Product.Base using (_×_; _,_; uncurry)
+open import Data.Unit.Polymorphic using (⊤)
+open import Function.Base using (const; _∘_)
+open import Level using (Level; _⊔_; suc)
 
 private
   variable
@@ -86,11 +88,11 @@ record RawIMonadState {I : Set i} (S : I → Set f)
   field
     monad : RawIMonad M
     get   : ∀ {i} → M i i (S i)
-    put   : ∀ {i j} → S j → M i j (Lift f ⊤)
+    put   : ∀ {i j} → S j → M i j ⊤
 
   open RawIMonad monad public
 
-  modify : ∀ {i j} → (S i → S j) → M i j (Lift f ⊤)
+  modify : ∀ {i j} → (S i → S j) → M i j ⊤
   modify f = get >>= put ∘ f
 
 StateTIMonadState : ∀ {i f} {I : Set i} (S : I → Set f) {M} →
diff --git a/src/Effect/Monad/State/Transformer.agda b/src/Effect/Monad/State/Transformer.agda
index 7271117eec..3a2f272f34 100644
--- a/src/Effect/Monad/State/Transformer.agda
+++ b/src/Effect/Monad/State/Transformer.agda
@@ -6,21 +6,20 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Level using (Level; suc; _⊔_)
 
 module Effect.Monad.State.Transformer where
 
 open import Algebra using (RawMonoid)
-open import Data.Product using (_×_; _,_; map₂; proj₁; proj₂)
-open import Data.Unit.Polymorphic.Base
-open import Effect.Choice
-open import Effect.Empty
-open import Effect.Functor
-open import Effect.Applicative
-open import Effect.Monad
-open import Function.Base
-
-open import Effect.Monad.Reader.Transformer using (RawMonadReader)
+open import Data.Product.Base using (_×_; _,_; map₂; proj₁; proj₂)
+open import Data.Unit.Polymorphic.Base using (tt)
+open import Effect.Choice using (RawChoice)
+open import Effect.Empty using (RawEmpty)
+open import Effect.Functor using (RawFunctor)
+open import Effect.Applicative using (RawApplicative; RawApplicativeZero; RawAlternative)
+open import Effect.Monad using (RawMonad; RawMonadZero; RawMonadPlus; RawMonadT; RawMonadTd)
+open import Function.Base using (_∘′_; _$_; const)
+open import Level using (Level; _⊔_)
+
 
 private
   variable
diff --git a/src/Effect/Monad/State/Transformer/Base.agda b/src/Effect/Monad/State/Transformer/Base.agda
index 0680a2207b..3b5d60fd6e 100644
--- a/src/Effect/Monad/State/Transformer/Base.agda
+++ b/src/Effect/Monad/State/Transformer/Base.agda
@@ -9,7 +9,7 @@
 
 module Effect.Monad.State.Transformer.Base where
 
-open import Data.Product using (_×_; proj₁; proj₂)
+open import Data.Product.Base using (_×_; proj₁; proj₂)
 open import Data.Unit.Polymorphic.Base using (⊤)
 open import Function.Base using (_∘′_; const; id)
 open import Level using (Level; suc; _⊔_)
diff --git a/src/Effect/Monad/Writer.agda b/src/Effect/Monad/Writer.agda
index 43f21deaa9..92fbad4086 100644
--- a/src/Effect/Monad/Writer.agda
+++ b/src/Effect/Monad/Writer.agda
@@ -9,14 +9,11 @@
 module Effect.Monad.Writer where
 
 open import Algebra using (RawMonoid)
-open import Data.Product using (_×_)
-open import Effect.Applicative
-open import Effect.Choice
-open import Effect.Empty
-open import Effect.Functor
-open import Effect.Monad
+open import Data.Product.Base using (_×_)
+open import Effect.Applicative using (RawApplicative)
+open import Effect.Functor using (RawFunctor)
+open import Effect.Monad using (RawMonad; module Join)
 open import Effect.Monad.Identity as Id using (Identity; runIdentity)
-open import Function.Base using (_∘′_)
 open import Level using (Level)
 
 import Effect.Monad.Writer.Transformer as Trans
@@ -55,6 +52,9 @@ module _ {𝕎 : RawMonoid w ℓ} where
   monad : RawMonad (Writer 𝕎)
   monad = Trans.monad Id.monad
 
+  join : Writer 𝕎 (Writer 𝕎 A) → Writer 𝕎 A
+  join = Join.join monad
+
   ----------------------------------------------------------------------
   -- Writer monad specifics
 
diff --git a/src/Effect/Monad/Writer/Indexed.agda b/src/Effect/Monad/Writer/Indexed.agda
index 9720e72b3c..d0fb68a967 100644
--- a/src/Effect/Monad/Writer/Indexed.agda
+++ b/src/Effect/Monad/Writer/Indexed.agda
@@ -11,12 +11,12 @@ open import Level
 module Effect.Monad.Writer.Indexed (a : Level) where
 
 open import Algebra using (RawMonoid)
-open import Data.Product using (_×_; _,_; map₁)
+open import Data.Product.Base using (_×_; _,_; map₁)
 open import Data.Unit.Polymorphic
 open import Effect.Applicative.Indexed
 open import Effect.Monad
 open import Effect.Monad.Indexed
-open import Function
+open import Function.Base using (_∘′_)
 open import Function.Identity.Effectful as Id using (Identity)
 
 private
@@ -34,7 +34,7 @@ module _ {M : IFun I (w ⊔ a)} {𝕎 : RawMonoid w ℓ} where
 
   open RawMonoid 𝕎 renaming (Carrier to W)
 
-  ------------------------------------------------------------------------
+  ----------------------------------------------------------------------
   -- Indexed writer applicative
 
   WriterTIApplicative : RawIApplicative M → RawIApplicative (IWriterT 𝕎 M)
@@ -59,7 +59,7 @@ module _ {M : IFun I (w ⊔ a)} {𝕎 : RawMonoid w ℓ} where
     ; _∣_ = _∣_
     } where open RawIAlternative Alt
 
-  ------------------------------------------------------------------------
+  ----------------------------------------------------------------------
   -- Indexed writer monad
 
   WriterTIMonad : RawIMonad M → RawIMonad (IWriterT 𝕎 M)
diff --git a/src/Effect/Monad/Writer/Transformer.agda b/src/Effect/Monad/Writer/Transformer.agda
index f239c08940..46f1e20776 100644
--- a/src/Effect/Monad/Writer/Transformer.agda
+++ b/src/Effect/Monad/Writer/Transformer.agda
@@ -10,14 +10,14 @@
 module Effect.Monad.Writer.Transformer where
 
 open import Algebra using (RawMonoid)
-open import Data.Product using (_×_; _,_; proj₂; map₂)
-open import Effect.Applicative
-open import Effect.Choice
-open import Effect.Empty
-open import Effect.Functor
-open import Effect.Monad
+open import Data.Product.Base using (_×_; _,_; proj₂; map₂)
+open import Effect.Applicative using (RawApplicative; RawApplicativeZero; RawAlternative)
+open import Effect.Choice using (RawChoice)
+open import Effect.Empty using (RawEmpty)
+open import Effect.Functor using (RawFunctor)
+open import Effect.Monad using (RawMonad; RawMonadZero; RawMonadPlus; RawMonadT)
 open import Function.Base using (_∘′_; const; _$_)
-open import Level using (Level; _⊔_; suc)
+open import Level using (Level)
 
 private
   variable
diff --git a/src/Effect/Monad/Writer/Transformer/Base.agda b/src/Effect/Monad/Writer/Transformer/Base.agda
index bf3c254fc3..4f910b101d 100644
--- a/src/Effect/Monad/Writer/Transformer/Base.agda
+++ b/src/Effect/Monad/Writer/Transformer/Base.agda
@@ -9,7 +9,7 @@
 module Effect.Monad.Writer.Transformer.Base where
 
 open import Algebra using (RawMonoid)
-open import Data.Product using (_×_; _,_; proj₁; proj₂)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂)
 open import Data.Unit.Polymorphic using (⊤; tt)
 open import Function.Base using (id; _∘′_)
 open import Level using (Level; suc; _⊔_)
diff --git a/src/Foreign/Haskell/Coerce.agda b/src/Foreign/Haskell/Coerce.agda
index 6e98f5426c..4383a1ac86 100644
--- a/src/Foreign/Haskell/Coerce.agda
+++ b/src/Foreign/Haskell/Coerce.agda
@@ -35,11 +35,11 @@ open import Level using (Level; _⊔_)
 open import Agda.Builtin.Nat
 open import Agda.Builtin.Int
 
-import IO.Primitive            as STD
+import IO.Primitive.Core       as STD
 import Data.List.Base          as STD
 import Data.List.NonEmpty.Base as STD
 import Data.Maybe.Base         as STD
-import Data.Product            as STD
+import Data.Product.Base       as STD
 import Data.Sum.Base           as STD
 
 import Foreign.Haskell.Pair          as FFI
@@ -54,16 +54,17 @@ private
     C : Set c
     D : Set d
 
--- We define a simple indexed datatype `Coercible`. A value of `Coercible A B`
--- is a proof that ̀A` and `B` have the same underlying runtime representation.
--- The only possible proof is an incantation from the implementer begging to
--- be trusted.
+-- We define a simple indexed datatype `Coercible`. A value of
+-- `Coercible A B` is a proof that `A` and `B` have the same underlying
+-- runtime representation. The only possible proof is an incantation
+-- from the implementer begging to be trusted.
 
--- We need this type to be concrete so that overlapping instances can be checked
--- for equality: we do not care what proof we get as long as we get one.
+-- We need this type to be concrete so that overlapping instances can be
+-- checked for equality: we do not care what proof we get as long as we
+-- get one.
 
--- We need for it to be a data type rather than a record type so that Agda does
--- not mistakenly build arbitrary instances by η-expansion.
+-- We need for it to be a data type rather than a record type so that
+-- Agda does not mistakenly build arbitrary instances by η-expansion.
 
 data Coercible (A : Set a) (B : Set b) : Set where
   TrustMe : Coercible A B
@@ -71,9 +72,9 @@ data Coercible (A : Set a) (B : Set b) : Set where
 {-# FOREIGN GHC data AgdaCoercible l1 l2 a b = TrustMe #-}
 {-# COMPILE GHC Coercible = data AgdaCoercible (TrustMe) #-}
 
--- Once we get our hands on a proof that `Coercible A B` we postulate that it
--- is safe to convert an `A` into a `B`. This is done under the hood by using
--- `unsafeCoerce`.
+-- Once we get our hands on a proof that `Coercible A B` we postulate
+-- that it is safe to convert an `A` into a `B`. This is done under the
+-- hood by using `unsafeCoerce`.
 
 postulate coerce : {{_ : Coercible A B}} → A → B
 
@@ -95,9 +96,9 @@ Coercible₂ _ _ _ _ T U = ∀ {A B} → {{_ : Coercible A B}} → Coercible₁
 -- Nat
 
 -- Our first instance reveals one of Agda's secrets: natural numbers are
--- represented by (arbitrary precision) integers at runtime! Note that we
--- may only coerce in one direction: arbitrary integers may actually be
--- negative and will not do as mere natural numbers.
+-- represented by (arbitrary precision) integers at runtime! Note that
+-- we may only coerce in one direction: arbitrary integers may actually
+-- be negative and will not do as mere natural numbers.
 
 instance
 
@@ -132,8 +133,8 @@ instance
   nonEmpty-fromFFI : Coercible₁ a b FFI.NonEmpty STD.List⁺
   nonEmpty-fromFFI = TrustMe
 
--- We follow up with purely structural rules for builtin data types which
--- already have known low-level representations.
+-- We follow up with purely structural rules for builtin data types
+-- which already have known low-level representations.
 
 -- Maybe
 
@@ -156,14 +157,15 @@ instance
   coerce-fun : {{_ : Coercible A B}} → Coercible₁ c d (λ C → B → C) (λ D → A → D)
   coerce-fun = TrustMe
 
--- Finally we add a reflexivity proof to discharge all the dangling constraints
--- involving type variables and concrete builtin types such as `Bool`.
+-- Finally we add a reflexivity proof to discharge all the dangling
+-- constraints involving type variables and concrete builtin types such
+-- as `Bool`.
 
--- This rule overlaps with the purely structural ones: when attempting to prove
--- `Coercible (List A) (List A)`, should Agda use the proof obtained by `coerce-refl`
--- or the one obtained by `coerce-list coerce-refl`? Because we are using a
--- datatype with a single constructor these distinctions do not matter: both proofs
--- are definitionally equal.
+-- This rule overlaps with the purely structural ones: when attempting
+-- to prove `Coercible (List A) (List A)`, should Agda use the proof
+-- obtained by `coerce-refl` or the one obtained by `coerce-list coerce-refl`?
+-- Because we are using a datatype with a single constructor these
+-- distinctions do not matter: both proofs are definitionally equal.
 
   coerce-refl : Coercible A A
   coerce-refl = TrustMe
diff --git a/src/Foreign/Haskell/List/NonEmpty.agda b/src/Foreign/Haskell/List/NonEmpty.agda
index a36a1fc415..93e01e561f 100644
--- a/src/Foreign/Haskell/List/NonEmpty.agda
+++ b/src/Foreign/Haskell/List/NonEmpty.agda
@@ -25,5 +25,7 @@ private
 data NonEmpty (A : Set a) : Set a where
   _∷_ : A → List A → NonEmpty A
 
+infixr 5 _∷_
+
 {-# FOREIGN GHC type AgdaNonEmpty l a = NE.NonEmpty a #-}
 {-# COMPILE GHC NonEmpty = data AgdaNonEmpty ((NE.:|)) #-}
diff --git a/src/Foreign/Haskell/Pair.agda b/src/Foreign/Haskell/Pair.agda
index 1f10b05169..3487497204 100644
--- a/src/Foreign/Haskell/Pair.agda
+++ b/src/Foreign/Haskell/Pair.agda
@@ -9,7 +9,7 @@
 module Foreign.Haskell.Pair where
 
 open import Level
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 
 private
   variable
@@ -24,6 +24,7 @@ record Pair (A : Set a) (B : Set b) : Set (a ⊔ b) where
   constructor _,_
   field  fst : A
          snd : B
+infixr 4 _,_
 open Pair public
 
 {-# FOREIGN GHC type AgdaPair l1 l2 a b = (a , b) #-}
diff --git a/src/Function.agda b/src/Function.agda
index 1d45b05901..b4155ef8ef 100644
--- a/src/Function.agda
+++ b/src/Function.agda
@@ -13,4 +13,5 @@ open import Function.Base public
 open import Function.Strict public
 open import Function.Definitions public
 open import Function.Structures public
+open import Function.Structures.Biased public
 open import Function.Bundles public
diff --git a/src/Function/Base.agda b/src/Function/Base.agda
index 69ab60bed0..122e276469 100644
--- a/src/Function/Base.agda
+++ b/src/Function/Base.agda
@@ -72,7 +72,7 @@ flip f = λ y x → f x y
 
 -- Application - note that _$_ is right associative, as in Haskell.
 -- If you want a left associative infix application operator, use
--- Category.Functor._<$>_ from Category.Monad.Identity.IdentityMonad.
+-- RawFunctor._<$>_ from Effect.Functor.
 
 _$_ : ∀ {A : Set a} {B : A → Set b} →
       ((x : A) → B x) → ((x : A) → B x)
@@ -110,10 +110,10 @@ f $- = f _
 -- Case expressions (to be used with pattern-matching lambdas, see
 -- README.Case).
 
-case_return_of_ : ∀ {A : Set a} (x : A) (B : A → Set b) →
+case_returning_of_ : ∀ {A : Set a} (x : A) (B : A → Set b) →
                   ((x : A) → B x) → B x
-case x return B of f = f x
-{-# INLINE case_return_of_ #-}
+case x returning B of f = f x
+{-# INLINE case_returning_of_ #-}
 
 ------------------------------------------------------------------------
 -- Non-dependent versions of dependent operations
@@ -156,7 +156,7 @@ _|>′_ = _|>_
 -- README.Case).
 
 case_of_ : A → (A → B) → B
-case x of f = case x return _ of f
+case x of f = case x returning _ of f
 {-# INLINE case_of_ #-}
 
 ------------------------------------------------------------------------
@@ -247,10 +247,24 @@ _*_ on f = f -⟨ _*_ ⟩- f
 
 
 ------------------------------------------------------------------------
--- Deprecated
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 1.4
 
 _-[_]-_ = _-⟪_⟫-_
 {-# WARNING_ON_USAGE _-[_]-_
 "Warning: Function._-[_]-_ was deprecated in v1.4.
 Please use _-⟪_⟫-_ instead."
 #-}
+
+-- Version 2.0
+
+case_return_of_ = case_returning_of_
+{-# WARNING_ON_USAGE case_return_of_
+"case_return_of_ was deprecated in v2.0.
+Please use case_returning_of_ instead."
+#-}
+
diff --git a/src/Function/Bijection.agda b/src/Function/Bijection.agda
index 1de607e957..91974b6294 100644
--- a/src/Function/Bijection.agda
+++ b/src/Function/Bijection.agda
@@ -1,22 +1,22 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Bijections
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
-
--- Note: use of the standard function hierarchy is encouraged. The
--- module `Function` re-exports `Bijective`, `IsBijection` and
--- `Bijection`. The alternative definitions found in this file will
--- eventually be deprecated.
+{-# OPTIONS --warn=noUserWarning #-}
 
 module Function.Bijection where
 
-open import Data.Product
+{-# WARNING_ON_IMPORT
+"Function.Bijection was deprecated in v2.0.
+Use the standard function hierarchy in Function/Function.Bundles instead."
+#-}
+
 open import Level
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality as ≡
 open import Function.Equality as F
   using (_⟶_; _⟨$⟩_) renaming (_∘_ to _⟪∘⟫_)
 open import Function.Injection   as Inj  hiding (id; _∘_; injection)
@@ -38,6 +38,10 @@ record Bijective {f₁ f₂ t₁ t₂}
 
   left-inverse-of : from LeftInverseOf to
   left-inverse-of x = injective (right-inverse-of (to ⟨$⟩ x))
+{-# WARNING_ON_USAGE Bijective
+"Warning: Bijective was deprecated in v2.0.
+Please use Function.(Structures.)IsBijection instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all bijections between two setoids.
@@ -74,6 +78,10 @@ record Bijection {f₁ f₂ t₁ t₂}
     }
 
   open LeftInverse left-inverse public using (to-from)
+{-# WARNING_ON_USAGE Bijection
+"Warning: Bijection was deprecated in v2.0.
+Please use Function.(Bundles.)Bijection instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all bijections between two sets (i.e. bijections with
@@ -82,7 +90,11 @@ record Bijection {f₁ f₂ t₁ t₂}
 infix 3 _⤖_
 
 _⤖_ : ∀ {f t} → Set f → Set t → Set _
-From ⤖ To = Bijection (P.setoid From) (P.setoid To)
+From ⤖ To = Bijection (≡.setoid From) (≡.setoid To)
+{-# WARNING_ON_USAGE _⤖_
+"Warning: _⤖_ was deprecated in v2.0.
+Please use Function.(Bundles.)mk⤖ instead."
+#-}
 
 bijection : ∀ {f t} {From : Set f} {To : Set t} →
             (to : From → To) (from : To → From) →
@@ -90,15 +102,20 @@ bijection : ∀ {f t} {From : Set f} {To : Set t} →
             (∀ x → to (from x) ≡ x) →
             From ⤖ To
 bijection to from inj invʳ = record
-  { to        = P.→-to-⟶ to
+  { to        = F.→-to-⟶ to
   ; bijective = record
     { injective  = inj
     ; surjective = record
-      { from             = P.→-to-⟶ from
+      { from             = F.→-to-⟶ from
       ; right-inverse-of = invʳ
       }
     }
   }
+{-# WARNING_ON_USAGE bijection
+"Warning: bijection was deprecated in v2.0.
+Please use either Function.Properties.Bijection.trans or
+Function.Construct.Composition.bijection instead."
+#-}
 
 ------------------------------------------------------------------------
 -- Identity and composition. (Note that these proofs are superfluous,
@@ -112,6 +129,11 @@ id {S = S} = record
     ; surjective = Surjection.surjective (Surj.id {S = S})
     }
   }
+{-# WARNING_ON_USAGE id
+"Warning: id was deprecated in v2.0.
+Please use either Function.Properties.Bijection.refl or
+Function.Construct.Identity.bijection instead."
+#-}
 
 infixr 9 _∘_
 
@@ -125,3 +147,8 @@ f ∘ g = record
     ; surjective = Surjection.surjective (Surj._∘_ (surjection f) (surjection g))
     }
   } where open Bijection
+{-# WARNING_ON_USAGE _∘_
+"Warning: _∘_ was deprecated in v2.0.
+Please use either Function.Properties.Bijection.trans or
+Function.Construct.Composition.bijection instead."
+#-}
diff --git a/src/Function/Bundles.agda b/src/Function/Bundles.agda
index 6284182845..6532715a21 100644
--- a/src/Function/Bundles.agda
+++ b/src/Function/Bundles.agda
@@ -20,14 +20,16 @@
 module Function.Bundles where
 
 open import Function.Base using (_∘_)
-import Function.Definitions as FunctionDefinitions
+open import Function.Definitions
 import Function.Structures as FunctionStructures
 open import Level using (Level; _⊔_; suc)
-open import Data.Product using (_,_; proj₁; proj₂)
-open import Relation.Binary hiding (_⇔_)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Core using (_Preserves_⟶_)
 open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_)
 import Relation.Binary.PropositionalEquality.Properties as ≡
+open import Function.Consequences.Propositional
 open Setoid using (isEquivalence)
 
 private
@@ -42,8 +44,7 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
 
   open Setoid From using () renaming (Carrier to A; _≈_ to _≈₁_)
   open Setoid To   using () renaming (Carrier to B; _≈_ to _≈₂_)
-  open FunctionDefinitions _≈₁_ _≈₂_
-  open FunctionStructures  _≈₁_ _≈₂_
+  open FunctionStructures _≈₁_ _≈₂_
 
 ------------------------------------------------------------------------
 -- Bundles with one element
@@ -53,7 +54,7 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
   record Func : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       to   : A → B
-      cong : to Preserves _≈₁_ ⟶ _≈₂_
+      cong : Congruent _≈₁_ _≈₂_ to
 
     isCongruent : IsCongruent to
     isCongruent = record
@@ -69,8 +70,8 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
   record Injection : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       to          : A → B
-      cong        : to Preserves _≈₁_ ⟶ _≈₂_
-      injective   : Injective to
+      cong        : Congruent _≈₁_ _≈₂_ to
+      injective   : Injective _≈₁_ _≈₂_ to
 
     function : Func
     function = record
@@ -91,20 +92,17 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
   record Surjection : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       to         : A → B
-      cong       : to Preserves _≈₁_ ⟶ _≈₂_
-      surjective : Surjective to
+      cong       : Congruent _≈₁_ _≈₂_ to
+      surjective : Surjective _≈₁_ _≈₂_ to
 
-    to⁻ : B → A
-    to⁻ = proj₁ ∘ surjective
-
-    isCongruent : IsCongruent to
-    isCongruent = record
-      { cong           = cong
-      ; isEquivalence₁ = isEquivalence From
-      ; isEquivalence₂ = isEquivalence To
+    function : Func
+    function = record
+      { to   = to
+      ; cong = cong
       }
 
-    open IsCongruent isCongruent public using (module Eq₁; module Eq₂)
+    open Func function public
+      hiding (to; cong)
 
     isSurjection : IsSurjection to
     isSurjection = record
@@ -112,17 +110,28 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
       ; surjective  = surjective
       }
 
+    open IsSurjection isSurjection public
+      using
+      ( strictlySurjective
+      )
+
+    to⁻ : B → A
+    to⁻ = proj₁ ∘ surjective
+
+    to∘to⁻ : ∀ x → to (to⁻ x) ≈₂ x
+    to∘to⁻ = proj₂ ∘ strictlySurjective
+
 
   record Bijection : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       to        : A → B
-      cong      : to Preserves _≈₁_ ⟶ _≈₂_
-      bijective : Bijective to
+      cong      : Congruent _≈₁_ _≈₂_ to
+      bijective : Bijective _≈₁_ _≈₂_ to
 
-    injective : Injective to
+    injective : Injective _≈₁_ _≈₂_ to
     injective = proj₁ bijective
 
-    surjective : Surjective to
+    surjective : Surjective _≈₁_ _≈₂_ to
     surjective = proj₂ bijective
 
     injection : Injection
@@ -138,7 +147,7 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
       }
 
     open Injection  injection  public using (isInjection)
-    open Surjection surjection public using (isSurjection; to⁻)
+    open Surjection surjection public using (isSurjection; to⁻;  strictlySurjective)
 
     isBijection : IsBijection to
     isBijection = record
@@ -152,21 +161,47 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
 ------------------------------------------------------------------------
 -- Bundles with two elements
 
+module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
+
+  open Setoid From using () renaming (Carrier to A; _≈_ to _≈₁_)
+  open Setoid To   using () renaming (Carrier to B; _≈_ to _≈₂_)
+  open FunctionStructures _≈₁_ _≈₂_
+
   record Equivalence : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       to        : A → B
       from      : B → A
-      to-cong   : to Preserves _≈₁_ ⟶ _≈₂_
-      from-cong : from Preserves _≈₂_ ⟶ _≈₁_
+      to-cong   : Congruent _≈₁_ _≈₂_ to
+      from-cong : Congruent _≈₂_ _≈₁_ from
+
+    toFunction : Func From To
+    toFunction = record
+      { to = to
+      ; cong = to-cong
+      }
+
+    open Func toFunction public
+      using (module Eq₁; module Eq₂)
+      renaming (isCongruent to to-isCongruent)
+
+    fromFunction : Func To From
+    fromFunction = record
+      { to = from
+      ; cong = from-cong
+      }
+
+    open Func fromFunction public
+      using ()
+      renaming (isCongruent to from-isCongruent)
 
 
   record LeftInverse : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       to        : A → B
       from      : B → A
-      to-cong   : to Preserves _≈₁_ ⟶ _≈₂_
-      from-cong : from Preserves _≈₂_ ⟶ _≈₁_
-      inverseˡ  : Inverseˡ to from
+      to-cong   : Congruent _≈₁_ _≈₂_ to
+      from-cong : Congruent _≈₂_ _≈₁_ from
+      inverseˡ  : Inverseˡ _≈₁_ _≈₂_ to from
 
     isCongruent : IsCongruent to
     isCongruent = record
@@ -175,8 +210,6 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
       ; isEquivalence₂ = isEquivalence To
       }
 
-    open IsCongruent isCongruent public using (module Eq₁; module Eq₂)
-
     isLeftInverse : IsLeftInverse to from
     isLeftInverse = record
       { isCongruent = isCongruent
@@ -184,20 +217,37 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
       ; inverseˡ    = inverseˡ
       }
 
+    open IsLeftInverse isLeftInverse public
+      using (module Eq₁; module Eq₂; strictlyInverseˡ; isSurjection)
+
     equivalence : Equivalence
     equivalence = record
       { to-cong   = to-cong
       ; from-cong = from-cong
       }
 
+    isSplitSurjection : IsSplitSurjection to
+    isSplitSurjection = record
+      { from = from
+      ; isLeftInverse = isLeftInverse
+      }
+
+    surjection : Surjection From To
+    surjection = record
+      { to = to
+      ; cong = to-cong
+      ; surjective = λ y → from y , inverseˡ
+      }
+
+
 
   record RightInverse : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
       to        : A → B
       from      : B → A
-      to-cong   : to Preserves _≈₁_ ⟶ _≈₂_
+      to-cong   : Congruent _≈₁_ _≈₂_ to
       from-cong : from Preserves _≈₂_ ⟶ _≈₁_
-      inverseʳ  : Inverseʳ to from
+      inverseʳ  : Inverseʳ _≈₁_ _≈₂_ to from
 
     isCongruent : IsCongruent to
     isCongruent = record
@@ -213,6 +263,9 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
       ; inverseʳ    = inverseʳ
       }
 
+    open IsRightInverse isRightInverse public
+      using (module Eq₁; module Eq₂; strictlyInverseʳ)
+
     equivalence : Equivalence
     equivalence = record
       { to-cong   = to-cong
@@ -224,14 +277,14 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
     field
       to        : A → B
       from      : B → A
-      to-cong   : to Preserves _≈₁_ ⟶ _≈₂_
-      from-cong : from Preserves _≈₂_ ⟶ _≈₁_
-      inverse   : Inverseᵇ to from
+      to-cong   : Congruent _≈₁_ _≈₂_ to
+      from-cong : Congruent _≈₂_ _≈₁_ from
+      inverse   : Inverseᵇ _≈₁_ _≈₂_ to from
 
-    inverseˡ : Inverseˡ to from
+    inverseˡ : Inverseˡ _≈₁_ _≈₂_ to from
     inverseˡ = proj₁ inverse
 
-    inverseʳ : Inverseʳ to from
+    inverseʳ : Inverseʳ _≈₁_ _≈₂_ to from
     inverseʳ = proj₂ inverse
 
     leftInverse : LeftInverse
@@ -248,8 +301,8 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
       ; inverseʳ  = inverseʳ
       }
 
-    open LeftInverse leftInverse   public using (isLeftInverse)
-    open RightInverse rightInverse public using (isRightInverse)
+    open LeftInverse leftInverse   public using (isLeftInverse; strictlyInverseˡ)
+    open RightInverse rightInverse public using (isRightInverse; strictlyInverseʳ)
 
     isInverse : IsInverse to from
     isInverse = record
@@ -268,21 +321,21 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
       to         : A → B
       from₁      : B → A
       from₂      : B → A
-      to-cong    : to Preserves _≈₁_ ⟶ _≈₂_
-      from₁-cong : from₁ Preserves _≈₂_ ⟶ _≈₁_
-      from₂-cong : from₂ Preserves _≈₂_ ⟶ _≈₁_
+      to-cong    : Congruent _≈₁_ _≈₂_ to
+      from₁-cong : Congruent _≈₂_ _≈₁_ from₁
+      from₂-cong : Congruent _≈₂_ _≈₁_ from₂
 
 
   record BiInverse : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     field
-      to         : A → B
-      from₁        : B → A
-      from₂        : B → A
-      to-cong     : to Preserves _≈₁_ ⟶ _≈₂_
-      from₁-cong     : from₁ Preserves _≈₂_ ⟶ _≈₁_
-      from₂-cong     : from₂ Preserves _≈₂_ ⟶ _≈₁_
-      inverseˡ  : Inverseˡ to from₁
-      inverseʳ  : Inverseʳ to from₂
+      to          : A → B
+      from₁       : B → A
+      from₂       : B → A
+      to-cong     : Congruent _≈₁_ _≈₂_ to
+      from₁-cong  : Congruent _≈₂_ _≈₁_ from₁
+      from₂-cong  : Congruent _≈₂_ _≈₁_ from₂
+      inverseˡ  : Inverseˡ _≈₁_ _≈₂_ to from₁
+      inverseʳ  : Inverseʳ _≈₁_ _≈₂_ to from₂
 
     to-isCongruent : IsCongruent to
     to-isCongruent = record
@@ -307,6 +360,56 @@ module _ (From : Setoid a ℓ₁) (To : Setoid b ℓ₂) where
       ; from₂-cong = from₂-cong
       }
 
+------------------------------------------------------------------------
+-- Other
+
+  -- A left inverse is also known as a “split surjection”.
+  --
+  -- As the name implies, a split surjection is a special kind of
+  -- surjection where the witness generated in the domain in the
+  -- function for elements `x₁` and `x₂` are equal if `x₁ ≈ x₂` .
+  --
+  -- The difference is the `from-cong` law --- generally, the section
+  -- (called `Surjection.to⁻` or `SplitSurjection.from`) of a surjection
+  -- need not respect equality, whereas it must in a split surjection.
+  --
+  -- The two notions coincide when the equivalence relation on `B` is
+  -- propositional equality (because all functions respect propositional
+  -- equality).
+  --
+  -- For further background on (split) surjections, one may consult any
+  -- general mathematical references which work without the principle
+  -- of choice. For example:
+  --
+  --   https://ncatlab.org/nlab/show/split+epimorphism.
+  --
+  -- The connection to set-theoretic notions with the same names is
+  -- justified by the setoid type theory/homotopy type theory
+  -- observation/definition that (∃x : A. P) = ∥ Σx : A. P ∥ --- i.e.,
+  -- we can read set-theoretic ∃ as squashed/propositionally truncated Σ.
+  --
+  -- We see working with setoids as working in the MLTT model of a setoid
+  -- type theory, in which ∥ X ∥ is interpreted as the setoid with carrier
+  -- set X and the equivalence relation that relates all elements.
+  -- All maps into ∥ X ∥ respect equality, so in the idiomatic definitions
+  -- here, we drop the corresponding trivial `cong` field completely.
+
+  SplitSurjection : Set _
+  SplitSurjection = LeftInverse
+
+  module SplitSurjection (splitSurjection : SplitSurjection) =
+    LeftInverse splitSurjection
+
+------------------------------------------------------------------------
+-- Infix abbreviations for oft-used items
+------------------------------------------------------------------------
+
+-- Same naming convention as used for propositional equality below, with
+-- appended ₛ (for 'S'etoid).
+
+infixr 0 _⟶ₛ_
+_⟶ₛ_ : Setoid a ℓ₁ → Setoid b ℓ₂ → Set _
+_⟶ₛ_ = Func
 
 ------------------------------------------------------------------------
 -- Bundles specialised for propositional equality
@@ -345,29 +448,27 @@ A ↔ B = Inverse (≡.setoid A) (≡.setoid B)
 
 module _ {A : Set a} {B : Set b} where
 
-  open FunctionDefinitions {A = A} {B} _≡_ _≡_
-
   mk⟶ : (A → B) → A ⟶ B
   mk⟶ to = record
     { to        = to
     ; cong      = ≡.cong to
     }
 
-  mk↣ : ∀ {to : A → B} → Injective to → A ↣ B
+  mk↣ : ∀ {to : A → B} → Injective _≡_ _≡_ to → A ↣ B
   mk↣ {to} inj = record
     { to         = to
     ; cong      = ≡.cong to
     ; injective = inj
     }
 
-  mk↠ : ∀ {to : A → B} → Surjective to → A ↠ B
+  mk↠ : ∀ {to : A → B} → Surjective _≡_ _≡_ to → A ↠ B
   mk↠ {to} surj = record
     { to         = to
     ; cong       = ≡.cong to
     ; surjective = surj
     }
 
-  mk⤖ : ∀ {to : A → B} → Bijective to → A ⤖ B
+  mk⤖ : ∀ {to : A → B} → Bijective _≡_ _≡_ to → A ⤖ B
   mk⤖ {to} bij = record
     { to        = to
     ; cong      = ≡.cong to
@@ -382,7 +483,7 @@ module _ {A : Set a} {B : Set b} where
     ; from-cong = ≡.cong from
     }
 
-  mk↩ : ∀ {to : A → B} {from : B → A} → Inverseˡ to from → A ↩ B
+  mk↩ : ∀ {to : A → B} {from : B → A} → Inverseˡ _≡_ _≡_ to from → A ↩ B
   mk↩ {to} {from} invˡ = record
     { to        = to
     ; from      = from
@@ -391,7 +492,7 @@ module _ {A : Set a} {B : Set b} where
     ; inverseˡ  = invˡ
     }
 
-  mk↪ : ∀ {to : A → B} {from : B → A} → Inverseʳ to from → A ↪ B
+  mk↪ : ∀ {to : A → B} {from : B → A} → Inverseʳ _≡_ _≡_ to from → A ↪ B
   mk↪ {to} {from} invʳ = record
     { to        = to
     ; from      = from
@@ -401,7 +502,7 @@ module _ {A : Set a} {B : Set b} where
     }
 
   mk↩↪ : ∀ {to : A → B} {from₁ : B → A} {from₂ : B → A} →
-         Inverseˡ to from₁ → Inverseʳ to from₂ → A ↩↪ B
+         Inverseˡ _≡_ _≡_ to from₁ → Inverseʳ _≡_ _≡_ to from₂ → A ↩↪ B
   mk↩↪ {to} {from₁} {from₂} invˡ invʳ = record
     { to         = to
     ; from₁      = from₁
@@ -413,7 +514,7 @@ module _ {A : Set a} {B : Set b} where
     ; inverseʳ   = invʳ
     }
 
-  mk↔ : ∀ {to : A → B} {from : B → A} → Inverseᵇ to from → A ↔ B
+  mk↔ : ∀ {to : A → B} {from : B → A} → Inverseᵇ _≡_ _≡_ to from → A ↔ B
   mk↔ {to} {from} inv = record
     { to        = to
     ; from      = from
@@ -422,6 +523,29 @@ module _ {A : Set a} {B : Set b} where
     ; inverse   = inv
     }
 
-  -- Sometimes the implicit arguments above cannot be inferred
-  mk↔′ : ∀ (to : A → B) (from : B → A) → Inverseˡ to from → Inverseʳ to from → A ↔ B
-  mk↔′ to from invˡ invʳ = mk↔ {to = to} {from = from} (invˡ , invʳ)
+
+  -- Strict variant of the above.
+  mk↠ₛ : ∀ {to : A → B} → StrictlySurjective _≡_ to → A ↠ B
+  mk↠ₛ = mk↠ ∘ strictlySurjective⇒surjective
+
+  mk↔ₛ′ : ∀ (to : A → B) (from : B → A) →
+          StrictlyInverseˡ _≡_ to from →
+          StrictlyInverseʳ _≡_ to from →
+          A ↔ B
+  mk↔ₛ′ to from invˡ invʳ = mk↔ {to} {from}
+    ( strictlyInverseˡ⇒inverseˡ to invˡ
+    , strictlyInverseʳ⇒inverseʳ to invʳ
+    )
+
+------------------------------------------------------------------------
+-- Other
+------------------------------------------------------------------------
+
+-- Alternative syntax for the application of functions
+
+module _ {From : Setoid a ℓ₁} {To : Setoid b ℓ₂} where
+  open Setoid
+
+  infixl 5 _⟨$⟩_
+  _⟨$⟩_ : Func From To → Carrier From → Carrier To
+  _⟨$⟩_ = Func.to
diff --git a/src/Function/Consequences.agda b/src/Function/Consequences.agda
index 2b7603deea..2a13d452f6 100644
--- a/src/Function/Consequences.agda
+++ b/src/Function/Consequences.agda
@@ -1,56 +1,114 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Relationships between properties of functions
+-- Relationships between properties of functions. See
+-- `Function.Consequences.Propositional` for specialisations to
+-- propositional equality.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Function.Consequences where
 
-open import Data.Product
+open import Data.Product.Base as Product
 open import Function.Definitions
-open import Level
-open import Relation.Binary
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
-open import Relation.Nullary.Negation using (¬_)
-open import Relation.Nullary.Negation.Core using (contraposition)
+open import Level using (Level)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (Reflexive; Symmetric; Transitive)
+open import Relation.Nullary.Negation.Core using (¬_; contraposition)
 
 private
   variable
     a b ℓ₁ ℓ₂ : Level
-    A : Set a
-    B : Set b
+    A B : Set a
+    ≈₁ ≈₂ : Rel A ℓ₁
+    f f⁻¹ : A → B
 
-module _ (≈₁ : Rel A ℓ₁) (≈₂ : Rel B ℓ₂) {f f⁻¹} where
+------------------------------------------------------------------------
+-- Injective
+
+contraInjective : ∀ (≈₂ : Rel B ℓ₂) → Injective ≈₁ ≈₂ f →
+                  ∀ {x y} → ¬ (≈₁ x y) → ¬ (≈₂ (f x) (f y))
+contraInjective _ inj p = contraposition inj p
+
+------------------------------------------------------------------------
+-- Inverseˡ
 
-  inverseˡ⇒surjective : Inverseˡ ≈₁ ≈₂ f f⁻¹ → Surjective ≈₁ ≈₂ f
-  inverseˡ⇒surjective invˡ y = (f⁻¹ y , invˡ y)
+inverseˡ⇒surjective : ∀ (≈₂ : Rel B ℓ₂) →
+                      Inverseˡ ≈₁ ≈₂ f f⁻¹ →
+                      Surjective ≈₁ ≈₂ f
+inverseˡ⇒surjective ≈₂ invˡ y = (_ , invˡ)
 
-  inverseʳ⇒surjective : Inverseʳ ≈₁ ≈₂ f f⁻¹ → Surjective ≈₂ ≈₁ f⁻¹
-  inverseʳ⇒surjective invʳ y = (f y , invʳ y)
+------------------------------------------------------------------------
+-- Inverseʳ
+
+inverseʳ⇒injective : ∀ (≈₂ : Rel B ℓ₂) f →
+                     Reflexive ≈₂ →
+                     Symmetric ≈₁ →
+                     Transitive ≈₁ →
+                     Inverseʳ ≈₁ ≈₂ f f⁻¹ →
+                     Injective ≈₁ ≈₂ f
+inverseʳ⇒injective ≈₂ f refl sym trans invʳ {x} {y} fx≈fy =
+  trans (sym (invʳ refl)) (invʳ fx≈fy)
 
-module _ (From : Setoid a ℓ₁) {≈₂ : Rel B ℓ₂} where
+------------------------------------------------------------------------
+-- Inverseᵇ
 
-  open Setoid From using () renaming (Carrier to A; _≈_ to ≈₁)
+inverseᵇ⇒bijective : ∀ (≈₂ : Rel B ℓ₂) →
+                     Reflexive ≈₂ →
+                     Symmetric ≈₁ →
+                     Transitive ≈₁ →
+                     Inverseᵇ ≈₁ ≈₂ f f⁻¹ →
+                     Bijective ≈₁ ≈₂ f
+inverseᵇ⇒bijective {f = f} ≈₂ refl sym trans (invˡ , invʳ) =
+  (inverseʳ⇒injective ≈₂ f refl sym trans invʳ , inverseˡ⇒surjective ≈₂ invˡ)
 
-  inverseʳ⇒injective : ∀ {f f⁻¹} → Congruent ≈₂ ≈₁ f⁻¹ →
-                       Inverseʳ ≈₁ ≈₂ f f⁻¹ → Injective ≈₁ ≈₂ f
-  inverseʳ⇒injective {f} {f⁻¹} cong₂ invʳ {x} {y} x≈y = begin
-    x         ≈˘⟨ invʳ x ⟩
-    f⁻¹ (f x) ≈⟨  cong₂ x≈y ⟩
-    f⁻¹ (f y) ≈⟨  invʳ y ⟩
-    y         ∎
-    where open SetoidReasoning From
+------------------------------------------------------------------------
+-- StrictlySurjective
 
-  inverseᵇ⇒bijective : ∀ {f f⁻¹} → Congruent ≈₂ ≈₁ f⁻¹ → Inverseᵇ ≈₁ ≈₂ f f⁻¹ → Bijective ≈₁ ≈₂ f
-  inverseᵇ⇒bijective cong₂ (invˡ , invʳ) =
-    (inverseʳ⇒injective cong₂ invʳ , inverseˡ⇒surjective ≈₁ ≈₂ invˡ)
+surjective⇒strictlySurjective : ∀ (≈₂ : Rel B ℓ₂) →
+                                 Reflexive ≈₁ →
+                                 Surjective ≈₁ ≈₂ f →
+                                 StrictlySurjective ≈₂ f
+surjective⇒strictlySurjective _ refl surj x =
+  Product.map₂ (λ v → v refl) (surj x)
+
+strictlySurjective⇒surjective : Transitive ≈₂ →
+                                 Congruent ≈₁ ≈₂ f →
+                                 StrictlySurjective ≈₂ f →
+                                 Surjective ≈₁ ≈₂ f
+strictlySurjective⇒surjective trans cong surj x =
+  Product.map₂ (λ fy≈x z≈y → trans (cong z≈y) fy≈x) (surj x)
+
+------------------------------------------------------------------------
+-- StrictlyInverseˡ
+
+inverseˡ⇒strictlyInverseˡ : ∀ (≈₁ : Rel A ℓ₁) (≈₂ : Rel B ℓ₂) →
+                            Reflexive ≈₁ →
+                            Inverseˡ ≈₁ ≈₂ f f⁻¹ →
+                            StrictlyInverseˡ ≈₂ f f⁻¹
+inverseˡ⇒strictlyInverseˡ _ _ refl sinv x = sinv refl
+
+strictlyInverseˡ⇒inverseˡ : Transitive ≈₂ →
+                            Congruent ≈₁ ≈₂ f →
+                            StrictlyInverseˡ ≈₂ f f⁻¹ →
+                            Inverseˡ ≈₁ ≈₂ f f⁻¹
+strictlyInverseˡ⇒inverseˡ trans cong sinv {x} y≈f⁻¹x =
+  trans (cong y≈f⁻¹x) (sinv x)
+
+------------------------------------------------------------------------
+-- StrictlyInverseʳ
 
-module _
-  {f : A → B} (_≈₁_ : Rel A ℓ₁) (_≈₂_ : Rel B ℓ₂)
-  where
+inverseʳ⇒strictlyInverseʳ : ∀ (≈₁ : Rel A ℓ₁) (≈₂ : Rel B ℓ₂) →
+                            Reflexive ≈₂ →
+                            Inverseʳ ≈₁ ≈₂ f f⁻¹ →
+                            StrictlyInverseʳ ≈₁ f f⁻¹
+inverseʳ⇒strictlyInverseʳ _ _ refl sinv x = sinv refl
 
-  contraInjective : Injective _≈₁_ _≈₂_ f →
-                    ∀ {x y} → ¬ (x ≈₁ y) → ¬ (f x ≈₂ f y)
-  contraInjective inj p = contraposition inj p
+strictlyInverseʳ⇒inverseʳ : Transitive ≈₁ →
+                            Congruent ≈₂ ≈₁ f⁻¹ →
+                            StrictlyInverseʳ ≈₁ f f⁻¹ →
+                            Inverseʳ ≈₁ ≈₂ f f⁻¹
+strictlyInverseʳ⇒inverseʳ trans cong sinv {x} y≈f⁻¹x =
+  trans (cong y≈f⁻¹x) (sinv x)
diff --git a/src/Function/Consequences/Propositional.agda b/src/Function/Consequences/Propositional.agda
new file mode 100644
index 0000000000..a2558a9c48
--- /dev/null
+++ b/src/Function/Consequences/Propositional.agda
@@ -0,0 +1,53 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Relationships between properties of functions where the equality
+-- over both the domain and codomain is assumed to be _≡_
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Function.Consequences.Propositional
+  {a b} {A : Set a} {B : Set b}
+  where
+
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; _≢_; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (setoid)
+open import Function.Definitions
+open import Relation.Nullary.Negation.Core using (contraposition)
+
+import Function.Consequences.Setoid (setoid A) (setoid B) as Setoid
+
+------------------------------------------------------------------------
+-- Re-export setoid properties
+
+open Setoid public
+  hiding
+  ( strictlySurjective⇒surjective
+  ; strictlyInverseˡ⇒inverseˡ
+  ; strictlyInverseʳ⇒inverseʳ
+  )
+
+------------------------------------------------------------------------
+-- Properties that rely on congruence
+
+private
+  variable
+    f : A → B
+    f⁻¹ : B → A
+
+strictlySurjective⇒surjective : StrictlySurjective _≡_ f →
+                                 Surjective _≡_ _≡_ f
+strictlySurjective⇒surjective =
+ Setoid.strictlySurjective⇒surjective (cong _)
+
+strictlyInverseˡ⇒inverseˡ : ∀ f → StrictlyInverseˡ _≡_ f f⁻¹ →
+                            Inverseˡ _≡_ _≡_ f f⁻¹
+strictlyInverseˡ⇒inverseˡ f =
+  Setoid.strictlyInverseˡ⇒inverseˡ (cong _)
+
+strictlyInverseʳ⇒inverseʳ : ∀ f → StrictlyInverseʳ _≡_ f f⁻¹ →
+                            Inverseʳ _≡_ _≡_ f f⁻¹
+strictlyInverseʳ⇒inverseʳ f =
+  Setoid.strictlyInverseʳ⇒inverseʳ (cong _)
diff --git a/src/Function/Consequences/Setoid.agda b/src/Function/Consequences/Setoid.agda
new file mode 100644
index 0000000000..d2c3b948d9
--- /dev/null
+++ b/src/Function/Consequences/Setoid.agda
@@ -0,0 +1,92 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Relationships between properties of functions where the equality
+-- over both the domain and codomain are assumed to be setoids.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Bundles using (Setoid)
+
+module Function.Consequences.Setoid
+  {a b ℓ₁ ℓ₂}
+  (S : Setoid a ℓ₁)
+  (T : Setoid b ℓ₂)
+  where
+
+open import Function.Definitions
+open import Relation.Nullary.Negation.Core
+
+import Function.Consequences as C
+
+private
+  open module S = Setoid S using () renaming (Carrier to A; _≈_ to ≈₁)
+  open module T = Setoid T using () renaming (Carrier to B; _≈_ to ≈₂)
+
+  variable
+    f : A → B
+    f⁻¹ : B → A
+
+------------------------------------------------------------------------
+-- Injective
+
+contraInjective : Injective ≈₁ ≈₂ f →
+                  ∀ {x y} → ¬ (≈₁ x y) → ¬ (≈₂ (f x) (f y))
+contraInjective = C.contraInjective ≈₂
+
+------------------------------------------------------------------------
+-- Inverseˡ
+
+inverseˡ⇒surjective : Inverseˡ ≈₁ ≈₂ f f⁻¹ → Surjective ≈₁ ≈₂ f
+inverseˡ⇒surjective = C.inverseˡ⇒surjective ≈₂
+
+------------------------------------------------------------------------
+-- Inverseʳ
+
+inverseʳ⇒injective : ∀ f → Inverseʳ ≈₁ ≈₂ f f⁻¹ → Injective ≈₁ ≈₂ f
+inverseʳ⇒injective f = C.inverseʳ⇒injective ≈₂ f T.refl S.sym S.trans
+
+------------------------------------------------------------------------
+-- Inverseᵇ
+
+inverseᵇ⇒bijective : Inverseᵇ ≈₁ ≈₂ f f⁻¹ → Bijective ≈₁ ≈₂ f
+inverseᵇ⇒bijective = C.inverseᵇ⇒bijective ≈₂ T.refl S.sym S.trans
+
+------------------------------------------------------------------------
+-- StrictlySurjective
+
+surjective⇒strictlySurjective : Surjective ≈₁ ≈₂ f →
+                                 StrictlySurjective ≈₂ f
+surjective⇒strictlySurjective =
+  C.surjective⇒strictlySurjective ≈₂ S.refl
+
+strictlySurjective⇒surjective : Congruent ≈₁ ≈₂ f →
+                                 StrictlySurjective ≈₂ f →
+                                 Surjective ≈₁ ≈₂ f
+strictlySurjective⇒surjective =
+  C.strictlySurjective⇒surjective T.trans
+
+------------------------------------------------------------------------
+-- StrictlyInverseˡ
+
+inverseˡ⇒strictlyInverseˡ : Inverseˡ ≈₁ ≈₂ f f⁻¹ →
+                            StrictlyInverseˡ ≈₂ f f⁻¹
+inverseˡ⇒strictlyInverseˡ = C.inverseˡ⇒strictlyInverseˡ ≈₁ ≈₂ S.refl
+
+strictlyInverseˡ⇒inverseˡ : Congruent ≈₁ ≈₂ f →
+                            StrictlyInverseˡ ≈₂ f f⁻¹ →
+                            Inverseˡ ≈₁ ≈₂ f f⁻¹
+strictlyInverseˡ⇒inverseˡ = C.strictlyInverseˡ⇒inverseˡ T.trans
+
+------------------------------------------------------------------------
+-- StrictlyInverseʳ
+
+inverseʳ⇒strictlyInverseʳ : Inverseʳ ≈₁ ≈₂ f f⁻¹ →
+                            StrictlyInverseʳ ≈₁ f f⁻¹
+inverseʳ⇒strictlyInverseʳ = C.inverseʳ⇒strictlyInverseʳ ≈₁ ≈₂ T.refl
+
+strictlyInverseʳ⇒inverseʳ : Congruent ≈₂ ≈₁ f⁻¹ →
+                            StrictlyInverseʳ ≈₁ f f⁻¹ →
+                            Inverseʳ ≈₁ ≈₂ f f⁻¹
+strictlyInverseʳ⇒inverseʳ = C.strictlyInverseʳ⇒inverseʳ S.trans
diff --git a/src/Function/Construct/Composition.agda b/src/Function/Construct/Composition.agda
index 242456d212..10289cc8c9 100644
--- a/src/Function/Construct/Composition.agda
+++ b/src/Function/Construct/Composition.agda
@@ -8,10 +8,15 @@
 
 module Function.Construct.Composition where
 
-open import Data.Product using (_,_)
-open import Function
+open import Data.Product.Base as Product using (_,_)
+open import Function.Base using (_∘_; flip)
+open import Function.Bundles
+open import Function.Definitions
+open import Function.Structures
 open import Level using (Level)
-open import Relation.Binary as B hiding (_⇔_; IsEquivalence)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (Transitive)
 
 private
   variable
@@ -33,39 +38,31 @@ module _ (≈₁ : Rel A ℓ₁) (≈₂ : Rel B ℓ₂) (≈₃ : Rel C ℓ₃)
               Injective ≈₁ ≈₃ (g ∘ f)
   injective f-inj g-inj = f-inj ∘ g-inj
 
-  surjective : Transitive ≈₃ → Congruent ≈₂ ≈₃ g →
-               Surjective ≈₁ ≈₂ f → Surjective ≈₂ ≈₃ g →
+  surjective : Surjective ≈₁ ≈₂ f → Surjective ≈₂ ≈₃ g →
                Surjective ≈₁ ≈₃ (g ∘ f)
-  surjective trans g-cong f-sur g-sur x with g-sur x
-  ... | y , fy≈x  with f-sur y
-  ...   | z , fz≈y = z , trans (g-cong fz≈y) fy≈x
+  surjective f-sur g-sur x with g-sur x
+  ... | y , gproof with f-sur y
+  ...   | z , fproof = z , gproof ∘ fproof
 
-  bijective : Transitive ≈₃ → Congruent ≈₂ ≈₃ g →
-              Bijective ≈₁ ≈₂ f → Bijective ≈₂ ≈₃ g →
+  bijective : Bijective ≈₁ ≈₂ f → Bijective ≈₂ ≈₃ g →
               Bijective ≈₁ ≈₃ (g ∘ f)
-  bijective trans g-cong (f-inj , f-sur) (g-inj , g-sur) =
-    injective f-inj g-inj , surjective trans g-cong f-sur g-sur
+  bijective = Product.zip′ injective surjective
 
 module _ (≈₁ : Rel A ℓ₁) (≈₂ : Rel B ℓ₂) (≈₃ : Rel C ℓ₃)
-         (f : A → B) {f⁻¹ : B → A} {g : B → C} (g⁻¹ : C → B)
+         {f : A → B} {f⁻¹ : B → A} {g : B → C} {g⁻¹ : C → B}
          where
 
-  inverseˡ : Transitive ≈₃ → Congruent ≈₂ ≈₃ g →
-             Inverseˡ ≈₁ ≈₂ f f⁻¹ → Inverseˡ ≈₂ ≈₃ g g⁻¹ →
+  inverseˡ : Inverseˡ ≈₁ ≈₂ f f⁻¹ → Inverseˡ ≈₂ ≈₃ g g⁻¹ →
              Inverseˡ ≈₁ ≈₃ (g ∘ f) (f⁻¹ ∘ g⁻¹)
-  inverseˡ trn g-cong f-inv g-inv x = trn (g-cong (f-inv _)) (g-inv x)
+  inverseˡ f-inv g-inv = g-inv ∘ f-inv
 
-  inverseʳ : Transitive ≈₁ → Congruent ≈₂ ≈₁ f⁻¹ →
-             Inverseʳ ≈₁ ≈₂ f f⁻¹ → Inverseʳ ≈₂ ≈₃ g g⁻¹ →
+  inverseʳ : Inverseʳ ≈₁ ≈₂ f f⁻¹ → Inverseʳ ≈₂ ≈₃ g g⁻¹ →
              Inverseʳ ≈₁ ≈₃ (g ∘ f) (f⁻¹ ∘ g⁻¹)
-  inverseʳ trn f⁻¹-cong f-inv g-inv x = trn (f⁻¹-cong (g-inv _)) (f-inv x)
+  inverseʳ f-inv g-inv = f-inv ∘ g-inv
 
-  inverseᵇ : Transitive ≈₁ → Transitive ≈₃ →
-             Congruent ≈₂ ≈₃ g → Congruent ≈₂ ≈₁ f⁻¹ →
-             Inverseᵇ ≈₁ ≈₂ f f⁻¹ → Inverseᵇ ≈₂ ≈₃ g g⁻¹ →
+  inverseᵇ : Inverseᵇ ≈₁ ≈₂ f f⁻¹ → Inverseᵇ ≈₂ ≈₃ g g⁻¹ →
              Inverseᵇ ≈₁ ≈₃ (g ∘ f) (f⁻¹ ∘ g⁻¹)
-  inverseᵇ trn₁ trn₃ g-cong f⁻¹-cong (f-invˡ , f-invʳ) (g-invˡ , g-invʳ) =
-    inverseˡ trn₃ g-cong f-invˡ g-invˡ , inverseʳ trn₁ f⁻¹-cong f-invʳ g-invʳ
+  inverseᵇ = Product.zip′ inverseˡ inverseʳ
 
 ------------------------------------------------------------------------
 -- Structures
@@ -93,14 +90,14 @@ module _ {≈₁ : Rel A ℓ₁} {≈₂ : Rel B ℓ₂} {≈₃ : Rel C ℓ₃}
                  IsSurjection ≈₁ ≈₃ (g ∘ f)
   isSurjection f-surj g-surj = record
     { isCongruent = isCongruent F.isCongruent G.isCongruent
-    ; surjective  = surjective ≈₁ ≈₂ ≈₃ G.Eq₂.trans G.cong F.surjective G.surjective
+    ; surjective  = surjective ≈₁ ≈₂ ≈₃ F.surjective G.surjective
     } where module F = IsSurjection f-surj; module G = IsSurjection g-surj
 
   isBijection : IsBijection ≈₁ ≈₂ f → IsBijection ≈₂ ≈₃ g →
                 IsBijection ≈₁ ≈₃ (g ∘ f)
   isBijection f-bij g-bij = record
     { isInjection = isInjection F.isInjection G.isInjection
-    ; surjective  = surjective ≈₁ ≈₂ ≈₃ G.Eq₂.trans G.cong F.surjective G.surjective
+    ; surjective  = surjective ≈₁ ≈₂ ≈₃ F.surjective G.surjective
     } where module F = IsBijection f-bij; module G = IsBijection g-bij
 
 module _ {≈₁ : Rel A ℓ₁} {≈₂ : Rel B ℓ₂} {≈₃ : Rel C ℓ₃}
@@ -111,23 +108,23 @@ module _ {≈₁ : Rel A ℓ₁} {≈₂ : Rel B ℓ₂} {≈₃ : Rel C ℓ₃}
                   IsLeftInverse ≈₁ ≈₃ (g ∘ f) (f⁻¹ ∘ g⁻¹)
   isLeftInverse f-invˡ g-invˡ = record
     { isCongruent = isCongruent F.isCongruent G.isCongruent
-    ; from-cong       = congruent ≈₃ ≈₂ ≈₁ G.from-cong F.from-cong
-    ; inverseˡ    = inverseˡ ≈₁ ≈₂ ≈₃ f _ G.Eq₂.trans G.to-cong F.inverseˡ G.inverseˡ
+    ; from-cong   = congruent ≈₃ ≈₂ ≈₁ G.from-cong F.from-cong
+    ; inverseˡ    = inverseˡ ≈₁ ≈₂ ≈₃ F.inverseˡ G.inverseˡ
     } where module F = IsLeftInverse f-invˡ; module G = IsLeftInverse g-invˡ
 
   isRightInverse : IsRightInverse ≈₁ ≈₂ f f⁻¹ → IsRightInverse ≈₂ ≈₃ g g⁻¹ →
                    IsRightInverse ≈₁ ≈₃ (g ∘ f) (f⁻¹ ∘ g⁻¹)
   isRightInverse f-invʳ g-invʳ = record
     { isCongruent = isCongruent F.isCongruent G.isCongruent
-    ; from-cong       = congruent ≈₃ ≈₂ ≈₁ G.from-cong F.from-cong
-    ; inverseʳ    = inverseʳ ≈₁ ≈₂ ≈₃ _ g⁻¹ F.Eq₁.trans F.from-cong F.inverseʳ G.inverseʳ
+    ; from-cong   = congruent ≈₃ ≈₂ ≈₁ G.from-cong F.from-cong
+    ; inverseʳ    = inverseʳ ≈₁ ≈₂ ≈₃ F.inverseʳ G.inverseʳ
     } where module F = IsRightInverse f-invʳ; module G = IsRightInverse g-invʳ
 
   isInverse : IsInverse ≈₁ ≈₂ f f⁻¹ → IsInverse ≈₂ ≈₃ g g⁻¹ →
               IsInverse ≈₁ ≈₃ (g ∘ f) (f⁻¹ ∘ g⁻¹)
   isInverse f-inv g-inv = record
     { isLeftInverse = isLeftInverse F.isLeftInverse G.isLeftInverse
-    ; inverseʳ      = inverseʳ ≈₁ ≈₂ ≈₃ _ g⁻¹ F.Eq₁.trans F.from-cong F.inverseʳ G.inverseʳ
+    ; inverseʳ      = inverseʳ ≈₁ ≈₂ ≈₃ F.inverseʳ G.inverseʳ
     } where module F = IsInverse f-inv; module G = IsInverse g-inv
 
 ------------------------------------------------------------------------
@@ -153,15 +150,15 @@ module _ {R : Setoid a ℓ₁} {S : Setoid b ℓ₂} {T : Setoid c ℓ₃} where
   surjection : Surjection R S → Surjection S T → Surjection R T
   surjection surj₁ surj₂ = record
     { to         = G.to ∘ F.to
-    ; cong       = congruent (≈ R) (≈ S) (≈ T) F.cong G.cong
-    ; surjective = surjective (≈ R) (≈ S) (≈ T) G.Eq₂.trans G.cong F.surjective G.surjective
+    ; cong       = congruent  (≈ R) (≈ S) (≈ T) F.cong G.cong
+    ; surjective = surjective (≈ R) (≈ S) (≈ T) F.surjective G.surjective
     } where module F = Surjection surj₁; module G = Surjection surj₂
 
   bijection : Bijection R S → Bijection S T → Bijection R T
   bijection bij₁ bij₂ = record
     { to        = G.to ∘ F.to
     ; cong      = congruent (≈ R) (≈ S) (≈ T) F.cong G.cong
-    ; bijective = bijective (≈ R) (≈ S) (≈ T) (trans T) G.cong F.bijective G.bijective
+    ; bijective = bijective (≈ R) (≈ S) (≈ T) F.bijective G.bijective
     } where module F = Bijection bij₁; module G = Bijection bij₂
 
   equivalence : Equivalence R S → Equivalence S T → Equivalence R T
@@ -178,7 +175,7 @@ module _ {R : Setoid a ℓ₁} {S : Setoid b ℓ₂} {T : Setoid c ℓ₃} where
     ; from      = F.from ∘ G.from
     ; to-cong   = congruent (≈ R) (≈ S) (≈ T) F.to-cong G.to-cong
     ; from-cong = congruent (≈ T) (≈ S) (≈ R) G.from-cong F.from-cong
-    ; inverseˡ  = inverseˡ  (≈ R) (≈ S) (≈ T) F.to _ (trans T) G.to-cong F.inverseˡ G.inverseˡ
+    ; inverseˡ  = inverseˡ  (≈ R) (≈ S) (≈ T) F.inverseˡ G.inverseˡ
     } where module F = LeftInverse invˡ₁; module G = LeftInverse invˡ₂
 
   rightInverse : RightInverse R S → RightInverse S T → RightInverse R T
@@ -187,7 +184,7 @@ module _ {R : Setoid a ℓ₁} {S : Setoid b ℓ₂} {T : Setoid c ℓ₃} where
     ; from      = F.from ∘ G.from
     ; to-cong   = congruent (≈ R) (≈ S) (≈ T) F.to-cong G.to-cong
     ; from-cong = congruent (≈ T) (≈ S) (≈ R) G.from-cong F.from-cong
-    ; inverseʳ  = inverseʳ  (≈ R) (≈ S) (≈ T) _ G.from (trans R) F.from-cong F.inverseʳ G.inverseʳ
+    ; inverseʳ  = inverseʳ  (≈ R) (≈ S) (≈ T) F.inverseʳ G.inverseʳ
     } where module F = RightInverse invʳ₁; module G = RightInverse invʳ₂
 
   inverse : Inverse R S → Inverse S T → Inverse R T
@@ -196,37 +193,39 @@ module _ {R : Setoid a ℓ₁} {S : Setoid b ℓ₂} {T : Setoid c ℓ₃} where
     ; from      = F.from ∘ G.from
     ; to-cong   = congruent (≈ R) (≈ S) (≈ T) F.to-cong G.to-cong
     ; from-cong = congruent (≈ T) (≈ S) (≈ R) G.from-cong F.from-cong
-    ; inverse   = inverseᵇ  (≈ R) (≈ S) (≈ T) _ G.from (trans R) (trans T) G.to-cong F.from-cong F.inverse G.inverse
+    ; inverse   = inverseᵇ  (≈ R) (≈ S) (≈ T) F.inverse G.inverse
     } where module F = Inverse inv₁; module G = Inverse inv₂
 
 ------------------------------------------------------------------------
 -- Propositional bundles
 
+-- Notice the flipped order of the arguments to mirror composition.
+
 infix 8 _⟶-∘_ _↣-∘_ _↠-∘_ _⤖-∘_ _⇔-∘_ _↩-∘_ _↪-∘_ _↔-∘_
 
-_⟶-∘_ : (A ⟶ B) → (B ⟶ C) → (A ⟶ C)
-_⟶-∘_ = function
+_⟶-∘_ : (B ⟶ C) → (A ⟶ B) → (A ⟶ C)
+_⟶-∘_ = flip function
 
-_↣-∘_ : A ↣ B → B ↣ C → A ↣ C
-_↣-∘_ = injection
+_↣-∘_ : B ↣ C → A ↣ B → A ↣ C
+_↣-∘_ = flip injection
 
-_↠-∘_ : A ↠ B → B ↠ C → A ↠ C
-_↠-∘_ = surjection
+_↠-∘_ : B ↠ C → A ↠ B → A ↠ C
+_↠-∘_ = flip surjection
 
-_⤖-∘_ : A ⤖ B → B ⤖ C → A ⤖ C
-_⤖-∘_ = bijection
+_⤖-∘_ : B ⤖ C → A ⤖ B → A ⤖ C
+_⤖-∘_ = flip bijection
 
-_⇔-∘_ : A ⇔ B → B ⇔ C → A ⇔ C
-_⇔-∘_ = equivalence
+_⇔-∘_ : B ⇔ C → A ⇔ B → A ⇔ C
+_⇔-∘_ = flip equivalence
 
-_↩-∘_ : A ↩ B → B ↩ C → A ↩ C
-_↩-∘_ = leftInverse
+_↩-∘_ : B ↩ C → A ↩ B → A ↩ C
+_↩-∘_ = flip leftInverse
 
-_↪-∘_  : A ↪ B → B ↪ C → A ↪ C
-_↪-∘_ = rightInverse
+_↪-∘_  : B ↪ C → A ↪ B → A ↪ C
+_↪-∘_ = flip rightInverse
 
-_↔-∘_ : A ↔ B → B ↔ C → A ↔ C
-_↔-∘_ = inverse
+_↔-∘_ : B ↔ C → A ↔ B → A ↔ C
+_↔-∘_ = flip inverse
 
 
 ------------------------------------------------------------------------
@@ -237,6 +236,8 @@ _↔-∘_ = inverse
 
 -- Version v2.0
 
+infix 8 _∘-⟶_ _∘-↣_ _∘-↠_ _∘-⤖_ _∘-⇔_ _∘-↩_ _∘-↪_ _∘-↔_
+
 _∘-⟶_ = _⟶-∘_
 {-# WARNING_ON_USAGE _∘-⟶_
 "Warning: _∘-⟶_ was deprecated in v2.0.
diff --git a/src/Function/Construct/Constant.agda b/src/Function/Construct/Constant.agda
new file mode 100644
index 0000000000..2f43929a87
--- /dev/null
+++ b/src/Function/Construct/Constant.agda
@@ -0,0 +1,64 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- The constant function
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Function.Construct.Constant where
+
+open import Function.Base using (const)
+open import Function.Bundles
+import Function.Definitions as Definitions
+import Function.Structures as Structures
+open import Level using (Level)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures as B hiding (IsEquivalence)
+
+private
+  variable
+    a b ℓ₁ ℓ₂ : Level
+    A B : Set a
+
+------------------------------------------------------------------------
+-- Properties
+
+module _ (_≈₁_ : Rel A ℓ₁) (_≈₂_ : Rel B ℓ₂) where
+
+  open Definitions
+
+  congruent : ∀ {b} → b ≈₂ b → Congruent _≈₁_ _≈₂_ (const b)
+  congruent refl _ = refl
+
+------------------------------------------------------------------------
+-- Structures
+
+module _
+  {≈₁ : Rel A ℓ₁} {≈₂ : Rel B ℓ₂}
+  (isEq₁ : B.IsEquivalence ≈₁)
+  (isEq₂ : B.IsEquivalence ≈₂) where
+
+  open Structures ≈₁ ≈₂
+  open B.IsEquivalence
+
+  isCongruent : ∀ b → IsCongruent (const b)
+  isCongruent b = record
+    { cong           = congruent ≈₁ ≈₂ (refl isEq₂)
+    ; isEquivalence₁ = isEq₁
+    ; isEquivalence₂ = isEq₂
+    }
+
+------------------------------------------------------------------------
+-- Setoid bundles
+
+module _ (S : Setoid a ℓ₂) (T : Setoid b ℓ₂) where
+
+  open Setoid
+
+  function : Carrier T → Func S T
+  function b = record
+    { to   = const b
+    ; cong = congruent (_≈_ S) (_≈_ T) (refl T)
+    }
diff --git a/src/Function/Construct/Identity.agda b/src/Function/Construct/Identity.agda
index 1b69165dda..0088445ba5 100644
--- a/src/Function/Construct/Identity.agda
+++ b/src/Function/Construct/Identity.agda
@@ -8,14 +8,18 @@
 
 module Function.Construct.Identity where
 
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (id)
 open import Function.Bundles
 import Function.Definitions as Definitions
 import Function.Structures as Structures
-open import Level
-open import Relation.Binary as B hiding (_⇔_; IsEquivalence)
-open import Relation.Binary.PropositionalEquality using (_≡_; setoid)
+open import Level using (Level)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures as B hiding (IsEquivalence)
+open import Relation.Binary.Definitions using (Reflexive)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 
 private
   variable
@@ -27,28 +31,28 @@ private
 
 module _ (_≈_ : Rel A ℓ) where
 
-  open Definitions _≈_ _≈_
+  open Definitions
 
-  congruent : Congruent id
+  congruent : Congruent _≈_ _≈_ id
   congruent = id
 
-  injective : Injective id
+  injective : Injective _≈_ _≈_ id
   injective = id
 
-  surjective : Reflexive _≈_ → Surjective id
-  surjective refl x = x , refl
+  surjective : Surjective _≈_ _≈_ id
+  surjective x = x , id
 
-  bijective : Reflexive _≈_ → Bijective id
-  bijective refl = injective , surjective refl
+  bijective : Bijective _≈_ _≈_ id
+  bijective = injective , surjective
 
-  inverseˡ : Reflexive _≈_ → Inverseˡ id id
-  inverseˡ refl x = refl
+  inverseˡ : Inverseˡ _≈_ _≈_ id id
+  inverseˡ = id
 
-  inverseʳ : Reflexive _≈_ → Inverseʳ id id
-  inverseʳ refl x = refl
+  inverseʳ : Inverseʳ _≈_ _≈_ id id
+  inverseʳ = id
 
-  inverseᵇ : Reflexive _≈_ → Inverseᵇ id id
-  inverseᵇ refl = inverseˡ refl , inverseʳ refl
+  inverseᵇ : Inverseᵇ _≈_ _≈_ id id
+  inverseᵇ = inverseˡ , inverseʳ
 
 ------------------------------------------------------------------------
 -- Structures
@@ -74,33 +78,33 @@ module _ {_≈_ : Rel A ℓ} (isEq : B.IsEquivalence _≈_) where
   isSurjection : IsSurjection id
   isSurjection = record
     { isCongruent = isCongruent
-    ; surjective  = surjective _≈_ refl
+    ; surjective  = surjective _≈_
     }
 
   isBijection : IsBijection id
   isBijection = record
     { isInjection = isInjection
-    ; surjective  = surjective _≈_ refl
+    ; surjective  = surjective _≈_
     }
 
   isLeftInverse : IsLeftInverse id id
   isLeftInverse = record
     { isCongruent = isCongruent
     ; from-cong   = id
-    ; inverseˡ    = inverseˡ _≈_ refl
+    ; inverseˡ    = inverseˡ _≈_
     }
 
   isRightInverse : IsRightInverse id id
   isRightInverse = record
     { isCongruent = isCongruent
     ; from-cong   = id
-    ; inverseʳ    = inverseʳ _≈_ refl
+    ; inverseʳ    = inverseʳ _≈_
     }
 
   isInverse : IsInverse id id
   isInverse = record
     { isLeftInverse = isLeftInverse
-    ; inverseʳ      = inverseʳ _≈_ refl
+    ; inverseʳ      = inverseʳ _≈_
     }
 
 ------------------------------------------------------------------------
@@ -127,14 +131,14 @@ module _ (S : Setoid a ℓ) where
   surjection = record
     { to         = id
     ; cong       = id
-    ; surjective = surjective _≈_ refl
+    ; surjective = surjective _≈_
     }
 
   bijection : Bijection S S
   bijection = record
     { to        = id
     ; cong      = id
-    ; bijective = bijective _≈_ refl
+    ; bijective = bijective _≈_
     }
 
   equivalence : Equivalence S S
@@ -151,7 +155,7 @@ module _ (S : Setoid a ℓ) where
     ; from      = id
     ; to-cong   = id
     ; from-cong = id
-    ; inverseˡ  = inverseˡ _≈_ refl
+    ; inverseˡ  = inverseˡ _≈_
     }
 
   rightInverse : RightInverse S S
@@ -160,7 +164,7 @@ module _ (S : Setoid a ℓ) where
     ; from      = id
     ; to-cong   = id
     ; from-cong = id
-    ; inverseʳ  = inverseʳ _≈_ refl
+    ; inverseʳ  = inverseʳ _≈_
     }
 
   inverse : Inverse S S
@@ -169,7 +173,7 @@ module _ (S : Setoid a ℓ) where
     ; from      = id
     ; to-cong   = id
     ; from-cong = id
-    ; inverse   = inverseᵇ _≈_ refl
+    ; inverse   = inverseᵇ _≈_
     }
 
 ------------------------------------------------------------------------
diff --git a/src/Function/Construct/Symmetry.agda b/src/Function/Construct/Symmetry.agda
index ea86704a57..e7e9f13db9 100644
--- a/src/Function/Construct/Symmetry.agda
+++ b/src/Function/Construct/Symmetry.agda
@@ -8,11 +8,20 @@
 
 module Function.Construct.Symmetry where
 
-open import Data.Product using (_,_; swap; proj₁; proj₂)
-open import Function
+open import Data.Product.Base using (_,_; swap; proj₁; proj₂)
+open import Function.Base using (_∘_)
+open import Function.Definitions
+  using (Bijective; Injective; Surjective; Inverseˡ; Inverseʳ; Inverseᵇ; Congruent)
+open import Function.Structures
+  using (IsBijection; IsCongruent; IsRightInverse; IsLeftInverse; IsInverse)
+open import Function.Bundles
+  using (Bijection; Equivalence; LeftInverse; RightInverse; Inverse; _⤖_; _⇔_; _↩_; _↪_; _↔_)
 open import Level using (Level)
-open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Reflexive; Symmetric; Transitive)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
 
 private
   variable
@@ -30,18 +39,19 @@ module _ {≈₁ : Rel A ℓ₁} {≈₂ : Rel B ℓ₂} {f : A → B}
     f⁻¹      = proj₁ ∘ surj
     f∘f⁻¹≡id = proj₂ ∘ surj
 
-  injective : Symmetric ≈₂ → Transitive ≈₂ → Congruent ≈₁ ≈₂ f → Injective ≈₂ ≈₁ f⁻¹
-  injective sym trans cong gx≈gy = trans (trans (sym (f∘f⁻¹≡id _)) (cong gx≈gy)) (f∘f⁻¹≡id _)
+  injective : Reflexive ≈₁ → Symmetric ≈₂ → Transitive ≈₂ →
+              Congruent ≈₁ ≈₂ f → Injective ≈₂ ≈₁ f⁻¹
+  injective refl sym trans cong gx≈gy =
+    trans (trans (sym (f∘f⁻¹≡id _ refl)) (cong gx≈gy)) (f∘f⁻¹≡id _ refl)
 
-  surjective : Surjective ≈₂ ≈₁ f⁻¹
-  surjective x = f x , inj (proj₂ (surj (f x)))
+  surjective : Reflexive ≈₁ → Transitive ≈₂ → Surjective ≈₂ ≈₁ f⁻¹
+  surjective refl trans x = f x , inj ∘ trans (f∘f⁻¹≡id _ refl)
 
-  bijective : Symmetric ≈₂ → Transitive ≈₂ → Congruent ≈₁ ≈₂ f → Bijective ≈₂ ≈₁ f⁻¹
-  bijective sym trans cong = injective sym trans cong , surjective
+  bijective : Reflexive ≈₁ → Symmetric ≈₂ → Transitive ≈₂ →
+              Congruent ≈₁ ≈₂ f → Bijective ≈₂ ≈₁ f⁻¹
+  bijective refl sym trans cong = injective refl sym trans cong , surjective refl trans
 
-module _ (≈₁ : Rel A ℓ₁) (≈₂ : Rel B ℓ₂)
-         (f : A → B) {f⁻¹ : B → A}
-         where
+module _ (≈₁ : Rel A ℓ₁) (≈₂ : Rel B ℓ₂) {f : A → B} {f⁻¹ : B → A} where
 
   inverseʳ : Inverseˡ ≈₁ ≈₂ f f⁻¹ → Inverseʳ ≈₂ ≈₁ f⁻¹ f
   inverseʳ inv = inv
@@ -73,9 +83,9 @@ module _ {≈₁ : Rel A ℓ₁} {≈₂ : Rel B ℓ₂}
         ; isEquivalence₁ = IB.Eq₂.isEquivalence
         ; isEquivalence₂ = IB.Eq₁.isEquivalence
         }
-      ; injective = injective IB.bijective IB.Eq₂.sym IB.Eq₂.trans IB.cong
+      ; injective = injective IB.bijective IB.Eq₁.refl IB.Eq₂.sym IB.Eq₂.trans IB.cong
       }
-    ; surjective = surjective {≈₂ = ≈₂} IB.bijective
+    ; surjective = surjective IB.bijective IB.Eq₁.refl IB.Eq₂.trans
     }
 
 module _ {≈₁ : Rel A ℓ₁} {f : A → B} (isBij : IsBijection ≈₁ _≡_ f) where
@@ -86,35 +96,33 @@ module _ {≈₁ : Rel A ℓ₁} {f : A → B} (isBij : IsBijection ≈₁ _≡_
   isBijection-≡ = isBijection isBij (IB.Eq₁.reflexive ∘ cong _)
     where module IB = IsBijection isBij
 
-module _ {≈₁ : Rel A ℓ₁} {≈₂ : Rel B ℓ₂}
-         {f : A → B} {f⁻¹ : B → A}
-         where
+module _ {≈₁ : Rel A ℓ₁} {≈₂ : Rel B ℓ₂} {f : A → B} {f⁻¹ : B → A} where
 
   isCongruent : IsCongruent ≈₁ ≈₂ f → Congruent ≈₂ ≈₁ f⁻¹ → IsCongruent ≈₂ ≈₁ f⁻¹
   isCongruent ic cg = record
     { cong           = cg
-    ; isEquivalence₁ = IC.isEquivalence₂
-    ; isEquivalence₂ = IC.isEquivalence₁
-    } where module IC = IsCongruent ic
+    ; isEquivalence₁ = F.isEquivalence₂
+    ; isEquivalence₂ = F.isEquivalence₁
+    } where module F = IsCongruent ic
 
   isLeftInverse : IsRightInverse ≈₁ ≈₂ f f⁻¹ → IsLeftInverse ≈₂ ≈₁ f⁻¹ f
   isLeftInverse inv = record
     { isCongruent = isCongruent F.isCongruent F.from-cong
-    ; from-cong   = F.cong₁
-    ; inverseˡ    = inverseˡ ≈₁ ≈₂ f {f⁻¹} F.inverseʳ
+    ; from-cong   = F.to-cong
+    ; inverseˡ    = inverseˡ ≈₁ ≈₂ F.inverseʳ
     } where module F = IsRightInverse inv
 
   isRightInverse : IsLeftInverse ≈₁ ≈₂ f f⁻¹ → IsRightInverse ≈₂ ≈₁ f⁻¹ f
   isRightInverse inv = record
     { isCongruent = isCongruent F.isCongruent F.from-cong
     ; from-cong   = F.to-cong
-    ; inverseʳ    = inverseʳ ≈₁ ≈₂ f {f⁻¹} F.inverseˡ
+    ; inverseʳ    = inverseʳ ≈₁ ≈₂ F.inverseˡ
     } where module F = IsLeftInverse inv
 
   isInverse : IsInverse ≈₁ ≈₂ f f⁻¹ → IsInverse ≈₂ ≈₁ f⁻¹ f
   isInverse f-inv = record
     { isLeftInverse = isLeftInverse F.isRightInverse
-    ; inverseʳ      = inverseʳ ≈₁ ≈₂ f F.inverseˡ
+    ; inverseʳ      = inverseʳ ≈₁ ≈₂ F.inverseˡ
     } where module F = IsInverse f-inv
 
 ------------------------------------------------------------------------
@@ -132,7 +140,7 @@ module _ {R : Setoid a ℓ₁} {S : Setoid b ℓ₂} (bij : Bijection R S) where
   bijection cong = record
     { to        = from
     ; cong      = cong
-    ; bijective = bijective IB.bijective IB.Eq₂.sym IB.Eq₂.trans IB.cong
+    ; bijective = bijective IB.bijective IB.Eq₁.refl IB.Eq₂.sym IB.Eq₂.trans IB.cong
     }
 
 -- We can always flip a bijection if using the equality over the
diff --git a/src/Function/Definitions.agda b/src/Function/Definitions.agda
index ac805d9472..225dc53998 100644
--- a/src/Function/Definitions.agda
+++ b/src/Function/Definitions.agda
@@ -8,40 +8,57 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+module Function.Definitions where
 
-module Function.Definitions
-  {a b ℓ₁ ℓ₂} {A : Set a} {B : Set b}
+open import Data.Product.Base using (∃; _×_)
+open import Level using (Level)
+open import Relation.Binary.Core using (Rel)
+
+private
+  variable
+    a ℓ₁ ℓ₂ : Level
+    A B : Set a
+
+------------------------------------------------------------------------
+-- Basic definitions
+
+module _
   (_≈₁_ : Rel A ℓ₁) -- Equality over the domain
   (_≈₂_ : Rel B ℓ₂) -- Equality over the codomain
   where
 
-open import Data.Product using (∃; _×_)
-import Function.Definitions.Core1 as Core₁
-import Function.Definitions.Core2 as Core₂
-open import Function.Base
-open import Level using (_⊔_)
+  Congruent : (A → B) → Set _
+  Congruent f = ∀ {x y} → x ≈₁ y → f x ≈₂ f y
 
-------------------------------------------------------------------------
--- Definitions
+  Injective : (A → B) → Set _
+  Injective f = ∀ {x y} → f x ≈₂ f y → x ≈₁ y
 
-Congruent : (A → B) → Set (a ⊔ ℓ₁ ⊔ ℓ₂)
-Congruent f = ∀ {x y} → x ≈₁ y →  f x ≈₂ f y
+  Surjective : (A → B) → Set _
+  Surjective f = ∀ y → ∃ λ x → ∀ {z} → z ≈₁ x → f z ≈₂ y
 
-Injective : (A → B) → Set (a ⊔ ℓ₁ ⊔ ℓ₂)
-Injective f = ∀ {x y} → f x ≈₂ f y → x ≈₁ y
+  Bijective : (A → B) → Set _
+  Bijective f = Injective f × Surjective f
 
-open Core₂ {A = A} _≈₂_ public
-  using (Surjective)
+  Inverseˡ : (A → B) → (B → A) → Set _
+  Inverseˡ f g = ∀ {x y} → y ≈₁ g x → f y ≈₂ x
+
+  Inverseʳ : (A → B) → (B → A) → Set _
+  Inverseʳ f g = ∀ {x y} → y ≈₂ f x → g y ≈₁ x
+
+  Inverseᵇ : (A → B) → (B → A) → Set _
+  Inverseᵇ f g = Inverseˡ f g × Inverseʳ f g
+
+------------------------------------------------------------------------
+-- Strict definitions
 
-Bijective : (A → B) → Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)
-Bijective f = Injective f × Surjective f
+-- These are often easier to use once but much harder to compose and
+-- reason about.
 
-open Core₂ {A = A} _≈₂_ public
-  using (Inverseˡ)
+StrictlySurjective : Rel B ℓ₂ → (A → B) → Set _
+StrictlySurjective _≈₂_ f = ∀ y → ∃ λ x → f x ≈₂ y
 
-open Core₁ {B = B} _≈₁_ public
-  using (Inverseʳ)
+StrictlyInverseˡ : Rel B ℓ₂ → (A → B) → (B → A) → Set _
+StrictlyInverseˡ _≈₂_ f g = ∀ y → f (g y) ≈₂ y
 
-Inverseᵇ : (A → B) → (B → A) → Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)
-Inverseᵇ f g = Inverseˡ f g × Inverseʳ f g
+StrictlyInverseʳ : Rel A ℓ₁ → (A → B) → (B → A) → Set _
+StrictlyInverseʳ _≈₁_ f g = ∀ x → g (f x) ≈₁ x
diff --git a/src/Function/Definitions/Core1.agda b/src/Function/Definitions/Core1.agda
deleted file mode 100644
index c81e841af9..0000000000
--- a/src/Function/Definitions/Core1.agda
+++ /dev/null
@@ -1,25 +0,0 @@
-------------------------------------------------------------------------
--- The Agda standard library
---
--- Definitions for types of functions that only require an equality
--- relation over the domain.
-------------------------------------------------------------------------
-
--- The contents of this file should usually be accessed from `Function`.
-
-{-# OPTIONS --cubical-compatible --safe #-}
-
-open import Relation.Binary
-
-module Function.Definitions.Core1
-  {a b ℓ₁} {A : Set a} {B : Set b} (_≈₁_ : Rel A ℓ₁)
-  where
-
-open import Level using (_⊔_)
-
-------------------------------------------------------------------------
--- Definitions
-
--- (Note the name `RightInverse` is used for the bundle)
-Inverseʳ : (A → B) → (B → A) → Set (a ⊔ ℓ₁)
-Inverseʳ f g = ∀ x → g (f x) ≈₁ x
diff --git a/src/Function/Definitions/Core2.agda b/src/Function/Definitions/Core2.agda
deleted file mode 100644
index 313f331063..0000000000
--- a/src/Function/Definitions/Core2.agda
+++ /dev/null
@@ -1,29 +0,0 @@
-------------------------------------------------------------------------
--- The Agda standard library
---
--- Definitions for types of functions that only require an equality
--- relation over the co-domain.
-------------------------------------------------------------------------
-
--- The contents of this file should usually be accessed from `Function`.
-
-{-# OPTIONS --cubical-compatible --safe #-}
-
-open import Relation.Binary
-
-module Function.Definitions.Core2
-  {a b ℓ₂} {A : Set a} {B : Set b} (_≈₂_ : Rel B ℓ₂)
-  where
-
-open import Data.Product using (∃)
-open import Level using (Level; _⊔_)
-
-------------------------------------------------------------------------
--- Definitions
-
-Surjective : (A → B) → Set (a ⊔ b ⊔ ℓ₂)
-Surjective f = ∀ y → ∃ λ x → f x ≈₂ y
-
--- (Note the name `LeftInverse` is used for the bundle)
-Inverseˡ : (A → B) → (B → A) → Set (b ⊔ ℓ₂)
-Inverseˡ f g = ∀ x → f (g x) ≈₂ x
diff --git a/src/Function/Dependent/Bundles.agda b/src/Function/Dependent/Bundles.agda
new file mode 100644
index 0000000000..177e2f9b9f
--- /dev/null
+++ b/src/Function/Dependent/Bundles.agda
@@ -0,0 +1,50 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Bundles for types of functions
+------------------------------------------------------------------------
+
+-- The contents of this file should usually be accessed from `Function`.
+
+-- Note that these bundles differ from those found elsewhere in other
+-- library hierarchies as they take Setoids as parameters. This is
+-- because a function is of no use without knowing what its domain and
+-- codomain is, as well which equalities are being considered over them.
+-- One consequence of this is that they are not built from the
+-- definitions found in `Function.Structures` as is usually the case in
+-- other library hierarchies, as this would duplicate the equality
+-- axioms.
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Function.Dependent.Bundles where
+
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Indexed.Heterogeneous using (IndexedSetoid)
+
+private
+  variable
+    a b ℓ₁ ℓ₂ : Level
+
+------------------------------------------------------------------------
+-- Setoid bundles
+------------------------------------------------------------------------
+
+module _
+  (From : Setoid a ℓ₁)
+  (To : IndexedSetoid (Setoid.Carrier From) b ℓ₂)
+  where
+
+  open Setoid From using () renaming (Carrier to A; _≈_ to _≈₁_)
+  open IndexedSetoid To using () renaming (Carrier to B; _≈_ to _≈₂_)
+
+------------------------------------------------------------------------
+-- Bundles with one element
+
+  -- Called `Func` rather than `Function` in order to avoid clashing
+  -- with the top-level module.
+  record Func : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
+    field
+      to   : (x : A) → B x
+      cong : ∀ {x y} → x ≈₁ y → to x ≈₂ to y
diff --git a/src/Function/Endo/Propositional.agda b/src/Function/Endo/Propositional.agda
new file mode 100644
index 0000000000..4d1bb21cbb
--- /dev/null
+++ b/src/Function/Endo/Propositional.agda
@@ -0,0 +1,121 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Endomorphisms on a Set
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Function.Endo.Propositional {a} (A : Set a) where
+
+open import Algebra using (Semigroup; Magma; RawMagma; Monoid; RawMonoid)
+open import Algebra.Core
+import Algebra.Definitions.RawMonoid as RawMonoidDefinitions
+import Algebra.Properties.Monoid.Mult as MonoidMultProperties
+open import Algebra.Structures using (IsMagma; IsSemigroup; IsMonoid)
+open import Algebra.Morphism
+  using (module Definitions; IsMagmaHomomorphism; IsMonoidHomomorphism)
+open Definitions using (Homomorphic₂)
+
+open import Data.Nat.Base using (ℕ; zero; suc; _+_; +-rawMagma; +-0-rawMonoid)
+open import Data.Nat.Properties using (+-0-monoid; +-semigroup)
+open import Data.Product.Base using (_,_)
+
+open import Function.Base using (id; _∘′_; _∋_; flip)
+open import Function.Bundles using (Func; _⟶ₛ_; _⟨$⟩_)
+open import Relation.Binary.Core using (_Preserves_⟶_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong; cong₂)
+import Relation.Binary.PropositionalEquality.Properties as ≡
+
+import Function.Endo.Setoid (≡.setoid A) as Setoid
+
+------------------------------------------------------------------------
+-- Basic type and raw bundles
+
+Endo : Set a
+Endo = A → A
+
+private
+
+  _∘_ : Op₂ Endo
+  _∘_ = _∘′_
+
+  ∘-id-rawMonoid : RawMonoid a a
+  ∘-id-rawMonoid = record { Carrier = Endo; _≈_ = _≡_ ; _∙_ = _∘_ ; ε = id }
+
+  open RawMonoid ∘-id-rawMonoid
+    using ()
+    renaming (rawMagma to ∘-rawMagma)
+
+
+------------------------------------------------------------------------
+-- Conversion back and forth with the Setoid-based notion of Endomorphism
+
+fromSetoidEndo : Setoid.Endo → Endo
+fromSetoidEndo = _⟨$⟩_
+
+toSetoidEndo : Endo → Setoid.Endo
+toSetoidEndo f = record
+  { to = f
+  ; cong  = cong f
+  }
+
+------------------------------------------------------------------------
+-- Structures
+
+∘-isMagma : IsMagma _≡_ _∘_
+∘-isMagma = record
+  { isEquivalence = ≡.isEquivalence
+  ; ∙-cong        = cong₂ _∘_
+  }
+
+∘-magma : Magma _ _
+∘-magma = record { isMagma = ∘-isMagma }
+
+∘-isSemigroup : IsSemigroup _≡_ _∘_
+∘-isSemigroup = record
+  { isMagma = ∘-isMagma
+  ; assoc   = λ _ _ _ → refl
+  }
+
+∘-semigroup : Semigroup _ _
+∘-semigroup = record { isSemigroup = ∘-isSemigroup }
+
+∘-id-isMonoid : IsMonoid _≡_ _∘_ id
+∘-id-isMonoid = record
+  { isSemigroup = ∘-isSemigroup
+  ; identity    = (λ _ → refl) , (λ _ → refl)
+  }
+
+∘-id-monoid : Monoid _ _
+∘-id-monoid = record { isMonoid = ∘-id-isMonoid }
+
+------------------------------------------------------------------------
+-- n-th iterated composition
+
+infixr 8 _^_
+
+_^_ : Endo → ℕ → Endo
+_^_ = flip _×_ where open RawMonoidDefinitions ∘-id-rawMonoid using (_×_)
+
+------------------------------------------------------------------------
+-- Homomorphism
+
+module _ (f : Endo) where
+
+  open MonoidMultProperties ∘-id-monoid using (×-homo-+)
+
+  ^-homo : Homomorphic₂ ℕ Endo _≡_ (f ^_) _+_ _∘_
+  ^-homo = ×-homo-+ f
+
+  ^-isMagmaHomomorphism : IsMagmaHomomorphism +-rawMagma ∘-rawMagma (f ^_)
+  ^-isMagmaHomomorphism = record
+    { isRelHomomorphism = record { cong = cong (f ^_) }
+    ; homo = ^-homo
+    }
+
+  ^-isMonoidHomomorphism : IsMonoidHomomorphism +-0-rawMonoid ∘-id-rawMonoid (f ^_)
+  ^-isMonoidHomomorphism = record
+    { isMagmaHomomorphism = ^-isMagmaHomomorphism
+    ; ε-homo = refl
+    }
diff --git a/src/Function/Endo/Setoid.agda b/src/Function/Endo/Setoid.agda
new file mode 100644
index 0000000000..583ba2f4c6
--- /dev/null
+++ b/src/Function/Endo/Setoid.agda
@@ -0,0 +1,117 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Endomorphisms on a Setoid
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Bundles using (Setoid)
+
+module Function.Endo.Setoid {c e} (S : Setoid c e) where
+
+open import Agda.Builtin.Equality using (_≡_)
+
+open import Algebra using (Semigroup; Magma; RawMagma; Monoid; RawMonoid)
+import Algebra.Definitions.RawMonoid as RawMonoidDefinitions
+import Algebra.Properties.Monoid.Mult as MonoidMultProperties
+open import Algebra.Structures using (IsMagma; IsSemigroup; IsMonoid)
+open import Algebra.Morphism
+  using (module Definitions; IsMagmaHomomorphism; IsMonoidHomomorphism)
+open Definitions using (Homomorphic₂)
+open import Data.Nat.Base using (ℕ; zero; suc; _+_; +-rawMagma; +-0-rawMonoid)
+open import Data.Nat.Properties using (+-semigroup; +-identityʳ)
+open import Data.Product.Base using (_,_)
+open import Function.Bundles using (Func; _⟶ₛ_; _⟨$⟩_)
+open import Function.Construct.Identity using () renaming (function to identity)
+open import Function.Construct.Composition using () renaming (function to _∘_)
+open import Function.Relation.Binary.Setoid.Equality as Eq using (_⇨_)
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Core using (_Preserves_⟶_)
+
+private
+  open module E = Setoid (S ⇨ S) hiding (refl)
+  module S = Setoid S
+  open Func using (cong)
+
+
+------------------------------------------------------------------------
+-- Basic type and raw bundles
+
+Endo : Set _
+Endo = S ⟶ₛ S
+
+private
+  id : Endo
+  id = identity S
+
+  ∘-id-rawMonoid : RawMonoid (c ⊔ e) (c ⊔ e)
+  ∘-id-rawMonoid = record { Carrier = Endo; _≈_ = _≈_ ; _∙_ = _∘_ ; ε = id }
+
+  open RawMonoid ∘-id-rawMonoid
+    using ()
+    renaming (rawMagma to ∘-rawMagma)
+
+--------------------------------------------------------------
+-- Structures
+
+∘-isMagma : IsMagma _≈_ _∘_
+∘-isMagma = record
+  { isEquivalence = isEquivalence
+  ; ∙-cong        = λ {_} {_} {_} {k} f≈g h≈k x → S.trans (h≈k _) (cong k (f≈g x))
+  }
+
+∘-magma : Magma (c ⊔ e) (c ⊔ e)
+∘-magma = record { isMagma = ∘-isMagma }
+
+∘-isSemigroup : IsSemigroup _≈_ _∘_
+∘-isSemigroup = record
+  { isMagma = ∘-isMagma
+  ; assoc   = λ _ _ _ _ → S.refl
+  }
+
+∘-semigroup : Semigroup (c ⊔ e) (c ⊔ e)
+∘-semigroup = record { isSemigroup = ∘-isSemigroup }
+
+∘-id-isMonoid : IsMonoid _≈_ _∘_ id
+∘-id-isMonoid = record
+  { isSemigroup = ∘-isSemigroup
+  ; identity    = (λ _ _ → S.refl) , (λ _ _ → S.refl)
+  }
+
+∘-id-monoid : Monoid (c ⊔ e) (c ⊔ e)
+∘-id-monoid = record { isMonoid = ∘-id-isMonoid }
+
+------------------------------------------------------------------------
+-- -- n-th iterated composition
+
+infixr 8 _^_
+
+_^_ : Endo → ℕ → Endo
+f ^ n = n × f where open RawMonoidDefinitions ∘-id-rawMonoid using (_×_)
+
+------------------------------------------------------------------------
+-- Homomorphism
+
+module _ (f : Endo) where
+
+  open MonoidMultProperties ∘-id-monoid using (×-congˡ; ×-homo-+)
+
+  ^-cong₂ : (f ^_) Preserves _≡_ ⟶ _≈_
+  ^-cong₂ = ×-congˡ {f}
+
+  ^-homo : Homomorphic₂ ℕ Endo _≈_ (f ^_) _+_ _∘_
+  ^-homo = ×-homo-+ f
+
+  ^-isMagmaHomomorphism : IsMagmaHomomorphism +-rawMagma ∘-rawMagma (f ^_)
+  ^-isMagmaHomomorphism = record
+    { isRelHomomorphism = record { cong = ^-cong₂ }
+    ; homo = ^-homo
+    }
+
+  ^-isMonoidHomomorphism : IsMonoidHomomorphism +-0-rawMonoid ∘-id-rawMonoid (f ^_)
+  ^-isMonoidHomomorphism = record
+    { isMagmaHomomorphism = ^-isMagmaHomomorphism
+    ; ε-homo = λ _ → S.refl
+    }
+
diff --git a/src/Function/Endomorphism/Propositional.agda b/src/Function/Endomorphism/Propositional.agda
index 32a5522318..7f9d99a155 100644
--- a/src/Function/Endomorphism/Propositional.agda
+++ b/src/Function/Endomorphism/Propositional.agda
@@ -1,29 +1,32 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Endomorphisms on a Set
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
--- Disabled to prevent warnings from deprecated names
-{-# OPTIONS --warn=noUserWarning #-}
-
 module Function.Endomorphism.Propositional {a} (A : Set a) where
 
+{-# WARNING_ON_IMPORT
+"Function.Endomorphism.Propositional was deprecated in v2.1.
+Use Function.Endo.Propositional instead."
+#-}
+
 open import Algebra
 open import Algebra.Morphism; open Definitions
 
 open import Data.Nat.Base using (ℕ; zero; suc; _+_)
 open import Data.Nat.Properties using (+-0-monoid; +-semigroup)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 
-open import Function
+open import Function.Base using (id; _∘′_; _∋_)
 open import Function.Equality using (_⟨$⟩_)
-open import Relation.Binary using (_Preserves_⟶_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; refl)
+open import Relation.Binary.Core using (_Preserves_⟶_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong; cong₂)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
-import Function.Endomorphism.Setoid (P.setoid A) as Setoid
+import Function.Endomorphism.Setoid (≡.setoid A) as Setoid
 
 Endo : Set a
 Endo = A → A
@@ -37,27 +40,29 @@ fromSetoidEndo = _⟨$⟩_
 toSetoidEndo : Endo → Setoid.Endo
 toSetoidEndo f = record
   { _⟨$⟩_ = f
-  ; cong  = P.cong f
+  ; cong  = cong f
   }
 
 ------------------------------------------------------------------------
 -- N-th composition
 
+infixr 8 _^_
+
 _^_ : Endo → ℕ → Endo
 f ^ zero  = id
 f ^ suc n = f ∘′ (f ^ n)
 
 ^-homo : ∀ f → Homomorphic₂ ℕ Endo _≡_ (f ^_) _+_ _∘′_
 ^-homo f zero    n = refl
-^-homo f (suc m) n = P.cong (f ∘′_) (^-homo f m n)
+^-homo f (suc m) n = cong (f ∘′_) (^-homo f m n)
 
 ------------------------------------------------------------------------
 -- Structures
 
 ∘-isMagma : IsMagma _≡_ (Op₂ Endo ∋ _∘′_)
 ∘-isMagma = record
-  { isEquivalence = P.isEquivalence
-  ; ∙-cong        = P.cong₂ _∘′_
+  { isEquivalence = ≡.isEquivalence
+  ; ∙-cong        = cong₂ _∘′_
   }
 
 ∘-magma : Magma _ _
@@ -86,7 +91,7 @@ f ^ suc n = f ∘′ (f ^ n)
 
 ^-isSemigroupMorphism : ∀ f → IsSemigroupMorphism +-semigroup ∘-semigroup (f ^_)
 ^-isSemigroupMorphism f = record
-  { ⟦⟧-cong = P.cong (f ^_)
+  { ⟦⟧-cong = cong (f ^_)
   ; ∙-homo  = ^-homo f
   }
 
diff --git a/src/Function/Endomorphism/Setoid.agda b/src/Function/Endomorphism/Setoid.agda
index 9c3d18e7f4..5d4993ecf6 100644
--- a/src/Function/Endomorphism/Setoid.agda
+++ b/src/Function/Endomorphism/Setoid.agda
@@ -1,27 +1,30 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Endomorphisms on a Setoid
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
--- Disabled to prevent warnings from deprecated names
-{-# OPTIONS --warn=noUserWarning #-}
-
-open import Relation.Binary
+open import Relation.Binary.Core using (_Preserves_⟶_)
+open import Relation.Binary.Bundles using (Setoid)
 
 module Function.Endomorphism.Setoid {c e} (S : Setoid c e) where
 
+{-# WARNING_ON_IMPORT
+"Function.Endomorphism.Setoid was deprecated in v2.1.
+Use Function.Endo.Setoid instead."
+#-}
+
 open import Agda.Builtin.Equality
 
 open import Algebra
 open import Algebra.Structures
 open import Algebra.Morphism; open Definitions
-open import Function.Equality
+open import Function.Equality using (setoid; _⟶_; id; _∘_; cong)
 open import Data.Nat.Base using (ℕ; _+_); open ℕ
 open import Data.Nat.Properties
-open import Data.Product
+open import Data.Product.Base using (_,_)
 
 import Relation.Binary.Indexed.Heterogeneous.Construct.Trivial as Trivial
 
@@ -35,6 +38,8 @@ private
 Endo : Set _
 Endo = S ⟶ S
 
+infixr 8 _^_
+
 _^_ : Endo → ℕ → Endo
 f ^ zero  = id
 f ^ suc n = f ∘ (f ^ n)
diff --git a/src/Function/Equality.agda b/src/Function/Equality.agda
index 97bb752ceb..4748834a83 100644
--- a/src/Function/Equality.agda
+++ b/src/Function/Equality.agda
@@ -1,25 +1,27 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Function setoids and related constructions
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
--- Note: use of the standard function hierarchy is encouraged. The
--- module `Function` re-exports `Congruent`, `IsBijection` and
--- `Bijection`. The alternative definitions found in this file will
--- eventually be deprecated.
-
 module Function.Equality where
 
+{-# WARNING_ON_IMPORT
+"Function.Equality was deprecated in v2.0.
+Use the standard function hierarchy in Function/Function.Bundles instead."
+#-}
+
 import Function.Base as Fun
-open import Level
-open import Relation.Binary using (Setoid)
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Bundles using (Setoid)
 open import Relation.Binary.Indexed.Heterogeneous
   using (IndexedSetoid; _=[_]⇒_)
 import Relation.Binary.Indexed.Heterogeneous.Construct.Trivial
   as Trivial
+import Relation.Binary.PropositionalEquality.Core as ≡
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 ------------------------------------------------------------------------
 -- Functions which preserve equality
@@ -32,6 +34,10 @@ record Π {f₁ f₂ t₁ t₂}
   field
     _⟨$⟩_ : (x : Setoid.Carrier From) → IndexedSetoid.Carrier To x
     cong  : Setoid._≈_ From =[ _⟨$⟩_ ]⇒ IndexedSetoid._≈_ To
+{-# WARNING_ON_USAGE Π
+"Warning: Π was deprecated in v2.0.
+Please use Function.Dependent.Bundles.Func instead."
+#-}
 
 open Π public
 
@@ -39,12 +45,20 @@ infixr 0 _⟶_
 
 _⟶_ : ∀ {f₁ f₂ t₁ t₂} → Setoid f₁ f₂ → Setoid t₁ t₂ → Set _
 From ⟶ To = Π From (Trivial.indexedSetoid To)
+{-# WARNING_ON_USAGE _⟶_
+"Warning: _⟶_ was deprecated in v2.0.
+Please use Function.(Bundles.)Func instead."
+#-}
 
 ------------------------------------------------------------------------
 -- Identity and composition.
 
 id : ∀ {a₁ a₂} {A : Setoid a₁ a₂} → A ⟶ A
 id = record { _⟨$⟩_ = Fun.id; cong = Fun.id }
+{-# WARNING_ON_USAGE id
+"Warning: id was deprecated in v2.0.
+Please use Function.Construct.Identity.function instead."
+#-}
 
 infixr 9 _∘_
 
@@ -56,6 +70,10 @@ f ∘ g = record
   { _⟨$⟩_ = Fun._∘_ (_⟨$⟩_ f) (_⟨$⟩_ g)
   ; cong  = Fun._∘_ (cong  f) (cong  g)
   }
+{-# WARNING_ON_USAGE _∘_
+"Warning: _∘_ was deprecated in v2.0.
+Please use Function.Construct.Composition.function instead."
+#-}
 
 -- Constant equality-preserving function.
 
@@ -66,6 +84,10 @@ const {B = B} b = record
   { _⟨$⟩_ = Fun.const b
   ; cong  = Fun.const (Setoid.refl B)
   }
+{-# WARNING_ON_USAGE const
+"Warning: const was deprecated in v2.0.
+Please use Function.Construct.Constant.function instead."
+#-}
 
 ------------------------------------------------------------------------
 -- Function setoids
@@ -122,3 +144,10 @@ flip {B = B} f = record
     ; cong  = λ a₁≈a₂ → cong f a₁≈a₂ (Setoid.refl B) }
   ; cong  = λ b₁≈b₂ a₁≈a₂ → cong f a₁≈a₂ b₁≈b₂
   }
+
+→-to-⟶ : ∀ {a b ℓ} {A : Set a} {B : Setoid b ℓ} →
+         (A → Setoid.Carrier B) → ≡.setoid A ⟶ B
+→-to-⟶ {B = B} to = record
+  { _⟨$⟩_ = to
+  ; cong = λ { ≡.refl → Setoid.refl B }
+  }
diff --git a/src/Function/Equivalence.agda b/src/Function/Equivalence.agda
index 7bbbade93c..9556023b56 100644
--- a/src/Function/Equivalence.agda
+++ b/src/Function/Equivalence.agda
@@ -1,24 +1,26 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Equivalence (coinhabitance)
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
+{-# OPTIONS --warn=noUserWarning #-}
 
 module Function.Equivalence where
 
--- Note: use of the standard function hierarchy is encouraged. The
--- module `Function` re-exports `Congruent` and `IsCongruent`.
--- The alternative definitions found in this file will eventually be
--- deprecated.
+{-# WARNING_ON_IMPORT
+"Function.Equivalence was deprecated in v2.0.
+Use the standard function hierarchy in Function/Function.Bundles instead."
+#-}
 
 open import Function.Base using (flip)
 open import Function.Equality as F
-  using (_⟶_; _⟨$⟩_) renaming (_∘_ to _⟪∘⟫_)
+  using (_⟶_; _⟨$⟩_; →-to-⟶) renaming (_∘_ to _⟪∘⟫_)
 open import Level
-open import Relation.Binary hiding (_⇔_)
-import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (Reflexive; TransFlip; Sym)
+import Relation.Binary.PropositionalEquality as ≡
 
 ------------------------------------------------------------------------
 -- Setoid equivalence
@@ -29,6 +31,10 @@ record Equivalence {f₁ f₂ t₁ t₂}
   field
     to   : From ⟶ To
     from : To ⟶ From
+{-# WARNING_ON_USAGE Equivalence
+"Warning: Equivalence was deprecated in v2.0.
+Please use Function.(Bundles.)Equivalence instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all equivalences between two sets (i.e. equivalences
@@ -37,14 +43,22 @@ record Equivalence {f₁ f₂ t₁ t₂}
 infix 3 _⇔_
 
 _⇔_ : ∀ {f t} → Set f → Set t → Set _
-From ⇔ To = Equivalence (P.setoid From) (P.setoid To)
+From ⇔ To = Equivalence (≡.setoid From) (≡.setoid To)
+{-# WARNING_ON_USAGE _⇔_
+"Warning: _⇔_ was deprecated in v2.0.
+Please use Function.(Bundles.)_⇔_ instead."
+#-}
 
 equivalence : ∀ {f t} {From : Set f} {To : Set t} →
               (From → To) → (To → From) → From ⇔ To
 equivalence to from = record
-  { to   = P.→-to-⟶ to
-  ; from = P.→-to-⟶ from
+  { to   = →-to-⟶ to
+  ; from = →-to-⟶ from
   }
+{-# WARNING_ON_USAGE equivalence
+"Warning: equivalence was deprecated in v2.0.
+Please use Function.Properties.Equivalence.mkEquivalence instead."
+#-}
 
 ------------------------------------------------------------------------
 -- Equivalence is an equivalence relation
@@ -56,6 +70,11 @@ id {x = S} = record
   { to   = F.id
   ; from = F.id
   }
+{-# WARNING_ON_USAGE id
+"Warning: id was deprecated in v2.0.
+Please use Function.Properties.Equivalence.refl or
+Function.Construct.Identity.equivalence instead."
+#-}
 
 infixr 9 _∘_
 
@@ -67,6 +86,11 @@ f ∘ g = record
   { to   = to   f ⟪∘⟫ to   g
   ; from = from g ⟪∘⟫ from f
   } where open Equivalence
+{-# WARNING_ON_USAGE _∘_
+"Warning: _∘_ was deprecated in v2.0.
+Please use Function.Properties.Equivalence.trans or
+Function.Construct.Composition.equivalence instead."
+#-}
 
 -- Symmetry.
 
@@ -77,6 +101,11 @@ sym eq = record
   { from       = to
   ; to         = from
   } where open Equivalence eq
+{-# WARNING_ON_USAGE sym
+"Warning: sym was deprecated in v2.0.
+Please use Function.Properties.Equivalence.sym or
+Function.Construct.Symmetry.equivalence instead."
+#-}
 
 -- For fixed universe levels we can construct setoids.
 
@@ -90,6 +119,10 @@ setoid s₁ s₂ = record
     ; trans = flip _∘_
     }
   }
+{-# WARNING_ON_USAGE setoid
+"Warning: setoid was deprecated in v2.0.
+Please use Function.Properties.Equivalence.setoid instead."
+#-}
 
 ⇔-setoid : (ℓ : Level) → Setoid (suc ℓ) ℓ
 ⇔-setoid ℓ = record
@@ -101,6 +134,10 @@ setoid s₁ s₂ = record
     ; trans = flip _∘_
     }
   }
+{-# WARNING_ON_USAGE ⇔-setoid
+"Warning: ⇔-setoid was deprecated in v2.0.
+Please use Function.Properties.Equivalence.⇔-setoid instead."
+#-}
 
 ------------------------------------------------------------------------
 -- Transformations
diff --git a/src/Function/HalfAdjointEquivalence.agda b/src/Function/HalfAdjointEquivalence.agda
index f600dfe759..b78c1bc139 100644
--- a/src/Function/HalfAdjointEquivalence.agda
+++ b/src/Function/HalfAdjointEquivalence.agda
@@ -1,13 +1,19 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Half adjoint equivalences
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
+{-# OPTIONS --warn=noUserWarning #-}
 
 module Function.HalfAdjointEquivalence where
 
+{-# WARNING_ON_IMPORT
+"Function.HalfAdjointEquivalence was deprecated in v2.0.
+Use Function.Properties.Inverse.HalfAdjointEquivalence instead."
+#-}
+
 open import Function.Base
 open import Function.Equality using (_⟨$⟩_)
 open import Function.Inverse as Inv using (_↔_; module Inverse)
@@ -16,6 +22,8 @@ open import Relation.Binary.PropositionalEquality
 
 -- Half adjoint equivalences (see the HoTT book).
 
+infix 4 _≃_
+
 record _≃_ {a b} (A : Set a) (B : Set b) : Set (a ⊔ b) where
   field
     to               : A → B
diff --git a/src/Function/Identity/Categorical.agda b/src/Function/Identity/Categorical.agda
new file mode 100644
index 0000000000..7fbdec019e
--- /dev/null
+++ b/src/Function/Identity/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Function.Identity.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Function.Identity.Categorical where
+
+open import Function.Identity.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Function.Identity.Categorical was deprecated in v2.0.
+Use Function.Identity.Effectful instead."
+#-}
diff --git a/src/Function/Indexed/Bundles.agda b/src/Function/Indexed/Bundles.agda
new file mode 100644
index 0000000000..682f19e634
--- /dev/null
+++ b/src/Function/Indexed/Bundles.agda
@@ -0,0 +1,52 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Operations on Relations for Indexed sets
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Function.Indexed.Bundles where
+
+open import Relation.Unary using (Pred)
+open import Function.Bundles using (_⟶_; _↣_; _↠_; _⤖_; _⇔_; _↩_; _↪_; _↩↪_; _↔_)
+open import Relation.Binary.Core hiding (_⇔_)
+open import Level using (Level)
+
+private
+  variable
+    a b i : Level
+    I : Set i
+
+------------------------------------------------------------------------
+-- Bundles specialised for lifting relations to indexed sets
+------------------------------------------------------------------------
+
+infix 3 _⟶ᵢ_ _↣ᵢ_ _↠ᵢ_ _⤖ᵢ_ _⇔ᵢ_ _↩ᵢ_ _↪ᵢ_ _↩↪ᵢ_ _↔ᵢ_
+
+_⟶ᵢ_ : Pred I a → Pred I b → Set _
+A ⟶ᵢ B = ∀ {i} → A i ⟶ B i
+
+_↣ᵢ_ : Pred I a → Pred I b → Set _
+A ↣ᵢ B = ∀ {i} → A i ↣ B i
+
+_↠ᵢ_ : Pred I a → Pred I b → Set _
+A ↠ᵢ B = ∀ {i} → A i ↠ B i
+
+_⤖ᵢ_ : Pred I a → Pred I b → Set _
+A ⤖ᵢ B = ∀ {i} → A i ⤖ B i
+
+_⇔ᵢ_ : Pred I a → Pred I b → Set _
+A ⇔ᵢ B = ∀ {i} → A i ⇔ B i
+
+_↩ᵢ_ : Pred I a → Pred I b → Set _
+A ↩ᵢ B = ∀ {i} → A i ↩ B i
+
+_↪ᵢ_ : Pred I a → Pred I b → Set _
+A ↪ᵢ B = ∀ {i} → A i ↪ B i
+
+_↩↪ᵢ_ : Pred I a → Pred I b → Set _
+A ↩↪ᵢ B = ∀ {i} → A i ↩↪ B i
+
+_↔ᵢ_ : Pred I a → Pred I b → Set _
+A ↔ᵢ B = ∀ {i} → A i ↔ B i
diff --git a/src/Function/Indexed/Relation/Binary/Equality.agda b/src/Function/Indexed/Relation/Binary/Equality.agda
new file mode 100644
index 0000000000..6f0bd7db8f
--- /dev/null
+++ b/src/Function/Indexed/Relation/Binary/Equality.agda
@@ -0,0 +1,27 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Function setoids and related constructions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Function.Indexed.Relation.Binary.Equality where
+
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Indexed.Heterogeneous using (IndexedSetoid)
+
+-- A variant of setoid which uses the propositional equality setoid
+-- for the domain, and a more convenient definition of _≈_.
+
+≡-setoid : ∀ {f t₁ t₂} (From : Set f) → IndexedSetoid From t₁ t₂ → Setoid _ _
+≡-setoid From To = record
+  { Carrier       = (x : From) → Carrier x
+  ; _≈_           = λ f g → ∀ x → f x ≈ g x
+  ; isEquivalence = record
+    { refl  = λ {f} x → refl
+    ; sym   = λ f∼g x → sym (f∼g x)
+    ; trans = λ f∼g g∼h x → trans (f∼g x) (g∼h x)
+    }
+  } where open IndexedSetoid To
+
diff --git a/src/Function/Injection.agda b/src/Function/Injection.agda
index bfa03a1ff1..72785584f1 100644
--- a/src/Function/Injection.agda
+++ b/src/Function/Injection.agda
@@ -1,24 +1,25 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Injections
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
-
--- Note: use of the standard function hierarchy is encouraged. The
--- module `Function` re-exports `Injective`, `IsInjection` and
--- `Injection`. The alternative definitions found in this file will
--- eventually be deprecated.
+{-# OPTIONS --warn=noUserWarning #-}
 
 module Function.Injection where
 
-open import Function as Fun using () renaming (_∘_ to _⟨∘⟩_)
+{-# WARNING_ON_IMPORT
+"Function.Injection was deprecated in v2.0.
+Use the standard function hierarchy in Function/Function.Bundles instead."
+#-}
+
+open import Function.Base as Fun using () renaming (_∘_ to _⟨∘⟩_)
 open import Level
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
 open import Function.Equality as F
   using (_⟶_; _⟨$⟩_ ; Π) renaming (_∘_ to _⟪∘⟫_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)
 
 ------------------------------------------------------------------------
 -- Injective functions
@@ -29,6 +30,10 @@ Injective {A = A} {B} f = ∀ {x y} → f ⟨$⟩ x ≈₂ f ⟨$⟩ y → x ≈
   where
   open Setoid A renaming (_≈_ to _≈₁_)
   open Setoid B renaming (_≈_ to _≈₂_)
+{-# WARNING_ON_USAGE Injective
+"Warning: Injective was deprecated in v2.0.
+Please use Function.(Definitions.)Injective instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all injections between two setoids
@@ -41,6 +46,10 @@ record Injection {f₁ f₂ t₁ t₂}
     injective : Injective to
 
   open Π to public
+{-# WARNING_ON_USAGE Injection
+"Warning: Injection was deprecated in v2.0.
+Please use Function.(Bundles.)Injection instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all injections from one set to another (i.e. injections
@@ -49,14 +58,25 @@ record Injection {f₁ f₂ t₁ t₂}
 infix 3 _↣_
 
 _↣_ : ∀ {f t} → Set f → Set t → Set _
-From ↣ To = Injection (P.setoid From) (P.setoid To)
+From ↣ To = Injection (≡.setoid From) (≡.setoid To)
+{-# WARNING_ON_USAGE _↣_
+"Warning: _↣_ was deprecated in v2.0.
+Please use Function.(Bundles.)_↣_ instead."
+#-}
 
 injection : ∀ {f t} {From : Set f} {To : Set t} → (to : From → To) →
             (∀ {x y} → to x ≡ to y → x ≡ y) → From ↣ To
 injection to injective = record
-  { to        = P.→-to-⟶ to
+  { to        = record
+    { _⟨$⟩_ = to
+    ; cong = ≡.cong to
+    }
   ; injective = injective
   }
+{-# WARNING_ON_USAGE injection
+"Warning: injection was deprecated in v2.0.
+Please use Function.(Bundles.)mk↣ instead."
+#-}
 
 ------------------------------------------------------------------------
 -- Identity and composition.
@@ -68,6 +88,11 @@ id = record
   { to        = F.id
   ; injective = Fun.id
   }
+{-# WARNING_ON_USAGE id
+"Warning: id was deprecated in v2.0.
+Please use Function.Properties.Injection.refl or
+Function.Construct.Identity.injection instead."
+#-}
 
 _∘_ : ∀ {f₁ f₂ m₁ m₂ t₁ t₂}
         {F : Setoid f₁ f₂} {M : Setoid m₁ m₂} {T : Setoid t₁ t₂} →
@@ -76,3 +101,8 @@ f ∘ g = record
   { to        =          to        f  ⟪∘⟫ to        g
   ; injective = (λ {_} → injective g) ⟨∘⟩ injective f
   } where open Injection
+{-# WARNING_ON_USAGE _∘_
+"Warning: _∘_ was deprecated in v2.0.
+Please use Function.Properties.Injection.trans or
+Function.Construct.Composition.injection instead."
+#-}
diff --git a/src/Function/Inverse.agda b/src/Function/Inverse.agda
index 4d0185d4b6..792382ca17 100644
--- a/src/Function/Inverse.agda
+++ b/src/Function/Inverse.agda
@@ -1,26 +1,28 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Inverses
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
-
--- Note: use of the standard function hierarchy is encouraged. The
--- module `Function` re-exports `Inverseᵇ`, `IsInverse` and
--- `Inverse`. The alternative definitions found in this file will
--- eventually be deprecated.
+{-# OPTIONS --warn=noUserWarning #-}
 
 module Function.Inverse where
 
+{-# WARNING_ON_IMPORT
+"Function.Inverse was deprecated in v2.0.
+Use the standard function hierarchy in Function/Function.Bundles instead."
+#-}
+
 open import Level
 open import Function.Base using (flip)
 open import Function.Bijection hiding (id; _∘_; bijection)
 open import Function.Equality as F
   using (_⟶_) renaming (_∘_ to _⟪∘⟫_)
 open import Function.LeftInverse as Left hiding (id; _∘_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≗_; _≡_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (Reflexive; TransFlip; Sym)
+open import Relation.Binary.PropositionalEquality as ≡ using (_≗_; _≡_)
 open import Relation.Unary using (Pred)
 
 ------------------------------------------------------------------------
@@ -33,6 +35,10 @@ record _InverseOf_ {f₁ f₂ t₁ t₂}
   field
     left-inverse-of  : from LeftInverseOf  to
     right-inverse-of : from RightInverseOf to
+{-# WARNING_ON_USAGE _InverseOf_
+"Warning: _InverseOf_ was deprecated in v2.0.
+Please use Function.(Structures.)IsInverse instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all inverses between two setoids
@@ -72,6 +78,10 @@ record Inverse {f₁ f₂ t₁ t₂}
   open Bijection bijection public
     using (equivalence; surjective; surjection; right-inverse;
            to-from; from-to)
+{-# WARNING_ON_USAGE Inverse
+"Warning: Inverse was deprecated in v2.0.
+Please use Function.(Bundles.)Inverse instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all inverses between two sets (i.e. inverses with
@@ -80,10 +90,18 @@ record Inverse {f₁ f₂ t₁ t₂}
 infix 3 _↔_ _↔̇_
 
 _↔_ : ∀ {f t} → Set f → Set t → Set _
-From ↔ To = Inverse (P.setoid From) (P.setoid To)
+From ↔ To = Inverse (≡.setoid From) (≡.setoid To)
+{-# WARNING_ON_USAGE _↔_
+"Warning: _↔_ was deprecated in v2.0.
+Please use Function.(Bundles.)_↔_ instead."
+#-}
 
 _↔̇_ : ∀ {i f t} {I : Set i} → Pred I f → Pred I t → Set _
 From ↔̇ To = ∀ {i} → From i ↔ To i
+{-# WARNING_ON_USAGE _↔̇_
+"Warning: _↔̇_ was deprecated in v2.0.
+Please use Function.Indexed.(Bundles.)_↔ᵢ_ instead."
+#-}
 
 inverse : ∀ {f t} {From : Set f} {To : Set t} →
           (to : From → To) (from : To → From) →
@@ -91,13 +109,17 @@ inverse : ∀ {f t} {From : Set f} {To : Set t} →
           (∀ x → to (from x) ≡ x) →
           From ↔ To
 inverse to from from∘to to∘from = record
-  { to   = P.→-to-⟶ to
-  ; from = P.→-to-⟶ from
+  { to   = F.→-to-⟶ to
+  ; from = F.→-to-⟶ from
   ; inverse-of = record
     { left-inverse-of  = from∘to
     ; right-inverse-of = to∘from
     }
   }
+{-# WARNING_ON_USAGE inverse
+"Warning: inverse was deprecated in v2.0.
+Please use Function.(Bundles.)mk↔ instead."
+#-}
 
 ------------------------------------------------------------------------
 -- If two setoids are in bijective correspondence, then there is an
@@ -129,6 +151,11 @@ id {x = S} = record
     ; right-inverse-of = LeftInverse.left-inverse-of id′
     }
   } where id′ = Left.id {S = S}
+{-# WARNING_ON_USAGE id
+"Warning: id was deprecated in v2.0.
+Please use either Function.Properties.Inverse.refl or
+Function.Construct.Identity.inverse instead."
+#-}
 
 -- Transitivity
 
@@ -146,6 +173,11 @@ f ∘ g = record
     ; right-inverse-of = LeftInverse.left-inverse-of (Left._∘_ (right-inverse g) (right-inverse f))
     }
   } where open Inverse
+{-# WARNING_ON_USAGE _∘_
+"Warning: _∘_ was deprecated in v2.0.
+Please use either Function.Properties.Inverse.trans or
+Function.Construct.Composition.inverse instead."
+#-}
 
 -- Symmetry.
 
@@ -159,6 +191,11 @@ sym inv = record
     ; right-inverse-of = left-inverse-of
     }
   } where open Inverse inv
+{-# WARNING_ON_USAGE sym
+"Warning: sym was deprecated in v2.0.
+Please use either Function.Properties.Inverse.sym or
+Function.Construct.Symmetry.inverse instead."
+#-}
 
 ------------------------------------------------------------------------
 -- Transformations
diff --git a/src/Function/LeftInverse.agda b/src/Function/LeftInverse.agda
index f06fbc6c8a..d9ccc9a806 100644
--- a/src/Function/LeftInverse.agda
+++ b/src/Function/LeftInverse.agda
@@ -1,27 +1,27 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Left inverses
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
-
--- Note: use of the standard function hierarchy is encouraged. The
--- module `Function` re-exports `Inverseˡ`, `IsLeftInverse` and
--- `LeftInverse`. The alternative definitions found in this file will
--- eventually be deprecated.
+{-# OPTIONS --warn=noUserWarning #-}
 
 module Function.LeftInverse where
 
-open import Data.Product
+{-# WARNING_ON_IMPORT
+"Function.LeftInverse was deprecated in v2.0.
+Use the standard function hierarchy in Function/Function.Bundles instead."
+#-}
+
 open import Level
 import Relation.Binary.Reasoning.Setoid as EqReasoning
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
 open import Function.Equality as Eq
   using (_⟶_; _⟨$⟩_) renaming (_∘_ to _⟪∘⟫_)
 open import Function.Equivalence using (Equivalence)
 open import Function.Injection using (Injective; Injection)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)
 
 ------------------------------------------------------------------------
 -- Left and right inverses.
@@ -31,11 +31,19 @@ _LeftInverseOf_ :
   To ⟶ From → From ⟶ To → Set _
 _LeftInverseOf_ {From = From} f g = ∀ x → f ⟨$⟩ (g ⟨$⟩ x) ≈ x
   where open Setoid From
+{-# WARNING_ON_USAGE _LeftInverseOf_
+"Warning: _LeftInverseOf_ was deprecated in v2.0.
+Please use Function.(Structures.)IsRightInverse instead."
+#-}
 
 _RightInverseOf_ :
   ∀ {f₁ f₂ t₁ t₂} {From : Setoid f₁ f₂} {To : Setoid t₁ t₂} →
   To ⟶ From → From ⟶ To → Set _
 f RightInverseOf g = g LeftInverseOf f
+{-# WARNING_ON_USAGE _RightInverseOf_
+"Warning: _RightInverseOf_ was deprecated in v2.0.
+Please use Function.(Structures.)IsLeftInverse instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all left inverses between two setoids.
@@ -74,12 +82,20 @@ record LeftInverse {f₁ f₂ t₁ t₂}
     from ⟨$⟩ y           ≈⟨ Eq.cong from (T.sym to-x≈y) ⟩
     from ⟨$⟩ (to ⟨$⟩ x)  ≈⟨ left-inverse-of x ⟩
     x                    ∎
+{-# WARNING_ON_USAGE LeftInverse
+"Warning: LeftInverse was deprecated in v2.0.
+Please use Function.(Bundles.)RightInverse instead."
+#-}
 
 -- The set of all right inverses between two setoids.
 
 RightInverse : ∀ {f₁ f₂ t₁ t₂}
                (From : Setoid f₁ f₂) (To : Setoid t₁ t₂) → Set _
 RightInverse From To = LeftInverse To From
+{-# WARNING_ON_USAGE RightInverse
+"Warning: RightInverse was deprecated in v2.0.
+Please use Function.(Bundles.)LeftInverse instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all left inverses from one set to another (i.e. left
@@ -90,17 +106,25 @@ RightInverse From To = LeftInverse To From
 infix 3 _↞_
 
 _↞_ : ∀ {f t} → Set f → Set t → Set _
-From ↞ To = LeftInverse (P.setoid From) (P.setoid To)
+From ↞ To = LeftInverse (≡.setoid From) (≡.setoid To)
+{-# WARNING_ON_USAGE _↞_
+"Warning: _↞_ was deprecated in v2.0.
+Please use Function.(Bundles.)_↪_ instead."
+#-}
 
 leftInverse : ∀ {f t} {From : Set f} {To : Set t} →
               (to : From → To) (from : To → From) →
               (∀ x → from (to x) ≡ x) →
               From ↞ To
 leftInverse to from invˡ = record
-  { to              = P.→-to-⟶ to
-  ; from            = P.→-to-⟶ from
+  { to              = Eq.→-to-⟶ to
+  ; from            = Eq.→-to-⟶ from
   ; left-inverse-of = invˡ
   }
+{-# WARNING_ON_USAGE leftInverse
+"Warning: leftInverse was deprecated in v2.0.
+Please use Function.(Bundles.)mk↪ instead."
+#-}
 
 ------------------------------------------------------------------------
 -- Identity and composition.
@@ -111,6 +135,11 @@ id {S = S} = record
   ; from            = Eq.id
   ; left-inverse-of = λ _ → Setoid.refl S
   }
+{-# WARNING_ON_USAGE id
+"Warning: id was deprecated in v2.0.
+Please use either Function.Properties.RightInverse.refl or
+Function.Construct.Identity.rightInverse instead."
+#-}
 
 infixr 9 _∘_
 
@@ -128,3 +157,8 @@ _∘_ {F = F} f g = record
   where
   open LeftInverse
   open EqReasoning F
+{-# WARNING_ON_USAGE _∘_
+"Warning: _∘_ was deprecated in v2.0.
+Please use either Function.Properties.RightInverse.trans or
+Function.Construct.Composition.rightInverse instead."
+#-}
diff --git a/src/Function/Metric/Bundles.agda b/src/Function/Metric/Bundles.agda
index 7acf81de13..ad3a29c333 100644
--- a/src/Function/Metric/Bundles.agda
+++ b/src/Function/Metric/Bundles.agda
@@ -22,6 +22,7 @@ open import Function.Metric.Core
 
 record ProtoMetric (a i ℓ₁ ℓ₂ ℓ₃ : Level)
                  : Set (suc (a ⊔ i ⊔ ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃)) where
+  infix 4 _≈_ _≈ᵢ_ _≤_
   field
     Carrier       : Set a
     Image         : Set i
@@ -39,6 +40,7 @@ record ProtoMetric (a i ℓ₁ ℓ₂ ℓ₃ : Level)
 
 record PreMetric (a i ℓ₁ ℓ₂ ℓ₃ : Level)
                : Set (suc (a ⊔ i ⊔ ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃)) where
+  infix 4 _≈_ _≈ᵢ_ _≤_
   field
     Carrier     : Set a
     Image       : Set i
@@ -61,6 +63,8 @@ record PreMetric (a i ℓ₁ ℓ₂ ℓ₃ : Level)
 
 record QuasiSemiMetric (a i ℓ₁ ℓ₂ ℓ₃ : Level)
                      : Set (suc (a ⊔ i ⊔ ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃)) where
+
+  infix 4 _≈_ _≈ᵢ_ _≤_
   field
     Carrier           : Set a
     Image             : Set i
@@ -86,6 +90,7 @@ record QuasiSemiMetric (a i ℓ₁ ℓ₂ ℓ₃ : Level)
 
 record SemiMetric (a i ℓ₁ ℓ₂ ℓ₃ : Level)
                 : Set (suc (a ⊔ i ⊔ ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃)) where
+  infix 4 _≈_ _≈ᵢ_ _≤_
   field
     Carrier      : Set a
     Image        : Set i
@@ -120,6 +125,8 @@ record SemiMetric (a i ℓ₁ ℓ₂ ℓ₃ : Level)
 
 record GeneralMetric (a i ℓ₁ ℓ₂ ℓ₃ : Level)
                    : Set (suc (a ⊔ i ⊔ ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃)) where
+  infix 4 _≈_ _≈ᵢ_ _≤_
+  infixl 6 _∙_
   field
     Carrier         : Set a
     Image           : Set i
diff --git a/src/Function/Metric/Definitions.agda b/src/Function/Metric/Definitions.agda
index 6c6d471aef..acecc24564 100644
--- a/src/Function/Metric/Definitions.agda
+++ b/src/Function/Metric/Definitions.agda
@@ -11,7 +11,7 @@
 module Function.Metric.Definitions where
 
 open import Algebra.Core using (Op₂)
-open import Data.Product using (∃)
+open import Data.Product.Base using (∃)
 open import Function.Metric.Core using (DistanceFunction)
 open import Level using (Level)
 open import Relation.Binary.Core using (Rel; _Preserves₂_⟶_⟶_)
@@ -23,7 +23,7 @@ private
     A : Set a
     I : Set i
 
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties
 
 Congruent : Rel A ℓ₁ → Rel I ℓ₂ → DistanceFunction A I → Set _
diff --git a/src/Function/Metric/Nat/Bundles.agda b/src/Function/Metric/Nat/Bundles.agda
index 3e406d7611..6623fac24f 100644
--- a/src/Function/Metric/Nat/Bundles.agda
+++ b/src/Function/Metric/Nat/Bundles.agda
@@ -13,13 +13,13 @@
 module Function.Metric.Nat.Bundles where
 
 open import Data.Nat.Base hiding (suc; _⊔_)
-open import Function using (const)
+open import Function.Base using (const)
 open import Level using (Level; suc; _⊔_)
-open import Relation.Binary.Core
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; isEquivalence)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+open import Relation.Binary.PropositionalEquality.Properties using (isEquivalence)
 
-open import Function.Metric.Nat.Core
+open import Function.Metric.Nat.Core using (DistanceFunction)
 open import Function.Metric.Nat.Structures
 open import Function.Metric.Bundles as Base
   using (GeneralMetric)
@@ -28,6 +28,7 @@ open import Function.Metric.Bundles as Base
 -- Proto-metric
 
 record ProtoMetric a ℓ : Set (suc (a ⊔ ℓ)) where
+  infix 4 _≈_
   field
     Carrier       : Set a
     _≈_           : Rel Carrier ℓ
@@ -40,6 +41,7 @@ record ProtoMetric a ℓ : Set (suc (a ⊔ ℓ)) where
 -- PreMetric
 
 record PreMetric a ℓ : Set (suc (a ⊔ ℓ)) where
+  infix 4 _≈_
   field
     Carrier     : Set a
     _≈_         : Rel Carrier ℓ
@@ -57,6 +59,7 @@ record PreMetric a ℓ : Set (suc (a ⊔ ℓ)) where
 -- QuasiSemiMetric
 
 record QuasiSemiMetric a ℓ : Set (suc (a ⊔ ℓ)) where
+  infix 4 _≈_
   field
     Carrier           : Set a
     _≈_               : Rel Carrier ℓ
@@ -77,6 +80,7 @@ record QuasiSemiMetric a ℓ : Set (suc (a ⊔ ℓ)) where
 -- SemiMetric
 
 record SemiMetric a ℓ : Set (suc (a ⊔ ℓ)) where
+  infix 4 _≈_
   field
     Carrier      : Set a
     _≈_          : Rel Carrier ℓ
@@ -97,6 +101,7 @@ record SemiMetric a ℓ : Set (suc (a ⊔ ℓ)) where
 -- Metrics
 
 record Metric a ℓ : Set (suc (a ⊔ ℓ)) where
+  infix 4 _≈_
   field
     Carrier  : Set a
     _≈_      : Rel Carrier ℓ
@@ -117,6 +122,7 @@ record Metric a ℓ : Set (suc (a ⊔ ℓ)) where
 -- UltraMetrics
 
 record UltraMetric a ℓ : Set (suc (a ⊔ ℓ)) where
+  infix 4 _≈_
   field
     Carrier       : Set a
     _≈_           : Rel Carrier ℓ
diff --git a/src/Function/Metric/Nat/Structures.agda b/src/Function/Metric/Nat/Structures.agda
index d601cad35f..8eaa533faa 100644
--- a/src/Function/Metric/Nat/Structures.agda
+++ b/src/Function/Metric/Nat/Structures.agda
@@ -9,10 +9,10 @@
 module Function.Metric.Nat.Structures where
 
 open import Data.Nat.Base hiding (suc)
-open import Function using (const)
+open import Function.Base using (const)
 open import Level using (Level; suc)
-open import Relation.Binary hiding (Symmetric)
-open import Relation.Binary.PropositionalEquality using (_≡_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 open import Function.Metric.Nat.Core
 open import Function.Metric.Nat.Definitions
diff --git a/src/Function/Metric/Rational/Bundles.agda b/src/Function/Metric/Rational/Bundles.agda
index 89067d2718..018d26c6df 100644
--- a/src/Function/Metric/Rational/Bundles.agda
+++ b/src/Function/Metric/Rational/Bundles.agda
@@ -10,20 +10,19 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Rational.Base hiding (_⊔_)
-open import Function using (const)
+module Function.Metric.Rational.Bundles where
+
+open import Function.Base using (const)
 open import Level using (Level; suc; _⊔_)
-open import Relation.Binary.Core
-open import Relation.Binary.PropositionalEquality
-  using (_≡_; isEquivalence)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+open import Relation.Binary.PropositionalEquality.Properties using (isEquivalence)
 
-open import Function.Metric.Rational.Core
+open import Function.Metric.Rational.Core using (DistanceFunction)
 open import Function.Metric.Rational.Structures
 open import Function.Metric.Bundles as Base
   using (GeneralMetric)
 
-module Function.Metric.Rational.Bundles where
-
 ------------------------------------------------------------------------
 -- Proto-metric
 
@@ -34,6 +33,8 @@ record ProtoMetric a ℓ : Set (suc (a ⊔ ℓ)) where
     d             : DistanceFunction Carrier
     isProtoMetric : IsProtoMetric _≈_ d
 
+  infix 4 _≈_
+
   open IsProtoMetric isProtoMetric public
 
 ------------------------------------------------------------------------
@@ -46,6 +47,8 @@ record PreMetric a ℓ : Set (suc (a ⊔ ℓ)) where
     d           : DistanceFunction Carrier
     isPreMetric : IsPreMetric _≈_ d
 
+  infix 4 _≈_
+
   open IsPreMetric isPreMetric public
 
   protoMetric : ProtoMetric a ℓ
@@ -63,6 +66,8 @@ record QuasiSemiMetric a ℓ : Set (suc (a ⊔ ℓ)) where
     d                 : DistanceFunction Carrier
     isQuasiSemiMetric : IsQuasiSemiMetric _≈_ d
 
+  infix 4 _≈_
+
   open IsQuasiSemiMetric isQuasiSemiMetric public
 
   preMetric : PreMetric a ℓ
@@ -83,6 +88,8 @@ record SemiMetric a ℓ : Set (suc (a ⊔ ℓ)) where
     d            : DistanceFunction Carrier
     isSemiMetric : IsSemiMetric _≈_ d
 
+  infix 4 _≈_
+
   open IsSemiMetric isSemiMetric public
 
   quasiSemiMetric : QuasiSemiMetric a ℓ
@@ -103,6 +110,8 @@ record Metric a ℓ : Set (suc (a ⊔ ℓ)) where
     d        : DistanceFunction Carrier
     isMetric : IsMetric _≈_ d
 
+  infix 4 _≈_
+
   open IsMetric isMetric public
 
   semiMetric : SemiMetric a ℓ
@@ -123,6 +132,8 @@ record UltraMetric a ℓ : Set (suc (a ⊔ ℓ)) where
     d             : DistanceFunction Carrier
     isUltraMetric : IsUltraMetric _≈_ d
 
+  infix 4 _≈_
+
   open IsUltraMetric isUltraMetric public
 
   semiMetric : SemiMetric a ℓ
diff --git a/src/Function/Metric/Rational/Structures.agda b/src/Function/Metric/Rational/Structures.agda
index 44339d296b..3a8acdaae6 100644
--- a/src/Function/Metric/Rational/Structures.agda
+++ b/src/Function/Metric/Rational/Structures.agda
@@ -7,10 +7,10 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Data.Rational.Base
-open import Function using (const)
+open import Function.Base using (const)
 open import Level using (Level; suc)
-open import Relation.Binary hiding (Symmetric)
-open import Relation.Binary.PropositionalEquality using (_≡_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 
 open import Function.Metric.Rational.Core
 open import Function.Metric.Rational.Definitions
diff --git a/src/Function/Metric/Structures.agda b/src/Function/Metric/Structures.agda
index 1523673557..68c85e48b4 100644
--- a/src/Function/Metric/Structures.agda
+++ b/src/Function/Metric/Structures.agda
@@ -9,7 +9,8 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary hiding (Symmetric)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsPartialOrder; IsEquivalence)
 
 module Function.Metric.Structures
   {a i ℓ₁ ℓ₂ ℓ₃} {A : Set a} {I : Set i}
diff --git a/src/Function/Nary/NonDependent.agda b/src/Function/Nary/NonDependent.agda
index 3c29079b5e..b1962a68c4 100644
--- a/src/Function/Nary/NonDependent.agda
+++ b/src/Function/Nary/NonDependent.agda
@@ -17,11 +17,13 @@ module Function.Nary.NonDependent where
 open import Level using (Level; 0ℓ; _⊔_; Lift)
 open import Data.Nat.Base using (ℕ; zero; suc)
 open import Data.Fin.Base using (Fin; zero; suc)
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Data.Product.Nary.NonDependent
+  using (Product; uncurryₙ; Equalₙ; curryₙ; fromEqualₙ; toEqualₙ)
 open import Function.Base using (_∘′_; _$′_; const; flip)
 open import Relation.Unary using (IUniversal)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; cong)
 
 private
   variable
diff --git a/src/Function/Nary/NonDependent/Base.agda b/src/Function/Nary/NonDependent/Base.agda
index 72e093b3a7..2f7347cdab 100644
--- a/src/Function/Nary/NonDependent/Base.agda
+++ b/src/Function/Nary/NonDependent/Base.agda
@@ -16,7 +16,7 @@ module Function.Nary.NonDependent.Base where
 
 open import Level using (Level; 0ℓ; _⊔_)
 open import Data.Nat.Base using (ℕ; zero; suc)
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Data.Unit.Polymorphic.Base
 open import Function.Base using (_∘′_; _$′_; const; flip)
 
@@ -30,15 +30,15 @@ private
 ------------------------------------------------------------------------
 -- Type Definitions
 
--- We want to define n-ary function spaces and generic n-ary operations on
--- them such as (un)currying, zipWith, alignWith, etc.
+-- We want to define n-ary function spaces and generic n-ary operations
+-- on them such as (un)currying, zipWith, alignWith, etc.
 
 -- We want users to be able to use these seamlessly whenever n is concrete.
 
--- In other words, we want Agda to infer the sets `A₁, ⋯, Aₙ` when we write
--- `uncurryₙ n f` where `f` has type `A₁ → ⋯ → Aₙ → B`. For this to happen,
--- we need the structure in which these Sets are stored to effectively
--- η-expand to `A₁, ⋯, Aₙ` when the parameter `n` is known.
+-- In other words, we want Agda to infer the sets `A₁, ⋯, Aₙ` when we
+-- write `uncurryₙ n f` where `f` has type `A₁ → ⋯ → Aₙ → B`. For this
+-- to happen, we need the structure in which these Sets are stored to
+-- effectively η-expand to `A₁, ⋯, Aₙ` when the parameter `n` is known.
 
 -- Hence the following definitions:
 ------------------------------------------------------------------------
@@ -66,9 +66,9 @@ Sets : ∀ n (ls : Levels n) → Set (Level.suc (⨆ n ls))
 Sets zero    _        = ⊤
 Sets (suc n) (l , ls) = Set l × Sets n ls
 
--- Third, a function type whose domains are given by a "vector" of `n` Sets
--- `A₁, ⋯, Aₙ` and whose codomain is `B`. `Arrows` forms such a type of
--- shape `A₁ → ⋯ → Aₙ → B` by induction on `n`.
+-- Third, a function type whose domains are given by a "vector" of `n`
+-- Sets `A₁, ⋯, Aₙ` and whose codomain is `B`. `Arrows` forms such a
+-- type of shape `A₁ → ⋯ → Aₙ → B` by induction on `n`.
 
 Arrows : ∀ n {r ls} → Sets n ls → Set r → Set (r ⊔ (⨆ n ls))
 Arrows zero    _        b = b
diff --git a/src/Function/Properties.agda b/src/Function/Properties.agda
index b20807f64e..08692108bc 100644
--- a/src/Function/Properties.agda
+++ b/src/Function/Properties.agda
@@ -9,7 +9,8 @@
 module Function.Properties where
 
 open import Axiom.Extensionality.Propositional using (Extensionality)
-open import Function
+open import Function.Base using (flip; _∘_)
+open import Function.Bundles using (_↔_; mk↔ₛ′; Inverse)
 open import Level
 open import Relation.Binary.PropositionalEquality.Core
   using (trans; cong; cong′)
@@ -24,14 +25,14 @@ private
 -- Implicit and explicit function spaces are isomorphic
 
 Π↔Π : {B : A → Set b} → ((x : A) → B x) ↔ ({x : A} → B x)
-Π↔Π = mk↔′ (λ f {x} → f x) (λ f _ → f) cong′ cong′
+Π↔Π = mk↔ₛ′ (λ f {x} → f x) (λ f _ → f) cong′ cong′
 
 ------------------------------------------------------------------------
 -- Function spaces can be reordered
 
 ΠΠ↔ΠΠ : (R : A → B → Set p) →
         ((x : A) (y : B) → R x y) ↔ ((y : B) (x : A) → R x y)
-ΠΠ↔ΠΠ _ = mk↔′ flip flip cong′ cong′
+ΠΠ↔ΠΠ _ = mk↔ₛ′ flip flip cong′ cong′
 
 ------------------------------------------------------------------------
 -- Assuming extensionality then → preserves ↔
@@ -39,9 +40,9 @@ private
 →-cong-↔ : {A : Set a} {B : Set b} {C : Set c} {D : Set d} →
          Extensionality a c → Extensionality b d →
          A ↔ B → C ↔ D → (A → C) ↔ (B → D)
-→-cong-↔ extAC extBD A↔B C↔D = mk↔′
+→-cong-↔ extAC extBD A↔B C↔D = mk↔ₛ′
   (λ h → C↔D.to   ∘ h ∘ A↔B.from)
   (λ g → C↔D.from ∘ g ∘ A↔B.to  )
-  (λ h → extBD λ x → trans (C↔D.inverseˡ _) (cong h (A↔B.inverseˡ x)))
-  (λ g → extAC λ x → trans (C↔D.inverseʳ _) (cong g (A↔B.inverseʳ x)))
+  (λ h → extBD λ x → trans (C↔D.strictlyInverseˡ _) (cong h (A↔B.strictlyInverseˡ x)))
+  (λ g → extAC λ x → trans (C↔D.strictlyInverseʳ _) (cong g (A↔B.strictlyInverseʳ x)))
   where module A↔B = Inverse A↔B; module C↔D = Inverse C↔D
diff --git a/src/Function/Properties/Bijection.agda b/src/Function/Properties/Bijection.agda
index e484098774..21e295e807 100644
--- a/src/Function/Properties/Bijection.agda
+++ b/src/Function/Properties/Bijection.agda
@@ -8,13 +8,16 @@
 
 module Function.Properties.Bijection where
 
-open import Function.Bundles
+open import Function.Bundles using (Bijection; Inverse; Equivalence;
+  _⤖_; _↔_; _⇔_)
 open import Level using (Level)
-open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality as P using (setoid)
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
-open import Data.Product using (_,_; proj₁; proj₂)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions using (Reflexive; Trans)
+open import Relation.Binary.PropositionalEquality.Properties using (setoid)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Function.Base using (_∘_)
+open import Function.Properties.Surjection using (injective⇒to⁻-cong)
 open import Function.Properties.Inverse using (Inverse⇒Equivalence)
 
 import Function.Construct.Identity as Identity
@@ -35,7 +38,7 @@ refl = Identity.bijection _
 
 -- Can't prove full symmetry as we have no proof that the witness
 -- produced by the surjection proof preserves equality
-sym-≡ : Bijection S (P.setoid B) → Bijection (P.setoid B) S
+sym-≡ : Bijection S (setoid B) → Bijection (setoid B) S
 sym-≡ = Symmetry.bijection-≡
 
 trans : Trans (Bijection {a} {ℓ₁} {b} {ℓ₂}) (Bijection {b} {ℓ₂} {c} {ℓ₃}) Bijection
@@ -55,18 +58,15 @@ trans = Composition.bijection
 -- Conversion functions
 
 Bijection⇒Inverse : Bijection S T → Inverse S T
-Bijection⇒Inverse {S = S} {T = T} b = record
+Bijection⇒Inverse bij = record
   { to        = to
   ; from      = to⁻
   ; to-cong   = cong
-  ; from-cong = λ {x} {y} x≈y → injective (begin
-      to (to⁻ x) ≈⟨ to∘to⁻ x ⟩
-      x          ≈⟨ x≈y ⟩
-      y          ≈˘⟨ to∘to⁻ y ⟩
-      to (to⁻ y) ∎)
-  ; inverse = to∘to⁻ , injective ∘ to∘to⁻ ∘ to
+  ; from-cong = injective⇒to⁻-cong surjection injective
+  ; inverse   = (λ y≈to⁻[x] → Eq₂.trans (cong y≈to⁻[x]) (to∘to⁻ _)) ,
+                (λ y≈to[x] → injective (Eq₂.trans (to∘to⁻ _) y≈to[x]))
   }
-  where open SetoidReasoning T; open Bijection b; to∘to⁻ = proj₂ ∘ surjective
+  where open Bijection bij; to∘to⁻ = proj₂ ∘ strictlySurjective
 
 Bijection⇒Equivalence : Bijection T S → Equivalence T S
 Bijection⇒Equivalence = Inverse⇒Equivalence ∘ Bijection⇒Inverse
diff --git a/src/Function/Properties/Equivalence.agda b/src/Function/Properties/Equivalence.agda
index ced34d9bd3..5872569945 100644
--- a/src/Function/Properties/Equivalence.agda
+++ b/src/Function/Properties/Equivalence.agda
@@ -9,10 +9,12 @@
 
 module Function.Properties.Equivalence where
 
-open import Function.Bundles using (Equivalence; _⇔_)
+open import Function.Bundles
 open import Level
-open import Relation.Binary using (Setoid; IsEquivalence)
-import Relation.Binary.PropositionalEquality as Eq using (setoid)
+open import Relation.Binary.Definitions
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 
 import Function.Construct.Identity as Identity
 import Function.Construct.Symmetry as Symmetry
@@ -20,39 +22,72 @@ import Function.Construct.Composition as Composition
 
 private
   variable
-    a ℓ : Level
+    a b c ℓ ℓ₁ ℓ₂ ℓ₃ : Level
+    A B : Set a
+    S T : Setoid a ℓ
+
+------------------------------------------------------------------------
+-- Constructors
+
+mkEquivalence : Func S T → Func T S → Equivalence S T
+mkEquivalence f g = record
+  { to = to f
+  ; from = to g
+  ; to-cong = cong f
+  ; from-cong = cong g
+  } where open Func
+
+⟶×⟵⇒⇔ : A ⟶ B → B ⟶ A → A ⇔ B
+⟶×⟵⇒⇔ = mkEquivalence
+
+------------------------------------------------------------------------
+-- Destructors
+
+⇔⇒⟶ : A ⇔ B → A ⟶ B
+⇔⇒⟶ = Equivalence.toFunction
+
+⇔⇒⟵ : A ⇔ B → B ⟶ A
+⇔⇒⟵ = Equivalence.fromFunction
 
 ------------------------------------------------------------------------
 -- Setoid bundles
 
+refl : Reflexive (Equivalence {a} {ℓ})
+refl {x = x} = Identity.equivalence x
+
+sym : Sym (Equivalence {a} {ℓ₁} {b} {ℓ₂})
+          (Equivalence {b} {ℓ₂} {a} {ℓ₁})
+sym = Symmetry.equivalence
+
+trans : Trans (Equivalence {a} {ℓ₁} {b} {ℓ₂})
+              (Equivalence {b} {ℓ₂} {c} {ℓ₃})
+              (Equivalence {a} {ℓ₁} {c} {ℓ₃})
+trans = Composition.equivalence
+
 isEquivalence : IsEquivalence (Equivalence {a} {ℓ})
 isEquivalence = record
-  { refl = λ {x} → Identity.equivalence x
-  ; sym = Symmetry.equivalence
+  { refl = refl
+  ; sym = sym
   ; trans = Composition.equivalence
   }
 
+setoid : (s₁ s₂ : Level) → Setoid (suc (s₁ ⊔ s₂)) (s₁ ⊔ s₂)
+setoid s₁ s₂ = record
+  { Carrier       = Setoid s₁ s₂
+  ; _≈_           = Equivalence
+  ; isEquivalence = isEquivalence
+  }
+
 ------------------------------------------------------------------------
 -- Propositional bundles
 
 ⇔-isEquivalence : IsEquivalence {ℓ = ℓ} _⇔_
 ⇔-isEquivalence = record
-  { refl = λ {x} → Identity.equivalence (Eq.setoid x)
+  { refl = λ {x} → Identity.equivalence (≡.setoid x)
   ; sym = Symmetry.equivalence
   ; trans = Composition.equivalence
   }
 
-
-------------------------------------------------------------------------
--- Setoids
-
-setoid : (s₁ s₂ : Level) → Setoid (suc (s₁ ⊔ s₂)) (s₁ ⊔ s₂)
-setoid s₁ s₂ = record
-  { Carrier       = Setoid s₁ s₂
-  ; _≈_           = Equivalence
-  ; isEquivalence = isEquivalence
-  }
-
 ⇔-setoid : (ℓ : Level) → Setoid (suc ℓ) ℓ
 ⇔-setoid ℓ = record
   { Carrier       = Set ℓ
diff --git a/src/Function/Properties/Injection.agda b/src/Function/Properties/Injection.agda
new file mode 100644
index 0000000000..b191513549
--- /dev/null
+++ b/src/Function/Properties/Injection.agda
@@ -0,0 +1,62 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Properties for injections
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Function.Properties.Injection where
+
+open import Function.Base
+open import Function.Definitions
+open import Function.Bundles
+import Function.Construct.Identity as Identity
+import Function.Construct.Composition as Compose
+open import Level using (Level)
+open import Data.Product.Base using (proj₁; proj₂)
+open import Relation.Binary.Definitions
+open import Relation.Binary using (Setoid)
+
+private
+  variable
+    a b c ℓ ℓ₁ ℓ₂ ℓ₃ : Level
+    A B : Set a
+    T S U : Setoid a ℓ
+
+------------------------------------------------------------------------
+-- Constructors
+
+mkInjection : (f : Func S T) (open Func f) →
+              Injective Eq₁._≈_ Eq₂._≈_ to  →
+              Injection S T
+mkInjection f injective = record
+  { Func f
+  ; injective = injective
+  }
+
+------------------------------------------------------------------------
+-- Conversion functions
+
+↣⇒⟶ : A ↣ B → A ⟶ B
+↣⇒⟶ = Injection.function
+
+------------------------------------------------------------------------
+-- Setoid properties
+
+refl : Reflexive (Injection {a} {ℓ})
+refl {x = x} = Identity.injection x
+
+trans : Trans (Injection {a} {ℓ₁} {b} {ℓ₂})
+              (Injection {b} {ℓ₂} {c} {ℓ₃})
+              (Injection {a} {ℓ₁} {c} {ℓ₃})
+trans = Compose.injection
+
+------------------------------------------------------------------------
+-- Propositonal properties
+
+↣-refl : Injection S S
+↣-refl = refl
+
+↣-trans : Injection S T → Injection T U → Injection S U
+↣-trans = trans
diff --git a/src/Function/Properties/Inverse.agda b/src/Function/Properties/Inverse.agda
index 6310a8479f..0579d70a62 100644
--- a/src/Function/Properties/Inverse.agda
+++ b/src/Function/Properties/Inverse.agda
@@ -1,8 +1,7 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Some functional properties are Equivalence Relations
---   This file is meant to be imported qualified.
+-- Properties of inverses.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
@@ -10,13 +9,17 @@
 module Function.Properties.Inverse where
 
 open import Axiom.Extensionality.Propositional using (Extensionality)
-open import Data.Product using (_,_; proj₁; proj₂)
+open import Data.Product.Base using (_,_; proj₁; proj₂)
 open import Function.Bundles
-open import Level using (Level)
-open import Relation.Binary using (Setoid; IsEquivalence)
-open import Relation.Binary.PropositionalEquality as P using (setoid)
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
-open import Function.Consequences
+import Function.Properties.RightInverse as RightInverse
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Core using (REL)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
+import Function.Consequences.Setoid as Consequences
 
 import Function.Construct.Identity as Identity
 import Function.Construct.Symmetry as Symmetry
@@ -26,48 +29,73 @@ private
   variable
     a b ℓ ℓ₁ ℓ₂ : Level
     A B C D : Set a
-    S T : Setoid a ℓ
+    S T U V : Setoid a ℓ
 
 ------------------------------------------------------------------------
 -- Setoid bundles
 
+open Identity    public using () renaming (inverse to refl)
+open Symmetry    public using () renaming (inverse to sym)
+open Composition public using () renaming (inverse to trans)
+
 isEquivalence : IsEquivalence (Inverse {a} {b})
 isEquivalence = record
   { refl  = λ {x} → Identity.inverse x
-  ; sym   = Symmetry.inverse
-  ; trans = Composition.inverse
+  ; sym   = sym
+  ; trans = trans
   }
 
 ------------------------------------------------------------------------
 -- Propositional bundles
 
+↔-refl : A ↔ A
+↔-refl = Identity.↔-id _
+
+↔-sym : A ↔ B → B ↔ A
+↔-sym = Symmetry.↔-sym
+
+↔-trans : A ↔ B → B ↔ C → A ↔ C
+↔-trans = Composition.inverse
+
 -- need to η-expand for everything to line up properly
 ↔-isEquivalence : IsEquivalence {ℓ = ℓ} _↔_
 ↔-isEquivalence = record
-  { refl  = λ {x} → Identity.inverse (P.setoid x)
-  ; sym   = Symmetry.inverse
-  ; trans = Composition.inverse
+  { refl  = ↔-refl
+  ; sym   = ↔-sym
+  ; trans = ↔-trans
   }
 
-open module ↔ {ℓ} = IsEquivalence (↔-isEquivalence {ℓ}) using ()
-  renaming (refl to ↔-refl; sym to ↔-sym; trans to ↔-trans) public
-
 ------------------------------------------------------------------------
 -- Conversion functions
 
+toFunction : Inverse S T → Func S T
+toFunction I = record { to = to ; cong = to-cong }
+  where open Inverse I
+
+fromFunction : Inverse S T → Func T S
+fromFunction I = record { to = from ; cong = from-cong }
+  where open Inverse I
+
 Inverse⇒Injection : Inverse S T → Injection S T
-Inverse⇒Injection {S = S} I = record
+Inverse⇒Injection {S = S} {T = T} I = record
   { to = to
   ; cong = to-cong
-  ; injective = inverseʳ⇒injective S {f⁻¹ = from} from-cong inverseʳ
-  } where open Inverse I
+  ; injective = inverseʳ⇒injective to inverseʳ
+  } where open Inverse I; open Consequences S T
+
+Inverse⇒Surjection : Inverse S T → Surjection S T
+Inverse⇒Surjection {S = S} {T = T} I = record
+  { to = to
+  ; cong = to-cong
+  ; surjective = inverseˡ⇒surjective inverseˡ
+  } where open Inverse I; open Consequences S T
 
 Inverse⇒Bijection : Inverse S T → Bijection S T
-Inverse⇒Bijection {S = S} I = record
+Inverse⇒Bijection {S = S} {T = T} I = record
   { to        = to
   ; cong      = to-cong
-  ; bijective = inverseᵇ⇒bijective S from-cong inverse
-  } where open Inverse I
+  ; bijective = inverseᵇ⇒bijective inverse
+  } where open Inverse I; open Consequences S T
 
 Inverse⇒Equivalence : Inverse S T → Equivalence S T
 Inverse⇒Equivalence I = record
@@ -77,21 +105,55 @@ Inverse⇒Equivalence I = record
   ; from-cong = from-cong
   } where open Inverse I
 
+↔⇒⟶ : A ↔ B → A ⟶ B
+↔⇒⟶ = toFunction
+
+↔⇒⟵ : A ↔ B → B ⟶ A
+↔⇒⟵ = fromFunction
+
 ↔⇒↣ : A ↔ B → A ↣ B
 ↔⇒↣ = Inverse⇒Injection
 
+↔⇒↠ : A ↔ B → A ↠ B
+↔⇒↠ = Inverse⇒Surjection
+
 ↔⇒⤖ : A ↔ B → A ⤖ B
 ↔⇒⤖ = Inverse⇒Bijection
 
 ↔⇒⇔ : A ↔ B → A ⇔ B
 ↔⇒⇔ = Inverse⇒Equivalence
 
+↔⇒↩ : A ↔ B → A ↩ B
+↔⇒↩ = Inverse.leftInverse
+
+↔⇒↪ : A ↔ B → A ↪ B
+↔⇒↪ = Inverse.rightInverse
+
+-- The functions above can be combined with the following lemma to
+-- transport an arbitrary relation R (e.g. Injection) across
+-- inverses.
+transportVia : {R : ∀ {a b ℓ₁ ℓ₂} → REL (Setoid a ℓ₁) (Setoid b ℓ₂) (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂)} →
+               (∀ {a b c ℓ₁ ℓ₂ ℓ₃} {S : Setoid a ℓ₁} {T : Setoid b ℓ₂} {U : Setoid c ℓ₃} → R S T → R T U → R S U) →
+               (∀ {a b ℓ₁ ℓ₂} {S : Setoid a ℓ₁} {T : Setoid b ℓ₂} → Inverse S T → R S T) →
+               Inverse S T → R T U → Inverse U V → R S V
+transportVia R-trans inv⇒R IBA RBC ICD =
+  R-trans (inv⇒R IBA) (R-trans RBC (inv⇒R ICD))
+
+------------------------------------------------------------------------
+-- Other
+
 module _ (ext : ∀ {a b} → Extensionality a b) where
 
   ↔-fun : A ↔ B → C ↔ D → (A → C) ↔ (B → D)
-  ↔-fun A↔B C↔D = mk↔′
+  ↔-fun A↔B C↔D = mk↔ₛ′
     (λ a→c b → to C↔D (a→c (from A↔B b)))
     (λ b→d a → from C↔D (b→d (to A↔B a)))
-    (λ b→d → ext λ _ → P.trans (inverseˡ C↔D _ ) (P.cong b→d (inverseˡ A↔B _)))
-    (λ a→c → ext λ _ → P.trans (inverseʳ C↔D _ ) (P.cong a→c (inverseʳ A↔B _)))
+    (λ b→d → ext λ _ → ≡.trans (strictlyInverseˡ C↔D _ ) (≡.cong b→d (strictlyInverseˡ A↔B _)))
+    (λ a→c → ext λ _ → ≡.trans (strictlyInverseʳ C↔D _ ) (≡.cong a→c (strictlyInverseʳ A↔B _)))
     where open Inverse
+
+module _ (I : Inverse S T) where
+  open Inverse I
+
+  to-from : ∀ {x y} → to x Eq₂.≈ y → from y Eq₁.≈ x
+  to-from = RightInverse.to-from rightInverse
diff --git a/src/Function/Properties/Inverse/HalfAdjointEquivalence.agda b/src/Function/Properties/Inverse/HalfAdjointEquivalence.agda
new file mode 100644
index 0000000000..05c20b9682
--- /dev/null
+++ b/src/Function/Properties/Inverse/HalfAdjointEquivalence.agda
@@ -0,0 +1,123 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Half adjoint equivalences
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Function.Properties.Inverse.HalfAdjointEquivalence where
+
+open import Function.Base using (id; _∘_)
+open import Function.Bundles using (Inverse; _↔_; mk↔ₛ′)
+open import Level using (Level; _⊔_)
+open import Relation.Binary.PropositionalEquality
+  using (_≡_; refl; cong; sym; trans; trans-reflʳ; cong-≡id; cong-∘; naturality;
+         cong-id; trans-assoc; trans-symˡ; module ≡-Reasoning)
+
+private
+  variable
+    a b : Level
+    A B : Set a
+
+-- Half adjoint equivalences (see the HoTT book).
+--
+-- They are inverses with an extra coherence condition that the left
+-- and right inversion proofs interact the right way with `cong`.
+
+infix 4 _≃_
+
+record _≃_ (A : Set a) (B : Set b) : Set (a ⊔ b) where
+  field
+    to               : A → B
+    from             : B → A
+    left-inverse-of  : ∀ x → from (to x) ≡ x
+    right-inverse-of : ∀ x → to (from x) ≡ x
+    left-right       : ∀ x → cong to (left-inverse-of x) ≡ right-inverse-of (to x)
+
+  -- The forward direction of a half adjoint equivalence is injective.
+
+  injective : ∀ {x y} → to x ≡ to y → x ≡ y
+  injective {x} {y} to-x≡to-y =
+    x            ≡⟨ sym (left-inverse-of _) ⟩
+    from (to x)  ≡⟨ cong from to-x≡to-y ⟩
+    from (to y)  ≡⟨ left-inverse-of _ ⟩
+    y            ∎
+    where open ≡-Reasoning
+
+-- Half adjoint equivalences can be turned into inverses.
+
+≃⇒↔ : A ≃ B → A ↔ B
+≃⇒↔ A≃B = mk↔ₛ′ to from right-inverse-of left-inverse-of
+  where open _≃_ A≃B
+
+-- Inverses can be turned into half adjoint equivalences.
+--
+-- (This proof is based on one in the HoTT book.)
+
+↔⇒≃ : A ↔ B → A ≃ B
+↔⇒≃ A↔B = record
+  { to               = to
+  ; from             = from
+  ; left-inverse-of  = strictlyInverseʳ
+  ; right-inverse-of = right-inverse-of
+  ; left-right       = left-right
+  }
+  where
+  open ≡-Reasoning
+  open module A↔B = Inverse A↔B
+
+  right-inverse-of : ∀ x → to (from x) ≡ x
+  right-inverse-of x =
+    to (from x)               ≡⟨ sym (A↔B.strictlyInverseˡ _) ⟩
+    to (from (to (from x)))   ≡⟨ cong to (strictlyInverseʳ  _) ⟩
+    to (from x)               ≡⟨ A↔B.strictlyInverseˡ _ ⟩
+    x                         ∎
+
+  left-right :
+    ∀ x →
+    cong to (strictlyInverseʳ x) ≡ right-inverse-of (to x)
+  left-right x =
+    cong to (strictlyInverseʳ x)               ≡⟨⟩
+
+    trans refl (cong to (strictlyInverseʳ _))  ≡⟨ cong (λ p → trans p (cong to (strictlyInverseʳ _)))
+                                                          (sym (trans-symˡ (A↔B.strictlyInverseˡ _))) ⟩
+    trans (trans (sym (A↔B.strictlyInverseˡ _))
+               (A↔B.strictlyInverseˡ _))
+      (cong to (strictlyInverseʳ _))           ≡⟨ trans-assoc (sym (A↔B.strictlyInverseˡ _)) ⟩
+
+    trans (sym (A↔B.strictlyInverseˡ _))
+      (trans (A↔B.strictlyInverseˡ _)
+         (cong to (strictlyInverseʳ _)))       ≡⟨ cong (trans (sym (A↔B.strictlyInverseˡ _))) lemma ⟩
+
+    trans (sym (A↔B.strictlyInverseˡ _))
+      (trans (cong to (strictlyInverseʳ _))
+         (trans (A↔B.strictlyInverseˡ _) refl))      ≡⟨⟩
+
+    right-inverse-of (to x)                      ∎
+    where
+    lemma =
+      trans (A↔B.strictlyInverseˡ _)
+        (cong to (strictlyInverseʳ _))             ≡⟨ cong (trans (A↔B.strictlyInverseˡ _)) (sym (cong-id _)) ⟩
+
+      trans (A↔B.strictlyInverseˡ _)
+        (cong id (cong to (strictlyInverseʳ _)))   ≡⟨ sym (naturality A↔B.strictlyInverseˡ) ⟩
+
+      trans (cong (to ∘ from)
+                 (cong to (strictlyInverseʳ _)))
+        (A↔B.strictlyInverseˡ _)                         ≡⟨ cong (λ p → trans p (A↔B.strictlyInverseˡ _))
+                                                              (sym (cong-∘ _)) ⟩
+      trans (cong (to ∘ from ∘ to)
+                      (strictlyInverseʳ _))
+        (A↔B.strictlyInverseˡ _)                         ≡⟨ cong (λ p → trans p (A↔B.strictlyInverseˡ _))
+                                                              (cong-∘ _) ⟩
+      trans (cong to
+                 (cong (from ∘ to)
+                    (strictlyInverseʳ _)))
+        (A↔B.strictlyInverseˡ _)                         ≡⟨ cong (λ p → trans (cong to p) (strictlyInverseˡ (to x)))
+                                                              (cong-≡id strictlyInverseʳ) ⟩
+      trans (cong to (strictlyInverseʳ _))
+        (A↔B.strictlyInverseˡ _)                         ≡⟨ cong (trans (cong to (strictlyInverseʳ _)))
+                                                              (sym (trans-reflʳ _)) ⟩
+      trans (cong to (strictlyInverseʳ _))
+        (trans (A↔B.strictlyInverseˡ _) refl)            ∎
diff --git a/src/Function/Properties/RightInverse.agda b/src/Function/Properties/RightInverse.agda
index f5aa05d9df..ae8bc266de 100644
--- a/src/Function/Properties/RightInverse.agda
+++ b/src/Function/Properties/RightInverse.agda
@@ -1,7 +1,7 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Conversions for right inverses
+-- Properties of right inverses
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
@@ -9,26 +9,73 @@
 module Function.Properties.RightInverse where
 
 open import Function.Base
+open import Function.Definitions
 open import Function.Bundles
-open import Function.Consequences using (inverseʳ⇒surjective)
+open import Function.Consequences using (inverseˡ⇒surjective)
 open import Level using (Level)
-open import Data.Product
-open import Relation.Binary using (Setoid; IsEquivalence)
+open import Data.Product.Base using (_,_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
 
 private
   variable
     ℓ₁ ℓ₂ a b : Level
-    A : Set a
-    B : Set b
-    S : Setoid a ℓ₁
-    T : Setoid b ℓ₂
+    A B : Set a
+    S T : Setoid a ℓ₁
+
+------------------------------------------------------------------------
+-- Constructors
+
+mkRightInverse : (e : Equivalence S T) (open Equivalence e) →
+                 Inverseʳ Eq₁._≈_ Eq₂._≈_ to from →
+                 RightInverse S T
+mkRightInverse eq invʳ = record
+  { Equivalence eq
+  ; inverseʳ = invʳ
+  }
+
+------------------------------------------------------------------------
+-- Conversion
+
+RightInverse⇒LeftInverse : RightInverse S T → LeftInverse T S
+RightInverse⇒LeftInverse I = record
+  { to         = from
+  ; from       = to
+  ; to-cong    = from-cong
+  ; from-cong  = to-cong
+  ; inverseˡ   = inverseʳ
+  } where open RightInverse I
+
+LeftInverse⇒RightInverse : LeftInverse S T → RightInverse T S
+LeftInverse⇒RightInverse I = record
+  { to         = from
+  ; from       = to
+  ; to-cong    = from-cong
+  ; from-cong  = to-cong
+  ; inverseʳ    = inverseˡ
+  } where open LeftInverse I
 
 RightInverse⇒Surjection : RightInverse S T → Surjection T S
 RightInverse⇒Surjection I = record
   { to         = from
   ; cong       = from-cong
-  ; surjective = λ a → to a , inverseʳ a
+  ; surjective = inverseˡ⇒surjective Eq₁._≈_ inverseʳ
   } where open RightInverse I
 
 ↪⇒↠ : B ↪ A → A ↠ B
 ↪⇒↠ = RightInverse⇒Surjection
+
+↪⇒↩ : B ↪ A → A ↩ B
+↪⇒↩ = RightInverse⇒LeftInverse
+
+↩⇒↪ : B ↩ A → A ↪ B
+↩⇒↪ = LeftInverse⇒RightInverse
+
+------------------------------------------------------------------------
+-- Other
+
+module _ (R : RightInverse S T) where
+  open RightInverse R
+
+  to-from : ∀ {x y} → to x Eq₂.≈ y → from y Eq₁.≈ x
+  to-from eq = Eq₁.trans (from-cong (Eq₂.sym eq)) (strictlyInverseʳ _)
diff --git a/src/Function/Properties/Surjection.agda b/src/Function/Properties/Surjection.agda
index ab164c43d0..d5e6b8e75d 100644
--- a/src/Function/Properties/Surjection.agda
+++ b/src/Function/Properties/Surjection.agda
@@ -1,30 +1,81 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Conversions for surjections
+-- Properties of surjections
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Function.Properties.Surjection where
 
-open import Function.Base
-open import Function.Bundles
+open import Function.Base using (_∘_; _$_)
+open import Function.Definitions using (Surjective; Injective; Congruent)
+open import Function.Bundles using (Func; Surjection; _↠_; _⟶_; _↪_; mk↪;
+  _⇔_; mk⇔)
+import Function.Construct.Identity as Identity
+import Function.Construct.Composition as Compose
 open import Level using (Level)
-open import Data.Product
+open import Data.Product.Base using (proj₁; proj₂)
+import Relation.Binary.PropositionalEquality.Core as ≡
+open import Relation.Binary.Definitions using (Reflexive; Trans)
+open import Relation.Binary.Bundles using (Setoid)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 private
   variable
-    a b : Level
+    a b c ℓ ℓ₁ ℓ₂ ℓ₃ : Level
     A B : Set a
+    T S : Setoid a ℓ
+
+------------------------------------------------------------------------
+-- Constructors
+
+mkSurjection : (f : Func S T) (open Func f) →
+              Surjective Eq₁._≈_ Eq₂._≈_ to  →
+              Surjection S T
+mkSurjection f surjective = record
+  { Func f
+  ; surjective = surjective
+  }
 
 ------------------------------------------------------------------------
 -- Conversion functions
 
+↠⇒⟶ : A ↠ B → A ⟶ B
+↠⇒⟶ = Surjection.function
+
 ↠⇒↪ : A ↠ B → B ↪ A
-↠⇒↪ s = mk↪ {to = proj₁ ∘ surjective} {from = to} (proj₂ ∘ surjective)
+↠⇒↪ s = mk↪ {from = to} λ { ≡.refl → proj₂ (strictlySurjective _)}
   where open Surjection s
 
 ↠⇒⇔ : A ↠ B → A ⇔ B
 ↠⇒⇔ s = mk⇔ to (proj₁ ∘ surjective)
   where open Surjection s
+
+------------------------------------------------------------------------
+-- Setoid properties
+
+refl : Reflexive (Surjection {a} {ℓ})
+refl {x = x} = Identity.surjection x
+
+trans : Trans (Surjection {a} {ℓ₁} {b} {ℓ₂})
+              (Surjection {b} {ℓ₂} {c} {ℓ₃})
+              (Surjection {a} {ℓ₁} {c} {ℓ₃})
+trans = Compose.surjection
+
+------------------------------------------------------------------------
+-- Other
+
+injective⇒to⁻-cong : (surj : Surjection S T) →
+                      (open Surjection surj) →
+                      Injective Eq₁._≈_ Eq₂._≈_ to →
+                      Congruent Eq₂._≈_ Eq₁._≈_ to⁻
+injective⇒to⁻-cong {T = T} surj injective {x} {y} x≈y = injective $ begin
+  to (to⁻ x) ≈⟨ to∘to⁻ x ⟩
+  x          ≈⟨ x≈y ⟩
+  y          ≈⟨ to∘to⁻ y ⟨
+  to (to⁻ y) ∎
+  where
+  open ≈-Reasoning T
+  open Surjection surj
+
diff --git a/src/Function/Reasoning.agda b/src/Function/Reasoning.agda
index 09747c0541..ea39d0b52e 100644
--- a/src/Function/Reasoning.agda
+++ b/src/Function/Reasoning.agda
@@ -19,4 +19,4 @@ infixl 0 ∋-syntax
 syntax ∋-syntax A a = a ∶ A
 
 -- Export pipeline functions
-open import Function public using (_|>_; _|>′_)
+open import Function.Base public using (_|>_; _|>′_)
diff --git a/src/Function/Related.agda b/src/Function/Related.agda
index 0746b3c14a..3bcb839237 100644
--- a/src/Function/Related.agda
+++ b/src/Function/Related.agda
@@ -1,14 +1,19 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- A universe which includes several kinds of "relatedness" for sets,
--- such as equivalences, surjections and bijections
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
+{-# OPTIONS --warn=noUserWarning #-}
 
 module Function.Related where
 
+{-# WARNING_ON_IMPORT
+"Function.Related was deprecated in v2.0.
+Use Function.Related.Propositional instead."
+#-}
+
 open import Level
 open import Function.Base
 open import Function.Equality using (_⟨$⟩_)
@@ -17,9 +22,14 @@ open import Function.Injection   as Inj     using (Injection; _↣_)
 open import Function.Inverse     as Inv     using (Inverse; _↔_)
 open import Function.LeftInverse as LeftInv using (LeftInverse)
 open import Function.Surjection  as Surj    using (Surjection)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
-open import Data.Product using (_,_; proj₁; proj₂; <_,_>)
+open import Function.Consequences.Propositional
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Bundles using (Setoid; Preorder)
+open import Relation.Binary.Structures using (IsEquivalence; IsPreorder)
+open import Relation.Binary.Definitions using (Reflexive; Trans; Sym)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
+open import Data.Product.Base using (_,_; proj₁; proj₂; <_,_>)
 
 import Function.Related.Propositional as R
 import Function.Bundles as B
@@ -53,6 +63,8 @@ open R public using
 -- (which implies that Agda can deduce the universe code from an
 -- expression matching any of the right-hand sides).
 
+infix 3 _←_ _↢_
+
 record _←_ {a b} (A : Set a) (B : Set b) : Set (a ⊔ b) where
   constructor lam
   field app-← : B → A
@@ -78,12 +90,17 @@ infix 4 _∼[_]_
 _∼[_]_ : ∀ {ℓ₁ ℓ₂} → Set ℓ₁ → Kind → Set ℓ₂ → Set _
 A ∼[ implication         ] B = A → B
 A ∼[ reverse-implication ] B = A ← B
-A ∼[ equivalence         ] B = Equivalence (P.setoid A) (P.setoid B)
-A ∼[ injection           ] B = Injection   (P.setoid A) (P.setoid B)
+A ∼[ equivalence         ] B = Equivalence (≡.setoid A) (≡.setoid B)
+A ∼[ injection           ] B = Injection   (≡.setoid A) (≡.setoid B)
 A ∼[ reverse-injection   ] B = A ↢ B
-A ∼[ left-inverse        ] B = LeftInverse (P.setoid A) (P.setoid B)
-A ∼[ surjection          ] B = Surjection  (P.setoid A) (P.setoid B)
-A ∼[ bijection           ] B = Inverse     (P.setoid A) (P.setoid B)
+A ∼[ left-inverse        ] B = LeftInverse (≡.setoid A) (≡.setoid B)
+A ∼[ surjection          ] B = Surjection  (≡.setoid A) (≡.setoid B)
+A ∼[ bijection           ] B = Inverse     (≡.setoid A) (≡.setoid B)
+
+-- A non-infix synonym.
+
+Related : Kind → ∀ {ℓ₁ ℓ₂} → Set ℓ₁ → Set ℓ₂ → Set _
+Related k A B = A ∼[ k ] B
 
 toRelated : {K : Kind} → A R.∼[ K ] B → A ∼[ K ] B
 toRelated {K = implication}         rel = B.Func.to rel
@@ -91,12 +108,12 @@ toRelated {K = reverse-implication} rel = lam (B.Func.to rel)
 toRelated {K = equivalence}         rel = Eq.equivalence (B.Equivalence.to rel) (B.Equivalence.from rel)
 toRelated {K = injection}           rel = Inj.injection (B.Injection.to rel) (B.Injection.injective rel)
 toRelated {K = reverse-injection}   rel = lam (Inj.injection (B.Injection.to rel) (B.Injection.injective rel))
-toRelated {K = left-inverse}        rel =
-  LeftInv.leftInverse (B.RightInverse.to rel) (B.RightInverse.from rel) (B.RightInverse.inverseʳ rel)
-toRelated {K = surjection}          rel with B.Surjection.surjective rel
-... | surj = Surj.surjection (B.Surjection.to rel) (proj₁ ∘ surj) (proj₂ ∘ surj)
-toRelated {K = bijection}           rel with B.Bijection.bijective rel
-... | (inj , surj) = Inv.inverse (B.Bijection.to rel) (proj₁ ∘ surj) (inj ∘ proj₂ ∘ surj ∘ (B.Bijection.to rel)) (proj₂ ∘ surj)
+toRelated {K = left-inverse}        rel = LeftInv.leftInverse to from strictlyInverseʳ where open B.RightInverse rel
+toRelated {K = surjection}          rel = Surj.surjection to (proj₁ ∘ strictlySurjective) (proj₂ ∘ strictlySurjective)
+  where open B.Surjection rel
+toRelated {K = bijection}           rel =
+             Inv.inverse to from strictlyInverseʳ strictlyInverseˡ
+  where open B.Inverse rel
 
 fromRelated : {K : Kind} → A ∼[ K ] B → A R.∼[ K ] B
 fromRelated {K = implication}         rel = B.mk⟶ rel
@@ -105,18 +122,12 @@ fromRelated {K = equivalence}         record { to = to ; from = from } = B.mk⇔
 fromRelated {K = injection}           rel = B.mk↣ (Inj.Injection.injective rel)
 fromRelated {K = reverse-injection}   (lam app-↢) = B.mk↣ (Inj.Injection.injective app-↢)
 fromRelated {K = left-inverse}        record { to = to ; from = from ; left-inverse-of = left-inverse-of } =
-  B.mk↪ {to = to ⟨$⟩_} {from = from ⟨$⟩_} left-inverse-of
+  B.mk↪ {to = to ⟨$⟩_} {from = from ⟨$⟩_} (strictlyInverseʳ⇒inverseʳ (to ⟨$⟩_) left-inverse-of)
 fromRelated {K = surjection}          record { to = to ; surjective = surjective } with surjective
-... | record { from = from ; right-inverse-of = right-inverse-of } = B.mk↠ {to = to ⟨$⟩_} < from ⟨$⟩_ , right-inverse-of >
-fromRelated {K = bijection}           record { to = to ; from = from ; inverse-of = inverse-of } with inverse-of
-... | record { left-inverse-of = left-inverse-of ; right-inverse-of = right-inverse-of } = B.mk⤖
-  ((λ {x y} h → P.subst₂ P._≡_ (left-inverse-of x) (left-inverse-of y) (P.cong (from ⟨$⟩_) h)) ,
-  < from ⟨$⟩_ , right-inverse-of >)
-
--- A non-infix synonym.
-
-Related : Kind → ∀ {ℓ₁ ℓ₂} → Set ℓ₁ → Set ℓ₂ → Set _
-Related k A B = A ∼[ k ] B
+... | record { from = from ; right-inverse-of = right-inverse-of } =
+  B.mk↠ {to = to ⟨$⟩_} < from ⟨$⟩_ , (λ { x ≡.refl → right-inverse-of x }) >
+fromRelated {K = bijection}           rel = B.mk↔ₛ′ (to ⟨$⟩_) (from ⟨$⟩_) right-inverse-of left-inverse-of
+  where open Inverse rel
 
 -- The bijective equality implies any kind of relatedness.
 
@@ -134,7 +145,7 @@ Related k A B = A ∼[ k ] B
 -- Actual equality also implies any kind of relatedness.
 
 ≡⇒ : ∀ {k ℓ} {X Y : Set ℓ} → X ≡ Y → X ∼[ k ] Y
-≡⇒ P.refl = ↔⇒ Inv.id
+≡⇒ ≡.refl = ↔⇒ Inv.id
 
 ------------------------------------------------------------------------
 -- Special kinds of kinds
@@ -302,7 +313,7 @@ K-refl {surjection}          = Surj.id
 K-refl {bijection}           = Inv.id
 
 K-reflexive : ∀ {k ℓ} → _≡_ ⇒ Related k {ℓ}
-K-reflexive P.refl = K-refl
+K-reflexive ≡.refl = K-refl
 
 K-trans : ∀ {k ℓ₁ ℓ₂ ℓ₃} → Trans (Related k {ℓ₁} {ℓ₂})
                                 (Related k {ℓ₂} {ℓ₃})
@@ -372,7 +383,7 @@ module EquationalReasoning where
 
   _≡˘⟨_⟩_ : ∀ {k ℓ z} (X : Set ℓ) {Y : Set ℓ} {Z : Set z} →
             Y ≡ X → Y ∼[ k ] Z → X ∼[ k ] Z
-  X ≡˘⟨ Y≡X ⟩ Y⇔Z = X ∼⟨ ≡⇒ (P.sym Y≡X) ⟩ Y⇔Z
+  X ≡˘⟨ Y≡X ⟩ Y⇔Z = X ∼⟨ ≡⇒ (≡.sym Y≡X) ⟩ Y⇔Z
 
   _≡⟨_⟩_ : ∀ {k ℓ z} (X : Set ℓ) {Y : Set ℓ} {Z : Set z} →
            X ≡ Y → Y ∼[ k ] Z → X ∼[ k ] Z
@@ -393,12 +404,12 @@ InducedPreorder₁ : Kind → ∀ {a s} {A : Set a} →
                    (A → Set s) → Preorder _ _ _
 InducedPreorder₁ k S = record
   { _≈_        = _≡_
-  ; _∼_        = InducedRelation₁ k S
+  ; _≲_        = InducedRelation₁ k S
   ; isPreorder = record
-    { isEquivalence = P.isEquivalence
+    { isEquivalence = ≡.isEquivalence
     ; reflexive     = reflexive ∘
                       K-reflexive ∘
-                      P.cong S
+                      ≡.cong S
     ; trans         = K-trans
     }
   } where open Preorder (K-preorder _ _)
@@ -426,13 +437,13 @@ InducedPreorder₂ : Kind → ∀ {a b s} {A : Set a} {B : Set b} →
                    (A → B → Set s) → Preorder _ _ _
 InducedPreorder₂ k _S_ = record
   { _≈_        = _≡_
-  ; _∼_        = InducedRelation₂ k _S_
+  ; _≲_        = InducedRelation₂ k _S_
   ; isPreorder = record
-    { isEquivalence = P.isEquivalence
+    { isEquivalence = ≡.isEquivalence
     ; reflexive     = λ x≡y {z} →
                         reflexive $
                         K-reflexive $
-                        P.cong (_S_ z) x≡y
+                        ≡.cong (_S_ z) x≡y
 
     ; trans         = λ i↝j j↝k → K-trans i↝j j↝k
     }
diff --git a/src/Function/Related/Propositional.agda b/src/Function/Related/Propositional.agda
index 0ef8830265..589c36a6b3 100644
--- a/src/Function/Related/Propositional.agda
+++ b/src/Function/Related/Propositional.agda
@@ -10,15 +10,17 @@ module Function.Related.Propositional where
 
 open import Level
 open import Relation.Binary
-  using (Sym; Reflexive; Trans; IsEquivalence; Setoid; IsPreorder; Preorder)
+  using (Rel; REL; Sym; Reflexive; Trans; IsEquivalence; Setoid; IsPreorder; Preorder)
 open import Function.Bundles
 open import Function.Base
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+import Relation.Binary.PropositionalEquality.Properties as ≡
+open import Relation.Binary.Reasoning.Syntax
 
 open import Function.Properties.Surjection   using (↠⇒↪; ↠⇒⇔)
 open import Function.Properties.RightInverse using (↪⇒↠)
 open import Function.Properties.Bijection    using (⤖⇒↔; ⤖⇒⇔)
-open import Function.Properties.Inverse      using (↔⇒⤖)
+open import Function.Properties.Inverse      using (↔⇒⤖; ↔⇒⇔; ↔⇒↣; ↔⇒↠)
 
 import Function.Construct.Symmetry    as Symmetry
 import Function.Construct.Identity    as Identity
@@ -45,9 +47,7 @@ data Kind : Set where
 private
   variable
     a b c p : Level
-    A : Set a
-    B : Set b
-    C : Set c
+    A B C : Set a
     k : Kind
 
 -- Interpretation of the codes above. The code "bijection" is
@@ -64,7 +64,7 @@ A ∼[ injection          ] B = A ↣ B
 A ∼[ reverseInjection   ] B = B ↣ A
 A ∼[ leftInverse        ] B = A ↪ B
 A ∼[ surjection         ] B = A ↠ B
-A ∼[ bijection          ] B = A ⤖ B
+A ∼[ bijection          ] B = A ↔ B
 
 -- A non-infix synonym.
 
@@ -73,20 +73,20 @@ Related k A B = A ∼[ k ] B
 
 -- The bijective equality implies any kind of relatedness.
 
-⤖⇒ : A ∼[ bijection ] B → A ∼[ k ] B
-⤖⇒ {k = implication}        = mk⟶ ∘ Bijection.to
-⤖⇒ {k = reverseImplication} = mk⟶ ∘ Inverse.from ∘ ⤖⇒↔
-⤖⇒ {k = equivalence}        = ⤖⇒⇔
-⤖⇒ {k = injection}          = Bijection.injection
-⤖⇒ {k = reverseInjection}   = Bijection.injection ∘ ↔⇒⤖ ∘ Symmetry.inverse ∘ ⤖⇒↔
-⤖⇒ {k = leftInverse}        = Inverse.rightInverse ∘ ⤖⇒↔
-⤖⇒ {k = surjection}         = Bijection.surjection
-⤖⇒ {k = bijection}          = id
+↔⇒ : A ∼[ bijection ] B → A ∼[ k ] B
+↔⇒ {k = implication}        = mk⟶ ∘ Inverse.to
+↔⇒ {k = reverseImplication} = mk⟶ ∘ Inverse.from
+↔⇒ {k = equivalence}        = ↔⇒⇔
+↔⇒ {k = injection}          = ↔⇒↣
+↔⇒ {k = reverseInjection}   = ↔⇒↣ ∘ Symmetry.inverse
+↔⇒ {k = leftInverse}        = Inverse.rightInverse
+↔⇒ {k = surjection}         = ↔⇒↠
+↔⇒ {k = bijection}          = id
 
 -- Propositional equality also implies any kind of relatedness.
 
 ≡⇒ : A ≡ B → A ∼[ k ] B
-≡⇒ P.refl = ⤖⇒ (Identity.⤖-id _)
+≡⇒ ≡.refl = ↔⇒ (Identity.↔-id _)
 
 ------------------------------------------------------------------------
 -- Special kinds of kinds
@@ -134,7 +134,7 @@ data ForwardKind : Set where
 ⇒→ {k = injection}   = Injection.to
 ⇒→ {k = leftInverse} = RightInverse.to
 ⇒→ {k = surjection}  = Surjection.to
-⇒→ {k = bijection}   = Bijection.to
+⇒→ {k = bijection}   = Inverse.to
 
 -- Kinds whose interpretation include a function which "goes backwards".
 
@@ -164,7 +164,7 @@ data BackwardKind : Set where
 ⇒← {k = reverseInjection}   = Injection.to
 ⇒← {k = leftInverse}        = RightInverse.from
 ⇒← {k = surjection}         = RightInverse.to ∘ ↠⇒↪
-⇒← {k = bijection}          = Inverse.from ∘ ⤖⇒↔
+⇒← {k = bijection}          = Inverse.from
 
 -- Kinds whose interpretation include functions going in both
 -- directions.
@@ -189,7 +189,7 @@ data EquivalenceKind : Set where
 ⇒⇔ {k = equivalence} = id
 ⇒⇔ {k = leftInverse} = RightInverse.equivalence
 ⇒⇔ {k = surjection}  = ↠⇒⇔
-⇒⇔ {k = bijection}   = ⤖⇒⇔
+⇒⇔ {k = bijection}   = ↔⇒⇔
 
 -- Conversions between special kinds.
 
@@ -235,7 +235,7 @@ reverse {k = injection}          = id
 reverse {k = reverseInjection}   = id
 reverse {k = leftInverse}        = ↪⇒↠
 reverse {k = surjection}         = ↠⇒↪
-reverse {k = bijection}          = ↔⇒⤖ ∘ Symmetry.↔-sym ∘ ⤖⇒↔
+reverse {k = bijection}          = Symmetry.↔-sym
 
 ------------------------------------------------------------------------
 -- For a fixed universe level every kind is a preorder and each
@@ -249,22 +249,22 @@ K-refl {k = injection}          = Identity.↣-id _
 K-refl {k = reverseInjection}   = Identity.↣-id _
 K-refl {k = leftInverse}        = Identity.↪-id _
 K-refl {k = surjection}         = Identity.↠-id _
-K-refl {k = bijection}          = Identity.⤖-id _
+K-refl {k = bijection}          = Identity.↔-id _
 
 K-reflexive : _≡_ Relation.Binary.⇒ Related {a} k
-K-reflexive P.refl = K-refl
+K-reflexive ≡.refl = K-refl
 
 K-trans : Trans (Related {a} {b} k)
                 (Related {b} {c} k)
                 (Related {a} {c} k)
-K-trans {k = implication}        = Composition._⟶-∘_
-K-trans {k = reverseImplication} = flip Composition._⟶-∘_
-K-trans {k = equivalence}        = Composition._⇔-∘_
-K-trans {k = injection}          = Composition._↣-∘_
-K-trans {k = reverseInjection}   = flip Composition._↣-∘_
-K-trans {k = leftInverse}        = Composition._↪-∘_
-K-trans {k = surjection}         = Composition._↠-∘_
-K-trans {k = bijection}          = Composition._⤖-∘_
+K-trans {k = implication}        = flip Composition._⟶-∘_
+K-trans {k = reverseImplication} = Composition._⟶-∘_
+K-trans {k = equivalence}        = flip Composition._⇔-∘_
+K-trans {k = injection}          = flip Composition._↣-∘_
+K-trans {k = reverseInjection}   = Composition._↣-∘_
+K-trans {k = leftInverse}        = flip Composition._↪-∘_
+K-trans {k = surjection}         = flip Composition._↠-∘_
+K-trans {k = bijection}          = flip Composition._↔-∘_
 
 SK-sym : ∀ {k} → Sym (Related {a} {b} ⌊ k ⌋)
                      (Related {b} {a} ⌊ k ⌋)
@@ -281,10 +281,10 @@ SK-isEquivalence k = record
 SK-setoid : SymmetricKind → (ℓ : Level) → Setoid _ _
 SK-setoid k ℓ = record { isEquivalence = SK-isEquivalence {ℓ} k }
 
-K-isPreorder : ∀ k → IsPreorder {ℓ = a} _⤖_ (Related k)
+K-isPreorder : ∀ k → IsPreorder {ℓ = a} _↔_ (Related k)
 K-isPreorder k = record
   { isEquivalence = SK-isEquivalence bijection
-  ; reflexive     = ⤖⇒
+  ; reflexive     = ↔⇒
   ; trans         = K-trans
   }
 
@@ -294,33 +294,39 @@ K-preorder k ℓ = record { isPreorder = K-isPreorder k }
 ------------------------------------------------------------------------
 -- Equational reasoning
 
--- Equational reasoning for related things.
+-- Equational reasoning for related things. Note that we don't use
+-- the `Relation.Binary.Reasoning.Syntax` for this as this relation
+-- is heterogeneous.
 
-module EquationalReasoning where
+module EquationalReasoning {k : Kind} where
 
-  infix  3 _∎
-  infixr 2 _∼⟨_⟩_ _⤖⟨_⟩_ _↔⟨_⟩_ _↔⟨⟩_ _≡⟨_⟩_
+  -- Combinators with one heterogeneous relation
+  module _ {a b : Level} where
+    open begin-syntax (Related {a} {b} k) id public
+    open ≡-noncomputing-syntax (Related {a} {b} k) public
 
-  _∼⟨_⟩_ : (A : Set a) → A ∼[ k ] B → B ∼[ k ] C → A ∼[ k ] C
-  _ ∼⟨ A↝B ⟩ B↝C = K-trans A↝B B↝C
+  -- Combinators with two heterogeneous relations
+  module _ {a b c : Level} where
+    private
+      rel1 = Related {b} {c} k
+      rel2 = Related {a} {c} k
 
-  -- Isomorphisms and bijections can be combined with any other kind of relatedness.
+    open ∼-syntax rel1 rel2 K-trans public
+    open ⤖-syntax rel1 rel2 (K-trans ∘′ ↔⇒ ∘′ ⤖⇒↔) Symmetry.⤖-sym public
+    open ↔-syntax rel1 rel2 (K-trans ∘′ ↔⇒) Symmetry.↔-sym public
 
-  _⤖⟨_⟩_ : (A : Set a) → A ⤖ B → B ∼[ k ] C → A ∼[ k ] C
-  A ⤖⟨ A⤖B ⟩ B⇔C = A ∼⟨ ⤖⇒ A⤖B ⟩ B⇔C
+  -- Combinators with homogeneous relations
+  module _ {a : Level} where
+    open end-syntax (Related {a} k) K-refl public
 
-  _↔⟨_⟩_ : (A : Set a) → A ↔ B → B ∼[ k ] C → A ∼[ k ] C
-  A ↔⟨ A↔B ⟩ B⇔C = A ∼⟨ ⤖⇒ (↔⇒⤖ A↔B) ⟩ B⇔C
 
+  infixr 2 _↔⟨⟩_
   _↔⟨⟩_ : (A : Set a) → A ∼[ k ] B → A ∼[ k ] B
   A ↔⟨⟩ A⇔B = A⇔B
-
-  _≡⟨_⟩_ : (A : Set a) → A ≡ B → B ∼[ k ] C → A ∼[ k ] C
-  A ≡⟨ A≡B ⟩ B⇔C = A ∼⟨ ≡⇒ A≡B ⟩ B⇔C
-
-  _∎ : (A : Set a) → A ∼[ k ] A
-  A ∎ = K-refl
-
+  {-# WARNING_ON_USAGE _↔⟨⟩_
+  "Warning: _↔⟨⟩_ was deprecated in v2.0.
+  Please use _≡⟨⟩_ instead. "
+  #-}
 
 ------------------------------------------------------------------------
 -- Every unary relation induces a preorder and, for symmetric kinds,
@@ -332,12 +338,12 @@ InducedRelation₁ k P = λ x y → P x ∼[ k ] P y
 InducedPreorder₁ : Kind → (P : A → Set p) → Preorder _ _ _
 InducedPreorder₁ k P = record
   { _≈_        = _≡_
-  ; _∼_        = InducedRelation₁ k P
+  ; _≲_        = InducedRelation₁ k P
   ; isPreorder = record
-    { isEquivalence = P.isEquivalence
+    { isEquivalence = ≡.isEquivalence
     ; reflexive     = reflexive ∘
                       K-reflexive ∘
-                      P.cong P
+                      ≡.cong P
     ; trans         = K-trans
     }
   } where open Preorder (K-preorder _ _)
@@ -362,13 +368,13 @@ InducedRelation₂ k _S_ = λ x y → ∀ {z} → (z S x) ∼[ k ] (z S y)
 InducedPreorder₂ : Kind → ∀ {s} → (A → B → Set s) → Preorder _ _ _
 InducedPreorder₂ k _S_ = record
   { _≈_        = _≡_
-  ; _∼_        = InducedRelation₂ k _S_
+  ; _≲_        = InducedRelation₂ k _S_
   ; isPreorder = record
-    { isEquivalence = P.isEquivalence
+    { isEquivalence = ≡.isEquivalence
     ; reflexive     = λ x≡y {z} →
                         reflexive $
                         K-reflexive $
-                        P.cong (_S_ z) x≡y
+                        ≡.cong (_S_ z) x≡y
 
     ; trans         = λ i↝j j↝k → K-trans i↝j j↝k
     }
diff --git a/src/Function/Related/TypeIsomorphisms.agda b/src/Function/Related/TypeIsomorphisms.agda
index cf151d9d3c..3386032654 100644
--- a/src/Function/Related/TypeIsomorphisms.agda
+++ b/src/Function/Related/TypeIsomorphisms.agda
@@ -13,61 +13,64 @@ open import Algebra
 open import Algebra.Structures.Biased using (isCommutativeSemiringˡ)
 open import Axiom.Extensionality.Propositional using (Extensionality)
 open import Data.Bool.Base using (true; false)
-open import Data.Empty using (⊥-elim)
-open import Data.Empty.Polymorphic using (⊥) renaming (⊥-elim to ⊥ₚ-elim)
-open import Data.Product as Prod hiding (swap)
+open import Data.Empty.Polymorphic using (⊥; ⊥-elim)
+open import Data.Product.Base as Product
+  using (_×_; Σ; curry; uncurry; _,_; -,_; <_,_>; proj₁; proj₂; ∃₂; ∃)
 open import Data.Product.Function.NonDependent.Propositional
 open import Data.Sum.Base as Sum
 open import Data.Sum.Properties using (swap-involutive)
 open import Data.Sum.Function.Propositional using (_⊎-cong_)
-open import Data.Unit.Polymorphic using (⊤)
+open import Data.Unit.Polymorphic.Base using (⊤)
 open import Level using (Level; Lift; 0ℓ; suc)
 open import Function.Base
-open import Function.Equality using (_⟨$⟩_)
-open import Function.Equivalence as Eq using (_⇔_; Equivalence)
-open import Function.Inverse as Inv using (_↔_; Inverse; inverse)
-open import Function.Related
+open import Function.Bundles
+open import Function.Related.Propositional
+import Function.Construct.Identity as Identity
 open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; _≗_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 open import Relation.Nullary.Reflects using (invert)
-open import Relation.Nullary using (Dec; ¬_; _because_; ofⁿ)
+open import Relation.Nullary using (Dec; ¬_; _because_; ofⁿ; contradiction)
 import Relation.Nullary.Indexed as I
 open import Relation.Nullary.Decidable using (True)
 
+private
+  variable
+    a b c d : Level
+    A B C D : Set a
+
 ------------------------------------------------------------------------
 -- Properties of Σ and _×_
 
 -- Σ is associative
-Σ-assoc : ∀ {a b c}
-            {A : Set a} {B : A → Set b} {C : (a : A) → B a → Set c} →
+Σ-assoc : ∀ {A : Set a} {B : A → Set b} {C : (a : A) → B a → Set c} →
           Σ (Σ A B) (uncurry C) ↔ Σ A (λ a → Σ (B a) (C a))
-Σ-assoc = inverse (λ where ((a , b) , c) → (a , b , c))
-                  (λ where (a , b , c) → ((a , b) , c))
-                  (λ _ → P.refl) (λ _ → P.refl)
+Σ-assoc = mk↔ₛ′ Product.assocʳ Product.assocˡ (λ _ → refl) (λ _ → refl)
 
 -- × is commutative
 
-×-comm : ∀ {a b} (A : Set a) (B : Set b) → (A × B) ↔ (B × A)
-×-comm _ _ = inverse Prod.swap Prod.swap (λ _ → P.refl) λ _ → P.refl
+×-comm : ∀ (A : Set a) (B : Set b) → (A × B) ↔ (B × A)
+×-comm _ _ = mk↔ₛ′ Product.swap Product.swap (λ _ → refl) λ _ → refl
 
 -- × has ⊤ as its identity
 
-×-identityˡ : ∀ ℓ → LeftIdentity _↔_ (⊤ {ℓ}) _×_
-×-identityˡ _ _ = inverse proj₂ -,_ (λ _ → P.refl) (λ _ → P.refl)
+×-identityˡ : ∀ ℓ → LeftIdentity  {ℓ = ℓ} _↔_ ⊤ _×_
+×-identityˡ _ _ = mk↔ₛ′ proj₂ -,_ (λ _ → refl) (λ _ → refl)
 
-×-identityʳ : ∀ ℓ → RightIdentity _↔_ (⊤ {ℓ}) _×_
-×-identityʳ _ _ = inverse proj₁ (_, _) (λ _ → P.refl) (λ _ → P.refl)
+×-identityʳ : ∀ ℓ → RightIdentity  {ℓ = ℓ} _↔_ ⊤ _×_
+×-identityʳ _ _ = mk↔ₛ′ proj₁ (_, _) (λ _ → refl) (λ _ → refl)
 
 ×-identity : ∀ ℓ → Identity _↔_ ⊤ _×_
 ×-identity ℓ = ×-identityˡ ℓ , ×-identityʳ ℓ
 
 -- × has ⊥ has its zero
 
-×-zeroˡ : ∀ ℓ → LeftZero _↔_ (⊥ {ℓ}) _×_
-×-zeroˡ ℓ A = inverse proj₁ < id , ⊥ₚ-elim > (λ { () }) (λ _ → P.refl)
+×-zeroˡ : ∀ ℓ → LeftZero {ℓ = ℓ} _↔_ ⊥ _×_
+×-zeroˡ ℓ A = mk↔ₛ′ proj₁ < id , ⊥-elim > (λ _ → refl) (λ { () })
 
-×-zeroʳ : ∀ ℓ → RightZero _↔_ (⊥ {ℓ}) _×_
-×-zeroʳ ℓ A = inverse proj₂ < ⊥ₚ-elim , id > (λ { () }) λ _ → P.refl
+×-zeroʳ : ∀ ℓ → RightZero {ℓ = ℓ} _↔_ ⊥ _×_
+×-zeroʳ ℓ A = mk↔ₛ′ proj₂ < ⊥-elim , id > (λ _ → refl) (λ { () })
 
 ×-zero : ∀ ℓ → Zero _↔_ ⊥ _×_
 ×-zero ℓ  = ×-zeroˡ ℓ , ×-zeroʳ ℓ
@@ -78,26 +81,26 @@ open import Relation.Nullary.Decidable using (True)
 -- ⊎ is associative
 
 ⊎-assoc : ∀ ℓ → Associative {ℓ = ℓ} _↔_ _⊎_
-⊎-assoc ℓ _ _ _ = inverse
+⊎-assoc ℓ _ _ _ = mk↔ₛ′
   [ [ inj₁ , inj₂ ∘′ inj₁ ]′ , inj₂ ∘′ inj₂ ]′
   [ inj₁ ∘′ inj₁ , [ inj₁ ∘′ inj₂ , inj₂ ]′ ]′
-  [ [ (λ _ → P.refl) , (λ _ → P.refl) ] , (λ _ → P.refl) ]
-  [ (λ _ → P.refl) , [ (λ _ → P.refl) , (λ _ → P.refl) ] ]
+  [ (λ _ → refl) , [ (λ _ → refl) , (λ _ → refl) ] ]
+  [ [ (λ _ → refl) , (λ _ → refl) ] , (λ _ → refl) ]
 
 -- ⊎ is commutative
 
-⊎-comm : ∀ {a b} (A : Set a) (B : Set b) → (A ⊎ B) ↔ (B ⊎ A)
-⊎-comm _ _ = inverse swap swap swap-involutive swap-involutive
+⊎-comm : ∀ (A : Set a) (B : Set b) → (A ⊎ B) ↔ (B ⊎ A)
+⊎-comm _ _ = mk↔ₛ′ swap swap swap-involutive swap-involutive
 
 -- ⊎ has ⊥ as its identity
 
 ⊎-identityˡ : ∀ ℓ → LeftIdentity _↔_ (⊥ {ℓ}) _⊎_
-⊎-identityˡ _ _ = inverse [ (λ ()) , id ]′ inj₂
-                          [ (λ ()) , (λ _ → P.refl) ] (λ _ → P.refl)
+⊎-identityˡ _ _ = mk↔ₛ′ [ (λ ()) , id ]′ inj₂ (λ _ → refl)
+                          [ (λ ()) , (λ _ → refl) ]
 
 ⊎-identityʳ : ∀ ℓ → RightIdentity _↔_ (⊥ {ℓ}) _⊎_
-⊎-identityʳ _ _ = inverse [ id , (λ ()) ]′ inj₁
-                          [ (λ _ → P.refl) , (λ ()) ] (λ _ → P.refl)
+⊎-identityʳ _ _ = mk↔ₛ′ [ id , (λ ()) ]′ inj₁ (λ _ → refl)
+                          [ (λ _ → refl) , (λ ()) ]
 
 ⊎-identity : ∀ ℓ → Identity _↔_ ⊥ _⊎_
 ⊎-identity ℓ = ⊎-identityˡ ℓ , ⊎-identityʳ ℓ
@@ -108,18 +111,18 @@ open import Relation.Nullary.Decidable using (True)
 -- × distributes over ⊎
 
 ×-distribˡ-⊎ : ∀ ℓ → _DistributesOverˡ_ {ℓ = ℓ} _↔_ _×_ _⊎_
-×-distribˡ-⊎ ℓ _ _ _ = inverse
+×-distribˡ-⊎ ℓ _ _ _ = mk↔ₛ′
   (uncurry λ x → [ inj₁ ∘′ (x ,_) , inj₂ ∘′ (x ,_) ]′)
-  [ Prod.map₂ inj₁ , Prod.map₂ inj₂ ]′
-  (uncurry λ _ → [ (λ _ → P.refl) , (λ _ → P.refl) ])
-  [ (λ _ → P.refl) , (λ _ → P.refl) ]
+  [ Product.map₂ inj₁ , Product.map₂ inj₂ ]′
+  [ (λ _ → refl) , (λ _ → refl) ]
+  (uncurry λ _ → [ (λ _ → refl) , (λ _ → refl) ])
 
 ×-distribʳ-⊎ : ∀ ℓ → _DistributesOverʳ_ {ℓ = ℓ} _↔_ _×_ _⊎_
-×-distribʳ-⊎ ℓ _ _ _ = inverse
+×-distribʳ-⊎ ℓ _ _ _ = mk↔ₛ′
   (uncurry [ curry inj₁ , curry inj₂ ]′)
-  [ Prod.map₁ inj₁ , Prod.map₁ inj₂ ]′
-  (uncurry [ (λ _ _ → P.refl) , (λ _ _ → P.refl) ])
-  [ (λ _ → P.refl) , (λ _ → P.refl) ]
+  [ Product.map₁ inj₁ , Product.map₁ inj₂ ]′
+  [ (λ _ → refl) , (λ _ → refl) ]
+  (uncurry [ (λ _ _ → refl) , (λ _ _ → refl) ])
 
 ×-distrib-⊎ : ∀ ℓ → _DistributesOver_ {ℓ = ℓ} _↔_ _×_ _⊎_
 ×-distrib-⊎ ℓ = ×-distribˡ-⊎ ℓ , ×-distribʳ-⊎ ℓ
@@ -131,11 +134,11 @@ open import Relation.Nullary.Decidable using (True)
 
 ×-isMagma : ∀ k ℓ → IsMagma {Level.suc ℓ} (Related ⌊ k ⌋) _×_
 ×-isMagma k ℓ = record
-  { isEquivalence = SK-isEquivalence k ℓ
+  { isEquivalence = SK-isEquivalence k
   ; ∙-cong        = _×-cong_
   }
 
-×-magma : Symmetric-kind → (ℓ : Level) → Magma _ _
+×-magma : SymmetricKind → (ℓ : Level) → Magma _ _
 ×-magma k ℓ = record
   { isMagma = ×-isMagma k ℓ
   }
@@ -146,7 +149,7 @@ open import Relation.Nullary.Decidable using (True)
   ; assoc   = λ _ _ _ → ↔⇒ Σ-assoc
   }
 
-×-semigroup : Symmetric-kind → (ℓ : Level) → Semigroup _ _
+×-semigroup : SymmetricKind → (ℓ : Level) → Semigroup _ _
 ×-semigroup k ℓ = record
   { isSemigroup = ×-isSemigroup k ℓ
   }
@@ -157,7 +160,7 @@ open import Relation.Nullary.Decidable using (True)
   ; identity    = (↔⇒ ∘ ×-identityˡ ℓ) , (↔⇒ ∘ ×-identityʳ ℓ)
   }
 
-×-monoid : Symmetric-kind → (ℓ : Level) → Monoid _ _
+×-monoid : SymmetricKind → (ℓ : Level) → Monoid _ _
 ×-monoid k ℓ = record
   { isMonoid = ×-isMonoid k ℓ
   }
@@ -168,7 +171,7 @@ open import Relation.Nullary.Decidable using (True)
   ; comm     = λ _ _ → ↔⇒ (×-comm _ _)
   }
 
-×-commutativeMonoid : Symmetric-kind → (ℓ : Level) → CommutativeMonoid _ _
+×-commutativeMonoid : SymmetricKind → (ℓ : Level) → CommutativeMonoid _ _
 ×-commutativeMonoid k ℓ = record
   { isCommutativeMonoid = ×-isCommutativeMonoid k ℓ
   }
@@ -177,11 +180,11 @@ open import Relation.Nullary.Decidable using (True)
 
 ⊎-isMagma : ∀ k ℓ → IsMagma {Level.suc ℓ} (Related ⌊ k ⌋) _⊎_
 ⊎-isMagma k ℓ = record
-  { isEquivalence = SK-isEquivalence k ℓ
+  { isEquivalence = SK-isEquivalence k
   ; ∙-cong        = _⊎-cong_
   }
 
-⊎-magma : Symmetric-kind → (ℓ : Level) → Magma _ _
+⊎-magma : SymmetricKind → (ℓ : Level) → Magma _ _
 ⊎-magma k ℓ = record
   { isMagma = ⊎-isMagma k ℓ
   }
@@ -192,7 +195,7 @@ open import Relation.Nullary.Decidable using (True)
   ; assoc   = λ A B C → ↔⇒ (⊎-assoc ℓ A B C)
   }
 
-⊎-semigroup : Symmetric-kind → (ℓ : Level) → Semigroup _ _
+⊎-semigroup : SymmetricKind → (ℓ : Level) → Semigroup _ _
 ⊎-semigroup k ℓ = record
   { isSemigroup = ⊎-isSemigroup k ℓ
   }
@@ -203,7 +206,7 @@ open import Relation.Nullary.Decidable using (True)
   ; identity    = (↔⇒ ∘ ⊎-identityˡ ℓ) , (↔⇒ ∘ ⊎-identityʳ ℓ)
   }
 
-⊎-monoid : Symmetric-kind → (ℓ : Level) → Monoid _ _
+⊎-monoid : SymmetricKind → (ℓ : Level) → Monoid _ _
 ⊎-monoid k ℓ = record
   { isMonoid = ⊎-isMonoid k ℓ
   }
@@ -214,7 +217,7 @@ open import Relation.Nullary.Decidable using (True)
   ; comm     = λ _ _ → ↔⇒ (⊎-comm _ _)
   }
 
-⊎-commutativeMonoid : Symmetric-kind → (ℓ : Level) →
+⊎-commutativeMonoid : SymmetricKind → (ℓ : Level) →
                       CommutativeMonoid _ _
 ⊎-commutativeMonoid k ℓ = record
   { isCommutativeMonoid = ⊎-isCommutativeMonoid k ℓ
@@ -229,7 +232,7 @@ open import Relation.Nullary.Decidable using (True)
   ; zeroˡ                 = ↔⇒ ∘ ×-zeroˡ ℓ
   }
 
-×-⊎-commutativeSemiring : Symmetric-kind → (ℓ : Level) →
+×-⊎-commutativeSemiring : SymmetricKind → (ℓ : Level) →
                           CommutativeSemiring (Level.suc ℓ) ℓ
 ×-⊎-commutativeSemiring k ℓ = record
   { isCommutativeSemiring = ×-⊎-isCommutativeSemiring k ℓ
@@ -240,11 +243,11 @@ open import Relation.Nullary.Decidable using (True)
 
 ΠΠ↔ΠΠ : ∀ {a b p} {A : Set a} {B : Set b} (P : A → B → Set p) →
         ((x : A) (y : B) → P x y) ↔ ((y : B) (x : A) → P x y)
-ΠΠ↔ΠΠ _ = inverse flip flip (λ _ → P.refl) (λ _ → P.refl)
+ΠΠ↔ΠΠ _ = mk↔ₛ′ flip flip (λ _ → refl) (λ _ → refl)
 
 ∃∃↔∃∃ : ∀ {a b p} {A : Set a} {B : Set b} (P : A → B → Set p) →
         (∃₂ λ x y → P x y) ↔ (∃₂ λ y x → P x y)
-∃∃↔∃∃ P = inverse to from (λ _ → P.refl) (λ _ → P.refl)
+∃∃↔∃∃ P = mk↔ₛ′ to from (λ _ → refl) (λ _ → refl)
   where
   to : (∃₂ λ x y → P x y) → (∃₂ λ y x → P x y)
   to (x , y , Pxy) = (y , x , Pxy)
@@ -255,57 +258,51 @@ open import Relation.Nullary.Decidable using (True)
 ------------------------------------------------------------------------
 -- Implicit and explicit function spaces are isomorphic
 
-Π↔Π : ∀ {a b} {A : Set a} {B : A → Set b} →
+Π↔Π : ∀ {A : Set a} {B : A → Set b} →
       ((x : A) → B x) ↔ ({x : A} → B x)
-Π↔Π = inverse (λ f {x} → f x) (λ f x → f) (λ _ → P.refl) (λ _ → P.refl)
+Π↔Π = mk↔ₛ′ _$- λ- (λ _ → refl) (λ _ → refl)
 
 ------------------------------------------------------------------------
 -- _→_ preserves the symmetric relations
 
-_→-cong-⇔_ :
-  ∀ {a b c d} {A : Set a} {B : Set b} {C : Set c} {D : Set d} →
-  A ⇔ B → C ⇔ D → (A → C) ⇔ (B → D)
-A⇔B →-cong-⇔ C⇔D = Eq.equivalence
-  (λ f x → Equivalence.to   C⇔D ⟨$⟩ f (Equivalence.from A⇔B ⟨$⟩ x))
-  (λ f x → Equivalence.from C⇔D ⟨$⟩ f (Equivalence.to   A⇔B ⟨$⟩ x))
-
-→-cong :
-  ∀ {a b c d} →
-  Extensionality a c → Extensionality b d →
-  ∀ {k} {A : Set a} {B : Set b} {C : Set c} {D : Set d} →
-  A ∼[ ⌊ k ⌋ ] B → C ∼[ ⌊ k ⌋ ] D → (A → C) ∼[ ⌊ k ⌋ ] (B → D)
-→-cong extAC extBD {equivalence} A⇔B C⇔D = A⇔B →-cong-⇔ C⇔D
-→-cong extAC extBD {bijection}   A↔B C↔D = record
-  { to         = Equivalence.to   A→C⇔B→D
-  ; from       = Equivalence.from A→C⇔B→D
-  ; inverse-of = record
-    { left-inverse-of  = λ f → extAC λ x → begin
-        Inverse.from C↔D ⟨$⟩ (Inverse.to C↔D ⟨$⟩
-          f (Inverse.from A↔B ⟨$⟩ (Inverse.to A↔B ⟨$⟩ x)))  ≡⟨ Inverse.left-inverse-of C↔D _ ⟩
-        f (Inverse.from A↔B ⟨$⟩ (Inverse.to A↔B ⟨$⟩ x))     ≡⟨ P.cong f $ Inverse.left-inverse-of A↔B x ⟩
-        f x                                                 ∎
-    ; right-inverse-of = λ f → extBD λ x → begin
-        Inverse.to C↔D ⟨$⟩ (Inverse.from C↔D ⟨$⟩
-          f (Inverse.to A↔B ⟨$⟩ (Inverse.from A↔B ⟨$⟩ x)))  ≡⟨ Inverse.right-inverse-of C↔D _ ⟩
-        f (Inverse.to A↔B ⟨$⟩ (Inverse.from A↔B ⟨$⟩ x))     ≡⟨ P.cong f $ Inverse.right-inverse-of A↔B x ⟩
-        f x                                                 ∎
-    }
-  }
-  where
-  open P.≡-Reasoning
-  A→C⇔B→D = ↔⇒ A↔B →-cong-⇔ ↔⇒ C↔D
+→-cong-⇔ : A ⇔ B → C ⇔ D → (A → C) ⇔ (B → D)
+→-cong-⇔ A⇔B C⇔D = mk⇔
+  (λ f → to C⇔D ∘ f ∘ from A⇔B)
+  (λ f → from C⇔D ∘ f ∘ to A⇔B)
+  where open Equivalence
+
+→-cong-↔ : Extensionality a c → Extensionality b d →
+             {A : Set a} {B : Set b} {C : Set c} {D : Set d} →
+             A ↔ B → C ↔ D → (A → C) ↔ (B → D)
+→-cong-↔ ext₁ ext₂ A↔B C↔D = mk↔ₛ′
+  (λ f → to C↔D ∘ f ∘ from A↔B)
+  (λ f → from C↔D ∘ f ∘ to A↔B)
+  (λ f → ext₂ λ x → begin
+    to C↔D (from C↔D (f (to A↔B (from A↔B x)))) ≡⟨ strictlyInverseˡ C↔D _ ⟩
+    f (to A↔B (from A↔B x))                     ≡⟨ cong f $ strictlyInverseˡ A↔B x ⟩
+    f x                                         ∎)
+  (λ f → ext₁ λ x → begin
+    from C↔D (to C↔D (f (from A↔B (to A↔B x)))) ≡⟨ strictlyInverseʳ C↔D _ ⟩
+    f (from A↔B (to A↔B x))                     ≡⟨ cong f $ strictlyInverseʳ A↔B x ⟩
+    f x                                         ∎)
+  where open Inverse; open ≡-Reasoning
+
+→-cong :  Extensionality a c → Extensionality b d →
+          ∀ {k} {A : Set a} {B : Set b} {C : Set c} {D : Set d} →
+          A ∼[ ⌊ k ⌋ ] B → C ∼[ ⌊ k ⌋ ] D → (A → C) ∼[ ⌊ k ⌋ ] (B → D)
+→-cong extAC extBD {equivalence} = →-cong-⇔
+→-cong extAC extBD {bijection}   = →-cong-↔ extAC extBD
 
 ------------------------------------------------------------------------
 -- ¬_ (at Level 0) preserves the symmetric relations
 
-¬-cong-⇔ : ∀ {a b} {A : Set a} {B : Set b} →
-           A ⇔ B → (¬ A) ⇔ (¬ B)
-¬-cong-⇔ A⇔B =  A⇔B →-cong-⇔ Eq.id
+¬-cong-⇔ : A ⇔ B → (¬ A) ⇔ (¬ B)
+¬-cong-⇔ A⇔B = →-cong-⇔ A⇔B (Identity.⇔-id _)
 
-¬-cong : ∀ {a b} → Extensionality a 0ℓ → Extensionality b 0ℓ →
+¬-cong : Extensionality a 0ℓ → Extensionality b 0ℓ →
          ∀ {k} {A : Set a} {B : Set b} →
          A ∼[ ⌊ k ⌋ ] B → (¬ A) ∼[ ⌊ k ⌋ ] (¬ B)
-¬-cong extA extB A≈B = →-cong extA extB A≈B (K-reflexive P.refl)
+¬-cong extA extB A≈B = →-cong extA extB A≈B (K-reflexive refl)
 
 ------------------------------------------------------------------------
 -- _⇔_ preserves _⇔_
@@ -313,17 +310,17 @@ A⇔B →-cong-⇔ C⇔D = Eq.equivalence
 -- The type of the following proof is a bit more general.
 
 Related-cong :
-  ∀ {k a b c d} {A : Set a} {B : Set b} {C : Set c} {D : Set d} →
+  ∀ {k} →
   A ∼[ ⌊ k ⌋ ] B → C ∼[ ⌊ k ⌋ ] D → (A ∼[ ⌊ k ⌋ ] C) ⇔ (B ∼[ ⌊ k ⌋ ] D)
-Related-cong {A = A} {B} {C} {D} A≈B C≈D =
-  Eq.equivalence (λ A≈C → B  ∼⟨ SK-sym A≈B ⟩
-                          A  ∼⟨ A≈C ⟩
-                          C  ∼⟨ C≈D ⟩
-                          D  ∎)
-                 (λ B≈D → A  ∼⟨ A≈B ⟩
-                          B  ∼⟨ B≈D ⟩
-                          D  ∼⟨ SK-sym C≈D ⟩
-                          C  ∎)
+Related-cong {A = A} {B = B} {C = C} {D = D} A≈B C≈D = mk⇔
+  (λ A≈C → B  ∼⟨ SK-sym A≈B ⟩
+            A  ∼⟨ A≈C ⟩
+            C  ∼⟨ C≈D ⟩
+            D  ∎)
+  (λ B≈D → A  ∼⟨ A≈B ⟩
+            B  ∼⟨ B≈D ⟩
+            D  ∼⟨ SK-sym C≈D ⟩
+            C  ∎)
   where open EquationalReasoning
 
 ------------------------------------------------------------------------
@@ -332,58 +329,6 @@ Related-cong {A = A} {B} {C} {D} A≈B C≈D =
 True↔ : ∀ {p} {P : Set p}
         (dec : Dec P) → ((p₁ p₂ : P) → p₁ ≡ p₂) → True dec ↔ P
 True↔ ( true because  [p]) irr =
-  inverse (λ _ → invert [p]) (λ _ → _) (λ _ → P.refl) (irr _)
+  mk↔ₛ′ (λ _ → invert [p]) (λ _ → _) (irr _) (λ _ → refl)
 True↔ (false because ofⁿ ¬p) _ =
-  inverse (λ()) (invert (ofⁿ ¬p)) (λ ()) (⊥-elim ∘ ¬p)
-
-------------------------------------------------------------------------
--- Equality between pairs can be expressed as a pair of equalities
-
-module _ {a b} {A : Set a} {B : A → Set b} {p₁ p₂ : Σ A B} where
-  Σ-≡,≡→≡ : Σ (proj₁ p₁ ≡ proj₁ p₂)
-              (λ p → P.subst B p (proj₂ p₁) ≡ proj₂ p₂) →
-            p₁ ≡ p₂
-  Σ-≡,≡→≡ (P.refl , P.refl) = P.refl
-
-  Σ-≡,≡←≡ : p₁ ≡ p₂ →
-            Σ (proj₁ p₁ ≡ proj₁ p₂)
-              (λ p → P.subst B p (proj₂ p₁) ≡ proj₂ p₂)
-  Σ-≡,≡←≡ P.refl = P.refl , P.refl
-
-  private
-
-    left-inverse-of : (p : Σ (proj₁ p₁ ≡ proj₁ p₂)
-                             (λ x → P.subst B x (proj₂ p₁) ≡ proj₂ p₂)) →
-                      Σ-≡,≡←≡ (Σ-≡,≡→≡ p) ≡ p
-    left-inverse-of (P.refl , P.refl) = P.refl
-
-    right-inverse-of : (p : p₁ ≡ p₂) → Σ-≡,≡→≡ (Σ-≡,≡←≡ p) ≡ p
-    right-inverse-of P.refl = P.refl
-
-  Σ-≡,≡↔≡ : (∃ λ (p : proj₁ p₁ ≡ proj₁ p₂) →
-               P.subst B p (proj₂ p₁) ≡ proj₂ p₂) ↔
-            p₁ ≡ p₂
-  Σ-≡,≡↔≡ = inverse Σ-≡,≡→≡ Σ-≡,≡←≡ left-inverse-of right-inverse-of
-
-module _ {a b} {A : Set a} {B : Set b} {p₁ p₂ : A × B} where
-  ×-≡,≡→≡ : (proj₁ p₁ ≡ proj₁ p₂) × (proj₂ p₁ ≡ proj₂ p₂) → p₁ ≡ p₂
-  ×-≡,≡→≡ (P.refl , P.refl) = P.refl
-
-  ×-≡,≡←≡ : p₁ ≡ p₂ →
-            (proj₁ p₁ ≡ proj₁ p₂) × (proj₂ p₁ ≡ proj₂ p₂)
-  ×-≡,≡←≡ P.refl = P.refl , P.refl
-
-  private
-    left-inverse-of : (p : (proj₁ p₁ ≡ proj₁ p₂) × (proj₂ p₁ ≡ proj₂ p₂)) →
-                      ×-≡,≡←≡ (×-≡,≡→≡ p) ≡ p
-    left-inverse-of (P.refl , P.refl) = P.refl
-
-    right-inverse-of : (p : p₁ ≡ p₂) → ×-≡,≡→≡ (×-≡,≡←≡ p) ≡ p
-    right-inverse-of P.refl = P.refl
-
-  ×-≡,≡↔≡ : (proj₁ p₁ ≡ proj₁ p₂ × proj₂ p₁ ≡ proj₂ p₂) ↔ p₁ ≡ p₂
-  ×-≡,≡↔≡ = inverse ×-≡,≡→≡ ×-≡,≡←≡ left-inverse-of right-inverse-of
-
-×-≡×≡↔≡,≡ : ∀ {a b} {A : Set a} {B : Set b} {x y} (p : A × B) →
-            (x ≡ proj₁ p × y ≡ proj₂ p) ↔ (x , y) ≡ p
-×-≡×≡↔≡,≡ _ = ×-≡,≡↔≡
+  mk↔ₛ′ (λ()) (invert (ofⁿ ¬p)) (λ x → flip contradiction ¬p x) (λ ())
diff --git a/src/Function/Related/TypeIsomorphisms/Solver.agda b/src/Function/Related/TypeIsomorphisms/Solver.agda
index 29f19c8afd..2d952ba82a 100644
--- a/src/Function/Related/TypeIsomorphisms/Solver.agda
+++ b/src/Function/Related/TypeIsomorphisms/Solver.agda
@@ -13,18 +13,19 @@ module Function.Related.TypeIsomorphisms.Solver where
 open import Algebra using (CommutativeSemiring)
 import Algebra.Solver.Ring.NaturalCoefficients.Default
 open import Data.Empty.Polymorphic using (⊥)
-open import Data.Product using (_×_)
+open import Data.Product.Base using (_×_)
 open import Data.Sum.Base using (_⊎_)
 open import Data.Unit.Polymorphic using (⊤)
 open import Level using (Level)
-open import Function.Inverse as Inv using (_↔_)
-open import Function.Related as Related
+open import Function.Bundles using (_↔_)
+open import Function.Properties.Inverse using (↔-refl)
+open import Function.Related.Propositional as Related
 open import Function.Related.TypeIsomorphisms
 
 ------------------------------------------------------------------------
 -- The solver
 
-module ×-⊎-Solver (k : Symmetric-kind) {ℓ} =
+module ×-⊎-Solver (k : SymmetricKind) {ℓ} =
   Algebra.Solver.Ring.NaturalCoefficients.Default
     (×-⊎-commutativeSemiring k ℓ)
 
@@ -39,5 +40,5 @@ private
          (⊤ × A × (B ⊎ C)) ↔ (A × B ⊎ C × (⊥ ⊎ A))
   test = solve 3 (λ A B C → con 1 :* (A :* (B :+ C)) :=
                             A :* B :+ C :* (con 0 :+ A))
-                 Inv.id
+                 ↔-refl
     where open ×-⊎-Solver bijection
diff --git a/src/Function/Relation/Binary/Setoid/Equality.agda b/src/Function/Relation/Binary/Setoid/Equality.agda
new file mode 100644
index 0000000000..6c530b0e9b
--- /dev/null
+++ b/src/Function/Relation/Binary/Setoid/Equality.agda
@@ -0,0 +1,51 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Function Equality setoid
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Bundles using (Setoid)
+
+module Function.Relation.Binary.Setoid.Equality {a₁ a₂ b₁ b₂ : Level}
+  (From : Setoid a₁ a₂) (To : Setoid b₁ b₂) where
+
+open import Function.Bundles using (Func; _⟨$⟩_)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
+open import Relation.Binary.Structures
+  using (IsEquivalence)
+
+private
+  module To = Setoid To
+  module From = Setoid From
+
+infix 4 _≈_
+_≈_ : (f g : Func From To) → Set (a₁ ⊔ b₂)
+f ≈ g = ∀ x → f ⟨$⟩ x To.≈ g ⟨$⟩ x
+
+refl : Reflexive _≈_
+refl _ = To.refl
+
+sym : Symmetric _≈_
+sym f≈g x = To.sym (f≈g x)
+
+trans : Transitive _≈_
+trans f≈g g≈h x = To.trans (f≈g x) (g≈h x)
+
+isEquivalence : IsEquivalence _≈_
+isEquivalence = record  -- need to η-expand else Agda gets confused
+  { refl = λ {f} → refl {f}
+  ; sym = λ {f} {g} → sym {f} {g}
+  ; trans = λ {f} {g} {h} → trans {f} {g} {h}
+  }
+
+setoid : Setoid _ _
+setoid = record { isEquivalence = isEquivalence }
+
+-- most of the time, this infix version is nicer to use
+infixr 9 _⇨_
+_⇨_ : Setoid _ _
+_⇨_ = setoid
diff --git a/src/Function/Structures.agda b/src/Function/Structures.agda
index 31004c2db4..9533cfb179 100644
--- a/src/Function/Structures.agda
+++ b/src/Function/Structures.agda
@@ -8,14 +8,16 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
 
 module Function.Structures {a b ℓ₁ ℓ₂}
   {A : Set a} (_≈₁_ : Rel A ℓ₁) -- Equality over the domain
   {B : Set b} (_≈₂_ : Rel B ℓ₂) -- Equality over the codomain
   where
 
-open import Data.Product using (∃; _×_; _,_)
+open import Data.Product.Base as Product using (∃; _×_; _,_)
 open import Function.Base
 open import Function.Definitions
 open import Level using (_⊔_)
@@ -64,6 +66,9 @@ record IsSurjection (f : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
 
   open IsCongruent isCongruent public
 
+  strictlySurjective : StrictlySurjective _≈₂_ f
+  strictlySurjective x = Product.map₂ (λ v → v Eq₁.refl) (surjective x)
+
 
 record IsBijection (f : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
   field
@@ -81,6 +86,9 @@ record IsBijection (f : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     ; surjective  = surjective
     }
 
+  open IsSurjection isSurjection public
+    using (strictlySurjective)
+
 
 ------------------------------------------------------------------------
 -- Two element structures
@@ -95,6 +103,15 @@ record IsLeftInverse (to : A → B) (from : B → A) : Set (a ⊔ b ⊔ ℓ₁ 
   open IsCongruent isCongruent public
     renaming (cong to to-cong)
 
+  strictlyInverseˡ : StrictlyInverseˡ _≈₂_ to from
+  strictlyInverseˡ x = inverseˡ Eq₁.refl
+
+  isSurjection : IsSurjection to
+  isSurjection = record
+    { isCongruent = isCongruent
+    ; surjective = λ y → from y , inverseˡ
+    }
+
 
 record IsRightInverse (to : A → B) (from : B → A) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
   field
@@ -103,7 +120,10 @@ record IsRightInverse (to : A → B) (from : B → A) : Set (a ⊔ b ⊔ ℓ₁
     inverseʳ    : Inverseʳ _≈₁_ _≈₂_ to from
 
   open IsCongruent isCongruent public
-    renaming (cong to cong₁)
+    renaming (cong to to-cong)
+
+  strictlyInverseʳ : StrictlyInverseʳ _≈₁_ to from
+  strictlyInverseʳ x = inverseʳ Eq₂.refl
 
 
 record IsInverse (to : A → B) (from : B → A) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
@@ -120,6 +140,9 @@ record IsInverse (to : A → B) (from : B → A) : Set (a ⊔ b ⊔ ℓ₁ ⊔ 
     ; inverseʳ    = inverseʳ
     }
 
+  open IsRightInverse isRightInverse public
+    using (strictlyInverseʳ)
+
   inverse : Inverseᵇ _≈₁_ _≈₂_ to from
   inverse = inverseˡ , inverseʳ
 
@@ -150,3 +173,17 @@ record IsBiInverse
 
   open IsCongruent to-isCongruent public
     renaming (cong to to-cong)
+
+
+------------------------------------------------------------------------
+-- Other
+------------------------------------------------------------------------
+
+-- See the comment on `SplitSurjection` in `Function.Bundles` for an
+-- explanation of (split) surjections.
+record IsSplitSurjection (f : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
+  field
+    from : B → A
+    isLeftInverse : IsLeftInverse f from
+
+  open IsLeftInverse isLeftInverse public
diff --git a/src/Function/Structures/Biased.agda b/src/Function/Structures/Biased.agda
new file mode 100644
index 0000000000..e25c4970c9
--- /dev/null
+++ b/src/Function/Structures/Biased.agda
@@ -0,0 +1,127 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Ways to give instances of certain structures where some fields can
+-- be given in terms of others.
+-- The contents of this file should usually be accessed from `Function`.
+------------------------------------------------------------------------
+
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+
+module Function.Structures.Biased {a b ℓ₁ ℓ₂}
+  {A : Set a} (_≈₁_ : Rel A ℓ₁) -- Equality over the domain
+  {B : Set b} (_≈₂_ : Rel B ℓ₂) -- Equality over the codomain
+  where
+
+open import Data.Product.Base as Product using (∃; _×_; _,_)
+open import Function.Base
+open import Function.Definitions
+open import Function.Structures _≈₁_ _≈₂_
+open import Function.Consequences.Setoid
+open import Level using (_⊔_)
+
+------------------------------------------------------------------------
+-- Surjection
+------------------------------------------------------------------------
+
+record IsStrictSurjection (f : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
+  field
+    isCongruent : IsCongruent f
+    strictlySurjective : StrictlySurjective _≈₂_ f
+
+  open IsCongruent isCongruent public
+
+  isSurjection : IsSurjection f
+  isSurjection = record
+    { isCongruent = isCongruent
+    ; surjective = strictlySurjective⇒surjective
+        Eq₁.setoid Eq₂.setoid cong strictlySurjective
+    }
+
+open IsStrictSurjection public
+  using () renaming (isSurjection to isStrictSurjection)
+
+------------------------------------------------------------------------
+-- Bijection
+------------------------------------------------------------------------
+
+record IsStrictBijection (f : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
+  field
+    isInjection : IsInjection f
+    strictlySurjective  : StrictlySurjective _≈₂_ f
+
+  isBijection : IsBijection f
+  isBijection = record
+    { isInjection = isInjection
+    ; surjective = strictlySurjective⇒surjective
+        Eq₁.setoid Eq₂.setoid cong strictlySurjective
+    } where open IsInjection isInjection
+
+open IsStrictBijection public
+  using () renaming (isBijection to isStrictBijection)
+
+------------------------------------------------------------------------
+-- Left inverse
+------------------------------------------------------------------------
+
+record IsStrictLeftInverse (to : A → B) (from : B → A) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
+  field
+    isCongruent  : IsCongruent to
+    from-cong    : Congruent _≈₂_ _≈₁_ from
+    strictlyInverseˡ : StrictlyInverseˡ _≈₂_ to from
+
+  isLeftInverse : IsLeftInverse to from
+  isLeftInverse = record
+    { isCongruent = isCongruent
+    ; from-cong = from-cong
+    ; inverseˡ = strictlyInverseˡ⇒inverseˡ
+        Eq₁.setoid Eq₂.setoid cong strictlyInverseˡ
+    } where open IsCongruent isCongruent
+
+open IsStrictLeftInverse public
+  using () renaming (isLeftInverse to isStrictLeftInverse)
+
+------------------------------------------------------------------------
+-- Right inverse
+------------------------------------------------------------------------
+
+record IsStrictRightInverse (to : A → B) (from : B → A) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
+  field
+    isCongruent : IsCongruent to
+    from-cong   : Congruent _≈₂_ _≈₁_ from
+    strictlyInverseʳ : StrictlyInverseʳ _≈₁_ to from
+
+  isRightInverse : IsRightInverse to from
+  isRightInverse = record
+    { isCongruent = isCongruent
+    ; from-cong = from-cong
+    ; inverseʳ = strictlyInverseʳ⇒inverseʳ
+        Eq₁.setoid Eq₂.setoid from-cong strictlyInverseʳ
+    } where open IsCongruent isCongruent
+
+open IsStrictRightInverse public
+  using () renaming (isRightInverse to isStrictRightInverse)
+
+------------------------------------------------------------------------
+-- Inverse
+------------------------------------------------------------------------
+
+record IsStrictInverse (to : A → B) (from : B → A) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
+  field
+    isLeftInverse : IsLeftInverse to from
+    strictlyInverseʳ : StrictlyInverseʳ _≈₁_ to from
+
+  isInverse : IsInverse to from
+  isInverse = record
+    { isLeftInverse = isLeftInverse
+    ; inverseʳ      = strictlyInverseʳ⇒inverseʳ
+        Eq₁.setoid Eq₂.setoid from-cong strictlyInverseʳ
+    } where open IsLeftInverse isLeftInverse
+
+open IsStrictInverse public
+  using () renaming (isInverse to isStrictInverse)
diff --git a/src/Function/Surjection.agda b/src/Function/Surjection.agda
index 12f4490f3e..684da0b3d7 100644
--- a/src/Function/Surjection.agda
+++ b/src/Function/Surjection.agda
@@ -1,27 +1,27 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Surjections
+-- This module is DEPRECATED.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
-
--- Note: use of the standard function hierarchy is encouraged. The
--- module `Function` re-exports `Surjective`, `IsSurjection` and
--- `Surjection`. The alternative definitions found in this file will
--- eventually be deprecated.
+{-# OPTIONS --warn=noUserWarning #-}
 
 module Function.Surjection where
 
+{-# WARNING_ON_IMPORT
+"Function.Surjection was deprecated in v2.0.
+Use the standard function hierarchy in Function/Function.Bundles instead."
+#-}
+
 open import Level
 open import Function.Equality as F
   using (_⟶_) renaming (_∘_ to _⟪∘⟫_)
 open import Function.Equivalence using (Equivalence)
 open import Function.Injection           hiding (id; _∘_; injection)
 open import Function.LeftInverse as Left hiding (id; _∘_)
-open import Data.Product
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)
 
 ------------------------------------------------------------------------
 -- Surjective functions.
@@ -33,6 +33,10 @@ record Surjective {f₁ f₂ t₁ t₂}
   field
     from             : To ⟶ From
     right-inverse-of : from RightInverseOf to
+{-# WARNING_ON_USAGE Surjective
+"Warning: Surjective was deprecated in v2.0.
+Please use Function.(Definitions.)Surjective instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all surjections from one setoid to another.
@@ -67,6 +71,10 @@ record Surjection {f₁ f₂ t₁ t₂}
     { to   = to
     ; from = from
     }
+{-# WARNING_ON_USAGE Surjection
+"Warning: Surjection was deprecated in v2.0.
+Please use Function.(Bundles.)Surjection instead."
+#-}
 
 -- Right inverses can be turned into surjections.
 
@@ -80,6 +88,10 @@ fromRightInverse r = record
     ; right-inverse-of = left-inverse-of
     }
   } where open LeftInverse r
+{-# WARNING_ON_USAGE fromRightInverse
+"Warning: fromRightInverse was deprecated in v2.0.
+Please use Function.(Properties.)RightInverse.RightInverse⇒Surjection instead."
+#-}
 
 ------------------------------------------------------------------------
 -- The set of all surjections from one set to another (i.e. sujections
@@ -88,19 +100,27 @@ fromRightInverse r = record
 infix 3 _↠_
 
 _↠_ : ∀ {f t} → Set f → Set t → Set _
-From ↠ To = Surjection (P.setoid From) (P.setoid To)
+From ↠ To = Surjection (≡.setoid From) (≡.setoid To)
+{-# WARNING_ON_USAGE _↠_
+"Warning: _↠_ was deprecated in v2.0.
+Please use Function.(Bundles.)_↠_ instead."
+#-}
 
 surjection : ∀ {f t} {From : Set f} {To : Set t} →
              (to : From → To) (from : To → From) →
              (∀ x → to (from x) ≡ x) →
              From ↠ To
 surjection to from surjective = record
-  { to         = P.→-to-⟶ to
+  { to         = F.→-to-⟶ to
   ; surjective = record
-    { from             = P.→-to-⟶ from
+    { from             = F.→-to-⟶ from
     ; right-inverse-of = surjective
     }
   }
+{-# WARNING_ON_USAGE surjection
+"Warning: surjection was deprecated in v2.0.
+Please use Function.(Bundles.)mk↠ instead."
+#-}
 
 ------------------------------------------------------------------------
 -- Identity and composition.
@@ -113,6 +133,11 @@ id {S = S} = record
     ; right-inverse-of = LeftInverse.left-inverse-of id′
     }
   } where id′ = Left.id {S = S}
+{-# WARNING_ON_USAGE id
+"Warning: id was deprecated in v2.0.
+Please use Function.Properties.Surjection.refl or
+Function.Construct.Identity.surjection instead."
+#-}
 
 infixr 9 _∘_
 
@@ -129,3 +154,8 @@ f ∘ g = record
   where
   open Surjection
   g∘f = Left._∘_ (right-inverse g) (right-inverse f)
+{-# WARNING_ON_USAGE _∘_
+"Warning: _∘_ was deprecated in v2.0.
+Please use Function.Properties.Surjection.trans or
+Function.Construct.Composition.surjection instead."
+#-}
diff --git a/src/IO.agda b/src/IO.agda
index eebb5d7d92..0462d9b8b9 100644
--- a/src/IO.agda
+++ b/src/IO.agda
@@ -11,10 +11,10 @@ module IO where
 open import Codata.Musical.Notation
 open import Codata.Musical.Costring
 open import Data.Unit.Polymorphic.Base
-open import Data.String.Base
+open import Data.String.Base using (String)
 import Data.Unit.Base as Unit0
 open import Function.Base using (_∘_; flip)
-import IO.Primitive as Prim
+import IO.Primitive.Core as Prim
 open import Level
 
 private
@@ -27,6 +27,7 @@ private
 -- Re-exporting the basic type and functions
 
 open import IO.Base public
+open import IO.Handle public
 
 ------------------------------------------------------------------------
 -- Utilities
diff --git a/src/IO/Base.agda b/src/IO/Base.agda
index cce93d922b..54aff90dfc 100644
--- a/src/IO/Base.agda
+++ b/src/IO/Base.agda
@@ -16,13 +16,14 @@ open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 import Agda.Builtin.Unit as Unit0
 open import Data.Unit.Polymorphic.Base
 open import Function.Base using (_∘′_; const; flip)
-import IO.Primitive as Prim
+import IO.Primitive.Core as Prim
 
 private
   variable
-    a b : Level
+    a b e : Level
     A : Set a
     B : Set b
+    E : Set e
 
 ------------------------------------------------------------------------
 -- The IO monad
@@ -78,9 +79,9 @@ module _ {A B : Set a} where
 -- Running programs
 
 -- A value of type `IO A` is a description of a computation that may
--- eventually produce an `A`. The `run` function converts this description
--- of a computation into calls to primitive functions that will actually
--- perform it.
+-- eventually produce an `A`. The `run` function converts this
+-- description of a computation into calls to primitive functions that
+-- will actually perform it.
 
 {-# NON_TERMINATING #-}
 run : IO A → Prim.IO A
@@ -106,18 +107,37 @@ lift′ io = lift (io Prim.>>= λ _ → Prim.pure _)
 ignore : IO A → IO ⊤
 ignore io = io >> pure _
 
+
+------------------------------------------------------------------------
 -- Conditional executions
+
+-- Only run the action if the boolean is true
 when : Bool → IO {a} ⊤ → IO ⊤
 when true m = m
 when false _ = pure _
 
+-- Only run the action if the boolean is false
 unless : Bool → IO {a} ⊤ → IO ⊤
 unless = when ∘′ not
 
+-- Run the action if the `Maybe` computation was successful
 whenJust : Maybe A → (A → IO {a} ⊤) → IO ⊤
 whenJust (just a) k = k a
 whenJust nothing  _ = pure _
 
+-- Run the action if the `E ⊎_` computation was successful
+whenInj₂ : E ⊎ A → (A → IO {a} ⊤) → IO ⊤
+whenInj₂ (inj₂ a) k = k a
+whenInj₂ (inj₁ _) _ = pure _
+
+
+------------------------------------------------------------------------
+-- Loops
+
+-- Keep running the action forever
+forever : IO {a} ⊤ → IO {a} ⊤
+forever act = seq (♯ act) (♯ forever act)
+
 -- Keep running an IO action until we get a value. Convenient when user
 -- input is involved and it may be malformed.
 untilJust : IO (Maybe A) → IO A
@@ -127,7 +147,22 @@ untilJust m = bind (♯ m) λ where
   nothing  → ♯ untilJust m
   (just a) → ♯ pure a
 
-untilRight : {A B : Set a} → (A → IO (A ⊎ B)) → A → IO B
-untilRight f x = bind (♯ f x) λ where
-  (inj₁ x′) → ♯ untilRight f x′
+untilInj₂ : {A B : Set a} → (A → IO (A ⊎ B)) → A → IO B
+untilInj₂ f x = bind (♯ f x) λ where
+  (inj₁ x′) → ♯ untilInj₂ f x′
   (inj₂ y) → ♯ pure y
+
+
+
+
+
+
+
+------------------------------------------------------------------------
+-- DEPRECATIONS
+
+untilRight = untilInj₂
+{-# WARNING_ON_USAGE untilRight
+"Warning: untilRight was deprecated in v2.1.
+Please use untilInj₂ instead."
+#-}
diff --git a/src/IO/Categorical.agda b/src/IO/Categorical.agda
new file mode 100644
index 0000000000..9e264a5283
--- /dev/null
+++ b/src/IO/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `IO.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --guardedness #-}
+
+module IO.Categorical where
+
+open import IO.Effectful public
+
+{-# WARNING_ON_IMPORT
+"IO.Categorical was deprecated in v2.0.
+Use IO.Effectful instead."
+#-}
diff --git a/src/IO/Finite.agda b/src/IO/Finite.agda
index 44b5edc050..1827d471b9 100644
--- a/src/IO/Finite.agda
+++ b/src/IO/Finite.agda
@@ -12,7 +12,7 @@ open import Data.Unit.Polymorphic.Base
 open import Agda.Builtin.String
 import Data.Unit.Base as Unit0
 open import IO.Base
-import IO.Primitive as Prim
+import IO.Primitive.Core as Prim
 import IO.Primitive.Finite as Prim
 open import Level
 
diff --git a/src/IO/Handle.agda b/src/IO/Handle.agda
new file mode 100644
index 0000000000..0c15906201
--- /dev/null
+++ b/src/IO/Handle.agda
@@ -0,0 +1,41 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- IO handles: simple bindings to Haskell types and functions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --guardedness #-}
+
+module IO.Handle where
+
+open import Level using (Level)
+open import Data.Unit.Polymorphic.Base using (⊤)
+open import IO.Base using (IO; lift; lift′)
+
+private variable a : Level
+
+------------------------------------------------------------------------
+-- Re-exporting types and constructors
+
+open import IO.Primitive.Handle as Prim public
+  using ( BufferMode
+        ; noBuffering
+        ; lineBuffering
+        ; blockBuffering
+        ; Handle
+        ; stdin
+        ; stdout
+        ; stderr
+        )
+
+------------------------------------------------------------------------
+-- Wrapping functions
+
+hSetBuffering : Handle → BufferMode → IO {a} ⊤
+hSetBuffering hdl bm = lift′ (Prim.hSetBuffering hdl bm)
+
+hGetBuffering : Handle → IO BufferMode
+hGetBuffering hdl = lift (Prim.hGetBuffering hdl)
+
+hFlush : Handle → IO {a} ⊤
+hFlush hdl = lift′ (Prim.hFlush hdl)
diff --git a/src/IO/Infinite.agda b/src/IO/Infinite.agda
index f2137cc4c6..90afd8989d 100644
--- a/src/IO/Infinite.agda
+++ b/src/IO/Infinite.agda
@@ -13,7 +13,7 @@ open import Agda.Builtin.String
 open import Data.Unit.Polymorphic.Base
 import Data.Unit.Base as Unit0
 open import IO.Base
-import IO.Primitive as Prim
+import IO.Primitive.Core as Prim
 import IO.Primitive.Infinite as Prim
 open import Level
 
diff --git a/src/IO/Primitive.agda b/src/IO/Primitive.agda
index 220e862fb4..324a32b643 100644
--- a/src/IO/Primitive.agda
+++ b/src/IO/Primitive.agda
@@ -1,29 +1,15 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Primitive IO: simple bindings to Haskell types and functions
+-- This module is DEPRECATED. Please use IO.Primitive.Core instead
 ------------------------------------------------------------------------
 
--- NOTE: the contents of this module should be accessed via `IO`.
-
 {-# OPTIONS --cubical-compatible #-}
 
 module IO.Primitive where
 
-open import Agda.Builtin.IO
-
-------------------------------------------------------------------------
--- The IO monad
-
-open import Agda.Builtin.IO public using (IO)
-
-infixl 1 _>>=_
-
-postulate
-  pure : ∀ {a} {A : Set a} → A → IO A
-  _>>=_  : ∀ {a b} {A : Set a} {B : Set b} → IO A → (A → IO B) → IO B
+open import IO.Primitive.Core public
 
-{-# COMPILE GHC pure = \_ _ -> return    #-}
-{-# COMPILE GHC _>>=_  = \_ _ _ _ -> (>>=) #-}
-{-# COMPILE UHC pure = \_ _ x -> UHC.Agda.Builtins.primReturn x #-}
-{-# COMPILE UHC _>>=_  = \_ _ _ _ x y -> UHC.Agda.Builtins.primBind x y #-}
+{-# WARNING_ON_IMPORT
+"IO.Primitive was deprecated in v2.1. Use IO.Primitive.Core instead."
+#-}
diff --git a/src/IO/Primitive/Core.agda b/src/IO/Primitive/Core.agda
new file mode 100644
index 0000000000..04fba8c6f8
--- /dev/null
+++ b/src/IO/Primitive/Core.agda
@@ -0,0 +1,41 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Primitive IO: simple bindings to Haskell types and functions
+------------------------------------------------------------------------
+
+-- NOTE: the contents of this module should be accessed via `IO`.
+
+{-# OPTIONS --cubical-compatible #-}
+
+module IO.Primitive.Core where
+
+open import Level using (Level)
+private
+  variable
+    a : Level
+    A B : Set a
+
+------------------------------------------------------------------------
+-- The IO monad
+
+open import Agda.Builtin.IO public
+  using (IO)
+
+infixl 1 _>>=_
+
+postulate
+  pure : A → IO A
+  _>>=_  : IO A → (A → IO B) → IO B
+
+{-# COMPILE GHC pure = \_ _ -> return    #-}
+{-# COMPILE GHC _>>=_  = \_ _ _ _ -> (>>=) #-}
+{-# COMPILE UHC pure = \_ _ x -> UHC.Agda.Builtins.primReturn x #-}
+{-# COMPILE UHC _>>=_  = \_ _ _ _ x y -> UHC.Agda.Builtins.primBind x y #-}
+
+-- Haskell-style alternative syntax
+return : A → IO A
+return = pure
+
+_>>_ : IO A → IO B → IO B
+a >> b = a >>= λ _ → b
diff --git a/src/IO/Primitive/Handle.agda b/src/IO/Primitive/Handle.agda
new file mode 100644
index 0000000000..f6b01a70be
--- /dev/null
+++ b/src/IO/Primitive/Handle.agda
@@ -0,0 +1,61 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Primitive IO handles: simple bindings to Haskell types and functions
+------------------------------------------------------------------------
+
+-- NOTE: the contents of this module should be accessed via `IO`.
+
+{-# OPTIONS --cubical-compatible #-}
+
+module IO.Primitive.Handle where
+
+open import Data.Maybe.Base using (Maybe)
+open import Data.Nat.Base using (ℕ)
+
+data BufferMode : Set where
+  noBuffering lineBuffering : BufferMode
+  blockBuffering : Maybe ℕ → BufferMode
+{-# FOREIGN GHC import System.IO #-}
+{-# FOREIGN GHC
+    data AgdaBufferMode
+      = AgdaNoBuffering
+      | AgdaLineBuffering
+      | AgdaBlockBuffering (Maybe Integer)
+    toBufferMode :: AgdaBufferMode -> BufferMode
+    toBufferMode x = case x of
+      AgdaNoBuffering       -> NoBuffering
+      AgdaLineBuffering     -> LineBuffering
+      AgdaBlockBuffering mi -> BlockBuffering (fromIntegral <$> mi)
+    fromBufferMode :: BufferMode -> AgdaBufferMode
+    fromBufferMode x = case x of
+      NoBuffering       -> AgdaNoBuffering
+      LineBuffering     -> AgdaLineBuffering
+      BlockBuffering mi -> AgdaBlockBuffering (fromIntegral <$> mi)
+#-}
+
+{-# COMPILE GHC BufferMode = data AgdaBufferMode
+                           ( AgdaNoBuffering
+                           | AgdaLineBuffering
+                           | AgdaBlockBuffering
+                           )
+#-}
+
+open import Data.Unit.Base using (⊤)
+open import IO.Primitive.Core using (IO)
+
+postulate
+  Handle : Set
+  stdin stdout stderr : Handle
+  hSetBuffering : Handle → BufferMode → IO ⊤
+  hGetBuffering : Handle → IO BufferMode
+  hFlush : Handle → IO ⊤
+
+{-# FOREIGN GHC import System.IO #-}
+{-# COMPILE GHC Handle = type Handle #-}
+{-# COMPILE GHC stdin = stdin #-}
+{-# COMPILE GHC stdout = stdout #-}
+{-# COMPILE GHC stderr = stderr #-}
+{-# COMPILE GHC hSetBuffering = \ h -> hSetBuffering h . toBufferMode #-}
+{-# COMPILE GHC hGetBuffering = fmap fromBufferMode . hGetBuffering #-}
+{-# COMPILE GHC hFlush = hFlush #-}
diff --git a/src/Induction.agda b/src/Induction.agda
index 56f0ae8267..03d7750b9e 100644
--- a/src/Induction.agda
+++ b/src/Induction.agda
@@ -17,45 +17,48 @@ module Induction where
 
 open import Level
 open import Relation.Unary
+open import Relation.Unary.PredicateTransformer using (PT)
 
+private
+  variable
+    a ℓ ℓ₁ ℓ₂ : Level
+    A : Set a
+    Q : Pred A ℓ
+    Rec : PT A A ℓ₁ ℓ₂
+
+
+------------------------------------------------------------------------
 -- A RecStruct describes the allowed structure of recursion. The
 -- examples in Data.Nat.Induction should explain what this is all
 -- about.
 
-RecStruct : ∀ {a} → Set a → (ℓ₁ ℓ₂ : Level) → Set _
-RecStruct A ℓ₁ ℓ₂ = Pred A ℓ₁ → Pred A ℓ₂
+RecStruct : Set a → (ℓ₁ ℓ₂ : Level) → Set _
+RecStruct A = PT A A
 
 -- A recursor builder constructs an instance of a recursion structure
 -- for a given input.
 
-RecursorBuilder : ∀ {a ℓ₁ ℓ₂} {A : Set a} → RecStruct A ℓ₁ ℓ₂ → Set _
+RecursorBuilder : RecStruct A ℓ₁ ℓ₂ → Set _
 RecursorBuilder Rec = ∀ P → Rec P ⊆′ P → Universal (Rec P)
 
 -- A recursor can be used to actually compute/prove something useful.
 
-Recursor : ∀ {a ℓ₁ ℓ₂} {A : Set a} → RecStruct A ℓ₁ ℓ₂ → Set _
+Recursor : RecStruct A ℓ₁ ℓ₂ → Set _
 Recursor Rec = ∀ P → Rec P ⊆′ P → Universal P
 
 -- And recursors can be constructed from recursor builders.
 
-build : ∀ {a ℓ₁ ℓ₂} {A : Set a} {Rec : RecStruct A ℓ₁ ℓ₂} →
-        RecursorBuilder Rec →
-        Recursor Rec
+build : RecursorBuilder Rec → Recursor Rec
 build builder P f x = f x (builder P f x)
 
 -- We can repeat the exercise above for subsets of the type we are
 -- recursing over.
 
-SubsetRecursorBuilder : ∀ {a ℓ₁ ℓ₂ ℓ₃} {A : Set a} →
-                        Pred A ℓ₁ → RecStruct A ℓ₂ ℓ₃ → Set _
+SubsetRecursorBuilder : Pred A ℓ → RecStruct A ℓ₁ ℓ₂ → Set _
 SubsetRecursorBuilder Q Rec = ∀ P → Rec P ⊆′ P → Q ⊆′ Rec P
 
-SubsetRecursor : ∀ {a ℓ₁ ℓ₂ ℓ₃} {A : Set a} →
-                 Pred A ℓ₁ → RecStruct A ℓ₂ ℓ₃ → Set _
+SubsetRecursor : Pred A ℓ → RecStruct A ℓ₁ ℓ₂ → Set _
 SubsetRecursor Q Rec = ∀ P → Rec P ⊆′ P → Q ⊆′ P
 
-subsetBuild : ∀ {a ℓ₁ ℓ₂ ℓ₃}
-                {A : Set a} {Q : Pred A ℓ₁} {Rec : RecStruct A ℓ₂ ℓ₃} →
-                SubsetRecursorBuilder Q Rec →
-                SubsetRecursor Q Rec
+subsetBuild : SubsetRecursorBuilder Q Rec → SubsetRecursor Q Rec
 subsetBuild builder P f x q = f x (builder P f x q)
diff --git a/src/Induction/InfiniteDescent.agda b/src/Induction/InfiniteDescent.agda
new file mode 100644
index 0000000000..ed25c880d5
--- /dev/null
+++ b/src/Induction/InfiniteDescent.agda
@@ -0,0 +1,189 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- A standard consequence of accessibility/well-foundedness:
+-- the impossibility of 'infinite descent' from any (accessible)
+-- element x satisfying P to 'smaller' y also satisfying P
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Induction.InfiniteDescent where
+
+open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
+open import Data.Nat.Properties as ℕ
+open import Data.Product.Base using (_,_; proj₁; ∃-syntax; _×_)
+open import Function.Base using (_∘_)
+open import Induction.WellFounded
+  using (WellFounded; Acc; acc; acc-inverse; module Some)
+open import Level using (Level)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Construct.Closure.Transitive
+open import Relation.Binary.PropositionalEquality.Core
+open import Relation.Nullary.Negation.Core as Negation using (¬_)
+open import Relation.Unary
+  using (Pred; ∁; _∩_; _⊆_;  _⇒_; Universal; IUniversal; Stable; Empty)
+
+private
+  variable
+    a r ℓ : Level
+    A : Set a
+    f : ℕ → A
+    _<_ : Rel A r
+    P : Pred A ℓ
+
+------------------------------------------------------------------------
+-- Definitions
+
+InfiniteDescendingSequence : Rel A r → (ℕ → A) → Set _
+InfiniteDescendingSequence _<_ f = ∀ n → f (suc n) < f n
+
+InfiniteDescendingSequenceFrom : Rel A r → (ℕ → A) → Pred A _
+InfiniteDescendingSequenceFrom _<_ f x = f zero ≡ x × InfiniteDescendingSequence _<_ f
+
+InfiniteDescendingSequence⁺ : Rel A r → (ℕ → A) → Set _
+InfiniteDescendingSequence⁺ _<_ f = ∀ {m n} → m ℕ.< n → TransClosure _<_ (f n) (f m)
+
+InfiniteDescendingSequenceFrom⁺ : Rel A r → (ℕ → A) → Pred A _
+InfiniteDescendingSequenceFrom⁺ _<_ f x = f zero ≡ x × InfiniteDescendingSequence⁺ _<_ f
+
+DescentFrom : Rel A r → Pred A ℓ → Pred A _
+DescentFrom _<_ P x = P x → ∃[ y ] y < x × P y
+
+Descent : Rel A r → Pred A ℓ → Set _
+Descent _<_ P = ∀ {x} → DescentFrom _<_ P x
+
+InfiniteDescentFrom : Rel A r → Pred A ℓ → Pred A _
+InfiniteDescentFrom _<_ P x = P x → ∃[ f ] InfiniteDescendingSequenceFrom _<_ f x × ∀ n → P (f n)
+
+InfiniteDescent : Rel A r → Pred A ℓ →  Set _
+InfiniteDescent _<_ P = ∀ {x} → InfiniteDescentFrom _<_ P x
+
+InfiniteDescentFrom⁺ : Rel A r → Pred A ℓ → Pred A _
+InfiniteDescentFrom⁺ _<_ P x = P x → ∃[ f ] InfiniteDescendingSequenceFrom⁺ _<_ f x × ∀ n → P (f n)
+
+InfiniteDescent⁺ : Rel A r → Pred A ℓ → Set _
+InfiniteDescent⁺ _<_ P = ∀ {x} → InfiniteDescentFrom⁺ _<_ P x
+
+NoSmallestCounterExample : Rel A r → Pred A ℓ →  Set _
+NoSmallestCounterExample _<_ P = ∀ {x} → Acc _<_ x → DescentFrom (TransClosure _<_) (∁ P) x
+
+------------------------------------------------------------------------
+-- We can swap between transitively closed and non-transitively closed
+-- definitions
+
+sequence⁺ : InfiniteDescendingSequence (TransClosure _<_) f →
+            InfiniteDescendingSequence⁺ _<_ f
+sequence⁺ {_<_ = _<_} {f = f} seq[f] = seq⁺[f]′ ∘ ℕ.<⇒<′
+  where
+  seq⁺[f]′ : ∀ {m n} → m ℕ.<′ n → TransClosure _<_ (f n) (f m)
+  seq⁺[f]′ ℕ.<′-base        = seq[f] _
+  seq⁺[f]′ (ℕ.<′-step m<′n) = seq[f] _ ++ seq⁺[f]′ m<′n
+
+sequence⁻ : InfiniteDescendingSequence⁺ _<_ f →
+            InfiniteDescendingSequence (TransClosure _<_) f
+sequence⁻ seq[f] = seq[f] ∘ n<1+n
+
+------------------------------------------------------------------------
+-- Results about unrestricted descent
+
+module _ (descent : Descent _<_ P) where
+
+  descent∧acc⇒infiniteDescentFrom : (Acc _<_) ⊆ (InfiniteDescentFrom _<_ P)
+  descent∧acc⇒infiniteDescentFrom {x} =
+    Some.wfRec (InfiniteDescentFrom _<_ P) rec x
+    where
+    rec : _
+    rec y rec[y] py
+      with z , z<y , pz ← descent py
+      with g , (g0≡z , g<P) , Π[P∘g] ← rec[y] z<y pz
+         = h , (h0≡y , h<P) , Π[P∘h]
+      where
+      h : ℕ → _
+      h zero = y
+      h (suc n) = g n
+
+      h0≡y : h zero ≡ y
+      h0≡y = refl
+
+      h<P : ∀ n → h (suc n) < h n
+      h<P zero rewrite g0≡z = z<y
+      h<P (suc n)           = g<P n
+
+      Π[P∘h] : ∀ n →  P (h n)
+      Π[P∘h] zero rewrite g0≡z = py
+      Π[P∘h] (suc n)           = Π[P∘g] n
+
+  descent∧wf⇒infiniteDescent : WellFounded _<_ → InfiniteDescent _<_ P
+  descent∧wf⇒infiniteDescent wf = descent∧acc⇒infiniteDescentFrom (wf _)
+
+  descent∧acc⇒unsatisfiable : Acc _<_ ⊆ ∁ P
+  descent∧acc⇒unsatisfiable {x} = Some.wfRec (∁ P) rec x
+    where
+    rec : _
+    rec y rec[y] py = let z , z<y , pz = descent py in rec[y] z<y pz
+
+  descent∧wf⇒empty : WellFounded _<_ → Empty P
+  descent∧wf⇒empty wf x = descent∧acc⇒unsatisfiable (wf x)
+
+------------------------------------------------------------------------
+-- Results about descent only from accessible elements
+
+module _ (accDescent : Acc _<_ ⊆ DescentFrom _<_ P) where
+
+  private
+    descent∩ : Descent _<_ (P ∩ Acc _<_)
+    descent∩ (px , acc[x]) =
+      let y , y<x , py = accDescent acc[x] px
+      in  y , y<x , py , acc-inverse acc[x] y<x
+
+  accDescent∧acc⇒infiniteDescentFrom : Acc _<_ ⊆ InfiniteDescentFrom _<_ P
+  accDescent∧acc⇒infiniteDescentFrom acc[x] px =
+    let f , sequence[f] , Π[[P∩Acc]∘f] = descent∧acc⇒infiniteDescentFrom descent∩ acc[x] (px , acc[x])
+    in f , sequence[f] , proj₁ ∘ Π[[P∩Acc]∘f]
+
+  accDescent∧wf⇒infiniteDescent : WellFounded _<_ → InfiniteDescent _<_ P
+  accDescent∧wf⇒infiniteDescent wf = accDescent∧acc⇒infiniteDescentFrom (wf _)
+
+  accDescent∧acc⇒unsatisfiable : Acc _<_ ⊆ ∁ P
+  accDescent∧acc⇒unsatisfiable acc[x] px = descent∧acc⇒unsatisfiable descent∩ acc[x] (px , acc[x])
+
+  wf⇒empty : WellFounded _<_ → Empty P
+  wf⇒empty wf x = accDescent∧acc⇒unsatisfiable (wf x)
+
+------------------------------------------------------------------------
+-- Results about transitively-closed descent only from accessible elements
+
+module _ (accDescent⁺ : Acc _<_ ⊆ DescentFrom (TransClosure _<_) P) where
+
+  private
+    descent : Acc (TransClosure _<_) ⊆ DescentFrom (TransClosure _<_) P
+    descent = accDescent⁺  ∘ accessible⁻ _
+
+  accDescent⁺∧acc⇒infiniteDescentFrom⁺ : Acc _<_ ⊆ InfiniteDescentFrom⁺ _<_ P
+  accDescent⁺∧acc⇒infiniteDescentFrom⁺ acc[x] px
+    with f , (f0≡x , sequence[f]) , Π[P∘f]
+       ← accDescent∧acc⇒infiniteDescentFrom descent (accessible _ acc[x]) px
+       = f , (f0≡x , sequence⁺ sequence[f]) , Π[P∘f]
+
+  accDescent⁺∧wf⇒infiniteDescent⁺ : WellFounded _<_ → InfiniteDescent⁺ _<_ P
+  accDescent⁺∧wf⇒infiniteDescent⁺ wf = accDescent⁺∧acc⇒infiniteDescentFrom⁺ (wf _)
+
+  accDescent⁺∧acc⇒unsatisfiable : Acc _<_ ⊆ ∁ P
+  accDescent⁺∧acc⇒unsatisfiable = accDescent∧acc⇒unsatisfiable descent ∘ accessible _
+
+  accDescent⁺∧wf⇒empty : WellFounded _<_ → Empty P
+  accDescent⁺∧wf⇒empty = wf⇒empty descent ∘ (wellFounded _)
+
+------------------------------------------------------------------------
+-- Finally: the (classical) no smallest counterexample principle itself
+
+module _ (stable : Stable P) (noSmallest : NoSmallestCounterExample _<_ P) where
+
+  noSmallestCounterExample∧acc⇒satisfiable : Acc _<_ ⊆ P
+  noSmallestCounterExample∧acc⇒satisfiable =
+    stable _ ∘ accDescent⁺∧acc⇒unsatisfiable noSmallest
+
+  noSmallestCounterExample∧wf⇒universal : WellFounded _<_ → Universal P
+  noSmallestCounterExample∧wf⇒universal wf =
+    stable _ ∘ accDescent⁺∧wf⇒empty noSmallest wf
diff --git a/src/Induction/Lexicographic.agda b/src/Induction/Lexicographic.agda
index 303f2c8dfa..d70b989acd 100644
--- a/src/Induction/Lexicographic.agda
+++ b/src/Induction/Lexicographic.agda
@@ -8,7 +8,7 @@
 
 module Induction.Lexicographic where
 
-open import Data.Product
+open import Data.Product.Base using (Σ; _,_; _×_)
 open import Induction
 open import Level
 
@@ -68,13 +68,13 @@ RecA ⊗ RecB = Σ-Rec RecA (λ _ → RecB)
 private
 
   open import Data.Nat.Base
-  open import Data.Nat.Induction as N
+  open import Data.Nat.Induction as ℕ
 
   -- The Ackermann function à la Rózsa Péter.
 
   ackermann : ℕ → ℕ → ℕ
   ackermann m n =
-    build [ N.recBuilder ⊗ N.recBuilder ]
+    build [ ℕ.recBuilder ⊗ ℕ.recBuilder ]
           (λ _ → ℕ)
           (λ { (zero  , n)     _                   → 1 + n
              ; (suc m , zero)  (_         , ackm•) → ackm• 1
diff --git a/src/Induction/WellFounded.agda b/src/Induction/WellFounded.agda
index 5c88529d27..1dac16c059 100644
--- a/src/Induction/WellFounded.agda
+++ b/src/Induction/WellFounded.agda
@@ -6,16 +6,20 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
-
 module Induction.WellFounded where
 
-open import Data.Product
-open import Function
+open import Data.Product.Base using (Σ; _,_; proj₁; proj₂)
+open import Function.Base using (_∘_; flip; _on_)
 open import Induction
-open import Level
-open import Relation.Binary.PropositionalEquality hiding (trans)
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions
+  using (Symmetric; Asymmetric; Irreflexive; _Respects₂_;
+    _Respectsʳ_; _Respects_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
+open import Relation.Binary.Consequences using (asym⇒irr)
 open import Relation.Unary
+open import Relation.Nullary.Negation.Core using (¬_)
 
 private
   variable
@@ -31,7 +35,7 @@ private
 -- well-founded.
 
 WfRec : Rel A r → ∀ {ℓ} → RecStruct A ℓ _
-WfRec _<_ P x = ∀ y → y < x → P y
+WfRec _<_ P x = ∀ {y} → y < x → P y
 
 -- The accessibility predicate: x is accessible if everything which is
 -- smaller than x is also accessible (inductively).
@@ -50,13 +54,16 @@ WellFounded _<_ = ∀ x → Acc _<_ x
 -- Basic properties
 
 acc-inverse : ∀ {_<_ : Rel A ℓ} {x : A} (q : Acc _<_ x) →
-              (y : A) → y < x → Acc _<_ y
-acc-inverse (acc rs) y y<x = rs y y<x
+              WfRec _<_ (Acc _<_) x
+acc-inverse (acc rs) y<x = rs y<x
+
+module _ {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} where
+
+  Acc-resp-flip-≈ : _<_ Respectsʳ (flip _≈_) → (Acc _<_) Respects _≈_
+  Acc-resp-flip-≈ respʳ x≈y (acc rec) = acc λ z<y → rec (respʳ x≈y z<y)
 
-Acc-resp-≈ : {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} → Symmetric _≈_ →
-             _<_ Respectsʳ _≈_ → (Acc _<_) Respects _≈_
-Acc-resp-≈ sym respʳ x≈y (acc rec) =
-  acc (λ z z<y → rec z (respʳ (sym x≈y) z<y))
+  Acc-resp-≈ : Symmetric _≈_ → _<_ Respectsʳ _≈_ → (Acc _<_) Respects _≈_
+  Acc-resp-≈ sym respʳ x≈y wf = Acc-resp-flip-≈ (respʳ ∘ sym) x≈y wf
 
 ------------------------------------------------------------------------
 -- Well-founded induction for the subset of accessible elements:
@@ -64,14 +71,13 @@ Acc-resp-≈ sym respʳ x≈y (acc rec) =
 module Some {_<_ : Rel A r} {ℓ} where
 
   wfRecBuilder : SubsetRecursorBuilder (Acc _<_) (WfRec _<_ {ℓ = ℓ})
-  wfRecBuilder P f x (acc rs) = λ y y<x →
-    f y (wfRecBuilder P f y (rs y y<x))
+  wfRecBuilder P f x (acc rs) = λ y<x → f _ (wfRecBuilder P f _ (rs y<x))
 
   wfRec : SubsetRecursor (Acc _<_) (WfRec _<_)
   wfRec = subsetBuild wfRecBuilder
 
   unfold-wfRec : (P : Pred A ℓ) (f : WfRec _<_ P ⊆′ P) {x : A} (q : Acc _<_ x) →
-                 wfRec P f x q ≡ f x (λ y y<x → wfRec P f y (acc-inverse q y y<x))
+                 wfRec P f x q ≡ f x λ y<x → wfRec P f _ (acc-inverse q y<x)
   unfold-wfRec P f (acc rs) = refl
 
 
@@ -92,22 +98,41 @@ module All {_<_ : Rel A r} (wf : WellFounded _<_) ℓ where
 module FixPoint
   {_<_ : Rel A r} (wf : WellFounded _<_)
   (P : Pred A ℓ) (f : WfRec _<_ P ⊆′ P)
-  (f-ext : (x : A) {IH IH′ : WfRec _<_ P x} → (∀ {y} y<x → IH y y<x ≡ IH′ y y<x) → f x IH ≡ f x IH′)
+  (f-ext : (x : A) {IH IH′ : WfRec _<_ P x} →
+           (∀ {y} y<x → IH {y} y<x ≡ IH′ y<x) →
+           f x IH ≡ f x IH′)
   where
 
-  some-wfRec-irrelevant : ∀ x → (q q′ : Acc _<_ x) → Some.wfRec P f x q ≡ Some.wfRec P f x q′
-  some-wfRec-irrelevant = All.wfRec wf _
-                                   (λ x → (q q′ : Acc _<_ x) → Some.wfRec P f x q ≡ Some.wfRec P f x q′)
-                                   (λ { x IH (acc rs) (acc rs′) → f-ext x (λ y<x → IH _ y<x (rs _ y<x) (rs′ _ y<x)) })
+  some-wfrec-Irrelevant : Pred A _
+  some-wfrec-Irrelevant x = ∀ q q′ → Some.wfRec P f x q ≡ Some.wfRec P f x q′
+
+  some-wfRec-irrelevant : ∀ x → some-wfrec-Irrelevant x
+  some-wfRec-irrelevant = All.wfRec wf _ some-wfrec-Irrelevant
+    λ { x IH (acc rs) (acc rs′) → f-ext x λ y<x → IH y<x (rs y<x) (rs′ y<x) }
 
   open All wf ℓ
-  wfRecBuilder-wfRec : ∀ {x y} y<x → wfRecBuilder P f x y y<x ≡ wfRec P f y
-  wfRecBuilder-wfRec {x} {y} y<x with wf x
-  ... | acc rs = some-wfRec-irrelevant y (rs y y<x) (wf y)
 
-  unfold-wfRec : ∀ {x} → wfRec P f x ≡ f x (λ y _ → wfRec P f y)
+  wfRecBuilder-wfRec : ∀ {x y} y<x → wfRecBuilder P f x y<x ≡ wfRec P f y
+  wfRecBuilder-wfRec {x} {y} y<x with acc rs ← wf x
+   = some-wfRec-irrelevant y (rs y<x) (wf y)
+
+  unfold-wfRec : ∀ {x} → wfRec P f x ≡ f x λ _ → wfRec P f _
   unfold-wfRec {x} = f-ext x wfRecBuilder-wfRec
 
+------------------------------------------------------------------------
+-- Well-founded relations are asymmetric and irreflexive.
+
+module _ {_<_ : Rel A r} where
+  acc⇒asym : ∀ {x y} → Acc _<_ x → x < y → ¬ (y < x)
+  acc⇒asym {x} hx =
+    Some.wfRec (λ x → ∀ {y} → x < y → ¬ (y < x)) (λ _ hx x<y y<x → hx y<x y<x x<y) _ hx
+
+  wf⇒asym : WellFounded _<_ → Asymmetric _<_
+  wf⇒asym wf = acc⇒asym (wf _)
+
+  wf⇒irrefl : {_≈_ : Rel A ℓ} → _<_ Respects₂ _≈_ →
+              Symmetric _≈_ → WellFounded _<_ → Irreflexive _≈_ _<_
+  wf⇒irrefl r s wf = asym⇒irr r s (wf⇒asym wf)
 
 ------------------------------------------------------------------------
 -- It might be useful to establish proofs of Acc or Well-founded using
@@ -119,7 +144,7 @@ module Subrelation {_<₁_ : Rel A ℓ₁} {_<₂_ : Rel A ℓ₂}
                    (<₁⇒<₂ : ∀ {x y} → x <₁ y → x <₂ y) where
 
   accessible : Acc _<₂_ ⊆ Acc _<₁_
-  accessible (acc rs) = acc (λ y y<x → accessible (rs y (<₁⇒<₂ y<x)))
+  accessible (acc rs) = acc λ y<x → accessible (rs (<₁⇒<₂ y<x))
 
   wellFounded : WellFounded _<₂_ → WellFounded _<₁_
   wellFounded wf = λ x → accessible (wf x)
@@ -130,7 +155,7 @@ module Subrelation {_<₁_ : Rel A ℓ₁} {_<₂_ : Rel A ℓ₂}
 module InverseImage {_<_ : Rel B ℓ} (f : A → B) where
 
   accessible : ∀ {x} → Acc _<_ (f x) → Acc (_<_ on f) x
-  accessible (acc rs) = acc (λ y fy<fx → accessible (rs (f y) fy<fx))
+  accessible (acc rs) = acc λ fy<fx → accessible (rs fy<fx)
 
   wellFounded : WellFounded _<_ → WellFounded (_<_ on f)
   wellFounded wf = λ x → accessible (wf (f x))
@@ -157,7 +182,7 @@ module TransitiveClosure {A : Set a} (_<_ : Rel A ℓ) where
     trans : ∀ {x y z} (x<y : x <⁺ y) (y<z : y <⁺ z) → x <⁺ z
 
   downwardsClosed : ∀ {x y} → Acc _<⁺_ y → x <⁺ y → Acc _<⁺_ x
-  downwardsClosed (acc rs) x<y = acc (λ z z<x → rs z (trans z<x x<y))
+  downwardsClosed (acc rs) x<y = acc λ z<x → rs (trans z<x x<y)
 
   mutual
 
@@ -165,9 +190,9 @@ module TransitiveClosure {A : Set a} (_<_ : Rel A ℓ) where
     accessible acc-x = acc (accessible′ acc-x)
 
     accessible′ : ∀ {x} → Acc _<_ x → WfRec _<⁺_ (Acc _<⁺_) x
-    accessible′ (acc rs) y [ y<x ]         = accessible (rs y y<x)
-    accessible′ acc-x    y (trans y<z z<x) =
-      downwardsClosed (accessible′ acc-x _ z<x) y<z
+    accessible′ (acc rs) [ y<x ]         = accessible (rs y<x)
+    accessible′ acc-x    (trans y<z z<x) =
+      downwardsClosed (accessible′ acc-x z<x) y<z
 
   wellFounded : WellFounded _<_ → WellFounded _<⁺_
   wellFounded wf = λ x → accessible (wf x)
@@ -184,6 +209,7 @@ module Lexicographic {A : Set a} {B : A → Set b}
                      (RelA : Rel A ℓ₁)
                      (RelB : ∀ x → Rel (B x) ℓ₂) where
 
+  infix 4 _<_
   data _<_ : Rel (Σ A B) (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂) where
     left  : ∀ {x₁ y₁ x₂ y₂} (x₁<x₂ : RelA   x₁ x₂) → (x₁ , y₁) < (x₂ , y₂)
     right : ∀ {x y₁ y₂}     (y₁<y₂ : RelB x y₁ y₂) → (x  , y₁) < (x  , y₂)
@@ -200,9 +226,9 @@ module Lexicographic {A : Set a} {B : A → Set b}
       ∀ {x y} →
       Acc RelA x → Acc (RelB x) y → (∀ {x} → WellFounded (RelB x)) →
       WfRec _<_ (Acc _<_) (x , y)
-    accessible′ (acc rsA) _    wfB ._ (left  x′<x) = accessible (rsA _ x′<x) wfB
-    accessible′ accA (acc rsB) wfB ._ (right y′<y) =
-      acc (accessible′ accA (rsB _ y′<y) wfB)
+    accessible′ (acc rsA) _    wfB (left  x′<x) = accessible (rsA x′<x) wfB
+    accessible′ accA (acc rsB) wfB (right y′<y) =
+      acc (accessible′ accA (rsB y′<y) wfB)
 
   wellFounded : WellFounded RelA → (∀ {x} → WellFounded (RelB x)) →
                 WellFounded _<_
diff --git a/src/Level/Literals.agda b/src/Level/Literals.agda
index 8e3eebb4e5..d1ac0f7ac4 100644
--- a/src/Level/Literals.agda
+++ b/src/Level/Literals.agda
@@ -15,6 +15,8 @@ open import Level using (Level; 0ℓ)
 
 -- Increase a Level by a number of sucs.
 
+infixl 6 _ℕ+_
+
 _ℕ+_ : ℕ → Level → Level
 zero  ℕ+ ℓ = ℓ
 suc n ℕ+ ℓ = Level.suc (n ℕ+ ℓ)
diff --git a/src/Reflection/AST/Abstraction.agda b/src/Reflection/AST/Abstraction.agda
index 9ed64b8835..4f640bcb20 100644
--- a/src/Reflection/AST/Abstraction.agda
+++ b/src/Reflection/AST/Abstraction.agda
@@ -8,12 +8,13 @@
 
 module Reflection.AST.Abstraction where
 
-open import Data.Product                          using (_×_; <_,_>; uncurry)
-open import Data.String as String                 using (String)
-open import Level
-open import Relation.Nullary.Decidable            using (Dec; map′; _×-dec_)
-open import Relation.Binary                       using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong₂)
+open import Data.String.Base as String                 using (String)
+open import Data.String.Properties as String           using (_≟_)
+open import Data.Product.Base                          using (_×_; <_,_>; uncurry)
+open import Level using (Level)
+open import Relation.Nullary.Decidable.Core            using (Dec; map′; _×-dec_)
+open import Relation.Binary.Definitions                using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong₂)
 
 private
   variable
@@ -50,8 +51,8 @@ abs-injective = < abs-injective₁ , abs-injective₂ >
 
 -- We often need decidability of equality for Abs A when implementing it
 -- for A. Unfortunately ≡-dec makes the termination checker unhappy.
--- Instead, we can match on both Abs A and use unAbs-dec for an obviously
--- decreasing recursive call.
+-- Instead, we can match on both Abs A and use unAbs-dec for an
+-- obviously decreasing recursive call.
 
 unAbs : Abs A → A
 unAbs (abs s a) = a
diff --git a/src/Reflection/AST/AlphaEquality.agda b/src/Reflection/AST/AlphaEquality.agda
index 2c8637e9dc..ec0b556292 100644
--- a/src/Reflection/AST/AlphaEquality.agda
+++ b/src/Reflection/AST/AlphaEquality.agda
@@ -8,12 +8,12 @@
 
 module Reflection.AST.AlphaEquality where
 
-open import Data.Bool.Base             using (Bool; true; false; _∧_)
-open import Data.List.Base             using ([]; _∷_)
-open import Data.Nat.Base as ℕ        using (ℕ; zero; suc; _≡ᵇ_)
-open import Data.Product.Base          using (_,_)
-open import Relation.Nullary.Decidable using (⌊_⌋)
-open import Relation.Binary            using (DecidableEquality)
+open import Data.Bool.Base                   using (Bool; true; false; _∧_)
+open import Data.List.Base                   using ([]; _∷_)
+open import Data.Nat.Base as ℕ               using (ℕ; zero; suc; _≡ᵇ_)
+open import Data.Product.Base                using (_,_)
+open import Relation.Nullary.Decidable.Core  using (⌊_⌋)
+open import Relation.Binary.Definitions      using (DecidableEquality)
 
 open import Reflection.AST.Abstraction
 open import Reflection.AST.Argument
diff --git a/src/Reflection/AST/Argument.agda b/src/Reflection/AST/Argument.agda
index 1b0884b615..d21b3688cb 100644
--- a/src/Reflection/AST/Argument.agda
+++ b/src/Reflection/AST/Argument.agda
@@ -8,11 +8,11 @@
 
 module Reflection.AST.Argument where
 
-open import Data.List.Base as List                using (List; []; _∷_)
-open import Data.Product                          using (_×_; <_,_>; uncurry)
-open import Relation.Nullary.Decidable            using (Dec; map′; _×-dec_)
-open import Relation.Binary                       using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong₂)
+open import Data.List.Base as List                     using (List; []; _∷_)
+open import Data.Product.Base                          using (_×_; <_,_>; uncurry)
+open import Relation.Nullary.Decidable.Core            using (Dec; map′; _×-dec_)
+open import Relation.Binary.Definitions                using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong₂)
 open import Level
 
 open import Reflection.AST.Argument.Visibility
@@ -79,8 +79,8 @@ arg-injective = < arg-injective₁ , arg-injective₂ >
 
 -- We often need decidability of equality for Arg A when implementing it
 -- for A. Unfortunately ≡-dec makes the termination checker unhappy.
--- Instead, we can match on both Arg A and use unArg-dec for an obviously
--- decreasing recursive call.
+-- Instead, we can match on both Arg A and use unArg-dec for an
+-- obviously decreasing recursive call.
 
 unArg : Arg A → A
 unArg (arg i a) = a
diff --git a/src/Reflection/AST/Argument/Information.agda b/src/Reflection/AST/Argument/Information.agda
index 3e97598d46..98c91ee818 100644
--- a/src/Reflection/AST/Argument/Information.agda
+++ b/src/Reflection/AST/Argument/Information.agda
@@ -8,10 +8,10 @@
 
 module Reflection.AST.Argument.Information where
 
-open import Data.Product.Base                     using (_×_; <_,_>; uncurry)
-open import Relation.Nullary.Decidable            using (map′; _×-dec_)
-open import Relation.Binary                       using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong₂)
+open import Data.Product.Base                          using (_×_; <_,_>; uncurry)
+open import Relation.Nullary.Decidable.Core            using (map′; _×-dec_)
+open import Relation.Binary.Definitions                using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong₂)
 
 open import Reflection.AST.Argument.Modality as Modality using (Modality)
 open import Reflection.AST.Argument.Visibility as Visibility using (Visibility)
@@ -48,6 +48,8 @@ arg-info-injective₂ refl = refl
 arg-info-injective : arg-info v m ≡ arg-info v′ m′ → v ≡ v′ × m ≡ m′
 arg-info-injective = < arg-info-injective₁ , arg-info-injective₂ >
 
+infix 4 _≟_
+
 _≟_ : DecidableEquality ArgInfo
 arg-info v m ≟ arg-info v′ m′ =
   map′
diff --git a/src/Reflection/AST/Argument/Modality.agda b/src/Reflection/AST/Argument/Modality.agda
index 1e39783349..722c1cfa0e 100644
--- a/src/Reflection/AST/Argument/Modality.agda
+++ b/src/Reflection/AST/Argument/Modality.agda
@@ -8,10 +8,10 @@
 
 module Reflection.AST.Argument.Modality where
 
-open import Data.Product.Base                     using (_×_; <_,_>; uncurry)
-open import Relation.Nullary.Decidable            using (map′; _×-dec_)
-open import Relation.Binary                       using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong₂)
+open import Data.Product.Base                          using (_×_; <_,_>; uncurry)
+open import Relation.Nullary.Decidable.Core            using (map′; _×-dec_)
+open import Relation.Binary.Definitions                using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong₂)
 
 open import Reflection.AST.Argument.Relevance as Relevance using (Relevance)
 open import Reflection.AST.Argument.Quantity as Quantity using (Quantity)
@@ -48,6 +48,8 @@ modality-injective₂ refl = refl
 modality-injective : modality r q ≡ modality r′ q′ → r ≡ r′ × q ≡ q′
 modality-injective = < modality-injective₁ , modality-injective₂ >
 
+infix 4 _≟_
+
 _≟_ : DecidableEquality Modality
 modality r q ≟ modality r′ q′ =
   map′
diff --git a/src/Reflection/AST/Argument/Quantity.agda b/src/Reflection/AST/Argument/Quantity.agda
index 3942a667a1..ff0a0d3c65 100644
--- a/src/Reflection/AST/Argument/Quantity.agda
+++ b/src/Reflection/AST/Argument/Quantity.agda
@@ -8,9 +8,9 @@
 
 module Reflection.AST.Argument.Quantity where
 
-open import Relation.Nullary                      using (yes; no)
-open import Relation.Binary                       using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (refl)
+open import Relation.Nullary.Decidable.Core           using (yes; no)
+open import Relation.Binary.Definitions                using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core using (refl)
 
 ------------------------------------------------------------------------
 -- Re-exporting the builtins publicly
@@ -21,6 +21,8 @@ open Quantity public
 ------------------------------------------------------------------------
 -- Decidable equality
 
+infix 4 _≟_
+
 _≟_ : DecidableEquality Quantity
 quantity-ω ≟ quantity-ω = yes refl
 quantity-0 ≟ quantity-0 = yes refl
diff --git a/src/Reflection/AST/Argument/Relevance.agda b/src/Reflection/AST/Argument/Relevance.agda
index 1ec1606453..b2ef362d7d 100644
--- a/src/Reflection/AST/Argument/Relevance.agda
+++ b/src/Reflection/AST/Argument/Relevance.agda
@@ -8,9 +8,9 @@
 
 module Reflection.AST.Argument.Relevance where
 
-open import Relation.Nullary                      using (yes; no)
-open import Relation.Binary                       using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (refl)
+open import Relation.Nullary.Decidable.Core            using (yes; no)
+open import Relation.Binary.Definitions                using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core using (refl)
 
 ------------------------------------------------------------------------
 -- Re-exporting the builtins publicly
@@ -21,6 +21,8 @@ open Relevance public
 ------------------------------------------------------------------------
 -- Decidable equality
 
+infix 4 _≟_
+
 _≟_ : DecidableEquality Relevance
 relevant   ≟ relevant   = yes refl
 irrelevant ≟ irrelevant = yes refl
diff --git a/src/Reflection/AST/Argument/Visibility.agda b/src/Reflection/AST/Argument/Visibility.agda
index 93654a018c..f8bd2afeee 100644
--- a/src/Reflection/AST/Argument/Visibility.agda
+++ b/src/Reflection/AST/Argument/Visibility.agda
@@ -8,9 +8,9 @@
 
 module Reflection.AST.Argument.Visibility where
 
-open import Relation.Nullary                      using (yes; no)
-open import Relation.Binary                       using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (refl)
+open import Relation.Nullary.Decidable.Core            using (yes; no)
+open import Relation.Binary.Definitions                using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core using (refl)
 
 ------------------------------------------------------------------------
 -- Re-exporting the builtins publicly
@@ -21,6 +21,8 @@ open Visibility public
 ------------------------------------------------------------------------
 -- Decidable equality
 
+infix 4 _≟_
+
 _≟_ : DecidableEquality Visibility
 visible   ≟ visible   = yes refl
 hidden    ≟ hidden    = yes refl
diff --git a/src/Reflection/AST/DeBruijn.agda b/src/Reflection/AST/DeBruijn.agda
index 8d05f19952..2973912d3f 100644
--- a/src/Reflection/AST/DeBruijn.agda
+++ b/src/Reflection/AST/DeBruijn.agda
@@ -116,7 +116,7 @@ module _ where
 module _ where
 
   private
-    anyApplicative : RawApplicative (λ _ → Bool)
+    anyApplicative : ∀ {ℓ} → RawApplicative {ℓ} (λ _ → Bool)
     anyApplicative = mkRawApplicative _ (λ _ → false)  _∨_
 
   open Traverse anyApplicative
@@ -128,5 +128,7 @@ module _ where
     actions : ℕ → Actions
     actions i = record defaultActions { onVar = fvVar i }
 
+  infix 4 _∈FV_
+
   _∈FV_ : ℕ → Term → Bool
   i ∈FV t = traverseTerm (actions i) (0 , []) t
diff --git a/src/Reflection/AST/Definition.agda b/src/Reflection/AST/Definition.agda
index 7cb403fb49..dab8ab2505 100644
--- a/src/Reflection/AST/Definition.agda
+++ b/src/Reflection/AST/Definition.agda
@@ -8,16 +8,17 @@
 
 module Reflection.AST.Definition where
 
-import Data.List.Properties as Listₚ              using (≡-dec)
-import Data.Nat.Properties as ℕₚ                 using (_≟_)
-open import Data.Product                          using (_×_; <_,_>; uncurry)
-open import Relation.Nullary.Decidable            using (map′; _×-dec_; yes; no)
-open import Relation.Binary                       using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong; cong₂)
-
-import Reflection.AST.Argument as Arg
-import Reflection.AST.Name     as Name
-import Reflection.AST.Term     as Term
+import Data.List.Properties as List                    using (≡-dec)
+import Data.Nat.Properties as ℕ                        using (_≟_)
+open import Data.Product.Base                          using (_×_; <_,_>; uncurry)
+open import Relation.Nullary.Decidable.Core            using (map′; _×-dec_; yes; no)
+open import Relation.Binary.Definitions                using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong; cong₂)
+
+import Reflection.AST.Argument          as Arg
+import Reflection.AST.Argument.Quantity as Quantity
+import Reflection.AST.Name              as Name
+import Reflection.AST.Term              as Term
 
 ------------------------------------------------------------------------
 -- Re-exporting type publically
@@ -56,51 +57,60 @@ record′-injective₂ refl = refl
 record′-injective : ∀ {c c′ fs fs′} → record′ c fs ≡ record′ c′ fs′ → c ≡ c′ × fs ≡ fs′
 record′-injective = < record′-injective₁ , record′-injective₂ >
 
-constructor′-injective : ∀ {c c′} → constructor′ c ≡ constructor′ c′ → c ≡ c′
-constructor′-injective refl = refl
+constructor′-injective₁ : ∀ {c c′ q q′} → constructor′ c q ≡ constructor′ c′ q′ → c ≡ c′
+constructor′-injective₁ refl = refl
+
+constructor′-injective₂ : ∀ {c c′ q q′} → constructor′ c q ≡ constructor′ c′ q′ → q ≡ q′
+constructor′-injective₂ refl = refl
+
+constructor′-injective : ∀ {c c′ q q′} → constructor′ c q ≡ constructor′ c′ q′ → c ≡ c′ × q ≡ q′
+constructor′-injective = < constructor′-injective₁ , constructor′-injective₂ >
+
+infix 4 _≟_
 
 _≟_ : DecidableEquality Definition
 function cs       ≟ function cs′        =
   map′ (cong function) function-injective (cs Term.≟-Clauses cs′)
 data-type pars cs ≟ data-type pars′ cs′ =
   map′ (uncurry (cong₂ data-type)) data-type-injective
-           (pars ℕₚ.≟ pars′ ×-dec Listₚ.≡-dec Name._≟_ cs cs′)
+           (pars ℕ.≟ pars′ ×-dec List.≡-dec Name._≟_ cs cs′)
 record′ c fs      ≟ record′ c′ fs′      =
   map′ (uncurry (cong₂ record′)) record′-injective
-           (c Name.≟ c′ ×-dec Listₚ.≡-dec (Arg.≡-dec Name._≟_) fs fs′)
-constructor′ d    ≟ constructor′ d′     =
-  map′ (cong constructor′) constructor′-injective (d Name.≟ d′)
+           (c Name.≟ c′ ×-dec List.≡-dec (Arg.≡-dec Name._≟_) fs fs′)
+constructor′ d q  ≟ constructor′ d′ q′  =
+  map′ (uncurry (cong₂ constructor′)) constructor′-injective
+           (d Name.≟ d′ ×-dec q Quantity.≟ q′)
 axiom             ≟ axiom               = yes refl
 primitive′        ≟ primitive′          = yes refl
 
 -- antidiagonal
 function cs ≟ data-type pars cs₁ = no (λ ())
 function cs ≟ record′ c fs = no (λ ())
-function cs ≟ constructor′ d = no (λ ())
+function cs ≟ constructor′ d q = no (λ ())
 function cs ≟ axiom = no (λ ())
 function cs ≟ primitive′ = no (λ ())
 data-type pars cs ≟ function cs₁ = no (λ ())
 data-type pars cs ≟ record′ c fs = no (λ ())
-data-type pars cs ≟ constructor′ d = no (λ ())
+data-type pars cs ≟ constructor′ d q = no (λ ())
 data-type pars cs ≟ axiom = no (λ ())
 data-type pars cs ≟ primitive′ = no (λ ())
 record′ c fs ≟ function cs = no (λ ())
 record′ c fs ≟ data-type pars cs = no (λ ())
-record′ c fs ≟ constructor′ d = no (λ ())
+record′ c fs ≟ constructor′ d q = no (λ ())
 record′ c fs ≟ axiom = no (λ ())
 record′ c fs ≟ primitive′ = no (λ ())
-constructor′ d ≟ function cs = no (λ ())
-constructor′ d ≟ data-type pars cs = no (λ ())
-constructor′ d ≟ record′ c fs = no (λ ())
-constructor′ d ≟ axiom = no (λ ())
-constructor′ d ≟ primitive′ = no (λ ())
+constructor′ d q ≟ function cs = no (λ ())
+constructor′ d q ≟ data-type pars cs = no (λ ())
+constructor′ d q ≟ record′ c fs = no (λ ())
+constructor′ d q ≟ axiom = no (λ ())
+constructor′ d q ≟ primitive′ = no (λ ())
 axiom ≟ function cs = no (λ ())
 axiom ≟ data-type pars cs = no (λ ())
 axiom ≟ record′ c fs = no (λ ())
-axiom ≟ constructor′ d = no (λ ())
+axiom ≟ constructor′ d q = no (λ ())
 axiom ≟ primitive′ = no (λ ())
 primitive′ ≟ function cs = no (λ ())
 primitive′ ≟ data-type pars cs = no (λ ())
 primitive′ ≟ record′ c fs = no (λ ())
-primitive′ ≟ constructor′ d = no (λ ())
+primitive′ ≟ constructor′ d q = no (λ ())
 primitive′ ≟ axiom = no (λ ())
diff --git a/src/Reflection/AST/Instances.agda b/src/Reflection/AST/Instances.agda
index cb7cc014d5..27a766076d 100644
--- a/src/Reflection/AST/Instances.agda
+++ b/src/Reflection/AST/Instances.agda
@@ -17,6 +17,7 @@ import Reflection.AST.Abstraction as Abstraction
 import Reflection.AST.Argument as Argument
 import Reflection.AST.Argument.Visibility as Visibility
 import Reflection.AST.Argument.Relevance as Relevance
+import Reflection.AST.Argument.Quantity as Quantity
 import Reflection.AST.Argument.Information as Information
 import Reflection.AST.Pattern as Pattern
 import Reflection.AST.Term as Term
@@ -37,6 +38,7 @@ instance
   Meta-≡-isDecEquivalence = isDecEquivalence Meta._≟_
   Visibility-≡-isDecEquivalence = isDecEquivalence Visibility._≟_
   Relevance-≡-isDecEquivalence = isDecEquivalence Relevance._≟_
+  Quantity-≡-isDecEquivalence = isDecEquivalence Quantity._≟_
   ArgInfo-≡-isDecEquivalence = isDecEquivalence Information._≟_
   Pattern-≡-isDecEquivalence = isDecEquivalence Pattern._≟_
   Clause-≡-isDecEquivalence = isDecEquivalence Term._≟-Clause_
diff --git a/src/Reflection/AST/Literal.agda b/src/Reflection/AST/Literal.agda
index 280ba13010..540e150169 100644
--- a/src/Reflection/AST/Literal.agda
+++ b/src/Reflection/AST/Literal.agda
@@ -8,18 +8,17 @@
 
 module Reflection.AST.Literal where
 
-open import Data.Bool.Base   using (Bool; true; false)
-import Data.Char as Char     using (_≟_)
-import Data.Float as Float   using (_≟_)
-import Data.Nat as ℕ        using (_≟_)
-import Data.String as String using (_≟_)
-import Data.Word as Word     using (_≟_)
+open import Data.Bool.Base using (Bool; true; false)
+import Data.Char.Properties as Char
+import Data.Float.Properties as Float
+import Data.Nat.Properties as ℕ
+import Data.String.Properties as String
+import Data.Word64.Properties as Word64
 import Reflection.AST.Meta as Meta
 import Reflection.AST.Name as Name
-open import Relation.Nullary                      using (yes; no)
-open import Relation.Nullary.Decidable            using (map′; isYes)
-open import Relation.Binary                       using (DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong)
+open import Relation.Nullary.Decidable.Core            using (yes; no; map′; isYes)
+open import Relation.Binary.Definitions                using (DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
 
 ------------------------------------------------------------------------
 -- Re-exporting the builtin type and constructors
@@ -61,7 +60,7 @@ nat x ≟ char x₁ = no (λ ())
 nat x ≟ string x₁ = no (λ ())
 nat x ≟ name x₁ = no (λ ())
 nat x ≟ meta x₁ = no (λ ())
-word64 x ≟ word64 x₁ = map′ (cong word64) word64-injective (x Word.≟ x₁)
+word64 x ≟ word64 x₁ = map′ (cong word64) word64-injective (x Word64.≟ x₁)
 word64 x ≟ nat x₁ = no (λ ())
 word64 x ≟ float x₁ = no (λ ())
 word64 x ≟ char x₁ = no (λ ())
@@ -104,5 +103,7 @@ meta x ≟ string x₁ = no (λ ())
 meta x ≟ name x₁ = no (λ ())
 meta x ≟ meta x₁ = map′ (cong meta) meta-injective (x Meta.≟ x₁)
 
+infix 4 _≡ᵇ_
+
 _≡ᵇ_ : Literal → Literal → Bool
 l ≡ᵇ l′ = isYes (l ≟ l′)
diff --git a/src/Reflection/AST/Meta.agda b/src/Reflection/AST/Meta.agda
index b5db1fad1a..a3cac80c9a 100644
--- a/src/Reflection/AST/Meta.agda
+++ b/src/Reflection/AST/Meta.agda
@@ -8,12 +8,13 @@
 
 module Reflection.AST.Meta where
 
-import Data.Nat.Properties as ℕₚ                using (_≟_)
-open import Function                             using (_on_)
-open import Relation.Nullary.Decidable           using (map′)
-open import Relation.Binary                      using (Rel; Decidable; DecidableEquality)
+import Data.Nat.Properties as ℕ
+open import Function.Base                              using (_on_)
+open import Relation.Nullary.Decidable.Core            using (map′)
+open import Relation.Binary.Core                       using (Rel)
+open import Relation.Binary.Definitions                using (Decidable; DecidableEquality)
 import Relation.Binary.Construct.On as On
-open import Relation.Binary.PropositionalEquality using (_≡_; cong)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong)
 
 open import Agda.Builtin.Reflection public
   using (Meta) renaming (primMetaToNat to toℕ; primMetaEquality to _≡ᵇ_)
@@ -23,12 +24,13 @@ open import Agda.Builtin.Reflection.Properties public
 
 -- Equality of metas is decidable.
 
+infix 4 _≈?_ _≟_ _≈_
+
 _≈_ : Rel Meta _
 _≈_ = _≡_ on toℕ
 
 _≈?_ : Decidable _≈_
-_≈?_ = On.decidable toℕ _≡_ ℕₚ._≟_
+_≈?_ = On.decidable toℕ _≡_ ℕ._≟_
 
-infix 4 _≟_
 _≟_ : DecidableEquality Meta
 m ≟ n = map′ (toℕ-injective _ _) (cong toℕ) (m ≈? n)
diff --git a/src/Reflection/AST/Name.agda b/src/Reflection/AST/Name.agda
index 50c6ee7878..5ceb025126 100644
--- a/src/Reflection/AST/Name.agda
+++ b/src/Reflection/AST/Name.agda
@@ -10,14 +10,15 @@ module Reflection.AST.Name where
 
 open import Data.List.Base              using (List)
 import Data.Product.Properties as Prodₚ using (≡-dec)
-import Data.Word.Properties as Wₚ       using (_≟_)
-open import Function                    using (_on_)
-open import Relation.Nullary.Decidable            using (map′)
-open import Relation.Binary                       using (Rel; Decidable; DecidableEquality)
-open import Relation.Binary.Construct.On          using (decidable)
-open import Relation.Binary.PropositionalEquality using (_≡_; cong)
-
-----------------------------------------------------------------------
+import Data.Word64.Properties as Wₚ       using (_≟_)
+open import Function.Base               using (_on_)
+open import Relation.Nullary.Decidable.Core            using (map′)
+open import Relation.Binary.Core                       using (Rel)
+open import Relation.Binary.Definitions                using (Decidable; DecidableEquality)
+open import Relation.Binary.Construct.On               using (decidable)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong)
+
+------------------------------------------------------------------------
 -- Re-export built-ins
 
 open import Agda.Builtin.Reflection public
@@ -26,22 +27,22 @@ open import Agda.Builtin.Reflection public
 open import Agda.Builtin.Reflection.Properties public
   renaming (primQNameToWord64sInjective to toWords-injective)
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- More definitions
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 Names : Set
 Names = List Name
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Decidable equality for names
-----------------------------------------------------------------------
+------------------------------------------------------------------------
+
+infix 4 _≈?_ _≟_ _≈_
 
 _≈_ : Rel Name _
 _≈_ = _≡_ on toWords
 
-infix 4 _≈?_ _≟_
-
 _≈?_ : Decidable _≈_
 _≈?_ = decidable toWords _≡_ (Prodₚ.≡-dec Wₚ._≟_ Wₚ._≟_)
 
diff --git a/src/Reflection/AST/Show.agda b/src/Reflection/AST/Show.agda
index ffe97352f4..8757e3aef1 100644
--- a/src/Reflection/AST/Show.agda
+++ b/src/Reflection/AST/Show.agda
@@ -11,19 +11,20 @@
 
 module Reflection.AST.Show where
 
-import Data.Char as Char   using (show)
-import Data.Float as Float using (show)
-open import Data.List hiding (_++_; intersperse)
-import Data.Nat.Show as ℕ using (show)
-open import Data.Product   using (_×_; _,_)
-open import Data.String as String
-  using (String; _++_; intersperse; braces; parens; parensIfSpace; _<+>_)
-import Data.Word as Word   using (toℕ)
+import Data.Char.Base as Char
+import Data.Float.Base as Float
+open import Data.List.Base hiding (_++_; intersperse)
+import Data.Nat.Show as ℕ
+open import Data.String.Base as String using (String; _++_; intersperse; braces; parens; _<+>_)
+open import Data.String as String using (parensIfSpace)
+open import Data.Product.Base using (_×_; _,_)
+import Data.Word64.Base as Word64
 open import Function.Base using (id; _∘′_; case_of_)
-open import Relation.Nullary.Decidable using (yes; no)
+open import Relation.Nullary.Decidable.Core using (yes; no)
 
 open import Reflection.AST.Abstraction hiding (map)
 open import Reflection.AST.Argument hiding (map)
+open import Reflection.AST.Argument.Quantity
 open import Reflection.AST.Argument.Relevance
 open import Reflection.AST.Argument.Visibility
 open import Reflection.AST.Argument.Modality
@@ -58,9 +59,13 @@ showVisibility visible   = "visible"
 showVisibility hidden    = "hidden"
 showVisibility instance′ = "instance"
 
+showQuantity : Quantity → String
+showQuantity quantity-0 = "quantity-0"
+showQuantity quantity-ω = "quantity-ω"
+
 showLiteral : Literal → String
 showLiteral (nat x)    = ℕ.show x
-showLiteral (word64 x) = ℕ.show (Word.toℕ x)
+showLiteral (word64 x) = ℕ.show (Word64.toℕ x)
 showLiteral (float x)  = Float.show x
 showLiteral (char x)   = Char.show x
 showLiteral (string x) = String.show x
@@ -144,6 +149,6 @@ showDefinition (data-type pars cs) =
  "datatype" <+> ℕ.show pars <+> braces (intersperse ", " (map showName cs))
 showDefinition (record′ c fs)      =
  "record" <+> showName c <+> braces (intersperse ", " (map (showName ∘′ unArg) fs))
-showDefinition (constructor′ d)    = "constructor" <+> showName d
+showDefinition (constructor′ d q)  = "constructor" <+> showName d <+> showQuantity q
 showDefinition axiom               = "axiom"
 showDefinition primitive′          = "primitive"
diff --git a/src/Reflection/AST/Term.agda b/src/Reflection/AST/Term.agda
index fb0f5bde61..14381c3ba6 100644
--- a/src/Reflection/AST/Term.agda
+++ b/src/Reflection/AST/Term.agda
@@ -8,16 +8,18 @@
 
 module Reflection.AST.Term where
 
-open import Data.List.Base as List  hiding (_++_)
-open import Data.List.Properties    using (∷-dec)
-open import Data.Nat as ℕ          using (ℕ; zero; suc)
-open import Data.Product            using (_×_; _,_; <_,_>; uncurry; map₁)
-open import Data.Product.Properties using (,-injective)
-open import Data.Maybe.Base         using (Maybe; just; nothing)
-open import Data.String as String   using (String)
-open import Relation.Nullary.Decidable            using (map′; _×-dec_; yes; no)
-open import Relation.Binary                       using (Decidable; DecidableEquality)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong; cong₂)
+open import Data.List.Base as List                     hiding (_++_)
+open import Data.List.Properties                       using (∷-dec)
+open import Data.Nat.Base                              using (ℕ; zero; suc)
+import Data.Nat.Properties as ℕ
+open import Data.Product.Base                          using (_×_; _,_; <_,_>; uncurry; map₁)
+open import Data.Product.Properties                    using (,-injective)
+open import Data.Maybe.Base                            using (Maybe; just; nothing)
+open import Data.String.Base                           using (String)
+open import Data.String.Properties as String           hiding (_≟_)
+open import Relation.Nullary.Decidable                 using (map′; _×-dec_; yes; no)
+open import Relation.Binary.Definitions                using (Decidable; DecidableEquality)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong; cong₂)
 
 open import Reflection.AST.Abstraction
 open import Reflection.AST.Argument
@@ -59,7 +61,7 @@ pattern vΠ[_∶_]_ s a ty    = Π[ s ∶ (vArg a) ] ty
 pattern hΠ[_∶_]_ s a ty    = Π[ s ∶ (hArg a) ] ty
 pattern iΠ[_∶_]_ s a ty    = Π[ s ∶ (iArg a) ] ty
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Utility functions
 
 getName : Term → Maybe Name
@@ -128,7 +130,7 @@ absurd-clause-injective = < absurd-clause-injective₁ , absurd-clause-injective
 
 infix 4 _≟-AbsTerm_ _≟-AbsType_ _≟-ArgTerm_ _≟-ArgType_ _≟-Args_
         _≟-Clause_ _≟-Clauses_ _≟_
-        _≟-Sort_ _≟-Pattern_ _≟-Patterns_
+        _≟-Sort_ _≟-Pattern_ _≟-Patterns_ _≟-Telescope_
 
 _≟-AbsTerm_  : DecidableEquality (Abs Term)
 _≟-AbsType_  : DecidableEquality (Abs Type)
@@ -139,13 +141,13 @@ _≟-Clause_   : DecidableEquality Clause
 _≟-Clauses_  : DecidableEquality Clauses
 _≟_          : DecidableEquality Term
 _≟-Sort_     : DecidableEquality Sort
-_≟-Patterns_ : Decidable (_≡_ {A = Args Pattern})
-_≟-Pattern_  : Decidable (_≡_ {A = Pattern})
+_≟-Patterns_ : DecidableEquality (Args Pattern)
+_≟-Pattern_  : DecidableEquality Pattern
 
 -- Decidable equality 'transformers'
--- We need to inline these because the terms are not sized so termination
--- would not obvious if we were to use higher-order functions such as
--- Data.List.Properties' ≡-dec
+-- We need to inline these because the terms are not sized so
+-- termination would not obvious if we were to use higher-order
+-- functions such as Data.List.Properties' ≡-dec
 
 abs s a ≟-AbsTerm abs s′ a′ = unAbs-dec (a ≟ a′)
 abs s a ≟-AbsType abs s′ a′ = unAbs-dec (a ≟ a′)
diff --git a/src/Reflection/AST/Traversal.agda b/src/Reflection/AST/Traversal.agda
index de28c8db2a..815642bf05 100644
--- a/src/Reflection/AST/Traversal.agda
+++ b/src/Reflection/AST/Traversal.agda
@@ -11,12 +11,12 @@ open import Effect.Applicative using (RawApplicative)
 module Reflection.AST.Traversal
   {F : Set → Set} (AppF : RawApplicative F) where
 
-open import Data.Nat     using (ℕ; zero; suc; _+_)
-open import Data.List    using (List; []; _∷_; _++_; reverse; length)
-open import Data.Product using (_×_; _,_)
-open import Data.String  using (String)
-open import Function     using (_∘_)
-open import Reflection   hiding (pure)
+open import Data.Nat.Base     using (ℕ; zero; suc; _+_)
+open import Data.List.Base    using (List; []; _∷_; _++_; reverse; length)
+open import Data.String.Base  using (String)
+open import Data.Product.Base using (_×_; _,_)
+open import Function.Base     using (_∘_)
+open import Reflection        hiding (pure)
 
 open RawApplicative AppF
 
@@ -31,6 +31,7 @@ record Cxt : Set where
   field
     len     : ℕ
     context : List (String × Arg Term)
+infixr 4 _,_
 
 private
   _∷cxt_ : String × Arg Term → Cxt → Cxt
diff --git a/src/Reflection/AST/Universe.agda b/src/Reflection/AST/Universe.agda
index 334458ce2d..dac0af71ed 100644
--- a/src/Reflection/AST/Universe.agda
+++ b/src/Reflection/AST/Universe.agda
@@ -10,7 +10,7 @@ module Reflection.AST.Universe where
 
 open import Data.List.Base             using (List)
 open import Data.String.Base           using (String)
-open import Data.Product               using (_×_)
+open import Data.Product.Base          using (_×_)
 open import Reflection.AST.Argument    using (Arg)
 open import Reflection.AST.Abstraction using (Abs)
 open import Reflection.AST.Term        using (Term; Pattern; Sort; Clause)
diff --git a/src/Reflection/AnnotatedAST.agda b/src/Reflection/AnnotatedAST.agda
index 61d55def7d..aac574dea9 100644
--- a/src/Reflection/AnnotatedAST.agda
+++ b/src/Reflection/AnnotatedAST.agda
@@ -3,9 +3,10 @@
 --
 -- Annotated reflected syntax.
 --
--- NOTE: This file does not check under --cubical-compatible due to restrictions
---       in the termination checker. In particular recursive functions
---       over a universe of types is not supported by --cubical-compatible.
+-- NOTE: This file does not check under --cubical-compatible due to
+--       restrictions in the termination checker. In particular
+--       recursive functions over a universe of types is not supported
+--       by --cubical-compatible.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --safe --with-K #-}
@@ -17,7 +18,7 @@ open import Effect.Applicative           using (RawApplicative)
 open import Data.Bool.Base               using (Bool; false; true; if_then_else_)
 open import Data.List.Base               using (List; []; _∷_)
 open import Data.List.Relation.Unary.All using (All; _∷_; [])
-open import Data.Product                 using (_×_; _,_; proj₁; proj₂)
+open import Data.Product.Base            using (_×_; _,_; proj₁; proj₂)
 open import Data.String.Base             using (String)
 
 open import Reflection                   hiding (pure)
@@ -35,8 +36,8 @@ Annotation : ∀ ℓ → Set (suc ℓ)
 Annotation ℓ = ∀ {u} → ⟦ u ⟧ → Set ℓ
 
 -- An annotated type is a family over an Annotation and a reflected term.
-Typeₐ : ∀ ℓ → Univ → Set (suc ℓ)
-Typeₐ ℓ u = Annotation ℓ → ⟦ u ⟧ → Set ℓ
+Typeₐ : ∀ ℓ → Univ → Set (suc (suc ℓ))
+Typeₐ ℓ u = Annotation ℓ → ⟦ u ⟧ → Set (suc ℓ)
 
 private
   variable
@@ -82,6 +83,7 @@ Argₐ Tyₐ = ⟪ Argₐ′ Tyₐ ⟫
 
 data Namedₐ′ (Tyₐ : Typeₐ ℓ u) : Typeₐ ℓ (⟨named⟩ u) where
   _,_ : ∀ {t} x → Tyₐ Ann t → Namedₐ′ Tyₐ Ann (x , t)
+infixr 4 _,_
 
 Namedₐ : Typeₐ ℓ u → Typeₐ ℓ (⟨named⟩ u)
 Namedₐ Tyₐ = ⟪ Namedₐ′ Tyₐ ⟫
@@ -168,7 +170,7 @@ mutual
 
 -- An annotation function computes the top-level annotation given a
 -- term annotated at all sub-terms.
-AnnotationFun : Annotation ℓ → Set ℓ
+AnnotationFun : Annotation ℓ → Set (suc ℓ)
 AnnotationFun Ann = ∀ u {t : ⟦ u ⟧} → Annotated′ Ann t → Ann t
 
 
diff --git a/src/Reflection/AnnotatedAST/Free.agda b/src/Reflection/AnnotatedAST/Free.agda
index 79ae7a96be..2017e2fd9f 100644
--- a/src/Reflection/AnnotatedAST/Free.agda
+++ b/src/Reflection/AnnotatedAST/Free.agda
@@ -12,7 +12,7 @@ open import Data.Bool.Base               using (if_then_else_)
 open import Data.Nat.Base                using (ℕ; _∸_; compare; _<ᵇ_; less; equal; greater)
 open import Data.List.Base               using (List; []; _∷_; [_]; concatMap; length)
 open import Data.List.Relation.Unary.All using (_∷_)
-open import Data.Product                 using (_×_; _,_; proj₁; proj₂)
+open import Data.Product.Base            using (_×_; _,_; proj₁; proj₂)
 open import Data.String.Base             using (String)
 
 open import Reflection
diff --git a/src/Reflection/External.agda b/src/Reflection/External.agda
index 3206ee2145..122eab9905 100644
--- a/src/Reflection/External.agda
+++ b/src/Reflection/External.agda
@@ -12,11 +12,11 @@ import Agda.Builtin.Reflection.External as Builtin
 
 open import Data.Nat.Base using (ℕ; suc; zero; NonZero)
 open import Data.List.Base using (List; _∷_; [])
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Data.String.Base as String using (String; _++_)
-open import Data.Sum using (_⊎_; inj₁; inj₂; [_,_])
+open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_])
 open import Data.Unit.Base using (⊤; tt)
-open import Function using (case_of_; _$_; _∘_)
+open import Function.Base using (case_of_; _$_; _∘_)
 open import Reflection hiding (name)
 
 -- Type aliases for the various strings.
@@ -26,8 +26,8 @@ StdIn   = String
 StdErr  = String
 StdOut  = String
 
--- Representation for exit codes, assuming 0 is consistently used to indicate
--- success across platforms.
+-- Representation for exit codes, assuming 0 is consistently used to
+-- indicate success across platforms.
 data ExitCode : Set where
   exitSuccess : ExitCode
   exitFailure : (n : ℕ) {n≢0 : NonZero n} → ExitCode
diff --git a/src/Reflection/TCM.agda b/src/Reflection/TCM.agda
index a3df1f1bc3..d762dab2c5 100644
--- a/src/Reflection/TCM.agda
+++ b/src/Reflection/TCM.agda
@@ -8,8 +8,9 @@
 
 module Reflection.TCM where
 
-open import Reflection.AST.Term
 import Agda.Builtin.Reflection as Builtin
+
+open import Reflection.AST.Term
 import Reflection.TCM.Format as Format
 
 ------------------------------------------------------------------------
@@ -29,7 +30,9 @@ open Builtin public
   ; getContext; extendContext; inContext; freshName
   ; declareDef; declarePostulate; defineFun; getType; getDefinition
   ; blockOnMeta; commitTC; isMacro; withNormalisation
-  ; debugPrint; noConstraints; runSpeculative)
+  ; debugPrint; noConstraints; runSpeculative
+  ; Blocker; blockerMeta; blockerAny; blockerAll; blockTC
+  )
   renaming (returnTC to pure)
 
 open Format public
diff --git a/src/Reflection/TCM/Categorical.agda b/src/Reflection/TCM/Categorical.agda
new file mode 100644
index 0000000000..f1c5d76319
--- /dev/null
+++ b/src/Reflection/TCM/Categorical.agda
@@ -0,0 +1,17 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- This module is DEPRECATED. Please use
+-- `Reflection.TCM.Effectful` instead.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Reflection.TCM.Categorical where
+
+open import Reflection.TCM.Effectful public
+
+{-# WARNING_ON_IMPORT
+"Reflection.TCM.Categorical was deprecated in v2.0.
+Use Reflection.TCM.Effectful instead."
+#-}
diff --git a/src/Reflection/TCM/Utilities.agda b/src/Reflection/TCM/Utilities.agda
new file mode 100644
index 0000000000..d61db6350e
--- /dev/null
+++ b/src/Reflection/TCM/Utilities.agda
@@ -0,0 +1,33 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Reflection utilities
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Reflection.TCM.Utilities where
+
+open import Data.List using (List; []; _∷_; _++_; map)
+open import Data.Unit using (⊤; tt)
+open import Effect.Applicative using (RawApplicative; mkRawApplicative)
+open import Function using (case_of_)
+open import Reflection.AST.Meta using (Meta)
+open import Reflection.AST.Term using (Term)
+open import Reflection.TCM using (TC; pure; blockTC; blockerAll; blockerMeta)
+
+import Reflection.AST.Traversal as Traversal
+
+blockOnMetas : Term → TC ⊤
+blockOnMetas t =
+  case traverseTerm actions (0 , []) t of λ where
+    []         → pure tt
+    xs@(_ ∷ _) → blockTC (blockerAll (map blockerMeta xs))
+  where
+  applicative : ∀ {ℓ} → RawApplicative {ℓ} (λ _ → List Meta)
+  applicative = mkRawApplicative (λ _ → List Meta) (λ _ → []) _++_
+
+  open Traversal applicative
+
+  actions : Actions
+  actions = record defaultActions { onMeta = λ _ x → x ∷ [] }
diff --git a/src/Relation/Binary.agda b/src/Relation/Binary.agda
index 95b2ca002a..efdd9921f9 100644
--- a/src/Relation/Binary.agda
+++ b/src/Relation/Binary.agda
@@ -14,4 +14,5 @@ module Relation.Binary where
 open import Relation.Binary.Core public
 open import Relation.Binary.Definitions public
 open import Relation.Binary.Structures public
+open import Relation.Binary.Structures.Biased public
 open import Relation.Binary.Bundles public
diff --git a/src/Relation/Binary/Bundles.agda b/src/Relation/Binary/Bundles.agda
index 498e1f95ef..5d29cabe57 100644
--- a/src/Relation/Binary/Bundles.agda
+++ b/src/Relation/Binary/Bundles.agda
@@ -10,17 +10,18 @@
 
 module Relation.Binary.Bundles where
 
-open import Level
-open import Relation.Nullary.Negation using (¬_)
-open import Relation.Binary.Core
-open import Relation.Binary.Definitions
-open import Relation.Binary.Structures
+open import Function.Base using (flip)
+open import Level using (Level; suc; _⊔_)
+open import Relation.Nullary.Negation.Core using (¬_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures -- most of it
 
 ------------------------------------------------------------------------
 -- Setoids
 ------------------------------------------------------------------------
 
 record PartialSetoid a ℓ : Set (suc (a ⊔ ℓ)) where
+  infix 4 _≈_
   field
     Carrier              : Set a
     _≈_                  : Rel Carrier ℓ
@@ -41,13 +42,15 @@ record Setoid c ℓ : Set (suc (c ⊔ ℓ)) where
     isEquivalence : IsEquivalence _≈_
 
   open IsEquivalence isEquivalence public
+    using (refl; reflexive; isPartialEquivalence)
 
   partialSetoid : PartialSetoid c ℓ
   partialSetoid = record
     { isPartialEquivalence = isPartialEquivalence
     }
 
-  open PartialSetoid partialSetoid public using (_≉_)
+  open PartialSetoid partialSetoid public
+    hiding (Carrier; _≈_; isPartialEquivalence)
 
 
 record DecSetoid c ℓ : Set (suc (c ⊔ ℓ)) where
@@ -58,26 +61,27 @@ record DecSetoid c ℓ : Set (suc (c ⊔ ℓ)) where
     isDecEquivalence : IsDecEquivalence _≈_
 
   open IsDecEquivalence isDecEquivalence public
+    using (_≟_; isEquivalence)
 
   setoid : Setoid c ℓ
   setoid = record
     { isEquivalence = isEquivalence
     }
 
-  open Setoid setoid public using (partialSetoid; _≉_)
-
+  open Setoid setoid public
+    hiding (Carrier; _≈_; isEquivalence)
 
 ------------------------------------------------------------------------
 -- Preorders
 ------------------------------------------------------------------------
 
 record Preorder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix 4 _≈_ _∼_
+  infix 4 _≈_ _≲_
   field
     Carrier    : Set c
     _≈_        : Rel Carrier ℓ₁  -- The underlying equality.
-    _∼_        : Rel Carrier ℓ₂  -- The relation.
-    isPreorder : IsPreorder _≈_ _∼_
+    _≲_        : Rel Carrier ℓ₂  -- The relation.
+    isPreorder : IsPreorder _≈_ _≲_
 
   open IsPreorder isPreorder public
     hiding (module Eq)
@@ -90,6 +94,24 @@ record Preorder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
 
     open Setoid setoid public
 
+  infix 4 _⋦_
+  _⋦_ : Rel Carrier _
+  x ⋦ y = ¬ (x ≲ y)
+
+  infix 4 _≳_
+  _≳_ = flip _≲_
+
+  infix 4 _⋧_
+  _⋧_ = flip _⋦_
+
+  -- Deprecated.
+  infix 4 _∼_
+  _∼_ = _≲_
+  {-# WARNING_ON_USAGE _∼_
+  "Warning: _∼_ was deprecated in v2.0.
+  Please use _≲_ instead. "
+  #-}
+
 
 record TotalPreorder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
   infix 4 _≈_ _≲_
@@ -100,14 +122,15 @@ record TotalPreorder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
     isTotalPreorder : IsTotalPreorder _≈_ _≲_
 
   open IsTotalPreorder isTotalPreorder public
-    hiding (module Eq)
+    using (total; isPreorder)
 
   preorder : Preorder c ℓ₁ ℓ₂
-  preorder = record { isPreorder = isPreorder }
+  preorder = record
+    { isPreorder = isPreorder
+    }
 
   open Preorder preorder public
-    using (module Eq)
-
+    hiding (Carrier; _≈_; _≲_; isPreorder)
 
 ------------------------------------------------------------------------
 -- Partial orders
@@ -122,7 +145,7 @@ record Poset c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
     isPartialOrder : IsPartialOrder _≈_ _≤_
 
   open IsPartialOrder isPartialOrder public
-    hiding (module Eq)
+    using (antisym; isPreorder)
 
   preorder : Preorder c ℓ₁ ℓ₂
   preorder = record
@@ -130,7 +153,13 @@ record Poset c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
     }
 
   open Preorder preorder public
-    using (module Eq)
+    hiding (Carrier; _≈_; _≲_; isPreorder)
+    renaming
+    ( _⋦_ to _≰_; _≳_ to _≥_; _⋧_ to _≱_
+    ; ≲-respˡ-≈ to ≤-respˡ-≈
+    ; ≲-respʳ-≈ to ≤-respʳ-≈
+    ; ≲-resp-≈  to ≤-resp-≈
+    )
 
 
 record DecPoset c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
@@ -141,9 +170,10 @@ record DecPoset c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
     _≤_               : Rel Carrier ℓ₂
     isDecPartialOrder : IsDecPartialOrder _≈_ _≤_
 
-  private
-    module DPO = IsDecPartialOrder isDecPartialOrder
-  open DPO public hiding (module Eq)
+  private module DPO = IsDecPartialOrder isDecPartialOrder
+
+  open DPO public
+    using (_≟_; _≤?_; isPartialOrder)
 
   poset : Poset c ℓ₁ ℓ₂
   poset = record
@@ -151,7 +181,7 @@ record DecPoset c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
     }
 
   open Poset poset public
-    using (preorder)
+    hiding (Carrier; _≈_; _≤_; isPartialOrder; module Eq)
 
   module Eq where
     decSetoid : DecSetoid c ℓ₁
@@ -181,6 +211,16 @@ record StrictPartialOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂))
 
     open Setoid setoid public
 
+  infix 4 _≮_
+  _≮_ : Rel Carrier _
+  x ≮ y = ¬ (x < y)
+
+  infix 4 _>_
+  _>_ = flip _<_
+
+  infix 4 _≯_
+  _≯_ = flip _≮_
+
 
 record DecStrictPartialOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
   infix 4 _≈_ _<_
@@ -190,15 +230,19 @@ record DecStrictPartialOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂
     _<_                     : Rel Carrier ℓ₂
     isDecStrictPartialOrder : IsDecStrictPartialOrder _≈_ _<_
 
-  private
-    module DSPO = IsDecStrictPartialOrder isDecStrictPartialOrder
-  open DSPO public hiding (module Eq)
+  private module DSPO = IsDecStrictPartialOrder isDecStrictPartialOrder
+
+  open DSPO public
+    using (_<?_; _≟_; isStrictPartialOrder)
 
   strictPartialOrder : StrictPartialOrder c ℓ₁ ℓ₂
   strictPartialOrder = record
     { isStrictPartialOrder = isStrictPartialOrder
     }
 
+  open StrictPartialOrder strictPartialOrder public
+    hiding (Carrier; _≈_; _<_; isStrictPartialOrder; module Eq)
+
   module Eq where
 
     decSetoid : DecSetoid c ℓ₁
@@ -222,7 +266,7 @@ record TotalOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
     isTotalOrder : IsTotalOrder _≈_ _≤_
 
   open IsTotalOrder isTotalOrder public
-    hiding (module Eq)
+    using (total; isPartialOrder; isTotalPreorder)
 
   poset : Poset c ℓ₁ ℓ₂
   poset = record
@@ -230,7 +274,7 @@ record TotalOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
     }
 
   open Poset poset public
-    using (module Eq; preorder)
+    hiding (Carrier; _≈_; _≤_; isPartialOrder)
 
   totalPreorder : TotalPreorder c ℓ₁ ℓ₂
   totalPreorder = record
@@ -246,23 +290,26 @@ record DecTotalOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
     _≤_             : Rel Carrier ℓ₂
     isDecTotalOrder : IsDecTotalOrder _≈_ _≤_
 
-  private
-    module DTO = IsDecTotalOrder isDecTotalOrder
-  open DTO public hiding (module Eq)
+  private module DTO = IsDecTotalOrder isDecTotalOrder
+
+  open DTO public
+    using (_≟_; _≤?_; isTotalOrder; isDecPartialOrder)
 
   totalOrder : TotalOrder c ℓ₁ ℓ₂
   totalOrder = record
     { isTotalOrder = isTotalOrder
     }
 
-  open TotalOrder totalOrder public using (poset; preorder)
+  open TotalOrder totalOrder public
+    hiding (Carrier; _≈_; _≤_; isTotalOrder; module Eq)
 
   decPoset : DecPoset c ℓ₁ ℓ₂
   decPoset = record
     { isDecPartialOrder = isDecPartialOrder
     }
 
-  open DecPoset decPoset public using (module Eq)
+  open DecPoset decPoset public
+    using (module Eq)
 
 
 -- Note that these orders are decidable. The current implementation
@@ -279,7 +326,10 @@ record StrictTotalOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) wh
     isStrictTotalOrder : IsStrictTotalOrder _≈_ _<_
 
   open IsStrictTotalOrder isStrictTotalOrder public
-    hiding (module Eq)
+    using
+    ( _≟_; _<?_; compare; isStrictPartialOrder
+    ; isDecStrictPartialOrder; isDecEquivalence
+    )
 
   strictPartialOrder : StrictPartialOrder c ℓ₁ ℓ₂
   strictPartialOrder = record
@@ -287,11 +337,19 @@ record StrictTotalOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) wh
     }
 
   open StrictPartialOrder strictPartialOrder public
+    hiding (Carrier; _≈_; _<_; isStrictPartialOrder; module Eq)
+
+  decStrictPartialOrder : DecStrictPartialOrder c ℓ₁ ℓ₂
+  decStrictPartialOrder = record
+    { isDecStrictPartialOrder = isDecStrictPartialOrder
+    }
+
+  open DecStrictPartialOrder decStrictPartialOrder public
     using (module Eq)
 
   decSetoid : DecSetoid c ℓ₁
   decSetoid = record
-    { isDecEquivalence = isDecEquivalence
+    { isDecEquivalence = Eq.isDecEquivalence
     }
   {-# WARNING_ON_USAGE decSetoid
   "Warning: decSetoid was deprecated in v1.3.
@@ -299,6 +357,26 @@ record StrictTotalOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) wh
   #-}
 
 
+record DenseLinearOrder c ℓ₁ ℓ₂ : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂)) where
+  infix 4 _≈_ _<_
+  field
+    Carrier            : Set c
+    _≈_                : Rel Carrier ℓ₁
+    _<_                : Rel Carrier ℓ₂
+    isDenseLinearOrder : IsDenseLinearOrder _≈_ _<_
+
+  open IsDenseLinearOrder isDenseLinearOrder public
+    using (isStrictTotalOrder; dense)
+
+  strictTotalOrder : StrictTotalOrder c ℓ₁ ℓ₂
+  strictTotalOrder = record
+    { isStrictTotalOrder = isStrictTotalOrder
+    }
+
+  open StrictTotalOrder strictTotalOrder public
+    hiding (Carrier; _≈_; _<_; isStrictTotalOrder)
+
+
 ------------------------------------------------------------------------
 -- Apartness relations
 ------------------------------------------------------------------------
diff --git a/src/Relation/Binary/Consequences.agda b/src/Relation/Binary/Consequences.agda
index ff82600c03..3cdb4db356 100644
--- a/src/Relation/Binary/Consequences.agda
+++ b/src/Relation/Binary/Consequences.agda
@@ -8,16 +8,16 @@
 
 module Relation.Binary.Consequences where
 
-open import Data.Maybe.Base using (just; nothing; decToMaybe)
+open import Data.Empty using (⊥-elim)
+open import Data.Product.Base using (_,_)
 open import Data.Sum.Base as Sum using (inj₁; inj₂; [_,_]′)
-open import Data.Product using (_,_)
-open import Data.Empty.Irrelevant using (⊥-elim)
 open import Function.Base using (_∘_; _∘₂_; _$_; flip)
 open import Level using (Level)
 open import Relation.Binary.Core
 open import Relation.Binary.Definitions
-open import Relation.Nullary using (yes; no; recompute; ¬_)
-open import Relation.Nullary.Decidable.Core using (map′)
+open import Relation.Nullary.Negation.Core using (¬_)
+open import Relation.Nullary.Decidable.Core
+  using (yes; no; recompute; map′; dec⇒maybe)
 open import Relation.Unary using (∁; Pred)
 
 private
@@ -193,7 +193,7 @@ module _  {_R_ : Rel A ℓ₁} {Q : Rel A ℓ₂} where
 module _ {R : REL A B p} where
 
   dec⇒weaklyDec : Decidable R → WeaklyDecidable R
-  dec⇒weaklyDec dec x y = decToMaybe (dec x y)
+  dec⇒weaklyDec dec x y = dec⇒maybe (dec x y)
 
   dec⇒recomputable : Decidable R → Recomputable R
   dec⇒recomputable dec {a} {b} = recompute $ dec a b
diff --git a/src/Relation/Binary/Construct/Add/Extrema/Equality.agda b/src/Relation/Binary/Construct/Add/Extrema/Equality.agda
index 2829910dcc..d34e84602f 100644
--- a/src/Relation/Binary/Construct/Add/Extrema/Equality.agda
+++ b/src/Relation/Binary/Construct/Add/Extrema/Equality.agda
@@ -2,14 +2,18 @@
 -- The Agda standard library
 --
 -- A pointwise lifting of a relation to incorporate new extrema.
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 -- This module is designed to be used with
 -- Relation.Nullary.Construct.Add.Extrema
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Decidable; Irrelevant; Substitutive)
 
 module Relation.Binary.Construct.Add.Extrema.Equality
   {a ℓ} {A : Set a} (_≈_ : Rel A ℓ) where
@@ -19,7 +23,7 @@ import Relation.Binary.Construct.Add.Infimum.Equality as AddInfimum
 import Relation.Binary.Construct.Add.Supremum.Equality as AddSupremum
 open import Relation.Nullary.Construct.Add.Extrema
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Definition
 
 private
@@ -28,14 +32,14 @@ private
 
 open Sup using () renaming (_≈⁺_ to _≈±_) public
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Useful pattern synonyms
 
 pattern ⊥±≈⊥± = Sup.[ Inf.⊥₋≈⊥₋ ]
 pattern [_] p = Sup.[ Inf.[ p ] ]
 pattern ⊤±≈⊤± = Sup.⊤⁺≈⊤⁺
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Relational properties
 
 [≈]-injective : ∀ {k l} → [ k ] ≈± [ l ] → k ≈ l
@@ -59,7 +63,7 @@ pattern ⊤±≈⊤± = Sup.⊤⁺≈⊤⁺
 ≈±-substitutive : ∀ {ℓ} → Substitutive _≈_ ℓ → Substitutive _≈±_ ℓ
 ≈±-substitutive = Sup.≈⁺-substitutive ∘′ Inf.≈₋-substitutive
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Structures
 
 ≈±-isEquivalence : IsEquivalence _≈_ → IsEquivalence _≈±_
diff --git a/src/Relation/Binary/Construct/Add/Extrema/NonStrict.agda b/src/Relation/Binary/Construct/Add/Extrema/NonStrict.agda
index 93a04ce62a..35fdf49431 100644
--- a/src/Relation/Binary/Construct/Add/Extrema/NonStrict.agda
+++ b/src/Relation/Binary/Construct/Add/Extrema/NonStrict.agda
@@ -9,7 +9,11 @@
 -- This module is designed to be used with
 -- Relation.Nullary.Construct.Add.Extrema
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsDecPartialOrder; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Decidable; Transitive; Minimum; Maximum; Total; Irrelevant; Antisymmetric)
 
 module Relation.Binary.Construct.Add.Extrema.NonStrict
   {a ℓ} {A : Set a} (_≤_ : Rel A ℓ) where
@@ -17,12 +21,12 @@ module Relation.Binary.Construct.Add.Extrema.NonStrict
 open import Function.Base
 open import Relation.Nullary.Construct.Add.Extrema
 import Relation.Nullary.Construct.Add.Infimum as I
-open import Relation.Binary.PropositionalEquality using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_)
 import Relation.Binary.Construct.Add.Infimum.NonStrict as AddInfimum
 import Relation.Binary.Construct.Add.Supremum.NonStrict as AddSupremum
 import Relation.Binary.Construct.Add.Extrema.Equality as Equality
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Definition
 
 private
@@ -31,7 +35,7 @@ private
 
 open Sup using () renaming (_≤⁺_ to _≤±_) public
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Useful pattern synonyms
 
 pattern ⊥±≤⊥±    = Sup.[ Inf.⊥₋≤ I.⊥₋ ]
@@ -51,7 +55,7 @@ _≤⊤± : ∀ k → k ≤± ⊤±
 [ k ] ≤⊤± = [ k ]≤⊤±
 ⊤±    ≤⊤± = ⊤±≤⊤±
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Relational properties
 
 [≤]-injective : ∀ {k l} → [ k ] ≤± [ l ] → k ≤ l
@@ -75,7 +79,7 @@ _≤⊤± : ∀ k → k ≤± ⊤±
 ≤±-irrelevant : Irrelevant _≤_ → Irrelevant _≤±_
 ≤±-irrelevant = Sup.≤⁺-irrelevant ∘′ Inf.≤₋-irrelevant
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Relational properties + propositional equality
 
 ≤±-reflexive-≡ : (_≡_ ⇒ _≤_) → (_≡_ ⇒ _≤±_)
@@ -84,7 +88,7 @@ _≤⊤± : ∀ k → k ≤± ⊤±
 ≤±-antisym-≡ : Antisymmetric _≡_ _≤_ → Antisymmetric _≡_ _≤±_
 ≤±-antisym-≡ = Sup.≤⁺-antisym-≡ ∘′ Inf.≤₋-antisym-≡
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Relational properties + setoid equality
 
 module _ {e} {_≈_ : Rel A e} where
@@ -97,7 +101,7 @@ module _ {e} {_≈_ : Rel A e} where
   ≤±-antisym : Antisymmetric _≈_ _≤_ → Antisymmetric _≈±_ _≤±_
   ≤±-antisym = Sup.≤⁺-antisym ∘′ Inf.≤₋-antisym
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Structures + propositional equality
 
 ≤±-isPreorder-≡ : IsPreorder _≡_ _≤_ → IsPreorder _≡_ _≤±_
@@ -115,7 +119,7 @@ module _ {e} {_≈_ : Rel A e} where
 ≤±-isDecTotalOrder-≡ : IsDecTotalOrder _≡_ _≤_ → IsDecTotalOrder _≡_ _≤±_
 ≤±-isDecTotalOrder-≡ = Sup.≤⁺-isDecTotalOrder-≡ ∘′ Inf.≤₋-isDecTotalOrder-≡
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Structures + setoid equality
 
 module _ {e} {_≈_ : Rel A e} where
diff --git a/src/Relation/Binary/Construct/Add/Extrema/Strict.agda b/src/Relation/Binary/Construct/Add/Extrema/Strict.agda
index 1195e265a9..496ac3d617 100644
--- a/src/Relation/Binary/Construct/Add/Extrema/Strict.agda
+++ b/src/Relation/Binary/Construct/Add/Extrema/Strict.agda
@@ -9,23 +9,26 @@
 -- This module is designed to be used with
 -- Relation.Nullary.Construct.Add.Extrema
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
 
 module Relation.Binary.Construct.Add.Extrema.Strict
   {a ℓ} {A : Set a} (_<_ : Rel A ℓ) where
 
 open import Level
-open import Function.Base
-open import Relation.Nullary hiding (Irrelevant)
+open import Function.Base using (_∘′_)
 
 import Relation.Nullary.Construct.Add.Infimum as I
 open import Relation.Nullary.Construct.Add.Extrema
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
   using (_≡_; refl)
 import Relation.Binary.Construct.Add.Infimum.Strict as AddInfimum
 import Relation.Binary.Construct.Add.Supremum.Strict as AddSupremum
 import Relation.Binary.Construct.Add.Extrema.Equality as Equality
 import Relation.Binary.Construct.Add.Extrema.NonStrict as NonStrict
+open import Relation.Binary.Definitions
+  using (Asymmetric; Transitive; Decidable; Irrelevant; Trichotomous; Irreflexive; Trans; _Respectsˡ_; _Respectsʳ_; _Respects₂_)
+open import Relation.Binary.Structures
+  using (IsStrictPartialOrder; IsDecStrictPartialOrder; IsStrictTotalOrder)
 
 ------------------------------------------------------------------------
 -- Definition
diff --git a/src/Relation/Binary/Construct/Add/Infimum/Equality.agda b/src/Relation/Binary/Construct/Add/Infimum/Equality.agda
index 4c1fd79449..6f5336fc44 100644
--- a/src/Relation/Binary/Construct/Add/Infimum/Equality.agda
+++ b/src/Relation/Binary/Construct/Add/Infimum/Equality.agda
@@ -9,7 +9,7 @@
 -- This module is designed to be used with
 -- Relation.Nullary.Construct.Add.Infimum
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
 
 module Relation.Binary.Construct.Add.Infimum.Equality
   {a ℓ} {A : Set a} (_≈_ : Rel A ℓ) where
diff --git a/src/Relation/Binary/Construct/Add/Infimum/NonStrict.agda b/src/Relation/Binary/Construct/Add/Infimum/NonStrict.agda
index c6c313c98c..c3b186c62a 100644
--- a/src/Relation/Binary/Construct/Add/Infimum/NonStrict.agda
+++ b/src/Relation/Binary/Construct/Add/Infimum/NonStrict.agda
@@ -9,15 +9,19 @@
 -- This module is designed to be used with
 -- Relation.Nullary.Construct.Add.Infimum
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsDecPartialOrder; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Minimum; Transitive; Total; Decidable; Irrelevant; Antisymmetric)
 
 module Relation.Binary.Construct.Add.Infimum.NonStrict
   {a ℓ} {A : Set a} (_≤_ : Rel A ℓ) where
 
 open import Level using (_⊔_)
 open import Data.Sum.Base as Sum
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 import Relation.Binary.Construct.Add.Infimum.Equality as Equality
 open import Relation.Nullary hiding (Irrelevant)
 open import Relation.Nullary.Construct.Add.Infimum
@@ -55,8 +59,8 @@ data _≤₋_ : Rel (A ₋) (a ⊔ ℓ) where
 ≤₋-total ≤-total [ k ] [ l ] = Sum.map [_] [_] (≤-total k l)
 
 ≤₋-irrelevant : Irrelevant _≤_ → Irrelevant _≤₋_
-≤₋-irrelevant ≤-irr (⊥₋≤ k) (⊥₋≤ k) = P.refl
-≤₋-irrelevant ≤-irr [ p ]   [ q ]   = P.cong _ (≤-irr p q)
+≤₋-irrelevant ≤-irr (⊥₋≤ k) (⊥₋≤ k) = refl
+≤₋-irrelevant ≤-irr [ p ]   [ q ]   = cong _ (≤-irr p q)
 
 ------------------------------------------------------------------------
 -- Relational properties + propositional equality
@@ -67,7 +71,7 @@ data _≤₋_ : Rel (A ₋) (a ⊔ ℓ) where
 
 ≤₋-antisym-≡ : Antisymmetric _≡_ _≤_ → Antisymmetric _≡_ _≤₋_
 ≤₋-antisym-≡ antisym (⊥₋≤ _) (⊥₋≤ _) = refl
-≤₋-antisym-≡ antisym [ p ] [ q ]       = P.cong [_] (antisym p q)
+≤₋-antisym-≡ antisym [ p ] [ q ]     = cong [_] (antisym p q)
 
 ------------------------------------------------------------------------
 -- Relational properties + setoid equality
@@ -89,7 +93,7 @@ module _ {e} {_≈_ : Rel A e} where
 
 ≤₋-isPreorder-≡ : IsPreorder _≡_ _≤_ → IsPreorder _≡_ _≤₋_
 ≤₋-isPreorder-≡ ≤-isPreorder = record
-  { isEquivalence = P.isEquivalence
+  { isEquivalence = ≡.isEquivalence
   ; reflexive     = ≤₋-reflexive-≡ reflexive
   ; trans         = ≤₋-trans trans
   } where open IsPreorder ≤-isPreorder
diff --git a/src/Relation/Binary/Construct/Add/Infimum/Strict.agda b/src/Relation/Binary/Construct/Add/Infimum/Strict.agda
index 06ac74899b..c1312d7b14 100644
--- a/src/Relation/Binary/Construct/Add/Infimum/Strict.agda
+++ b/src/Relation/Binary/Construct/Add/Infimum/Strict.agda
@@ -9,16 +9,20 @@
 -- This module is designed to be used with
 -- Relation.Nullary.Construct.Add.Infimum
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures
+  using (IsStrictPartialOrder; IsDecStrictPartialOrder; IsStrictTotalOrder)
+open import Relation.Binary.Definitions
+  using (Asymmetric; Transitive; Decidable; Irrelevant; Irreflexive; Trans; Trichotomous; tri≈; tri<; tri>; _Respectsˡ_; _Respectsʳ_; _Respects₂_)
 
 module Relation.Binary.Construct.Add.Infimum.Strict
   {a ℓ} {A : Set a} (_<_ : Rel A ℓ) where
 
 open import Level using (_⊔_)
-open import Data.Product
+open import Data.Product.Base using (_,_; map)
 open import Function.Base
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong; subst)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 import Relation.Binary.Construct.Add.Infimum.Equality as Equality
 import Relation.Binary.Construct.Add.Infimum.NonStrict as NonStrict
 open import Relation.Nullary hiding (Irrelevant)
@@ -28,6 +32,8 @@ import Relation.Nullary.Decidable as Dec
 ------------------------------------------------------------------------
 -- Definition
 
+infix 4 _<₋_
+
 data _<₋_ : Rel (A ₋) (a ⊔ ℓ) where
   ⊥₋<[_] : (l : A)           → ⊥₋    <₋ [ l ]
   [_]    : {k l : A} → k < l → [ k ] <₋ [ l ]
@@ -52,8 +58,8 @@ data _<₋_ : Rel (A ₋) (a ⊔ ℓ) where
 <₋-dec _<?_ [ k ] [ l ] = Dec.map′ [_] [<]-injective (k <? l)
 
 <₋-irrelevant : Irrelevant _<_ → Irrelevant _<₋_
-<₋-irrelevant <-irr ⊥₋<[ l ] ⊥₋<[ l ] = P.refl
-<₋-irrelevant <-irr [ p ]    [ q ]    = P.cong _ (<-irr p q)
+<₋-irrelevant <-irr ⊥₋<[ l ] ⊥₋<[ l ] = refl
+<₋-irrelevant <-irr [ p ]    [ q ]    = cong _ (<-irr p q)
 
 module _ {r} {_≤_ : Rel A r} where
 
@@ -84,10 +90,10 @@ module _ {r} {_≤_ : Rel A r} where
 <₋-irrefl-≡ <-irrefl refl [ x ] = <-irrefl refl x
 
 <₋-respˡ-≡ : _<₋_ Respectsˡ _≡_
-<₋-respˡ-≡ = P.subst (_<₋ _)
+<₋-respˡ-≡ = subst (_<₋ _)
 
 <₋-respʳ-≡ : _<₋_ Respectsʳ _≡_
-<₋-respʳ-≡ = P.subst (_ <₋_)
+<₋-respʳ-≡ = subst (_ <₋_)
 
 <₋-resp-≡ : _<₋_ Respects₂ _≡_
 <₋-resp-≡ = <₋-respʳ-≡ , <₋-respˡ-≡
@@ -129,7 +135,7 @@ module _ {e} {_≈_ : Rel A e} where
 <₋-isStrictPartialOrder-≡ : IsStrictPartialOrder _≡_ _<_ →
                             IsStrictPartialOrder _≡_ _<₋_
 <₋-isStrictPartialOrder-≡ strict = record
-  { isEquivalence = P.isEquivalence
+  { isEquivalence = ≡.isEquivalence
   ; irrefl        = <₋-irrefl-≡ irrefl
   ; trans         = <₋-trans trans
   ; <-resp-≈      = <₋-resp-≡
@@ -146,9 +152,8 @@ module _ {e} {_≈_ : Rel A e} where
 <₋-isStrictTotalOrder-≡ : IsStrictTotalOrder _≡_ _<_ →
                           IsStrictTotalOrder _≡_ _<₋_
 <₋-isStrictTotalOrder-≡ strictot = record
-  { isEquivalence = P.isEquivalence
-  ; trans         = <₋-trans trans
-  ; compare       = <₋-cmp-≡ compare
+  { isStrictPartialOrder = <₋-isStrictPartialOrder-≡ isStrictPartialOrder
+  ; compare              = <₋-cmp-≡ compare
   } where open IsStrictTotalOrder strictot
 
 ------------------------------------------------------------------------
@@ -178,7 +183,6 @@ module _ {e} {_≈_ : Rel A e} where
   <₋-isStrictTotalOrder : IsStrictTotalOrder _≈_ _<_ →
                           IsStrictTotalOrder _≈₋_ _<₋_
   <₋-isStrictTotalOrder strictot = record
-    { isEquivalence = ≈₋-isEquivalence isEquivalence
-    ; trans         = <₋-trans trans
-    ; compare       = <₋-cmp compare
+    { isStrictPartialOrder = <₋-isStrictPartialOrder isStrictPartialOrder
+    ; compare              = <₋-cmp compare
     } where open IsStrictTotalOrder strictot
diff --git a/src/Relation/Binary/Construct/Add/Point/Equality.agda b/src/Relation/Binary/Construct/Add/Point/Equality.agda
index 2968754a9f..b3f2ea6dcf 100644
--- a/src/Relation/Binary/Construct/Add/Point/Equality.agda
+++ b/src/Relation/Binary/Construct/Add/Point/Equality.agda
@@ -9,14 +9,18 @@
 -- This module is designed to be used with
 -- Relation.Nullary.Construct.Add.Point
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Decidable; Irrelevant; Substitutive)
 
 module Relation.Binary.Construct.Add.Point.Equality
   {a ℓ} {A : Set a} (_≈_ : Rel A ℓ) where
 
 open import Level using (_⊔_)
 open import Function.Base
-import Relation.Binary.PropositionalEquality as P
+import Relation.Binary.PropositionalEquality.Core as ≡
 open import Relation.Nullary hiding (Irrelevant)
 open import Relation.Nullary.Construct.Add.Point
 import Relation.Nullary.Decidable as Dec
@@ -24,6 +28,8 @@ import Relation.Nullary.Decidable as Dec
 ------------------------------------------------------------------------
 -- Definition
 
+infix 4 _≈∙_
+
 data _≈∙_ : Rel (Pointed A) (a ⊔ ℓ) where
   ∙≈∙ :                     ∙     ≈∙ ∙
   [_] : {k l : A} → k ≈ l → [ k ] ≈∙ [ l ]
@@ -53,8 +59,8 @@ data _≈∙_ : Rel (Pointed A) (a ⊔ ℓ) where
 ≈∙-dec _≟_ [ k ] [ l ] = Dec.map′ [_] [≈]-injective (k ≟ l)
 
 ≈∙-irrelevant : Irrelevant _≈_ → Irrelevant _≈∙_
-≈∙-irrelevant ≈-irr ∙≈∙   ∙≈∙   = P.refl
-≈∙-irrelevant ≈-irr [ p ] [ q ] = P.cong _ (≈-irr p q)
+≈∙-irrelevant ≈-irr ∙≈∙   ∙≈∙   = ≡.refl
+≈∙-irrelevant ≈-irr [ p ] [ q ] = ≡.cong _ (≈-irr p q)
 
 ≈∙-substitutive : ∀ {ℓ} → Substitutive _≈_ ℓ → Substitutive _≈∙_ ℓ
 ≈∙-substitutive ≈-subst P ∙≈∙   = id
diff --git a/src/Relation/Binary/Construct/Add/Supremum/Equality.agda b/src/Relation/Binary/Construct/Add/Supremum/Equality.agda
index 04f9376f8e..c0a18a68e5 100644
--- a/src/Relation/Binary/Construct/Add/Supremum/Equality.agda
+++ b/src/Relation/Binary/Construct/Add/Supremum/Equality.agda
@@ -9,7 +9,7 @@
 -- This module is designed to be used with
 -- Relation.Nullary.Construct.Add.Supremum
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
 
 module Relation.Binary.Construct.Add.Supremum.Equality
   {a ℓ} {A : Set a} (_≈_ : Rel A ℓ) where
diff --git a/src/Relation/Binary/Construct/Add/Supremum/NonStrict.agda b/src/Relation/Binary/Construct/Add/Supremum/NonStrict.agda
index 68346824a2..9eb4cc7189 100644
--- a/src/Relation/Binary/Construct/Add/Supremum/NonStrict.agda
+++ b/src/Relation/Binary/Construct/Add/Supremum/NonStrict.agda
@@ -9,7 +9,11 @@
 -- This module is designed to be used with
 -- Relation.Nullary.Construct.Add.Supremum
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsDecPartialOrder; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Maximum; Transitive; Total; Decidable; Irrelevant; Antisymmetric)
 
 module Relation.Binary.Construct.Add.Supremum.NonStrict
   {a ℓ} {A : Set a} (_≤_ : Rel A ℓ) where
@@ -18,14 +22,17 @@ open import Level using (_⊔_)
 open import Data.Sum.Base as Sum
 open import Relation.Nullary hiding (Irrelevant)
 import Relation.Nullary.Decidable as Dec
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; cong)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 open import Relation.Nullary.Construct.Add.Supremum
 import Relation.Binary.Construct.Add.Supremum.Equality as Equality
 
 ------------------------------------------------------------------------
 -- Definition
 
+infix 4 _≤⁺_ _≤⊤⁺
+
 data _≤⁺_ : Rel (A ⁺) (a ⊔ ℓ) where
   [_]  : {k l : A} → k ≤ l → [ k ] ≤⁺ [ l ]
   _≤⊤⁺ : (k : A ⁺)         → k     ≤⁺ ⊤⁺
@@ -54,8 +61,8 @@ data _≤⁺_ : Rel (A ⁺) (a ⊔ ℓ) where
 ≤⁺-total ≤-total [ k ] [ l ] = Sum.map [_] [_] (≤-total k l)
 
 ≤⁺-irrelevant : Irrelevant _≤_ → Irrelevant _≤⁺_
-≤⁺-irrelevant ≤-irr [ p ]   [ q ]    = P.cong _ (≤-irr p q)
-≤⁺-irrelevant ≤-irr (k ≤⊤⁺) (k ≤⊤⁺) = P.refl
+≤⁺-irrelevant ≤-irr [ p ]   [ q ]   = cong _ (≤-irr p q)
+≤⁺-irrelevant ≤-irr (k ≤⊤⁺) (k ≤⊤⁺) = refl
 
 ------------------------------------------------------------------------
 -- Relational properties + propositional equality
@@ -66,7 +73,7 @@ data _≤⁺_ : Rel (A ⁺) (a ⊔ ℓ) where
 
 ≤⁺-antisym-≡ : Antisymmetric _≡_ _≤_ → Antisymmetric _≡_ _≤⁺_
 ≤⁺-antisym-≡ antisym (_ ≤⊤⁺) (_ ≤⊤⁺) = refl
-≤⁺-antisym-≡ antisym [ p ] [ q ]       = P.cong [_] (antisym p q)
+≤⁺-antisym-≡ antisym [ p ] [ q ]     = cong [_] (antisym p q)
 
 ------------------------------------------------------------------------
 -- Relation properties + setoid equality
@@ -88,7 +95,7 @@ module _ {e} {_≈_ : Rel A e} where
 
 ≤⁺-isPreorder-≡ : IsPreorder _≡_ _≤_ → IsPreorder _≡_ _≤⁺_
 ≤⁺-isPreorder-≡ ≤-isPreorder = record
-  { isEquivalence = P.isEquivalence
+  { isEquivalence = ≡.isEquivalence
   ; reflexive     = ≤⁺-reflexive-≡ reflexive
   ; trans         = ≤⁺-trans trans
   } where open IsPreorder ≤-isPreorder
diff --git a/src/Relation/Binary/Construct/Add/Supremum/Strict.agda b/src/Relation/Binary/Construct/Add/Supremum/Strict.agda
index 46415e6895..5613be8112 100644
--- a/src/Relation/Binary/Construct/Add/Supremum/Strict.agda
+++ b/src/Relation/Binary/Construct/Add/Supremum/Strict.agda
@@ -9,18 +9,22 @@
 -- This module is designed to be used with
 -- Relation.Nullary.Construct.Add.Supremum
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures
+  using (IsStrictPartialOrder; IsDecStrictPartialOrder; IsStrictTotalOrder)
+open import Relation.Binary.Definitions
+  using (Asymmetric; Transitive; Decidable; Irrelevant; Irreflexive; Trans; Trichotomous; tri≈; tri>; tri<; _Respectsˡ_; _Respectsʳ_; _Respects₂_)
 
 module Relation.Binary.Construct.Add.Supremum.Strict
   {a r} {A : Set a} (_<_ : Rel A r) where
 
 open import Level using (_⊔_)
-open import Data.Product
+open import Data.Product.Base using (_,_; map)
 open import Function.Base
 open import Relation.Nullary hiding (Irrelevant)
 import Relation.Nullary.Decidable as Dec
-open import Relation.Binary.PropositionalEquality as P
-  using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong; subst)
+import Relation.Binary.PropositionalEquality.Properties as ≡
 open import Relation.Nullary.Construct.Add.Supremum
 import Relation.Binary.Construct.Add.Supremum.Equality as Equality
 import Relation.Binary.Construct.Add.Supremum.NonStrict as NonStrict
@@ -54,8 +58,8 @@ data _<⁺_ : Rel (A ⁺) (a ⊔ r) where
 <⁺-dec _<?_ ⊤⁺    ⊤⁺    = no (λ ())
 
 <⁺-irrelevant : Irrelevant _<_ → Irrelevant _<⁺_
-<⁺-irrelevant <-irr [ p ]    [ q ]    = P.cong _ (<-irr p q)
-<⁺-irrelevant <-irr [ k ]<⊤⁺ [ k ]<⊤⁺ = P.refl
+<⁺-irrelevant <-irr [ p ]    [ q ]    = cong _ (<-irr p q)
+<⁺-irrelevant <-irr [ k ]<⊤⁺ [ k ]<⊤⁺ = refl
 
 
 module _ {r} {_≤_ : Rel A r} where
@@ -87,10 +91,10 @@ module _ {r} {_≤_ : Rel A r} where
 <⁺-irrefl-≡ <-irrefl refl [ x ] = <-irrefl refl x
 
 <⁺-respˡ-≡ : _<⁺_ Respectsˡ _≡_
-<⁺-respˡ-≡ = P.subst (_<⁺ _)
+<⁺-respˡ-≡ = subst (_<⁺ _)
 
 <⁺-respʳ-≡ : _<⁺_ Respectsʳ _≡_
-<⁺-respʳ-≡ = P.subst (_ <⁺_)
+<⁺-respʳ-≡ = subst (_ <⁺_)
 
 <⁺-resp-≡ : _<⁺_ Respects₂ _≡_
 <⁺-resp-≡ = <⁺-respʳ-≡ , <⁺-respˡ-≡
@@ -132,7 +136,7 @@ module _ {e} {_≈_ : Rel A e} where
 <⁺-isStrictPartialOrder-≡ : IsStrictPartialOrder _≡_ _<_ →
                             IsStrictPartialOrder _≡_ _<⁺_
 <⁺-isStrictPartialOrder-≡ strict = record
-  { isEquivalence = P.isEquivalence
+  { isEquivalence = ≡.isEquivalence
   ; irrefl        = <⁺-irrefl-≡ irrefl
   ; trans         = <⁺-trans trans
   ; <-resp-≈      = <⁺-resp-≡
@@ -149,9 +153,8 @@ module _ {e} {_≈_ : Rel A e} where
 <⁺-isStrictTotalOrder-≡ : IsStrictTotalOrder _≡_ _<_ →
                           IsStrictTotalOrder _≡_ _<⁺_
 <⁺-isStrictTotalOrder-≡ strictot = record
-  { isEquivalence = P.isEquivalence
-  ; trans         = <⁺-trans trans
-  ; compare       = <⁺-cmp-≡ compare
+  { isStrictPartialOrder = <⁺-isStrictPartialOrder-≡ isStrictPartialOrder
+  ; compare              = <⁺-cmp-≡ compare
   } where open IsStrictTotalOrder strictot
 
 ------------------------------------------------------------------------
@@ -181,7 +184,6 @@ module _ {e} {_≈_ : Rel A e} where
   <⁺-isStrictTotalOrder : IsStrictTotalOrder _≈_ _<_ →
                           IsStrictTotalOrder _≈⁺_ _<⁺_
   <⁺-isStrictTotalOrder strictot = record
-    { isEquivalence = ≈⁺-isEquivalence isEquivalence
-    ; trans         = <⁺-trans trans
-    ; compare       = <⁺-cmp compare
+    { isStrictPartialOrder = <⁺-isStrictPartialOrder isStrictPartialOrder
+    ; compare              = <⁺-cmp compare
     } where open IsStrictTotalOrder strictot
diff --git a/src/Relation/Binary/Construct/Always.agda b/src/Relation/Binary/Construct/Always.agda
index 76eb5e5963..70c22e1034 100644
--- a/src/Relation/Binary/Construct/Always.agda
+++ b/src/Relation/Binary/Construct/Always.agda
@@ -8,7 +8,10 @@
 
 module Relation.Binary.Construct.Always where
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions using (Reflexive; Symmetric; Transitive)
 open import Relation.Binary.Construct.Constant using (Const)
 open import Data.Unit.Polymorphic using (⊤; tt)
 
diff --git a/src/Relation/Binary/Construct/Closure/Equivalence.agda b/src/Relation/Binary/Construct/Closure/Equivalence.agda
index a4aea65266..622bf20e24 100644
--- a/src/Relation/Binary/Construct/Closure/Equivalence.agda
+++ b/src/Relation/Binary/Construct/Closure/Equivalence.agda
@@ -11,7 +11,11 @@ module Relation.Binary.Construct.Closure.Equivalence where
 
 open import Function.Base using (flip; id; _∘_; _on_)
 open import Level using (Level; _⊔_)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _=[_]⇒_; _⇒_)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Transitive; Symmetric)
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive as Star
   using (Star; ε; _◅◅_; reverse)
 open import Relation.Binary.Construct.Closure.Symmetric as SC
diff --git a/src/Relation/Binary/Construct/Closure/Reflexive/Properties.agda b/src/Relation/Binary/Construct/Closure/Reflexive/Properties.agda
index 9bac46632e..c19304d464 100644
--- a/src/Relation/Binary/Construct/Closure/Reflexive/Properties.agda
+++ b/src/Relation/Binary/Construct/Closure/Reflexive/Properties.agda
@@ -8,16 +8,21 @@
 
 module Relation.Binary.Construct.Closure.Reflexive.Properties where
 
-open import Data.Product.Base as Prod
+open import Data.Product.Base as Product
 open import Data.Sum.Base as Sum
 open import Function.Bundles using (_⇔_; mk⇔)
 open import Function.Base using (id)
 open import Level
-open import Relation.Binary hiding (_⇔_)
+open import Relation.Binary.Core using (Rel; REL; _=[_]⇒_)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsStrictPartialOrder; IsPartialOrder; IsDecStrictPartialOrder; IsDecPartialOrder; IsStrictTotalOrder; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Symmetric; Transitive; Reflexive; Asymmetric; Antisymmetric; Trichotomous; Total; Decidable; DecidableEquality; tri<; tri≈; tri>; _Respectsˡ_; _Respectsʳ_; _Respects_; _Respects₂_)
 open import Relation.Binary.Construct.Closure.Reflexive
-open import Relation.Binary.PropositionalEquality as PropEq using (_≡_; refl)
-open import Relation.Nullary
-import Relation.Nullary.Decidable as Dec
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
+import Relation.Binary.PropositionalEquality.Properties as ≡
+open import Relation.Nullary.Negation.Core using (contradiction)
+open import Relation.Nullary.Decidable as Dec using (yes; no)
 open import Relation.Unary using (Pred)
 
 private
@@ -73,8 +78,8 @@ module _ {_~_ : Rel A ℓ} where
   ... | tri≈ _ refl _ = inj₁ refl
   ... | tri> _ _    c = inj₂ [ c ]
 
-  dec : Decidable {A = A} _≡_ → Decidable _~_ → Decidable _~ᵒ_
-  dec ≡-dec ~-dec a b = Dec.map ⊎⇔Refl (≡-dec a b ⊎-dec ~-dec a b)
+  dec : DecidableEquality A → Decidable _~_ → Decidable _~ᵒ_
+  dec ≡-dec ~-dec a b = Dec.map ⊎⇔Refl (≡-dec a b Dec.⊎-dec ~-dec a b)
 
   decidable : Trichotomous _≡_ _~_ → Decidable _~ᵒ_
   decidable ~-tri a b with ~-tri a b
@@ -98,7 +103,7 @@ module _ {_~_ : Rel A ℓ} {P : Pred A p} where
 module _ {_~_ : Rel A ℓ} {P : Rel A p} where
 
   resp₂ : P Respects₂ _~_ → P Respects₂ (ReflClosure _~_)
-  resp₂ = Prod.map respˡ respʳ
+  resp₂ = Product.map respˡ respʳ
 
 ------------------------------------------------------------------------
 -- Structures
@@ -110,7 +115,7 @@ module _ {_~_ : Rel A ℓ} where
 
   isPreorder : Transitive _~_ → IsPreorder _≡_ _~ᵒ_
   isPreorder ~-trans = record
-    { isEquivalence = PropEq.isEquivalence
+    { isEquivalence = ≡.isEquivalence
     ; reflexive     = λ { refl → refl }
     ; trans         = trans ~-trans
     }
diff --git a/src/Relation/Binary/Construct/Closure/Reflexive/Properties/WithK.agda b/src/Relation/Binary/Construct/Closure/Reflexive/Properties/WithK.agda
index 2ae6422870..8684bf119a 100644
--- a/src/Relation/Binary/Construct/Closure/Reflexive/Properties/WithK.agda
+++ b/src/Relation/Binary/Construct/Closure/Reflexive/Properties/WithK.agda
@@ -8,9 +8,10 @@
 
 module Relation.Binary.Construct.Closure.Reflexive.Properties.WithK where
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Irrelevant; Irreflexive)
 open import Relation.Binary.Construct.Closure.Reflexive
-open import Relation.Binary.PropositionalEquality as PropEq using (_≡_; refl; cong)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
 open import Relation.Nullary.Negation using (contradiction)
 
 open import Relation.Binary.Construct.Closure.Reflexive.Properties public
diff --git a/src/Relation/Binary/Construct/Closure/ReflexiveTransitive.agda b/src/Relation/Binary/Construct/Closure/ReflexiveTransitive.agda
index ef9f4fe074..43778816c3 100644
--- a/src/Relation/Binary/Construct/Closure/ReflexiveTransitive.agda
+++ b/src/Relation/Binary/Construct/Closure/ReflexiveTransitive.agda
@@ -8,7 +8,9 @@
 
 module Relation.Binary.Construct.Closure.ReflexiveTransitive where
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _=[_]⇒_; _⇒_)
+open import Relation.Binary.Definitions
+  using (Transitive; Trans; Sym; TransFlip; Reflexive)
 open import Function.Base
 open import Level using (_⊔_)
 
@@ -128,11 +130,11 @@ _>>=_ : ∀ {i t u} {I : Set i} {T : Rel I t} {U : Rel I u} {j k} →
 m >>= f = (f ⋆) m
 
 -- Note that the monad-like structure above is not an indexed monad
--- (as defined in Category.Monad.Indexed). If it were, then _>>=_
+-- (as defined in Effect.Monad.Indexed). If it were, then _>>=_
 -- would have a type similar to
 --
 --   ∀ {I} {T U : Rel I t} {i j k} →
 --   Star T i j → (T i j → Star U j k) → Star U i k.
 --                  ^^^^^
 -- Note, however, that there is no scope for applying T to any indices
--- in the definition used in Category.Monad.Indexed.
+-- in the definition used in Effect.Monad.Indexed.
diff --git a/src/Relation/Binary/Construct/Closure/ReflexiveTransitive/Properties.agda b/src/Relation/Binary/Construct/Closure/ReflexiveTransitive/Properties.agda
index 88e284c2bf..a68071d25e 100644
--- a/src/Relation/Binary/Construct/Closure/ReflexiveTransitive/Properties.agda
+++ b/src/Relation/Binary/Construct/Closure/ReflexiveTransitive/Properties.agda
@@ -8,12 +8,17 @@
 
 module Relation.Binary.Construct.Closure.ReflexiveTransitive.Properties where
 
-open import Function
-open import Relation.Binary
+open import Function.Base using (id; _∘_; _$_)
+open import Relation.Binary.Core using (Rel; _=[_]⇒_; _⇒_)
+open import Relation.Binary.Bundles using (Preorder)
+open import Relation.Binary.Structures using (IsPreorder)
+open import Relation.Binary.Definitions using (Transitive; Reflexive)
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive
-open import Relation.Binary.PropositionalEquality as PropEq
+open import Relation.Binary.PropositionalEquality.Core as ≡
   using (_≡_; refl; sym; cong; cong₂)
-import Relation.Binary.Reasoning.Preorder as PreR
+import Relation.Binary.PropositionalEquality.Properties as ≡
+import Relation.Binary.Reasoning.Preorder as ≲-Reasoning
+open import Relation.Binary.Reasoning.Syntax
 
 ------------------------------------------------------------------------
 -- _◅◅_
@@ -77,7 +82,7 @@ fold-◅◅ P _⊕_ ∅ left-unit assoc (x ◅ xs) ys = begin
                                                    fold-◅◅ P _⊕_ ∅ left-unit assoc xs ys ⟩
   (x ⊕ (fold P _⊕_ ∅ xs  ⊕ fold P _⊕_ ∅ ys))  ≡⟨ sym (assoc x _ _) ⟩
   ((x ⊕ fold P _⊕_ ∅ xs) ⊕ fold P _⊕_ ∅ ys)   ∎
-  where open PropEq.≡-Reasoning
+  where open ≡.≡-Reasoning
 
 ------------------------------------------------------------------------
 -- Relational properties
@@ -92,7 +97,7 @@ module _ {i t} {I : Set i} (T : Rel I t) where
 
   isPreorder : IsPreorder _≡_ (Star T)
   isPreorder = record
-    { isEquivalence = PropEq.isEquivalence
+    { isEquivalence = ≡.isEquivalence
     ; reflexive     = reflexive
     ; trans         = trans
     }
@@ -100,7 +105,7 @@ module _ {i t} {I : Set i} (T : Rel I t) where
   preorder : Preorder _ _ _
   preorder = record
     { _≈_        = _≡_
-    ; _∼_        = Star T
+    ; _≲_        = Star T
     ; isPreorder = isPreorder
     }
 
@@ -108,17 +113,11 @@ module _ {i t} {I : Set i} (T : Rel I t) where
 -- Preorder reasoning for Star
 
 module StarReasoning {i t} {I : Set i} (T : Rel I t) where
-  private module Base = PreR (preorder T)
+  private module Base = ≲-Reasoning (preorder T)
 
   open Base public
-    hiding (step-≈; step-∼)
+    hiding (step-≈; step-≈˘; step-≈-⟩; step-≈-⟨; step-∼; step-≲)
+    renaming (≲-go to ⟶-go)
 
-  infixr 2 step-⟶ step-⟶⋆
-
-  step-⟶⋆ = Base.step-∼
-
-  step-⟶ : ∀ x {y z} → y IsRelatedTo z → T x y → x IsRelatedTo z
-  step-⟶ x y⟶⋆z x⟶y = step-⟶⋆ x y⟶⋆z (x⟶y ◅ ε)
-
-  syntax step-⟶⋆ x y⟶⋆z x⟶⋆y = x ⟶⋆⟨ x⟶⋆y ⟩ y⟶⋆z
-  syntax step-⟶  x y⟶⋆z x⟶y  = x ⟶⟨ x⟶y ⟩ y⟶⋆z
+  open ⟶-syntax _IsRelatedTo_ _IsRelatedTo_ (⟶-go ∘ (_◅ ε)) public
+  open ⟶*-syntax _IsRelatedTo_ _IsRelatedTo_ ⟶-go public
diff --git a/src/Relation/Binary/Construct/Closure/ReflexiveTransitive/Properties/WithK.agda b/src/Relation/Binary/Construct/Closure/ReflexiveTransitive/Properties/WithK.agda
index c88cf76c8a..899be634a1 100644
--- a/src/Relation/Binary/Construct/Closure/ReflexiveTransitive/Properties/WithK.agda
+++ b/src/Relation/Binary/Construct/Closure/ReflexiveTransitive/Properties/WithK.agda
@@ -11,10 +11,10 @@ module
   Relation.Binary.Construct.Closure.ReflexiveTransitive.Properties.WithK
   where
 
-open import Function
-open import Relation.Binary
-open import Relation.Binary.Construct.Closure.ReflexiveTransitive
-open import Relation.Binary.PropositionalEquality
+open import Function.Base using (_∋_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Construct.Closure.ReflexiveTransitive using (Star; _◅_)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 ------------------------------------------------------------------------
 -- Equality
diff --git a/src/Relation/Binary/Construct/Closure/Symmetric.agda b/src/Relation/Binary/Construct/Closure/Symmetric.agda
index c1731b5ecd..369b368f20 100644
--- a/src/Relation/Binary/Construct/Closure/Symmetric.agda
+++ b/src/Relation/Binary/Construct/Closure/Symmetric.agda
@@ -10,7 +10,8 @@ module Relation.Binary.Construct.Closure.Symmetric where
 
 open import Function.Base using (id; _on_)
 open import Level using (Level)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _=[_]⇒_; _⇒_)
+open import Relation.Binary.Definitions using (Symmetric)
 import Relation.Binary.Construct.On as On
 
 private
diff --git a/src/Relation/Binary/Construct/Closure/SymmetricTransitive.agda b/src/Relation/Binary/Construct/Closure/SymmetricTransitive.agda
index 0ef90ba9b4..5766ce704a 100644
--- a/src/Relation/Binary/Construct/Closure/SymmetricTransitive.agda
+++ b/src/Relation/Binary/Construct/Closure/SymmetricTransitive.agda
@@ -10,7 +10,12 @@ module Relation.Binary.Construct.Closure.SymmetricTransitive where
 
 open import Level
 open import Function.Base
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _=[_]⇒_; _⇒_)
+open import Relation.Binary.Bundles using (PartialSetoid; Setoid)
+open import Relation.Binary.Structures
+  using (IsPartialEquivalence; IsEquivalence)
+open import Relation.Binary.Definitions
+  using (Transitive; Symmetric; Reflexive)
 
 private
   variable
diff --git a/src/Relation/Binary/Construct/Closure/Transitive.agda b/src/Relation/Binary/Construct/Closure/Transitive.agda
index 85ab19e3dc..fde3fe17a3 100644
--- a/src/Relation/Binary/Construct/Closure/Transitive.agda
+++ b/src/Relation/Binary/Construct/Closure/Transitive.agda
@@ -12,8 +12,10 @@ open import Function.Base
 open import Function.Bundles using (_⇔_; mk⇔)
 open import Induction.WellFounded
 open import Level
-open import Relation.Binary hiding (_⇔_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (Rel; _=[_]⇒_; _⇒_)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 private
   variable
@@ -39,6 +41,8 @@ module _ {_∼_ : Rel A ℓ} where
   private
     _∼⁺_ = TransClosure _∼_
 
+  infixr 5 _∷ʳ_
+
   _∷ʳ_ : ∀ {x y z} → (x∼⁺y : x ∼⁺ y) (y∼z : y ∼ z) → x ∼⁺ z
   [ x∼y ]      ∷ʳ y∼z = x∼y ∷ [ y∼z ]
   (x∼y ∷ x∼⁺y) ∷ʳ y∼z = x∼y ∷ (x∼⁺y ∷ʳ y∼z)
@@ -54,6 +58,7 @@ module _ {_∼_ : Rel A ℓ} where
 module _ (_∼_ : Rel A ℓ) where
   private
     _∼⁺_ = TransClosure _∼_
+    module ∼⊆∼⁺ = Subrelation {_<₂_ = _∼⁺_} [_]
 
   reflexive : Reflexive _∼_ → Reflexive _∼⁺_
   reflexive refl = [ refl ]
@@ -65,17 +70,25 @@ module _ (_∼_ : Rel A ℓ) where
   transitive : Transitive _∼⁺_
   transitive = _++_
 
-  wellFounded : WellFounded _∼_ → WellFounded _∼⁺_
-  wellFounded wf = λ x → acc (accessible′ (wf x))
-    where
-    downwardsClosed : ∀ {x y} → Acc _∼⁺_ y → x ∼ y → Acc _∼⁺_ x
-    downwardsClosed (acc rec) x∼y = acc (λ z z∼x → rec z (z∼x ∷ʳ x∼y))
+  transitive⁻ : Transitive _∼_ → _∼⁺_ ⇒ _∼_
+  transitive⁻ trans [ x∼y ]      = x∼y
+  transitive⁻ trans (x∼y ∷ x∼⁺y) = trans x∼y (transitive⁻ trans x∼⁺y)
+
+  accessible⁻ : ∀ {x} → Acc _∼⁺_ x → Acc _∼_ x
+  accessible⁻ = ∼⊆∼⁺.accessible
 
-    accessible′ : ∀ {x} → Acc _∼_ x → WfRec _∼⁺_ (Acc _∼⁺_) x
-    accessible′ (acc rec) y [ y∼x ]      = acc (accessible′ (rec y y∼x))
-    accessible′ acc[x]    y (y∼z ∷ z∼⁺x) =
-      downwardsClosed (accessible′ acc[x] _ z∼⁺x) y∼z
+  wellFounded⁻ : WellFounded _∼⁺_ → WellFounded _∼_
+  wellFounded⁻ = ∼⊆∼⁺.wellFounded
 
+  accessible : ∀ {x} → Acc _∼_ x → Acc _∼⁺_ x
+  accessible acc[x] = acc (wf-acc acc[x])
+    where
+    wf-acc : ∀ {x} → Acc _∼_ x → WfRec _∼⁺_ (Acc _∼⁺_) x
+    wf-acc (acc rec) [ y∼x ]   = acc (wf-acc (rec y∼x))
+    wf-acc acc[x] (y∼z ∷ z∼⁺x) = acc-inverse (wf-acc acc[x] z∼⁺x) [ y∼z ]
+
+  wellFounded : WellFounded _∼_ → WellFounded _∼⁺_
+  wellFounded wf x = accessible (wf x)
 
 
 ------------------------------------------------------------------------
@@ -93,7 +106,7 @@ data Plus {A : Set a} (_∼_ : Rel A ℓ) : Rel A (a ⊔ ℓ) where
 module _ {_∼_ : Rel A ℓ} where
 
  []-injective : ∀ {x y p q} → (x [ _∼_ ]⁺ y ∋ [ p ]) ≡ [ q ] → p ≡ q
- []-injective P.refl = P.refl
+ []-injective ≡.refl = ≡.refl
 
  -- See also ∼⁺⟨⟩-injectiveˡ and ∼⁺⟨⟩-injectiveʳ in
  -- Relation.Binary.Construct.Closure.Transitive.WithK.
diff --git a/src/Relation/Binary/Construct/Closure/Transitive/WithK.agda b/src/Relation/Binary/Construct/Closure/Transitive/WithK.agda
index 1eff43bbca..c05323903b 100644
--- a/src/Relation/Binary/Construct/Closure/Transitive/WithK.agda
+++ b/src/Relation/Binary/Construct/Closure/Transitive/WithK.agda
@@ -8,10 +8,10 @@
 
 module Relation.Binary.Construct.Closure.Transitive.WithK where
 
-open import Function
-open import Relation.Binary
+open import Function.Base using (_∋_)
+open import Relation.Binary.Core using (Rel)
 open import Relation.Binary.Construct.Closure.Transitive
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 module _ {a ℓ} {A : Set a} {_∼_ : Rel A ℓ} where
 
diff --git a/src/Relation/Binary/Construct/Composition.agda b/src/Relation/Binary/Construct/Composition.agda
index e34550fb58..35df23947d 100644
--- a/src/Relation/Binary/Construct/Composition.agda
+++ b/src/Relation/Binary/Construct/Composition.agda
@@ -8,10 +8,13 @@
 
 module Relation.Binary.Construct.Composition where
 
-open import Data.Product
+open import Data.Product.Base using (∃; _×_; _,_)
 open import Function.Base
 open import Level
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; REL; _⇒_)
+open import Relation.Binary.Structures using (IsPreorder)
+open import Relation.Binary.Definitions
+  using (_Respects_; _Respectsʳ_; _Respectsˡ_; _Respects₂_; Reflexive; Transitive)
 
 private
   variable
@@ -23,6 +26,8 @@ private
 ------------------------------------------------------------------------
 -- Definition
 
+infixr 9 _;_
+
 _;_ : {A : Set a} {B : Set b} {C : Set c} →
       REL A B ℓ₁ → REL B C ℓ₂ → REL A C (b ⊔ ℓ₁ ⊔ ℓ₂)
 L ; R = λ i j → ∃ λ k → L i k × R k j
@@ -77,3 +82,6 @@ module _ (L : Rel A ℓ₁) (R : Rel A ℓ₂) (comm : R ; L ⇒ L ; R) where
     ; trans         = transitive Oˡ.trans Oʳ.trans
     }
     where module Oˡ = IsPreorder Oˡ; module Oʳ = IsPreorder Oʳ
+
+transitive⇒≈;≈⊆≈ : (≈ : Rel A ℓ) → Transitive ≈ → (≈ ; ≈) ⇒ ≈
+transitive⇒≈;≈⊆≈ _ trans (_ , l , r) = trans l r
diff --git a/src/Relation/Binary/Construct/Constant.agda b/src/Relation/Binary/Construct/Constant.agda
index 1dad265ea7..8566dc6e30 100644
--- a/src/Relation/Binary/Construct/Constant.agda
+++ b/src/Relation/Binary/Construct/Constant.agda
@@ -9,7 +9,9 @@
 module Relation.Binary.Construct.Constant where
 
 open import Level
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions using (Reflexive; Symmetric; Transitive)
 
 private
   variable
diff --git a/src/Relation/Binary/Construct/Converse.agda b/src/Relation/Binary/Construct/Converse.agda
index e750283521..c1e2d177a7 100644
--- a/src/Relation/Binary/Construct/Converse.agda
+++ b/src/Relation/Binary/Construct/Converse.agda
@@ -1,195 +1,17 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Many properties which hold for `∼` also hold for `flip ∼`. Unlike
--- the module `Relation.Binary.Construct.Flip` this module does not
--- flip the underlying equality.
+-- This module is DEPRECATED. Please use
+-- `Relation.Binary.Construct.Flip.EqAndOrd` instead.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
-
 module Relation.Binary.Construct.Converse where
 
-open import Data.Product
-open import Function.Base using (flip; _∘_)
-open import Level using (Level)
-
-private
-  variable
-    a b p ℓ ℓ₁ ℓ₂ : Level
-    A B : Set a
-    ≈ ∼ ≤ < : Rel A ℓ
-
-------------------------------------------------------------------------
--- Properties
-
-module _ (∼ : Rel A ℓ) where
-
-  refl : Reflexive ∼ → Reflexive (flip ∼)
-  refl refl = refl
-
-  sym : Symmetric ∼ → Symmetric (flip ∼)
-  sym sym = sym
-
-  trans : Transitive ∼ → Transitive (flip ∼)
-  trans trans = flip trans
-
-  asym : Asymmetric ∼ → Asymmetric (flip ∼)
-  asym asym = asym
-
-  total : Total ∼ → Total (flip ∼)
-  total total x y = total y x
-
-  resp : ∀ {p} (P : A → Set p) → Symmetric ∼ →
-             P Respects ∼ → P Respects (flip ∼)
-  resp _ sym resp ∼ = resp (sym ∼)
-
-  max : ∀ {⊥} → Minimum ∼ ⊥ → Maximum (flip ∼) ⊥
-  max min = min
-
-  min : ∀ {⊤} → Maximum ∼ ⊤ → Minimum (flip ∼) ⊤
-  min max = max
-
-module _ {≈ : Rel A ℓ₁} (∼ : Rel A ℓ₂) where
-
-  reflexive : Symmetric ≈ → (≈ ⇒ ∼) → (≈ ⇒ flip ∼)
-  reflexive sym impl = impl ∘ sym
-
-  irrefl : Symmetric ≈ → Irreflexive ≈ ∼ → Irreflexive ≈ (flip ∼)
-  irrefl sym irrefl x≈y y∼x = irrefl (sym x≈y) y∼x
-
-  antisym : Antisymmetric ≈ ∼ → Antisymmetric ≈ (flip ∼)
-  antisym antisym = flip antisym
-
-  compare : Trichotomous ≈ ∼ → Trichotomous ≈ (flip ∼)
-  compare cmp x y with cmp x y
-  ... | tri< x<y x≉y y≮x = tri> y≮x x≉y x<y
-  ... | tri≈ x≮y x≈y y≮x = tri≈ y≮x x≈y x≮y
-  ... | tri> x≮y x≉y y<x = tri< y<x x≉y x≮y
-
-module _ (∼₁ : Rel A ℓ₁) (∼₂ : Rel A ℓ₂) where
-
-  resp₂ : ∼₁ Respects₂ ∼₂ → (flip ∼₁) Respects₂ ∼₂
-  resp₂ (resp₁ , resp₂) = resp₂ , resp₁
-
-module _ (∼ : REL A B ℓ) where
-
-  dec : Decidable ∼ → Decidable (flip ∼)
-  dec dec = flip dec
-
-------------------------------------------------------------------------
--- Structures
-
-isEquivalence : IsEquivalence ≈ → IsEquivalence (flip ≈)
-isEquivalence {≈ = ≈} eq = record
-  { refl  = refl  ≈ Eq.refl
-  ; sym   = sym   ≈ Eq.sym
-  ; trans = trans ≈ Eq.trans
-  } where module Eq = IsEquivalence eq
-
-isDecEquivalence : IsDecEquivalence ≈ → IsDecEquivalence (flip ≈)
-isDecEquivalence {≈ = ≈} eq = record
-  { isEquivalence = isEquivalence Dec.isEquivalence
-  ; _≟_           = dec ≈ Dec._≟_
-  } where module Dec = IsDecEquivalence eq
-
-isPreorder : IsPreorder ≈ ∼ → IsPreorder ≈ (flip ∼)
-isPreorder {≈ = ≈} {∼ = ∼} O = record
-  { isEquivalence = O.isEquivalence
-  ; reflexive     = reflexive ∼ O.Eq.sym O.reflexive
-  ; trans         = trans ∼ O.trans
-  } where module O = IsPreorder O
-
-isTotalPreorder : IsTotalPreorder ≈ ∼ → IsTotalPreorder ≈ (flip ∼)
-isTotalPreorder O = record
-  { isPreorder = isPreorder O.isPreorder
-  ; total      = total _ O.total
-  } where module O = IsTotalPreorder O
-
-isPartialOrder : IsPartialOrder ≈ ≤ → IsPartialOrder ≈ (flip ≤)
-isPartialOrder {≤ = ≤} O = record
-  { isPreorder = isPreorder O.isPreorder
-  ; antisym    = antisym ≤ O.antisym
-  } where module O = IsPartialOrder O
-
-isTotalOrder : IsTotalOrder ≈ ≤ → IsTotalOrder ≈ (flip ≤)
-isTotalOrder O = record
-  { isPartialOrder = isPartialOrder O.isPartialOrder
-  ; total          = total _ O.total
-  } where module O = IsTotalOrder O
-
-isDecTotalOrder : IsDecTotalOrder ≈ ≤ → IsDecTotalOrder ≈ (flip ≤)
-isDecTotalOrder O = record
-  { isTotalOrder = isTotalOrder O.isTotalOrder
-  ; _≟_          = O._≟_
-  ; _≤?_         = dec _ O._≤?_
-  } where module O = IsDecTotalOrder O
-
-isStrictPartialOrder : IsStrictPartialOrder ≈ < →
-                       IsStrictPartialOrder ≈ (flip <)
-isStrictPartialOrder {< = <} O = record
-  { isEquivalence = O.isEquivalence
-  ; irrefl        = irrefl < O.Eq.sym O.irrefl
-  ; trans         = trans < O.trans
-  ; <-resp-≈      = resp₂ _ _ O.<-resp-≈
-  } where module O = IsStrictPartialOrder O
-
-isStrictTotalOrder : IsStrictTotalOrder ≈ < →
-                     IsStrictTotalOrder ≈ (flip <)
-isStrictTotalOrder {< = <} O = record
-  { isEquivalence = O.isEquivalence
-  ; trans         = trans < O.trans
-  ; compare       = compare _ O.compare
-  } where module O = IsStrictTotalOrder O
-
-------------------------------------------------------------------------
--- Bundles
-
-setoid : Setoid a ℓ → Setoid a ℓ
-setoid S = record
-  { isEquivalence = isEquivalence S.isEquivalence
-  } where module S = Setoid S
-
-decSetoid : DecSetoid a ℓ → DecSetoid a ℓ
-decSetoid S = record
-  { isDecEquivalence = isDecEquivalence S.isDecEquivalence
-  } where module S = DecSetoid S
-
-preorder : Preorder a ℓ₁ ℓ₂ → Preorder a ℓ₁ ℓ₂
-preorder O = record
-  { isPreorder = isPreorder O.isPreorder
-  } where module O = Preorder O
-
-totalPreorder : TotalPreorder a ℓ₁ ℓ₂ → TotalPreorder a ℓ₁ ℓ₂
-totalPreorder O = record
-  { isTotalPreorder = isTotalPreorder O.isTotalPreorder
-  } where module O = TotalPreorder O
-
-poset : Poset a ℓ₁ ℓ₂ → Poset a ℓ₁ ℓ₂
-poset O = record
-  { isPartialOrder = isPartialOrder O.isPartialOrder
-  } where module O = Poset O
-
-totalOrder : TotalOrder a ℓ₁ ℓ₂ → TotalOrder a ℓ₁ ℓ₂
-totalOrder O = record
-  { isTotalOrder = isTotalOrder O.isTotalOrder
-  } where module O = TotalOrder O
-
-decTotalOrder : DecTotalOrder a ℓ₁ ℓ₂ → DecTotalOrder a ℓ₁ ℓ₂
-decTotalOrder O = record
-  { isDecTotalOrder = isDecTotalOrder O.isDecTotalOrder
-  } where module O = DecTotalOrder O
-
-strictPartialOrder : StrictPartialOrder a ℓ₁ ℓ₂ →
-                     StrictPartialOrder a ℓ₁ ℓ₂
-strictPartialOrder O = record
-  { isStrictPartialOrder = isStrictPartialOrder O.isStrictPartialOrder
-  } where module O = StrictPartialOrder O
+open import Relation.Binary.Construct.Flip.EqAndOrd public
 
-strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂ →
-                   StrictTotalOrder a ℓ₁ ℓ₂
-strictTotalOrder O = record
-  { isStrictTotalOrder = isStrictTotalOrder O.isStrictTotalOrder
-  } where module O = StrictTotalOrder O
+{-# WARNING_ON_IMPORT
+"Relation.Binary.Construct.Converse was deprecated in v2.0.
+Use Relation.Binary.Construct.Flip.EqAndOrd instead."
+#-}
diff --git a/src/Relation/Binary/Construct/Flip.agda b/src/Relation/Binary/Construct/Flip.agda
index 2f7145be9e..cbae1e8867 100644
--- a/src/Relation/Binary/Construct/Flip.agda
+++ b/src/Relation/Binary/Construct/Flip.agda
@@ -1,186 +1,17 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Many properties which hold for `∼` also hold for `flip ∼`. Unlike
--- the module `Relation.Binary.Construct.Converse` this module flips
--- both the relation and the underlying equality.
+-- This module is DEPRECATED. Please use
+-- `Relation.Binary.Construct.Flip.Ord` instead.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
-
 module Relation.Binary.Construct.Flip where
 
-open import Data.Product
-open import Function.Base using (flip; _∘_)
-open import Level using (Level)
-
-private
-  variable
-    a b p ℓ ℓ₁ ℓ₂ : Level
-    A B : Set a
-    ≈ ∼ ≤ < : Rel A ℓ
-
-------------------------------------------------------------------------
--- Properties
-
-module _ (∼ : Rel A ℓ) where
-
-  reflexive : Reflexive ∼ → Reflexive (flip ∼)
-  reflexive refl = refl
-
-  symmetric : Symmetric ∼ → Symmetric (flip ∼)
-  symmetric sym = sym
-
-  transitive : Transitive ∼ → Transitive (flip ∼)
-  transitive trans = flip trans
-
-  asymmetric : Asymmetric ∼ → Asymmetric (flip ∼)
-  asymmetric asym = asym
-
-  total : Total ∼ → Total (flip ∼)
-  total total x y = total y x
-
-  respects : ∀ (P : A → Set p) → Symmetric ∼ →
-             P Respects ∼ → P Respects flip ∼
-  respects _ sym resp ∼ = resp (sym ∼)
-
-  max : ∀ {⊥} → Minimum ∼ ⊥ → Maximum (flip ∼) ⊥
-  max min = min
-
-  min : ∀ {⊤} → Maximum ∼ ⊤ → Minimum (flip ∼) ⊤
-  min max = max
-
-module _ (≈ : REL A B ℓ₁) (∼ : REL A B ℓ₂) where
-
-  implies : ≈ ⇒ ∼ → flip ≈ ⇒ flip ∼
-  implies impl = impl
-
-  irreflexive : Irreflexive ≈ ∼ → Irreflexive (flip ≈) (flip ∼)
-  irreflexive irrefl = irrefl
-
-module _ (≈ : Rel A ℓ₁) (∼ : Rel A ℓ₂) where
-
-  antisymmetric : Antisymmetric ≈ ∼ → Antisymmetric (flip ≈) (flip ∼)
-  antisymmetric antisym = antisym
-
-  trichotomous : Trichotomous ≈ ∼ → Trichotomous (flip ≈) (flip ∼)
-  trichotomous compare x y = compare y x
-
-module _ (∼₁ : Rel A ℓ₁) (∼₂ : Rel A ℓ₂) where
-
-  respects₂ : Symmetric ∼₂ → ∼₁ Respects₂ ∼₂ → flip ∼₁ Respects₂ flip ∼₂
-  respects₂ sym (resp₁ , resp₂) = (resp₂ ∘ sym , resp₁ ∘ sym)
-
-module _ (∼ : REL A B ℓ) where
-
-  decidable : Decidable ∼ → Decidable (flip ∼)
-  decidable dec x y = dec y x
-
-------------------------------------------------------------------------
--- Structures
-
-isEquivalence : IsEquivalence ≈ → IsEquivalence (flip ≈)
-isEquivalence {≈ = ≈} eq = record
-  { refl  = reflexive  ≈ Eq.refl
-  ; sym   = symmetric  ≈ Eq.sym
-  ; trans = transitive ≈ Eq.trans
-  } where module Eq = IsEquivalence eq
-
-isDecEquivalence : IsDecEquivalence ≈ → IsDecEquivalence (flip ≈)
-isDecEquivalence {≈ = ≈} dec = record
-  { isEquivalence = isEquivalence Dec.isEquivalence
-  ; _≟_           = decidable ≈ Dec._≟_
-  } where module Dec = IsDecEquivalence dec
-
-isPreorder : IsPreorder ≈ ∼ → IsPreorder (flip ≈) (flip ∼)
-isPreorder {≈ = ≈} {∼ = ∼} O = record
-  { isEquivalence = isEquivalence O.isEquivalence
-  ; reflexive     = implies ≈ ∼ O.reflexive
-  ; trans         = transitive ∼ O.trans
-  } where module O = IsPreorder O
-
-isPartialOrder : IsPartialOrder ≈ ≤ → IsPartialOrder (flip ≈) (flip ≤)
-isPartialOrder {≈ = ≈} {≤ = ≤} O = record
-  { isPreorder = isPreorder O.isPreorder
-  ; antisym    = antisymmetric ≈ ≤ O.antisym
-  } where module O = IsPartialOrder O
-
-isTotalOrder : IsTotalOrder ≈ ≤ → IsTotalOrder (flip ≈) (flip ≤)
-isTotalOrder {≈ = ≈} {≤ = ≤} O = record
-  { isPartialOrder = isPartialOrder O.isPartialOrder
-  ; total          = total ≤ O.total
-  }
-  where module O = IsTotalOrder O
-
-isDecTotalOrder : IsDecTotalOrder ≈ ≤ → IsDecTotalOrder (flip ≈) (flip ≤)
-isDecTotalOrder {≈ = ≈} {≤ = ≤} O = record
-  { isTotalOrder = isTotalOrder O.isTotalOrder
-  ; _≟_          = decidable ≈ O._≟_
-  ; _≤?_         = decidable ≤ O._≤?_
-  } where module O = IsDecTotalOrder O
-
-isStrictPartialOrder : IsStrictPartialOrder ≈ < →
-                       IsStrictPartialOrder (flip ≈) (flip <)
-isStrictPartialOrder {≈ = ≈} {< = <} O = record
-  { isEquivalence = isEquivalence O.isEquivalence
-  ; irrefl        = irreflexive ≈ < O.irrefl
-  ; trans         = transitive < O.trans
-  ; <-resp-≈      = respects₂ < ≈ O.Eq.sym O.<-resp-≈
-  } where module O = IsStrictPartialOrder O
-
-isStrictTotalOrder : IsStrictTotalOrder ≈ < →
-                     IsStrictTotalOrder (flip ≈) (flip <)
-isStrictTotalOrder {≈ = ≈} {< = <} O = record
-  { isEquivalence = isEquivalence O.isEquivalence
-  ; trans         = transitive < O.trans
-  ; compare       = trichotomous ≈ < O.compare
-  } where module O = IsStrictTotalOrder O
-
-------------------------------------------------------------------------
--- Bundles
-
-setoid : Setoid a ℓ → Setoid a ℓ
-setoid S = record
-  { _≈_           = flip S._≈_
-  ; isEquivalence = isEquivalence S.isEquivalence
-  } where module S = Setoid S
-
-decSetoid : DecSetoid a ℓ → DecSetoid a ℓ
-decSetoid S = record
-  { _≈_              = flip S._≈_
-  ; isDecEquivalence = isDecEquivalence S.isDecEquivalence
-  } where module S = DecSetoid S
-
-preorder : Preorder a ℓ₁ ℓ₂ → Preorder a ℓ₁ ℓ₂
-preorder O = record
-  { isPreorder = isPreorder O.isPreorder
-  } where module O = Preorder O
-
-poset : Poset a ℓ₁ ℓ₂ → Poset a ℓ₁ ℓ₂
-poset O = record
-  { isPartialOrder = isPartialOrder O.isPartialOrder
-  } where module O = Poset O
-
-totalOrder : TotalOrder a ℓ₁ ℓ₂ → TotalOrder a ℓ₁ ℓ₂
-totalOrder O = record
-  { isTotalOrder = isTotalOrder O.isTotalOrder
-  } where module O = TotalOrder O
-
-decTotalOrder : DecTotalOrder a ℓ₁ ℓ₂ → DecTotalOrder a ℓ₁ ℓ₂
-decTotalOrder O = record
-  { isDecTotalOrder = isDecTotalOrder O.isDecTotalOrder
-  } where module O = DecTotalOrder O
-
-strictPartialOrder : StrictPartialOrder a ℓ₁ ℓ₂ →
-                     StrictPartialOrder a ℓ₁ ℓ₂
-strictPartialOrder O = record
-  { isStrictPartialOrder = isStrictPartialOrder O.isStrictPartialOrder
-  } where module O = StrictPartialOrder O
+open import Relation.Binary.Construct.Flip.Ord public
 
-strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂ →
-                   StrictTotalOrder a ℓ₁ ℓ₂
-strictTotalOrder O = record
-  { isStrictTotalOrder = isStrictTotalOrder O.isStrictTotalOrder
-  } where module O = StrictTotalOrder O
+{-# WARNING_ON_IMPORT
+"Relation.Binary.Construct.Flip was deprecated in v2.0.
+Use Relation.Binary.Construct.Flip.Ord instead."
+#-}
diff --git a/src/Relation/Binary/Construct/Flip/EqAndOrd.agda b/src/Relation/Binary/Construct/Flip/EqAndOrd.agda
new file mode 100644
index 0000000000..122842f967
--- /dev/null
+++ b/src/Relation/Binary/Construct/Flip/EqAndOrd.agda
@@ -0,0 +1,200 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Many properties which hold for `∼` also hold for `flip ∼`. Unlike
+-- the module `Relation.Binary.Construct.Flip.Ord` this module does not
+-- flip the underlying equality.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Core using (Rel; REL; _⇒_)
+open import Relation.Binary.Bundles
+  using (Setoid; DecSetoid; Preorder; Poset; TotalOrder; DecTotalOrder; StrictPartialOrder; StrictTotalOrder; TotalPreorder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence; IsPreorder; IsPartialOrder; IsTotalOrder; IsDecTotalOrder; IsStrictPartialOrder; IsStrictTotalOrder; IsTotalPreorder)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Asymmetric; Total; _Respects_; _Respects₂_; Minimum; Maximum; Irreflexive; Antisymmetric; Trichotomous; Decidable; tri<; tri>; tri≈)
+
+module Relation.Binary.Construct.Flip.EqAndOrd where
+
+open import Data.Product.Base using (_,_)
+open import Function.Base using (flip; _∘_)
+open import Level using (Level)
+
+private
+  variable
+    a b p ℓ ℓ₁ ℓ₂ : Level
+    A B : Set a
+    ≈ ∼ ≤ < : Rel A ℓ
+
+------------------------------------------------------------------------
+-- Properties
+
+module _ (∼ : Rel A ℓ) where
+
+  refl : Reflexive ∼ → Reflexive (flip ∼)
+  refl refl = refl
+
+  sym : Symmetric ∼ → Symmetric (flip ∼)
+  sym sym = sym
+
+  trans : Transitive ∼ → Transitive (flip ∼)
+  trans trans = flip trans
+
+  asym : Asymmetric ∼ → Asymmetric (flip ∼)
+  asym asym = asym
+
+  total : Total ∼ → Total (flip ∼)
+  total total x y = total y x
+
+  resp : ∀ {p} (P : A → Set p) → Symmetric ∼ →
+             P Respects ∼ → P Respects (flip ∼)
+  resp _ sym resp ∼ = resp (sym ∼)
+
+  max : ∀ {⊥} → Minimum ∼ ⊥ → Maximum (flip ∼) ⊥
+  max min = min
+
+  min : ∀ {⊤} → Maximum ∼ ⊤ → Minimum (flip ∼) ⊤
+  min max = max
+
+module _ {≈ : Rel A ℓ₁} (∼ : Rel A ℓ₂) where
+
+  reflexive : Symmetric ≈ → (≈ ⇒ ∼) → (≈ ⇒ flip ∼)
+  reflexive sym impl = impl ∘ sym
+
+  irrefl : Symmetric ≈ → Irreflexive ≈ ∼ → Irreflexive ≈ (flip ∼)
+  irrefl sym irrefl x≈y y∼x = irrefl (sym x≈y) y∼x
+
+  antisym : Antisymmetric ≈ ∼ → Antisymmetric ≈ (flip ∼)
+  antisym antisym = flip antisym
+
+  compare : Trichotomous ≈ ∼ → Trichotomous ≈ (flip ∼)
+  compare cmp x y with cmp x y
+  ... | tri< x<y x≉y y≮x = tri> y≮x x≉y x<y
+  ... | tri≈ x≮y x≈y y≮x = tri≈ y≮x x≈y x≮y
+  ... | tri> x≮y x≉y y<x = tri< y<x x≉y x≮y
+
+module _ (∼₁ : Rel A ℓ₁) (∼₂ : Rel A ℓ₂) where
+
+  resp₂ : ∼₁ Respects₂ ∼₂ → (flip ∼₁) Respects₂ ∼₂
+  resp₂ (resp₁ , resp₂) = resp₂ , resp₁
+
+module _ (∼ : REL A B ℓ) where
+
+  dec : Decidable ∼ → Decidable (flip ∼)
+  dec dec = flip dec
+
+------------------------------------------------------------------------
+-- Structures
+
+isEquivalence : IsEquivalence ≈ → IsEquivalence (flip ≈)
+isEquivalence {≈ = ≈} eq = record
+  { refl  = refl  ≈ Eq.refl
+  ; sym   = sym   ≈ Eq.sym
+  ; trans = trans ≈ Eq.trans
+  } where module Eq = IsEquivalence eq
+
+isDecEquivalence : IsDecEquivalence ≈ → IsDecEquivalence (flip ≈)
+isDecEquivalence {≈ = ≈} eq = record
+  { isEquivalence = isEquivalence Dec.isEquivalence
+  ; _≟_           = dec ≈ Dec._≟_
+  } where module Dec = IsDecEquivalence eq
+
+isPreorder : IsPreorder ≈ ∼ → IsPreorder ≈ (flip ∼)
+isPreorder {≈ = ≈} {∼ = ∼} O = record
+  { isEquivalence = O.isEquivalence
+  ; reflexive     = reflexive ∼ O.Eq.sym O.reflexive
+  ; trans         = trans ∼ O.trans
+  } where module O = IsPreorder O
+
+isTotalPreorder : IsTotalPreorder ≈ ∼ → IsTotalPreorder ≈ (flip ∼)
+isTotalPreorder O = record
+  { isPreorder = isPreorder O.isPreorder
+  ; total      = total _ O.total
+  } where module O = IsTotalPreorder O
+
+isPartialOrder : IsPartialOrder ≈ ≤ → IsPartialOrder ≈ (flip ≤)
+isPartialOrder {≤ = ≤} O = record
+  { isPreorder = isPreorder O.isPreorder
+  ; antisym    = antisym ≤ O.antisym
+  } where module O = IsPartialOrder O
+
+isTotalOrder : IsTotalOrder ≈ ≤ → IsTotalOrder ≈ (flip ≤)
+isTotalOrder O = record
+  { isPartialOrder = isPartialOrder O.isPartialOrder
+  ; total          = total _ O.total
+  } where module O = IsTotalOrder O
+
+isDecTotalOrder : IsDecTotalOrder ≈ ≤ → IsDecTotalOrder ≈ (flip ≤)
+isDecTotalOrder O = record
+  { isTotalOrder = isTotalOrder O.isTotalOrder
+  ; _≟_          = O._≟_
+  ; _≤?_         = dec _ O._≤?_
+  } where module O = IsDecTotalOrder O
+
+isStrictPartialOrder : IsStrictPartialOrder ≈ < →
+                       IsStrictPartialOrder ≈ (flip <)
+isStrictPartialOrder {< = <} O = record
+  { isEquivalence = O.isEquivalence
+  ; irrefl        = irrefl < O.Eq.sym O.irrefl
+  ; trans         = trans < O.trans
+  ; <-resp-≈      = resp₂ _ _ O.<-resp-≈
+  } where module O = IsStrictPartialOrder O
+
+isStrictTotalOrder : IsStrictTotalOrder ≈ < →
+                     IsStrictTotalOrder ≈ (flip <)
+isStrictTotalOrder {< = <} O = record
+  { isStrictPartialOrder = isStrictPartialOrder O.isStrictPartialOrder
+  ; compare              = compare _ O.compare
+  } where module O = IsStrictTotalOrder O
+
+------------------------------------------------------------------------
+-- Bundles
+
+setoid : Setoid a ℓ → Setoid a ℓ
+setoid S = record
+  { isEquivalence = isEquivalence S.isEquivalence
+  } where module S = Setoid S
+
+decSetoid : DecSetoid a ℓ → DecSetoid a ℓ
+decSetoid S = record
+  { isDecEquivalence = isDecEquivalence S.isDecEquivalence
+  } where module S = DecSetoid S
+
+preorder : Preorder a ℓ₁ ℓ₂ → Preorder a ℓ₁ ℓ₂
+preorder O = record
+  { isPreorder = isPreorder O.isPreorder
+  } where module O = Preorder O
+
+totalPreorder : TotalPreorder a ℓ₁ ℓ₂ → TotalPreorder a ℓ₁ ℓ₂
+totalPreorder O = record
+  { isTotalPreorder = isTotalPreorder O.isTotalPreorder
+  } where module O = TotalPreorder O
+
+poset : Poset a ℓ₁ ℓ₂ → Poset a ℓ₁ ℓ₂
+poset O = record
+  { isPartialOrder = isPartialOrder O.isPartialOrder
+  } where module O = Poset O
+
+totalOrder : TotalOrder a ℓ₁ ℓ₂ → TotalOrder a ℓ₁ ℓ₂
+totalOrder O = record
+  { isTotalOrder = isTotalOrder O.isTotalOrder
+  } where module O = TotalOrder O
+
+decTotalOrder : DecTotalOrder a ℓ₁ ℓ₂ → DecTotalOrder a ℓ₁ ℓ₂
+decTotalOrder O = record
+  { isDecTotalOrder = isDecTotalOrder O.isDecTotalOrder
+  } where module O = DecTotalOrder O
+
+strictPartialOrder : StrictPartialOrder a ℓ₁ ℓ₂ →
+                     StrictPartialOrder a ℓ₁ ℓ₂
+strictPartialOrder O = record
+  { isStrictPartialOrder = isStrictPartialOrder O.isStrictPartialOrder
+  } where module O = StrictPartialOrder O
+
+strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂ →
+                   StrictTotalOrder a ℓ₁ ℓ₂
+strictTotalOrder O = record
+  { isStrictTotalOrder = isStrictTotalOrder O.isStrictTotalOrder
+  } where module O = StrictTotalOrder O
diff --git a/src/Relation/Binary/Construct/Flip/Ord.agda b/src/Relation/Binary/Construct/Flip/Ord.agda
new file mode 100644
index 0000000000..64d41fdb77
--- /dev/null
+++ b/src/Relation/Binary/Construct/Flip/Ord.agda
@@ -0,0 +1,191 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Many properties which hold for `∼` also hold for `flip ∼`. Unlike
+-- the module `Relation.Binary.Construct.Flip.EqAndOrd` this module
+-- flips both the relation and the underlying equality.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Core using (Rel; REL; _⇒_)
+open import Relation.Binary.Bundles
+  using (Setoid; DecSetoid; Preorder; Poset; TotalOrder; DecTotalOrder; StrictPartialOrder; StrictTotalOrder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence; IsPreorder; IsPartialOrder; IsTotalOrder; IsDecTotalOrder; IsStrictPartialOrder; IsStrictTotalOrder)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Asymmetric; Total; _Respects_; _Respects₂_; Minimum; Maximum; Irreflexive; Antisymmetric; Trichotomous; Decidable)
+
+module Relation.Binary.Construct.Flip.Ord where
+
+open import Data.Product.Base using (_,_)
+open import Function.Base using (flip; _∘_)
+open import Level using (Level)
+
+private
+  variable
+    a b p ℓ ℓ₁ ℓ₂ : Level
+    A B : Set a
+    ≈ ∼ ≤ < : Rel A ℓ
+
+------------------------------------------------------------------------
+-- Properties
+
+module _ (∼ : Rel A ℓ) where
+
+  reflexive : Reflexive ∼ → Reflexive (flip ∼)
+  reflexive refl = refl
+
+  symmetric : Symmetric ∼ → Symmetric (flip ∼)
+  symmetric sym = sym
+
+  transitive : Transitive ∼ → Transitive (flip ∼)
+  transitive trans = flip trans
+
+  asymmetric : Asymmetric ∼ → Asymmetric (flip ∼)
+  asymmetric asym = asym
+
+  total : Total ∼ → Total (flip ∼)
+  total total x y = total y x
+
+  respects : ∀ (P : A → Set p) → Symmetric ∼ →
+             P Respects ∼ → P Respects flip ∼
+  respects _ sym resp ∼ = resp (sym ∼)
+
+  max : ∀ {⊥} → Minimum ∼ ⊥ → Maximum (flip ∼) ⊥
+  max min = min
+
+  min : ∀ {⊤} → Maximum ∼ ⊤ → Minimum (flip ∼) ⊤
+  min max = max
+
+module _ (≈ : REL A B ℓ₁) (∼ : REL A B ℓ₂) where
+
+  implies : ≈ ⇒ ∼ → flip ≈ ⇒ flip ∼
+  implies impl = impl
+
+  irreflexive : Irreflexive ≈ ∼ → Irreflexive (flip ≈) (flip ∼)
+  irreflexive irrefl = irrefl
+
+module _ (≈ : Rel A ℓ₁) (∼ : Rel A ℓ₂) where
+
+  antisymmetric : Antisymmetric ≈ ∼ → Antisymmetric (flip ≈) (flip ∼)
+  antisymmetric antisym = antisym
+
+  trichotomous : Trichotomous ≈ ∼ → Trichotomous (flip ≈) (flip ∼)
+  trichotomous compare x y = compare y x
+
+module _ (∼₁ : Rel A ℓ₁) (∼₂ : Rel A ℓ₂) where
+
+  respects₂ : Symmetric ∼₂ → ∼₁ Respects₂ ∼₂ → flip ∼₁ Respects₂ flip ∼₂
+  respects₂ sym (resp₁ , resp₂) = (resp₂ ∘ sym , resp₁ ∘ sym)
+
+module _ (∼ : REL A B ℓ) where
+
+  decidable : Decidable ∼ → Decidable (flip ∼)
+  decidable dec x y = dec y x
+
+------------------------------------------------------------------------
+-- Structures
+
+isEquivalence : IsEquivalence ≈ → IsEquivalence (flip ≈)
+isEquivalence {≈ = ≈} eq = record
+  { refl  = reflexive  ≈ Eq.refl
+  ; sym   = symmetric  ≈ Eq.sym
+  ; trans = transitive ≈ Eq.trans
+  } where module Eq = IsEquivalence eq
+
+isDecEquivalence : IsDecEquivalence ≈ → IsDecEquivalence (flip ≈)
+isDecEquivalence {≈ = ≈} dec = record
+  { isEquivalence = isEquivalence Dec.isEquivalence
+  ; _≟_           = decidable ≈ Dec._≟_
+  } where module Dec = IsDecEquivalence dec
+
+isPreorder : IsPreorder ≈ ∼ → IsPreorder (flip ≈) (flip ∼)
+isPreorder {≈ = ≈} {∼ = ∼} O = record
+  { isEquivalence = isEquivalence O.isEquivalence
+  ; reflexive     = implies ≈ ∼ O.reflexive
+  ; trans         = transitive ∼ O.trans
+  } where module O = IsPreorder O
+
+isPartialOrder : IsPartialOrder ≈ ≤ → IsPartialOrder (flip ≈) (flip ≤)
+isPartialOrder {≈ = ≈} {≤ = ≤} O = record
+  { isPreorder = isPreorder O.isPreorder
+  ; antisym    = antisymmetric ≈ ≤ O.antisym
+  } where module O = IsPartialOrder O
+
+isTotalOrder : IsTotalOrder ≈ ≤ → IsTotalOrder (flip ≈) (flip ≤)
+isTotalOrder {≈ = ≈} {≤ = ≤} O = record
+  { isPartialOrder = isPartialOrder O.isPartialOrder
+  ; total          = total ≤ O.total
+  }
+  where module O = IsTotalOrder O
+
+isDecTotalOrder : IsDecTotalOrder ≈ ≤ → IsDecTotalOrder (flip ≈) (flip ≤)
+isDecTotalOrder {≈ = ≈} {≤ = ≤} O = record
+  { isTotalOrder = isTotalOrder O.isTotalOrder
+  ; _≟_          = decidable ≈ O._≟_
+  ; _≤?_         = decidable ≤ O._≤?_
+  } where module O = IsDecTotalOrder O
+
+isStrictPartialOrder : IsStrictPartialOrder ≈ < →
+                       IsStrictPartialOrder (flip ≈) (flip <)
+isStrictPartialOrder {≈ = ≈} {< = <} O = record
+  { isEquivalence = isEquivalence O.isEquivalence
+  ; irrefl        = irreflexive ≈ < O.irrefl
+  ; trans         = transitive < O.trans
+  ; <-resp-≈      = respects₂ < ≈ O.Eq.sym O.<-resp-≈
+  } where module O = IsStrictPartialOrder O
+
+isStrictTotalOrder : IsStrictTotalOrder ≈ < →
+                     IsStrictTotalOrder (flip ≈) (flip <)
+isStrictTotalOrder {≈ = ≈} {< = <} O = record
+  { isStrictPartialOrder = isStrictPartialOrder O.isStrictPartialOrder
+  ; compare              = trichotomous ≈ < O.compare
+  } where module O = IsStrictTotalOrder O
+
+------------------------------------------------------------------------
+-- Bundles
+
+setoid : Setoid a ℓ → Setoid a ℓ
+setoid S = record
+  { _≈_           = flip S._≈_
+  ; isEquivalence = isEquivalence S.isEquivalence
+  } where module S = Setoid S
+
+decSetoid : DecSetoid a ℓ → DecSetoid a ℓ
+decSetoid S = record
+  { _≈_              = flip S._≈_
+  ; isDecEquivalence = isDecEquivalence S.isDecEquivalence
+  } where module S = DecSetoid S
+
+preorder : Preorder a ℓ₁ ℓ₂ → Preorder a ℓ₁ ℓ₂
+preorder O = record
+  { isPreorder = isPreorder O.isPreorder
+  } where module O = Preorder O
+
+poset : Poset a ℓ₁ ℓ₂ → Poset a ℓ₁ ℓ₂
+poset O = record
+  { isPartialOrder = isPartialOrder O.isPartialOrder
+  } where module O = Poset O
+
+totalOrder : TotalOrder a ℓ₁ ℓ₂ → TotalOrder a ℓ₁ ℓ₂
+totalOrder O = record
+  { isTotalOrder = isTotalOrder O.isTotalOrder
+  } where module O = TotalOrder O
+
+decTotalOrder : DecTotalOrder a ℓ₁ ℓ₂ → DecTotalOrder a ℓ₁ ℓ₂
+decTotalOrder O = record
+  { isDecTotalOrder = isDecTotalOrder O.isDecTotalOrder
+  } where module O = DecTotalOrder O
+
+strictPartialOrder : StrictPartialOrder a ℓ₁ ℓ₂ →
+                     StrictPartialOrder a ℓ₁ ℓ₂
+strictPartialOrder O = record
+  { isStrictPartialOrder = isStrictPartialOrder O.isStrictPartialOrder
+  } where module O = StrictPartialOrder O
+
+strictTotalOrder : StrictTotalOrder a ℓ₁ ℓ₂ →
+                   StrictTotalOrder a ℓ₁ ℓ₂
+strictTotalOrder O = record
+  { isStrictTotalOrder = isStrictTotalOrder O.isStrictTotalOrder
+  } where module O = StrictTotalOrder O
diff --git a/src/Relation/Binary/Construct/FromPred.agda b/src/Relation/Binary/Construct/FromPred.agda
index c95f95fb6f..eb39112719 100644
--- a/src/Relation/Binary/Construct/FromPred.agda
+++ b/src/Relation/Binary/Construct/FromPred.agda
@@ -7,7 +7,10 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles using (Setoid; Preorder)
+open import Relation.Binary.Structures using (IsPreorder)
+open import Relation.Binary.Definitions using (_Respects_; Reflexive; Transitive)
 open import Relation.Unary using (Pred)
 
 module Relation.Binary.Construct.FromPred
@@ -16,7 +19,6 @@ module Relation.Binary.Construct.FromPred
   where
 
 open import Function.Base
-open import Data.Product
 
 open module Eq = Setoid S using (_≈_) renaming (Carrier to A)
 
diff --git a/src/Relation/Binary/Construct/FromRel.agda b/src/Relation/Binary/Construct/FromRel.agda
index fb842b7810..3cac113912 100644
--- a/src/Relation/Binary/Construct/FromRel.agda
+++ b/src/Relation/Binary/Construct/FromRel.agda
@@ -7,7 +7,10 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (REL; Rel; _⇒_)
+open import Relation.Binary.Bundles using (Setoid; Preorder)
+open import Relation.Binary.Structures using (IsPreorder)
+open import Relation.Binary.Definitions using (_Respects_; Transitive)
 open Setoid using (Carrier)
 
 module Relation.Binary.Construct.FromRel
@@ -15,7 +18,6 @@ module Relation.Binary.Construct.FromRel
   {a r} {A : Set a} (_R_ : REL A (Carrier S) r) -- The relation
   where
 
-open import Data.Product
 open import Function.Base
 open import Level using (_⊔_)
 
diff --git a/src/Relation/Binary/Construct/Interior/Symmetric.agda b/src/Relation/Binary/Construct/Interior/Symmetric.agda
new file mode 100644
index 0000000000..a954dc99ec
--- /dev/null
+++ b/src/Relation/Binary/Construct/Interior/Symmetric.agda
@@ -0,0 +1,83 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Symmetric interior of a binary relation
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Relation.Binary.Construct.Interior.Symmetric where
+
+open import Function.Base using (flip)
+open import Level
+open import Relation.Binary
+
+private
+  variable
+    a b c ℓ r s t : Level
+    A : Set a
+    R S T : Rel A r
+
+------------------------------------------------------------------------
+-- Definition
+
+record SymInterior (R : Rel A ℓ) (x y : A) : Set ℓ where
+  constructor _,_
+  field
+    lhs≤rhs : R x y
+    rhs≤lhs : R y x
+
+open SymInterior public
+
+------------------------------------------------------------------------
+-- Properties
+
+-- The symmetric interior is symmetric.
+symmetric : Symmetric (SymInterior R)
+symmetric (r , r′) = r′ , r
+
+-- The symmetric interior of R is greater than (or equal to) any other symmetric
+-- relation contained by R.
+unfold : Symmetric S → S ⇒ R → S ⇒ SymInterior R
+unfold sym f s = f s , f (sym s)
+
+-- SymInterior preserves various properties.
+reflexive : Reflexive R → Reflexive (SymInterior R)
+reflexive refl = refl , refl
+
+trans : Trans R S T → Trans S R T →
+  Trans (SymInterior R) (SymInterior S) (SymInterior T)
+trans trans-rs trans-sr (r , r′) (s , s′) = trans-rs r s , trans-sr s′ r′
+
+transitive : Transitive R → Transitive (SymInterior R)
+transitive tr = trans tr tr
+
+-- The symmetric interior of a strict relation is empty.
+asymmetric⇒empty : Asymmetric R → Empty (SymInterior R)
+asymmetric⇒empty asym (r , r′) = asym r r′
+
+-- A reflexive transitive relation _≤_ gives rise to a poset in which the
+-- equivalence relation is SymInterior _≤_.
+
+isEquivalence : Reflexive R → Transitive R → IsEquivalence (SymInterior R)
+isEquivalence refl trans = record
+  { refl = reflexive refl
+  ; sym = symmetric
+  ; trans = transitive trans
+  }
+
+isPartialOrder : Reflexive R → Transitive R → IsPartialOrder (SymInterior R) R
+isPartialOrder refl trans = record
+  { isPreorder = record
+    { isEquivalence = isEquivalence refl trans
+    ; reflexive = lhs≤rhs
+    ; trans = trans
+    }
+  ; antisym = _,_
+  }
+
+poset : ∀ {a} {A : Set a} {R : Rel A ℓ} → Reflexive R → Transitive R → Poset a ℓ ℓ
+poset {R = R} refl trans = record
+  { _≤_ = R
+  ; isPartialOrder = isPartialOrder refl trans
+  }
diff --git a/src/Relation/Binary/Construct/Intersection.agda b/src/Relation/Binary/Construct/Intersection.agda
index f74dfb3de9..0d26d675e6 100644
--- a/src/Relation/Binary/Construct/Intersection.agda
+++ b/src/Relation/Binary/Construct/Intersection.agda
@@ -12,7 +12,11 @@ open import Data.Product.Base
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂; [_,_])
 open import Function.Base using (_∘_)
 open import Level using (Level; _⊔_)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; REL; _⇒_)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence; IsPreorder; IsPartialOrder; IsStrictPartialOrder)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Antisymmetric; Decidable; _Respects_; _Respectsˡ_; _Respectsʳ_; _Respects₂_; Minimum; Maximum; Irreflexive)
 open import Relation.Nullary.Decidable using (yes; no; _×-dec_)
 
 private
@@ -24,6 +28,8 @@ private
 ------------------------------------------------------------------------
 -- Definition
 
+infixl 6 _∩_
+
 _∩_ : REL A B ℓ₁ → REL A B ℓ₂ → REL A B (ℓ₁ ⊔ ℓ₂)
 L ∩ R = λ i j → L i j × R i j
 
diff --git a/src/Relation/Binary/Construct/NaturalOrder/Left.agda b/src/Relation/Binary/Construct/NaturalOrder/Left.agda
index db1d0f5aff..cd8864af6e 100644
--- a/src/Relation/Binary/Construct/NaturalOrder/Left.agda
+++ b/src/Relation/Binary/Construct/NaturalOrder/Left.agda
@@ -8,11 +8,17 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra.Core
-open import Data.Product using (_,_; _×_)
-open import Data.Sum.Base using (inj₁; inj₂)
-open import Relation.Binary
+open import Data.Product.Base using (_,_; _×_)
+open import Data.Sum.Base using (inj₁; inj₂; map)
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (Preorder; Poset; DecPoset; TotalOrder; DecTotalOrder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsPreorder; IsPartialOrder; IsDecPartialOrder; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Symmetric; Transitive; Reflexive; Antisymmetric; Total; _Respectsʳ_; _Respectsˡ_; _Respects₂_; Decidable)
 open import Relation.Nullary.Negation using (¬_)
-import Relation.Binary.Reasoning.Setoid as EqReasoning
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 open import Relation.Binary.Lattice using (Infimum)
 
 module Relation.Binary.Construct.NaturalOrder.Left
@@ -38,7 +44,7 @@ reflexive magma idem {x} {y} x≈y = begin
   x     ≈⟨ sym (idem x) ⟩
   x ∙ x ≈⟨ ∙-cong refl x≈y ⟩
   x ∙ y ∎
-  where open IsMagma magma; open EqReasoning setoid
+  where open IsMagma magma; open ≈-Reasoning setoid
 
 refl : Symmetric _≈_ → Idempotent _∙_ → Reflexive _≤_
 refl sym idem {x} = sym (idem x)
@@ -49,12 +55,10 @@ antisym isEq comm {x} {y} x≤y y≤x = begin
   x ∙ y ≈⟨ comm x y ⟩
   y ∙ x ≈⟨ sym y≤x ⟩
   y     ∎
-  where open IsEquivalence isEq; open EqReasoning (record { isEquivalence = isEq })
+  where open IsEquivalence isEq; open ≈-Reasoning (record { isEquivalence = isEq })
 
 total : Symmetric _≈_ → Transitive _≈_ → Selective _∙_ → Commutative _∙_ → Total _≤_
-total sym trans sel comm x y with sel x y
-... | inj₁ x∙y≈x = inj₁ (sym x∙y≈x)
-... | inj₂ x∙y≈y = inj₂ (sym (trans (comm y x) x∙y≈y))
+total sym trans sel comm x y = map sym (λ x∙y≈y → trans (sym x∙y≈y) (comm x y)) (sel x y)
 
 trans : IsSemigroup _∙_ → Transitive _≤_
 trans semi {x} {y} {z} x≤y y≤z = begin
@@ -63,14 +67,14 @@ trans semi {x} {y} {z} x≤y y≤z = begin
   x ∙ (y ∙ z) ≈⟨ sym (assoc x y z) ⟩
   (x ∙ y) ∙ z ≈⟨ ∙-cong (sym x≤y) S.refl ⟩
   x ∙ z       ∎
-  where open module S = IsSemigroup semi; open EqReasoning S.setoid
+  where open module S = IsSemigroup semi; open ≈-Reasoning S.setoid
 
 respʳ : IsMagma _∙_ → _≤_ Respectsʳ _≈_
 respʳ magma {x} {y} {z} y≈z x≤y = begin
   x     ≈⟨ x≤y ⟩
   x ∙ y ≈⟨ ∙-cong M.refl y≈z ⟩
   x ∙ z ∎
-  where open module M = IsMagma magma; open EqReasoning M.setoid
+  where open module M = IsMagma magma; open ≈-Reasoning M.setoid
 
 respˡ : IsMagma _∙_ → _≤_ Respectsˡ _≈_
 respˡ magma {x} {y} {z} y≈z y≤x = begin
@@ -78,7 +82,7 @@ respˡ magma {x} {y} {z} y≈z y≤x = begin
   y     ≈⟨ y≤x ⟩
   y ∙ x ≈⟨ ∙-cong y≈z M.refl ⟩
   z ∙ x ∎
-  where open module M = IsMagma magma; open EqReasoning M.setoid
+  where open module M = IsMagma magma; open ≈-Reasoning M.setoid
 
 resp₂ : IsMagma _∙_ →  _≤_ Respects₂ _≈_
 resp₂ magma = respʳ magma , respˡ magma
@@ -89,25 +93,25 @@ dec _≟_ x y = x ≟ (x ∙ y)
 module _ (semi : IsSemilattice _∙_) where
 
   private open module S = IsSemilattice semi
-  open EqReasoning setoid
+  open ≈-Reasoning setoid
 
   x∙y≤x : ∀ x y → (x ∙ y) ≤ x
   x∙y≤x x y = begin
-    x ∙ y       ≈⟨ ∧-cong (sym (idem x)) S.refl ⟩
+    x ∙ y       ≈⟨ ∙-cong (sym (idem x)) S.refl ⟩
     (x ∙ x) ∙ y ≈⟨ assoc x x y ⟩
     x ∙ (x ∙ y) ≈⟨ comm x (x ∙ y) ⟩
     (x ∙ y) ∙ x ∎
 
   x∙y≤y : ∀ x y → (x ∙ y) ≤ y
   x∙y≤y x y = begin
-    x ∙ y        ≈⟨ ∧-cong S.refl (sym (idem y)) ⟩
+    x ∙ y        ≈⟨ ∙-cong S.refl (sym (idem y)) ⟩
     x ∙ (y ∙ y)  ≈⟨ sym (assoc x y y) ⟩
     (x ∙ y) ∙ y  ∎
 
   ∙-presʳ-≤ : ∀ {x y} z → z ≤ x → z ≤ y → z ≤ (x ∙ y)
   ∙-presʳ-≤ {x} {y} z z≤x z≤y = begin
     z            ≈⟨ z≤y ⟩
-    z ∙ y        ≈⟨ ∧-cong z≤x S.refl ⟩
+    z ∙ y        ≈⟨ ∙-cong z≤x S.refl ⟩
     (z ∙ x) ∙ y  ≈⟨ assoc z x y ⟩
     z ∙ (x ∙ y)  ∎
 
diff --git a/src/Relation/Binary/Construct/NaturalOrder/Right.agda b/src/Relation/Binary/Construct/NaturalOrder/Right.agda
index 7c4a6ab119..024b946cc8 100644
--- a/src/Relation/Binary/Construct/NaturalOrder/Right.agda
+++ b/src/Relation/Binary/Construct/NaturalOrder/Right.agda
@@ -8,11 +8,18 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Algebra.Core using (Op₂)
-open import Data.Product using (_,_; _×_)
-open import Data.Sum.Base using (inj₁; inj₂)
-open import Relation.Binary
+open import Data.Product.Base using (_,_; _×_)
+open import Data.Sum.Base using (inj₁; inj₂; map)
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (Preorder; Poset; DecPoset; TotalOrder; DecTotalOrder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsPreorder; IsPartialOrder; IsDecPartialOrder; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Symmetric; Transitive; Reflexive; Antisymmetric; Total; _Respectsʳ_; _Respectsˡ_; _Respects₂_; Decidable)
+
 open import Relation.Nullary.Negation using (¬_)
-import Relation.Binary.Reasoning.Setoid as EqReasoning
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 module Relation.Binary.Construct.NaturalOrder.Right
   {a ℓ} {A : Set a} (_≈_ : Rel A ℓ) (_∙_ : Op₂ A) where
@@ -37,7 +44,7 @@ reflexive magma idem {x} {y} x≈y = begin
   x     ≈⟨ sym (idem x) ⟩
   x ∙ x ≈⟨ ∙-cong x≈y refl ⟩
   y ∙ x ∎
-  where open IsMagma magma; open EqReasoning setoid
+  where open IsMagma magma; open ≈-Reasoning setoid
 
 refl : Symmetric _≈_ → Idempotent _∙_ → Reflexive _≤_
 refl sym idem {x} = sym (idem x)
@@ -46,14 +53,13 @@ antisym : IsEquivalence _≈_ → Commutative _∙_ → Antisymmetric _≈_ _≤
 antisym isEq comm {x} {y} x≤y y≤x = begin
   x     ≈⟨  x≤y ⟩
   y ∙ x ≈⟨  comm y x ⟩
-  x ∙ y ≈˘⟨ y≤x ⟩
+  x ∙ y ≈⟨ y≤x ⟨
   y     ∎
-  where open EqReasoning (record { isEquivalence = isEq })
+  where open ≈-Reasoning (record { isEquivalence = isEq })
 
 total : Symmetric _≈_ → Transitive _≈_ → Selective _∙_ → Commutative _∙_ → Total _≤_
-total sym trans sel comm x y with sel x y
-... | inj₁ x∙y≈x = inj₁ (trans (sym x∙y≈x) (comm x y) )
-... | inj₂ x∙y≈y = inj₂ (sym x∙y≈y)
+total sym trans sel comm x y =
+  map (λ x∙y≈x → trans (sym x∙y≈x) (comm x y)) sym (sel x y)
 
 trans : IsSemigroup _∙_ → Transitive _≤_
 trans semi {x} {y} {z} x≤y y≤z = begin
@@ -62,14 +68,14 @@ trans semi {x} {y} {z} x≤y y≤z = begin
   (z ∙ y) ∙ x ≈⟨ assoc z y x ⟩
   z ∙ (y ∙ x) ≈⟨ ∙-cong S.refl (sym x≤y) ⟩
   z ∙ x       ∎
-  where open module S = IsSemigroup semi; open EqReasoning S.setoid
+  where open module S = IsSemigroup semi; open ≈-Reasoning S.setoid
 
 respʳ : IsMagma _∙_ → _≤_ Respectsʳ _≈_
 respʳ magma {x} {y} {z} y≈z x≤y = begin
   x     ≈⟨ x≤y ⟩
   y ∙ x ≈⟨ ∙-cong y≈z M.refl ⟩
   z ∙ x ∎
-  where open module M = IsMagma magma; open EqReasoning M.setoid
+  where open module M = IsMagma magma; open ≈-Reasoning M.setoid
 
 respˡ : IsMagma _∙_ → _≤_ Respectsˡ _≈_
 respˡ magma {x} {y} {z} y≈z y≤x = begin
@@ -77,7 +83,7 @@ respˡ magma {x} {y} {z} y≈z y≤x = begin
   y     ≈⟨ y≤x ⟩
   x ∙ y ≈⟨ ∙-cong M.refl y≈z ⟩
   x ∙ z ∎
-  where open module M = IsMagma magma; open EqReasoning M.setoid
+  where open module M = IsMagma magma; open ≈-Reasoning M.setoid
 
 resp₂ : IsMagma _∙_ →  _≤_ Respects₂ _≈_
 resp₂ magma = respʳ magma , respˡ magma
diff --git a/src/Relation/Binary/Construct/NonStrictToStrict.agda b/src/Relation/Binary/Construct/NonStrictToStrict.agda
index d9dd2c57ce..f0402d7fb9 100644
--- a/src/Relation/Binary/Construct/NonStrictToStrict.agda
+++ b/src/Relation/Binary/Construct/NonStrictToStrict.agda
@@ -6,7 +6,11 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Structures
+  using (IsPartialOrder; IsEquivalence; IsStrictPartialOrder; IsDecPartialOrder; IsDecStrictPartialOrder; IsTotalOrder; IsStrictTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Trichotomous; Antisymmetric; Symmetric; Total; Decidable; Irreflexive; Transitive; _Respectsʳ_; _Respectsˡ_; _Respects₂_; Trans; Asymmetric; tri≈; tri<; tri>)
 
 module Relation.Binary.Construct.NonStrictToStrict
   {a ℓ₁ ℓ₂} {A : Set a} (_≈_ : Rel A ℓ₁) (_≤_ : Rel A ℓ₂) where
@@ -134,9 +138,8 @@ x < y = x ≤ y × x ≉ y
 <-isStrictTotalOrder₁ : Decidable _≈_ → IsTotalOrder _≈_ _≤_ →
                         IsStrictTotalOrder _≈_ _<_
 <-isStrictTotalOrder₁ ≟ tot = record
-  { isEquivalence = isEquivalence
-  ; trans         = <-trans isPartialOrder
-  ; compare       = <-trichotomous Eq.sym ≟ antisym total
+  { isStrictPartialOrder = <-isStrictPartialOrder isPartialOrder
+  ; compare              = <-trichotomous Eq.sym ≟ antisym total
   } where open IsTotalOrder tot
 
 <-isStrictTotalOrder₂ : IsDecTotalOrder _≈_ _≤_ →
diff --git a/src/Relation/Binary/Construct/On.agda b/src/Relation/Binary/Construct/On.agda
index 5206276f95..5544edbf4a 100644
--- a/src/Relation/Binary/Construct/On.agda
+++ b/src/Relation/Binary/Construct/On.agda
@@ -8,11 +8,17 @@
 
 module Relation.Binary.Construct.On where
 
-open import Data.Product
+open import Data.Product.Base using (_,_)
 open import Function.Base using (_on_; _∘_)
 open import Induction.WellFounded using (WellFounded; Acc; acc)
 open import Level using (Level)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Bundles
+  using (Preorder; Setoid; DecSetoid; Poset; DecPoset; StrictPartialOrder; TotalOrder; DecTotalOrder; StrictTotalOrder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence; IsPreorder; IsPartialOrder; IsDecPartialOrder; IsStrictPartialOrder; IsTotalOrder; IsDecTotalOrder; IsStrictTotalOrder)
+open import Relation.Binary.Definitions
+  using (Reflexive; Irreflexive; Symmetric; Transitive; Antisymmetric; Asymmetric; Decidable; Total; Trichotomous; _Respects_; _Respects₂_)
 
 private
   variable
@@ -68,7 +74,7 @@ module _ (f : B → A) where
   trichotomous _ _ compare x y = compare (f x) (f y)
 
   accessible : ∀ {∼ : Rel A ℓ} {x} → Acc ∼ (f x) → Acc (∼ on f) x
-  accessible (acc rs) = acc (λ y fy<fx → accessible (rs (f y) fy<fx))
+  accessible (acc rs) = acc (λ fy<fx → accessible (rs fy<fx))
 
   wellFounded : {∼ : Rel A ℓ} → WellFounded ∼ → WellFounded (∼ on f)
   wellFounded wf x = accessible (wf (f x))
@@ -144,9 +150,8 @@ module _ (f : B → A) {≈ : Rel A ℓ₁} {∼ : Rel A ℓ₂} where
   isStrictTotalOrder : IsStrictTotalOrder ≈ ∼ →
                        IsStrictTotalOrder (≈ on f) (∼ on f)
   isStrictTotalOrder sto = record
-    { isEquivalence = isEquivalence f Sto.isEquivalence
-    ; trans         = transitive f ∼ Sto.trans
-    ; compare       = trichotomous f ≈ ∼ Sto.compare
+    { isStrictPartialOrder = isStrictPartialOrder Sto.isStrictPartialOrder
+    ; compare              = trichotomous _ _ _ Sto.compare
     } where module Sto = IsStrictTotalOrder sto
 
 ------------------------------------------------------------------------
diff --git a/src/Relation/Binary/Construct/StrictToNonStrict.agda b/src/Relation/Binary/Construct/StrictToNonStrict.agda
index 42c76fc80f..d17b6017fc 100644
--- a/src/Relation/Binary/Construct/StrictToNonStrict.agda
+++ b/src/Relation/Binary/Construct/StrictToNonStrict.agda
@@ -10,7 +10,11 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsPreorder; IsStrictPartialOrder; IsPartialOrder; IsStrictTotalOrder; IsTotalOrder; IsDecTotalOrder)
+open import Relation.Binary.Definitions
+  using (Transitive; Symmetric; Irreflexive; Antisymmetric; Trichotomous; Decidable; Trans; Total; _Respects₂_; _Respectsʳ_; _Respectsˡ_; tri<; tri≈; tri>)
 
 module Relation.Binary.Construct.StrictToNonStrict
   {a ℓ₁ ℓ₂} {A : Set a}
diff --git a/src/Relation/Binary/Construct/Subst/Equality.agda b/src/Relation/Binary/Construct/Subst/Equality.agda
index 4e0a3d0100..8cde3b1a66 100644
--- a/src/Relation/Binary/Construct/Subst/Equality.agda
+++ b/src/Relation/Binary/Construct/Subst/Equality.agda
@@ -9,8 +9,10 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Product as Prod
-open import Relation.Binary
+open import Data.Product.Base using (_,_)
+open import Relation.Binary.Core using (Rel; _⇔_)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions using (Reflexive; Symmetric; Transitive)
 
 module Relation.Binary.Construct.Subst.Equality
   {a ℓ₁ ℓ₂} {A : Set a} {≈₁ : Rel A ℓ₁} {≈₂ : Rel A ℓ₂}
diff --git a/src/Relation/Binary/Construct/Union.agda b/src/Relation/Binary/Construct/Union.agda
index 3abd3ffe42..45f72c8190 100644
--- a/src/Relation/Binary/Construct/Union.agda
+++ b/src/Relation/Binary/Construct/Union.agda
@@ -12,7 +12,9 @@ open import Data.Product.Base
 open import Data.Sum.Base as Sum
 open import Function.Base using (_∘_)
 open import Level using (Level; _⊔_)
-open import Relation.Binary
+open import Relation.Binary.Core using (REL; Rel; _⇒_)
+open import Relation.Binary.Definitions
+  using (Reflexive; Total; Minimum; Maximum; Symmetric; Irreflexive; Decidable; _Respects_; _Respectsˡ_; _Respectsʳ_; _Respects₂_)
 open import Relation.Nullary.Decidable using (yes; no; _⊎-dec_)
 
 private
@@ -24,6 +26,8 @@ private
 ------------------------------------------------------------------------
 -- Definition
 
+infixr 6 _∪_
+
 _∪_ : REL A B ℓ₁ → REL A B ℓ₂ → REL A B (ℓ₁ ⊔ ℓ₂)
 L ∪ R = λ i j → L i j ⊎ R i j
 
diff --git a/src/Relation/Binary/Core.agda b/src/Relation/Binary/Core.agda
index d9c19173a1..079bf296cc 100644
--- a/src/Relation/Binary/Core.agda
+++ b/src/Relation/Binary/Core.agda
@@ -10,7 +10,7 @@
 
 module Relation.Binary.Core where
 
-open import Data.Product using (_×_)
+open import Data.Product.Base using (_×_)
 open import Function.Base using (_on_)
 open import Level using (Level; _⊔_; suc)
 
diff --git a/src/Relation/Binary/Definitions.agda b/src/Relation/Binary/Definitions.agda
index a44f2d058e..167b63a8cb 100644
--- a/src/Relation/Binary/Definitions.agda
+++ b/src/Relation/Binary/Definitions.agda
@@ -12,14 +12,12 @@ module Relation.Binary.Definitions where
 
 open import Agda.Builtin.Equality using (_≡_)
 
-open import Data.Maybe.Base using (Maybe)
-open import Data.Product using (_×_)
+open import Data.Product.Base using (_×_; ∃-syntax)
 open import Data.Sum.Base using (_⊎_)
 open import Function.Base using (_on_; flip)
 open import Level
 open import Relation.Binary.Core
-open import Relation.Nullary.Decidable.Core using (Dec)
-open import Relation.Nullary.Negation.Core using (¬_)
+open import Relation.Nullary as Nullary using (¬_; Dec)
 
 private
   variable
@@ -58,6 +56,12 @@ Symmetric _∼_ = Sym _∼_ _∼_
 Trans : REL A B ℓ₁ → REL B C ℓ₂ → REL A C ℓ₃ → Set _
 Trans P Q R = ∀ {i j k} → P i j → Q j k → R i k
 
+RightTrans : REL A B ℓ₁ → REL B B ℓ₂ → Set _
+RightTrans R S = Trans R S R
+
+LeftTrans : REL A A ℓ₁ → REL A B ℓ₂ → Set _
+LeftTrans S R = Trans S R R
+
 -- A flipped variant of generalised transitivity.
 
 TransFlip : REL A B ℓ₁ → REL B C ℓ₂ → REL A C ℓ₃ → Set _
@@ -88,7 +92,12 @@ Irreflexive _≈_ _<_ = ∀ {x y} → x ≈ y → ¬ (x < y)
 Asymmetric : Rel A ℓ → Set _
 Asymmetric _<_ = ∀ {x y} → x < y → ¬ (y < x)
 
--- Generalised connex - exactly one of the two relations holds.
+-- Density
+
+Dense : Rel A ℓ → Set _
+Dense _<_ = ∀ {x y} → x < y → ∃[ z ] x < z × z < y
+
+-- Generalised connex - at least one of the two relations holds.
 
 Connex : REL A B ℓ₁ → REL B A ℓ₂ → Set _
 Connex P Q = ∀ x y → P x y ⊎ Q y x
@@ -195,40 +204,50 @@ P Respects₂ _∼_ = (P Respectsʳ _∼_) × (P Respectsˡ _∼_)
 Substitutive : Rel A ℓ₁ → (ℓ₂ : Level) → Set _
 Substitutive {A = A} _∼_ p = (P : A → Set p) → P Respects _∼_
 
--- Decidability - it is possible to determine whether a given pair of
--- elements are related.
+-- Irrelevancy - all proofs that a given pair of elements are related
+-- are indistinguishable.
 
-Decidable : REL A B ℓ → Set _
-Decidable _∼_ = ∀ x y → Dec (x ∼ y)
+Irrelevant : REL A B ℓ → Set _
+Irrelevant _∼_ = ∀ {x y} → Nullary.Irrelevant (x ∼ y)
+
+-- Recomputability - we can rebuild a relevant proof given an
+-- irrelevant one.
+
+Recomputable : REL A B ℓ → Set _
+Recomputable _∼_ = ∀ {x y} → Nullary.Recomputable (x ∼ y)
+
+-- Stability
+
+Stable : REL A B ℓ → Set _
+Stable _∼_ = ∀ x y → Nullary.Stable (x ∼ y)
 
 -- Weak decidability - it is sometimes possible to determine if a given
 -- pair of elements are related.
 
 WeaklyDecidable : REL A B ℓ → Set _
-WeaklyDecidable _∼_ = ∀ x y → Maybe (x ∼ y)
+WeaklyDecidable _∼_ = ∀ x y → Nullary.WeaklyDecidable (x ∼ y)
+
+-- Decidability - it is possible to determine whether a given pair of
+-- elements are related.
+
+Decidable : REL A B ℓ → Set _
+Decidable _∼_ = ∀ x y → Dec (x ∼ y)
 
 -- Propositional equality is decidable for the type.
 
 DecidableEquality : (A : Set a) → Set _
 DecidableEquality A = Decidable {A = A} _≡_
 
--- Irrelevancy - all proofs that a given pair of elements are related
--- are indistinguishable.
-
-Irrelevant : REL A B ℓ → Set _
-Irrelevant _∼_ = ∀ {x y} (a b : x ∼ y) → a ≡ b
-
--- Recomputability - we can rebuild a relevant proof given an
--- irrelevant one.
-
-Recomputable : REL A B ℓ → Set _
-Recomputable _∼_ = ∀ {x y} → .(x ∼ y) → x ∼ y
-
 -- Universal - all pairs of elements are related
 
 Universal : REL A B ℓ → Set _
 Universal _∼_ = ∀ x y → x ∼ y
 
+-- Empty - no elements are related
+
+Empty : REL A B ℓ → Set _
+Empty _∼_ = ∀ {x y} → ¬ (x ∼ y)
+
 -- Non-emptiness - at least one pair of elements are related.
 
 record NonEmpty {A : Set a} {B : Set b}
diff --git a/src/Relation/Binary/HeterogeneousEquality.agda b/src/Relation/Binary/HeterogeneousEquality.agda
index 0a4886531e..41d6b709a6 100644
--- a/src/Relation/Binary/HeterogeneousEquality.agda
+++ b/src/Relation/Binary/HeterogeneousEquality.agda
@@ -9,21 +9,26 @@
 module Relation.Binary.HeterogeneousEquality where
 
 import Axiom.Extensionality.Heterogeneous as Ext
-open import Data.Product
 open import Data.Unit.NonEta
+open import Data.Product.Base using (_,_)
 open import Function.Base
-open import Function.Inverse using (Inverse)
+open import Function.Bundles using (Inverse)
 open import Level
 open import Relation.Nullary hiding (Irrelevant)
 open import Relation.Unary using (Pred)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; REL; _⇒_)
+open import Relation.Binary.Bundles using (Setoid; DecSetoid; Preorder)
+open import Relation.Binary.Structures using (IsEquivalence; IsPreorder)
+open import Relation.Binary.Definitions using (Substitutive; Irrelevant; Decidable; _Respects₂_; Trans; Reflexive)
 open import Relation.Binary.Consequences
 open import Relation.Binary.Indexed.Heterogeneous
   using (IndexedSetoid)
 open import Relation.Binary.Indexed.Heterogeneous.Construct.At
   using (_atₛ_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_; refl)
+open import Relation.Binary.Reasoning.Syntax
 
+import Relation.Binary.PropositionalEquality.Properties as ≡
 import Relation.Binary.HeterogeneousEquality.Core as Core
 
 private
@@ -54,7 +59,7 @@ open Core public using (≅-to-≡; ≡-to-≅)
 ≅-to-type-≡ refl = refl
 
 ≅-to-subst-≡ : ∀ {A B : Set a} {x : A} {y : B} → (p : x ≅ y) →
-               P.subst (λ x → x) (≅-to-type-≡ p) x ≡ y
+               ≡.subst (λ x → x) (≅-to-type-≡ p) x ≡ y
 ≅-to-subst-≡ refl = refl
 
 ------------------------------------------------------------------------
@@ -84,7 +89,7 @@ subst₂-removable : ∀ (_∼_ : REL A B r) {x y u v} (eq₁ : x ≅ y) (eq₂
 subst₂-removable _∼_ refl refl z = refl
 
 ≡-subst-removable : ∀ (P : Pred A p) {x y} (eq : x ≡ y) (z : P x) →
-                    P.subst P eq z ≅ z
+                    ≡.subst P eq z ≅ z
 ≡-subst-removable P refl z = refl
 
 cong : ∀ {A : Set a} {B : A → Set b} {x y}
@@ -128,7 +133,7 @@ module _ {I : Set ℓ} (A : I → Set a) {B : {k : I} → A k → Set b} where
   icong-≡-subst-removable : {i j : I} (eq : i ≡ j)
                             (f : {k : I} → (z : A k) → B z)
                             (x : A i) →
-                            f (P.subst A eq x) ≅ f x
+                            f (≡.subst A eq x) ≅ f x
   icong-≡-subst-removable refl _ _ = refl
 
 ------------------------------------------------------------------------
@@ -178,14 +183,13 @@ indexedSetoid B = record
   }
 
 ≡↔≅ : ∀ {A : Set a} (B : A → Set b) {x : A} →
-      Inverse (P.setoid (B x)) ((indexedSetoid B) atₛ x)
+      Inverse (≡.setoid (B x)) ((indexedSetoid B) atₛ x)
 ≡↔≅ B = record
-  { to         = record { _⟨$⟩_ = id; cong = ≡-to-≅ }
-  ; from       = record { _⟨$⟩_ = id; cong = ≅-to-≡ }
-  ; inverse-of = record
-    { left-inverse-of  = λ _ → refl
-    ; right-inverse-of = λ _ → refl
-    }
+  { to         = id
+  ; to-cong    = ≡-to-≅
+  ; from       = id
+  ; from-cong  = ≅-to-≡
+  ; inverse    = (λ { ≡.refl → refl }) , λ { refl → ≡.refl }
   }
 
 decSetoid : Decidable {A = A} {B = A} (λ x y → x ≅ y) →
@@ -207,7 +211,7 @@ isPreorder = record
 
 isPreorder-≡ : IsPreorder {A = A} _≡_ (λ x y → x ≅ y)
 isPreorder-≡ = record
-  { isEquivalence = P.isEquivalence
+  { isEquivalence = ≡.isEquivalence
   ; reflexive     = reflexive
   ; trans         = trans
   }
@@ -216,7 +220,7 @@ preorder : Set ℓ → Preorder ℓ ℓ ℓ
 preorder A = record
   { Carrier    = A
   ; _≈_        = _≡_
-  ; _∼_        = λ x y → x ≅ y
+  ; _≲_        = λ x y → x ≅ y
   ; isPreorder = isPreorder-≡
   }
 
@@ -228,39 +232,46 @@ module ≅-Reasoning where
   -- The code in `Relation.Binary.Reasoning.Setoid` cannot handle
   -- heterogeneous equalities, hence the code duplication here.
 
-  infix  4 _IsRelatedTo_
-  infix  3 _∎
-  infixr 2 _≅⟨_⟩_ _≅˘⟨_⟩_ _≡⟨_⟩_ _≡˘⟨_⟩_ _≡⟨⟩_
-  infix  1 begin_
+  infix 4 _IsRelatedTo_
 
-  data _IsRelatedTo_ {A : Set ℓ} (x : A) {B : Set ℓ} (y : B) :
-                     Set ℓ where
+  data _IsRelatedTo_ {A : Set ℓ} {B : Set ℓ} (x : A) (y : B) : Set ℓ where
     relTo : (x≅y : x ≅ y) → x IsRelatedTo y
 
-  begin_ : ∀ {x : A} {y : B} → x IsRelatedTo y → x ≅ y
-  begin relTo x≅y = x≅y
+  start : ∀ {x : A} {y : B} → x IsRelatedTo y → x ≅ y
+  start (relTo x≅y) = x≅y
 
-  _≅⟨_⟩_ : ∀ (x : A) {y : B} {z : C} →
-           x ≅ y → y IsRelatedTo z → x IsRelatedTo z
-  _ ≅⟨ x≅y ⟩ relTo y≅z = relTo (trans x≅y y≅z)
+  ≡-go : ∀ {A : Set a} → Trans {A = A} {C = A} _≡_ _IsRelatedTo_ _IsRelatedTo_
+  ≡-go x≡y (relTo y≅z) = relTo (trans (reflexive x≡y) y≅z)
 
-  _≅˘⟨_⟩_ : ∀ (x : A) {y : B} {z : C} →
-            y ≅ x → y IsRelatedTo z → x IsRelatedTo z
-  _ ≅˘⟨ y≅x ⟩ relTo y≅z = relTo (trans (sym y≅x) y≅z)
+  -- Combinators with one heterogeneous relation
+  module _ {A : Set ℓ} {B : Set ℓ} where
+    open begin-syntax (_IsRelatedTo_ {A = A} {B}) start public
 
-  _≡⟨_⟩_ : ∀ (x : A) {y : A} {z : C} →
-           x ≡ y → y IsRelatedTo z → x IsRelatedTo z
-  _ ≡⟨ x≡y ⟩ relTo y≅z = relTo (trans (reflexive x≡y) y≅z)
+  -- Combinators with homogeneous relations
+  module _ {A : Set ℓ} where
+    open ≡-syntax (_IsRelatedTo_ {A = A}) ≡-go public
+    open end-syntax (_IsRelatedTo_ {A = A}) (relTo refl) public
 
-  _≡˘⟨_⟩_ : ∀ (x : A) {y : A} {z : C} →
-            y ≡ x → y IsRelatedTo z → x IsRelatedTo z
-  _ ≡˘⟨ y≡x ⟩ relTo y≅z = relTo (trans (sym (reflexive y≡x)) y≅z)
+  -- Can't create syntax in the standard `Syntax` module for
+  -- heterogeneous steps because it would force that module to use
+  -- the `--with-k` option.
+  infixr 2 _≅⟨_⟩_ _≅⟨_⟨_
 
-  _≡⟨⟩_ : ∀ (x : A) {y : B} → x IsRelatedTo y → x IsRelatedTo y
-  _ ≡⟨⟩ x≅y = x≅y
+  _≅⟨_⟩_ : ∀ (x : A) {y : B} {z : C} →
+           x ≅ y → y IsRelatedTo z → x IsRelatedTo z
+  _ ≅⟨ x≅y ⟩ relTo y≅z = relTo (trans x≅y y≅z)
 
-  _∎ : ∀ (x : A) → x IsRelatedTo x
-  _∎ _ = relTo refl
+  _≅⟨_⟨_ : ∀ (x : A) {y : B} {z : C} →
+            y ≅ x → y IsRelatedTo z → x IsRelatedTo z
+  _ ≅⟨ y≅x ⟨ relTo y≅z = relTo (trans (sym y≅x) y≅z)
+
+  -- Deprecated
+  infixr 2 _≅˘⟨_⟩_
+  _≅˘⟨_⟩_ = _≅⟨_⟨_
+  {-# WARNING_ON_USAGE _≅˘⟨_⟩_
+  "Warning: _≅˘⟨_⟩_ was deprecated in v2.0.
+  Please use _≅⟨_⟨_ instead."
+  #-}
 
 ------------------------------------------------------------------------
 -- Inspect
diff --git a/src/Relation/Binary/HeterogeneousEquality/Quotients.agda b/src/Relation/Binary/HeterogeneousEquality/Quotients.agda
index a429dafe8f..18bc88002a 100644
--- a/src/Relation/Binary/HeterogeneousEquality/Quotients.agda
+++ b/src/Relation/Binary/HeterogeneousEquality/Quotients.agda
@@ -8,9 +8,9 @@
 
 module Relation.Binary.HeterogeneousEquality.Quotients where
 
-open import Function
+open import Function.Base using (_$_; const; _∘_)
 open import Level hiding (lift)
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
 open import Relation.Binary.HeterogeneousEquality
 open ≅-Reasoning
 
diff --git a/src/Relation/Binary/HeterogeneousEquality/Quotients/Examples.agda b/src/Relation/Binary/HeterogeneousEquality/Quotients/Examples.agda
index c7bddf4a5a..12092a07ac 100644
--- a/src/Relation/Binary/HeterogeneousEquality/Quotients/Examples.agda
+++ b/src/Relation/Binary/HeterogeneousEquality/Quotients/Examples.agda
@@ -10,12 +10,13 @@ module Relation.Binary.HeterogeneousEquality.Quotients.Examples where
 
 open import Relation.Binary.HeterogeneousEquality.Quotients
 open import Level using (0ℓ)
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Structures using (IsEquivalence)
 open import Relation.Binary.HeterogeneousEquality hiding (isEquivalence)
-import Relation.Binary.PropositionalEquality as ≡
+import Relation.Binary.PropositionalEquality.Core as ≡
 open import Data.Nat.Base
 open import Data.Nat.Properties
-open import Data.Product
+open import Data.Product.Base using (_×_; _,_)
 open import Function.Base
 
 open ≅-Reasoning
@@ -58,10 +59,12 @@ module Integers (quot : Quotients 0ℓ 0ℓ) where
 
   open Quotient Int renaming (Q to ℤ)
 
+  infixl 6 _+²_
+
   _+²_ : ℕ² → ℕ² → ℕ²
   (x₁ , y₁) +² (x₂ , y₂) = x₁ + x₂ , y₁ + y₂
 
-  +²-cong : ∀{a b a′ b′} → a ∼ a′ → b ∼ b′ → a +² b ∼ a′ +² b′
+  +²-cong : ∀{a b a′ b′} → a ∼ a′ → b ∼ b′ → (a +² b) ∼ (a′ +² b′)
   +²-cong {a₁ , b₁} {c₁ , d₁} {a₂ , b₂} {c₂ , d₂} ab∼cd₁ ab∼cd₂ = begin
     (a₁ + c₁) + (b₂ + d₂) ≡⟨ ≡.cong (_+ (b₂ + d₂)) (+-comm a₁ c₁) ⟩
     (c₁ + a₁) + (b₂ + d₂) ≡⟨ +-assoc c₁ a₁ (b₂ + d₂) ⟩
@@ -82,6 +85,8 @@ module Integers (quot : Quotients 0ℓ 0ℓ) where
   module _ (ext : ∀ {a b} {A : Set a} {B₁ B₂ : A → Set b} {f₁ : ∀ a → B₁ a}
                   {f₂ : ∀ a → B₂ a} → (∀ a → f₁ a ≅ f₂ a) → f₁ ≅ f₂) where
 
+    infixl 6 _+ℤ_
+
     _+ℤ_ : ℤ → ℤ → ℤ
     _+ℤ_ = Properties₂.lift₂ ext Int Int (λ i j → abs (i +² j))
          $ λ {a} {b} {c} p p′ → compat-abs (+²-cong {a} {b} {c} p p′)
@@ -125,7 +130,7 @@ module Integers (quot : Quotients 0ℓ 0ℓ) where
         abs (zero² +² a)   ≅⟨ compat-abs (+²-identityˡ a) ⟩
         abs a              ∎
 
-    +²-assoc : (i j k : ℕ²) → (i +² j) +² k ∼ i +² (j +² k)
+    +²-assoc : (i j k : ℕ²) → ((i +² j) +² k) ∼ (i +² (j +² k))
     +²-assoc (a , b) (c , d) (e , f) = begin
       ((a + c) + e) + (b + (d + f)) ≡⟨ ≡.cong (_+ (b + (d + f))) (+-assoc a c e) ⟩
       (a + (c + e)) + (b + (d + f)) ≡⟨ ≡.cong ((a + (c + e)) +_) (≡.sym (+-assoc b d f)) ⟩
diff --git a/src/Relation/Binary/Indexed/Heterogeneous/Bundles.agda b/src/Relation/Binary/Indexed/Heterogeneous/Bundles.agda
index 089cad70ab..e1d8e53b07 100644
--- a/src/Relation/Binary/Indexed/Heterogeneous/Bundles.agda
+++ b/src/Relation/Binary/Indexed/Heterogeneous/Bundles.agda
@@ -11,10 +11,7 @@
 
 module Relation.Binary.Indexed.Heterogeneous.Bundles where
 
-open import Function.Base
 open import Level using (suc; _⊔_)
-open import Relation.Binary using (_⇒_)
-open import Relation.Binary.PropositionalEquality.Core as P using (_≡_)
 open import Relation.Binary.Indexed.Heterogeneous.Core
 open import Relation.Binary.Indexed.Heterogeneous.Structures
 
@@ -33,11 +30,28 @@ record IndexedSetoid {i} (I : Set i) c ℓ : Set (suc (i ⊔ c ⊔ ℓ)) where
 
 record IndexedPreorder {i} (I : Set i) c ℓ₁ ℓ₂ :
                        Set (suc (i ⊔ c ⊔ ℓ₁ ⊔ ℓ₂)) where
-  infix 4 _≈_ _∼_
+  infix 4 _≈_ _≲_
   field
     Carrier    : I → Set c
     _≈_        : IRel Carrier ℓ₁  -- The underlying equality.
-    _∼_        : IRel Carrier ℓ₂  -- The relation.
-    isPreorder : IsIndexedPreorder Carrier _≈_ _∼_
+    _≲_        : IRel Carrier ℓ₂  -- The relation.
+    isPreorder : IsIndexedPreorder Carrier _≈_ _≲_
 
   open IsIndexedPreorder isPreorder public
+
+  infix 4 _∼_
+  _∼_ = _≲_
+
+
+
+------------------------------------------------------------------------
+-- DEPRECATED
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
+
+{-# WARNING_ON_USAGE IndexedPreorder._∼_
+"Warning: IndexedPreorder._∼_ was deprecated in v2.0. Please use IndexedPreorder._≲_ instead. "
+#-}
diff --git a/src/Relation/Binary/Indexed/Heterogeneous/Construct/At.agda b/src/Relation/Binary/Indexed/Heterogeneous/Construct/At.agda
index f9c6dd8712..441ef849bc 100644
--- a/src/Relation/Binary/Indexed/Heterogeneous/Construct/At.agda
+++ b/src/Relation/Binary/Indexed/Heterogeneous/Construct/At.agda
@@ -9,7 +9,8 @@
 
 module Relation.Binary.Indexed.Heterogeneous.Construct.At where
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid; Preorder)
+open import Relation.Binary.Structures using (IsEquivalence; IsPreorder)
 open import Relation.Binary.Indexed.Heterogeneous
 
 ------------------------------------------------------------------------
@@ -26,9 +27,9 @@ module _ {a i} {I : Set i} {A : I → Set a} where
     }
     where open IsIndexedEquivalence isEq
 
-  isPreorder : ∀ {ℓ₁ ℓ₂} {_≈_ : IRel A ℓ₁} {_∼_ : IRel A ℓ₂} →
-               IsIndexedPreorder A _≈_ _∼_ →
-               (index : I) → IsPreorder (_≈_ {index}) _∼_
+  isPreorder : ∀ {ℓ₁ ℓ₂} {_≈_ : IRel A ℓ₁} {_≲_ : IRel A ℓ₂} →
+               IsIndexedPreorder A _≈_ _≲_ →
+               (index : I) → IsPreorder (_≈_ {index}) _≲_
   isPreorder isPreorder index = record
     { isEquivalence = isEquivalence O.isEquivalence index
     ; reflexive     = O.reflexive
@@ -53,7 +54,7 @@ module _ {a i} {I : Set i} where
   preorder O index = record
     { Carrier    = O.Carrier index
     ; _≈_        = O._≈_
-    ; _∼_        = O._∼_
+    ; _≲_        = O._≲_
     ; isPreorder = isPreorder O.isPreorder index
     }
     where module O = IndexedPreorder O
@@ -63,5 +64,7 @@ module _ {a i} {I : Set i} where
 
 module _ {a i} {I : Set i} where
 
+  infixr -1 _atₛ_
+
   _atₛ_ : ∀ {ℓ} → IndexedSetoid I a ℓ → I → Setoid a ℓ
   _atₛ_ = setoid
diff --git a/src/Relation/Binary/Indexed/Heterogeneous/Construct/Trivial.agda b/src/Relation/Binary/Indexed/Heterogeneous/Construct/Trivial.agda
index 800d7e09f3..797e0587bc 100644
--- a/src/Relation/Binary/Indexed/Heterogeneous/Construct/Trivial.agda
+++ b/src/Relation/Binary/Indexed/Heterogeneous/Construct/Trivial.agda
@@ -9,7 +9,9 @@
 module Relation.Binary.Indexed.Heterogeneous.Construct.Trivial
   {i} {I : Set i} where
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid; Preorder)
+open import Relation.Binary.Structures using (IsEquivalence; IsPreorder)
 open import Relation.Binary.Indexed.Heterogeneous
 
 ------------------------------------------------------------------------
diff --git a/src/Relation/Binary/Indexed/Heterogeneous/Core.agda b/src/Relation/Binary/Indexed/Heterogeneous/Core.agda
index 7195bb9ec4..a58276ad32 100644
--- a/src/Relation/Binary/Indexed/Heterogeneous/Core.agda
+++ b/src/Relation/Binary/Indexed/Heterogeneous/Core.agda
@@ -13,8 +13,6 @@ module Relation.Binary.Indexed.Heterogeneous.Core where
 
 open import Level
 import Relation.Binary.Core as B
-import Relation.Binary.Definitions as B
-import Relation.Binary.PropositionalEquality.Core as P
 
 ------------------------------------------------------------------------
 -- Indexed binary relations
diff --git a/src/Relation/Binary/Indexed/Heterogeneous/Definitions.agda b/src/Relation/Binary/Indexed/Heterogeneous/Definitions.agda
index f6657a6861..0fb09c6dd6 100644
--- a/src/Relation/Binary/Indexed/Heterogeneous/Definitions.agda
+++ b/src/Relation/Binary/Indexed/Heterogeneous/Definitions.agda
@@ -12,9 +12,7 @@
 module Relation.Binary.Indexed.Heterogeneous.Definitions where
 
 open import Level
-import Relation.Binary.Core as B
 import Relation.Binary.Definitions as B
-import Relation.Binary.PropositionalEquality.Core as P
 open import Relation.Binary.Indexed.Heterogeneous.Core
 
 private
diff --git a/src/Relation/Binary/Indexed/Heterogeneous/Structures.agda b/src/Relation/Binary/Indexed/Heterogeneous/Structures.agda
index c61022d362..c084dadc8c 100644
--- a/src/Relation/Binary/Indexed/Heterogeneous/Structures.agda
+++ b/src/Relation/Binary/Indexed/Heterogeneous/Structures.agda
@@ -17,8 +17,8 @@ module Relation.Binary.Indexed.Heterogeneous.Structures
 
 open import Function.Base
 open import Level using (suc; _⊔_)
-open import Relation.Binary using (_⇒_)
-open import Relation.Binary.PropositionalEquality.Core as P using (_≡_)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Binary.Indexed.Heterogeneous.Definitions
 
 ------------------------------------------------------------------------
@@ -31,16 +31,16 @@ record IsIndexedEquivalence : Set (i ⊔ a ⊔ ℓ) where
     trans : Transitive A _≈_
 
   reflexive : ∀ {i} → _≡_ ⟨ _⇒_ ⟩ _≈_ {i}
-  reflexive P.refl = refl
+  reflexive ≡.refl = refl
 
 
-record IsIndexedPreorder {ℓ₂} (_∼_ : IRel A ℓ₂) : Set (i ⊔ a ⊔ ℓ ⊔ ℓ₂) where
+record IsIndexedPreorder {ℓ₂} (_≲_ : IRel A ℓ₂) : Set (i ⊔ a ⊔ ℓ ⊔ ℓ₂) where
   field
     isEquivalence : IsIndexedEquivalence
-    reflexive     : ∀ {i j} → (_≈_ {i} {j}) ⟨ _⇒_ ⟩ _∼_
-    trans         : Transitive A _∼_
+    reflexive     : ∀ {i j} → (_≈_ {i} {j}) ⟨ _⇒_ ⟩ _≲_
+    trans         : Transitive A _≲_
 
   module Eq = IsIndexedEquivalence isEquivalence
 
-  refl : Reflexive A _∼_
+  refl : Reflexive A _≲_
   refl = reflexive Eq.refl
diff --git a/src/Relation/Binary/Indexed/Homogeneous/Bundles.agda b/src/Relation/Binary/Indexed/Homogeneous/Bundles.agda
index 670949c138..aa56c0dcdb 100644
--- a/src/Relation/Binary/Indexed/Homogeneous/Bundles.agda
+++ b/src/Relation/Binary/Indexed/Homogeneous/Bundles.agda
@@ -11,11 +11,9 @@
 
 module Relation.Binary.Indexed.Homogeneous.Bundles where
 
-open import Data.Product using (_,_)
-open import Function.Base using (_⟨_⟩_)
-open import Level using (Level; _⊔_; suc)
-open import Relation.Binary as B using (_⇒_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Level using (suc; _⊔_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles as B
 open import Relation.Nullary.Negation using (¬_)
 open import Relation.Binary.Indexed.Homogeneous.Core
 open import Relation.Binary.Indexed.Homogeneous.Structures
@@ -39,10 +37,12 @@ record IndexedSetoid {i} (I : Set i) c ℓ : Set (suc (i ⊔ c ⊔ ℓ)) where
   Carrier : Set _
   Carrier = ∀ i → Carrierᵢ i
 
-  _≈_ : B.Rel Carrier _
+  infix 4 _≉_
+
+  _≈_ : Rel Carrier _
   _≈_ = Lift Carrierᵢ _≈ᵢ_
 
-  _≉_ : B.Rel Carrier _
+  _≉_ : Rel Carrier _
   x ≉ y = ¬ (x ≈ y)
 
   setoid : B.Setoid _ _
@@ -87,10 +87,10 @@ record IndexedPreorder {i} (I : Set i) c ℓ₁ ℓ₂ :
   Carrier : Set _
   Carrier = ∀ i → Carrierᵢ i
 
-  _≈_ : B.Rel Carrier _
+  _≈_ : Rel Carrier _
   x ≈ y = ∀ i → x i ≈ᵢ y i
 
-  _∼_ : B.Rel Carrier _
+  _∼_ : Rel Carrier _
   x ∼ y = ∀ i → x i ∼ᵢ y i
 
   preorder : B.Preorder _ _ _
@@ -103,6 +103,7 @@ record IndexedPreorder {i} (I : Set i) c ℓ₁ ℓ₂ :
 
 record IndexedPoset {i} (I : Set i) c ℓ₁ ℓ₂ :
                     Set (suc (i ⊔ c ⊔ ℓ₁ ⊔ ℓ₂)) where
+  infix 4 _≈ᵢ_ _≤ᵢ_
   field
     Carrierᵢ        : I → Set c
     _≈ᵢ_            : IRel Carrierᵢ ℓ₁
diff --git a/src/Relation/Binary/Indexed/Homogeneous/Construct/At.agda b/src/Relation/Binary/Indexed/Homogeneous/Construct/At.agda
index 9899c200b3..f8911c770b 100644
--- a/src/Relation/Binary/Indexed/Homogeneous/Construct/At.agda
+++ b/src/Relation/Binary/Indexed/Homogeneous/Construct/At.agda
@@ -7,7 +7,9 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Level
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid; DecSetoid; Preorder)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence; IsPreorder)
 open import Relation.Binary.Indexed.Homogeneous
 
 module Relation.Binary.Indexed.Homogeneous.Construct.At where
@@ -66,5 +68,7 @@ preorder O index = record
 ------------------------------------------------------------------------
 -- Some useful shorthand infix notation
 
+infixr -1 _atₛ_
+
 _atₛ_ : ∀ {ℓ} → IndexedSetoid I a ℓ → I → Setoid a ℓ
 _atₛ_ = setoid
diff --git a/src/Relation/Binary/Indexed/Homogeneous/Core.agda b/src/Relation/Binary/Indexed/Homogeneous/Core.agda
index 6dc2e03f82..50f8b3a200 100644
--- a/src/Relation/Binary/Indexed/Homogeneous/Core.agda
+++ b/src/Relation/Binary/Indexed/Homogeneous/Core.agda
@@ -12,8 +12,8 @@
 module Relation.Binary.Indexed.Homogeneous.Core where
 
 open import Level using (Level; _⊔_)
-open import Data.Product using (_×_)
-open import Relation.Binary as B using (REL; Rel)
+open import Data.Product.Base using (_×_)
+open import Relation.Binary.Core as B using (REL; Rel)
 open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 import Relation.Binary.Indexed.Heterogeneous as I
 open import Relation.Unary.Indexed using (IPred)
diff --git a/src/Relation/Binary/Indexed/Homogeneous/Definitions.agda b/src/Relation/Binary/Indexed/Homogeneous/Definitions.agda
index 0231def44f..cde714bc83 100644
--- a/src/Relation/Binary/Indexed/Homogeneous/Definitions.agda
+++ b/src/Relation/Binary/Indexed/Homogeneous/Definitions.agda
@@ -11,9 +11,10 @@
 
 module Relation.Binary.Indexed.Homogeneous.Definitions where
 
-open import Data.Product using (_×_)
+open import Data.Product.Base using (_×_)
 open import Level using (Level)
-import Relation.Binary as B
+open import Relation.Binary.Core using (_⇒_)
+import Relation.Binary.Definitions as B
 open import Relation.Unary.Indexed using (IPred)
 
 open import Relation.Binary.Indexed.Homogeneous.Core
@@ -31,7 +32,7 @@ module _ (A : I → Set a) where
   syntax Implies A _∼₁_ _∼₂_ = _∼₁_ ⇒[ A ] _∼₂_
 
   Implies : IRel A ℓ₁ → IRel A ℓ₂ → Set _
-  Implies _∼₁_ _∼₂_ = ∀ {i} → _∼₁_ B.⇒ (_∼₂_ {i})
+  Implies _∼₁_ _∼₂_ = ∀ {i} → _∼₁_ ⇒ (_∼₂_ {i})
 
   Reflexive : IRel A ℓ → Set _
   Reflexive _∼_ = ∀ {i} → B.Reflexive (_∼_ {i})
diff --git a/src/Relation/Binary/Indexed/Homogeneous/Structures.agda b/src/Relation/Binary/Indexed/Homogeneous/Structures.agda
index 1404bf7f52..f5a941b65b 100644
--- a/src/Relation/Binary/Indexed/Homogeneous/Structures.agda
+++ b/src/Relation/Binary/Indexed/Homogeneous/Structures.agda
@@ -17,11 +17,13 @@ module Relation.Binary.Indexed.Homogeneous.Structures
   (_≈ᵢ_ : IRel A ℓ) -- The underlying indexed equality relation
   where
 
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (_⟨_⟩_)
 open import Level using (Level; _⊔_; suc)
-open import Relation.Binary as B using (_⇒_)
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
+open import Relation.Binary.Core using (_⇒_)
+import Relation.Binary.Definitions as B
+import Relation.Binary.Structures as B
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Binary.Indexed.Homogeneous.Definitions
 
 ------------------------------------------------------------------------
@@ -38,12 +40,12 @@ record IsIndexedEquivalence : Set (i ⊔ a ⊔ ℓ) where
     transᵢ : Transitive A _≈ᵢ_
 
   reflexiveᵢ : ∀ {i} → _≡_ ⟨ _⇒_ ⟩ _≈ᵢ_ {i}
-  reflexiveᵢ P.refl = reflᵢ
+  reflexiveᵢ ≡.refl = reflᵢ
 
   -- Lift properties
 
   reflexive : _≡_ ⇒ (Lift A _≈ᵢ_)
-  reflexive P.refl i = reflᵢ
+  reflexive ≡.refl i = reflᵢ
 
   refl : B.Reflexive (Lift A _≈ᵢ_)
   refl i = reflᵢ
@@ -97,7 +99,7 @@ record IsIndexedPreorder {ℓ₂} (_∼ᵢ_ : IRel A ℓ₂)
 
   -- Lifted properties
 
-  reflexive : Lift A _≈ᵢ_ B.⇒ Lift A _∼ᵢ_
+  reflexive : Lift A _≈ᵢ_ ⇒ Lift A _∼ᵢ_
   reflexive x≈y i = reflexiveᵢ (x≈y i)
 
   refl : B.Reflexive (Lift A _∼ᵢ_)
diff --git a/src/Relation/Binary/Lattice/Bundles.agda b/src/Relation/Binary/Lattice/Bundles.agda
index ffe5dbf50d..7752c79676 100644
--- a/src/Relation/Binary/Lattice/Bundles.agda
+++ b/src/Relation/Binary/Lattice/Bundles.agda
@@ -13,7 +13,8 @@ module Relation.Binary.Lattice.Bundles where
 
 open import Algebra.Core
 open import Level using (suc; _⊔_)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Poset; Setoid)
 open import Relation.Binary.Lattice.Structures
 
 ------------------------------------------------------------------------
diff --git a/src/Relation/Binary/Lattice/Definitions.agda b/src/Relation/Binary/Lattice/Definitions.agda
index 61102f19f9..2cdc32a1c3 100644
--- a/src/Relation/Binary/Lattice/Definitions.agda
+++ b/src/Relation/Binary/Lattice/Definitions.agda
@@ -12,10 +12,10 @@
 module Relation.Binary.Lattice.Definitions where
 
 open import Algebra.Core
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Function.Base using (flip)
-open import Relation.Binary
-open import Level
+open import Relation.Binary.Core using (Rel)
+open import Level using (Level)
 
 private
   variable
diff --git a/src/Relation/Binary/Lattice/Properties/BoundedJoinSemilattice.agda b/src/Relation/Binary/Lattice/Properties/BoundedJoinSemilattice.agda
index b75cfa7093..4d089b6b0f 100644
--- a/src/Relation/Binary/Lattice/Properties/BoundedJoinSemilattice.agda
+++ b/src/Relation/Binary/Lattice/Properties/BoundedJoinSemilattice.agda
@@ -14,14 +14,11 @@ module Relation.Binary.Lattice.Properties.BoundedJoinSemilattice
 open BoundedJoinSemilattice J
 
 open import Algebra.Definitions _≈_
-open import Algebra.Ordered.Structures using (IsCommutativePomonoid)
-open import Algebra.Ordered.Bundles using (CommutativePomonoid)
-open import Data.Product
+open import Data.Product.Base using (_,_)
 open import Function.Base using (_∘_; flip)
-open import Relation.Binary
 open import Relation.Binary.Properties.Poset poset
 open import Relation.Binary.Lattice.Properties.JoinSemilattice joinSemilattice
-  using (isPosemigroup; ∨-comm)
+  using (∨-comm)
 
 -- Bottom is an identity of the meet operation.
 
@@ -55,24 +52,3 @@ dualBoundedMeetSemilattice = record
   { ⊤                        = ⊥
   ; isBoundedMeetSemilattice = dualIsBoundedMeetSemilattice
   }
-
--- Every bounded semilattice gives rise to a commutative pomonoid
-
-isCommutativePomonoid : IsCommutativePomonoid _≈_ _≤_ _∨_ ⊥
-isCommutativePomonoid = record
-  { isPomonoid          = record
-    { isPosemigroup     = isPosemigroup
-    ; identity          = identity
-    }
-  ; comm                = ∨-comm
-  }
-
-commutativePomonoid : CommutativePomonoid c ℓ₁ ℓ₂
-commutativePomonoid = record
-  { Carrier               = Carrier
-  ; _≈_                   = _≈_
-  ; _≤_                   = _≤_
-  ; _∙_                   = _∨_
-  ; ε                     = ⊥
-  ; isCommutativePomonoid = isCommutativePomonoid
-  }
diff --git a/src/Relation/Binary/Lattice/Properties/BoundedLattice.agda b/src/Relation/Binary/Lattice/Properties/BoundedLattice.agda
index 95bf238945..b665166517 100644
--- a/src/Relation/Binary/Lattice/Properties/BoundedLattice.agda
+++ b/src/Relation/Binary/Lattice/Properties/BoundedLattice.agda
@@ -14,8 +14,8 @@ module Relation.Binary.Lattice.Properties.BoundedLattice
 open BoundedLattice L
 
 open import Algebra.Definitions _≈_
-open import Data.Product using (_,_)
-open import Relation.Binary using (Setoid)
+open import Data.Product.Base using (_,_)
+open import Relation.Binary.Bundles using (Setoid)
 open import Relation.Binary.Lattice.Properties.MeetSemilattice meetSemilattice
 open import Relation.Binary.Lattice.Properties.JoinSemilattice joinSemilattice
 
diff --git a/src/Relation/Binary/Lattice/Properties/BoundedMeetSemilattice.agda b/src/Relation/Binary/Lattice/Properties/BoundedMeetSemilattice.agda
index b6c7be5a5c..b0c945c39f 100644
--- a/src/Relation/Binary/Lattice/Properties/BoundedMeetSemilattice.agda
+++ b/src/Relation/Binary/Lattice/Properties/BoundedMeetSemilattice.agda
@@ -14,9 +14,7 @@ module Relation.Binary.Lattice.Properties.BoundedMeetSemilattice
 open BoundedMeetSemilattice M
 
 open import Algebra.Definitions _≈_
-open import Data.Product
 open import Function.Base using (_∘_; flip)
-open import Relation.Binary
 open import Relation.Binary.Properties.Poset poset
 import Relation.Binary.Lattice.Properties.BoundedJoinSemilattice as J
 
diff --git a/src/Relation/Binary/Lattice/Properties/DistributiveLattice.agda b/src/Relation/Binary/Lattice/Properties/DistributiveLattice.agda
index 8ee0462d39..f287e0a05d 100644
--- a/src/Relation/Binary/Lattice/Properties/DistributiveLattice.agda
+++ b/src/Relation/Binary/Lattice/Properties/DistributiveLattice.agda
@@ -14,8 +14,8 @@ module Relation.Binary.Lattice.Properties.DistributiveLattice
 open DistributiveLattice L hiding (refl)
 
 open import Algebra.Definitions _≈_
-open import Data.Product using (_,_)
-open import Relation.Binary
+open import Data.Product.Base using (_,_)
+open import Relation.Binary.Bundles using (Setoid)
 open import Relation.Binary.Reasoning.Setoid setoid
 open import Relation.Binary.Lattice.Properties.Lattice lattice
 open import Relation.Binary.Lattice.Properties.MeetSemilattice meetSemilattice
diff --git a/src/Relation/Binary/Lattice/Properties/HeytingAlgebra.agda b/src/Relation/Binary/Lattice/Properties/HeytingAlgebra.agda
new file mode 100644
index 0000000000..4727088718
--- /dev/null
+++ b/src/Relation/Binary/Lattice/Properties/HeytingAlgebra.agda
@@ -0,0 +1,199 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Properties satisfied by Heyting Algebra
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Lattice
+
+module Relation.Binary.Lattice.Properties.HeytingAlgebra
+  {c ℓ₁ ℓ₂} (L : HeytingAlgebra c ℓ₁ ℓ₂) where
+
+open HeytingAlgebra L
+
+open import Algebra.Core
+open import Algebra.Definitions _≈_
+open import Data.Product.Base using (_,_)
+open import Function.Base using (_$_; flip; _∘_)
+open import Level using (_⊔_)
+open import Relation.Binary.Core using (_Preserves_⟶_; _Preserves₂_⟶_⟶_)
+import Relation.Binary.Reasoning.PartialOrder as ≤-Reasoning
+open import Relation.Binary.Lattice.Properties.MeetSemilattice meetSemilattice
+open import Relation.Binary.Lattice.Properties.JoinSemilattice joinSemilattice
+import Relation.Binary.Lattice.Properties.BoundedMeetSemilattice boundedMeetSemilattice as BM
+open import Relation.Binary.Lattice.Properties.Lattice lattice
+open import Relation.Binary.Lattice.Properties.BoundedLattice boundedLattice
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
+
+------------------------------------------------------------------------
+-- Useful lemmas
+
+⇨-eval : ∀ {x y} → (x ⇨ y) ∧ x ≤ y
+⇨-eval {x} {y} = transpose-∧ refl
+
+swap-transpose-⇨ : ∀ {x y w} → x ∧ w ≤ y → w ≤ x ⇨ y
+swap-transpose-⇨ x∧w≤y = transpose-⇨ $ trans (reflexive $ ∧-comm _ _) x∧w≤y
+
+------------------------------------------------------------------------
+-- Properties of exponential
+
+⇨-unit : ∀ {x} → x ⇨ x ≈ ⊤
+⇨-unit = antisym (maximum _) (transpose-⇨ $ reflexive $ BM.identityˡ _)
+
+y≤x⇨y : ∀ {x y} → y ≤ x ⇨ y
+y≤x⇨y = transpose-⇨ (x∧y≤x _ _)
+
+⇨-drop : ∀ {x y} → (x ⇨ y) ∧ y ≈ y
+⇨-drop = antisym (x∧y≤y _ _) (∧-greatest y≤x⇨y refl)
+
+⇨-app : ∀ {x y} → (x ⇨ y) ∧ x ≈ y ∧ x
+⇨-app = antisym (∧-greatest ⇨-eval (x∧y≤y _ _)) (∧-monotonic y≤x⇨y refl)
+
+⇨ʳ-covariant : ∀ {x} → (x ⇨_) Preserves _≤_ ⟶ _≤_
+⇨ʳ-covariant y≤z = transpose-⇨ (trans ⇨-eval y≤z)
+
+⇨ˡ-contravariant : ∀ {x} → (_⇨ x) Preserves (flip _≤_) ⟶ _≤_
+⇨ˡ-contravariant z≤y = transpose-⇨ (trans (∧-monotonic refl z≤y) ⇨-eval)
+
+⇨-relax : _⇨_ Preserves₂ (flip _≤_) ⟶ _≤_ ⟶ _≤_
+⇨-relax {x} {y} {u} {v} y≤x u≤v = begin
+  x ⇨ u ≤⟨ ⇨ʳ-covariant u≤v ⟩
+  x ⇨ v ≤⟨ ⇨ˡ-contravariant y≤x ⟩
+  y ⇨ v ∎
+  where open ≤-Reasoning poset
+
+⇨-cong : _⇨_ Preserves₂ _≈_ ⟶ _≈_ ⟶ _≈_
+⇨-cong x≈y u≈v = antisym (⇨-relax (reflexive $ Eq.sym x≈y) (reflexive u≈v))
+                         (⇨-relax (reflexive x≈y) (reflexive $ Eq.sym u≈v))
+
+⇨-applyˡ : ∀ {w x y} → w ≤ x → (x ⇨ y) ∧ w ≤ y
+⇨-applyˡ = transpose-∧ ∘ ⇨ˡ-contravariant
+
+⇨-applyʳ : ∀ {w x y} → w ≤ x → w ∧ (x ⇨ y) ≤ y
+⇨-applyʳ w≤x = trans (reflexive (∧-comm _ _)) (⇨-applyˡ w≤x)
+
+⇨-curry : ∀ {x y z} → x ∧ y ⇨ z ≈ x ⇨ y ⇨ z
+⇨-curry = antisym (transpose-⇨ $ transpose-⇨ $ trans (reflexive $ ∧-assoc _ _ _) ⇨-eval)
+                  (transpose-⇨ $ trans (reflexive $ Eq.sym $ ∧-assoc _ _ _)
+                                       (transpose-∧ $ ⇨-applyˡ refl))
+
+------------------------------------------------------------------------
+-- Various proofs of distributivity
+
+∧-distribˡ-∨-≤ : ∀ x y z → x ∧ (y ∨ z) ≤ x ∧ y ∨ x ∧ z
+∧-distribˡ-∨-≤ x y z = trans (reflexive $ ∧-comm _ _)
+  (transpose-∧ $ ∨-least (swap-transpose-⇨ (x≤x∨y _ _)) $ swap-transpose-⇨ (y≤x∨y _ _))
+
+∧-distribˡ-∨-≥ : ∀ x y z → x ∧ y ∨ x ∧ z ≤ x ∧ (y ∨ z)
+∧-distribˡ-∨-≥ x y z = let
+    x∧y≤x , x∧y≤y , _ = infimum x y
+    x∧z≤x , x∧z≤z , _ = infimum x z
+    y≤y∨z , z≤y∨z , _ = supremum y z
+  in ∧-greatest (∨-least x∧y≤x x∧z≤x)
+                (∨-least (trans x∧y≤y y≤y∨z) (trans x∧z≤z z≤y∨z))
+
+∧-distribˡ-∨ : _∧_ DistributesOverˡ _∨_
+∧-distribˡ-∨ x y z = antisym (∧-distribˡ-∨-≤ x y z) (∧-distribˡ-∨-≥ x y z)
+
+⇨-distribˡ-∧-≤ : ∀ x y z → x ⇨ y ∧ z ≤ (x ⇨ y) ∧ (x ⇨ z)
+⇨-distribˡ-∧-≤ x y z = let
+     y∧z≤y , y∧z≤z , _ = infimum y z
+   in ∧-greatest (transpose-⇨ $ trans ⇨-eval y∧z≤y)
+                 (transpose-⇨ $ trans ⇨-eval y∧z≤z)
+
+⇨-distribˡ-∧-≥ : ∀ x y z → (x ⇨ y) ∧ (x ⇨ z) ≤ x ⇨ y ∧ z
+⇨-distribˡ-∧-≥ x y z = transpose-⇨ (begin
+  (((x ⇨ y) ∧ (x ⇨ z)) ∧ x)      ≈⟨ ∧-cong Eq.refl $ Eq.sym $ ∧-idempotent _ ⟩
+  (((x ⇨ y) ∧ (x ⇨ z)) ∧ x  ∧ x) ≈⟨ Eq.sym $ ∧-assoc _ _ _ ⟩
+  (((x ⇨ y) ∧ (x ⇨ z)) ∧ x) ∧ x  ≈⟨ ∧-cong (∧-assoc _ _ _) Eq.refl ⟩
+  (((x ⇨ y) ∧ (x ⇨ z)  ∧ x) ∧ x) ≈⟨ ∧-cong (∧-cong Eq.refl $ ∧-comm _ _) Eq.refl ⟩
+  (((x ⇨ y) ∧ x  ∧ (x ⇨ z)) ∧ x) ≈⟨ ∧-cong (Eq.sym $ ∧-assoc _ _ _) Eq.refl ⟩
+  (((x ⇨ y) ∧ x) ∧ (x ⇨ z)) ∧ x  ≈⟨ ∧-assoc _ _ _ ⟩
+  (((x ⇨ y) ∧ x) ∧ (x ⇨ z)  ∧ x) ≤⟨ ∧-monotonic ⇨-eval ⇨-eval ⟩
+  y ∧ z                          ∎)
+  where open ≤-Reasoning poset
+
+⇨-distribˡ-∧ : _⇨_ DistributesOverˡ _∧_
+⇨-distribˡ-∧ x y z = antisym (⇨-distribˡ-∧-≤ x y z) (⇨-distribˡ-∧-≥ x y z)
+
+⇨-distribˡ-∨-∧-≤ : ∀ x y z → x ∨ y ⇨ z ≤ (x ⇨ z) ∧ (y ⇨ z)
+⇨-distribˡ-∨-∧-≤ x y z = let x≤x∨y , y≤x∨y , _ = supremum x y
+   in ∧-greatest (transpose-⇨ $ trans (∧-monotonic refl x≤x∨y) ⇨-eval)
+                 (transpose-⇨ $ trans (∧-monotonic refl y≤x∨y) ⇨-eval)
+
+⇨-distribˡ-∨-∧-≥ : ∀ x y z → (x ⇨ z) ∧ (y ⇨ z) ≤ x ∨ y ⇨ z
+⇨-distribˡ-∨-∧-≥ x y z = transpose-⇨ (trans (reflexive $ ∧-distribˡ-∨ _ _ _)
+  (∨-least (trans (transpose-∧ (x∧y≤x _ _)) refl)
+           (trans (transpose-∧ (x∧y≤y _ _)) refl)))
+
+⇨-distribˡ-∨-∧ : ∀ x y z → x ∨ y ⇨ z ≈ (x ⇨ z) ∧ (y ⇨ z)
+⇨-distribˡ-∨-∧ x y z = antisym (⇨-distribˡ-∨-∧-≤ x y z) (⇨-distribˡ-∨-∧-≥ x y z)
+
+------------------------------------------------------------------------
+-- Heyting algebras are distributive lattices
+
+isDistributiveLattice : IsDistributiveLattice _≈_ _≤_ _∨_ _∧_
+isDistributiveLattice = record
+  { isLattice    = isLattice
+  ; ∧-distribˡ-∨ = ∧-distribˡ-∨
+  }
+
+distributiveLattice : DistributiveLattice _ _ _
+distributiveLattice = record
+  { isDistributiveLattice = isDistributiveLattice
+  }
+
+------------------------------------------------------------------------
+-- Heyting algebras can define pseudo-complement
+
+infix 8 ¬_
+
+¬_ : Op₁ Carrier
+¬ x = x ⇨ ⊥
+
+x≤¬¬x : ∀ x → x ≤ ¬ ¬ x
+x≤¬¬x x = transpose-⇨ (trans (reflexive (∧-comm _ _)) ⇨-eval)
+
+------------------------------------------------------------------------
+-- De-Morgan laws
+
+de-morgan₁ : ∀ x y → ¬ (x ∨ y) ≈ ¬ x ∧ ¬ y
+de-morgan₁ x y = ⇨-distribˡ-∨-∧ _ _ _
+
+de-morgan₂-≤ : ∀ x y → ¬ (x ∧ y) ≤ ¬ ¬ (¬ x ∨ ¬ y)
+de-morgan₂-≤ x y = transpose-⇨ $ begin
+  ¬ (x ∧ y) ∧ ¬ (¬ x ∨ ¬ y)     ≈⟨ ∧-cong ⇨-curry (de-morgan₁ _ _) ⟩
+  (x ⇨ ¬ y) ∧ ¬ ¬ x ∧ ¬ ¬ y     ≈⟨ ∧-cong Eq.refl (∧-comm _ _) ⟩
+  (x ⇨ ¬ y) ∧ ¬ ¬ y ∧ ¬ ¬ x     ≈⟨ Eq.sym $ ∧-assoc _ _ _ ⟩
+  ((x ⇨ ¬ y) ∧ ¬ ¬ y) ∧ ¬ ¬ x   ≤⟨ ⇨-applyʳ $ transpose-⇨ $
+    begin
+      ((x ⇨ ¬ y) ∧ ¬ ¬ y) ∧ x   ≈⟨ ∧-cong (∧-comm _ _) Eq.refl ⟩
+      ((¬ ¬ y) ∧ (x ⇨ ¬ y)) ∧ x ≈⟨ ∧-assoc _ _ _ ⟩
+      (¬ ¬ y) ∧ (x ⇨ ¬ y) ∧ x   ≤⟨ ∧-monotonic refl ⇨-eval ⟩
+      ¬ ¬ y ∧ ¬ y               ≤⟨ ⇨-eval ⟩
+      ⊥                         ∎ ⟩
+  ⊥                             ∎
+  where open ≤-Reasoning poset
+
+de-morgan₂-≥ : ∀ x y → ¬ ¬ (¬ x ∨ ¬ y) ≤ ¬ (x ∧ y)
+de-morgan₂-≥ x y = transpose-⇨ $ ⇨-applyˡ $ transpose-⇨ $ begin
+  (x ∧ y) ∧ (¬ x ∨ ¬ y)         ≈⟨ ∧-distribˡ-∨ _ _ _ ⟩
+  (x ∧ y) ∧ ¬ x ∨ (x ∧ y) ∧ ¬ y ≤⟨ ∨-monotonic (⇨-applyʳ (x∧y≤x _ _))
+                                               (⇨-applyʳ (x∧y≤y _ _)) ⟩
+  ⊥ ∨ ⊥                         ≈⟨ ∨-idempotent _ ⟩
+  ⊥                             ∎
+  where open ≤-Reasoning poset
+
+de-morgan₂ : ∀ x y → ¬ (x ∧ y) ≈ ¬ ¬ (¬ x ∨ ¬ y)
+de-morgan₂ x y = antisym (de-morgan₂-≤ x y) (de-morgan₂-≥ x y)
+
+weak-lem : ∀ {x} → ¬ ¬ (¬ x ∨ x) ≈ ⊤
+weak-lem {x} = begin
+  ¬ ¬ (¬ x ∨ x)   ≈⟨ ⇨-cong (de-morgan₁ _ _) Eq.refl ⟩
+  ¬ (¬ ¬ x ∧ ¬ x) ≈⟨ ⇨-cong ⇨-app Eq.refl ⟩
+  ⊥ ∧ (x ⇨ ⊥) ⇨ ⊥ ≈⟨ ⇨-cong (∧-zeroˡ _) Eq.refl ⟩
+  ⊥ ⇨ ⊥           ≈⟨ ⇨-unit ⟩
+  ⊤               ∎
+  where open ≈-Reasoning setoid
diff --git a/src/Relation/Binary/Lattice/Properties/JoinSemilattice.agda b/src/Relation/Binary/Lattice/Properties/JoinSemilattice.agda
index fb85a17fe0..c94c3bad16 100644
--- a/src/Relation/Binary/Lattice/Properties/JoinSemilattice.agda
+++ b/src/Relation/Binary/Lattice/Properties/JoinSemilattice.agda
@@ -16,11 +16,11 @@ open JoinSemilattice J
 import Algebra.Lattice as Alg
 import Algebra.Structures as Alg
 open import Algebra.Definitions _≈_
-open import Algebra.Ordered.Structures using (IsPosemigroup)
-open import Algebra.Ordered.Bundles using (Posemigroup)
-open import Data.Product
+open import Data.Product.Base using (_,_)
 open import Function.Base using (_∘_; flip)
-open import Relation.Binary
+open import Relation.Binary.Core using (_Preserves₂_⟶_⟶_)
+open import Relation.Binary.Structures using (IsDecPartialOrder)
+open import Relation.Binary.Definitions using (Decidable)
 open import Relation.Binary.Properties.Poset poset
 open import Relation.Nullary using (¬_; yes; no)
 open import Relation.Nullary.Negation using (contraposition)
@@ -95,26 +95,6 @@ isAlgSemilattice = record
 algSemilattice : Alg.Semilattice c ℓ₁
 algSemilattice = record { isSemilattice = isAlgSemilattice }
 
--- Every semilattice gives rise to a posemigroup
-
-isPosemigroup : IsPosemigroup _≈_ _≤_ _∨_
-isPosemigroup = record
-  { isPomagma        = record
-    { isPartialOrder = isPartialOrder
-    ; mono           = ∨-monotonic
-    }
-  ; assoc            = ∨-assoc
-  }
-
-posemigroup : Posemigroup c ℓ₁ ℓ₂
-posemigroup = record
-  { Carrier           = Carrier
-  ; _≈_               = _≈_
-  ; _≤_               = _≤_
-  ; _∙_               = _∨_
-  ; isPosemigroup     = isPosemigroup
-  }
-
 ------------------------------------------------------------------------
 -- The dual construction is a meet semilattice.
 
diff --git a/src/Relation/Binary/Lattice/Properties/Lattice.agda b/src/Relation/Binary/Lattice/Properties/Lattice.agda
index a221c35b2e..261371a3f0 100644
--- a/src/Relation/Binary/Lattice/Properties/Lattice.agda
+++ b/src/Relation/Binary/Lattice/Properties/Lattice.agda
@@ -16,14 +16,13 @@ open Lattice L
 import Algebra.Lattice as Alg
 import Algebra.Structures as Alg
 open import Algebra.Definitions _≈_
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (flip)
-open import Relation.Binary
 open import Relation.Binary.Properties.Poset poset
 import Relation.Binary.Lattice.Properties.JoinSemilattice joinSemilattice as J
 import Relation.Binary.Lattice.Properties.MeetSemilattice meetSemilattice as M
-import Relation.Binary.Reasoning.Setoid as EqReasoning
-import Relation.Binary.Reasoning.PartialOrder as POR
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
+import Relation.Binary.Reasoning.PartialOrder as ≤-Reasoning
 
 ∨-absorbs-∧ : _∨_ Absorbs _∧_
 ∨-absorbs-∧ x y =
@@ -45,7 +44,7 @@ absorptive = ∨-absorbs-∧ , ∧-absorbs-∨
   x ∧ y ≤⟨ x∧y≤x x y ⟩
   x     ≤⟨ x≤x∨y x y ⟩
   x ∨ y ∎
-  where open POR poset
+  where open ≤-Reasoning poset
 
 -- two quadrilateral arguments
 
@@ -56,14 +55,14 @@ quadrilateral₁ {x} {y} x∨y≈x = begin
   y ∧ (x ∨ y) ≈⟨ M.∧-cong Eq.refl (J.∨-comm _ _) ⟩
   y ∧ (y ∨ x) ≈⟨ ∧-absorbs-∨ _ _ ⟩
   y           ∎
-  where open EqReasoning setoid
+  where open ≈-Reasoning setoid
 
 quadrilateral₂ : ∀ {x y} → x ∧ y ≈ y → x ∨ y ≈ x
 quadrilateral₂ {x} {y} x∧y≈y = begin
   x ∨ y       ≈⟨ J.∨-cong Eq.refl (Eq.sym x∧y≈y) ⟩
   x ∨ (x ∧ y) ≈⟨ ∨-absorbs-∧ _ _ ⟩
   x           ∎
-  where open EqReasoning setoid
+  where open ≈-Reasoning setoid
 
 -- collapsing sublattice
 
@@ -76,7 +75,7 @@ collapse₁ {x} {y} x≈y = begin
   x ∨ y ∎
   where
   y≤x = reflexive (Eq.sym x≈y)
-  open EqReasoning setoid
+  open ≈-Reasoning setoid
 
 -- this can also be proved by quadrilateral argument, but it's much less symmetric.
 collapse₂ : ∀ {x y} → x ∨ y ≤ x ∧ y → x ≈ y
@@ -89,7 +88,7 @@ collapse₂ {x} {y} ∨≤∧ = antisym
          x ∨ y ≤⟨ ∨≤∧ ⟩
          x ∧ y ≤⟨ x∧y≤x _ _ ⟩
          x     ∎)
-  where open POR poset
+  where open ≤-Reasoning poset
 
 ------------------------------------------------------------------------
 -- The dual construction is also a lattice.
diff --git a/src/Relation/Binary/Lattice/Properties/MeetSemilattice.agda b/src/Relation/Binary/Lattice/Properties/MeetSemilattice.agda
index 34e4252f92..f8fca492b7 100644
--- a/src/Relation/Binary/Lattice/Properties/MeetSemilattice.agda
+++ b/src/Relation/Binary/Lattice/Properties/MeetSemilattice.agda
@@ -14,9 +14,9 @@ module Relation.Binary.Lattice.Properties.MeetSemilattice
 open MeetSemilattice M
 
 open import Algebra.Definitions _≈_
-open import Data.Product
 open import Function.Base using (flip)
-open import Relation.Binary
+open import Relation.Binary.Structures using (IsDecPartialOrder)
+open import Relation.Binary.Definitions using (Decidable)
 open import Relation.Binary.Properties.Poset poset
 import Relation.Binary.Lattice.Properties.JoinSemilattice as J
 
@@ -35,7 +35,7 @@ dualJoinSemilattice = record
   }
 
 open J dualJoinSemilattice public
-  using (isAlgSemilattice; algSemilattice; isPosemigroup; posemigroup)
+  using (isAlgSemilattice; algSemilattice)
   renaming
     ( ∨-monotonic  to ∧-monotonic
     ; ∨-cong       to ∧-cong
diff --git a/src/Relation/Binary/Lattice/Structures.agda b/src/Relation/Binary/Lattice/Structures.agda
index 10178af05d..77d9604167 100644
--- a/src/Relation/Binary/Lattice/Structures.agda
+++ b/src/Relation/Binary/Lattice/Structures.agda
@@ -9,7 +9,9 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsPartialOrder)
+open import Relation.Binary.Definitions using (Minimum; Maximum)
 
 module Relation.Binary.Lattice.Structures
  {a ℓ₁ ℓ₂} {A : Set a}
@@ -19,7 +21,7 @@ module Relation.Binary.Lattice.Structures
 
 open import Algebra.Core
 open import Algebra.Definitions
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Level using (suc; _⊔_)
 
 open import Relation.Binary.Lattice.Definitions
diff --git a/src/Relation/Binary/Morphism/Bundles.agda b/src/Relation/Binary/Morphism/Bundles.agda
index 782c6af098..8cd52d3341 100644
--- a/src/Relation/Binary/Morphism/Bundles.agda
+++ b/src/Relation/Binary/Morphism/Bundles.agda
@@ -70,7 +70,7 @@ record PreorderHomomorphism (S₁ : Preorder ℓ₁ ℓ₂ ℓ₃)
   open Preorder
   field
     ⟦_⟧                 : Carrier S₁ → Carrier S₂
-    isOrderHomomorphism : IsOrderHomomorphism (_≈_ S₁) (_≈_ S₂) (_∼_ S₁) (_∼_ S₂) ⟦_⟧
+    isOrderHomomorphism : IsOrderHomomorphism (_≈_ S₁) (_≈_ S₂) (_≲_ S₁) (_≲_ S₂) ⟦_⟧
 
   open IsOrderHomomorphism isOrderHomomorphism public
 
@@ -92,8 +92,8 @@ module _ (P : Poset ℓ₁ ℓ₂ ℓ₃) (Q : Poset ℓ₄ ℓ₅ ℓ₆) where
     open IsOrderHomomorphism isOrderHomomorphism public
 
 
-  -- Smart constructor that automatically constructs the congruence proof
-  -- from the monotonicity proof
+  -- Smart constructor that automatically constructs the congruence
+  -- proof from the monotonicity proof
   mkPosetHomo : ∀ f → f Preserves P._≤_ ⟶ Q._≤_ → PosetHomomorphism
   mkPosetHomo f mono = record
     { ⟦_⟧ = f
diff --git a/src/Relation/Binary/Morphism/Construct/Composition.agda b/src/Relation/Binary/Morphism/Construct/Composition.agda
index 202605b608..d86860b6bb 100644
--- a/src/Relation/Binary/Morphism/Construct/Composition.agda
+++ b/src/Relation/Binary/Morphism/Construct/Composition.agda
@@ -9,7 +9,9 @@
 open import Function.Base using (_∘_)
 open import Function.Construct.Composition using (surjective)
 open import Level using (Level)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid; Preorder; Poset)
+open import Relation.Binary.Definitions using (Transitive)
 open import Relation.Binary.Morphism.Bundles
 open import Relation.Binary.Morphism.Structures
 
@@ -46,9 +48,9 @@ isRelIsomorphism : Transitive ≈₃ →
                    IsRelIsomorphism ≈₁ ≈₂ f →
                    IsRelIsomorphism ≈₂ ≈₃ g →
                    IsRelIsomorphism ≈₁ ≈₃ (g ∘ f)
-isRelIsomorphism {≈₁ = ≈₁} ≈₃-trans m₁ m₂ = record
+isRelIsomorphism  {≈₃ = ≈₃} ≈₃-trans m₁ m₂ = record
   { isMonomorphism = isRelMonomorphism F.isMonomorphism G.isMonomorphism
-  ; surjective     = surjective ≈₁ _ _ ≈₃-trans G.cong F.surjective G.surjective
+  ; surjective     = surjective _ _ ≈₃ F.surjective G.surjective
   } where module F = IsRelIsomorphism m₁; module G = IsRelIsomorphism m₂
 
 ------------------------------------------------------------------------
@@ -103,9 +105,9 @@ isOrderIsomorphism : Transitive ≈₃ →
                      IsOrderIsomorphism ≈₁ ≈₂ ∼₁ ∼₂ f →
                      IsOrderIsomorphism ≈₂ ≈₃ ∼₂ ∼₃ g →
                      IsOrderIsomorphism ≈₁ ≈₃ ∼₁ ∼₃ (g ∘ f)
-isOrderIsomorphism {≈₁ = ≈₁} ≈₃-trans m₁ m₂ = record
+isOrderIsomorphism {≈₃ = ≈₃}  ≈₃-trans m₁ m₂ = record
   { isOrderMonomorphism = isOrderMonomorphism F.isOrderMonomorphism G.isOrderMonomorphism
-  ; surjective          = surjective ≈₁ _ _ ≈₃-trans G.cong F.surjective G.surjective
+  ; surjective          = surjective _ _ ≈₃ F.surjective G.surjective
   } where module F = IsOrderIsomorphism m₁; module G = IsOrderIsomorphism m₂
 
 ------------------------------------------------------------------------
diff --git a/src/Relation/Binary/Morphism/Construct/Constant.agda b/src/Relation/Binary/Morphism/Construct/Constant.agda
index d31c274bfa..f3a1bd2212 100644
--- a/src/Relation/Binary/Morphism/Construct/Constant.agda
+++ b/src/Relation/Binary/Morphism/Construct/Constant.agda
@@ -8,7 +8,9 @@
 
 open import Function.Base using (const)
 open import Level using (Level)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid; Preorder)
+open import Relation.Binary.Definitions using (Reflexive)
 open import Relation.Binary.Morphism.Structures
 open import Relation.Binary.Morphism.Bundles
 
diff --git a/src/Relation/Binary/Morphism/Construct/Identity.agda b/src/Relation/Binary/Morphism/Construct/Identity.agda
index c8ed9c6b03..2a11d642ad 100644
--- a/src/Relation/Binary/Morphism/Construct/Identity.agda
+++ b/src/Relation/Binary/Morphism/Construct/Identity.agda
@@ -6,10 +6,13 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (id)
+import Function.Construct.Identity as Id
 open import Level using (Level)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid; Preorder; Poset)
+open import Relation.Binary.Definitions using (Reflexive)
 open import Relation.Binary.Morphism.Structures
 open import Relation.Binary.Morphism.Bundles
 
@@ -29,19 +32,19 @@ module _ (≈ : Rel A ℓ₁) where
 
   isRelHomomorphism : IsRelHomomorphism ≈ ≈ id
   isRelHomomorphism = record
-    { cong = id
+    { cong = Id.congruent ≈
     }
 
   isRelMonomorphism : IsRelMonomorphism ≈ ≈ id
   isRelMonomorphism = record
     { isHomomorphism = isRelHomomorphism
-    ; injective      = id
+    ; injective      = Id.injective ≈
     }
 
   isRelIsomorphism : Reflexive ≈ → IsRelIsomorphism ≈ ≈ id
   isRelIsomorphism refl = record
     { isMonomorphism = isRelMonomorphism
-    ; surjective     = λ y → y , refl
+    ; surjective     = Id.surjective ≈
     }
 
 ------------------------------------------------------------------------
@@ -76,14 +79,14 @@ module _ (≈ : Rel A ℓ₁) (∼ : Rel A ℓ₂) where
   isOrderMonomorphism : IsOrderMonomorphism ≈ ≈ ∼ ∼ id
   isOrderMonomorphism = record
     { isOrderHomomorphism = isOrderHomomorphism
-    ; injective           = id
+    ; injective           = Id.injective ≈
     ; cancel              = id
     }
 
   isOrderIsomorphism : Reflexive ≈ → IsOrderIsomorphism ≈ ≈ ∼ ∼ id
   isOrderIsomorphism refl = record
     { isOrderMonomorphism = isOrderMonomorphism
-    ; surjective          = λ y → y , refl
+    ; surjective          = Id.surjective ≈
     }
 
 ------------------------------------------------------------------------
diff --git a/src/Relation/Binary/Morphism/OrderMonomorphism.agda b/src/Relation/Binary/Morphism/OrderMonomorphism.agda
index dd2e0ef821..12a80d1f31 100644
--- a/src/Relation/Binary/Morphism/OrderMonomorphism.agda
+++ b/src/Relation/Binary/Morphism/OrderMonomorphism.agda
@@ -11,17 +11,21 @@
 
 open import Algebra.Morphism.Definitions
 open import Function.Base
-open import Data.Product using (_,_; map)
-open import Relation.Binary
+open import Data.Product.Base using (_,_; map)
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Structures
+  using (IsPreorder; IsPartialOrder; IsTotalOrder; IsDecTotalOrder; IsStrictPartialOrder; IsStrictTotalOrder)
+open import Relation.Binary.Definitions
+  using (Irreflexive; Antisymmetric; Trichotomous; tri<; tri≈; tri>; _Respectsˡ_; _Respectsʳ_; _Respects₂_)
 open import Relation.Binary.Morphism
 import Relation.Binary.Morphism.RelMonomorphism as RawRelation
 
 module Relation.Binary.Morphism.OrderMonomorphism
   {a b ℓ₁ ℓ₂ ℓ₃ ℓ₄} {A : Set a} {B : Set b}
   {_≈₁_ : Rel A ℓ₁} {_≈₂_ : Rel B ℓ₃}
-  {_∼₁_ : Rel A ℓ₂} {_∼₂_ : Rel B ℓ₄}
+  {_≲₁_ : Rel A ℓ₂} {_≲₂_ : Rel B ℓ₄}
   {⟦_⟧ : A → B}
-  (isOrderMonomorphism : IsOrderMonomorphism _≈₁_ _≈₂_ _∼₁_ _∼₂_ ⟦_⟧)
+  (isOrderMonomorphism : IsOrderMonomorphism _≈₁_ _≈₂_ _≲₁_ _≲₂_ ⟦_⟧)
   where
 
 open IsOrderMonomorphism isOrderMonomorphism
@@ -36,61 +40,61 @@ open RawRelation isRelMonomorphism public
 ------------------------------------------------------------------------
 -- Properties
 
-reflexive : _≈₂_ ⇒ _∼₂_ → _≈₁_ ⇒ _∼₁_
+reflexive : _≈₂_ ⇒ _≲₂_ → _≈₁_ ⇒ _≲₁_
 reflexive refl x≈y = cancel (refl (cong x≈y))
 
-irrefl : Irreflexive _≈₂_ _∼₂_ → Irreflexive _≈₁_ _∼₁_
+irrefl : Irreflexive _≈₂_ _≲₂_ → Irreflexive _≈₁_ _≲₁_
 irrefl irrefl x≈y x∼y = irrefl (cong x≈y) (mono x∼y)
 
-antisym : Antisymmetric _≈₂_ _∼₂_ → Antisymmetric _≈₁_ _∼₁_
+antisym : Antisymmetric _≈₂_ _≲₂_ → Antisymmetric _≈₁_ _≲₁_
 antisym antisym x∼y y∼x = injective (antisym (mono x∼y) (mono y∼x))
 
-compare : Trichotomous _≈₂_ _∼₂_ → Trichotomous _≈₁_ _∼₁_
+compare : Trichotomous _≈₂_ _≲₂_ → Trichotomous _≈₁_ _≲₁_
 compare compare x y with compare ⟦ x ⟧ ⟦ y ⟧
 ... | tri< a ¬b ¬c = tri< (cancel a) (¬b ∘ cong) (¬c ∘ mono)
 ... | tri≈ ¬a b ¬c = tri≈ (¬a ∘ mono) (injective b) (¬c ∘ mono)
 ... | tri> ¬a ¬b c = tri> (¬a ∘ mono) (¬b ∘ cong) (cancel c)
 
-respˡ : _∼₂_ Respectsˡ _≈₂_ → _∼₁_ Respectsˡ _≈₁_
+respˡ : _≲₂_ Respectsˡ _≈₂_ → _≲₁_ Respectsˡ _≈₁_
 respˡ resp x≈y x∼z = cancel (resp (cong x≈y) (mono x∼z))
 
-respʳ : _∼₂_ Respectsʳ _≈₂_ → _∼₁_ Respectsʳ _≈₁_
+respʳ : _≲₂_ Respectsʳ _≈₂_ → _≲₁_ Respectsʳ _≈₁_
 respʳ resp x≈y y∼z = cancel (resp (cong x≈y) (mono y∼z))
 
-resp : _∼₂_ Respects₂ _≈₂_ → _∼₁_ Respects₂ _≈₁_
+resp : _≲₂_ Respects₂ _≈₂_ → _≲₁_ Respects₂ _≈₁_
 resp = map respʳ respˡ
 
 ------------------------------------------------------------------------
 -- Structures
 
-isPreorder : IsPreorder _≈₂_ _∼₂_ → IsPreorder _≈₁_ _∼₁_
+isPreorder : IsPreorder _≈₂_ _≲₂_ → IsPreorder _≈₁_ _≲₁_
 isPreorder O = record
   { isEquivalence = EqM.isEquivalence O.isEquivalence
   ; reflexive     = reflexive O.reflexive
   ; trans         = trans O.trans
   } where module O = IsPreorder O
 
-isPartialOrder : IsPartialOrder _≈₂_ _∼₂_ → IsPartialOrder _≈₁_ _∼₁_
+isPartialOrder : IsPartialOrder _≈₂_ _≲₂_ → IsPartialOrder _≈₁_ _≲₁_
 isPartialOrder O = record
   { isPreorder = isPreorder O.isPreorder
   ; antisym    = antisym O.antisym
   } where module O = IsPartialOrder O
 
-isTotalOrder : IsTotalOrder _≈₂_ _∼₂_ → IsTotalOrder _≈₁_ _∼₁_
+isTotalOrder : IsTotalOrder _≈₂_ _≲₂_ → IsTotalOrder _≈₁_ _≲₁_
 isTotalOrder O = record
   { isPartialOrder = isPartialOrder O.isPartialOrder
   ; total          = total O.total
   } where module O = IsTotalOrder O
 
-isDecTotalOrder : IsDecTotalOrder _≈₂_ _∼₂_ → IsDecTotalOrder _≈₁_ _∼₁_
+isDecTotalOrder : IsDecTotalOrder _≈₂_ _≲₂_ → IsDecTotalOrder _≈₁_ _≲₁_
 isDecTotalOrder O = record
   { isTotalOrder = isTotalOrder O.isTotalOrder
   ; _≟_          = EqM.dec O._≟_
   ; _≤?_         = dec O._≤?_
   } where module O = IsDecTotalOrder O
 
-isStrictPartialOrder : IsStrictPartialOrder _≈₂_ _∼₂_ →
-                       IsStrictPartialOrder _≈₁_ _∼₁_
+isStrictPartialOrder : IsStrictPartialOrder _≈₂_ _≲₂_ →
+                       IsStrictPartialOrder _≈₁_ _≲₁_
 isStrictPartialOrder O = record
   { isEquivalence = EqM.isEquivalence O.isEquivalence
   ; irrefl        = irrefl O.irrefl
@@ -98,10 +102,9 @@ isStrictPartialOrder O = record
   ; <-resp-≈      = resp O.<-resp-≈
   } where module O = IsStrictPartialOrder O
 
-isStrictTotalOrder : IsStrictTotalOrder _≈₂_ _∼₂_ →
-                     IsStrictTotalOrder _≈₁_ _∼₁_
+isStrictTotalOrder : IsStrictTotalOrder _≈₂_ _≲₂_ →
+                     IsStrictTotalOrder _≈₁_ _≲₁_
 isStrictTotalOrder O = record
-  { isEquivalence = EqM.isEquivalence O.isEquivalence
-  ; trans         = trans O.trans
-  ; compare       = compare O.compare
+  { isStrictPartialOrder = isStrictPartialOrder O.isStrictPartialOrder
+  ; compare              = compare O.compare
   } where module O = IsStrictTotalOrder O
diff --git a/src/Relation/Binary/Morphism/RelMonomorphism.agda b/src/Relation/Binary/Morphism/RelMonomorphism.agda
index e500fa4368..73a873fae5 100644
--- a/src/Relation/Binary/Morphism/RelMonomorphism.agda
+++ b/src/Relation/Binary/Morphism/RelMonomorphism.agda
@@ -10,7 +10,10 @@
 {-# OPTIONS --cubical-compatible --safe #-}
 
 open import Function.Base
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsEquivalence; IsDecEquivalence)
+open import Relation.Binary.Definitions
+  using (Reflexive; Symmetric; Transitive; Total; Asymmetric; Decidable)
 open import Relation.Binary.Morphism
 
 module Relation.Binary.Morphism.RelMonomorphism
diff --git a/src/Relation/Binary/Morphism/Structures.agda b/src/Relation/Binary/Morphism/Structures.agda
index 39a333e1b7..081008fbd1 100644
--- a/src/Relation/Binary/Morphism/Structures.agda
+++ b/src/Relation/Binary/Morphism/Structures.agda
@@ -6,15 +6,15 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary.Core
+open import Relation.Binary.Core using (Rel)
 
 module Relation.Binary.Morphism.Structures
   {a b} {A : Set a} {B : Set b}
   where
 
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Definitions
-open import Level
+open import Level using (Level; _⊔_)
 open import Relation.Binary.Morphism.Definitions A B
 
 private
@@ -57,29 +57,29 @@ record IsRelIsomorphism (_∼₁_ : Rel A ℓ₁) (_∼₂_ : Rel B ℓ₂)
 ------------------------------------------------------------------------
 
 record IsOrderHomomorphism (_≈₁_ : Rel A ℓ₁) (_≈₂_ : Rel B ℓ₂)
-                           (_∼₁_ : Rel A ℓ₃) (_∼₂_ : Rel B ℓ₄)
+                           (_≲₁_ : Rel A ℓ₃) (_≲₂_ : Rel B ℓ₄)
                            (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄)
                            where
   field
     cong  : Homomorphic₂ _≈₁_ _≈₂_ ⟦_⟧
-    mono  : Homomorphic₂ _∼₁_ _∼₂_ ⟦_⟧
+    mono  : Homomorphic₂ _≲₁_ _≲₂_ ⟦_⟧
 
   module Eq where
     isRelHomomorphism : IsRelHomomorphism _≈₁_ _≈₂_ ⟦_⟧
     isRelHomomorphism = record { cong = cong }
 
-  isRelHomomorphism : IsRelHomomorphism _∼₁_ _∼₂_ ⟦_⟧
+  isRelHomomorphism : IsRelHomomorphism _≲₁_ _≲₂_ ⟦_⟧
   isRelHomomorphism = record { cong = mono }
 
 
 record IsOrderMonomorphism (_≈₁_ : Rel A ℓ₁) (_≈₂_ : Rel B ℓ₂)
-                           (_∼₁_ : Rel A ℓ₃) (_∼₂_ : Rel B ℓ₄)
+                           (_≲₁_ : Rel A ℓ₃) (_≲₂_ : Rel B ℓ₄)
                            (⟦_⟧ : A → B) : Set (a ⊔ ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄)
                            where
   field
-    isOrderHomomorphism : IsOrderHomomorphism _≈₁_ _≈₂_ _∼₁_ _∼₂_ ⟦_⟧
+    isOrderHomomorphism : IsOrderHomomorphism _≈₁_ _≈₂_ _≲₁_ _≲₂_ ⟦_⟧
     injective           : Injective _≈₁_ _≈₂_ ⟦_⟧
-    cancel              : Injective _∼₁_ _∼₂_ ⟦_⟧
+    cancel              : Injective _≲₁_ _≲₂_ ⟦_⟧
 
   open IsOrderHomomorphism isOrderHomomorphism public
     hiding (module Eq)
@@ -91,7 +91,7 @@ record IsOrderMonomorphism (_≈₁_ : Rel A ℓ₁) (_≈₂_ : Rel B ℓ₂)
       ; injective      = injective
       }
 
-  isRelMonomorphism : IsRelMonomorphism _∼₁_ _∼₂_ ⟦_⟧
+  isRelMonomorphism : IsRelMonomorphism _≲₁_ _≲₂_ ⟦_⟧
   isRelMonomorphism = record
     { isHomomorphism = isRelHomomorphism
     ; injective      = cancel
@@ -99,11 +99,11 @@ record IsOrderMonomorphism (_≈₁_ : Rel A ℓ₁) (_≈₂_ : Rel B ℓ₂)
 
 
 record IsOrderIsomorphism (_≈₁_ : Rel A ℓ₁) (_≈₂_ : Rel B ℓ₂)
-                          (_∼₁_ : Rel A ℓ₃) (_∼₂_ : Rel B ℓ₄)
+                          (_≲₁_ : Rel A ℓ₃) (_≲₂_ : Rel B ℓ₄)
                           (⟦_⟧ : A → B) : Set (a ⊔ b ⊔ ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃ ⊔ ℓ₄)
                           where
   field
-    isOrderMonomorphism : IsOrderMonomorphism _≈₁_ _≈₂_ _∼₁_ _∼₂_ ⟦_⟧
+    isOrderMonomorphism : IsOrderMonomorphism _≈₁_ _≈₂_ _≲₁_ _≲₂_ ⟦_⟧
     surjective          : Surjective _≈₁_ _≈₂_ ⟦_⟧
 
   open IsOrderMonomorphism isOrderMonomorphism public
diff --git a/src/Relation/Binary/OrderMorphism.agda b/src/Relation/Binary/OrderMorphism.agda
index 9e2cb84ba3..d516d5342e 100644
--- a/src/Relation/Binary/OrderMorphism.agda
+++ b/src/Relation/Binary/OrderMorphism.agda
@@ -14,9 +14,10 @@ module Relation.Binary.OrderMorphism where
 Use Relation.Binary.Reasoning.Morphism instead."
 #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (_=[_]⇒_)
+open import Relation.Binary.Bundles using (Poset; DecTotalOrder)
 open Poset
-import Function as F
+import Function.Base as F
 open import Level
 
 record _⇒-Poset_ {p₁ p₂ p₃ p₄ p₅ p₆}
diff --git a/src/Relation/Binary/Properties/DecSetoid.agda b/src/Relation/Binary/Properties/DecSetoid.agda
new file mode 100644
index 0000000000..7f9b323d85
--- /dev/null
+++ b/src/Relation/Binary/Properties/DecSetoid.agda
@@ -0,0 +1,43 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Every decidable setoid induces tight apartness relation.
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Bundles using (DecSetoid; ApartnessRelation)
+
+module Relation.Binary.Properties.DecSetoid {c ℓ} (S : DecSetoid c ℓ) where
+
+open import Data.Product using (_,_)
+open import Data.Sum using (inj₁; inj₂)
+open import Relation.Binary.Definitions
+  using (Cotransitive; Tight)
+import Relation.Binary.Properties.Setoid as SetoidProperties
+open import Relation.Binary.Structures
+  using (IsApartnessRelation; IsDecEquivalence)
+open import Relation.Nullary.Decidable.Core
+  using (yes; no; decidable-stable)
+
+open DecSetoid S using (_≈_; _≉_; _≟_; setoid; trans)
+open SetoidProperties setoid
+
+≉-cotrans : Cotransitive _≉_
+≉-cotrans {x} {y} x≉y z with x ≟ z | z ≟ y
+... | _ | no z≉y = inj₂ z≉y
+... | no x≉z | _ = inj₁ x≉z
+... | yes x≈z | yes z≈y = inj₁ λ _ → x≉y (trans x≈z z≈y)
+
+≉-isApartnessRelation : IsApartnessRelation _≈_ _≉_
+≉-isApartnessRelation = record
+  { irrefl = ≉-irrefl
+  ; sym = ≉-sym
+  ; cotrans = ≉-cotrans
+  }
+
+≉-apartnessRelation : ApartnessRelation c ℓ ℓ
+≉-apartnessRelation = record { isApartnessRelation = ≉-isApartnessRelation }
+
+≉-tight : Tight _≈_ _≉_
+≉-tight x y = decidable-stable (x ≟ y) , ≉-irrefl
diff --git a/src/Relation/Binary/Properties/DecTotalOrder.agda b/src/Relation/Binary/Properties/DecTotalOrder.agda
index 3a84300690..38df65dc94 100644
--- a/src/Relation/Binary/Properties/DecTotalOrder.agda
+++ b/src/Relation/Binary/Properties/DecTotalOrder.agda
@@ -6,14 +6,17 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Structures
+  using (IsDecTotalOrder; IsStrictTotalOrder)
+open import Relation.Binary.Bundles
+  using (DecTotalOrder; StrictTotalOrder)
 
 module Relation.Binary.Properties.DecTotalOrder
-  {d₁ d₂ d₃} (DT : DecTotalOrder d₁ d₂ d₃) where
+  {d₁ d₂ d₃} (DTO : DecTotalOrder d₁ d₂ d₃) where
 
-open DecTotalOrder DT hiding (trans)
+open DecTotalOrder DTO hiding (trans)
 
-import Relation.Binary.Construct.Converse as Converse
+import Relation.Binary.Construct.Flip.EqAndOrd as EqAndOrd
 import Relation.Binary.Construct.NonStrictToStrict _≈_ _≤_ as ToStrict
 import Relation.Binary.Properties.TotalOrder totalOrder as TotalOrderProperties
 open import Relation.Nullary.Negation using (¬_)
@@ -23,8 +26,7 @@ open import Relation.Nullary.Negation using (¬_)
 
 open TotalOrderProperties public
   using
-  ( _≥_
-  ; ≥-refl
+  ( ≥-refl
   ; ≥-reflexive
   ; ≥-trans
   ; ≥-antisym
@@ -38,7 +40,7 @@ open TotalOrderProperties public
   )
 
 ≥-isDecTotalOrder : IsDecTotalOrder _≈_ _≥_
-≥-isDecTotalOrder = Converse.isDecTotalOrder isDecTotalOrder
+≥-isDecTotalOrder = EqAndOrd.isDecTotalOrder isDecTotalOrder
 
 ≥-decTotalOrder : DecTotalOrder _ _ _
 ≥-decTotalOrder = record
@@ -77,19 +79,18 @@ open TotalOrderProperties public
   }
 
 open StrictTotalOrder <-strictTotalOrder public
-  using () renaming (compare to <-compare)
+  using (_≮_) renaming (compare to <-compare)
 
 ------------------------------------------------------------------------
 -- _≰_ - the negated order
 
 open TotalOrderProperties public
   using
-  ( _≰_
-  ; ≰-respʳ-≈
+  ( ≰-respʳ-≈
   ; ≰-respˡ-≈
   ; ≰⇒>
   ; ≰⇒≥
   )
 
-≮⇒≥ : ∀ {x y} → ¬ (x < y) → y ≤ x
+≮⇒≥ : ∀ {x y} → x ≮ y → y ≤ x
 ≮⇒≥ = ToStrict.≮⇒≥ Eq.sym _≟_ reflexive total
diff --git a/src/Relation/Binary/Properties/HeytingAlgebra.agda b/src/Relation/Binary/Properties/HeytingAlgebra.agda
index f823a5b519..7ec65c0675 100644
--- a/src/Relation/Binary/Properties/HeytingAlgebra.agda
+++ b/src/Relation/Binary/Properties/HeytingAlgebra.agda
@@ -1,199 +1,20 @@
 ------------------------------------------------------------------------
 -- The Agda standard library
 --
--- Properties satisfied by Heyting Algebra
+-- This module is DEPRECATED. Please use
+-- `Relation.Binary.Lattice.Properties.HeytingAlgebra` instead.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary.Lattice
+open import Relation.Binary.Lattice using (HeytingAlgebra)
 
 module Relation.Binary.Properties.HeytingAlgebra
   {c ℓ₁ ℓ₂} (L : HeytingAlgebra c ℓ₁ ℓ₂) where
 
-open HeytingAlgebra L
+open import Relation.Binary.Lattice.Properties.HeytingAlgebra L public
 
-open import Algebra.Core
-open import Algebra.Definitions _≈_
-open import Data.Product using (_,_)
-open import Function.Base using (_$_; flip; _∘_)
-open import Level using (_⊔_)
-open import Relation.Binary
-import Relation.Binary.Reasoning.PartialOrder as POR
-open import Relation.Binary.Lattice.Properties.MeetSemilattice meetSemilattice
-open import Relation.Binary.Lattice.Properties.JoinSemilattice joinSemilattice
-import Relation.Binary.Lattice.Properties.BoundedMeetSemilattice boundedMeetSemilattice as BM
-open import Relation.Binary.Lattice.Properties.Lattice lattice
-open import Relation.Binary.Lattice.Properties.BoundedLattice boundedLattice
-import Relation.Binary.Reasoning.Setoid as EqReasoning
-
-------------------------------------------------------------------------
--- Useful lemmas
-
-⇨-eval : ∀ {x y} → (x ⇨ y) ∧ x ≤ y
-⇨-eval {x} {y} = transpose-∧ refl
-
-swap-transpose-⇨ : ∀ {x y w} → x ∧ w ≤ y → w ≤ x ⇨ y
-swap-transpose-⇨ x∧w≤y = transpose-⇨ $ trans (reflexive $ ∧-comm _ _) x∧w≤y
-
-------------------------------------------------------------------------
--- Properties of exponential
-
-⇨-unit : ∀ {x} → x ⇨ x ≈ ⊤
-⇨-unit = antisym (maximum _) (transpose-⇨ $ reflexive $ BM.identityˡ _)
-
-y≤x⇨y : ∀ {x y} → y ≤ x ⇨ y
-y≤x⇨y = transpose-⇨ (x∧y≤x _ _)
-
-⇨-drop : ∀ {x y} → (x ⇨ y) ∧ y ≈ y
-⇨-drop = antisym (x∧y≤y _ _) (∧-greatest y≤x⇨y refl)
-
-⇨-app : ∀ {x y} → (x ⇨ y) ∧ x ≈ y ∧ x
-⇨-app = antisym (∧-greatest ⇨-eval (x∧y≤y _ _)) (∧-monotonic y≤x⇨y refl)
-
-⇨ʳ-covariant : ∀ {x} → (x ⇨_) Preserves _≤_ ⟶ _≤_
-⇨ʳ-covariant y≤z = transpose-⇨ (trans ⇨-eval y≤z)
-
-⇨ˡ-contravariant : ∀ {x} → (_⇨ x) Preserves (flip _≤_) ⟶ _≤_
-⇨ˡ-contravariant z≤y = transpose-⇨ (trans (∧-monotonic refl z≤y) ⇨-eval)
-
-⇨-relax : _⇨_ Preserves₂ (flip _≤_) ⟶ _≤_ ⟶ _≤_
-⇨-relax {x} {y} {u} {v} y≤x u≤v = begin
-  x ⇨ u ≤⟨ ⇨ʳ-covariant u≤v ⟩
-  x ⇨ v ≤⟨ ⇨ˡ-contravariant y≤x ⟩
-  y ⇨ v ∎
-  where open POR poset
-
-⇨-cong : _⇨_ Preserves₂ _≈_ ⟶ _≈_ ⟶ _≈_
-⇨-cong x≈y u≈v = antisym (⇨-relax (reflexive $ Eq.sym x≈y) (reflexive u≈v))
-                         (⇨-relax (reflexive x≈y) (reflexive $ Eq.sym u≈v))
-
-⇨-applyˡ : ∀ {w x y} → w ≤ x → (x ⇨ y) ∧ w ≤ y
-⇨-applyˡ = transpose-∧ ∘ ⇨ˡ-contravariant
-
-⇨-applyʳ : ∀ {w x y} → w ≤ x → w ∧ (x ⇨ y) ≤ y
-⇨-applyʳ w≤x = trans (reflexive (∧-comm _ _)) (⇨-applyˡ w≤x)
-
-⇨-curry : ∀ {x y z} → x ∧ y ⇨ z ≈ x ⇨ y ⇨ z
-⇨-curry = antisym (transpose-⇨ $ transpose-⇨ $ trans (reflexive $ ∧-assoc _ _ _) ⇨-eval)
-                  (transpose-⇨ $ trans (reflexive $ Eq.sym $ ∧-assoc _ _ _)
-                                       (transpose-∧ $ ⇨-applyˡ refl))
-
-------------------------------------------------------------------------
--- Various proofs of distributivity
-
-∧-distribˡ-∨-≤ : ∀ x y z → x ∧ (y ∨ z) ≤ x ∧ y ∨ x ∧ z
-∧-distribˡ-∨-≤ x y z = trans (reflexive $ ∧-comm _ _)
-  (transpose-∧ $ ∨-least (swap-transpose-⇨ (x≤x∨y _ _)) $ swap-transpose-⇨ (y≤x∨y _ _))
-
-∧-distribˡ-∨-≥ : ∀ x y z → x ∧ y ∨ x ∧ z ≤ x ∧ (y ∨ z)
-∧-distribˡ-∨-≥ x y z = let
-    x∧y≤x , x∧y≤y , _ = infimum x y
-    x∧z≤x , x∧z≤z , _ = infimum x z
-    y≤y∨z , z≤y∨z , _ = supremum y z
-  in ∧-greatest (∨-least x∧y≤x x∧z≤x)
-                (∨-least (trans x∧y≤y y≤y∨z) (trans x∧z≤z z≤y∨z))
-
-∧-distribˡ-∨ : _∧_ DistributesOverˡ _∨_
-∧-distribˡ-∨ x y z = antisym (∧-distribˡ-∨-≤ x y z) (∧-distribˡ-∨-≥ x y z)
-
-⇨-distribˡ-∧-≤ : ∀ x y z → x ⇨ y ∧ z ≤ (x ⇨ y) ∧ (x ⇨ z)
-⇨-distribˡ-∧-≤ x y z = let
-     y∧z≤y , y∧z≤z , _ = infimum y z
-   in ∧-greatest (transpose-⇨ $ trans ⇨-eval y∧z≤y)
-                 (transpose-⇨ $ trans ⇨-eval y∧z≤z)
-
-⇨-distribˡ-∧-≥ : ∀ x y z → (x ⇨ y) ∧ (x ⇨ z) ≤ x ⇨ y ∧ z
-⇨-distribˡ-∧-≥ x y z = transpose-⇨ (begin
-  (((x ⇨ y) ∧ (x ⇨ z)) ∧ x)      ≈⟨ ∧-cong Eq.refl $ Eq.sym $ ∧-idempotent _ ⟩
-  (((x ⇨ y) ∧ (x ⇨ z)) ∧ x  ∧ x) ≈⟨ Eq.sym $ ∧-assoc _ _ _ ⟩
-  (((x ⇨ y) ∧ (x ⇨ z)) ∧ x) ∧ x  ≈⟨ ∧-cong (∧-assoc _ _ _) Eq.refl ⟩
-  (((x ⇨ y) ∧ (x ⇨ z)  ∧ x) ∧ x) ≈⟨ ∧-cong (∧-cong Eq.refl $ ∧-comm _ _) Eq.refl ⟩
-  (((x ⇨ y) ∧ x  ∧ (x ⇨ z)) ∧ x) ≈⟨ ∧-cong (Eq.sym $ ∧-assoc _ _ _) Eq.refl ⟩
-  (((x ⇨ y) ∧ x) ∧ (x ⇨ z)) ∧ x  ≈⟨ ∧-assoc _ _ _ ⟩
-  (((x ⇨ y) ∧ x) ∧ (x ⇨ z)  ∧ x) ≤⟨ ∧-monotonic ⇨-eval ⇨-eval ⟩
-  y ∧ z                          ∎)
-  where open POR poset
-
-⇨-distribˡ-∧ : _⇨_ DistributesOverˡ _∧_
-⇨-distribˡ-∧ x y z = antisym (⇨-distribˡ-∧-≤ x y z) (⇨-distribˡ-∧-≥ x y z)
-
-⇨-distribˡ-∨-∧-≤ : ∀ x y z → x ∨ y ⇨ z ≤ (x ⇨ z) ∧ (y ⇨ z)
-⇨-distribˡ-∨-∧-≤ x y z = let x≤x∨y , y≤x∨y , _ = supremum x y
-   in ∧-greatest (transpose-⇨ $ trans (∧-monotonic refl x≤x∨y) ⇨-eval)
-                 (transpose-⇨ $ trans (∧-monotonic refl y≤x∨y) ⇨-eval)
-
-⇨-distribˡ-∨-∧-≥ : ∀ x y z → (x ⇨ z) ∧ (y ⇨ z) ≤ x ∨ y ⇨ z
-⇨-distribˡ-∨-∧-≥ x y z = transpose-⇨ (trans (reflexive $ ∧-distribˡ-∨ _ _ _)
-  (∨-least (trans (transpose-∧ (x∧y≤x _ _)) refl)
-           (trans (transpose-∧ (x∧y≤y _ _)) refl)))
-
-⇨-distribˡ-∨-∧ : ∀ x y z → x ∨ y ⇨ z ≈ (x ⇨ z) ∧ (y ⇨ z)
-⇨-distribˡ-∨-∧ x y z = antisym (⇨-distribˡ-∨-∧-≤ x y z) (⇨-distribˡ-∨-∧-≥ x y z)
-
-------------------------------------------------------------------------
--- Heyting algebras are distributive lattices
-
-isDistributiveLattice : IsDistributiveLattice _≈_ _≤_ _∨_ _∧_
-isDistributiveLattice = record
-  { isLattice    = isLattice
-  ; ∧-distribˡ-∨ = ∧-distribˡ-∨
-  }
-
-distributiveLattice : DistributiveLattice _ _ _
-distributiveLattice = record
-  { isDistributiveLattice = isDistributiveLattice
-  }
-
-------------------------------------------------------------------------
--- Heyting algebras can define pseudo-complement
-
-infix 8 ¬_
-
-¬_ : Op₁ Carrier
-¬ x = x ⇨ ⊥
-
-x≤¬¬x : ∀ x → x ≤ ¬ ¬ x
-x≤¬¬x x = transpose-⇨ (trans (reflexive (∧-comm _ _)) ⇨-eval)
-
-------------------------------------------------------------------------
--- De-Morgan laws
-
-de-morgan₁ : ∀ x y → ¬ (x ∨ y) ≈ ¬ x ∧ ¬ y
-de-morgan₁ x y = ⇨-distribˡ-∨-∧ _ _ _
-
-de-morgan₂-≤ : ∀ x y → ¬ (x ∧ y) ≤ ¬ ¬ (¬ x ∨ ¬ y)
-de-morgan₂-≤ x y = transpose-⇨ $ begin
-  ¬ (x ∧ y) ∧ ¬ (¬ x ∨ ¬ y)     ≈⟨ ∧-cong ⇨-curry (de-morgan₁ _ _) ⟩
-  (x ⇨ ¬ y) ∧ ¬ ¬ x ∧ ¬ ¬ y     ≈⟨ ∧-cong Eq.refl (∧-comm _ _) ⟩
-  (x ⇨ ¬ y) ∧ ¬ ¬ y ∧ ¬ ¬ x     ≈⟨ Eq.sym $ ∧-assoc _ _ _ ⟩
-  ((x ⇨ ¬ y) ∧ ¬ ¬ y) ∧ ¬ ¬ x   ≤⟨ ⇨-applyʳ $ transpose-⇨ $
-    begin
-      ((x ⇨ ¬ y) ∧ ¬ ¬ y) ∧ x   ≈⟨ ∧-cong (∧-comm _ _) Eq.refl ⟩
-      ((¬ ¬ y) ∧ (x ⇨ ¬ y)) ∧ x ≈⟨ ∧-assoc _ _ _ ⟩
-      (¬ ¬ y) ∧ (x ⇨ ¬ y) ∧ x   ≤⟨ ∧-monotonic refl ⇨-eval ⟩
-      ¬ ¬ y ∧ ¬ y               ≤⟨ ⇨-eval ⟩
-      ⊥                         ∎ ⟩
-  ⊥                             ∎
-  where open POR poset
-
-de-morgan₂-≥ : ∀ x y → ¬ ¬ (¬ x ∨ ¬ y) ≤ ¬ (x ∧ y)
-de-morgan₂-≥ x y = transpose-⇨ $ ⇨-applyˡ $ transpose-⇨ $ begin
-  (x ∧ y) ∧ (¬ x ∨ ¬ y)         ≈⟨ ∧-distribˡ-∨ _ _ _ ⟩
-  (x ∧ y) ∧ ¬ x ∨ (x ∧ y) ∧ ¬ y ≤⟨ ∨-monotonic (⇨-applyʳ (x∧y≤x _ _))
-                                               (⇨-applyʳ (x∧y≤y _ _)) ⟩
-  ⊥ ∨ ⊥                         ≈⟨ ∨-idempotent _ ⟩
-  ⊥                             ∎
-  where open POR poset
-
-de-morgan₂ : ∀ x y → ¬ (x ∧ y) ≈ ¬ ¬ (¬ x ∨ ¬ y)
-de-morgan₂ x y = antisym (de-morgan₂-≤ x y) (de-morgan₂-≥ x y)
-
-weak-lem : ∀ {x} → ¬ ¬ (¬ x ∨ x) ≈ ⊤
-weak-lem {x} = begin
-  ¬ ¬ (¬ x ∨ x)   ≈⟨ ⇨-cong (de-morgan₁ _ _) Eq.refl ⟩
-  ¬ (¬ ¬ x ∧ ¬ x) ≈⟨ ⇨-cong ⇨-app Eq.refl ⟩
-  ⊥ ∧ (x ⇨ ⊥) ⇨ ⊥ ≈⟨ ⇨-cong (∧-zeroˡ _) Eq.refl ⟩
-  ⊥ ⇨ ⊥           ≈⟨ ⇨-unit ⟩
-  ⊤               ∎
-  where open EqReasoning setoid
+{-# WARNING_ON_IMPORT
+"Relation.Binary.Properties.HeytingAlgebra was deprecated in v2.0.
+Use Relation.Binary.Lattice.Properties.HeytingAlgebra instead."
+#-}
diff --git a/src/Relation/Binary/Properties/Poset.agda b/src/Relation/Binary/Properties/Poset.agda
index 5d1d6e9fe8..d25f3af79a 100644
--- a/src/Relation/Binary/Properties/Poset.agda
+++ b/src/Relation/Binary/Properties/Poset.agda
@@ -6,8 +6,14 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
+open import Data.Product.Base using (_,_)
 open import Function.Base using (flip; _∘_)
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _Preserves_⟶_)
+open import Relation.Binary.Bundles using (Poset; StrictPartialOrder)
+open import Relation.Binary.Structures
+  using (IsPartialOrder; IsStrictPartialOrder; IsDecPartialOrder)
+open import Relation.Binary.Definitions
+  using (_Respectsˡ_; _Respectsʳ_; Decidable)
 import Relation.Binary.Consequences as Consequences
 open import Relation.Nullary using (¬_; yes; no)
 open import Relation.Nullary.Negation using (contradiction)
@@ -24,11 +30,6 @@ open Eq using (_≉_)
 ------------------------------------------------------------------------
 -- The _≥_ relation is also a poset.
 
-infix 4 _≥_
-
-_≥_ : Rel A p₃
-x ≥ y = y ≤ x
-
 open PreorderProperties public
   using () renaming
   ( converse-isPreorder to ≥-isPreorder
@@ -57,11 +58,6 @@ open Poset ≥-poset public
 ------------------------------------------------------------------------
 -- Negated order
 
-infix 4 _≰_
-
-_≰_ : Rel A p₃
-x ≰ y = ¬ (x ≤ y)
-
 ≰-respˡ-≈ : _≰_ Respectsˡ _≈_
 ≰-respˡ-≈ x≈y = _∘ ≤-respˡ-≈ (Eq.sym x≈y)
 
@@ -85,7 +81,7 @@ _<_ = ToStrict._<_
   }
 
 open StrictPartialOrder <-strictPartialOrder public
-  using ( <-resp-≈; <-respʳ-≈; <-respˡ-≈)
+  using (_≮_; <-resp-≈; <-respʳ-≈; <-respˡ-≈)
   renaming
   ( irrefl to <-irrefl
   ; asym   to <-asym
@@ -98,10 +94,10 @@ open StrictPartialOrder <-strictPartialOrder public
 ≤∧≉⇒< : ∀ {x y} → x ≤ y → x ≉ y → x < y
 ≤∧≉⇒< = ToStrict.≤∧≉⇒<
 
-<⇒≱ : ∀ {x y} → x < y → ¬ (y ≤ x)
+<⇒≱ : ∀ {x y} → x < y → y ≰ x
 <⇒≱ = ToStrict.<⇒≱ antisym
 
-≤⇒≯ : ∀ {x y} → x ≤ y → ¬ (y < x)
+≤⇒≯ : ∀ {x y} → x ≤ y → y ≮ x
 ≤⇒≯ = ToStrict.≤⇒≯ antisym
 
 ------------------------------------------------------------------------
diff --git a/src/Relation/Binary/Properties/Preorder.agda b/src/Relation/Binary/Properties/Preorder.agda
index a6a8c196a0..93ff3ba71e 100644
--- a/src/Relation/Binary/Properties/Preorder.agda
+++ b/src/Relation/Binary/Properties/Preorder.agda
@@ -6,36 +6,38 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Preorder; Setoid)
+open import Relation.Binary.Structures using (IsPreorder)
 
 module Relation.Binary.Properties.Preorder
   {p₁ p₂ p₃} (P : Preorder p₁ p₂ p₃) where
 
-open import Function.Base
-open import Data.Product as Prod
-import Relation.Binary.Construct.Converse as Converse
+open import Function.Base using (flip)
+open import Data.Product.Base as Product using (_×_; _,_; swap)
+import Relation.Binary.Construct.Flip.EqAndOrd as EqAndOrd
 
 open Preorder P
 
+
 ------------------------------------------------------------------------
--- The inverse relation is also a preorder.
+-- The converse relation is also a preorder.
 
-converse-isPreorder : IsPreorder _≈_ (flip _∼_)
-converse-isPreorder = Converse.isPreorder isPreorder
+converse-isPreorder : IsPreorder _≈_ _≳_
+converse-isPreorder = EqAndOrd.isPreorder isPreorder
 
 converse-preorder : Preorder p₁ p₂ p₃
-converse-preorder = Converse.preorder P
+converse-preorder = EqAndOrd.preorder P
 
 ------------------------------------------------------------------------
 -- For every preorder there is an induced equivalence
 
 InducedEquivalence : Setoid _ _
 InducedEquivalence = record
-  { _≈_           = λ x y → x ∼ y × y ∼ x
+  { _≈_           = λ x y → x ≲ y × x ≳ y
   ; isEquivalence = record
     { refl  = (refl , refl)
     ; sym   = swap
-    ; trans = Prod.zip trans (flip trans)
+    ; trans = Product.zip trans (flip trans)
     }
   }
 
diff --git a/src/Relation/Binary/Properties/Setoid.agda b/src/Relation/Binary/Properties/Setoid.agda
index 137641d49b..43dc7e67d0 100644
--- a/src/Relation/Binary/Properties/Setoid.agda
+++ b/src/Relation/Binary/Properties/Setoid.agda
@@ -1,32 +1,37 @@
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The Agda standard library
 --
 -- Additional properties for setoids
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (_∘_; id; _$_; flip)
-open import Relation.Nullary.Negation using (¬_)
-open import Relation.Binary.PropositionalEquality.Core as P using (_≡_)
-open import Relation.Binary
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Binary.Bundles using (Setoid; Preorder; Poset)
+open import Relation.Binary.Definitions
+  using (Symmetric; _Respectsˡ_; _Respectsʳ_; _Respects₂_; Irreflexive)
+open import Relation.Binary.Structures using (IsPreorder; IsPartialOrder)
+open import Relation.Binary.Construct.Composition
+  using (_;_; impliesˡ; transitive⇒≈;≈⊆≈)
 
 module Relation.Binary.Properties.Setoid {a ℓ} (S : Setoid a ℓ) where
 
 open Setoid S
 
-
-------------------------------------------------------------------------------
--- Every setoid is a preorder and partial order with respect to propositional
--- equality
+------------------------------------------------------------------------
+-- Every setoid is a preorder and partial order with respect to
+-- propositional equality
 
 isPreorder : IsPreorder _≡_ _≈_
 isPreorder = record
   { isEquivalence = record
-    { refl  = P.refl
-    ; sym   = P.sym
-    ; trans = P.trans
+    { refl  = ≡.refl
+    ; sym   = ≡.sym
+    ; trans = ≡.trans
     }
   ; reflexive     = reflexive
   ; trans         = trans
@@ -60,7 +65,7 @@ preorder = record
   { isPartialOrder = ≈-isPartialOrder
   }
 
-------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Properties of _≉_
 
 ≉-sym :  Symmetric _≉_
@@ -75,7 +80,19 @@ preorder = record
 ≉-resp₂ : _≉_ Respects₂ _≈_
 ≉-resp₂ = ≉-respʳ , ≉-respˡ
 
-------------------------------------------------------------------------------
+≉-irrefl : Irreflexive _≈_ _≉_
+≉-irrefl x≈y x≉y = contradiction x≈y x≉y
+
+------------------------------------------------------------------------
+-- Equality is closed under composition
+
+≈;≈⇒≈ : _≈_ ; _≈_ ⇒ _≈_
+≈;≈⇒≈ = transitive⇒≈;≈⊆≈ _ trans
+
+≈⇒≈;≈ : _≈_ ⇒ _≈_ ; _≈_
+≈⇒≈;≈ = impliesˡ _≈_ _≈_ refl id
+
+------------------------------------------------------------------------
 -- Other properties
 
 respʳ-flip : _≈_ Respectsʳ (flip _≈_)
diff --git a/src/Relation/Binary/Properties/StrictPartialOrder.agda b/src/Relation/Binary/Properties/StrictPartialOrder.agda
index d907fd75d4..680323c770 100644
--- a/src/Relation/Binary/Properties/StrictPartialOrder.agda
+++ b/src/Relation/Binary/Properties/StrictPartialOrder.agda
@@ -6,21 +6,21 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (StrictPartialOrder; Poset)
 
 module Relation.Binary.Properties.StrictPartialOrder
        {s₁ s₂ s₃} (SPO : StrictPartialOrder s₁ s₂ s₃) where
 
-import Relation.Binary.Construct.Converse as Converse
+import Relation.Binary.Construct.Flip.EqAndOrd as EqAndOrd
 import Relation.Binary.Construct.StrictToNonStrict
 
-open Relation.Binary.StrictPartialOrder SPO
+open StrictPartialOrder SPO
 
 ------------------------------------------------------------------------
--- The inverse relation is also a strict partial order.
+-- The converse relation is also a strict partial order.
 
 >-strictPartialOrder : StrictPartialOrder s₁ s₂ s₃
->-strictPartialOrder = Converse.strictPartialOrder SPO
+>-strictPartialOrder = EqAndOrd.strictPartialOrder SPO
 
 open StrictPartialOrder >-strictPartialOrder public
   using ()
diff --git a/src/Relation/Binary/Properties/StrictTotalOrder.agda b/src/Relation/Binary/Properties/StrictTotalOrder.agda
index ab82e8ea54..e6d34ab8d1 100644
--- a/src/Relation/Binary/Properties/StrictTotalOrder.agda
+++ b/src/Relation/Binary/Properties/StrictTotalOrder.agda
@@ -6,19 +6,19 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (StrictTotalOrder; DecTotalOrder)
 
 module Relation.Binary.Properties.StrictTotalOrder
        {s₁ s₂ s₃} (STO : StrictTotalOrder s₁ s₂ s₃)
        where
 
-open Relation.Binary.StrictTotalOrder STO
+open StrictTotalOrder STO
 open import Relation.Binary.Construct.StrictToNonStrict _≈_ _<_
 import Relation.Binary.Properties.StrictPartialOrder as SPO
 open import Relation.Binary.Consequences
 
 ------------------------------------------------------------------------
--- _<_ - the strict version is a strict total order
+-- _<_ - the strict version is a decidable total order
 
 decTotalOrder : DecTotalOrder _ _ _
 decTotalOrder = record
diff --git a/src/Relation/Binary/Properties/TotalOrder.agda b/src/Relation/Binary/Properties/TotalOrder.agda
index 58964e71a3..b949f9b361 100644
--- a/src/Relation/Binary/Properties/TotalOrder.agda
+++ b/src/Relation/Binary/Properties/TotalOrder.agda
@@ -6,21 +6,21 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (TotalOrder; DecTotalOrder)
+open import Relation.Binary.Definitions using (Decidable)
+open import Relation.Binary.Structures using (IsTotalOrder)
 
 module Relation.Binary.Properties.TotalOrder
   {t₁ t₂ t₃} (T : TotalOrder t₁ t₂ t₃) where
 
 open TotalOrder T
 
-open import Data.Product using (proj₁)
+open import Data.Product.Base using (proj₁)
 open import Data.Sum.Base using (inj₁; inj₂)
-import Relation.Binary.Construct.Converse as Converse
+import Relation.Binary.Construct.Flip.EqAndOrd as EqAndOrd
 import Relation.Binary.Construct.NonStrictToStrict _≈_ _≤_ as ToStrict
 import Relation.Binary.Properties.Poset poset as PosetProperties
 open import Relation.Binary.Consequences
-open import Relation.Nullary.Negation using (¬_)
-open import Relation.Nullary.Negation using (contradiction)
 
 ------------------------------------------------------------------------
 -- Total orders are almost decidable total orders
@@ -39,8 +39,7 @@ decTotalOrder ≟ = record
 
 open PosetProperties public
   using
-  ( _≥_
-  ; ≥-refl
+  ( ≥-refl
   ; ≥-reflexive
   ; ≥-trans
   ; ≥-antisym
@@ -51,7 +50,7 @@ open PosetProperties public
   )
 
 ≥-isTotalOrder : IsTotalOrder _≈_ _≥_
-≥-isTotalOrder = Converse.isTotalOrder isTotalOrder
+≥-isTotalOrder = EqAndOrd.isTotalOrder isTotalOrder
 
 ≥-totalOrder : TotalOrder _ _ _
 ≥-totalOrder = record
@@ -90,8 +89,7 @@ open PosetProperties public
 
 open PosetProperties public
   using
-  ( _≰_
-  ; ≰-respʳ-≈
+  ( ≰-respʳ-≈
   ; ≰-respˡ-≈
   )
 
diff --git a/src/Relation/Binary/PropositionalEquality.agda b/src/Relation/Binary/PropositionalEquality.agda
index c9e2d102fd..55b7d30926 100644
--- a/src/Relation/Binary/PropositionalEquality.agda
+++ b/src/Relation/Binary/PropositionalEquality.agda
@@ -8,16 +8,15 @@
 
 module Relation.Binary.PropositionalEquality where
 
-import Axiom.Extensionality.Propositional as Ext
 open import Axiom.UniquenessOfIdentityProofs
 open import Function.Base using (id; _∘_)
-open import Function.Equality using (Π; _⟶_; ≡-setoid)
+import Function.Dependent.Bundles as Dependent
+open import Function.Indexed.Relation.Binary.Equality using (≡-setoid)
 open import Level using (Level; _⊔_)
-open import Data.Product using (∃)
-
-open import Relation.Nullary.Decidable using (yes; no)
-open import Relation.Nullary.Decidable
-open import Relation.Binary
+open import Relation.Nullary using (Irrelevant)
+open import Relation.Nullary.Decidable using (yes; no; dec-yes-irr; dec-no)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Definitions using (DecidableEquality)
 open import Relation.Binary.Indexed.Heterogeneous
   using (IndexedSetoid)
 import Relation.Binary.Indexed.Heterogeneous.Construct.Trivial
@@ -26,9 +25,7 @@ import Relation.Binary.Indexed.Heterogeneous.Construct.Trivial
 private
   variable
     a b c ℓ p : Level
-    A : Set a
-    B : Set b
-    C : Set c
+    A B C : Set a
 
 ------------------------------------------------------------------------
 -- Re-export contents modules that make up the parts
@@ -40,50 +37,22 @@ open import Relation.Binary.PropositionalEquality.Algebra public
 ------------------------------------------------------------------------
 -- Pointwise equality
 
-infix 4 _≗_
-
 _→-setoid_ : ∀ (A : Set a) (B : Set b) → Setoid _ _
 A →-setoid B = ≡-setoid A (Trivial.indexedSetoid (setoid B))
 
-_≗_ : (f g : A → B) → Set _
-_≗_ {A = A} {B = B} = Setoid._≈_ (A →-setoid B)
-
 :→-to-Π : ∀ {A : Set a} {B : IndexedSetoid A b ℓ} →
-          ((x : A) → IndexedSetoid.Carrier B x) → Π (setoid A) B
+          ((x : A) → IndexedSetoid.Carrier B x) →
+          Dependent.Func (setoid A) B
 :→-to-Π {B = B} f = record
-  { _⟨$⟩_ = f
-  ; cong  = λ { refl → IndexedSetoid.refl B }
+  { to = f
+  ; cong = λ { refl → IndexedSetoid.refl B }
   }
-  where open IndexedSetoid B using (_≈_)
 
 →-to-⟶ : ∀ {A : Set a} {B : Setoid b ℓ} →
-         (A → Setoid.Carrier B) → setoid A ⟶ B
+         (A → Setoid.Carrier B) →
+         Dependent.Func (setoid A) (Trivial.indexedSetoid B)
 →-to-⟶ = :→-to-Π
 
-------------------------------------------------------------------------
--- Inspect
-
--- Inspect can be used when you want to pattern match on the result r
--- of some expression e, and you also need to "remember" that r ≡ e.
-
--- See README.Inspect for an explanation of how/why to use this.
-
-record Reveal_·_is_ {A : Set a} {B : A → Set b}
-                    (f : (x : A) → B x) (x : A) (y : B x) :
-                    Set (a ⊔ b) where
-  constructor [_]
-  field eq : f x ≡ y
-
-inspect : ∀ {A : Set a} {B : A → Set b}
-          (f : (x : A) → B x) (x : A) → Reveal f · x is f x
-inspect f x = [ refl ]
-
-------------------------------------------------------------------------
--- Propositionality
-
-isPropositional : Set a → Set a
-isPropositional A = (a b : A) → a ≡ b
-
 ------------------------------------------------------------------------
 -- More complex rearrangement lemmas
 
@@ -120,3 +89,44 @@ module _ (_≟_ : DecidableEquality A) {x y : A} where
 
   ≢-≟-identity : (x≢y : x ≢ y) → x ≟ y ≡ no x≢y
   ≢-≟-identity = dec-no (x ≟ y)
+
+
+------------------------------------------------------------------------
+-- Inspect
+
+-- Inspect can be used when you want to pattern match on the result r
+-- of some expression e, and you also need to "remember" that r ≡ e.
+
+-- See README.Inspect for an explanation of how/why to use this.
+
+-- Normally (but not always) the new `with ... in` syntax described at
+-- https://agda.readthedocs.io/en/v2.6.4/language/with-abstraction.html#with-abstraction-equality
+-- can be used instead."
+
+record Reveal_·_is_ {A : Set a} {B : A → Set b}
+                    (f : (x : A) → B x) (x : A) (y : B x) :
+                    Set (a ⊔ b) where
+  constructor [_]
+  field eq : f x ≡ y
+
+inspect : ∀ {A : Set a} {B : A → Set b}
+          (f : (x : A) → B x) (x : A) → Reveal f · x is f x
+inspect f x = [ refl ]
+
+
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
+
+isPropositional : Set a → Set a
+isPropositional = Irrelevant
+
+{-# WARNING_ON_USAGE isPropositional
+"Warning: isPropositional was deprecated in v2.0.
+Please use Relation.Nullary.Irrelevant instead. "
+#-}
+
diff --git a/src/Relation/Binary/PropositionalEquality/Algebra.agda b/src/Relation/Binary/PropositionalEquality/Algebra.agda
index 22ac67b298..7e0118bbcb 100644
--- a/src/Relation/Binary/PropositionalEquality/Algebra.agda
+++ b/src/Relation/Binary/PropositionalEquality/Algebra.agda
@@ -8,10 +8,12 @@
 
 module Relation.Binary.PropositionalEquality.Algebra where
 
-open import Algebra
-open import Level
-open import Relation.Binary.PropositionalEquality.Core
-open import Relation.Binary.PropositionalEquality.Properties
+open import Algebra.Bundles using (Magma)
+open import Algebra.Core using (Op₂)
+open import Algebra.Structures using (IsMagma)
+open import Level using (Level)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong₂)
+open import Relation.Binary.PropositionalEquality.Properties using (isEquivalence)
 
 private
   variable
diff --git a/src/Relation/Binary/PropositionalEquality/Core.agda b/src/Relation/Binary/PropositionalEquality/Core.agda
index 83c406b8aa..f52fed277f 100644
--- a/src/Relation/Binary/PropositionalEquality/Core.agda
+++ b/src/Relation/Binary/PropositionalEquality/Core.agda
@@ -11,7 +11,7 @@
 
 module Relation.Binary.PropositionalEquality.Core where
 
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Function.Base using (_∘_)
 open import Level
 open import Relation.Binary.Core
@@ -32,6 +32,15 @@ infix 4 _≢_
 _≢_ : {A : Set a} → Rel A a
 x ≢ y = ¬ x ≡ y
 
+------------------------------------------------------------------------
+-- Pointwise equality
+
+infix 4 _≗_
+
+_≗_ : (f g : A → B) → Set _
+_≗_ {A = A} {B = B} f g = ∀ x → f x ≡ g x
+
+
 ------------------------------------------------------------------------
 -- A variant of `refl` where the argument is explicit
 
@@ -91,35 +100,3 @@ resp₂ _∼_ = respʳ _∼_ , respˡ _∼_
 
 ≢-sym : Symmetric {A = A} _≢_
 ≢-sym x≢y =  x≢y ∘ sym
-
-------------------------------------------------------------------------
--- Convenient syntax for equational reasoning
-
--- This is a special instance of `Relation.Binary.Reasoning.Setoid`.
--- Rather than instantiating the latter with (setoid A), we reimplement
--- equation chains from scratch since then goals are printed much more
--- readably.
-
-module ≡-Reasoning {A : Set a} where
-
-  infix  3 _∎
-  infixr 2 _≡⟨⟩_ step-≡ step-≡˘
-  infix  1 begin_
-
-  begin_ : ∀{x y : A} → x ≡ y → x ≡ y
-  begin_ x≡y = x≡y
-
-  _≡⟨⟩_ : ∀ (x {y} : A) → x ≡ y → x ≡ y
-  _ ≡⟨⟩ x≡y = x≡y
-
-  step-≡ : ∀ (x {y z} : A) → y ≡ z → x ≡ y → x ≡ z
-  step-≡ _ y≡z x≡y = trans x≡y y≡z
-
-  step-≡˘ : ∀ (x {y z} : A) → y ≡ z → y ≡ x → x ≡ z
-  step-≡˘ _ y≡z y≡x = trans (sym y≡x) y≡z
-
-  _∎ : ∀ (x : A) → x ≡ x
-  _∎ _ = refl
-
-  syntax step-≡  x y≡z x≡y = x ≡⟨  x≡y ⟩ y≡z
-  syntax step-≡˘ x y≡z y≡x = x ≡˘⟨ y≡x ⟩ y≡z
diff --git a/src/Relation/Binary/PropositionalEquality/Properties.agda b/src/Relation/Binary/PropositionalEquality/Properties.agda
index 0953c68cbd..4aba0ba4c8 100644
--- a/src/Relation/Binary/PropositionalEquality/Properties.agda
+++ b/src/Relation/Binary/PropositionalEquality/Properties.agda
@@ -3,9 +3,9 @@
 --
 -- Propositional equality
 --
--- This file contains some core properies of propositional equality which
--- are re-exported by Relation.Binary.PropositionalEquality. They are
--- ``equality rearrangement'' lemmas.
+-- This file contains some core properies of propositional equality
+-- which are re-exported by Relation.Binary.PropositionalEquality. They
+-- are ``equality rearrangement'' lemmas.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
@@ -13,11 +13,18 @@
 module Relation.Binary.PropositionalEquality.Properties where
 
 open import Function.Base using (id; _∘_)
-open import Level
-open import Relation.Binary
+open import Level using (Level)
+open import Relation.Binary.Bundles
+  using (Setoid; DecSetoid; Preorder; Poset)
+open import Relation.Binary.Structures
+  using (IsEquivalence; IsDecEquivalence; IsPreorder; IsPartialOrder)
+open import Relation.Binary.Definitions
+  using (DecidableEquality)
 import Relation.Binary.Properties.Setoid as Setoid
 open import Relation.Binary.PropositionalEquality.Core
 open import Relation.Unary using (Pred)
+open import Relation.Binary.Reasoning.Syntax
+
 
 private
   variable
@@ -150,7 +157,7 @@ isEquivalence = record
   ; trans = trans
   }
 
-isDecEquivalence : Decidable _≡_ → IsDecEquivalence {A = A} _≡_
+isDecEquivalence : DecidableEquality A → IsDecEquivalence _≡_
 isDecEquivalence _≟_ = record
   { isEquivalence = isEquivalence
   ; _≟_           = _≟_
@@ -183,3 +190,16 @@ preorder A = Setoid.≈-preorder (setoid A)
 
 poset : Set a → Poset _ _ _
 poset A = Setoid.≈-poset (setoid A)
+
+------------------------------------------------------------------------
+-- Reasoning
+
+-- This is a special instance of `Relation.Binary.Reasoning.Setoid`.
+-- Rather than instantiating the latter with (setoid A), we reimplement
+-- equation chains from scratch since then goals are printed much more
+-- readably.
+module ≡-Reasoning {a} {A : Set a} where
+
+  open begin-syntax {A = A} _≡_ id public
+  open ≡-syntax {A = A} _≡_ trans public
+  open end-syntax {A = A} _≡_ refl public
diff --git a/src/Relation/Binary/PropositionalEquality/WithK.agda b/src/Relation/Binary/PropositionalEquality/WithK.agda
index d14ec1d9f3..db49b97b2c 100644
--- a/src/Relation/Binary/PropositionalEquality/WithK.agda
+++ b/src/Relation/Binary/PropositionalEquality/WithK.agda
@@ -10,7 +10,7 @@
 module Relation.Binary.PropositionalEquality.WithK where
 
 open import Axiom.UniquenessOfIdentityProofs.WithK
-open import Relation.Binary
+open import Relation.Binary.Definitions using (Irrelevant)
 open import Relation.Binary.PropositionalEquality.Core
 
 ------------------------------------------------------------------------
diff --git a/src/Relation/Binary/Reasoning/Base/Apartness.agda b/src/Relation/Binary/Reasoning/Base/Apartness.agda
new file mode 100644
index 0000000000..d3a850eca7
--- /dev/null
+++ b/src/Relation/Binary/Reasoning/Base/Apartness.agda
@@ -0,0 +1,107 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- The basic code for equational reasoning with three relations:
+-- equality and apartness
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Level using (Level; _⊔_)
+open import Function.Base using (case_of_)
+open import Relation.Nullary.Decidable using (Dec; yes; no)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Structures using (IsEquivalence)
+open import Relation.Binary.Definitions using (Reflexive; Transitive; Symmetric; Trans)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Binary.Reasoning.Syntax
+
+
+module Relation.Binary.Reasoning.Base.Apartness {a ℓ₁ ℓ₂} {A : Set a}
+  {_≈_ : Rel A ℓ₁} {_#_ : Rel A ℓ₂}
+  (≈-equiv : IsEquivalence _≈_)
+  (#-trans : Transitive _#_) (#-sym   : Symmetric _#_)
+  (#-≈-trans : Trans _#_ _≈_ _#_) (≈-#-trans : Trans _≈_ _#_ _#_)
+  where
+
+module Eq = IsEquivalence ≈-equiv
+
+------------------------------------------------------------------------
+-- A datatype to hide the current relation type
+
+infix 4 _IsRelatedTo_
+
+data _IsRelatedTo_ (x y : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
+  nothing   :                 x IsRelatedTo y
+  apartness : (x#y : x # y) → x IsRelatedTo y
+  equals    : (x≈y : x ≈ y) → x IsRelatedTo y
+
+≡-go : Trans _≡_ _IsRelatedTo_ _IsRelatedTo_
+≡-go x≡y nothing = nothing
+≡-go x≡y (apartness y#z) = apartness (case x≡y of λ where ≡.refl → y#z)
+≡-go x≡y (equals y≈z) = equals (case x≡y of λ where ≡.refl → y≈z)
+
+≈-go  : Trans _≈_ _IsRelatedTo_ _IsRelatedTo_
+≈-go x≈y nothing         = nothing
+≈-go x≈y (apartness y#z) = apartness (≈-#-trans x≈y y#z)
+≈-go x≈y (equals    y≈z) = equals    (Eq.trans   x≈y y≈z)
+
+#-go : Trans _#_ _IsRelatedTo_ _IsRelatedTo_
+#-go x#y nothing         = nothing
+#-go x#y (apartness y#z) = nothing
+#-go x#y (equals    y≈z) = apartness (#-≈-trans x#y y≈z)
+
+stop : Reflexive _IsRelatedTo_
+stop = equals Eq.refl
+
+------------------------------------------------------------------------
+-- Apartness subrelation
+
+data IsApartness {x y} : x IsRelatedTo y → Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
+  isApartness : ∀ x#y → IsApartness (apartness x#y)
+
+IsApartness? : ∀ {x y} (x#y : x IsRelatedTo y) → Dec (IsApartness x#y)
+IsApartness? nothing         = no λ()
+IsApartness? (apartness x#y) = yes (isApartness x#y)
+IsApartness? (equals x≈y)    = no (λ ())
+
+extractApartness : ∀ {x y} {x#y : x IsRelatedTo y} → IsApartness x#y → x # y
+extractApartness (isApartness x#y) = x#y
+
+apartnessRelation : SubRelation _IsRelatedTo_ _ _
+apartnessRelation = record
+  { IsS = IsApartness
+  ; IsS? = IsApartness?
+  ; extract = extractApartness
+  }
+
+------------------------------------------------------------------------
+-- Equality subrelation
+
+data IsEquality {x y} : x IsRelatedTo y → Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
+  isEquality : ∀ x≈y → IsEquality (equals x≈y)
+
+IsEquality? : ∀ {x y} (x≲y : x IsRelatedTo y) → Dec (IsEquality x≲y)
+IsEquality? nothing       = no λ()
+IsEquality? (apartness _) = no λ()
+IsEquality? (equals  x≈y) = yes (isEquality x≈y)
+
+extractEquality : ∀ {x y} {x≲y : x IsRelatedTo y} → IsEquality x≲y → x ≈ y
+extractEquality (isEquality x≈y) = x≈y
+
+eqRelation : SubRelation _IsRelatedTo_ _ _
+eqRelation = record
+  { IsS = IsEquality
+  ; IsS? = IsEquality?
+  ; extract = extractEquality
+  }
+
+------------------------------------------------------------------------
+-- Reasoning combinators
+
+open begin-apartness-syntax _IsRelatedTo_ apartnessRelation public
+open begin-equality-syntax _IsRelatedTo_ eqRelation public
+open ≡-syntax _IsRelatedTo_ ≡-go public
+open #-syntax _IsRelatedTo_ _IsRelatedTo_ #-go #-sym public
+open ≈-syntax _IsRelatedTo_ _IsRelatedTo_ ≈-go Eq.sym public
+open end-syntax _IsRelatedTo_ stop public
diff --git a/src/Relation/Binary/Reasoning/Base/Double.agda b/src/Relation/Binary/Reasoning/Base/Double.agda
index f40a32bc9b..0c1ae9b60c 100644
--- a/src/Relation/Binary/Reasoning/Base/Double.agda
+++ b/src/Relation/Binary/Reasoning/Base/Double.agda
@@ -10,20 +10,20 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Level using (_⊔_)
+open import Function.Base using (case_of_)
+open import Relation.Nullary.Decidable.Core using (Dec; yes; no)
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Definitions using (Reflexive; Trans)
+open import Relation.Binary.Structures using (IsPreorder)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Binary.Reasoning.Syntax
+
 
 module Relation.Binary.Reasoning.Base.Double {a ℓ₁ ℓ₂} {A : Set a}
-  {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (isPreorder : IsPreorder _≈_ _∼_)
+  {_≈_ : Rel A ℓ₁} {_≲_ : Rel A ℓ₂} (isPreorder : IsPreorder _≈_ _≲_)
   where
 
-open import Data.Product using (proj₁; proj₂)
-open import Level using (Level; _⊔_; Lift; lift)
-open import Function.Base using (case_of_; id)
-open import Relation.Binary.PropositionalEquality.Core
-  using (_≡_; refl; sym)
-open import Relation.Nullary.Decidable using (Dec; yes; no)
-open import Relation.Nullary.Decidable using (True; toWitness)
-
 open IsPreorder isPreorder
 
 ------------------------------------------------------------------------
@@ -32,9 +32,28 @@ open IsPreorder isPreorder
 infix 4 _IsRelatedTo_
 
 data _IsRelatedTo_ (x y : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂) where
-  nonstrict : (x∼y : x ∼ y) → x IsRelatedTo y
+  nonstrict : (x≲y : x ≲ y) → x IsRelatedTo y
   equals    : (x≈y : x ≈ y) → x IsRelatedTo y
 
+start : _IsRelatedTo_ ⇒ _≲_
+start (equals x≈y) = reflexive x≈y
+start (nonstrict x≲y) = x≲y
+
+≡-go : Trans _≡_ _IsRelatedTo_ _IsRelatedTo_
+≡-go x≡y (equals y≈z) = equals (case x≡y of λ where ≡.refl → y≈z)
+≡-go x≡y (nonstrict y≤z) = nonstrict (case x≡y of λ where ≡.refl → y≤z)
+
+≲-go : Trans _≲_ _IsRelatedTo_ _IsRelatedTo_
+≲-go x≲y (equals y≈z) = nonstrict (∼-respʳ-≈ y≈z x≲y)
+≲-go x≲y (nonstrict y≲z) = nonstrict (trans x≲y y≲z)
+
+≈-go : Trans _≈_ _IsRelatedTo_ _IsRelatedTo_
+≈-go x≈y (equals y≈z) = equals (Eq.trans x≈y y≈z)
+≈-go x≈y (nonstrict y≲z) = nonstrict (∼-respˡ-≈ (Eq.sym x≈y) y≲z)
+
+stop : Reflexive _IsRelatedTo_
+stop = equals Eq.refl
+
 ------------------------------------------------------------------------
 -- A record that is used to ensure that the final relation proved by the
 -- chain of reasoning can be converted into the required relation.
@@ -49,67 +68,34 @@ IsEquality? (equals x≈y)  = yes (isEquality x≈y)
 extractEquality : ∀ {x y} {x≲y : x IsRelatedTo y} → IsEquality x≲y → x ≈ y
 extractEquality (isEquality x≈y) = x≈y
 
+equalitySubRelation : SubRelation  _IsRelatedTo_ _ _
+equalitySubRelation = record
+  { IsS = IsEquality
+  ; IsS? = IsEquality?
+  ; extract = extractEquality
+  }
+
 ------------------------------------------------------------------------
 -- Reasoning combinators
 
--- See `Relation.Binary.Reasoning.Base.Partial` for the design decisions
--- behind these combinators.
-
-infix  1 begin_ begin-equality_
-infixr 2 step-∼ step-≈ step-≈˘ step-≡ step-≡˘ _≡⟨⟩_
-infix  3 _∎
-
--- Beginnings of various types of proofs
-
-begin_ : ∀ {x y} (r : x IsRelatedTo y) → x ∼ y
-begin (nonstrict x∼y) = x∼y
-begin (equals    x≈y) = reflexive x≈y
-
-begin-equality_ : ∀ {x y} (r : x IsRelatedTo y) → {s : True (IsEquality? r)} → x ≈ y
-begin-equality_ r {s} = extractEquality (toWitness s)
-
--- Step with the main relation
+open begin-syntax  _IsRelatedTo_ start public
+open begin-equality-syntax  _IsRelatedTo_ equalitySubRelation public
+open ≡-syntax _IsRelatedTo_ ≡-go public
+open ≈-syntax _IsRelatedTo_ _IsRelatedTo_ ≈-go Eq.sym public
+open ≲-syntax _IsRelatedTo_ _IsRelatedTo_ ≲-go public
+open end-syntax _IsRelatedTo_ stop public
 
-step-∼ : ∀ (x : A) {y z} → y IsRelatedTo z → x ∼ y → x IsRelatedTo z
-step-∼ x (nonstrict y∼z) x∼y = nonstrict (trans x∼y y∼z)
-step-∼ x (equals    y≈z) x∼y = nonstrict (∼-respʳ-≈ y≈z x∼y)
 
--- Step with the setoid equality
-
-step-≈ : ∀ (x : A) {y z} → y IsRelatedTo z → x ≈ y → x IsRelatedTo z
-step-≈ x (nonstrict y∼z) x≈y = nonstrict (∼-respˡ-≈ (Eq.sym x≈y) y∼z)
-step-≈ x (equals    y≈z) x≈y = equals    (Eq.trans x≈y y≈z)
-
--- Flipped step with the setoid equality
-
-step-≈˘ : ∀ x {y z} → y IsRelatedTo z → y ≈ x → x IsRelatedTo z
-step-≈˘ x y∼z x≈y = step-≈ x y∼z (Eq.sym x≈y)
-
--- Step with non-trivial propositional equality
-
-step-≡ : ∀ (x : A) {y z} → y IsRelatedTo z → x ≡ y → x IsRelatedTo z
-step-≡ x (nonstrict y∼z) x≡y = nonstrict (case x≡y of λ where refl → y∼z)
-step-≡ x (equals    y≈z) x≡y = equals    (case x≡y of λ where refl → y≈z)
-
--- Flipped step with non-trivial propositional equality
-
-step-≡˘ : ∀ x {y z} → y IsRelatedTo z → y ≡ x → x IsRelatedTo z
-step-≡˘ x y∼z x≡y = step-≡ x y∼z (sym x≡y)
-
--- Step with trivial propositional equality
-
-_≡⟨⟩_ : ∀ (x : A) {y} → x IsRelatedTo y → x IsRelatedTo y
-x ≡⟨⟩ x≲y = x≲y
-
--- Termination step
-
-_∎ : ∀ x → x IsRelatedTo x
-x ∎ = equals Eq.refl
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
 
--- Syntax declarations
+-- Version 2.0
 
-syntax step-∼  x y∼z x∼y = x ∼⟨  x∼y ⟩ y∼z
-syntax step-≈  x y∼z x≈y = x ≈⟨  x≈y ⟩ y∼z
-syntax step-≈˘ x y∼z y≈x = x ≈˘⟨ y≈x ⟩ y∼z
-syntax step-≡  x y∼z x≡y = x ≡⟨  x≡y ⟩ y∼z
-syntax step-≡˘ x y∼z y≡x = x ≡˘⟨ y≡x ⟩ y∼z
+open ∼-syntax _IsRelatedTo_ _IsRelatedTo_ ≲-go public
+{-# WARNING_ON_USAGE step-∼
+"Warning: step-∼ and _∼⟨_⟩_ syntax was deprecated in v2.0.
+Please use step-≲ and _≲⟨_⟩_ instead. "
+#-}
diff --git a/src/Relation/Binary/Reasoning/Base/Partial.agda b/src/Relation/Binary/Reasoning/Base/Partial.agda
index e53f7e4efe..5da6792f64 100644
--- a/src/Relation/Binary/Reasoning/Base/Partial.agda
+++ b/src/Relation/Binary/Reasoning/Base/Partial.agda
@@ -6,13 +6,14 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary.Core
-open import Relation.Binary.Definitions
+open import Function.Base using (case_of_)
 open import Level using (_⊔_)
-open import Relation.Binary.PropositionalEquality.Core as P
-  using (_≡_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Transitive; Trans; Reflexive)
 open import Relation.Nullary.Decidable using (Dec; yes; no)
-open import Relation.Nullary.Decidable using (True)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Binary.Reasoning.Syntax
+
 
 module Relation.Binary.Reasoning.Base.Partial
   {a ℓ} {A : Set a} (_∼_ : Rel A ℓ) (trans : Transitive _∼_)
@@ -30,6 +31,13 @@ data _IsRelatedTo_ : A → A → Set (a ⊔ ℓ) where
   singleStep : ∀ x → x IsRelatedTo x
   multiStep  : ∀ {x y} (x∼y : x ∼ y) → x IsRelatedTo y
 
+∼-go : Trans _∼_ _IsRelatedTo_ _IsRelatedTo_
+∼-go x∼y (singleStep y) = multiStep x∼y
+∼-go x∼y (multiStep y∼z) = multiStep (trans x∼y y∼z)
+
+stop : Reflexive _IsRelatedTo_
+stop = singleStep _
+
 ------------------------------------------------------------------------
 -- Types that are used to ensure that the final relation proved by the
 -- chain of reasoning can be converted into the required relation.
@@ -41,61 +49,23 @@ IsMultiStep? : ∀ {x y} (x∼y : x IsRelatedTo y) → Dec (IsMultiStep x∼y)
 IsMultiStep? (multiStep x<y) = yes (isMultiStep x<y)
 IsMultiStep? (singleStep _)  = no λ()
 
-------------------------------------------------------------------------
--- Reasoning combinators
-
--- Note that the arguments to the `step`s are not provided in their
--- "natural" order and syntax declarations are later used to re-order
--- them. This is because the `step` ordering allows the type-checker to
--- better infer the middle argument `y` from the `_IsRelatedTo_`
--- argument (see issue 622).
---
--- This has two practical benefits. First it speeds up type-checking by
--- approximately a factor of 5. Secondly it allows the combinators to be
--- used with macros that use reflection, e.g. `Tactic.RingSolver`, where
--- they need to be able to extract `y` using reflection.
-
-infix  1 begin_
-infixr 2 step-∼ step-≡ step-≡˘
-infixr 2 _≡⟨⟩_
-infix  3 _∎⟨_⟩ _∎
-
--- Beginning of a proof
-
-begin_ : ∀ {x y} (x∼y : x IsRelatedTo y) → {True (IsMultiStep? x∼y)} → x ∼ y
-begin (multiStep x∼y) = x∼y
-
--- Standard step with the relation
+extractMultiStep : ∀ {x y} {x∼y : x IsRelatedTo y} → IsMultiStep x∼y → x ∼ y
+extractMultiStep (isMultiStep x≈y) = x≈y
 
-step-∼ : ∀ x {y z} → y IsRelatedTo z → x ∼ y → x IsRelatedTo z
-step-∼ _ (singleStep _) x∼y  = multiStep x∼y
-step-∼ _ (multiStep y∼z) x∼y = multiStep (trans x∼y y∼z)
+multiStepSubRelation : SubRelation _IsRelatedTo_ _ _
+multiStepSubRelation = record
+  { IsS = IsMultiStep
+  ; IsS? = IsMultiStep?
+  ; extract = extractMultiStep
+  }
 
--- Step with a non-trivial propositional equality
-
-step-≡ : ∀ x {y z} → y IsRelatedTo z → x ≡ y → x IsRelatedTo z
-step-≡ _ x∼z P.refl = x∼z
-
--- Step with a flipped non-trivial propositional equality
-
-step-≡˘ : ∀ x {y z} → y IsRelatedTo z → y ≡ x → x IsRelatedTo z
-step-≡˘ _ x∼z P.refl = x∼z
-
--- -- Step with a trivial propositional equality
-
-_≡⟨⟩_ : ∀ x {y} → x IsRelatedTo y → x IsRelatedTo y
-_ ≡⟨⟩ x∼y = x∼y
-
--- Termination
-
-_∎ : ∀ x → x IsRelatedTo x
-_∎ = singleStep
-
--- Syntax declarations
+------------------------------------------------------------------------
+-- Reasoning combinators
 
-syntax step-∼  x y∼z x∼y = x ∼⟨  x∼y ⟩ y∼z
-syntax step-≡  x y≡z x≡y = x ≡⟨  x≡y ⟩ y≡z
-syntax step-≡˘ x y≡z y≡x = x ≡˘⟨ y≡x ⟩ y≡z
+open begin-subrelation-syntax _IsRelatedTo_ multiStepSubRelation public
+open ≡-noncomputing-syntax _IsRelatedTo_ public
+open ∼-syntax _IsRelatedTo_ _IsRelatedTo_ ∼-go public
+open end-syntax _IsRelatedTo_ stop public
 
 
 ------------------------------------------------------------------------
@@ -106,6 +76,8 @@ syntax step-≡˘ x y≡z y≡x = x ≡˘⟨ y≡x ⟩ y≡z
 
 -- Version 1.6
 
+infix  3 _∎⟨_⟩
+
 _∎⟨_⟩ : ∀ x → x ∼ x → x IsRelatedTo x
 _ ∎⟨ x∼x ⟩ = multiStep x∼x
 {-# WARNING_ON_USAGE _∎⟨_⟩
diff --git a/src/Relation/Binary/Reasoning/Base/Single.agda b/src/Relation/Binary/Reasoning/Base/Single.agda
index 97da6b06b8..2f34ee8525 100644
--- a/src/Relation/Binary/Reasoning/Base/Single.agda
+++ b/src/Relation/Binary/Reasoning/Base/Single.agda
@@ -6,83 +6,45 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Level using (_⊔_)
+open import Function.Base using (case_of_)
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Definitions using (Reflexive; Transitive; Trans)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Binary.Reasoning.Syntax
 
 module Relation.Binary.Reasoning.Base.Single
   {a ℓ} {A : Set a} (_∼_ : Rel A ℓ)
   (refl : Reflexive _∼_) (trans : Transitive _∼_)
   where
 
--- TODO: the following part is copied from Relation.Binary.Reasoning.Base.Partial
--- in order to avoid larger refactors. We will refactor this part later
--- so taht we use the same framework as Relation.Binary.Reasoning.Base.Partial.
-
-open import Level using (_⊔_)
-open import Relation.Binary.PropositionalEquality.Core as P
-  using (_≡_)
-
-infix  4 _IsRelatedTo_
-
 ------------------------------------------------------------------------
 -- Definition of "related to"
 
 -- This seemingly unnecessary type is used to make it possible to
 -- infer arguments even if the underlying equality evaluates.
 
+infix 4 _IsRelatedTo_
+
 data _IsRelatedTo_ (x y : A) : Set ℓ where
   relTo : (x∼y : x ∼ y) → x IsRelatedTo y
 
-------------------------------------------------------------------------
--- Reasoning combinators
-
--- Note that the arguments to the `step`s are not provided in their
--- "natural" order and syntax declarations are later used to re-order
--- them. This is because the `step` ordering allows the type-checker to
--- better infer the middle argument `y` from the `_IsRelatedTo_`
--- argument (see issue 622).
---
--- This has two practical benefits. First it speeds up type-checking by
--- approximately a factor of 5. Secondly it allows the combinators to be
--- used with macros that use reflection, e.g. `Tactic.RingSolver`, where
--- they need to be able to extract `y` using reflection.
-
-infix  1 begin_
-infixr 2 step-∼ step-≡ step-≡˘
-infixr 2 _≡⟨⟩_
-infix  3 _∎
+start : _IsRelatedTo_ ⇒ _∼_
+start (relTo x∼y) = x∼y
 
--- Beginning of a proof
+∼-go : Trans _∼_ _IsRelatedTo_ _IsRelatedTo_
+∼-go x∼y (relTo y∼z) = relTo (trans x∼y y∼z)
 
-begin_ : ∀ {x y} → x IsRelatedTo y → x ∼ y
-begin relTo x∼y = x∼y
+≡-go : Trans _≡_ _IsRelatedTo_ _IsRelatedTo_
+≡-go x≡y (relTo y∼z) = relTo (case x≡y of λ where ≡.refl → y∼z)
 
--- Standard step with the relation
+stop : Reflexive _IsRelatedTo_
+stop = relTo refl
 
-step-∼ : ∀ x {y z} → y IsRelatedTo z → x ∼ y → x IsRelatedTo z
-step-∼ _ (relTo y∼z) x∼y = relTo (trans x∼y y∼z)
-
--- Step with a non-trivial propositional equality
-
-step-≡ : ∀ x {y z} → y IsRelatedTo z → x ≡ y → x IsRelatedTo z
-step-≡ _ x∼z P.refl = x∼z
-
--- Step with a flipped non-trivial propositional equality
-
-step-≡˘ : ∀ x {y z} → y IsRelatedTo z → y ≡ x → x IsRelatedTo z
-step-≡˘ _ x∼z P.refl = x∼z
-
--- Step with a trivial propositional equality
-
-_≡⟨⟩_ : ∀ x {y} → x IsRelatedTo y → x IsRelatedTo y
-_ ≡⟨⟩ x∼y = x∼y
-
--- Termination
-
-_∎ : ∀ x → x IsRelatedTo x
-x ∎ = relTo refl
-
--- Syntax declarations
+------------------------------------------------------------------------
+-- Reasoning combinators
 
-syntax step-∼  x y∼z x∼y = x ∼⟨  x∼y ⟩ y∼z
-syntax step-≡  x y≡z x≡y = x ≡⟨  x≡y ⟩ y≡z
-syntax step-≡˘ x y≡z y≡x = x ≡˘⟨ y≡x ⟩ y≡z
+open begin-syntax _IsRelatedTo_ start public
+open ≡-syntax _IsRelatedTo_ ≡-go public
+open ∼-syntax _IsRelatedTo_ _IsRelatedTo_ ∼-go public
+open end-syntax _IsRelatedTo_ stop public
diff --git a/src/Relation/Binary/Reasoning/Base/Triple.agda b/src/Relation/Binary/Reasoning/Base/Triple.agda
index 8e5ba6e159..3433e58063 100644
--- a/src/Relation/Binary/Reasoning/Base/Triple.agda
+++ b/src/Relation/Binary/Reasoning/Base/Triple.agda
@@ -10,29 +10,27 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Data.Product.Base using (proj₁; proj₂)
+open import Level using (_⊔_)
+open import Function.Base using (case_of_)
+open import Relation.Nullary.Decidable.Core
+  using (Dec; yes; no)
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Structures using (IsPreorder)
+open import Relation.Binary.Definitions
+  using (Transitive; _Respects₂_; Reflexive; Trans; Irreflexive; Asymmetric)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Binary.Reasoning.Syntax
 
 module Relation.Binary.Reasoning.Base.Triple {a ℓ₁ ℓ₂ ℓ₃} {A : Set a}
   {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} {_<_ : Rel A ℓ₃}
   (isPreorder : IsPreorder _≈_ _≤_)
-  (<-trans : Transitive _<_) (<-resp-≈ : _<_ Respects₂ _≈_) (<⇒≤ : _<_ ⇒ _≤_)
+  (<-asym : Asymmetric _<_) (<-trans : Transitive _<_) (<-resp-≈ : _<_ Respects₂ _≈_)
+  (<⇒≤ : _<_ ⇒ _≤_)
   (<-≤-trans : Trans _<_ _≤_ _<_) (≤-<-trans : Trans _≤_ _<_ _<_)
   where
 
-open import Data.Product using (proj₁; proj₂)
-open import Function.Base using (case_of_; id)
-open import Level using (Level; _⊔_; Lift; lift)
-open import Relation.Binary.PropositionalEquality.Core
-  using (_≡_; refl; sym)
-open import Relation.Nullary.Decidable using (Dec; yes; no)
-open import Relation.Nullary.Decidable using (True; toWitness)
-
 open IsPreorder isPreorder
-  renaming
-  ( reflexive to ≤-reflexive
-  ; trans     to ≤-trans
-  ; ∼-resp-≈  to ≤-resp-≈
-  )
 
 ------------------------------------------------------------------------
 -- A datatype to abstract over the current relation
@@ -44,6 +42,35 @@ data _IsRelatedTo_ (x y : A) : Set (a ⊔ ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃) where
   nonstrict : (x≤y : x ≤ y) → x IsRelatedTo y
   equals    : (x≈y : x ≈ y) → x IsRelatedTo y
 
+start : _IsRelatedTo_ ⇒ _≤_
+start (equals x≈y) = reflexive x≈y
+start (nonstrict x≤y) = x≤y
+start (strict x<y) = <⇒≤ x<y
+
+≡-go : Trans _≡_ _IsRelatedTo_ _IsRelatedTo_
+≡-go x≡y (equals y≈z) = equals (case x≡y of λ where ≡.refl → y≈z)
+≡-go x≡y (nonstrict y≤z) = nonstrict (case x≡y of λ where ≡.refl → y≤z)
+≡-go x≡y (strict y<z) = strict (case x≡y of λ where ≡.refl → y<z)
+
+≈-go : Trans _≈_ _IsRelatedTo_ _IsRelatedTo_
+≈-go x≈y (equals y≈z) = equals (Eq.trans x≈y y≈z)
+≈-go x≈y (nonstrict y≤z) = nonstrict (∼-respˡ-≈ (Eq.sym x≈y) y≤z)
+≈-go x≈y (strict y<z) = strict (proj₂ <-resp-≈ (Eq.sym x≈y) y<z)
+
+≤-go : Trans _≤_ _IsRelatedTo_ _IsRelatedTo_
+≤-go x≤y (equals y≈z) = nonstrict (∼-respʳ-≈ y≈z x≤y)
+≤-go x≤y (nonstrict y≤z) = nonstrict (trans x≤y y≤z)
+≤-go x≤y (strict y<z) = strict (≤-<-trans x≤y y<z)
+
+<-go : Trans _<_ _IsRelatedTo_ _IsRelatedTo_
+<-go x<y (equals y≈z) = strict (proj₁ <-resp-≈ y≈z x<y)
+<-go x<y (nonstrict y≤z) = strict (<-≤-trans x<y y≤z)
+<-go x<y (strict y<z) = strict (<-trans x<y y<z)
+
+stop : Reflexive _IsRelatedTo_
+stop = equals Eq.refl
+
+
 ------------------------------------------------------------------------
 -- Types that are used to ensure that the final relation proved by the
 -- chain of reasoning can be converted into the required relation.
@@ -59,6 +86,16 @@ IsStrict? (equals    _)   = no λ()
 extractStrict : ∀ {x y} {x≲y : x IsRelatedTo y} → IsStrict x≲y → x < y
 extractStrict (isStrict x<y) = x<y
 
+strictRelation : SubRelation _IsRelatedTo_ _ _
+strictRelation = record
+  { IsS = IsStrict
+  ; IsS? = IsStrict?
+  ; extract = extractStrict
+  }
+
+------------------------------------------------------------------------
+-- Equality sub-relation
+
 data IsEquality {x y} : x IsRelatedTo y → Set (a ⊔ ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃) where
   isEquality : ∀ x≈y → IsEquality (equals x≈y)
 
@@ -70,82 +107,22 @@ IsEquality? (equals x≈y)  = yes (isEquality x≈y)
 extractEquality : ∀ {x y} {x≲y : x IsRelatedTo y} → IsEquality x≲y → x ≈ y
 extractEquality (isEquality x≈y) = x≈y
 
+eqRelation : SubRelation _IsRelatedTo_ _ _
+eqRelation = record
+  { IsS = IsEquality
+  ; IsS? = IsEquality?
+  ; extract = extractEquality
+  }
+
 ------------------------------------------------------------------------
 -- Reasoning combinators
 
--- See `Relation.Binary.Reasoning.Base.Partial` for the design decisions
--- behind these combinators.
-
-infix  1 begin_ begin-strict_ begin-equality_
-infixr 2 step-< step-≤ step-≈ step-≈˘ step-≡ step-≡˘ _≡⟨⟩_
-infix  3 _∎
-
--- Beginnings of various types of proofs
-
-begin_ : ∀ {x y} → x IsRelatedTo y → x ≤ y
-begin (strict    x<y) = <⇒≤ x<y
-begin (nonstrict x≤y) = x≤y
-begin (equals    x≈y) = ≤-reflexive x≈y
-
-begin-strict_ : ∀ {x y} (r : x IsRelatedTo y) → {s : True (IsStrict? r)} → x < y
-begin-strict_ r {s} = extractStrict (toWitness s)
-
-begin-equality_ : ∀ {x y} (r : x IsRelatedTo y) → {s : True (IsEquality? r)} → x ≈ y
-begin-equality_ r {s} = extractEquality (toWitness s)
-
--- Step with the strict relation
-
-step-< : ∀ (x : A) {y z} → y IsRelatedTo z → x < y → x IsRelatedTo z
-step-< x (strict    y<z) x<y = strict (<-trans x<y y<z)
-step-< x (nonstrict y≤z) x<y = strict (<-≤-trans x<y y≤z)
-step-< x (equals    y≈z) x<y = strict (proj₁ <-resp-≈ y≈z x<y)
-
--- Step with the non-strict relation
-
-step-≤ : ∀ (x : A) {y z} → y IsRelatedTo z → x ≤ y → x IsRelatedTo z
-step-≤ x (strict    y<z) x≤y = strict    (≤-<-trans x≤y y<z)
-step-≤ x (nonstrict y≤z) x≤y = nonstrict (≤-trans x≤y y≤z)
-step-≤ x (equals    y≈z) x≤y = nonstrict (proj₁ ≤-resp-≈ y≈z x≤y)
-
--- Step with the setoid equality
-
-step-≈  : ∀ (x : A) {y z} → y IsRelatedTo z → x ≈ y → x IsRelatedTo z
-step-≈ x (strict    y<z) x≈y = strict    (proj₂ <-resp-≈ (Eq.sym x≈y) y<z)
-step-≈ x (nonstrict y≤z) x≈y = nonstrict (proj₂ ≤-resp-≈ (Eq.sym x≈y) y≤z)
-step-≈ x (equals    y≈z) x≈y = equals    (Eq.trans x≈y y≈z)
-
--- Flipped step with the setoid equality
-
-step-≈˘ : ∀ x {y z} → y IsRelatedTo z → y ≈ x → x IsRelatedTo z
-step-≈˘ x y∼z x≈y = step-≈ x y∼z (Eq.sym x≈y)
-
--- Step with non-trivial propositional equality
-
-step-≡ : ∀ (x : A) {y z} → y IsRelatedTo z → x ≡ y → x IsRelatedTo z
-step-≡ x (strict    y<z) x≡y  = strict    (case x≡y of λ where refl → y<z)
-step-≡ x (nonstrict y≤z) x≡y  = nonstrict (case x≡y of λ where refl → y≤z)
-step-≡ x (equals    y≈z) x≡y  = equals    (case x≡y of λ where refl → y≈z)
-
--- Flipped step with non-trivial propositional equality
-
-step-≡˘ : ∀ x {y z} → y IsRelatedTo z → y ≡ x → x IsRelatedTo z
-step-≡˘ x y∼z x≡y = step-≡ x y∼z (sym x≡y)
-
--- Step with trivial propositional equality
-
-_≡⟨⟩_ : ∀ (x : A) {y} → x IsRelatedTo y → x IsRelatedTo y
-x ≡⟨⟩ x≲y = x≲y
-
--- Termination step
-
-_∎ : ∀ x → x IsRelatedTo x
-x ∎ = equals Eq.refl
-
--- Syntax declarations
-
-syntax step-<  x y∼z x<y = x <⟨  x<y ⟩ y∼z
-syntax step-≤  x y∼z x≤y = x ≤⟨  x≤y ⟩ y∼z
-syntax step-≈  x y∼z x≈y = x ≈⟨  x≈y ⟩ y∼z
-syntax step-≈˘ x y∼z y≈x = x ≈˘⟨ y≈x ⟩ y∼z
-syntax step-≡  x y∼z x≡y = x ≡⟨  x≡y ⟩ y∼z
-syntax step-≡˘ x y∼z y≡x = x ≡˘⟨ y≡x ⟩ y∼z
+open begin-syntax _IsRelatedTo_ start public
+open begin-equality-syntax _IsRelatedTo_ eqRelation public
+open begin-strict-syntax _IsRelatedTo_ strictRelation public
+open begin-contradiction-syntax _IsRelatedTo_ strictRelation <-asym public
+open ≡-syntax _IsRelatedTo_ ≡-go public
+open ≈-syntax _IsRelatedTo_ _IsRelatedTo_ ≈-go Eq.sym public
+open ≤-syntax _IsRelatedTo_ _IsRelatedTo_ ≤-go public
+open <-syntax _IsRelatedTo_ _IsRelatedTo_ <-go public
+open end-syntax _IsRelatedTo_ stop public
diff --git a/src/Relation/Binary/Reasoning/MultiSetoid.agda b/src/Relation/Binary/Reasoning/MultiSetoid.agda
index 994ac3c4b6..5665472508 100644
--- a/src/Relation/Binary/Reasoning/MultiSetoid.agda
+++ b/src/Relation/Binary/Reasoning/MultiSetoid.agda
@@ -26,56 +26,51 @@
 
 module Relation.Binary.Reasoning.MultiSetoid where
 
-open import Function.Base using (flip)
-open import Level using (_⊔_)
-open import Relation.Binary
-open import Relation.Binary.PropositionalEquality as P using (_≡_)
-
-import Relation.Binary.Reasoning.Setoid as EqR
+open import Level using (Level; _⊔_)
+open import Function.Base using (case_of_)
+open import Relation.Binary.Core using (_⇒_)
+open import Relation.Binary.Definitions using (Trans; Reflexive)
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
+open import Relation.Binary.Reasoning.Syntax
+
+private
+  variable
+    a ℓ : Level
 
 ------------------------------------------------------------------------
 -- Combinators that take the current setoid as an explicit argument.
 
-module _ {c ℓ} (S : Setoid c ℓ) where
+module _ (S : Setoid a ℓ) where
   open Setoid S
 
-  data IsRelatedTo (x y : _) : Set (c ⊔ ℓ) where
-    relTo : (x∼y : x ≈ y) → IsRelatedTo x y
-
-  infix 1 begin⟨_⟩_
-
-  begin⟨_⟩_ : ∀ {x y} → IsRelatedTo x y → x ≈ y
-  begin⟨_⟩_ (relTo eq) = eq
-
-------------------------------------------------------------------------
--- Combinators that take the current setoid as an implicit argument.
-
-module _ {c ℓ} {S : Setoid c ℓ} where
+  data IsRelatedTo (x y : _) : Set (a ⊔ ℓ) where
+    relTo : (x≈y : x ≈ y) → IsRelatedTo x y
 
-  open Setoid S renaming (_≈_ to _≈_)
+  start : IsRelatedTo ⇒ _≈_
+  start (relTo x≈y) = x≈y
 
-  infixr 2 step-≈ step-≈˘ step-≡ step-≡˘ _≡⟨⟩_
-  infix 3 _∎
+  ≡-go : Trans _≡_ IsRelatedTo IsRelatedTo
+  ≡-go x≡y (relTo y∼z) = relTo (case x≡y of λ where ≡.refl → y∼z)
 
-  step-≈ : ∀ x {y z} → IsRelatedTo S y z → x ≈ y → IsRelatedTo S x z
-  step-≈ x (relTo y∼z) x∼y = relTo (trans x∼y y∼z)
+  ≈-go : Trans _≈_ IsRelatedTo IsRelatedTo
+  ≈-go x≈y (relTo y≈z) = relTo (trans x≈y y≈z)
 
-  step-≈˘ : ∀ x {y z} → IsRelatedTo S y z → y ≈ x → IsRelatedTo S x z
-  step-≈˘ x y∼z x≈y = step-≈ x y∼z (sym x≈y)
+  end : Reflexive IsRelatedTo
+  end = relTo refl
 
-  step-≡ : ∀ x {y z} → IsRelatedTo S y z → x ≡ y → IsRelatedTo S x z
-  step-≡ _ x∼z P.refl = x∼z
+------------------------------------------------------------------------
+-- Reasoning combinators
 
-  step-≡˘ : ∀ x {y z} → IsRelatedTo S y z → y ≡ x → IsRelatedTo S x z
-  step-≡˘ _ x∼z P.refl = x∼z
+-- Those that take the current setoid as an explicit argument.
+  open begin-syntax IsRelatedTo start public
+    renaming (begin_ to begin⟨_⟩_)
 
-  _≡⟨⟩_ : ∀ x {y} → IsRelatedTo S x y → IsRelatedTo S x y
-  _ ≡⟨⟩ x∼y = x∼y
 
-  _∎ : ∀ x → IsRelatedTo S x x
-  _∎ _ = relTo refl
+-- Those that take the current setoid as an implicit argument.
+module _ {S : Setoid a ℓ} where
+  open Setoid S
 
-  syntax step-≈  x y∼z x≈y = x ≈⟨  x≈y ⟩ y∼z
-  syntax step-≈˘ x y∼z y≈x = x ≈˘⟨ y≈x ⟩ y∼z
-  syntax step-≡  x y≡z x≡y = x ≡⟨  x≡y ⟩ y≡z
-  syntax step-≡˘ x y≡z y≡x = x ≡˘⟨ y≡x ⟩ y≡z
+  open ≡-syntax (IsRelatedTo S) (≡-go S)
+  open ≈-syntax (IsRelatedTo S) (IsRelatedTo S) (≈-go S) sym public
+  open end-syntax (IsRelatedTo S) (end S) public
diff --git a/src/Relation/Binary/Reasoning/PartialOrder.agda b/src/Relation/Binary/Reasoning/PartialOrder.agda
index fbf1bef25f..b633f1f548 100644
--- a/src/Relation/Binary/Reasoning/PartialOrder.agda
+++ b/src/Relation/Binary/Reasoning/PartialOrder.agda
@@ -27,8 +27,8 @@
 --      w  <⟨ w<x ⟩
 --      x  ≤⟨ x≤y ⟩
 --      y  <⟨ y<z ⟩
---      z  ≡˘⟨ d≡z ⟩
---      d  ≈˘⟨ e≈d ⟩
+--      z  ≡⟨ d≡z ⟨
+--      d  ≈⟨ e≈d ⟨
 --      e  ∎
 --
 --    u≈w : u ≈ w
@@ -39,19 +39,22 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Poset)
 
 module Relation.Binary.Reasoning.PartialOrder
   {p₁ p₂ p₃} (P : Poset p₁ p₂ p₃) where
 
 open Poset P
-import Relation.Binary.Construct.NonStrictToStrict _≈_ _≤_ as Strict
+open import Relation.Binary.Construct.NonStrictToStrict _≈_ _≤_
+  as Strict
+  using (_<_)
 
 ------------------------------------------------------------------------
 -- Re-export contents of base module
 
 open import Relation.Binary.Reasoning.Base.Triple
   isPreorder
+  (Strict.<-asym antisym)
   (Strict.<-trans isPartialOrder)
   (Strict.<-resp-≈ isEquivalence ≤-resp-≈)
   Strict.<⇒≤
diff --git a/src/Relation/Binary/Reasoning/PartialSetoid.agda b/src/Relation/Binary/Reasoning/PartialSetoid.agda
index 78f7c065d5..5163c99947 100644
--- a/src/Relation/Binary/Reasoning/PartialSetoid.agda
+++ b/src/Relation/Binary/Reasoning/PartialSetoid.agda
@@ -6,32 +6,23 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (PartialSetoid)
+open import Relation.Binary.Reasoning.Syntax
 
 module Relation.Binary.Reasoning.PartialSetoid
   {s₁ s₂} (S : PartialSetoid s₁ s₂) where
 
 open PartialSetoid S
-import Relation.Binary.Reasoning.Base.Partial _≈_ trans as Base
 
-------------------------------------------------------------------------
--- Re-export the contents of the base module
-
-open Base public
-  hiding (step-∼)
+import Relation.Binary.Reasoning.Base.Partial _≈_ trans
+  as ≈-Reasoning
 
 ------------------------------------------------------------------------
--- Additional reasoning combinators
-
-infixr 2 step-≈ step-≈˘
-
--- A step using an equality
-
-step-≈ = Base.step-∼
-syntax step-≈ x y≈z x≈y = x ≈⟨ x≈y ⟩ y≈z
+-- Reasoning combinators
 
--- A step using a symmetric equality
+-- Export the combinators for partial relation reasoning, hiding the
+-- single misnamed combinator.
+open ≈-Reasoning public hiding (step-∼)
 
-step-≈˘ : ∀ x {y z} → y IsRelatedTo z → y ≈ x → x IsRelatedTo z
-step-≈˘ x y∼z y≈x = x ≈⟨ sym y≈x ⟩ y∼z
-syntax step-≈˘ x y≈z y≈x = x ≈˘⟨ y≈x ⟩ y≈z
+-- Re-export the equality-based combinators instead
+open ≈-syntax _IsRelatedTo_ _IsRelatedTo_ ≈-Reasoning.∼-go sym public
diff --git a/src/Relation/Binary/Reasoning/Preorder.agda b/src/Relation/Binary/Reasoning/Preorder.agda
index 599be2f37b..aca729acc0 100644
--- a/src/Relation/Binary/Reasoning/Preorder.agda
+++ b/src/Relation/Binary/Reasoning/Preorder.agda
@@ -18,12 +18,12 @@
 --    u≈w = begin-equality
 --      u  ≈⟨ u≈v ⟩
 --      v  ≡⟨ v≡w ⟩
---      w  ≡˘⟨ x≡w ⟩
+--      w  ≡⟨ x≡w ⟨
 --      x  ∎
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Preorder)
 
 module Relation.Binary.Reasoning.Preorder
   {p₁ p₂ p₃} (P : Preorder p₁ p₂ p₃) where
diff --git a/src/Relation/Binary/Reasoning/Setoid.agda b/src/Relation/Binary/Reasoning/Setoid.agda
index 0c43af7bc7..d80b2546d7 100644
--- a/src/Relation/Binary/Reasoning/Setoid.agda
+++ b/src/Relation/Binary/Reasoning/Setoid.agda
@@ -15,33 +15,29 @@
 --   0         ∎
 
 -- Module `≡-Reasoning` in `Relation.Binary.PropositionalEquality`
--- is recommended for equational reasoning when the underlying equality is
--- `_≡_`.
+-- is recommended for equational reasoning when the underlying equality
+-- is `_≡_`.
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Setoid)
+open import Relation.Binary.Reasoning.Syntax using (module ≈-syntax)
 
 module Relation.Binary.Reasoning.Setoid {s₁ s₂} (S : Setoid s₁ s₂) where
 
 open Setoid S
 
+import Relation.Binary.Reasoning.Base.Single _≈_ refl trans
+  as SingleRelReasoning
+
 ------------------------------------------------------------------------
 -- Reasoning combinators
 
--- open import Relation.Binary.Reasoning.PartialSetoid partialSetoid public
-open import Relation.Binary.Reasoning.Base.Single _≈_ refl trans as Base public
+-- Export the combinators for single relation reasoning, hiding the
+-- single misnamed combinator.
+open SingleRelReasoning public
   hiding (step-∼)
+  renaming (∼-go to ≈-go)
 
-infixr 2 step-≈ step-≈˘
-
--- A step using an equality
-
-step-≈ = Base.step-∼
-syntax step-≈ x y≈z x≈y = x ≈⟨ x≈y ⟩ y≈z
-
--- A step using a symmetric equality
-
-step-≈˘ : ∀ x {y z} → y IsRelatedTo z → y ≈ x → x IsRelatedTo z
-step-≈˘ x y∼z y≈x = x ≈⟨ sym y≈x ⟩ y∼z
-syntax step-≈˘ x y≈z y≈x = x ≈˘⟨ y≈x ⟩ y≈z
+-- Re-export the equality-based combinators instead
+open ≈-syntax _IsRelatedTo_ _IsRelatedTo_ ≈-go sym public
diff --git a/src/Relation/Binary/Reasoning/StrictPartialOrder.agda b/src/Relation/Binary/Reasoning/StrictPartialOrder.agda
index 2e18d1fab7..ad23a68481 100644
--- a/src/Relation/Binary/Reasoning/StrictPartialOrder.agda
+++ b/src/Relation/Binary/Reasoning/StrictPartialOrder.agda
@@ -28,8 +28,8 @@
 --      w  <⟨ w<x ⟩
 --      x  ≤⟨ x≤y ⟩
 --      y  <⟨ y<z ⟩
---      z  ≡˘⟨ d≡z ⟩
---      d  ≈˘⟨ e≈d ⟩
+--      z  ≡⟨ d≡z ⟨
+--      d  ≈⟨ e≈d ⟨
 --      e  ∎
 --
 --    u≈w : u ≈ w
@@ -40,7 +40,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (StrictPartialOrder)
 
 module Relation.Binary.Reasoning.StrictPartialOrder
   {p₁ p₂ p₃} (S : StrictPartialOrder p₁ p₂ p₃) where
@@ -53,9 +53,11 @@ import Relation.Binary.Construct.StrictToNonStrict _≈_ _<_ as NonStrict
 
 open import Relation.Binary.Reasoning.Base.Triple
   (NonStrict.isPreorder₂ isStrictPartialOrder)
+  asym
   trans
   <-resp-≈
   NonStrict.<⇒≤
   (NonStrict.<-≤-trans trans <-respʳ-≈)
   (NonStrict.≤-<-trans Eq.sym trans <-respˡ-≈)
   public
+
diff --git a/src/Relation/Binary/Reasoning/Syntax.agda b/src/Relation/Binary/Reasoning/Syntax.agda
new file mode 100644
index 0000000000..3860f97b35
--- /dev/null
+++ b/src/Relation/Binary/Reasoning/Syntax.agda
@@ -0,0 +1,445 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Syntax for the building blocks of equational reasoning modules
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Level using (Level; _⊔_; suc)
+open import Relation.Nullary.Decidable.Core
+  using (Dec; True; toWitness)
+open import Relation.Nullary.Negation.Core using (contradiction)
+open import Relation.Binary.Core using (Rel; REL; _⇒_)
+open import Relation.Binary.Definitions
+  using (_Respectsʳ_; Asymmetric; Trans; Sym; Reflexive)
+open import Relation.Binary.PropositionalEquality.Core as ≡
+  using (_≡_)
+
+-- List of `Reasoning` modules that do not use this framework and so
+-- need to be updated manually if the syntax changes.
+--
+--   Data/Vec/Relation/Binary/Equality/Cast
+--   Relation/Binary/HeterogeneousEquality
+--   Effect/Monad/Partiality
+--   Effect/Monad/Partiality/All
+--   Codata/Guarded/Stream/Relation/Binary/Pointwise
+--   Function/Reasoning
+
+module Relation.Binary.Reasoning.Syntax where
+
+private
+  variable
+    a ℓ₁ ℓ₂ ℓ₃ ℓ₄ : Level
+    A B C : Set a
+    x y z : A
+
+------------------------------------------------------------------------
+-- Syntax for beginning a reasoning chain
+------------------------------------------------------------------------
+
+------------------------------------------------------------------------
+-- Basic begin syntax
+
+module begin-syntax
+  (R : REL A B ℓ₁)
+  {S : REL A B ℓ₂}
+  (reflexive : R ⇒ S)
+  where
+
+  infix 1 begin_
+
+  begin_ : R x y → S x y
+  begin_ = reflexive
+
+------------------------------------------------------------------------
+-- Begin subrelation syntax
+
+-- Sometimes we want to support sub-relations with the
+-- same reasoning operators as the main relations (e.g. perform equality
+-- proofs with non-strict reasoning operators). This record bundles all
+-- the parts needed to extract the sub-relation proofs.
+record SubRelation {A : Set a} (R : Rel A ℓ₁) ℓ₂ ℓ₃ : Set (a ⊔ ℓ₁ ⊔ suc ℓ₂ ⊔ suc ℓ₃) where
+  field
+    S : Rel A ℓ₂
+    IsS : R x y → Set ℓ₃
+    IsS? : ∀ (xRy : R x y) → Dec (IsS xRy)
+    extract : ∀ {xRy : R x y} → IsS xRy → S x y
+
+module begin-subrelation-syntax
+  (R : Rel A ℓ₁)
+  (sub : SubRelation R ℓ₂ ℓ₃)
+  where
+  open SubRelation sub
+
+  infix 1 begin_
+
+  begin_ : ∀ {x y} (xRy : R x y) → {s : True (IsS? xRy)} → S x y
+  begin_ r {s} = extract (toWitness s)
+
+-- Begin equality syntax
+module begin-equality-syntax
+  (R : Rel A ℓ₁)
+  (sub : SubRelation R ℓ₂ ℓ₃) where
+
+  open begin-subrelation-syntax R sub public
+    renaming (begin_ to begin-equality_)
+
+-- Begin apartness syntax
+module begin-apartness-syntax
+  (R : Rel A ℓ₁)
+  (sub : SubRelation R ℓ₂ ℓ₃) where
+
+  open begin-subrelation-syntax R sub public
+    renaming (begin_ to begin-apartness_)
+
+-- Begin strict syntax
+module begin-strict-syntax
+  (R : Rel A ℓ₁)
+  (sub : SubRelation R ℓ₂ ℓ₃) where
+
+  open begin-subrelation-syntax R sub public
+    renaming (begin_ to begin-strict_)
+
+------------------------------------------------------------------------
+-- Begin membership syntax
+
+module begin-membership-syntax
+  (R : Rel A ℓ₁)
+  (_∈_ : REL B A ℓ₂)
+  (resp : _∈_ Respectsʳ R) where
+
+  infix  1 step-∈
+
+  step-∈ : ∀ (x : B) {xs ys} → R xs ys → x ∈ xs → x ∈ ys
+  step-∈ x = resp
+
+  syntax step-∈ x  xs⊆ys x∈xs  = x ∈⟨ x∈xs ⟩ xs⊆ys
+
+------------------------------------------------------------------------
+-- Begin contradiction syntax
+
+-- Used with asymmetric subrelations to derive a contradiction from a
+-- proof that an element is related to itself.
+module begin-contradiction-syntax
+  (R : Rel A ℓ₁)
+  (sub : SubRelation R ℓ₂ ℓ₃)
+  (asym : Asymmetric (SubRelation.S sub))
+  where
+
+  open SubRelation sub
+
+  infix 1 begin-contradiction_
+
+  begin-contradiction_ : ∀ (xRx : R x x) {s : True (IsS? xRx)} →
+                         ∀ {b} {B : Set b} → B
+  begin-contradiction_ {x} r {s} = contradiction x<x (asym x<x)
+    where
+    x<x : S x x
+    x<x = extract (toWitness s)
+
+------------------------------------------------------------------------
+-- Syntax for continuing a chain of reasoning steps
+------------------------------------------------------------------------
+
+-- Note that the arguments to the `step`s are not provided in their
+-- "natural" order and syntax declarations are later used to re-order
+-- them. This is because the `step` ordering allows the type-checker to
+-- better infer the middle argument `y` from the `_IsRelatedTo_`
+-- argument (see issue 622).
+--
+-- This has two practical benefits. First it speeds up type-checking by
+-- approximately a factor of 5. Secondly it allows the combinators to be
+-- used with macros that use reflection, e.g. `Tactic.RingSolver`, where
+-- they need to be able to extract `y` using reflection.
+
+------------------------------------------------------------------------
+-- Syntax for unidirectional relations
+
+-- See https://github.com/agda/agda-stdlib/issues/2150 for a possible
+-- simplification.
+
+module _
+  {R : REL A B ℓ₂}
+  (S : REL B C ℓ₁)
+  (T : REL A C ℓ₃)
+  (step : Trans R S T)
+  where
+
+  forward : ∀ (x : A) {y z} → S y z → R x y → T x z
+  forward x yRz x∼y = step {x} x∼y yRz
+
+  -- Arbitrary relation syntax
+  module ∼-syntax where
+    infixr 2 step-∼
+    step-∼ = forward
+    syntax step-∼ x yRz x∼y = x ∼⟨ x∼y ⟩ yRz
+
+
+  -- Preorder syntax
+  module ≲-syntax where
+    infixr 2 step-≲
+    step-≲ = forward
+    syntax step-≲ x yRz x≲y = x ≲⟨ x≲y ⟩ yRz
+
+
+  -- Partial order syntax
+  module ≤-syntax where
+    infixr 2 step-≤
+    step-≤ = forward
+    syntax step-≤ x yRz x≤y = x ≤⟨ x≤y ⟩ yRz
+
+
+  -- Strict partial order syntax
+  module <-syntax where
+    infixr 2 step-<
+    step-< = forward
+    syntax step-< x yRz x<y = x <⟨ x<y ⟩ yRz
+
+
+  -- Subset order syntax
+  module ⊆-syntax where
+    infixr 2 step-⊆
+    step-⊆ = forward
+    syntax step-⊆ x yRz x⊆y = x ⊆⟨ x⊆y ⟩ yRz
+
+
+  -- Strict subset order syntax
+  module ⊂-syntax where
+    infixr 2 step-⊂
+    step-⊂ = forward
+    syntax step-⊂ x yRz x⊂y = x ⊂⟨ x⊂y ⟩ yRz
+
+
+  -- Square subset order syntax
+  module ⊑-syntax where
+    infixr 2 step-⊑
+    step-⊑ = forward
+    syntax step-⊑ x yRz x⊑y = x ⊑⟨ x⊑y ⟩ yRz
+
+
+  -- Strict square subset order syntax
+  module ⊏-syntax where
+    infixr 2 step-⊏
+    step-⊏ = forward
+    syntax step-⊏ x yRz x⊏y = x ⊏⟨ x⊏y ⟩ yRz
+
+
+  -- Divisibility syntax
+  module ∣-syntax where
+    infixr 2 step-∣
+    step-∣ = forward
+    syntax step-∣ x yRz x∣y = x ∣⟨ x∣y ⟩ yRz
+
+
+  -- Single-step syntax
+  module ⟶-syntax where
+    infixr 2 step-⟶
+    step-⟶ = forward
+    syntax step-⟶ x yRz x∣y = x ⟶⟨ x∣y ⟩ yRz
+
+
+  -- Multi-step syntax
+  module ⟶*-syntax where
+    infixr 2 step-⟶*
+    step-⟶* = forward
+    syntax step-⟶* x yRz x∣y = x ⟶*⟨ x∣y ⟩ yRz
+
+
+------------------------------------------------------------------------
+-- Syntax for bidirectional relations
+
+  module _
+    {U : REL B A ℓ₄}
+    (sym : Sym U R)
+    where
+
+    backward : ∀ x {y z} → S y z → U y x → T x z
+    backward x yRz x≈y = forward x yRz (sym x≈y)
+
+    -- Setoid equality syntax
+    module ≈-syntax where
+      infixr 2 step-≈-⟩ step-≈-⟨
+      step-≈-⟩ = forward
+      step-≈-⟨ = backward
+      syntax step-≈-⟩ x yRz x≈y = x ≈⟨ x≈y ⟩ yRz
+      syntax step-≈-⟨ x yRz y≈x = x ≈⟨ y≈x ⟨ yRz
+
+      -- Deprecated
+      infixr 2 step-≈ step-≈˘
+      step-≈ = step-≈-⟩
+      {-# WARNING_ON_USAGE step-≈
+      "Warning: step-≈ was deprecated in v2.0.
+      Please use step-≈-⟩ instead."
+      #-}
+      step-≈˘ = step-≈-⟨
+      {-# WARNING_ON_USAGE step-≈˘
+      "Warning: step-≈˘ and _≈˘⟨_⟩_ was deprecated in v2.0.
+      Please use step-≈-⟨ and _≈⟨_⟨_ instead."
+      #-}
+      syntax step-≈˘ x yRz y≈x = x ≈˘⟨ y≈x ⟩ yRz
+
+
+    -- Container equality syntax
+    module ≋-syntax where
+      infixr 2 step-≋-⟩ step-≋-⟨
+      step-≋-⟩ = forward
+      step-≋-⟨ = backward
+      syntax step-≋-⟩ x yRz x≋y = x ≋⟨ x≋y ⟩ yRz
+      syntax step-≋-⟨ x yRz y≋x = x ≋⟨ y≋x ⟨ yRz
+
+
+      -- Don't remove until https://github.com/agda/agda/issues/5617 fixed.
+      infixr 2 step-≋ step-≋˘
+      step-≋ = step-≋-⟩
+      {-# WARNING_ON_USAGE step-≋
+      "Warning: step-≋ was deprecated in v2.0.
+      Please use step-≋-⟩ instead."
+      #-}
+      step-≋˘ = step-≋-⟨
+      {-# WARNING_ON_USAGE step-≋˘
+      "Warning: step-≋˘ and _≋˘⟨_⟩_ was deprecated in v2.0.
+      Please use step-≋-⟨ and _≋⟨_⟨_ instead."
+      #-}
+      syntax step-≋˘ x yRz y≋x = x ≋˘⟨ y≋x ⟩ yRz
+
+
+    -- Other equality syntax
+    module ≃-syntax where
+      infixr 2 step-≃-⟩ step-≃-⟨
+      step-≃-⟩ = forward
+      step-≃-⟨ = backward
+      syntax step-≃-⟩ x yRz x≃y = x ≃⟨ x≃y ⟩ yRz
+      syntax step-≃-⟨ x yRz y≃x = x ≃⟨ y≃x ⟨ yRz
+
+
+    -- Apartness relation syntax
+    module #-syntax where
+      infixr 2 step-#-⟩ step-#-⟨
+      step-#-⟩ = forward
+      step-#-⟨ = backward
+      syntax step-#-⟩ x yRz x#y = x #⟨ x#y ⟩ yRz
+      syntax step-#-⟨ x yRz y#x = x #⟨ y#x ⟨ yRz
+
+      -- Don't remove until https://github.com/agda/agda/issues/5617 fixed.
+      infixr 2 step-# step-#˘
+      step-# = step-#-⟩
+      {-# WARNING_ON_USAGE step-#
+      "Warning: step-# was deprecated in v2.0.
+      Please use step-#-⟩ instead."
+      #-}
+      step-#˘ = step-#-⟨
+      {-# WARNING_ON_USAGE step-#˘
+      "Warning: step-#˘ and _#˘⟨_⟩_ was deprecated in v2.0.
+      Please use step-#-⟨ and _#⟨_⟨_ instead."
+      #-}
+      syntax step-#˘ x yRz y#x = x #˘⟨ y#x ⟩ yRz
+
+
+    -- Bijection syntax
+    module ⤖-syntax where
+      infixr 2 step-⤖ step-⬻
+      step-⤖ = forward
+      step-⬻ = backward
+      syntax step-⤖ x yRz x⤖y = x ⤖⟨ x⤖y ⟩ yRz
+      syntax step-⬻ x yRz y⤖x = x ⬻⟨ y⤖x ⟩ yRz
+
+
+    -- Inverse syntax
+    module ↔-syntax where
+      infixr 2 step-↔-⟩ step-↔-⟨
+      step-↔-⟩ = forward
+      step-↔-⟨ = backward
+      syntax step-↔-⟩ x yRz x↔y = x ↔⟨ x↔y ⟩ yRz
+      syntax step-↔-⟨ x yRz y↔x = x ↔⟨ y↔x ⟨ yRz
+
+
+    -- Inverse syntax
+    module ↭-syntax where
+      infixr 2 step-↭-⟩ step-↭-⟨
+      step-↭-⟩ = forward
+      step-↭-⟨ = backward
+      syntax step-↭-⟩ x yRz x↭y = x ↭⟨ x↭y ⟩ yRz
+      syntax step-↭-⟨ x yRz y↭x = x ↭⟨ y↭x ⟨ yRz
+
+
+      -- Don't remove until https://github.com/agda/agda/issues/5617 fixed.
+      infixr 2 step-↭ step-↭˘
+      step-↭ = forward
+      {-# WARNING_ON_USAGE step-↭
+      "Warning: step-↭ was deprecated in v2.0.
+      Please use step-↭-⟩ instead."
+      #-}
+      step-↭˘ = backward
+      {-# WARNING_ON_USAGE step-↭˘
+      "Warning: step-↭˘ and _↭˘⟨_⟩_ was deprecated in v2.0.
+      Please use step-↭-⟨ and _↭⟨_⟨_ instead."
+      #-}
+      syntax step-↭˘ x yRz y↭x = x ↭˘⟨ y↭x ⟩ yRz
+
+------------------------------------------------------------------------
+-- Propositional equality
+
+-- Crucially often the step function cannot just be `subst` or pattern
+-- match on `refl` as we often want to compute which constructor the
+-- relation begins with, in order for the implicit subrelation
+-- arguments to resolve. See `≡-noncomputable-syntax` below if this
+-- is not required.
+module ≡-syntax
+  (R : REL A B ℓ₁)
+  (step : Trans _≡_ R R)
+  where
+
+  infixr 2 step-≡-⟩  step-≡-∣ step-≡-⟨
+  step-≡-⟩ = forward R R step
+
+  step-≡-∣ : ∀ x {y} → R x y → R x y
+  step-≡-∣ x xRy = xRy
+
+  step-≡-⟨ = backward R R step ≡.sym
+
+  syntax step-≡-⟩ x yRz x≡y = x ≡⟨ x≡y ⟩ yRz
+  syntax step-≡-∣ x xRy     = x ≡⟨⟩ xRy
+  syntax step-≡-⟨ x yRz y≡x = x ≡⟨ y≡x ⟨ yRz
+
+
+  -- Don't remove until https://github.com/agda/agda/issues/5617 fixed.
+  infixr 2 step-≡ step-≡˘
+  step-≡ = step-≡-⟩
+  {-# WARNING_ON_USAGE step-≡
+  "Warning: step-≡ was deprecated in v2.0.
+  Please use step-≡-⟩ instead."
+  #-}
+  step-≡˘ = step-≡-⟨
+  {-# WARNING_ON_USAGE step-≡˘
+  "Warning: step-≡˘ and _≡˘⟨_⟩_ was deprecated in v2.0.
+  Please use step-≡-⟨ and _≡⟨_⟨_ instead."
+  #-}
+  syntax step-≡˘ x yRz y≡x = x ≡˘⟨ y≡x ⟩ yRz
+
+
+-- Unlike ≡-syntax above, chains of reasoning using this syntax will not
+-- reduce when proofs of propositional equality which are not definitionally
+-- equal to `refl` are passed.
+module ≡-noncomputing-syntax (R : REL A B ℓ₁) where
+
+  private
+    step : Trans _≡_ R R
+    step ≡.refl xRy = xRy
+
+  open ≡-syntax R step public
+
+------------------------------------------------------------------------
+-- Syntax for ending a chain of reasoning
+------------------------------------------------------------------------
+
+module end-syntax
+  (R : Rel A ℓ₁)
+  (reflexive : Reflexive R)
+  where
+
+  infix 3 _∎
+
+  _∎ : ∀ x → R x x
+  x ∎ = reflexive
+
diff --git a/src/Relation/Binary/Reflection.agda b/src/Relation/Binary/Reflection.agda
index 8b682a0407..12665df8cc 100644
--- a/src/Relation/Binary/Reflection.agda
+++ b/src/Relation/Binary/Reflection.agda
@@ -7,14 +7,14 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Data.Fin.Base
-open import Data.Nat.Base
-open import Data.Vec.Base as Vec
-open import Function.Base
+open import Data.Fin.Base using (Fin)
+open import Data.Nat.Base using (ℕ)
+open import Data.Vec.Base as Vec using (Vec; allFin)
+open import Function.Base using (id; _⟨_⟩_)
 open import Function.Bundles using (module Equivalence)
-open import Level
-open import Relation.Binary
-import Relation.Binary.PropositionalEquality as P
+open import Level using (Level)
+open import Relation.Binary.Bundles using (Setoid)
+import Relation.Binary.PropositionalEquality.Core as ≡
 
 -- Think of the parameters as follows:
 --
@@ -41,11 +41,11 @@ module Relation.Binary.Reflection
          where
 
 open import Data.Vec.N-ary
-open import Data.Product
-import Relation.Binary.Reasoning.Setoid as Eq
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂)
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
 open Setoid Sem
-open Eq Sem
+open ≈-Reasoning Sem
 
 -- If two normalised expressions are semantically equal, then their
 -- non-normalised forms are also equal.
@@ -91,7 +91,7 @@ solve₁ : ∀ n (f : N-ary n (Expr n) (Expr n × Expr n)) →
                  ⟦ proj₁ (close n f)  ⟧ ρ ≈ ⟦ proj₂ (close n f)  ⟧ ρ)
 solve₁ n f =
   Equivalence.from (uncurry-∀ⁿ n) λ ρ →
-    P.subst id (P.sym (left-inverse (λ _ → _ ≈ _ → _ ≈ _) ρ))
+    ≡.subst id (≡.sym (left-inverse (λ _ → _ ≈ _ → _ ≈ _) ρ))
       (prove ρ (proj₁ (close n f)) (proj₂ (close n f)))
 
 -- A variant of _,_ which is intended to make uses of solve and solve₁
diff --git a/src/Relation/Binary/Rewriting.agda b/src/Relation/Binary/Rewriting.agda
index 9006765413..de63347546 100644
--- a/src/Relation/Binary/Rewriting.agda
+++ b/src/Relation/Binary/Rewriting.agda
@@ -10,20 +10,20 @@
 module Relation.Binary.Rewriting where
 
 open import Agda.Builtin.Equality using (_≡_ ; refl)
-open import Data.Product using (_×_ ; ∃ ; -,_; _,_ ; proj₁ ; proj₂)
-open import Data.Empty
+open import Data.Product.Base using (_×_ ; ∃ ; -,_; _,_ ; proj₁ ; proj₂)
+open import Data.Empty using (⊥-elim)
 open import Function.Base using (flip)
-open import Induction.WellFounded
-open import Level
-open import Relation.Binary.Core
+open import Induction.WellFounded using (WellFounded; Acc; acc)
+open import Relation.Binary.Core using (REL; Rel)
 open import Relation.Binary.Construct.Closure.Equivalence using (EqClosure)
 open import Relation.Binary.Construct.Closure.Equivalence.Properties
-open import Relation.Binary.Construct.Closure.Reflexive
+  using (a—↠b&a—↠c⇒b↔c)
 open import Relation.Binary.Construct.Closure.ReflexiveTransitive
-open import Relation.Binary.Construct.Closure.Symmetric
+  using (Star; _◅_; ε; _◅◅_)
+open import Relation.Binary.Construct.Closure.Symmetric using (fwd; bwd)
 open import Relation.Binary.Construct.Closure.Transitive
-open import Relation.Binary.PropositionalEquality
-open import Relation.Nullary
+  using (Plus; [_]; _∼⁺⟨_⟩_)
+open import Relation.Nullary.Negation.Core using (¬_)
 
 -- The following definitions are taken from Klop [5]
 module _ {a ℓ} {A : Set a} (_⟶_ : Rel A ℓ) where
@@ -117,8 +117,8 @@ module _ {a ℓ} {A : Set a} {_⟶_ : Rel A ℓ} where
         jToInner = proj₁ (proj₂ wcrProof)
         kToInner = proj₂ (proj₂ wcrProof)
 
-        lhs = helper (g _ [ toJ ]) fst jToInner
-        rhs = helper (g _ [ toK ]) snd kToInner
+        lhs = helper (g [ toJ ]) fst jToInner
+        rhs = helper (g [ toK ]) snd kToInner
 
         fromAB = proj₁ (proj₂ lhs)
         fromInnerB = proj₂ (proj₂ lhs)
@@ -129,7 +129,7 @@ module _ {a ℓ} {A : Set a} {_⟶_ : Rel A ℓ} where
         aToInner : _ ⟶₊ innerPoint
         aToInner = starToPlus toJ jToInner
 
-        finalRecursion = helper (g innerPoint aToInner) fromInnerB fromInnerC
+        finalRecursion = helper (g aToInner) fromInnerB fromInnerC
 
         bMidToDest = proj₁ (proj₂ finalRecursion)
         cMidToDest = proj₂ (proj₂ finalRecursion)
diff --git a/src/Relation/Binary/Structures.agda b/src/Relation/Binary/Structures.agda
index 058ca5135c..14426b4cff 100644
--- a/src/Relation/Binary/Structures.agda
+++ b/src/Relation/Binary/Structures.agda
@@ -15,10 +15,10 @@ module Relation.Binary.Structures
   (_≈_ : Rel A ℓ)   -- The underlying equality relation
   where
 
-open import Data.Product using (proj₁; proj₂; _,_)
+open import Data.Product.Base using (proj₁; proj₂; _,_)
 open import Level using (Level; _⊔_)
 open import Relation.Nullary.Negation.Core using (¬_)
-open import Relation.Binary.PropositionalEquality.Core as P using (_≡_)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 open import Relation.Binary.Consequences
 open import Relation.Binary.Definitions
 
@@ -51,7 +51,7 @@ record IsEquivalence : Set (a ⊔ ℓ) where
     trans : Transitive _≈_
 
   reflexive : _≡_ ⇒ _≈_
-  reflexive P.refl = refl
+  reflexive ≡.refl = refl
 
   isPartialEquivalence : IsPartialEquivalence
   isPartialEquivalence = record
@@ -73,26 +73,42 @@ record IsDecEquivalence : Set (a ⊔ ℓ) where
 -- Preorders
 ------------------------------------------------------------------------
 
-record IsPreorder (_∼_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
+record IsPreorder (_≲_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
   field
     isEquivalence : IsEquivalence
     -- Reflexivity is expressed in terms of the underlying equality:
-    reflexive     : _≈_ ⇒ _∼_
-    trans         : Transitive _∼_
+    reflexive     : _≈_ ⇒ _≲_
+    trans         : Transitive _≲_
 
   module Eq = IsEquivalence isEquivalence
 
-  refl : Reflexive _∼_
+  refl : Reflexive _≲_
   refl = reflexive Eq.refl
 
-  ∼-respˡ-≈ : _∼_ Respectsˡ _≈_
-  ∼-respˡ-≈ x≈y x∼z = trans (reflexive (Eq.sym x≈y)) x∼z
+  ≲-respˡ-≈ : _≲_ Respectsˡ _≈_
+  ≲-respˡ-≈ x≈y x∼z = trans (reflexive (Eq.sym x≈y)) x∼z
 
-  ∼-respʳ-≈ : _∼_ Respectsʳ _≈_
-  ∼-respʳ-≈ x≈y z∼x = trans z∼x (reflexive x≈y)
+  ≲-respʳ-≈ : _≲_ Respectsʳ _≈_
+  ≲-respʳ-≈ x≈y z∼x = trans z∼x (reflexive x≈y)
 
-  ∼-resp-≈ : _∼_ Respects₂ _≈_
-  ∼-resp-≈ = ∼-respʳ-≈ , ∼-respˡ-≈
+  ≲-resp-≈ : _≲_ Respects₂ _≈_
+  ≲-resp-≈ = ≲-respʳ-≈ , ≲-respˡ-≈
+
+  ∼-respˡ-≈ = ≲-respˡ-≈
+  {-# WARNING_ON_USAGE ∼-respˡ-≈
+  "Warning: ∼-respˡ-≈ was deprecated in v2.0.
+  Please use ≲-respˡ-≈ instead. "
+  #-}
+  ∼-respʳ-≈ = ≲-respʳ-≈
+  {-# WARNING_ON_USAGE ∼-respʳ-≈
+  "Warning: ∼-respʳ-≈ was deprecated in v2.0.
+  Please use ≲-respʳ-≈ instead. "
+  #-}
+  ∼-resp-≈ = ≲-resp-≈
+  {-# WARNING_ON_USAGE ∼-resp-≈
+  "Warning: ∼-resp-≈ was deprecated in v2.0.
+  Please use ≲-resp-≈ instead. "
+  #-}
 
 
 record IsTotalPreorder (_≲_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
@@ -101,11 +117,6 @@ record IsTotalPreorder (_≲_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
     total      : Total _≲_
 
   open IsPreorder isPreorder public
-    renaming
-    ( ∼-respˡ-≈ to ≲-respˡ-≈
-    ; ∼-respʳ-≈ to ≲-respʳ-≈
-    ; ∼-resp-≈  to ≲-resp-≈
-    )
 
 
 ------------------------------------------------------------------------
@@ -235,16 +246,20 @@ record IsDecTotalOrder (_≤_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
 
 
 -- Note that these orders are decidable. The current implementation
--- of `Trichotomous` subsumes irreflexivity and asymmetry. Any reasonable
--- definition capturing these three properties implies decidability
--- as `Trichotomous` necessarily separates out the equality case.
+-- of `Trichotomous` subsumes irreflexivity and asymmetry. See
+-- `Relation.Binary.Structures.Biased` for ways of constructing this
+-- record without having to prove `isStrictPartialOrder`.
 
 record IsStrictTotalOrder (_<_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
   field
-    isEquivalence : IsEquivalence
-    trans         : Transitive _<_
-    compare       : Trichotomous _≈_ _<_
+    isStrictPartialOrder : IsStrictPartialOrder _<_
+    compare              : Trichotomous _≈_ _<_
 
+  open IsStrictPartialOrder isStrictPartialOrder public
+    hiding (module Eq)
+
+  -- `Trichotomous` necessarily separates out the equality case so
+  --  it implies decidability.
   infix 4 _≟_ _<?_
 
   _≟_ : Decidable _≈_
@@ -253,22 +268,6 @@ record IsStrictTotalOrder (_<_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) wher
   _<?_ : Decidable _<_
   _<?_ = tri⇒dec< compare
 
-  isDecEquivalence : IsDecEquivalence
-  isDecEquivalence = record
-    { isEquivalence = isEquivalence
-    ; _≟_           = _≟_
-    }
-
-  module Eq = IsDecEquivalence isDecEquivalence
-
-  isStrictPartialOrder : IsStrictPartialOrder _<_
-  isStrictPartialOrder = record
-    { isEquivalence = isEquivalence
-    ; irrefl        = tri⇒irr compare
-    ; trans         = trans
-    ; <-resp-≈      = trans∧tri⇒resp Eq.sym Eq.trans trans compare
-    }
-
   isDecStrictPartialOrder : IsDecStrictPartialOrder _<_
   isDecStrictPartialOrder = record
     { isStrictPartialOrder = isStrictPartialOrder
@@ -276,8 +275,33 @@ record IsStrictTotalOrder (_<_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) wher
     ; _<?_                 = _<?_
     }
 
-  open IsStrictPartialOrder isStrictPartialOrder public
-    using (irrefl; asym; <-respʳ-≈; <-respˡ-≈; <-resp-≈)
+  -- Redefine the `Eq` module to include decidability proofs
+  module Eq where
+
+    isDecEquivalence : IsDecEquivalence
+    isDecEquivalence = record
+      { isEquivalence = isEquivalence
+      ; _≟_           = _≟_
+      }
+
+    open IsDecEquivalence isDecEquivalence public
+
+  isDecEquivalence : IsDecEquivalence
+  isDecEquivalence = record
+    { isEquivalence = isEquivalence
+    ; _≟_           = _≟_
+    }
+  {-# WARNING_ON_USAGE isDecEquivalence
+  "Warning: isDecEquivalence was deprecated in v2.0.
+  Please use Eq.isDecEquivalence instead. "
+  #-}
+
+record IsDenseLinearOrder (_<_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
+  field
+    isStrictTotalOrder : IsStrictTotalOrder _<_
+    dense              : Dense _<_
+
+  open IsStrictTotalOrder isStrictTotalOrder public
 
 
 ------------------------------------------------------------------------
diff --git a/src/Relation/Binary/Structures/Biased.agda b/src/Relation/Binary/Structures/Biased.agda
new file mode 100644
index 0000000000..83636aa5d6
--- /dev/null
+++ b/src/Relation/Binary/Structures/Biased.agda
@@ -0,0 +1,49 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Ways to give instances of certain structures where some fields can
+-- be given in terms of others
+------------------------------------------------------------------------
+
+-- The contents of this module should be accessed via `Relation.Binary`.
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+open import Relation.Binary.Core
+
+module Relation.Binary.Structures.Biased
+  {a ℓ} {A : Set a} -- The underlying set
+  (_≈_ : Rel A ℓ)   -- The underlying equality relation
+  where
+
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Consequences
+open import Relation.Binary.Definitions
+open import Relation.Binary.Structures _≈_
+
+private
+  variable
+    ℓ₂ : Level
+
+-- To construct a StrictTotalOrder you only need to prove transitivity and
+-- trichotomy as the current implementation of `Trichotomous` subsumes
+-- irreflexivity and asymmetry.
+record IsStrictTotalOrderᶜ (_<_ : Rel A ℓ₂) : Set (a ⊔ ℓ ⊔ ℓ₂) where
+  field
+    isEquivalence : IsEquivalence
+    trans         : Transitive _<_
+    compare       : Trichotomous _≈_ _<_
+
+  isStrictTotalOrderᶜ : IsStrictTotalOrder _<_
+  isStrictTotalOrderᶜ = record
+    { isStrictPartialOrder = record
+      { isEquivalence = isEquivalence
+      ; irrefl = tri⇒irr compare
+      ; trans = trans
+      ; <-resp-≈ = trans∧tri⇒resp Eq.sym Eq.trans trans compare
+      }
+    ; compare = compare
+    } where module Eq = IsEquivalence isEquivalence
+
+open IsStrictTotalOrderᶜ public
+  using (isStrictTotalOrderᶜ)
diff --git a/src/Relation/Nary.agda b/src/Relation/Nary.agda
index 5e6ecb5b25..64308696fe 100644
--- a/src/Relation/Nary.agda
+++ b/src/Relation/Nary.agda
@@ -19,7 +19,7 @@ open import Data.Unit.Base
 open import Data.Bool.Base using (true; false)
 open import Data.Empty
 open import Data.Nat.Base using (zero; suc)
-open import Data.Product as Prod using (_×_; _,_)
+open import Data.Product.Base as Product using (_×_; _,_)
 open import Data.Product.Nary.NonDependent
 open import Data.Sum.Base using (_⊎_)
 open import Function.Base using (_$_; _∘′_)
@@ -27,7 +27,7 @@ open import Function.Nary.NonDependent
 open import Relation.Nullary.Negation using (¬_)
 open import Relation.Nullary.Decidable as Dec using (Dec; yes; no; _because_; _×-dec_)
 import Relation.Unary as Unary
-open import Relation.Binary.PropositionalEquality using (_≡_; cong; subst)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong; subst)
 
 private
   variable
@@ -105,10 +105,10 @@ module _ {n r ls} {as : Sets n ls} (P : as ⇉ Set r) where
 ------------------------------------------------------------------------
 -- Pointwise liftings of k-ary operators
 
--- Rather than having multiple ad-hoc lifting functions for various arities
--- we have a fully generic liftₙ functional which lifts a k-ary operator
--- to work with k n-ary functions whose respective codomains match the domains
--- of the operator.
+-- Rather than having multiple ad-hoc lifting functions for various
+-- arities we have a fully generic liftₙ functional which lifts a k-ary
+-- operator to work with k n-ary functions whose respective codomains
+-- match the domains of the operator.
 -- The type of liftₙ is fairly unreadable. Here it is written with ellipsis:
 
 -- liftₙ : ∀ k n. (B₁ → ⋯ → Bₖ → R) →
diff --git a/src/Relation/Nullary.agda b/src/Relation/Nullary.agda
index b8a4c30470..5ea302fd98 100644
--- a/src/Relation/Nullary.agda
+++ b/src/Relation/Nullary.agda
@@ -10,28 +10,33 @@
 
 module Relation.Nullary where
 
-open import Agda.Builtin.Equality
+open import Agda.Builtin.Equality using (_≡_)
+open import Agda.Builtin.Maybe using (Maybe)
+open import Level using (Level)
 
-------------------------------------------------------------------------
--- Re-exports
+private
+  variable
+    p : Level
+    P : Set p
 
-open import Relation.Nullary.Negation.Core public using
-  ( ¬_; _¬-⊎_
-  ; contradiction; contradiction₂; contraposition
-  )
 
-open import Relation.Nullary.Reflects public using
-  ( Reflects; ofʸ; ofⁿ
-  ; _×-reflects_; _⊎-reflects_; _→-reflects_
-  )
+------------------------------------------------------------------------
+-- Re-exports
 
-open import Relation.Nullary.Decidable.Core public using
-  ( Dec; does; proof; yes; no; _because_; recompute
-  ; ¬?; _×-dec_; _⊎-dec_; _→-dec_
-  )
+open import Relation.Nullary.Recomputable public using (Recomputable)
+open import Relation.Nullary.Negation.Core public
+open import Relation.Nullary.Reflects public hiding (recompute; recompute-constant)
+open import Relation.Nullary.Decidable.Core public
 
 ------------------------------------------------------------------------
 -- Irrelevant types
 
-Irrelevant : ∀ {p} → Set p → Set p
+Irrelevant : Set p → Set p
 Irrelevant P = ∀ (p₁ p₂ : P) → p₁ ≡ p₂
+
+------------------------------------------------------------------------
+-- Weak decidability
+-- `nothing` is 'don't know'/'give up'; `just` is `yes`/`definitely`
+
+WeaklyDecidable : Set p → Set p
+WeaklyDecidable = Maybe
diff --git a/src/Relation/Nullary/Construct/Add/Extrema.agda b/src/Relation/Nullary/Construct/Add/Extrema.agda
index 4b88fb3b3e..3366d83c27 100644
--- a/src/Relation/Nullary/Construct/Add/Extrema.agda
+++ b/src/Relation/Nullary/Construct/Add/Extrema.agda
@@ -8,7 +8,7 @@
 
 module Relation.Nullary.Construct.Add.Extrema where
 
-open import Relation.Binary.PropositionalEquality using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 open import Relation.Nullary.Construct.Add.Infimum  as Infimum  using (_₋)
 open import Relation.Nullary.Construct.Add.Supremum as Supremum using (_⁺)
 
diff --git a/src/Relation/Nullary/Decidable.agda b/src/Relation/Nullary/Decidable.agda
index a8970d9df5..4b28ed43f1 100644
--- a/src/Relation/Nullary/Decidable.agda
+++ b/src/Relation/Nullary/Decidable.agda
@@ -9,23 +9,22 @@
 module Relation.Nullary.Decidable where
 
 open import Level using (Level)
-open import Data.Bool.Base using (true; false; if_then_else_)
-open import Data.Empty using (⊥-elim)
-open import Data.Product as Prod hiding (map)
-open import Data.Sum.Base as Sum hiding (map)
-open import Function.Base
+open import Data.Bool.Base using (true; false)
+open import Data.Product.Base using (∃; _,_)
 open import Function.Bundles using
-  (Injection; module Injection; module Equivalence; _⇔_; _↔_; mk↔′)
-open import Relation.Binary using (Setoid; module Setoid; Decidable)
-open import Relation.Nullary
-open import Relation.Nullary.Negation
+  (Injection; module Injection; module Equivalence; _⇔_; _↔_; mk↔ₛ′)
+open import Relation.Binary.Bundles using (Setoid; module Setoid)
+open import Relation.Binary.Definitions using (Decidable)
+open import Relation.Nullary using (Irrelevant)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
 open import Relation.Nullary.Reflects using (invert)
-open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong′)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; sym; trans; cong′)
 
 private
   variable
-    p q r : Level
-    P Q R : Set p
+    a b ℓ₁ ℓ₂ : Level
+    A B : Set a
 
 ------------------------------------------------------------------------
 -- Re-exporting the core definitions
@@ -35,56 +34,49 @@ open import Relation.Nullary.Decidable.Core public
 ------------------------------------------------------------------------
 -- Maps
 
-map : P ⇔ Q → Dec P → Dec Q
-map P⇔Q = map′ to from
-  where open Equivalence P⇔Q
+map : A ⇔ B → Dec A → Dec B
+map A⇔B = map′ to from
+  where open Equivalence A⇔B
 
-module _ {a₁ a₂ b₁ b₂} {A : Setoid a₁ a₂} {B : Setoid b₁ b₂}
-         (inj : Injection A B)
-  where
-
-  open Injection inj
-  open Setoid A using () renaming (_≈_ to _≈A_)
-  open Setoid B using () renaming (_≈_ to _≈B_)
-
-  -- If there is an injection from one setoid to another, and the
-  -- latter's equivalence relation is decidable, then the former's
-  -- equivalence relation is also decidable.
-
-  via-injection : Decidable _≈B_ → Decidable _≈A_
-  via-injection dec x y =
-    map′ injective cong (dec (to x) (to y))
+-- If there is an injection from one setoid to another, and the
+-- latter's equivalence relation is decidable, then the former's
+-- equivalence relation is also decidable.
+via-injection : {S : Setoid a ℓ₁} {T : Setoid b ℓ₂}
+                (inj : Injection S T) (open Injection inj) →
+                Decidable Eq₂._≈_ → Decidable Eq₁._≈_
+via-injection inj _≟_ x y = map′ injective cong (to x ≟ to y)
+  where open Injection inj
 
 ------------------------------------------------------------------------
 -- A lemma relating True and Dec
 
-True-↔ : (dec : Dec P) → Irrelevant P → True dec ↔ P
-True-↔ (true  because  [p]) irr = mk↔′ (λ _ → invert [p]) _ (irr (invert [p])) cong′
-True-↔ (false because ofⁿ ¬p) _ = mk↔′ (λ ()) (invert (ofⁿ ¬p)) (⊥-elim ∘ ¬p) λ ()
+True-↔ : (a? : Dec A) → Irrelevant A → True a? ↔ A
+True-↔ (true  because [a]) irr = let a = invert [a] in mk↔ₛ′ (λ _ → a) _ (irr a) cong′
+True-↔ (false because [¬a]) _  = let ¬a = invert [¬a] in mk↔ₛ′ (λ ()) ¬a (λ a → contradiction a ¬a) λ ()
 
 ------------------------------------------------------------------------
 -- Result of decidability
 
-isYes≗does : (P? : Dec P) → isYes P? ≡ does P?
+isYes≗does : (a? : Dec A) → isYes a? ≡ does a?
 isYes≗does (true  because _) = refl
 isYes≗does (false because _) = refl
 
-dec-true : (p? : Dec P) → P → does p? ≡ true
-dec-true (true  because   _ ) p = refl
-dec-true (false because [¬p]) p = ⊥-elim (invert [¬p] p)
+dec-true : (a? : Dec A) → A → does a? ≡ true
+dec-true (true  because   _ ) a = refl
+dec-true (false because [¬a]) a = contradiction a (invert [¬a])
+
+dec-false : (a? : Dec A) → ¬ A → does a? ≡ false
+dec-false (false because  _ ) ¬a = refl
+dec-false (true  because [a]) ¬a = contradiction (invert [a]) ¬a
 
-dec-false : (p? : Dec P) → ¬ P → does p? ≡ false
-dec-false (false because  _ ) ¬p = refl
-dec-false (true  because [p]) ¬p = ⊥-elim (¬p (invert [p]))
+dec-yes : (a? : Dec A) → A → ∃ λ a → a? ≡ yes a
+dec-yes a? a with yes a′ ← a? | refl ← dec-true a? a = a′ , refl
 
-dec-yes : (p? : Dec P) → P → ∃ λ p′ → p? ≡ yes p′
-dec-yes p? p with dec-true p? p
-dec-yes (yes p′) p | refl = p′ , refl
+dec-no : (a? : Dec A) (¬a : ¬ A) → a? ≡ no ¬a
+dec-no a? ¬a with no _ ← a? | refl ← dec-false a? ¬a = refl
 
-dec-no : (p? : Dec P) (¬p : ¬ P) → p? ≡ no ¬p
-dec-no p? ¬p with dec-false p? ¬p
-dec-no (no _) _ | refl = refl
+dec-yes-irr : (a? : Dec A) → Irrelevant A → (a : A) → a? ≡ yes a
+dec-yes-irr a? irr a with a′ , eq ← dec-yes a? a rewrite irr a a′ = eq
 
-dec-yes-irr : (p? : Dec P) → Irrelevant P → (p : P) → p? ≡ yes p
-dec-yes-irr p? irr p with dec-yes p? p
-... | p′ , eq rewrite irr p p′ = eq
+⌊⌋-map′ : ∀ t f (a? : Dec A) → ⌊ map′ {B = B} t f a? ⌋ ≡ ⌊ a? ⌋
+⌊⌋-map′ t f a? = trans (isYes≗does (map′ t f a?)) (sym (isYes≗does a?))
diff --git a/src/Relation/Nullary/Decidable/Core.agda b/src/Relation/Nullary/Decidable/Core.agda
index c8d92f9375..3715c248e9 100644
--- a/src/Relation/Nullary/Decidable/Core.agda
+++ b/src/Relation/Nullary/Decidable/Core.agda
@@ -11,22 +11,27 @@
 
 module Relation.Nullary.Decidable.Core where
 
-open import Level using (Level; Lift)
-open import Data.Bool.Base using (Bool; false; true; not; T; _∧_; _∨_)
-open import Data.Unit.Base using (⊤)
-open import Data.Empty using (⊥)
-open import Data.Empty.Irrelevant using (⊥-elim)
-open import Data.Product using (_×_)
-open import Data.Sum.Base using (_⊎_)
+-- decToMaybe was deprecated in v2.1 #2330/#2336
+-- this can go through `Data.Maybe.Base` once that deprecation is fully done.
+open import Agda.Builtin.Maybe using (Maybe; just; nothing)
+
+open import Agda.Builtin.Equality using (_≡_)
+open import Level using (Level)
+open import Data.Bool.Base using (Bool; T; false; true; not; _∧_; _∨_)
+open import Data.Unit.Polymorphic.Base using (⊤)
+open import Data.Product.Base using (_×_)
+open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 open import Function.Base using (_∘_; const; _$_; flip)
-open import Relation.Nullary.Reflects
+open import Relation.Nullary.Recomputable as Recomputable hiding (recompute-constant)
+open import Relation.Nullary.Reflects as Reflects hiding (recompute; recompute-constant)
 open import Relation.Nullary.Negation.Core
+  using (¬_; Stable; negated-stable; contradiction; DoubleNegation)
+
 
 private
   variable
-    p q : Level
-    P : Set p
-    Q : Set q
+    a b : Level
+    A B : Set a
 
 ------------------------------------------------------------------------
 -- Definition.
@@ -36,30 +41,46 @@ private
 -- reflects the boolean result. This definition allows the boolean
 -- part of the decision procedure to compute independently from the
 -- proof. This leads to better computational behaviour when we only care
--- about the result and not the proof. See README.Decidability for
--- further details.
+-- about the result and not the proof. See README.Design.Decidability
+-- for further details.
 
 infix 2 _because_
 
-record Dec {p} (P : Set p) : Set p where
+record Dec (A : Set a) : Set a where
   constructor _because_
   field
     does  : Bool
-    proof : Reflects P does
+    proof : Reflects A does
 
 open Dec public
 
-pattern yes p =  true because ofʸ  p
-pattern no ¬p = false because ofⁿ ¬p
+pattern yes a =  true because ofʸ  a
+pattern no ¬a = false because ofⁿ ¬a
+
+------------------------------------------------------------------------
+-- Flattening
+
+module _ {A : Set a} where
+
+  From-yes : Dec A → Set a
+  From-yes (true  because _) = A
+  From-yes (false because _) = ⊤
+
+  From-no : Dec A → Set a
+  From-no (false because _) = ¬ A
+  From-no (true  because _) = ⊤
 
 ------------------------------------------------------------------------
 -- Recompute
 
 -- Given an irrelevant proof of a decidable type, a proof can
 -- be recomputed and subsequently used in relevant contexts.
-recompute : ∀ {a} {A : Set a} → Dec A → .A → A
-recompute (yes x) _ = x
-recompute (no ¬p) x = ⊥-elim (¬p x)
+
+recompute : Dec A → Recomputable A
+recompute = Reflects.recompute ∘ proof
+
+recompute-constant : (a? : Dec A) (p q : A) → recompute a? p ≡ recompute a? q
+recompute-constant = Recomputable.recompute-constant ∘ recompute
 
 ------------------------------------------------------------------------
 -- Interaction with negation, sum, product etc.
@@ -67,41 +88,63 @@ recompute (no ¬p) x = ⊥-elim (¬p x)
 infixr 1 _⊎-dec_
 infixr 2 _×-dec_ _→-dec_
 
-¬? : Dec P → Dec (¬ P)
-does  (¬? p?) = not (does p?)
-proof (¬? p?) = ¬-reflects (proof p?)
+T? : ∀ x → Dec (T x)
+T? x = x because T-reflects x
+
+¬? : Dec A → Dec (¬ A)
+does  (¬? a?) = not (does a?)
+proof (¬? a?) = ¬-reflects (proof a?)
+
+_×-dec_ : Dec A → Dec B → Dec (A × B)
+does  (a? ×-dec b?) = does a? ∧ does b?
+proof (a? ×-dec b?) = proof a? ×-reflects proof b?
 
-_×-dec_ : Dec P → Dec Q → Dec (P × Q)
-does  (p? ×-dec q?) = does p? ∧ does q?
-proof (p? ×-dec q?) = proof p? ×-reflects proof q?
+_⊎-dec_ : Dec A → Dec B → Dec (A ⊎ B)
+does  (a? ⊎-dec b?) = does a? ∨ does b?
+proof (a? ⊎-dec b?) = proof a? ⊎-reflects proof b?
 
-_⊎-dec_ : Dec P → Dec Q → Dec (P ⊎ Q)
-does  (p? ⊎-dec q?) = does p? ∨ does q?
-proof (p? ⊎-dec q?) = proof p? ⊎-reflects proof q?
+_→-dec_ : Dec A → Dec B → Dec (A → B)
+does  (a? →-dec b?) = not (does a?) ∨ does b?
+proof (a? →-dec b?) = proof a? →-reflects proof b?
 
-_→-dec_ : Dec P → Dec Q → Dec (P → Q)
-does  (p? →-dec q?) = not (does p?) ∨ does q?
-proof (p? →-dec q?) = proof p? →-reflects proof q?
+------------------------------------------------------------------------
+-- Relationship with Maybe
+
+dec⇒maybe : Dec A → Maybe A
+dec⇒maybe ( true because [a]) = just (invert [a])
+dec⇒maybe (false because  _ ) = nothing
+
+------------------------------------------------------------------------
+-- Relationship with Sum
+
+toSum : Dec A → A ⊎ ¬ A
+toSum ( true because  [p]) = inj₁ (invert  [p])
+toSum (false because [¬p]) = inj₂ (invert [¬p])
+
+fromSum : A ⊎ ¬ A → Dec A
+fromSum (inj₁ p)  = yes p
+fromSum (inj₂ ¬p) = no ¬p
 
 ------------------------------------------------------------------------
 -- Relationship with booleans
 
--- `isYes` is a stricter version of `does`. The lack of computation means that
--- we can recover the proposition `P` from `isYes P?` by unification. This is
--- useful when we are using the decision procedure for proof automation.
+-- `isYes` is a stricter version of `does`. The lack of computation
+-- means that we can recover the proposition `P` from `isYes a?` by
+-- unification. This is useful when we are using the decision procedure
+-- for proof automation.
 
-isYes : Dec P → Bool
+isYes : Dec A → Bool
 isYes (true  because _) = true
 isYes (false because _) = false
 
-isNo : Dec P → Bool
+isNo : Dec A → Bool
 isNo = not ∘ isYes
 
-True : Dec P → Set
-True Q = T (isYes Q)
+True : Dec A → Set
+True = T ∘ isYes
 
-False : Dec P → Set
-False Q = T (isNo Q)
+False : Dec A → Set
+False = T ∘ isNo
 
 -- The traditional name for isYes is ⌊_⌋, indicating the stripping of evidence.
 ⌊_⌋ = isYes
@@ -110,70 +153,93 @@ False Q = T (isNo Q)
 -- Witnesses
 
 -- Gives a witness to the "truth".
-toWitness : {Q : Dec P} → True Q → P
-toWitness {Q = true  because [p]} _  = invert [p]
-toWitness {Q = false because  _ } ()
+toWitness : {a? : Dec A} → True a? → A
+toWitness {a? = true  because [a]} _  = invert [a]
+toWitness {a? = false because  _ } ()
 
 -- Establishes a "truth", given a witness.
-fromWitness : {Q : Dec P} → P → True Q
-fromWitness {Q = true  because   _ } = const _
-fromWitness {Q = false because [¬p]} = invert [¬p]
+fromWitness : {a? : Dec A} → A → True a?
+fromWitness {a? = true  because   _ } = const _
+fromWitness {a? = false because [¬a]} = invert [¬a]
 
 -- Variants for False.
-toWitnessFalse : {Q : Dec P} → False Q → ¬ P
-toWitnessFalse {Q = true  because   _ } ()
-toWitnessFalse {Q = false because [¬p]} _  = invert [¬p]
+toWitnessFalse : {a? : Dec A} → False a? → ¬ A
+toWitnessFalse {a? = true  because   _ } ()
+toWitnessFalse {a? = false because [¬a]} _  = invert [¬a]
 
-fromWitnessFalse : {Q : Dec P} → ¬ P → False Q
-fromWitnessFalse {Q = true  because [p]} = flip _$_ (invert [p])
-fromWitnessFalse {Q = false because  _ } = const _
-
-module _ {p} {P : Set p} where
+fromWitnessFalse : {a? : Dec A} → ¬ A → False a?
+fromWitnessFalse {a? = true  because [a]} = flip _$_ (invert [a])
+fromWitnessFalse {a? = false because  _ } = const _
 
 -- If a decision procedure returns "yes", then we can extract the
 -- proof using from-yes.
-
-  From-yes : Dec P → Set p
-  From-yes (true  because _) = P
-  From-yes (false because _) = Lift p ⊤
-
-  from-yes : (p : Dec P) → From-yes p
-  from-yes (true  because [p]) = invert [p]
-  from-yes (false because _ ) = _
+from-yes : (a? : Dec A) → From-yes a?
+from-yes (true  because [a]) = invert [a]
+from-yes (false because _ ) = _
 
 -- If a decision procedure returns "no", then we can extract the proof
 -- using from-no.
-
-  From-no : Dec P → Set p
-  From-no (false because _) = ¬ P
-  From-no (true  because _) = Lift p ⊤
-
-  from-no : (p : Dec P) → From-no p
-  from-no (false because [¬p]) = invert [¬p]
-  from-no (true  because   _ ) = _
+from-no : (a? : Dec A) → From-no a?
+from-no (false because [¬a]) = invert [¬a]
+from-no (true  because   _ ) = _
 
 ------------------------------------------------------------------------
 -- Maps
 
-map′ : (P → Q) → (Q → P) → Dec P → Dec Q
-does  (map′ P→Q Q→P p?)                   = does p?
-proof (map′ P→Q Q→P (true  because  [p])) = ofʸ (P→Q (invert [p]))
-proof (map′ P→Q Q→P (false because [¬p])) = ofⁿ (invert [¬p] ∘ Q→P)
+map′ : (A → B) → (B → A) → Dec A → Dec B
+does  (map′ A→B B→A a?)                   = does a?
+proof (map′ A→B B→A (true  because  [a])) = of (A→B (invert [a]))
+proof (map′ A→B B→A (false because [¬a])) = of (invert [¬a] ∘ B→A)
 
 ------------------------------------------------------------------------
 -- Relationship with double-negation
 
 -- Decidable predicates are stable.
 
-decidable-stable : Dec P → Stable P
-decidable-stable (yes p) ¬¬p = p
-decidable-stable (no ¬p) ¬¬p = ⊥-elim (¬¬p ¬p)
+decidable-stable : Dec A → Stable A
+decidable-stable (true  because  [a]) ¬¬a = invert [a]
+decidable-stable (false because [¬a]) ¬¬a = contradiction (invert [¬a]) ¬¬a
 
-¬-drop-Dec : Dec (¬ ¬ P) → Dec (¬ P)
-¬-drop-Dec ¬¬p? = map′ negated-stable contradiction (¬? ¬¬p?)
+¬-drop-Dec : Dec (¬ ¬ A) → Dec (¬ A)
+¬-drop-Dec ¬¬a? = map′ negated-stable contradiction (¬? ¬¬a?)
 
 -- A double-negation-translated variant of excluded middle (or: every
 -- nullary relation is decidable in the double-negation monad).
 
-excluded-middle : DoubleNegation (Dec P)
-excluded-middle ¬h = ¬h (no (λ p → ¬h (yes p)))
+¬¬-excluded-middle : DoubleNegation (Dec A)
+¬¬-excluded-middle ¬?a = ¬?a (no (λ a → ¬?a (yes a)))
+
+
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
+
+excluded-middle = ¬¬-excluded-middle
+{-# WARNING_ON_USAGE excluded-middle
+"Warning: excluded-middle was deprecated in v2.0.
+Please use ¬¬-excluded-middle instead."
+#-}
+
+-- Version 2.1
+
+decToMaybe = dec⇒maybe
+{-# WARNING_ON_USAGE decToMaybe
+"Warning: decToMaybe was deprecated in v2.1.
+Please use Relation.Nullary.Decidable.Core.dec⇒maybe instead."
+#-}
+
+fromDec = toSum
+{-# WARNING_ON_USAGE fromDec
+"Warning: fromDec was deprecated in v2.1.
+Please use Relation.Nullary.Decidable.Core.toSum instead."
+#-}
+
+toDec = fromSum
+{-# WARNING_ON_USAGE toDec
+"Warning: toDec was deprecated in v2.1.
+Please use Relation.Nullary.Decidable.Core.fromSum instead."
+#-}
diff --git a/src/Relation/Nullary/Indexed/Negation.agda b/src/Relation/Nullary/Indexed/Negation.agda
index 45c6a9e2a1..4a742baea3 100644
--- a/src/Relation/Nullary/Indexed/Negation.agda
+++ b/src/Relation/Nullary/Indexed/Negation.agda
@@ -10,7 +10,7 @@ module Relation.Nullary.Indexed.Negation where
 
 open import Axiom.Extensionality.Propositional using (Extensionality)
 open import Data.Empty.Polymorphic
-open import Function
+open import Function.Bundles using (_↔_)
 open import Function.Properties
 import Function.Construct.Identity as Identity
 open import Relation.Nullary.Indexed
diff --git a/src/Relation/Nullary/Negation.agda b/src/Relation/Nullary/Negation.agda
index 6f663e73ac..5372ac5f5e 100644
--- a/src/Relation/Nullary/Negation.agda
+++ b/src/Relation/Nullary/Negation.agda
@@ -8,24 +8,20 @@
 
 module Relation.Nullary.Negation where
 
-open import Effect.Monad
-open import Data.Bool.Base using (Bool; false; true; if_then_else_; not)
-open import Data.Empty
-open import Data.Product as Prod
+open import Data.Bool.Base using (Bool; false; true; if_then_else_)
+open import Data.Product.Base as Product using (_,_; Σ; Σ-syntax; ∃; curry; uncurry)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; [_,_])
-open import Function.Base
-open import Level
-open import Relation.Nullary.Negation.Core
-open import Relation.Nullary.Decidable.Core
-open import Relation.Unary
+open import Effect.Monad using (RawMonad; mkRawMonad)
+open import Function.Base using (flip; _∘_; const; _∘′_)
+open import Level using (Level)
+open import Relation.Nullary.Decidable.Core using (Dec; yes; no; ¬¬-excluded-middle)
+open import Relation.Unary using (Universal; Pred)
 
 private
   variable
-    a p q r w : Level
-    A : Set a
-    P : Set p
-    Q : Set q
-    R : Set r
+    a b c d p w : Level
+    A B C D : Set a
+    P : Pred A p
     Whatever : Set w
 
 ------------------------------------------------------------------------
@@ -36,22 +32,20 @@ open import Relation.Nullary.Negation.Core public
 ------------------------------------------------------------------------
 -- Quantifier juggling
 
-module _ {P : A → Set p} where
+∃⟶¬∀¬ : ∃ P → ¬ (∀ x → ¬ P x)
+∃⟶¬∀¬ = flip uncurry
 
-  ∃⟶¬∀¬ : ∃ P → ¬ (∀ x → ¬ P x)
-  ∃⟶¬∀¬ = flip uncurry
+∀⟶¬∃¬ : (∀ x → P x) → ¬ ∃ λ x → ¬ P x
+∀⟶¬∃¬ ∀xPx (x , ¬Px) = ¬Px (∀xPx x)
 
-  ∀⟶¬∃¬ : (∀ x → P x) → ¬ ∃ λ x → ¬ P x
-  ∀⟶¬∃¬ ∀xPx (x , ¬Px) = ¬Px (∀xPx x)
+¬∃⟶∀¬ : ¬ ∃ (λ x → P x) → ∀ x → ¬ P x
+¬∃⟶∀¬ = curry
 
-  ¬∃⟶∀¬ : ¬ ∃ (λ x → P x) → ∀ x → ¬ P x
-  ¬∃⟶∀¬ = curry
+∀¬⟶¬∃ : (∀ x → ¬ P x) → ¬ ∃ (λ x → P x)
+∀¬⟶¬∃ = uncurry
 
-  ∀¬⟶¬∃ : (∀ x → ¬ P x) → ¬ ∃ (λ x → P x)
-  ∀¬⟶¬∃ = uncurry
-
-  ∃¬⟶¬∀ : ∃ (λ x → ¬ P x) → ¬ (∀ x → P x)
-  ∃¬⟶¬∀ = flip ∀⟶¬∃¬
+∃¬⟶¬∀ : ∃ (λ x → ¬ P x) → ¬ (∀ x → P x)
+∃¬⟶¬∀ = flip ∀⟶¬∃¬
 
 ------------------------------------------------------------------------
 -- Double Negation
@@ -59,15 +53,14 @@ module _ {P : A → Set p} where
 -- Double-negation is a monad (if we assume that all elements of ¬ ¬ P
 -- are equal).
 
-¬¬-Monad : RawMonad {p} DoubleNegation
+¬¬-Monad : RawMonad {a} DoubleNegation
 ¬¬-Monad = mkRawMonad
   DoubleNegation
   contradiction
   (λ x f → negated-stable (¬¬-map f x))
 
-¬¬-push : {Q : P → Set q} →
-          DoubleNegation Π[ Q ] → Π[ DoubleNegation ∘ Q ]
-¬¬-push ¬¬P⟶Q P ¬Q = ¬¬P⟶Q (λ P⟶Q → ¬Q (P⟶Q P))
+¬¬-push : DoubleNegation Π[ P ] → Π[ DoubleNegation ∘ P ]
+¬¬-push ¬¬∀P a ¬Pa = ¬¬∀P (λ ∀P → ¬Pa (∀P a))
 
 -- If Whatever is instantiated with ¬ ¬ something, then this function
 -- is call with current continuation in the double-negation monad, or,
@@ -78,28 +71,27 @@ module _ {P : A → Set p} where
 -- that case this function can be used (with Whatever instantiated to
 -- ⊥).
 
-call/cc : ((P → Whatever) → DoubleNegation P) → DoubleNegation P
-call/cc hyp ¬p = hyp (λ p → ⊥-elim (¬p p)) ¬p
+call/cc : ((A → Whatever) → DoubleNegation A) → DoubleNegation A
+call/cc hyp ¬a = hyp (flip contradiction ¬a) ¬a
 
 -- The "independence of premise" rule, in the double-negation monad.
--- It is assumed that the index set (Q) is inhabited.
+-- It is assumed that the index set (A) is inhabited.
 
-independence-of-premise : {R : Q → Set r} →
-                          Q → (P → Σ Q R) → DoubleNegation (Σ[ x ∈ Q ] (P → R x))
-independence-of-premise {P = P} q f = ¬¬-map helper excluded-middle
+independence-of-premise : A → (B → Σ A P) → DoubleNegation (Σ[ x ∈ A ] (B → P x))
+independence-of-premise {A = A} {B = B} {P = P} q f = ¬¬-map helper ¬¬-excluded-middle
   where
-  helper : Dec P → _
-  helper (yes p) = Prod.map id const (f p)
-  helper (no ¬p) = (q , ⊥-elim ∘′ ¬p)
+  helper : Dec B → Σ[ x ∈ A ] (B → P x)
+  helper (yes p) = Product.map₂ const (f p)
+  helper (no ¬p) = (q , flip contradiction ¬p)
 
 -- The independence of premise rule for binary sums.
 
-independence-of-premise-⊎ : (P → Q ⊎ R) → DoubleNegation ((P → Q) ⊎ (P → R))
-independence-of-premise-⊎ {P = P} f = ¬¬-map helper excluded-middle
+independence-of-premise-⊎ : (A → B ⊎ C) → DoubleNegation ((A → B) ⊎ (A → C))
+independence-of-premise-⊎ {A = A} {B = B} {C = C} f = ¬¬-map helper ¬¬-excluded-middle
   where
-  helper : Dec P → _
+  helper : Dec A → (A → B) ⊎ (A → C)
   helper (yes p) = Sum.map const const (f p)
-  helper (no ¬p) = inj₁ (⊥-elim ∘′ ¬p)
+  helper (no ¬p) = inj₁ (flip contradiction ¬p)
 
 private
 
@@ -107,12 +99,10 @@ private
   -- independence-of-premise (for simplicity it is assumed that Q and
   -- R have the same type here):
 
-  corollary : {Q R : Set q} →
-              (P → Q ⊎ R) → DoubleNegation ((P → Q) ⊎ (P → R))
-  corollary {P = P} {Q} {R} f =
-    ¬¬-map helper (independence-of-premise
-                     true ([ _,_ true , _,_ false ] ∘′ f))
+  corollary : {B C : Set b} → (A → B ⊎ C) → DoubleNegation ((A → B) ⊎ (A → C))
+  corollary {A = A} {B = B} {C = C} f =
+    ¬¬-map helper (independence-of-premise true ([ _,_ true , _,_ false ] ∘′ f))
     where
-    helper : ∃ (λ b → P → if b then Q else R) → (P → Q) ⊎ (P → R)
+    helper : ∃ (λ b → A → if b then B else C) → (A → B) ⊎ (A → C)
     helper (true  , f) = inj₁ f
     helper (false , f) = inj₂ f
diff --git a/src/Relation/Nullary/Negation/Core.agda b/src/Relation/Nullary/Negation/Core.agda
index 5c4efaf4fb..702fb16353 100644
--- a/src/Relation/Nullary/Negation/Core.agda
+++ b/src/Relation/Nullary/Negation/Core.agda
@@ -8,20 +8,15 @@
 
 module Relation.Nullary.Negation.Core where
 
-open import Data.Bool.Base using (not)
-open import Data.Empty using (⊥)
-open import Data.Empty.Irrelevant using (⊥-elim)
-open import Data.Product.Base using (_×_; _,_; proj₁; proj₂)
+open import Data.Empty using (⊥; ⊥-elim-irr)
 open import Data.Sum.Base using (_⊎_; [_,_]; inj₁; inj₂)
-open import Function.Base using (flip; _$_; _∘_; const)
+open import Function.Base using (flip; _∘_; const)
 open import Level
 
 private
   variable
     a p q w : Level
-    A : Set a
-    P : Set p
-    Q : Set q
+    A B C : Set a
     Whatever : Set w
 
 ------------------------------------------------------------------------
@@ -29,48 +24,55 @@ private
 
 infix 3 ¬_
 ¬_ : Set a → Set a
-¬ P = P → ⊥
+¬ A = A → ⊥
+
+------------------------------------------------------------------------
+-- Stability.
 
 -- Double-negation
-DoubleNegation : Set p → Set p
-DoubleNegation P = ¬ ¬ P
+DoubleNegation : Set a → Set a
+DoubleNegation A = ¬ ¬ A
 
 -- Stability under double-negation.
-Stable : Set p → Set p
-Stable P = ¬ ¬ P → P
+Stable : Set a → Set a
+Stable A = ¬ ¬ A → A
 
 ------------------------------------------------------------------------
--- Relationship to product and sum
+-- Relationship to sum
 
 infixr 1 _¬-⊎_
-_¬-⊎_ : ¬ P → ¬ Q → ¬ (P ⊎ Q)
+_¬-⊎_ : ¬ A → ¬ B → ¬ (A ⊎ B)
 _¬-⊎_ = [_,_]
 
 ------------------------------------------------------------------------
 -- Uses of negation
 
-contradiction : P → ¬ P → Whatever
-contradiction p ¬p = ⊥-elim (¬p p)
+contradiction-irr : .A → ¬ A → Whatever
+contradiction-irr a ¬a = ⊥-elim-irr (¬a a)
 
-contradiction₂ : P ⊎ Q → ¬ P → ¬ Q → Whatever
-contradiction₂ (inj₁ p) ¬p ¬q = contradiction p ¬p
-contradiction₂ (inj₂ q) ¬p ¬q = contradiction q ¬q
+contradiction : A → ¬ A → Whatever
+contradiction a = contradiction-irr a
 
-contraposition : (P → Q) → ¬ Q → ¬ P
-contraposition f ¬q p = contradiction (f p) ¬q
+contradiction₂ : A ⊎ B → ¬ A → ¬ B → Whatever
+contradiction₂ (inj₁ a) ¬a ¬b = contradiction a ¬a
+contradiction₂ (inj₂ b) ¬a ¬b = contradiction b ¬b
 
--- Note also the following use of flip:
-private
-  note : (P → ¬ Q) → Q → ¬ P
-  note = flip
+contraposition : (A → B) → ¬ B → ¬ A
+contraposition f ¬b a = contradiction (f a) ¬b
 
 -- Everything is stable in the double-negation monad.
-stable : ¬ ¬ Stable P
-stable ¬[¬¬p→p] = ¬[¬¬p→p] (λ ¬¬p → ⊥-elim (¬¬p (¬[¬¬p→p] ∘ const)))
+stable : ¬ ¬ Stable A
+stable ¬[¬¬a→a] = ¬[¬¬a→a] (contradiction (¬[¬¬a→a] ∘ const))
 
 -- Negated predicates are stable.
-negated-stable : Stable (¬ P)
-negated-stable ¬¬¬P P = ¬¬¬P (λ ¬P → ¬P P)
+negated-stable : Stable (¬ A)
+negated-stable ¬¬¬a a = ¬¬¬a (contradiction a)
 
-¬¬-map : (P → Q) → ¬ ¬ P → ¬ ¬ Q
+¬¬-map : (A → B) → ¬ ¬ A → ¬ ¬ B
 ¬¬-map f = contraposition (contraposition f)
+
+-- Note also the following use of flip:
+private
+  note : (A → ¬ B) → B → ¬ A
+  note = flip
+
diff --git a/src/Relation/Nullary/Recomputable.agda b/src/Relation/Nullary/Recomputable.agda
new file mode 100644
index 0000000000..cd0b83f113
--- /dev/null
+++ b/src/Relation/Nullary/Recomputable.agda
@@ -0,0 +1,63 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Recomputable types and their algebra as Harrop formulas
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --safe #-}
+
+module Relation.Nullary.Recomputable where
+
+open import Agda.Builtin.Equality using (_≡_; refl)
+open import Data.Empty using (⊥)
+open import Data.Product.Base using (_×_; _,_; proj₁; proj₂)
+open import Level using (Level)
+open import Relation.Nullary.Negation.Core using (¬_)
+
+private
+  variable
+    a b : Level
+    A : Set a
+    B : Set b
+
+------------------------------------------------------------------------
+-- Definition
+--
+-- The idea of being 'recomputable' is that, given an *irrelevant* proof
+-- of a proposition `A` (signalled by being a value of type `.A`, all of
+-- whose inhabitants are identified up to definitional equality, and hence
+-- do *not* admit pattern-matching), one may 'promote' such a value to a
+-- 'genuine' value of `A`, available for subsequent eg. pattern-matching.
+
+Recomputable : (A : Set a) → Set a
+Recomputable A = .A → A
+
+------------------------------------------------------------------------
+-- Fundamental property: 'promotion' is a constant function
+
+recompute-constant : (r : Recomputable A) (p q : A) → r p ≡ r q
+recompute-constant r p q = refl
+
+------------------------------------------------------------------------
+-- Constructions
+
+⊥-recompute : Recomputable ⊥
+⊥-recompute ()
+
+_×-recompute_ : Recomputable A → Recomputable B → Recomputable (A × B)
+(rA ×-recompute rB) p = rA (p .proj₁) , rB (p .proj₂)
+
+_→-recompute_ : (A : Set a) → Recomputable B → Recomputable (A → B)
+(A →-recompute rB) f a = rB (f a)
+
+Π-recompute : (B : A → Set b) → (∀ x → Recomputable (B x)) → Recomputable (∀ x → B x)
+Π-recompute B rB f a = rB a (f a)
+
+∀-recompute : (B : A → Set b) → (∀ {x} → Recomputable (B x)) → Recomputable (∀ {x} → B x)
+∀-recompute B rB f = rB f
+
+-- corollary: negated propositions are Recomputable
+
+¬-recompute : Recomputable (¬ A)
+¬-recompute {A = A} = A →-recompute ⊥-recompute
+
diff --git a/src/Relation/Nullary/Reflects.agda b/src/Relation/Nullary/Reflects.agda
index 66556e8ae6..00cee309a7 100644
--- a/src/Relation/Nullary/Reflects.agda
+++ b/src/Relation/Nullary/Reflects.agda
@@ -11,28 +11,28 @@ module Relation.Nullary.Reflects where
 open import Agda.Builtin.Equality
 
 open import Data.Bool.Base
-open import Data.Empty
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 open import Data.Product.Base using (_×_; _,_; proj₁; proj₂)
 open import Level using (Level)
-open import Function.Base using (_$_; _∘_; const)
-
+open import Function.Base using (_$_; _∘_; const; id)
 open import Relation.Nullary.Negation.Core
+  using (¬_; contradiction-irr; contradiction; _¬-⊎_)
+open import Relation.Nullary.Recomputable as Recomputable using (Recomputable)
 
 private
   variable
-    p q : Level
-    P Q : Set p
+    a : Level
+    A B : Set a
 
 ------------------------------------------------------------------------
 -- `Reflects` idiom.
 
--- The truth value of P is reflected by a boolean value.
--- `Reflects P b` is equivalent to `if b then P else ¬ P`.
+-- The truth value of A is reflected by a boolean value.
+-- `Reflects A b` is equivalent to `if b then A else ¬ A`.
 
-data Reflects {p} (P : Set p) : Bool → Set p where
-  ofʸ : ( p :   P) → Reflects P true
-  ofⁿ : (¬p : ¬ P) → Reflects P false
+data Reflects (A : Set a) : Bool → Set a where
+  ofʸ : ( a :   A) → Reflects A true
+  ofⁿ : (¬a : ¬ A) → Reflects A false
 
 ------------------------------------------------------------------------
 -- Constructors and destructors
@@ -41,57 +41,77 @@ data Reflects {p} (P : Set p) : Bool → Set p where
 -- that the `if` expressions have already been evaluated away.
 -- In this case, `of` works like the relevant constructor (`ofⁿ` or
 -- `ofʸ`), and `invert` strips off the constructor to just give either
--- the proof of `P` or the proof of `¬ P`.
+-- the proof of `A` or the proof of `¬ A`.
 
-of : ∀ {b} → if b then P else ¬ P → Reflects P b
-of {b = false} ¬p = ofⁿ ¬p
-of {b = true }  p = ofʸ p
+of : ∀ {b} → if b then A else ¬ A → Reflects A b
+of {b = false} ¬a = ofⁿ ¬a
+of {b = true }  a = ofʸ a
 
-invert : ∀ {b} → Reflects P b → if b then P else ¬ P
-invert (ofʸ  p) = p
-invert (ofⁿ ¬p) = ¬p
+invert : ∀ {b} → Reflects A b → if b then A else ¬ A
+invert (ofʸ  a) = a
+invert (ofⁿ ¬a) = ¬a
 
 ------------------------------------------------------------------------
--- Interaction with negation, product, sums etc.
+-- recompute
+
+-- Given an irrelevant proof of a reflected type, a proof can
+-- be recomputed and subsequently used in relevant contexts.
 
--- If we can decide P, then we can decide its negation.
-¬-reflects : ∀ {b} → Reflects P b → Reflects (¬ P) (not b)
-¬-reflects (ofʸ  p) = ofⁿ (_$ p)
-¬-reflects (ofⁿ ¬p) = ofʸ ¬p
+recompute : ∀ {b} → Reflects A b → Recomputable A
+recompute (ofʸ  a) _ = a
+recompute (ofⁿ ¬a) a = contradiction-irr a ¬a
 
--- If we can decide P and Q then we can decide their product
-infixr 2 _×-reflects_
-_×-reflects_ : ∀ {a b} → Reflects P a → Reflects Q b →
-               Reflects (P × Q) (a ∧ b)
-ofʸ  p ×-reflects ofʸ  q = ofʸ (p , q)
-ofʸ  p ×-reflects ofⁿ ¬q = ofⁿ (¬q ∘ proj₂)
-ofⁿ ¬p ×-reflects _      = ofⁿ (¬p ∘ proj₁)
+recompute-constant : ∀ {b} (r : Reflects A b) (p q : A) →
+                     recompute r p ≡ recompute r q
+recompute-constant = Recomputable.recompute-constant ∘ recompute
 
+------------------------------------------------------------------------
+-- Interaction with negation, product, sums etc.
 
 infixr 1 _⊎-reflects_
-_⊎-reflects_ : ∀ {a b} → Reflects P a → Reflects Q b →
-               Reflects (P ⊎ Q) (a ∨ b)
-ofʸ  p ⊎-reflects      _ = ofʸ (inj₁ p)
-ofⁿ ¬p ⊎-reflects ofʸ  q = ofʸ (inj₂ q)
-ofⁿ ¬p ⊎-reflects ofⁿ ¬q = ofⁿ (¬p ¬-⊎ ¬q)
-
-infixr 2 _→-reflects_
-_→-reflects_ : ∀ {a b} → Reflects P a → Reflects Q b →
-                Reflects (P → Q) (not a ∨ b)
-ofʸ  p →-reflects ofʸ  q = ofʸ (const q)
-ofʸ  p →-reflects ofⁿ ¬q = ofⁿ (¬q ∘ (_$ p))
-ofⁿ ¬p →-reflects _      = ofʸ (⊥-elim ∘ ¬p)
+infixr 2 _×-reflects_ _→-reflects_
+
+T-reflects : ∀ b → Reflects (T b) b
+T-reflects true  = of _
+T-reflects false = of id
+
+-- If we can decide A, then we can decide its negation.
+¬-reflects : ∀ {b} → Reflects A b → Reflects (¬ A) (not b)
+¬-reflects (ofʸ  a) = of (_$ a)
+¬-reflects (ofⁿ ¬a) = of ¬a
+
+-- If we can decide A and Q then we can decide their product
+_×-reflects_ : ∀ {a b} → Reflects A a → Reflects B b →
+               Reflects (A × B) (a ∧ b)
+ofʸ  a ×-reflects ofʸ  b = of (a , b)
+ofʸ  a ×-reflects ofⁿ ¬b = of (¬b ∘ proj₂)
+ofⁿ ¬a ×-reflects _      = of (¬a ∘ proj₁)
+
+_⊎-reflects_ : ∀ {a b} → Reflects A a → Reflects B b →
+               Reflects (A ⊎ B) (a ∨ b)
+ofʸ  a ⊎-reflects      _ = of (inj₁ a)
+ofⁿ ¬a ⊎-reflects ofʸ  b = of (inj₂ b)
+ofⁿ ¬a ⊎-reflects ofⁿ ¬b = of (¬a ¬-⊎ ¬b)
+
+_→-reflects_ : ∀ {a b} → Reflects A a → Reflects B b →
+                Reflects (A → B) (not a ∨ b)
+ofʸ  a →-reflects ofʸ  b = of (const b)
+ofʸ  a →-reflects ofⁿ ¬b = of (¬b ∘ (_$ a))
+ofⁿ ¬a →-reflects _      = of (λ a → contradiction a ¬a)
 
 ------------------------------------------------------------------------
 -- Other lemmas
 
-fromEquivalence : ∀ {b} → (T b → P) → (P → T b) → Reflects P b
-fromEquivalence {b = true}  sound complete = ofʸ (sound _)
-fromEquivalence {b = false} sound complete = ofⁿ complete
+fromEquivalence : ∀ {b} → (T b → A) → (A → T b) → Reflects A b
+fromEquivalence {b = true}  sound complete = of (sound _)
+fromEquivalence {b = false} sound complete = of complete
 
 -- `Reflects` is deterministic.
-det : ∀ {b b′} → Reflects P b → Reflects P b′ → b ≡ b′
-det (ofʸ  p) (ofʸ  p′) = refl
-det (ofʸ  p) (ofⁿ ¬p′) = ⊥-elim (¬p′ p)
-det (ofⁿ ¬p) (ofʸ  p′) = ⊥-elim (¬p p′)
-det (ofⁿ ¬p) (ofⁿ ¬p′) = refl
+det : ∀ {b b′} → Reflects A b → Reflects A b′ → b ≡ b′
+det (ofʸ  a) (ofʸ  _) = refl
+det (ofʸ  a) (ofⁿ ¬a) = contradiction a ¬a
+det (ofⁿ ¬a) (ofʸ  a) = contradiction a ¬a
+det (ofⁿ ¬a) (ofⁿ  _) = refl
+
+T-reflects-elim : ∀ {a b} → Reflects (T a) b → b ≡ a
+T-reflects-elim {a} r = det r (T-reflects a)
diff --git a/src/Relation/Nullary/Universe.agda b/src/Relation/Nullary/Universe.agda
index 4c0308343d..56b67682fc 100644
--- a/src/Relation/Nullary/Universe.agda
+++ b/src/Relation/Nullary/Universe.agda
@@ -10,18 +10,19 @@ module Relation.Nullary.Universe where
 
 open import Relation.Nullary
 open import Relation.Nullary.Negation
-open import Relation.Binary hiding (_⇒_)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Bundles using (Setoid)
 import Relation.Binary.Construct.Always as Always
-open import Relation.Binary.PropositionalEquality as PropEq
-  using (_≡_; refl)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
+import Relation.Binary.PropositionalEquality.Properties as PropEq
 import Relation.Binary.Indexed.Heterogeneous.Construct.Trivial
   as Trivial
-open import Data.Sum     as Sum  hiding (map)
-open import Data.Sum.Relation.Binary.Pointwise
-open import Data.Product as Prod hiding (map)
-open import Data.Product.Relation.Binary.Pointwise.NonDependent
-open import Function
-import Function.Equality as FunS
+open import Data.Sum.Base as Sum  hiding (map)
+open import Data.Sum.Relation.Binary.Pointwise using (_⊎ₛ_; inj₁; inj₂)
+open import Data.Product.Base as Product hiding (map)
+open import Data.Product.Relation.Binary.Pointwise.NonDependent using (_×ₛ_)
+open import Function.Base using (_∘_; id)
+open import Function.Indexed.Relation.Binary.Equality using (≡-setoid)
 open import Data.Empty
 open import Effect.Applicative
 open import Effect.Monad
@@ -52,7 +53,7 @@ mutual
   setoid (K P)     _ = PropEq.setoid P
   setoid (F₁ ∨ F₂) P = (setoid F₁ P) ⊎ₛ (setoid F₂ P)
   setoid (F₁ ∧ F₂) P = (setoid F₁ P) ×ₛ (setoid F₂ P)
-  setoid (P₁ ⇒ F₂) P = FunS.≡-setoid P₁
+  setoid (P₁ ⇒ F₂) P = ≡-setoid P₁
                          (Trivial.indexedSetoid (setoid F₂ P))
   setoid (¬¬ F)    P = Always.setoid (¬ ¬ ⟦ F ⟧ P) _
 
@@ -68,7 +69,7 @@ map : ∀ {p} (F : PropF p) {P Q} → (P → Q) → ⟦ F ⟧ P → ⟦ F ⟧ Q
 map Id        f  p = f p
 map (K P)     f  p = p
 map (F₁ ∨ F₂) f FP = Sum.map  (map F₁ f) (map F₂ f) FP
-map (F₁ ∧ F₂) f FP = Prod.map (map F₁ f) (map F₂ f) FP
+map (F₁ ∧ F₂) f FP = Product.map (map F₁ f) (map F₂ f) FP
 map (P₁ ⇒ F₂) f FP = map F₂ f ∘ FP
 map (¬¬ F)    f FP = ¬¬-map (map F f) FP
 
@@ -115,7 +116,7 @@ sequence {AF = AF} A extract-⊥ sequence-⇒ = helper
 -- Some lemmas about double negation.
 
 private
-  open module M {p} = RawMonad (¬¬-Monad {p = p})
+  open module M {a} = RawMonad (¬¬-Monad {a = a})
 
 ¬¬-pull : ∀ {p} (F : PropF p) {P} →
           ⟦ F ⟧ (¬ ¬ P) → ¬ ¬ ⟦ F ⟧ P
diff --git a/src/Relation/Unary.agda b/src/Relation/Unary.agda
index 76c064836b..3abc070ace 100644
--- a/src/Relation/Unary.agda
+++ b/src/Relation/Unary.agda
@@ -8,15 +8,14 @@
 
 module Relation.Unary where
 
-open import Data.Empty
+open import Data.Empty using (⊥)
 open import Data.Unit.Base using (⊤)
-open import Data.Product
+open import Data.Product.Base using (_×_; _,_; Σ-syntax; ∃; uncurry; swap)
 open import Data.Sum.Base using (_⊎_; [_,_])
-open import Function.Base
-open import Level
-open import Relation.Nullary.Decidable.Core using (Dec; True)
-open import Relation.Nullary.Negation.Core using (¬_)
+open import Function.Base using (_∘_; _|>_)
+open import Level using (Level; _⊔_; 0ℓ; suc; Lift)
 open import Relation.Binary.PropositionalEquality.Core using (_≡_)
+open import Relation.Nullary as Nullary using (¬_; Dec; True)
 
 private
   variable
@@ -42,6 +41,8 @@ Pred A ℓ = A → Set ℓ
 -- Special sets
 
 -- The empty set.
+-- Explicitly not level polymorphic as this often causes unsolved metas;
+-- see `Relation.Unary.Polymorphic` for a level-polymorphic version.
 
 ∅ : Pred A 0ℓ
 ∅ = λ _ → ⊥
@@ -52,6 +53,7 @@ Pred A ℓ = A → Set ℓ
 ｛ x ｝ = x ≡_
 
 -- The universal set.
+-- Explicitly not level polymorphic (see comments for `∅` for more details)
 
 U : Pred A 0ℓ
 U = λ _ → ⊤
@@ -162,6 +164,28 @@ IUniversal P = ∀ {x} → x ∈ P
 
 syntax IUniversal P = ∀[ P ]
 
+-- Irrelevance - any two proofs that an element satifies P are
+-- indistinguishable.
+
+Irrelevant : Pred A ℓ → Set _
+Irrelevant P = ∀ {x} → Nullary.Irrelevant (P x)
+
+-- Recomputability - we can rebuild a relevant proof given an
+-- irrelevant one.
+
+Recomputable : Pred A ℓ → Set _
+Recomputable P = ∀ {x} → Nullary.Recomputable (P x)
+
+-- Stability - instances of P are stable wrt double negation
+
+Stable : Pred A ℓ → Set _
+Stable P = ∀ x → Nullary.Stable (P x)
+
+-- Weak Decidability
+
+WeaklyDecidable : Pred A ℓ → Set _
+WeaklyDecidable P = ∀ x → Nullary.WeaklyDecidable (P x)
+
 -- Decidability - it is possible to determine if an arbitrary element
 -- satisfies P.
 
@@ -174,18 +198,6 @@ Decidable P = ∀ x → Dec (P x)
 ⌊_⌋ : {P : Pred A ℓ} → Decidable P → Pred A ℓ
 ⌊ P? ⌋ a = Lift _ (True (P? a))
 
--- Irrelevance - any two proofs that an element satifies P are
--- indistinguishable.
-
-Irrelevant : Pred A ℓ → Set _
-Irrelevant P = ∀ {x} (a : P x) (b : P x) → a ≡ b
-
--- Recomputability - we can rebuild a relevant proof given an
--- irrelevant one.
-
-Recomputable : Pred A ℓ → Set _
-Recomputable P = ∀ {x} → .(P x) → P x
-
 ------------------------------------------------------------------------
 -- Operations on sets
 
@@ -285,7 +297,7 @@ _⟨→⟩_ : Pred A ℓ₁ → Pred B ℓ₂ → Pred (A → B) _
 -- Product.
 
 _⟨·⟩_ : (P : Pred A ℓ₁) (Q : Pred B ℓ₂) →
-        (P ⟨×⟩ (P ⟨→⟩ Q)) ⊆ Q ∘ uncurry (flip _$_)
+        (P ⟨×⟩ (P ⟨→⟩ Q)) ⊆ Q ∘ uncurry _|>_
 (P ⟨·⟩ Q) (p , f) = f p
 
 -- Converse.
diff --git a/src/Relation/Unary/Algebra.agda b/src/Relation/Unary/Algebra.agda
index f302cf7272..514470de38 100644
--- a/src/Relation/Unary/Algebra.agda
+++ b/src/Relation/Unary/Algebra.agda
@@ -14,10 +14,10 @@ open import Algebra.Lattice.Bundles
 import Algebra.Lattice.Structures as AlgebraicLatticeStructures
 import Algebra.Structures as AlgebraicStructures
 open import Data.Empty.Polymorphic using (⊥-elim)
-open import Data.Product as Product using (_,_; proj₁; proj₂; <_,_>; curry; uncurry)
-open import Data.Sum as Sum using (inj₁; inj₂; [_,_])
+open import Data.Product.Base as Product using (_,_; proj₁; proj₂; <_,_>; curry; uncurry)
+open import Data.Sum.Base as Sum using (inj₁; inj₂; [_,_])
 open import Data.Unit.Polymorphic using (tt)
-open import Function using (id; const; _∘_)
+open import Function.Base using (id; const; _∘_)
 open import Level
 open import Relation.Unary hiding (∅; U)
 open import Relation.Unary.Polymorphic using (∅; U)
diff --git a/src/Relation/Unary/Closure/Base.agda b/src/Relation/Unary/Closure/Base.agda
index 5a210104b4..52ecac9ecf 100644
--- a/src/Relation/Unary/Closure/Base.agda
+++ b/src/Relation/Unary/Closure/Base.agda
@@ -6,12 +6,13 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Transitive; Reflexive)
 
 module Relation.Unary.Closure.Base {a b} {A : Set a} (R : Rel A b) where
 
 open import Level
-open import Data.Product using (Σ-syntax; _×_; _,_; -,_)
+open import Data.Product.Base using (Σ-syntax; _×_; _,_; -,_)
 open import Function.Base using (flip)
 open import Relation.Unary using (Pred)
 
@@ -20,9 +21,9 @@ open import Relation.Unary using (Pred)
 
 -- Box
 
--- We start with the definition of □ ("box") which is named after the box
--- modality in modal logic. `□ T x` states that all the elements one step
--- away from `x` with respect to the relation R satisfy `T`.
+-- We start with the definition of □ ("box") which is named after the
+-- box modality in modal logic. `□ T x` states that all the elements one
+-- step away from `x` with respect to the relation R satisfy `T`.
 
 □ : ∀ {t} → Pred A t → Pred A (a ⊔ b ⊔ t)
 □ T x = ∀ {y} → R x y → T y
@@ -42,8 +43,8 @@ open import Relation.Unary using (Pred)
 -- diamond modality in modal logic. In modal logic, `◇ T x` states that
 -- there exists an element one step away from x with respect to the
 -- relation R that satisfies T. It is worth noting that the modal logic
--- metaphor breaks down here: this only is a closure operator if the step
--- we take is *backwards* with respect to R.
+-- metaphor breaks down here: this only is a closure operator if the
+-- step we take is *backwards* with respect to R.
 
 ◇ : ∀ {t} → Pred A t → Pred A (a ⊔ b ⊔ t)
 ◇ T x = Σ[ support ∈ A ] (R support x × T support)
diff --git a/src/Relation/Unary/Closure/Preorder.agda b/src/Relation/Unary/Closure/Preorder.agda
index 8c261b0283..374669aa30 100644
--- a/src/Relation/Unary/Closure/Preorder.agda
+++ b/src/Relation/Unary/Closure/Preorder.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (Preorder)
 
 module Relation.Unary.Closure.Preorder {a r e} (P : Preorder a e r) where
 
diff --git a/src/Relation/Unary/Closure/StrictPartialOrder.agda b/src/Relation/Unary/Closure/StrictPartialOrder.agda
index 889977fd02..81d5fb48f1 100644
--- a/src/Relation/Unary/Closure/StrictPartialOrder.agda
+++ b/src/Relation/Unary/Closure/StrictPartialOrder.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (StrictPartialOrder)
 
 module Relation.Unary.Closure.StrictPartialOrder
        {a r e} (P : StrictPartialOrder a e r) where
diff --git a/src/Relation/Unary/Consequences.agda b/src/Relation/Unary/Consequences.agda
index 1b23578161..75c046c375 100644
--- a/src/Relation/Unary/Consequences.agda
+++ b/src/Relation/Unary/Consequences.agda
@@ -11,5 +11,19 @@ module Relation.Unary.Consequences where
 open import Relation.Unary
 open import Relation.Nullary using (recompute)
 
-dec⟶recomputable : {a ℓ : _} {A : Set a} {P : Pred A ℓ} → Decidable P → Recomputable P
-dec⟶recomputable P-dec = recompute (P-dec _)
+dec⇒recomputable : {a ℓ : _} {A : Set a} {P : Pred A ℓ} → Decidable P → Recomputable P
+dec⇒recomputable P-dec = recompute (P-dec _)
+
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.0
+
+dec⟶recomputable = dec⇒recomputable
+{-# WARNING_ON_USAGE dec⟶recomputable
+"Warning: dec⟶recomputable was deprecated in v2.0.
+Please use dec⇒recomputable instead."
+#-}
diff --git a/src/Relation/Unary/Indexed.agda b/src/Relation/Unary/Indexed.agda
index 1acfdc8cef..d0d1a62979 100644
--- a/src/Relation/Unary/Indexed.agda
+++ b/src/Relation/Unary/Indexed.agda
@@ -8,7 +8,7 @@
 
 module Relation.Unary.Indexed  where
 
-open import Data.Product using (∃; _×_)
+open import Data.Product.Base using (∃; _×_)
 open import Level
 open import Relation.Nullary.Negation using (¬_)
 
@@ -17,6 +17,8 @@ IPred A ℓ = ∀ {i} → A i → Set ℓ
 
 module _ {i a} {I : Set i} {A : I → Set a} where
 
+  infix 4 _∈_ _∉_
+
   _∈_ : ∀ {ℓ} → (∀ i → A i) → IPred A ℓ → Set _
   x ∈ P = ∀ i → P (x i)
 
diff --git a/src/Relation/Unary/Polymorphic/Properties.agda b/src/Relation/Unary/Polymorphic/Properties.agda
index 8d46f51807..91f332433f 100644
--- a/src/Relation/Unary/Polymorphic/Properties.agda
+++ b/src/Relation/Unary/Polymorphic/Properties.agda
@@ -10,7 +10,7 @@
 module Relation.Unary.Polymorphic.Properties where
 
 open import Level using (Level)
-open import Relation.Binary.Definitions hiding (Decidable; Universal)
+open import Relation.Binary.Definitions hiding (Decidable; Universal; Empty)
 open import Relation.Nullary.Decidable using (yes; no)
 open import Relation.Unary hiding (∅; U)
 open import Relation.Unary.Polymorphic
@@ -21,7 +21,7 @@ private
     a ℓ ℓ₁ ℓ₂ : Level
     A : Set a
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The empty set
 
 ∅? : Decidable {A = A} {ℓ} ∅
@@ -33,7 +33,7 @@ private
 ∁∅-Universal : Universal {A = A} {ℓ} (∁ ∅)
 ∁∅-Universal _ ()
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The universe
 
 U? : Decidable {A = A} {ℓ} U
@@ -45,7 +45,7 @@ U-Universal _ = _
 ∁U-Empty : Empty {A = A} {ℓ} (∁ U)
 ∁U-Empty _ x∈∁U = x∈∁U _
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Subset properties
 
 ∅-⊆ : (P : Pred A ℓ₁) → ∅ {ℓ = ℓ₂} ⊆ P
diff --git a/src/Relation/Unary/PredicateTransformer.agda b/src/Relation/Unary/PredicateTransformer.agda
index 518552d0d8..2134605502 100644
--- a/src/Relation/Unary/PredicateTransformer.agda
+++ b/src/Relation/Unary/PredicateTransformer.agda
@@ -8,12 +8,12 @@
 
 module Relation.Unary.PredicateTransformer where
 
-open import Data.Product
-open import Function
+open import Data.Product.Base using (∃)
+open import Function.Base using (_∘_)
 open import Level hiding (_⊔_)
 open import Relation.Nullary
 open import Relation.Unary
-open import Relation.Binary using (REL)
+open import Relation.Binary.Core using (REL)
 
 private
   variable
@@ -34,6 +34,8 @@ Pt A ℓ = PT A A ℓ ℓ
 ------------------------------------------------------------------------
 -- Composition and identity
 
+infixr 9 _⍮_
+
 _⍮_ : PT B C ℓ₂ ℓ₃ → PT A B ℓ₁ ℓ₂ → PT A C ℓ₁ _
 S ⍮ T = S ∘ T
 
@@ -53,6 +55,8 @@ magic = λ _ → U
 
 -- Negation.
 
+infix 8 ∼_
+
 ∼_ : PT A B ℓ₁ ℓ₂ → PT A B ℓ₁ ℓ₂
 ∼ T = ∁ ∘ T
 
diff --git a/src/Relation/Unary/Properties.agda b/src/Relation/Unary/Properties.agda
index e0b059f0b4..874869e271 100644
--- a/src/Relation/Unary/Properties.agda
+++ b/src/Relation/Unary/Properties.agda
@@ -8,12 +8,13 @@
 
 module Relation.Unary.Properties where
 
-open import Data.Product as Product using (_×_; _,_; swap; proj₁; zip′)
+open import Data.Product.Base as Product using (_×_; _,_; swap; proj₁; zip′)
 open import Data.Sum.Base using (inj₁; inj₂)
 open import Data.Unit.Base using (tt)
-open import Level
+open import Level using (Level)
 open import Relation.Binary.Core as Binary
-open import Relation.Binary.Definitions hiding (Decidable; Universal; Irrelevant)
+open import Relation.Binary.Definitions
+  hiding (Decidable; Universal; Irrelevant; Empty)
 open import Relation.Binary.PropositionalEquality.Core using (refl)
 open import Relation.Unary
 open import Relation.Nullary.Decidable using (yes; no; _⊎-dec_; _×-dec_; ¬?)
@@ -25,7 +26,7 @@ private
     A : Set a
     B : Set b
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The empty set
 
 ∅? : Decidable {A = A} ∅
@@ -37,7 +38,7 @@ private
 ∁∅-Universal : Universal {A = A} (∁ ∅)
 ∁∅-Universal = λ x x∈∅ → x∈∅
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The universe
 
 U? : Decidable {A = A} U
@@ -49,7 +50,7 @@ U-Universal = λ _ → _
 ∁U-Empty : Empty {A = A} (∁ U)
 ∁U-Empty = λ x x∈∁U → x∈∁U _
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Subset properties
 
 ∅-⊆ : (P : Pred A ℓ) → ∅ ⊆ P
@@ -169,7 +170,7 @@ U-Universal = λ _ → _
 ⊂′⇒⊂ : Binary._⇒_ {A = Pred A ℓ₁} {B = Pred A ℓ₂} _⊂′_ _⊂_
 ⊂′⇒⊂ = Product.map ⊆′⇒⊆ (_∘ ⊆⇒⊆′)
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Equality properties
 
 ≐-refl : Reflexive {A = Pred A ℓ} _≐_
@@ -196,12 +197,18 @@ U-Universal = λ _ → _
 ≐′⇒≐ : Binary._⇒_ {A = Pred A ℓ₁} {B = Pred A ℓ₂} _≐′_ _≐_
 ≐′⇒≐ = Product.map ⊆′⇒⊆ ⊆′⇒⊆
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Decidability properties
 
 ∁? : {P : Pred A ℓ} → Decidable P → Decidable (∁ P)
 ∁? P? x = ¬? (P? x)
 
+infix 2 _×?_ _⊙?_
+infix 10 _~?
+infixr 1 _⊎?_
+infixr 7 _∩?_
+infixr 6 _∪?_
+
 _∪?_ : {P : Pred A ℓ₁} {Q : Pred A ℓ₂} →
        Decidable P → Decidable Q → Decidable (P ∪ Q)
 _∪?_ P? Q? x = (P? x) ⊎-dec (Q? x)
@@ -226,7 +233,7 @@ _⊎?_ P? Q? (inj₂ b) = Q? b
 _~? : {P : Pred (A × B) ℓ} → Decidable P → Decidable (P ~)
 _~? P? = P? ∘ swap
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Irrelevant properties
 
 U-irrelevant : Irrelevant {A = A} U
diff --git a/src/Relation/Unary/Relation/Binary/Subset.agda b/src/Relation/Unary/Relation/Binary/Subset.agda
index 77679f15bd..1069b99a73 100644
--- a/src/Relation/Unary/Relation/Binary/Subset.agda
+++ b/src/Relation/Unary/Relation/Binary/Subset.agda
@@ -15,7 +15,7 @@ open import Relation.Unary
 open import Relation.Unary.Properties
 open import Relation.Unary.Relation.Binary.Equality using (≐-isEquivalence; ≐′-isEquivalence)
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Structures
 
 module _ {a : Level} {A : Set a} {ℓ : Level} where
@@ -68,7 +68,7 @@ module _ {a : Level} {A : Set a} {ℓ : Level} where
     ; <-resp-≈ = ⊂′-resp-≐′
     }
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Bundles
 
 module _ {a : Level} (A : Set a) (ℓ : Level) where
diff --git a/src/System/Clock.agda b/src/System/Clock.agda
index ef0e91d1fa..7ee4200207 100644
--- a/src/System/Clock.agda
+++ b/src/System/Clock.agda
@@ -12,9 +12,9 @@ open import Level using (Level; 0ℓ; Lift; lower)
 open import Data.Bool.Base using (if_then_else_)
 open import Data.Fin.Base using (Fin; toℕ)
 open import Data.Nat.Base as ℕ using (ℕ; zero; suc; _+_; _∸_; _^_; _<ᵇ_)
-import Data.Nat.Show as ℕ
+import Data.Nat.Show as ℕ using (show)
 open import Data.Nat.DivMod using (_/_)
-import Data.Nat.Properties as ℕₚ
+import Data.Nat.Properties as ℕ
 open import Data.String.Base using (String; _++_; padLeft)
 
 open import IO.Base
@@ -104,5 +104,5 @@ show : Time →   -- Time in seconds and nanoseconds
 show (mkTime s ns) prec = secs ++ "s" ++ padLeft '0' decimals nsecs where
   decimals = toℕ prec
   secs     = ℕ.show s
-  prf      = ℕₚ.m^n≢0 10 (9 ∸ decimals)
+  prf      = ℕ.m^n≢0 10 (9 ∸ decimals)
   nsecs    = ℕ.show ((ns / (10 ^ (9 ∸ decimals))) {{prf}})
diff --git a/src/System/Clock/Primitive.agda b/src/System/Clock/Primitive.agda
index 330b9e36c4..9e394af190 100644
--- a/src/System/Clock/Primitive.agda
+++ b/src/System/Clock/Primitive.agda
@@ -9,7 +9,7 @@
 module System.Clock.Primitive where
 
 open import Agda.Builtin.Nat using (Nat)
-open import IO.Primitive using (IO)
+open import IO.Primitive.Core using (IO)
 open import Foreign.Haskell using (Pair)
 
 data Clock : Set where
diff --git a/src/System/Console/ANSI.agda b/src/System/Console/ANSI.agda
index e1a903a653..867a4cd856 100644
--- a/src/System/Console/ANSI.agda
+++ b/src/System/Console/ANSI.agda
@@ -10,7 +10,7 @@ module System.Console.ANSI where
 
 open import Data.List.Base as List using (List; []; _∷_)
 open import Data.Nat.Base using (ℕ; _+_)
-import Data.Nat.Show as ℕ
+import Data.Nat.Show as ℕ using (show)
 open import Data.String.Base using (String; concat; intersperse)
 open import Function.Base using (_$_; case_of_)
 
diff --git a/src/System/Directory.agda b/src/System/Directory.agda
index baee50bc2d..fc2a1578a9 100644
--- a/src/System/Directory.agda
+++ b/src/System/Directory.agda
@@ -17,7 +17,7 @@ open import Data.Maybe.Base using (Maybe)
 open import Data.Nat.Base using (ℕ)
 open import Data.String.Base using (String)
 open import Foreign.Haskell.Coerce using (coerce)
-open import Function
+open import Function.Base using (_∘′_)
 open import System.FilePath.Posix hiding (makeRelative)
 
 open import System.Directory.Primitive as Prim
diff --git a/src/System/Directory/Primitive.agda b/src/System/Directory/Primitive.agda
index 57da7461bb..d5bae96742 100644
--- a/src/System/Directory/Primitive.agda
+++ b/src/System/Directory/Primitive.agda
@@ -21,12 +21,12 @@ open import System.FilePath.Posix.Primitive
 {-# FOREIGN GHC import Data.Text        #-}
 
 data XdgDirectory : Set where
-  XdgData XdgConfig XdgCache : XdgDirectory
+  XdgData XdgConfig XdgCache XdgState : XdgDirectory
 
 data XdgDirectoryList : Set where
   XdgDataDirs XdgConfigDirs : XdgDirectoryList
 
-{-# COMPILE GHC XdgDirectory     = data XdgDirectory (XdgData|XdgConfig|XdgCache)    #-}
+{-# COMPILE GHC XdgDirectory     = data XdgDirectory (XdgData|XdgConfig|XdgCache|XdgState) #-}
 {-# COMPILE GHC XdgDirectoryList = data XdgDirectoryList (XdgDataDirs|XdgConfigDirs) #-}
 
 private
diff --git a/src/System/Environment.agda b/src/System/Environment.agda
index 228bf699ac..ec6833f64c 100644
--- a/src/System/Environment.agda
+++ b/src/System/Environment.agda
@@ -11,7 +11,7 @@ module System.Environment where
 open import IO using (IO; lift; run; ignore)
 open import Data.List.Base using (List)
 open import Data.Maybe.Base using (Maybe)
-open import Data.Product using (_×_)
+open import Data.Product.Base using (_×_)
 open import Data.String.Base using (String)
 open import Data.Unit.Polymorphic using (⊤)
 open import Foreign.Haskell.Coerce
diff --git a/src/System/Environment/Primitive.agda b/src/System/Environment/Primitive.agda
index 103afc2ac9..9408613641 100644
--- a/src/System/Environment/Primitive.agda
+++ b/src/System/Environment/Primitive.agda
@@ -14,11 +14,11 @@
 
 module System.Environment.Primitive where
 
-open import IO.Primitive using (IO)
+open import IO.Primitive.Core using (IO)
 open import Data.List.Base using (List)
 open import Data.Maybe.Base using (Maybe)
 open import Data.String.Base using (String)
-open import Data.Unit using (⊤)
+open import Data.Unit.Base using (⊤)
 
 open import Foreign.Haskell.Pair using (Pair)
 
diff --git a/src/System/FilePath/Posix.agda b/src/System/FilePath/Posix.agda
index 4e4a205d47..f12cf8180e 100644
--- a/src/System/FilePath/Posix.agda
+++ b/src/System/FilePath/Posix.agda
@@ -13,9 +13,8 @@ open import Agda.Builtin.List using (List)
 open import Agda.Builtin.String using (String)
 open import IO.Base using (IO; lift)
 open import Data.Maybe.Base using (Maybe)
-open import Data.Product using (_×_)
+open import Data.Product.Base using (_×_)
 open import Data.Sum.Base using (_⊎_)
-open import Function
 
 open import Foreign.Haskell.Coerce
 
diff --git a/src/System/FilePath/Posix/Primitive.agda b/src/System/FilePath/Posix/Primitive.agda
index ed4cd56792..8226666ba6 100644
--- a/src/System/FilePath/Posix/Primitive.agda
+++ b/src/System/FilePath/Posix/Primitive.agda
@@ -14,7 +14,7 @@ open import Agda.Builtin.List using (List)
 open import Agda.Builtin.Maybe using (Maybe)
 open import Agda.Builtin.String using (String)
 open import Foreign.Haskell as FFI using (Pair; Either)
-open import IO.Primitive using (IO)
+open import IO.Primitive.Core using (IO)
 
 -- A filepath has a nature: it can be either relative or absolute.
 -- We postulate this nature rather than defining it as an inductive
diff --git a/src/System/Process.agda b/src/System/Process.agda
index 1473788365..b2eacdacea 100644
--- a/src/System/Process.agda
+++ b/src/System/Process.agda
@@ -1,4 +1,4 @@
------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The Agda standard library
 --
 -- Calling external processes
@@ -10,7 +10,7 @@ module System.Process where
 
 open import Level using (Level)
 open import Data.List.Base using (List)
-open import Data.Product using (_×_; proj₁)
+open import Data.Product.Base using (_×_; proj₁)
 open import Data.String.Base using (String)
 open import Data.Unit.Polymorphic using (⊤)
 open import Foreign.Haskell.Coerce
diff --git a/src/System/Process/Primitive.agda b/src/System/Process/Primitive.agda
index aa2bdfcbf2..828a275433 100644
--- a/src/System/Process/Primitive.agda
+++ b/src/System/Process/Primitive.agda
@@ -13,7 +13,7 @@ open import Agda.Builtin.List
 open import Agda.Builtin.String
 open import Agda.Builtin.Unit
 open import Foreign.Haskell using (Pair)
-open import IO.Primitive using (IO)
+open import IO.Primitive.Core using (IO)
 open import System.Exit.Primitive using (ExitCode)
 
 postulate
diff --git a/src/System/Random.agda b/src/System/Random.agda
new file mode 100644
index 0000000000..3587a0b927
--- /dev/null
+++ b/src/System/Random.agda
@@ -0,0 +1,199 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- *Pseudo-random* number generation
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible --guardedness #-}
+
+module System.Random where
+
+import System.Random.Primitive as Prim
+
+open import Data.Bool.Base using (T)
+open import Data.Nat.Base using (ℕ; z≤n) hiding (module ℕ)
+open import Foreign.Haskell.Pair using (_,_)
+open import Function.Base using (_$_; _∘_)
+open import IO.Base using (IO; lift; lift!; _<$>_; _>>=_; pure)
+import IO.Effectful as IO
+open import Level using (0ℓ; suc; _⊔_; lift)
+open import Relation.Binary.Core using (Rel)
+
+------------------------------------------------------------------------
+-- Ranged generation shall return proofs
+
+record InBounds {a r} {A : Set a} (_≤_ : Rel A r) (lo hi : A) : Set (a ⊔ r) where
+  constructor _∈[_,_]
+  field
+    value : A
+    .isLowerBound : lo ≤ value
+    .isUpperBound : value ≤ hi
+
+RandomRIO : ∀ {a r} {A : Set a} (_≤_ : Rel A r) → Set (suc (a ⊔ r))
+RandomRIO {A = A} _≤_ = (lo hi : A) → .(lo ≤ hi) → IO (InBounds _≤_ lo hi)
+
+------------------------------------------------------------------------
+-- Instances
+
+module Char where
+
+  open import Data.Char.Base using (Char; _≤_)
+
+  randomIO : IO Char
+  randomIO = lift Prim.randomIO-Char
+
+  randomRIO : RandomRIO _≤_
+  randomRIO lo hi _ = do
+    value ← lift (Prim.randomRIO-Char (lo , hi))
+    pure (value ∈[ trustMe , trustMe ])
+    where postulate trustMe : ∀ {A} → A
+
+module Float where
+
+  open import Data.Float.Base using (Float; _≤_)
+
+  randomIO : IO Float
+  randomIO = lift Prim.randomIO-Float
+
+  randomRIO : RandomRIO _≤_
+  randomRIO lo hi _ = do
+    value ← lift (Prim.randomRIO-Float (lo , hi))
+    pure (value ∈[ trustMe , trustMe ])
+    where postulate trustMe : ∀ {A} → A
+
+module ℤ where
+
+  open import Data.Integer.Base using (ℤ; _≤_)
+
+  randomIO : IO ℤ
+  randomIO = lift Prim.randomIO-Int
+
+  randomRIO : RandomRIO _≤_
+  randomRIO lo hi _ = do
+    value ← lift (Prim.randomRIO-Int (lo , hi))
+    pure (value ∈[ trustMe , trustMe ])
+    where postulate trustMe : ∀ {A} → A
+
+module ℕ where
+
+  open import Data.Nat.Base using (ℕ; _≤_)
+
+  randomIO : IO ℕ
+  randomIO = lift Prim.randomIO-Nat
+
+  randomRIO : RandomRIO _≤_
+  randomRIO lo hi _ = do
+    value ← lift (Prim.randomRIO-Nat (lo , hi))
+    pure (value ∈[ trustMe , trustMe ])
+    where postulate trustMe : ∀ {A} → A
+
+module Word64 where
+
+  open import Data.Word64.Base using (Word64; _≤_)
+
+  randomIO : IO Word64
+  randomIO = lift Prim.randomIO-Word64
+
+  randomRIO : RandomRIO _≤_
+  randomRIO lo hi _ = do
+    value ← lift (Prim.randomRIO-Word64 (lo , hi))
+    pure (value ∈[ trustMe , trustMe ])
+    where postulate trustMe : ∀ {A} → A
+
+module Fin where
+
+  open import Data.Nat.Base as ℕ using (suc; NonZero; z≤n; s≤s)
+  import Data.Nat.Properties as ℕ
+  open import Data.Fin.Base using (Fin; _≤_; fromℕ<; toℕ)
+  import Data.Fin.Properties as Fin
+
+  randomIO : ∀ {n} → .{{NonZero n}} → IO (Fin n)
+  randomIO {n = n@(suc _)} = do
+    suc k ∈[ lo≤k , k≤hi ] ← ℕ.randomRIO 1 n (s≤s z≤n)
+    pure (fromℕ< k≤hi)
+
+  toℕ-cancel-InBounds : ∀ {n} {lo hi : Fin n} →
+                        InBounds ℕ._≤_ (toℕ lo) (toℕ hi) →
+                        InBounds _≤_ lo hi
+  toℕ-cancel-InBounds {n} {lo} {hi} (k ∈[ toℕlo≤k , k≤toℕhi ]) =
+    let
+      .k<n  : k ℕ.< n
+      k<n = ℕ.≤-<-trans k≤toℕhi (Fin.toℕ<n hi)
+
+      .lo≤k : lo ≤ fromℕ< k<n
+      lo≤k = Fin.toℕ-cancel-≤ $ let open ℕ.≤-Reasoning in begin
+        toℕ lo           ≤⟨ toℕlo≤k ⟩
+        k                ≡⟨ Fin.toℕ-fromℕ< k<n ⟨
+        toℕ (fromℕ< k<n) ∎
+
+      .k≤hi : fromℕ< k<n ≤ hi
+      k≤hi = Fin.toℕ-cancel-≤ $ let open ℕ.≤-Reasoning in begin
+        toℕ (fromℕ< k<n) ≡⟨ Fin.toℕ-fromℕ< k<n ⟩
+        k                ≤⟨ k≤toℕhi ⟩
+        toℕ hi           ∎
+
+    in fromℕ< k<n ∈[ lo≤k , k≤hi ]
+
+  randomRIO : ∀ {n} → RandomRIO {A = Fin n} _≤_
+  randomRIO {n} lo hi p = do
+    k ← ℕ.randomRIO (toℕ lo) (toℕ hi) (Fin.toℕ-mono-≤ p)
+    pure (toℕ-cancel-InBounds k)
+
+module List {a} {A : Set a} (rIO : IO A)  where
+
+  open import Data.List.Base using (List; replicate)
+  open import Data.List.Effectful using (module TraversableA)
+
+  -- Careful: this can generate very long lists!
+  -- You may want to use Vec≤ instead.
+  randomIO : IO (List A)
+  randomIO = do
+    lift n ← lift! ℕ.randomIO
+    TraversableA.sequenceA IO.applicative $ replicate n rIO
+
+module Vec {a} {A : Set a} (rIO : IO A) (n : ℕ) where
+
+  open import Data.Vec.Base using (Vec; replicate)
+  open import Data.Vec.Effectful using (module TraversableA)
+
+  randomIO : IO (Vec A n)
+  randomIO = TraversableA.sequenceA IO.applicative $ replicate n rIO
+
+module Vec≤ {a} {A : Set a} (rIO : IO A) (n : ℕ) where
+
+  open import Data.Vec.Bounded.Base using (Vec≤; _,_)
+
+  randomIO : IO (Vec≤ A n)
+  randomIO = do
+    lift (len ∈[ _ , len≤n ]) ← lift! (ℕ.randomRIO 0 n z≤n)
+    vec ← Vec.randomIO rIO len
+    pure (vec , len≤n)
+
+module String where
+
+  open import Data.String.Base using (String; fromList)
+
+  -- Careful: this can generate very long lists!
+  -- You may want to use String≤ instead.
+  randomIO : IO String
+  randomIO = fromList <$> List.randomIO Char.randomIO
+
+module String≤ (n : ℕ) where
+
+  import Data.Vec.Bounded.Base as Vec≤
+  open import Data.String.Base using (String; fromList)
+
+  randomIO : IO String
+  randomIO = fromList ∘ Vec≤.toList <$> Vec≤.randomIO Char.randomIO n
+
+open import Data.Char.Base using (Char; _≤_)
+
+module RangedString≤ (a b : Char)  .(a≤b : a ≤ b) (n : ℕ) where
+
+  import Data.Vec.Bounded.Base as Vec≤
+  open import Data.String.Base using (String; fromList)
+
+  randomIO : IO String
+  randomIO =
+    fromList ∘ Vec≤.toList ∘ Vec≤.map InBounds.value
+    <$> Vec≤.randomIO (Char.randomRIO a b a≤b) n
diff --git a/src/System/Random/Primitive.agda b/src/System/Random/Primitive.agda
new file mode 100644
index 0000000000..b93ee91fcb
--- /dev/null
+++ b/src/System/Random/Primitive.agda
@@ -0,0 +1,42 @@
+------------------------------------------------------------------------
+-- The Agda standard library
+--
+-- Primitive System.Random simple bindings to Haskell functions
+------------------------------------------------------------------------
+
+{-# OPTIONS --cubical-compatible #-}
+
+module System.Random.Primitive where
+
+open import Agda.Builtin.IO using (IO)
+open import Agda.Builtin.Char using (Char)
+open import Agda.Builtin.Float using (Float)
+open import Agda.Builtin.Int using (Int)
+open import Agda.Builtin.Nat using (Nat)
+open import Agda.Builtin.Word using (Word64)
+open import Foreign.Haskell.Pair using (Pair)
+
+postulate
+  randomIO-Char : IO Char
+  randomRIO-Char : Pair Char Char → IO Char
+  randomIO-Int : IO Int
+  randomRIO-Int : Pair Int Int → IO Int
+  randomIO-Float : IO Float
+  randomRIO-Float : Pair Float Float → IO Float
+  randomIO-Nat : IO Nat
+  randomRIO-Nat : Pair Nat Nat → IO Nat
+  randomIO-Word64 : IO Word64
+  randomRIO-Word64 : Pair Word64 Word64 → IO Word64
+
+{-# FOREIGN GHC import System.Random #-}
+
+{-# COMPILE GHC randomIO-Char = randomIO #-}
+{-# COMPILE GHC randomRIO-Char = randomRIO #-}
+{-# COMPILE GHC randomIO-Int = randomIO #-}
+{-# COMPILE GHC randomRIO-Int = randomRIO #-}
+{-# COMPILE GHC randomIO-Float = randomIO #-}
+{-# COMPILE GHC randomRIO-Float = randomRIO #-}
+{-# COMPILE GHC randomIO-Nat = abs <$> randomIO #-}
+{-# COMPILE GHC randomRIO-Nat = randomRIO #-}
+{-# COMPILE GHC randomIO-Word64 = randomIO #-}
+{-# COMPILE GHC randomRIO-Word64 = randomRIO #-}
diff --git a/src/Tactic/Cong.agda b/src/Tactic/Cong.agda
index 5a545a4c77..6fea3dd1e0 100644
--- a/src/Tactic/Cong.agda
+++ b/src/Tactic/Cong.agda
@@ -15,31 +15,35 @@
 --     suc (suc m) + m
 --   ≡⟨ cong! eq ⟩
 --     suc (suc n) + n
---   ≡˘⟨ cong! (+-identityʳ n) ⟩
+--   ≡⟨ cong! (+-identityʳ n) ⟨
 --     suc (suc n) + (n + 0)
 --   ∎
+--
+-- Please see README.Tactic.Cong for more details.
 ------------------------------------------------------------------------
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
 module Tactic.Cong where
 
-open import Function using (_$_)
+open import Function.Base using (_$_)
 
 open import Data.Bool.Base            using (true; false; if_then_else_; _∧_)
 open import Data.Char.Base   as Char  using (toℕ)
 open import Data.Float.Base  as Float using (_≡ᵇ_)
 open import Data.List.Base   as List  using ([]; _∷_)
 open import Data.Maybe.Base  as Maybe using (Maybe; just; nothing)
-open import Data.Nat.Base    as Nat   using (ℕ; zero; suc; _≡ᵇ_; _+_)
+open import Data.Nat.Base    as ℕ     using (ℕ; zero; suc; _≡ᵇ_; _+_)
 open import Data.Unit.Base            using (⊤)
-open import Data.Word.Base   as Word  using (toℕ)
-open import Data.Product
+open import Data.Word64.Base   as Word64  using (toℕ)
+open import Data.Product.Base         using (_×_; map₁; _,_)
+open import Function                  using (flip; case_of_)
 
-open import Relation.Binary.PropositionalEquality as Eq using (_≡_; refl; cong)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
+open import Relation.Nullary.Decidable.Core            using (yes; no)
 
--- 'Data.String.Properties' defines this via 'Dec', so let's use the builtin
--- for maximum speed.
+-- 'Data.String.Properties' defines this via 'Dec', so let's use the
+-- builtin for maximum speed.
 import Agda.Builtin.String as String renaming (primStringEquality to _≡ᵇ_)
 
 open import Reflection
@@ -52,17 +56,33 @@ open import Reflection.AST.Literal              as Literal
 open import Reflection.AST.Meta                 as Meta
 open import Reflection.AST.Name                 as Name
 open import Reflection.AST.Term                 as Term
+import Reflection.AST.Traversal                 as Traversal
 
 open import Reflection.TCM.Syntax
+open import Reflection.TCM.Utilities
 
-----------------------------------------------------------------------
+-- Marker to keep anti-unification from descending into the wrapped
+-- subterm.
+--
+-- For instance, anti-unification of ⌞ a + b ⌟ + c and b + a + c
+-- yields λ ϕ → ϕ + c, as opposed to λ ϕ → ϕ + ϕ + c without ⌞_⌟.
+--
+-- The marker is only visible to the cong! tactic, which inhibits
+-- normalisation. Anywhere else, ⌞ a + b ⌟ reduces to a + b.
+--
+-- Thus, proving ⌞ a + b ⌟ + c ≡ b + a + c via cong! (+-comm a b)
+-- also proves a + b + c ≡ b + a + c.
+⌞_⌟ : ∀ {a} {A : Set a} → A → A
+⌞_⌟ x = x
+
+------------------------------------------------------------------------
 -- Utilities
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 private
   -- Descend past a variable.
   varDescend : ℕ → ℕ → ℕ
-  varDescend ϕ x = if ϕ Nat.≤ᵇ x then suc x else x
+  varDescend ϕ x = if ϕ ℕ.≤ᵇ x then suc x else x
 
   -- Descend a variable underneath pattern variables.
   patternDescend : ℕ → Pattern → Pattern × ℕ
@@ -86,6 +106,16 @@ private
   notEqualityError : ∀ {A : Set} Term → TC A
   notEqualityError goal = typeError (strErr "Cannot rewrite a goal that is not equality: " ∷ termErr goal ∷ [])
 
+  unificationError : ∀ {A : Set} → TC Term → TC Term → TC A
+  unificationError term symTerm = do
+    term' ← term
+    symTerm' ← symTerm
+    -- Don't show the same term twice.
+    let symErr = case term' Term.≟ symTerm' of λ where
+      (yes _) → []
+      (no _) → strErr "\n" ∷ termErr symTerm' ∷ []
+    typeError (strErr "cong! failed, tried:\n" ∷ termErr term' ∷ symErr)
+
   record EqualityGoal : Set where
     constructor equals
     field
@@ -116,7 +146,7 @@ private
     `y ← quoteTC y
     pure $ def (quote cong) $ `a ⟅∷⟆ `A ⟅∷⟆ level ⟅∷⟆ type ⟅∷⟆ vLam "ϕ" f ⟨∷⟩ `x ⟅∷⟆ `y ⟅∷⟆ eq ⟨∷⟩ []
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Anti-Unification
 --
 -- The core idea of the tactic is that we can compute the input
@@ -128,7 +158,7 @@ private
 -- For instance, the two terms 'suc (m + (m + 0)) + (m + 0)' and
 -- 'suc (m + m) + (m + 0)' would anti unify to 'suc (m + _) + (m + 0)'
 -- which we can then use to construct the lambda 'λ ϕ → suc (m + ϕ) + (m + 0)'.
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 private
   antiUnify        : ℕ → Term → Term → Term
@@ -136,7 +166,9 @@ private
   antiUnifyClauses : ℕ → Clauses → Clauses → Maybe Clauses
   antiUnifyClause  : ℕ → Clause → Clause → Maybe Clause
 
-  antiUnify ϕ (var x args) (var y args') with x Nat.≡ᵇ y | antiUnifyArgs ϕ args args'
+  pattern apply-⌞⌟ t = (def (quote ⌞_⌟) (_ ∷ _ ∷ arg _ t ∷ []))
+
+  antiUnify ϕ (var x args) (var y args') with x ℕ.≡ᵇ y | antiUnifyArgs ϕ args args'
   ... | _     | nothing    = var ϕ []
   ... | false | just uargs = var ϕ uargs
   ... | true  | just uargs = var (varDescend ϕ x) uargs
@@ -144,6 +176,7 @@ private
   ... | _     | nothing    = var ϕ []
   ... | false | just uargs = var ϕ []
   ... | true  | just uargs = con c uargs
+  antiUnify ϕ (def f args) (apply-⌞⌟ t) = antiUnify ϕ (def f args) t
   antiUnify ϕ (def f args) (def f' args') with f Name.≡ᵇ f' | antiUnifyArgs ϕ args args'
   ... | _     | nothing    = var ϕ []
   ... | false | just uargs = var ϕ []
@@ -158,13 +191,13 @@ private
     Π[ s ∶ arg i (antiUnify ϕ a a') ] antiUnify (suc ϕ) b b'
   antiUnify ϕ (sort (set t)) (sort (set t')) =
     sort (set (antiUnify ϕ t t'))
-  antiUnify ϕ (sort (lit n)) (sort (lit n')) with n Nat.≡ᵇ n'
+  antiUnify ϕ (sort (lit n)) (sort (lit n')) with n ℕ.≡ᵇ n'
   ... | true  = sort (lit n)
   ... | false = var ϕ []
-  antiUnify ϕ (sort (propLit n)) (sort (propLit n')) with n Nat.≡ᵇ n'
+  antiUnify ϕ (sort (propLit n)) (sort (propLit n')) with n ℕ.≡ᵇ n'
   ... | true  = sort (propLit n)
   ... | false = var ϕ []
-  antiUnify ϕ (sort (inf n)) (sort (inf n')) with n Nat.≡ᵇ n'
+  antiUnify ϕ (sort (inf n)) (sort (inf n')) with n ℕ.≡ᵇ n'
   ... | true  = sort (inf n)
   ... | false = var ϕ []
   antiUnify ϕ (sort unknown) (sort unknown) =
@@ -202,9 +235,9 @@ private
     just []
 
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Rewriting
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 macro
   cong! : ∀ {a} {A : Set a} {x y : A} → x ≡ y → Term → TC ⊤
@@ -217,6 +250,17 @@ macro
     withNormalisation false $ do
       goal ← inferType hole
       eqGoal ← destructEqualityGoal goal
-      let cong-lam = antiUnify 0 (EqualityGoal.lhs eqGoal) (EqualityGoal.rhs eqGoal)
-      cong-tm ← `cong eqGoal cong-lam x≡y
-      unify cong-tm hole
+      let makeTerm = λ lhs rhs → `cong eqGoal (antiUnify 0 lhs rhs) x≡y
+      let lhs = EqualityGoal.lhs eqGoal
+      let rhs = EqualityGoal.rhs eqGoal
+      let term = makeTerm lhs rhs
+      let symTerm = makeTerm rhs lhs
+      let uni = _>>= flip unify hole
+      -- When using ⌞_⌟ with ≡⟨ ... ⟨, (uni term) fails and
+      -- (uni symTerm) succeeds.
+      catchTC (uni term) $
+        catchTC (uni symTerm) $ do
+          -- If we failed because of unresolved metas, restart.
+          blockOnMetas goal
+          -- If we failed for a different reason, show an error.
+          unificationError term symTerm
diff --git a/src/Tactic/MonoidSolver.agda b/src/Tactic/MonoidSolver.agda
index e34d770cde..33cbf95001 100644
--- a/src/Tactic/MonoidSolver.agda
+++ b/src/Tactic/MonoidSolver.agda
@@ -73,13 +73,13 @@
 module Tactic.MonoidSolver where
 
 open import Algebra
-open import Function
+open import Function.Base using (_⟨_⟩_)
 
-open import Data.Bool    as Bool    using (Bool; _∨_; if_then_else_)
-open import Data.Maybe   as Maybe   using (Maybe; just; nothing; maybe)
-open import Data.List    as List    using (List; _∷_; [])
-open import Data.Nat     as ℕ       using (ℕ; suc; zero)
-open import Data.Product as Product using (_×_; _,_)
+open import Data.Bool.Base    as Bool    using (Bool; _∨_; if_then_else_)
+open import Data.Maybe.Base   as Maybe   using (Maybe; just; nothing; maybe)
+open import Data.List.Base    as List    using (List; _∷_; [])
+open import Data.Nat.Base     as ℕ       using (ℕ; suc; zero)
+open import Data.Product.Base as Product using (_×_; _,_)
 
 open import Reflection.AST
 open import Reflection.AST.Term
@@ -88,11 +88,11 @@ import Reflection.AST.Name as Name
 open import Reflection.TCM
 open import Reflection.TCM.Syntax
 
-import Relation.Binary.Reasoning.Setoid as SetoidReasoning
+import Relation.Binary.Reasoning.Setoid as ≈-Reasoning
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- The Expr type with homomorphism proofs
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 infixl 7 _∙′_
 data Expr {a} (A : Set a) : Set a where
@@ -103,7 +103,7 @@ data Expr {a} (A : Set a) : Set a where
 module _ {m₁ m₂} (monoid : Monoid m₁ m₂) where
 
   open Monoid monoid
-  open SetoidReasoning setoid
+  open ≈-Reasoning setoid
 
   -- Convert the AST to an expression (i.e. evaluate it) without
   -- normalising.
@@ -132,7 +132,7 @@ module _ {m₁ m₂} (monoid : Monoid m₁ m₂) where
   homo′ [ x ↑] y   = ∙-congʳ (identityʳ x)
   homo′ (x ∙′ y) z = begin
     [ x ∙′ y ⇓] ∙ z       ≡⟨⟩
-    [ x ⇓]′ [ y ⇓] ∙ z    ≈˘⟨ ∙-congʳ (homo′ x [ y ⇓]) ⟩
+    [ x ⇓]′ [ y ⇓] ∙ z    ≈⟨ ∙-congʳ (homo′ x [ y ⇓]) ⟨
     ([ x ⇓] ∙ [ y ⇓]) ∙ z ≈⟨ assoc [ x ⇓] [ y ⇓] z ⟩
     [ x ⇓] ∙ ([ y ⇓] ∙ z) ≈⟨ ∙-congˡ (homo′ y z) ⟩
     [ x ⇓] ∙ ([ y ⇓]′ z)  ≈⟨ homo′ x ([ y ⇓]′ z) ⟩
@@ -143,13 +143,13 @@ module _ {m₁ m₂} (monoid : Monoid m₁ m₂) where
   homo [ x ↑]   = identityʳ x
   homo (x ∙′ y) = begin
     [ x ∙′ y ⇓]     ≡⟨⟩
-    [ x ⇓]′ [ y ⇓]  ≈˘⟨ homo′ x [ y ⇓] ⟩
+    [ x ⇓]′ [ y ⇓]  ≈⟨ homo′ x [ y ⇓] ⟨
     [ x ⇓] ∙ [ y ⇓] ≈⟨ ∙-cong (homo x) (homo y) ⟩
     [ x ↓] ∙ [ y ↓] ∎
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Helpers for reflection
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 getArgs : Term → Maybe (Term × Term)
 getArgs (def _ xs) = go xs
@@ -160,9 +160,9 @@ getArgs (def _ xs) = go xs
   go _                      = nothing
 getArgs _ = nothing
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Getting monoid names
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 -- We try to be flexible here, by matching two kinds of names.
 -- The first is the field accessor for the monoid record itself.
@@ -191,9 +191,9 @@ findMonoidNames mon = do
     ; is-ε = buildMatcher (quote Monoid.ε)   (getName ε-altName)
     }
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Building Expr
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 -- We now define a function that takes an AST representing the LHS
 -- or RHS of the equation to solve and converts it into an AST
@@ -231,9 +231,9 @@ module _ (names : MonoidNames) where
     else [ t ↑]′
   buildExpr t = quote [_↑] ⟨ con ⟩ (t ⟨∷⟩ [])
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Constructing the solution
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 -- This function joins up the two homomorphism proofs. It constructs
 -- a proof of the following form:
@@ -252,9 +252,9 @@ constructSoln mon names lhs rhs =
     (quote homo ⟨ def ⟩ 2 ⋯⟅∷⟆ mon ⟨∷⟩ buildExpr names rhs ⟨∷⟩ []) ⟨∷⟩
     []
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Macro
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
 solve-macro : Term → Term → TC _
 solve-macro mon hole = do
diff --git a/src/Tactic/RingSolver.agda b/src/Tactic/RingSolver.agda
index 3ae3451e68..59475a3129 100644
--- a/src/Tactic/RingSolver.agda
+++ b/src/Tactic/RingSolver.agda
@@ -18,7 +18,7 @@ open import Data.Nat.Base              using (ℕ; suc; zero; _<ᵇ_)
 open import Data.Bool.Base             using (Bool; if_then_else_; true; false)
 open import Data.Unit.Base             using (⊤)
 open import Data.String.Base as String using (String; _++_; parens)
-open import Data.Product               using (_,_; proj₁)
+open import Data.Product.Base          using (_,_; proj₁)
 open import Function.Base
 open import Relation.Nullary.Decidable
 
@@ -141,6 +141,8 @@ module RingSolverReflection (ring : Term) (numberOfVariables : ℕ) where
   `I : Term → Term
   `I x = quote Ι $ᵉ (x ⟨∷⟩ [])
 
+  infixl 6 _`⊜_
+
   _`⊜_ : Term → Term → Term
   x `⊜ y = quote _⊜_  $ʳ (`numberOfVariables ⟅∷⟆ x ⟨∷⟩ y ⟨∷⟩ [])
 
@@ -349,9 +351,9 @@ constructSolution `ring opTerms variables `lhs `rhs = do
     t' ← convertTerm `ring numVars opTerms varMap t
     pure $ `correct `ring numVars t' ρ
 
--- Use this macro when you want to solve something *under* a lambda. For example:
--- say you have a long proof, and you just want the solver to deal with an
--- intermediate step. Call it like so:
+-- Use this macro when you want to solve something *under* a lambda.
+-- For example: say you have a long proof, and you just want the solver
+-- to deal with an intermediate step. Call it like so:
 --
 --   lemma₃ : ∀ x y → x + y * 1 + 3 ≈ 2 + 1 + y + x
 --   lemma₃ x y = begin
diff --git a/src/Tactic/RingSolver/Core/AlmostCommutativeRing.agda b/src/Tactic/RingSolver/Core/AlmostCommutativeRing.agda
index 84fe184f39..5ed5b8f4ff 100644
--- a/src/Tactic/RingSolver/Core/AlmostCommutativeRing.agda
+++ b/src/Tactic/RingSolver/Core/AlmostCommutativeRing.agda
@@ -9,13 +9,13 @@
 module Tactic.RingSolver.Core.AlmostCommutativeRing where
 
 open import Level
-open import Relation.Binary
+open import Relation.Binary.Core using (Rel; _Preserves_⟶_)
 open import Algebra.Core using (Op₁; Op₂)
 open import Algebra.Structures using (IsCommutativeSemiring)
 open import Algebra.Definitions
 open import Algebra.Bundles using (RawRing; CommutativeRing; CommutativeSemiring)
 import Algebra.Morphism as Morphism
-open import Function hiding (Morphism)
+open import Function.Base using (id)
 open import Level
 open import Data.Maybe.Base as Maybe using (Maybe; just; nothing)
 
diff --git a/src/Tactic/RingSolver/Core/Expression.agda b/src/Tactic/RingSolver/Core/Expression.agda
index cfea6fdf52..566e71ac96 100644
--- a/src/Tactic/RingSolver/Core/Expression.agda
+++ b/src/Tactic/RingSolver/Core/Expression.agda
@@ -17,6 +17,7 @@ open import Algebra
 infixl 6 _⊕_
 infixl 7 _⊗_
 infixr 8 _⊛_
+infix 8 ⊝_
 
 data Expr {a} (A : Set a) (n : ℕ) : Set a where
   Κ   : A → Expr A n                   -- Constant
diff --git a/src/Tactic/RingSolver/Core/NatSet.agda b/src/Tactic/RingSolver/Core/NatSet.agda
index 485539792e..53af68c511 100644
--- a/src/Tactic/RingSolver/Core/NatSet.agda
+++ b/src/Tactic/RingSolver/Core/NatSet.agda
@@ -3,20 +3,20 @@
 --
 -- Simple implementation of sets of ℕ.
 --
--- Since ℕ is represented as unary numbers, simply having an ordered list of
--- numbers to represent a set is quite inefficient. For instance, to see if
--- 6 is in the set {1, 3, 4}, we have to do a comparison with 1, then 3, and
--- then 4. But 4 is equal to suc 3, so we should be able to share the work
--- accross those two comparisons.
+-- Since ℕ is represented as unary numbers, simply having an ordered
+-- list of numbers to represent a set is quite inefficient. For
+-- instance, to see if 6 is in the set {1, 3, 4}, we have to do a
+-- comparison with 1, then 3, and then 4. But 4 is equal to suc 3, so
+-- we should be able to share the work accross those two comparisons.
 --
 -- This module defines a type that represents {1, 3, 4} as:
 --
 --   1 ∷ 1 ∷ 0 ∷ []
 --
--- i.e. we only store the gaps. When checking if a number (the needle) is in the
--- set (the haystack), we subtract each successive member of the haystack from the
--- needle as we go. For example, to check if 6 is in the above set, we do the
--- following:
+-- i.e. we only store the gaps. When checking if a number (the needle)
+-- is in the set (the haystack), we subtract each successive member of
+-- the haystack from the needle as we go. For example, to check if 6 is
+-- in the above set, we do the following:
 --
 --   start:                  6 ∈? (1 ∷ 1 ∷ 0 ∷ [])
 --   test head:              6 ≟ 1
@@ -36,12 +36,14 @@
 
 module Tactic.RingSolver.Core.NatSet where
 
-open import Data.Nat   as ℕ     using (ℕ; suc; zero)
-open import Data.List  as List  using (List; _∷_; [])
+open import Data.Nat.Base   as ℕ     using (ℕ; suc; zero)
+open import Data.List.Base  as List  using (List; _∷_; [])
+open import Data.List.Scans.Base as Scans using (scanl)
 open import Data.Maybe.Base as Maybe using (Maybe; just; nothing)
-open import Data.Bool  as Bool  using (Bool)
-open import Function
-open import Relation.Binary.PropositionalEquality
+open import Data.Bool.Base  as Bool  using (Bool)
+open import Function.Base            using (const; _∘_)
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl)
 
 ------------------------------------------------------------------------
 -- Helper methods
@@ -97,7 +99,7 @@ fromList : List ℕ → NatSet
 fromList = List.foldr insert []
 
 toList : NatSet → List ℕ
-toList = List.drop 1 ∘ List.map ℕ.pred ∘ List.scanl (λ x y → suc (y ℕ.+ x)) 0
+toList = List.drop 1 ∘ List.map ℕ.pred ∘ Scans.scanl (λ x y → suc (y ℕ.+ x)) 0
 
 ------------------------------------------------------------------------
 -- Tests
diff --git a/src/Tactic/RingSolver/Core/Polynomial/Base.agda b/src/Tactic/RingSolver/Core/Polynomial/Base.agda
index d762794b5e..6de64bf839 100644
--- a/src/Tactic/RingSolver/Core/Polynomial/Base.agda
+++ b/src/Tactic/RingSolver/Core/Polynomial/Base.agda
@@ -50,15 +50,15 @@ module Tactic.RingSolver.Core.Polynomial.Base
 
 open RawCoeff coeffs
 
-open import Data.Bool              using (Bool; true; false; T)
+open import Data.Bool.Base         using (Bool; true; false; T)
 open import Data.Empty             using (⊥)
 open import Data.Fin.Base as Fin        using (Fin; zero; suc)
 open import Data.List.Kleene
 open import Data.Nat.Base as ℕ          using (ℕ; suc; zero; _≤′_; compare; ≤′-refl; ≤′-step; _<′_)
 open import Data.Nat.Properties    using (z≤′n; ≤′-trans)
 open import Data.Nat.Induction
-open import Data.Product           using (_×_; _,_; map₁; curry; uncurry)
-open import Data.Unit              using (⊤; tt)
+open import Data.Product.Base      using (_×_; _,_; map₁; curry; uncurry)
+open import Data.Unit.Base         using (⊤; tt)
 open import Function.Base
 open import Relation.Nullary       using (¬_; Dec; yes; no)
 
@@ -106,9 +106,9 @@ space≤′n : ∀ {n} (x : Fin n) → space x ≤′ n
 space≤′n zero    = ≤′-refl
 space≤′n (suc x) = ≤′-step (space≤′n x)
 
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Definition
--------------------------------------------------------------------------
+------------------------------------------------------------------------
 
 infixl 6 _Δ_
 record PowInd {c} (C : Set c) : Set c where
@@ -168,7 +168,7 @@ Normalised (_ Δ suc _ & _)   = ⊤
 open NonZero public
 open Poly public
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Special operations
 
 -- Decision procedure for Zero
@@ -212,17 +212,17 @@ _⊐↓_ : ∀ {i n} → Coeff i * → suc i ≤′ n → Poly n
 (∹ (x    Δ suc j & xs  )) ⊐↓ i≤n = ⅀ (x Δ suc j & xs)   ⊐ i≤n
 {-# INLINE _⊐↓_ #-}
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Standard operations
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Folds
 
--- These folds allow us to abstract over the proofs later: we try to avoid
--- using ∷↓ and ⊐↓ directly anywhere except here, so if we prove that this fold
--- acts the same on a normalised or non-normalised polynomial, we can prove th
--- same about any operation which uses it.
+-- These folds allow us to abstract over the proofs later: we try to
+-- avoid using ∷↓ and ⊐↓ directly anywhere except here, so if we prove
+-- that this fold acts the same on a normalised or non-normalised
+-- polynomial, we can prove th same about any operation which uses it.
 
 PolyF : ℕ → Set ℓ₁
 PolyF i = Poly i × Coeff i *
@@ -238,7 +238,7 @@ poly-map : ∀ {i} → (Poly i → Poly i) → Coeff i + → Coeff i *
 poly-map f = para (map₁ f)
 {-# INLINE poly-map #-}
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Addition
 
 -- The reason the following code is so verbose is termination
@@ -255,8 +255,8 @@ poly-map f = para (map₁ f)
 -- a list that was already pattern-matched on, the recursive call
 -- does not strictly decrease the size of its argument.
 --
--- Interestingly, if --cubical-compatible is turned off, we don't need the
--- helper function ⊞-coeffs; we could pattern match on _⊞_ directly.
+-- Interestingly, if --cubical-compatible is turned off, we don't need
+-- the helper function ⊞-coeffs; we could pattern match on _⊞_ directly.
 --
 -- _⊞_ {zero} (lift x) (lift y) = lift (x + y)
 -- _⊞_ {suc n} [] ys = ys
@@ -308,7 +308,7 @@ mutual
   ⊞-zip-r x i xs [] = ∹ x Δ i & xs
   ⊞-zip-r x i xs (∹ y Δ j & ys) = ⊞-zip (compare i j) x xs y ys
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Negation
 
 -- recurse on acc directly
@@ -316,13 +316,13 @@ mutual
 
 ⊟-step : ∀ {n} → Acc _<′_ n → Poly n → Poly n
 ⊟-step (acc wf) (Κ x  ⊐ i≤n) = Κ (- x) ⊐ i≤n
-⊟-step (acc wf) (⅀ xs ⊐ i≤n) = poly-map (⊟-step (wf _ i≤n)) xs ⊐↓ i≤n
+⊟-step (acc wf) (⅀ xs ⊐ i≤n) = poly-map (⊟-step (wf i≤n)) xs ⊐↓ i≤n
 
 ⊟_ : ∀ {n} → Poly n → Poly n
 ⊟_ = ⊟-step (<′-wellFounded _)
 {-# INLINE ⊟_ #-}
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Multiplication
 
 mutual
@@ -335,12 +335,12 @@ mutual
 
   ⊠-Κ : ∀ {n} → Acc _<′_ n → Carrier → Poly n → Poly n
   ⊠-Κ (acc _ ) x (Κ y  ⊐ i≤n) = Κ (x * y) ⊐ i≤n
-  ⊠-Κ (acc wf) x (⅀ xs ⊐ i≤n) = ⊠-Κ-inj (wf _ i≤n) x xs ⊐↓ i≤n
+  ⊠-Κ (acc wf) x (⅀ xs ⊐ i≤n) = ⊠-Κ-inj (wf i≤n) x xs ⊐↓ i≤n
   {-# INLINE ⊠-Κ #-}
 
   ⊠-⅀ : ∀ {i n} → Acc _<′_ n → Coeff i + → i <′ n → Poly n → Poly n
   ⊠-⅀ (acc wf) xs i≤n (⅀ ys ⊐ j≤n) = ⊠-match  (acc wf) (inj-compare i≤n j≤n) xs ys
-  ⊠-⅀ (acc wf) xs i≤n (Κ y ⊐ _)    = ⊠-Κ-inj (wf _ i≤n) y xs ⊐↓ i≤n
+  ⊠-⅀ (acc wf) xs i≤n (Κ y ⊐ _)    = ⊠-Κ-inj (wf i≤n) y xs ⊐↓ i≤n
 
   ⊠-Κ-inj : ∀ {i}  → Acc _<′_ i → Carrier → Coeff i + → Coeff i *
   ⊠-Κ-inj a x xs = poly-map (⊠-Κ a x) (xs)
@@ -352,7 +352,7 @@ mutual
           → Poly k
           → Poly k
   ⊠-⅀-inj (acc wf) i≤k x (⅀ y ⊐ j≤k) = ⊠-match (acc wf) (inj-compare i≤k j≤k) x y
-  ⊠-⅀-inj (acc wf) i≤k x (Κ y ⊐ j≤k) = ⊠-Κ-inj (wf _ i≤k) y x ⊐↓ i≤k
+  ⊠-⅀-inj (acc wf) i≤k x (Κ y ⊐ j≤k) = ⊠-Κ-inj (wf i≤k) y x ⊐↓ i≤k
 
   ⊠-match : ∀ {i j n}
           → Acc _<′_ n
@@ -362,9 +362,9 @@ mutual
           → Coeff i +
           → Coeff j +
           → Poly n
-  ⊠-match (acc wf) (inj-eq i&j≤n)     xs ys = ⊠-coeffs (wf _ i&j≤n) xs ys               ⊐↓ i&j≤n
-  ⊠-match (acc wf) (inj-lt i≤j-1 j≤n) xs ys = poly-map (⊠-⅀-inj (wf _ j≤n) i≤j-1 xs) (ys) ⊐↓ j≤n
-  ⊠-match (acc wf) (inj-gt i≤n j≤i-1) xs ys = poly-map (⊠-⅀-inj (wf _ i≤n) j≤i-1 ys) (xs) ⊐↓ i≤n
+  ⊠-match (acc wf) (inj-eq i&j≤n)     xs ys = ⊠-coeffs (wf i&j≤n) xs ys               ⊐↓ i&j≤n
+  ⊠-match (acc wf) (inj-lt i≤j-1 j≤n) xs ys = poly-map (⊠-⅀-inj (wf j≤n) i≤j-1 xs) (ys) ⊐↓ j≤n
+  ⊠-match (acc wf) (inj-gt i≤n j≤i-1) xs ys = poly-map (⊠-⅀-inj (wf i≤n) j≤i-1 ys) (xs) ⊐↓ i≤n
 
   ⊠-coeffs : ∀ {n} → Acc _<′_ n → Coeff n + → Coeff n + → Coeff n *
   ⊠-coeffs a (xs) (y ≠0 Δ j & [])   = poly-map (⊠-step′ a y) (xs) ⍓* j
@@ -385,7 +385,7 @@ _⊠_ : ∀ {n} → Poly n → Poly n → Poly n
 _⊠_ = ⊠-step′ (<′-wellFounded _)
 {-# INLINE _⊠_ #-}
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Constants and variables
 
 -- The constant polynomial
@@ -398,7 +398,7 @@ _⊠_ = ⊠-step′ (<′-wellFounded _)
 ι i = (κ 1# Δ 1 ∷↓ []) ⊐↓ space≤′n i
 {-# INLINE ι #-}
 
-----------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Exponentiation
 
 -- We try very hard to never do things like multiply by 1
diff --git a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Addition.agda b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Addition.agda
index 990d6a46ed..32cbefe63a 100644
--- a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Addition.agda
+++ b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Addition.agda
@@ -13,16 +13,16 @@ module Tactic.RingSolver.Core.Polynomial.Homomorphism.Addition
   (homo : Homomorphism r₁ r₂ r₃ r₄)
   where
 
-open import Data.Nat            as ℕ  using (ℕ; suc; zero; compare; _≤′_; ≤′-step; ≤′-refl)
-open import Data.Nat.Properties as ℕₚ using (≤′-trans)
-open import Data.Product              using (_,_; _×_; proj₂)
-open import Data.List                 using (_∷_; [])
+open import Data.Nat.Base       as ℕ using (ℕ; suc; zero; compare; _≤′_; ≤′-step; ≤′-refl)
+open import Data.Nat.Properties as ℕ using (≤′-trans)
+open import Data.Product.Base        using (_,_; _×_; proj₂)
+open import Data.List.Base           using (_∷_; [])
 open import Data.List.Kleene
-open import Data.Vec                  using (Vec)
-open import Function
+open import Data.Vec.Base            using (Vec)
+open import Function.Base using (_⟨_⟩_; flip)
 open import Relation.Unary
 
-import Relation.Binary.PropositionalEquality as ≡
+import Relation.Binary.PropositionalEquality.Core as ≡
 
 open Homomorphism homo hiding (_^_)
 open import Tactic.RingSolver.Core.Polynomial.Homomorphism.Lemmas homo
@@ -206,7 +206,7 @@ mutual
             ρ ^ suc j * ((ρ * ⅀?⟦ xs ⟧ (ρ , Ρ) + ⟦ poly x ⟧ Ρ) *⟨ ρ ⟩^ k)
           ≈⟨ pow-add _ _ k j ⟩
             (ρ * ⅀?⟦ xs ⟧ (ρ , Ρ) + ⟦ poly x ⟧ Ρ) *⟨ ρ ⟩^ (k ℕ.+ suc j)
-            ≡⟨ ≡.cong (λ i → (ρ * ⅀?⟦ xs ⟧ (ρ , Ρ) + ⟦ poly x ⟧ Ρ) *⟨ ρ ⟩^ i) (ℕₚ.+-comm k (suc j)) ⟩
+            ≡⟨ ≡.cong (λ i → (ρ * ⅀?⟦ xs ⟧ (ρ , Ρ) + ⟦ poly x ⟧ Ρ) *⟨ ρ ⟩^ i) (ℕ.+-comm k (suc j)) ⟩
             (ρ * ⅀?⟦ xs ⟧ (ρ , Ρ) + ⟦ poly x ⟧ Ρ) *⟨ ρ ⟩^ (suc j ℕ.+ k)
           ∎)
     ⟩
diff --git a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Exponentiation.agda b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Exponentiation.agda
index 6fda530012..58086538ed 100644
--- a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Exponentiation.agda
+++ b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Exponentiation.agda
@@ -13,15 +13,15 @@ module Tactic.RingSolver.Core.Polynomial.Homomorphism.Exponentiation
   (homo : Homomorphism r₁ r₂ r₃ r₄)
   where
 
-open import Function
+open import Function.Base using (_⟨_⟩_)
 
 open import Data.Nat.Base as ℕ using (ℕ; suc; zero; compare)
-open import Data.Product  using (_,_; _×_; proj₁; proj₂)
+open import Data.Product.Base  using (_,_; _×_; proj₁; proj₂)
 open import Data.List.Kleene
-open import Data.Vec      using (Vec)
+open import Data.Vec.Base      using (Vec)
 
-import Data.Nat.Properties as ℕ-Prop
-import Relation.Binary.PropositionalEquality as ≡
+import Data.Nat.Properties as ℕ
+import Relation.Binary.PropositionalEquality.Core as ≡
 
 open Homomorphism homo
 open import Tactic.RingSolver.Core.Polynomial.Homomorphism.Lemmas homo
@@ -64,7 +64,7 @@ pow-eval-hom x (suc i) = (*-homo _ x) ⟨ trans ⟩ (≪* pow-eval-hom x i)
   rearrange zero =
     begin
       (ρ′ RawPow.^ (i ℕ.* 0)) * (⟦ x ⟧ Ρ RawPow.^ suc i)
-    ≡⟨ ≡.cong (λ k →  (ρ′ RawPow.^ k) * (⟦ x ⟧ Ρ RawPow.^ suc i)) (ℕ-Prop.*-zeroʳ i) ⟩
+    ≡⟨ ≡.cong (λ k →  (ρ′ RawPow.^ k) * (⟦ x ⟧ Ρ RawPow.^ suc i)) (ℕ.*-zeroʳ i) ⟩
       1# * (⟦ x ⟧ Ρ RawPow.^ suc i)
     ≈⟨ *-identityˡ _ ⟩
       ⟦ x ⟧ Ρ RawPow.^ suc i
@@ -72,7 +72,7 @@ pow-eval-hom x (suc i) = (*-homo _ x) ⟨ trans ⟩ (≪* pow-eval-hom x i)
   rearrange j@(suc j′) =
     begin
       (ρ′ RawPow.^ (suc i ℕ.* j))           * (⟦ x ⟧ Ρ RawPow.^ suc i)
-    ≡⟨ ≡.cong (λ v → (ρ′ RawPow.^ v) * (⟦ x ⟧ Ρ RawPow.^ suc i)) (ℕ-Prop.*-comm (suc i) j) ⟩
+    ≡⟨ ≡.cong (λ v → (ρ′ RawPow.^ v) * (⟦ x ⟧ Ρ RawPow.^ suc i)) (ℕ.*-comm (suc i) j) ⟩
       (ρ′ RawPow.^ (j ℕ.* suc i))           * (⟦ x ⟧ Ρ RawPow.^ suc i)
     ≈⟨ ≪* sym (RawPow.^-assocʳ ρ′ j (suc i)) ⟩
       ((ρ′ RawPow.^ suc j′) RawPow.^ suc i) * (⟦ x ⟧ Ρ RawPow.^ suc i)
diff --git a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Lemmas.agda b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Lemmas.agda
index f0c5dfcd76..36c66422c7 100644
--- a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Lemmas.agda
+++ b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Lemmas.agda
@@ -13,20 +13,20 @@ module Tactic.RingSolver.Core.Polynomial.Homomorphism.Lemmas
   (homo : Homomorphism r₁ r₂ r₃ r₄)
   where
 
-open import Data.Bool                                  using (Bool;true;false)
-open import Data.Nat.Base as ℕ                         using (ℕ; suc; zero; compare; _≤′_; ≤′-step; ≤′-refl)
-open import Data.Nat.Properties as ℕₚ                  using (≤′-trans)
-open import Data.Vec.Base as Vec                       using (Vec; _∷_)
-open import Data.Fin                                   using (Fin; zero; suc)
-open import Data.List                                  using (_∷_; [])
-open import Data.Unit using (tt)
+open import Data.Bool.Base                                  using (Bool;true;false)
+open import Data.Nat.Base as ℕ                              using (ℕ; suc; zero; compare; _≤′_; ≤′-step; ≤′-refl)
+open import Data.Nat.Properties as ℕ                        using (≤′-trans)
+open import Data.Vec.Base as Vec                            using (Vec; _∷_)
+open import Data.Fin.Base                                   using (Fin; zero; suc)
+open import Data.List.Base                                  using (_∷_; [])
+open import Data.Unit.Base using (tt)
 open import Data.List.Kleene
-open import Data.Product                               using (_,_; proj₁; proj₂; map₁; _×_)
-open import Data.Maybe                                 using (nothing; just)
-open import Function
-open import Level                                      using (lift)
-open import Relation.Nullary                           using (Dec; yes; no)
-open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)
+open import Data.Product.Base                               using (_,_; proj₁; proj₂; map₁; _×_)
+open import Data.Maybe.Base                                 using (nothing; just)
+open import Function.Base                                   using (_⟨_⟩_)
+open import Level                                           using (lift)
+open import Relation.Nullary.Decidable.Core                 using (Dec; yes; no)
+open import Relation.Binary.PropositionalEquality.Core as ≡ using (_≡_)
 
 open Homomorphism homo hiding (_^_)
 open import Tactic.RingSolver.Core.Polynomial.Reasoning to
@@ -59,13 +59,13 @@ pow-add x y (suc i) j = go x y i j
     y ^ suc (suc i ℕ.+ suc j) * x          ∎
 
 -- Here we show a homomorphism on exponentiation, i.e. that using the
--- exponentiation function on polynomials and then evaluating is the same
--- as evaluating and then exponentiating.
+-- exponentiation function on polynomials and then evaluating is the
+-- same as evaluating and then exponentiating.
 pow-hom : ∀ {n} i
         → (xs : Coeff n +)
         → ∀ ρ ρs
         → ⅀⟦ xs ⟧ (ρ , ρs) *⟨ ρ ⟩^ i ≈ ⅀⟦ xs ⍓+ i ⟧ (ρ , ρs)
-pow-hom zero (x Δ j & xs) ρ ρs rewrite ℕₚ.+-identityʳ j = refl
+pow-hom zero (x Δ j & xs) ρ ρs rewrite ℕ.+-identityʳ j = refl
 pow-hom (suc i) (x ≠0 Δ j & xs) ρ ρs =
   begin
     ρ ^ (suc i) * (((x , xs) ⟦∷⟧ (ρ , ρs)) *⟨ ρ ⟩^ j)
@@ -93,10 +93,10 @@ pow-sucʳ : ∀ x i → x ^ suc i ≈ x ^ i * x
 pow-sucʳ x zero  = sym (*-identityˡ _)
 pow-sucʳ x (suc i) = refl
 
--- In the proper evaluation function, we avoid ever inserting an unnecessary 0#
--- like we do here. However, it is easier to prove with the form that does insert
--- 0#. So we write one here, and then prove that it's equivalent to the one that
--- adds a 0#.
+-- In the proper evaluation function, we avoid ever inserting an
+-- unnecessary 0# like we do here. However, it is easier to prove with
+-- the form that does insert 0#. So we write one here, and then prove
+-- that it's equivalent to the one that adds a 0#.
 ⅀?⟦_⟧ : ∀ {n} (xs : Coeff n *) → Carrier × Vec Carrier n → Carrier
 ⅀?⟦ []  ⟧ _ = 0#
 ⅀?⟦ ∹ x ⟧   = ⅀⟦ x ⟧
@@ -117,8 +117,8 @@ pow′-hom zero [] ρ ρs = refl
 pow′-hom (suc i) [] ρ ρs = zeroʳ _
 
 -- Here, we show that the normalising cons is correct.
--- This lets us prove with respect to the non-normalising form, especially
--- when we're using the folds.
+-- This lets us prove with respect to the non-normalising form,
+-- especially when we're using the folds.
 ∷↓-hom-0 : ∀ {n} (x : Poly n) → ∀ xs ρ ρs → ⅀?⟦ x Δ 0 ∷↓ xs ⟧ (ρ , ρs) ≈ (x , xs) ⟦∷⟧ (ρ , ρs)
 ∷↓-hom-0 x xs      ρ ρs with zero? x
 ∷↓-hom-0 x xs      ρ ρs | no ¬p = refl
@@ -161,9 +161,9 @@ pow′-hom (suc i) [] ρ ρs = zeroʳ _
 ⟦∷⟧-hom x []     ρ ρs = sym ((≪+ zeroʳ _) ⟨ trans ⟩ +-identityˡ _)
 ⟦∷⟧-hom x (∹ xs) ρ ρs = refl
 
--- This proves that injecting a polynomial into more variables is correct.
--- Basically, we show that if a polynomial doesn't care about the first few
--- variables, we can drop them from the input vector.
+-- This proves that injecting a polynomial into more variables is
+-- correct. Basically, we show that if a polynomial doesn't care about
+-- the first few variables, we can drop them from the input vector.
 ⅀-⊐↑-hom : ∀ {i n m}
          → (xs : Coeff i +)
          → (si≤n : suc i ≤′ n)
@@ -222,11 +222,12 @@ drop-1⇒lookup : ∀ {n} (i : Fin n) (ρs : Vec Carrier n) →
 drop-1⇒lookup zero    (ρ ∷ ρs) = ≡.refl
 drop-1⇒lookup (suc i) (ρ ∷ ρs) = drop-1⇒lookup i ρs
 
--- The fold: this function saves us hundreds of lines of proofs in the rest of the
--- homomorphism proof.
--- Many of the functions on polynomials are defined using para: this function allows
--- us to prove properties of those functions (in a foldr-fusion style) *ignoring*
--- optimisations we have made to the polynomial structure.
+-- The fold: this function saves us hundreds of lines of proofs in the
+-- rest of the homomorphism proof.
+-- Many of the functions on polynomials are defined using para: this
+-- function allows us to prove properties of those functions (in a
+-- foldr-fusion style) *ignoring* optimisations we have made to the
+-- polynomial structure.
 poly-foldR : ∀ {n} ρ ρs
         → ([f] : Fold n)
         → (f : Carrier → Carrier)
@@ -245,7 +246,7 @@ poly-foldR ρ ρs f e cng dist step base (x ≠0 Δ suc i & []) =
     ⅀?⟦ y Δ suc i ∷↓ ys ⟧ (ρ , ρs)
   ≈⟨ ∷↓-hom-s y i ys ρ ρs ⟩
     (ρ ^ suc i) * ((y , ys) ⟦∷⟧ (ρ , ρs))
-  ≈˘⟨ *≫ ⟦∷⟧?-hom y ys ρ ρs ⟩
+  ≈⟨ *≫ ⟦∷⟧?-hom y ys ρ ρs ⟨
     (ρ ^ suc i) * ((y , ys) ⟦∷⟧? (ρ , ρs))
   ≈⟨ *≫ step x [] (sym base) ⟩
     (ρ ^ suc i) * e ((x , []) ⟦∷⟧? (ρ , ρs))
@@ -264,7 +265,7 @@ poly-foldR ρ ρs f e cng dist step base (x ≠0 Δ suc i & ∹ xs) =
     ⅀?⟦ y Δ suc i ∷↓ zs ⟧ (ρ , ρs)
   ≈⟨ ∷↓-hom-s y i zs ρ ρs ⟩
     (ρ ^ suc i) * ((y , zs) ⟦∷⟧ (ρ , ρs))
-  ≈˘⟨ *≫ ⟦∷⟧?-hom y zs ρ ρs ⟩
+  ≈⟨ *≫ ⟦∷⟧?-hom y zs ρ ρs ⟨
     (ρ ^ suc i) * ((y , zs) ⟦∷⟧? (ρ , ρs))
   ≈⟨ *≫ step x (∹ xs) (poly-foldR ρ ρs f e cng dist step base xs) ⟩
     (ρ ^ suc i) * e ((x , (∹ xs )) ⟦∷⟧? (ρ , ρs))
@@ -282,7 +283,7 @@ poly-foldR ρ ρs f e cng dist step base (x ≠0 Δ ℕ.zero & []) =
     ⅀?⟦ y Δ ℕ.zero ∷↓ zs ⟧ (ρ , ρs)
   ≈⟨ ∷↓-hom-0 y zs ρ ρs ⟩
     ((y , zs) ⟦∷⟧ (ρ , ρs))
-  ≈˘⟨ ⟦∷⟧?-hom y zs ρ ρs ⟩
+  ≈⟨ ⟦∷⟧?-hom y zs ρ ρs ⟨
     ((y , zs) ⟦∷⟧? (ρ , ρs))
   ≈⟨ step x [] (sym base) ⟩
     e ((x , []) ⟦∷⟧? (ρ , ρs))
@@ -299,7 +300,7 @@ poly-foldR ρ ρs f e cng dist step base (x ≠0 Δ ℕ.zero & (∹ xs )) =
     ⅀?⟦ y Δ ℕ.zero ∷↓ zs ⟧ (ρ , ρs)
   ≈⟨ ∷↓-hom-0 y zs ρ ρs ⟩
     ((y , zs) ⟦∷⟧ (ρ , ρs))
-  ≈˘⟨ ⟦∷⟧?-hom y zs ρ ρs ⟩
+  ≈⟨ ⟦∷⟧?-hom y zs ρ ρs ⟨
     ((y , zs) ⟦∷⟧? (ρ , ρs))
   ≈⟨ step x (∹ xs ) (poly-foldR ρ ρs f e cng dist step base xs) ⟩
     e ((x , (∹ xs )) ⟦∷⟧ (ρ , ρs))
diff --git a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Multiplication.agda b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Multiplication.agda
index c322284a96..07e157389c 100644
--- a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Multiplication.agda
+++ b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Multiplication.agda
@@ -16,10 +16,10 @@ module Tactic.RingSolver.Core.Polynomial.Homomorphism.Multiplication
 open import Data.Nat.Base as ℕ     using (ℕ; suc; zero; _<′_; _≤′_; ≤′-step; ≤′-refl)
 open import Data.Nat.Properties    using (≤′-trans)
 open import Data.Nat.Induction
-open import Data.Product           using (_×_; _,_; proj₁; proj₂; map₁)
+open import Data.Product.Base      using (_×_; _,_; proj₁; proj₂; map₁)
 open import Data.List.Kleene
-open import Data.Vec               using (Vec)
-open import Function
+open import Data.Vec.Base          using (Vec)
+open import Function.Base using (_⟨_⟩_; flip)
 open import Induction.WellFounded
 open import Relation.Unary
 
@@ -58,10 +58,10 @@ mutual
   ⊠-Κ-hom (acc _)  x (Κ y  ⊐ i≤n) ρ = *-homo x y
   ⊠-Κ-hom (acc wf) x (⅀ xs ⊐ i≤n) ρ =
     begin
-      ⟦ ⊠-Κ-inj (wf _ i≤n) x xs ⊐↓ i≤n ⟧ ρ
-    ≈⟨ ⊐↓-hom (⊠-Κ-inj (wf _ i≤n) x xs) i≤n ρ ⟩
-      ⅀?⟦ ⊠-Κ-inj (wf _ i≤n) x xs ⟧ (drop-1 i≤n ρ)
-    ≈⟨ ⊠-Κ-inj-hom (wf _ i≤n) x xs (drop-1 i≤n ρ) ⟩
+      ⟦ ⊠-Κ-inj (wf i≤n) x xs ⊐↓ i≤n ⟧ ρ
+    ≈⟨ ⊐↓-hom (⊠-Κ-inj (wf i≤n) x xs) i≤n ρ ⟩
+      ⅀?⟦ ⊠-Κ-inj (wf i≤n) x xs ⟧ (drop-1 i≤n ρ)
+    ≈⟨ ⊠-Κ-inj-hom (wf i≤n) x xs (drop-1 i≤n ρ) ⟩
       ⟦ x ⟧ᵣ * ⅀⟦ xs ⟧ (drop-1 i≤n ρ)
     ∎
 
@@ -94,10 +94,10 @@ mutual
   ⊠-⅀-hom (acc wf) xs i<n (⅀ ys ⊐ j≤n) = ⊠-match-hom (acc wf) (inj-compare i<n j≤n) xs ys
   ⊠-⅀-hom (acc wf) xs i<n (Κ y  ⊐ _) ρ =
     begin
-      ⟦ ⊠-Κ-inj (wf _ i<n) y xs ⊐↓ i<n ⟧ ρ
-    ≈⟨ ⊐↓-hom (⊠-Κ-inj (wf _ i<n) y xs) i<n ρ ⟩
-      ⅀?⟦ ⊠-Κ-inj (wf _ i<n) y xs ⟧ (drop-1 i<n ρ)
-    ≈⟨ ⊠-Κ-inj-hom (wf _ i<n) y xs (drop-1 i<n ρ) ⟩
+      ⟦ ⊠-Κ-inj (wf i<n) y xs ⊐↓ i<n ⟧ ρ
+    ≈⟨ ⊐↓-hom (⊠-Κ-inj (wf i<n) y xs) i<n ρ ⟩
+      ⅀?⟦ ⊠-Κ-inj (wf i<n) y xs ⟧ (drop-1 i<n ρ)
+    ≈⟨ ⊠-Κ-inj-hom (wf i<n) y xs (drop-1 i<n ρ) ⟩
       ⟦ y ⟧ᵣ * ⅀⟦ xs ⟧ (drop-1 i<n ρ)
     ≈⟨ *-comm _ _ ⟩
       ⅀⟦ xs ⟧ (drop-1 i<n ρ) * ⟦ y ⟧ᵣ
@@ -113,10 +113,10 @@ mutual
   ⊠-⅀-inj-hom (acc wf) i<k x (⅀ ys ⊐ j≤k) = ⊠-match-hom (acc wf) (inj-compare i<k j≤k) x ys
   ⊠-⅀-inj-hom (acc wf) i<k x (Κ y ⊐ j≤k) ρ =
     begin
-      ⟦ ⊠-Κ-inj (wf _ i<k) y x ⊐↓ i<k ⟧ ρ
-    ≈⟨ ⊐↓-hom (⊠-Κ-inj (wf _ i<k) y x) i<k ρ ⟩
-      ⅀?⟦ ⊠-Κ-inj (wf _ i<k) y x ⟧ (drop-1 i<k ρ)
-    ≈⟨ ⊠-Κ-inj-hom (wf _ i<k) y x (drop-1 i<k ρ) ⟩
+      ⟦ ⊠-Κ-inj (wf i<k) y x ⊐↓ i<k ⟧ ρ
+    ≈⟨ ⊐↓-hom (⊠-Κ-inj (wf i<k) y x) i<k ρ ⟩
+      ⅀?⟦ ⊠-Κ-inj (wf i<k) y x ⟧ (drop-1 i<k ρ)
+    ≈⟨ ⊠-Κ-inj-hom (wf i<k) y x (drop-1 i<k ρ) ⟩
       ⟦ y ⟧ᵣ * ⅀⟦ x ⟧ (drop-1 i<k ρ)
     ≈⟨ *-comm _ _ ⟩
       ⅀⟦ x ⟧ (drop-1 i<k ρ) * ⟦ y ⟧ᵣ
@@ -137,15 +137,15 @@ mutual
         xs′ = ⅀⟦ xs ⟧ (drop-1 (≤′-trans (≤′-step i≤j-1) j≤n) Ρ′)
     in
     begin
-      ⟦ poly-map ( (⊠-⅀-inj (wf _ j≤n) i≤j-1 xs)) ys ⊐↓ j≤n ⟧ Ρ′
-    ≈⟨ ⊐↓-hom (poly-map ( (⊠-⅀-inj (wf _ j≤n) i≤j-1 xs)) ys) j≤n Ρ′ ⟩
-      ⅀?⟦ poly-map ( (⊠-⅀-inj (wf _ j≤n) i≤j-1 xs)) ys ⟧ (ρ , Ρ)
-    ≈⟨ poly-mapR ρ Ρ (⊠-⅀-inj (wf _ j≤n) i≤j-1 xs)
+      ⟦ poly-map ( (⊠-⅀-inj (wf j≤n) i≤j-1 xs)) ys ⊐↓ j≤n ⟧ Ρ′
+    ≈⟨ ⊐↓-hom (poly-map ( (⊠-⅀-inj (wf j≤n) i≤j-1 xs)) ys) j≤n Ρ′ ⟩
+      ⅀?⟦ poly-map ( (⊠-⅀-inj (wf j≤n) i≤j-1 xs)) ys ⟧ (ρ , Ρ)
+    ≈⟨ poly-mapR ρ Ρ (⊠-⅀-inj (wf j≤n) i≤j-1 xs)
                      (_ *_)
                      (*-cong refl)
                      reassoc
                      (distribˡ _)
-                     (λ y → ⊠-⅀-inj-hom (wf _ j≤n) i≤j-1 xs y _)
+                     (λ y → ⊠-⅀-inj-hom (wf j≤n) i≤j-1 xs y _)
                      (zeroʳ _) ys ⟩
        ⅀⟦ xs ⟧ (drop-1 i≤j-1 Ρ) * ⅀⟦ ys ⟧ (ρ , Ρ)
     ≈⟨ ≪* trans-join-coeffs-hom i≤j-1 j≤n xs Ρ′ ⟩
@@ -156,15 +156,15 @@ mutual
         ys′ = ⅀⟦ ys ⟧ (drop-1 (≤′-step j≤i-1 ⟨ ≤′-trans ⟩ i≤n) Ρ′)
     in
     begin
-      ⟦ poly-map ( (⊠-⅀-inj (wf _ i≤n) j≤i-1 ys)) xs ⊐↓ i≤n ⟧ Ρ′
-    ≈⟨ ⊐↓-hom (poly-map ( (⊠-⅀-inj (wf _ i≤n) j≤i-1 ys)) xs) i≤n Ρ′ ⟩
-      ⅀?⟦ poly-map ( (⊠-⅀-inj (wf _ i≤n) j≤i-1 ys)) xs ⟧ (ρ , Ρ)
-    ≈⟨ poly-mapR ρ Ρ (⊠-⅀-inj (wf _ i≤n) j≤i-1 ys)
+      ⟦ poly-map ( (⊠-⅀-inj (wf i≤n) j≤i-1 ys)) xs ⊐↓ i≤n ⟧ Ρ′
+    ≈⟨ ⊐↓-hom (poly-map ( (⊠-⅀-inj (wf i≤n) j≤i-1 ys)) xs) i≤n Ρ′ ⟩
+      ⅀?⟦ poly-map ( (⊠-⅀-inj (wf i≤n) j≤i-1 ys)) xs ⟧ (ρ , Ρ)
+    ≈⟨ poly-mapR ρ Ρ (⊠-⅀-inj (wf i≤n) j≤i-1 ys)
                      (_ *_)
                      (*-cong refl)
                      reassoc
                      (distribˡ _)
-                     (λ x → ⊠-⅀-inj-hom (wf _ i≤n) j≤i-1 ys x _)
+                     (λ x → ⊠-⅀-inj-hom (wf i≤n) j≤i-1 ys x _)
                      (zeroʳ _) xs ⟩
       ⅀⟦ ys ⟧ (drop-1 j≤i-1 Ρ) * ⅀⟦ xs ⟧ (ρ , Ρ)
     ≈⟨ ≪* trans-join-coeffs-hom j≤i-1 i≤n ys Ρ′ ⟩
@@ -174,10 +174,10 @@ mutual
     ∎
   ⊠-match-hom (acc wf) (inj-eq ij≤n) xs ys Ρ =
     begin
-      ⟦ ⊠-coeffs (wf _ ij≤n) xs ys ⊐↓ ij≤n ⟧ Ρ
-    ≈⟨ ⊐↓-hom (⊠-coeffs (wf _ ij≤n) xs ys) ij≤n Ρ ⟩
-      ⅀?⟦ ⊠-coeffs (wf _ ij≤n) xs ys ⟧ (drop-1 ij≤n Ρ)
-    ≈⟨ ⊠-coeffs-hom (wf _ ij≤n) xs ys (drop-1 ij≤n Ρ) ⟩
+      ⟦ ⊠-coeffs (wf ij≤n) xs ys ⊐↓ ij≤n ⟧ Ρ
+    ≈⟨ ⊐↓-hom (⊠-coeffs (wf ij≤n) xs ys) ij≤n Ρ ⟩
+      ⅀?⟦ ⊠-coeffs (wf ij≤n) xs ys ⟧ (drop-1 ij≤n Ρ)
+    ≈⟨ ⊠-coeffs-hom (wf ij≤n) xs ys (drop-1 ij≤n Ρ) ⟩
       ⅀⟦ xs ⟧ (drop-1 ij≤n Ρ) * ⅀⟦ ys ⟧ (drop-1 ij≤n Ρ)
     ∎
 
diff --git a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Negation.agda b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Negation.agda
index ebef6fc39e..9f6aac7e58 100644
--- a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Negation.agda
+++ b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Negation.agda
@@ -13,12 +13,12 @@ module Tactic.RingSolver.Core.Polynomial.Homomorphism.Negation
   (homo : Homomorphism r₁ r₂ r₃ r₄)
   where
 
-open import Data.Product          using (_,_)
-open import Data.Vec              using (Vec)
-open import Data.Nat              using (_<′_)
+open import Data.Vec.Base         using (Vec)
+open import Data.Product.Base     using (_,_)
+open import Data.Nat.Base         using (_<′_)
 open import Data.Nat.Induction
 
-open import Function
+open import Function.Base using (_⟨_⟩_; flip)
 
 open Homomorphism homo
 open import Tactic.RingSolver.Core.Polynomial.Homomorphism.Lemmas homo
@@ -42,10 +42,10 @@ open import Tactic.RingSolver.Core.Polynomial.Semantics homo
         ∎
   in
   begin
-    ⟦ poly-map (⊟-step (wf _ i≤n)) xs ⊐↓ i≤n ⟧ ρ′
-  ≈⟨ ⊐↓-hom (poly-map (⊟-step (wf _ i≤n)) xs) i≤n ρ′ ⟩
-    ⅀?⟦ poly-map (⊟-step  (wf _ i≤n)) xs ⟧ (ρ , ρs)
-  ≈⟨ poly-mapR ρ ρs (⊟-step (wf _ i≤n)) -_ (-‿cong) (λ x y → *-comm x (- y) ⟨ trans ⟩ -‿*-distribˡ y x ⟨ trans ⟩ -‿cong (*-comm _ _)) (λ x y → sym (-‿+-comm x y)) (flip (⊟-step-hom (wf _ i≤n)) ρs) (sym neg-zero ) xs ⟩
+    ⟦ poly-map (⊟-step (wf i≤n)) xs ⊐↓ i≤n ⟧ ρ′
+  ≈⟨ ⊐↓-hom (poly-map (⊟-step (wf i≤n)) xs) i≤n ρ′ ⟩
+    ⅀?⟦ poly-map (⊟-step  (wf i≤n)) xs ⟧ (ρ , ρs)
+  ≈⟨ poly-mapR ρ ρs (⊟-step (wf i≤n)) -_ (-‿cong) (λ x y → *-comm x (- y) ⟨ trans ⟩ -‿*-distribˡ y x ⟨ trans ⟩ -‿cong (*-comm _ _)) (λ x y → sym (-‿+-comm x y)) (flip (⊟-step-hom (wf i≤n)) ρs) (sym neg-zero ) xs ⟩
     - ⅀⟦ xs ⟧ (ρ , ρs)
   ∎
 
diff --git a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Variables.agda b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Variables.agda
index c3884e9e2a..553f761768 100644
--- a/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Variables.agda
+++ b/src/Tactic/RingSolver/Core/Polynomial/Homomorphism/Variables.agda
@@ -13,9 +13,9 @@ module Tactic.RingSolver.Core.Polynomial.Homomorphism.Variables
   (homo : Homomorphism r₁ r₂ r₃ r₄)
   where
 
-open import Data.Product         using (_,_)
+open import Data.Product.Base    using (_,_)
 open import Data.Vec.Base as Vec using (Vec)
-open import Data.Fin             using (Fin)
+open import Data.Fin.Base        using (Fin)
 open import Data.List.Kleene
 
 open Homomorphism homo
diff --git a/src/Tactic/RingSolver/Core/Polynomial/Parameters.agda b/src/Tactic/RingSolver/Core/Polynomial/Parameters.agda
index a622ffb49c..c7777160a8 100644
--- a/src/Tactic/RingSolver/Core/Polynomial/Parameters.agda
+++ b/src/Tactic/RingSolver/Core/Polynomial/Parameters.agda
@@ -13,7 +13,6 @@ module Tactic.RingSolver.Core.Polynomial.Parameters where
 
 open import Algebra.Bundles using (RawRing)
 open import Data.Bool.Base using (Bool; T)
-open import Function
 open import Level
 open import Relation.Unary
 open import Tactic.RingSolver.Core.AlmostCommutativeRing
diff --git a/src/Tactic/RingSolver/Core/Polynomial/Semantics.agda b/src/Tactic/RingSolver/Core/Polynomial/Semantics.agda
index 648563112d..c73a8ac587 100644
--- a/src/Tactic/RingSolver/Core/Polynomial/Semantics.agda
+++ b/src/Tactic/RingSolver/Core/Polynomial/Semantics.agda
@@ -13,11 +13,11 @@ module Tactic.RingSolver.Core.Polynomial.Semantics
   (homo : Homomorphism r₁ r₂ r₃ r₄)
   where
 
-open import Data.Nat     using (ℕ; suc; zero; _≤′_; ≤′-step; ≤′-refl)
-open import Data.Vec     using (Vec; []; _∷_; uncons)
-open import Data.List    using ([]; _∷_)
-open import Data.Product using (_,_; _×_)
-open import Data.List.Kleene using (_+; _*; ∹_; _&_; [])
+open import Data.Nat.Base     using (ℕ; suc; zero; _≤′_; ≤′-step; ≤′-refl)
+open import Data.Vec.Base     using (Vec; []; _∷_; uncons)
+open import Data.List.Base    using ([]; _∷_)
+open import Data.Product.Base using (_,_; _×_)
+open import Data.List.Kleene  using (_+; _*; ∹_; _&_; [])
 
 open Homomorphism homo hiding (_^_)
 open import Tactic.RingSolver.Core.Polynomial.Base from
@@ -36,13 +36,14 @@ x *⟨ ρ ⟩^ zero = x
 x *⟨ ρ ⟩^ suc i = ρ ^ (suc i) * x
 {-# INLINE _*⟨_⟩^_ #-}
 
---------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Evaluation
---------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Why do we have three functions here? Why are they so weird looking?
 --
--- These three functions are the main bottleneck for all of the proofs: as such,
--- slight changes can dramatically affect the length of proof code.
+-- These three functions are the main bottleneck for all of the proofs:
+-- as such, slight changes can dramatically affect the length of proof
+-- code.
 
 mutual
 
@@ -59,13 +60,13 @@ mutual
   ⟦ ⅀ xs ⊐ i≤n ⟧ Ρ = ⅀⟦ xs ⟧ (drop-1 i≤n Ρ)
   {-# INLINE ⟦_⟧ #-}
 
---------------------------------------------------------------------------------
+------------------------------------------------------------------------
 -- Performance
---------------------------------------------------------------------------------
--- As you might imagine, the implementation of the functions above seriously
--- affect performance. What you might not realise, though, is that the most
--- important component is the *order of the arguments*. For instance, if
--- we change:
+------------------------------------------------------------------------
+-- As you might imagine, the implementation of the functions above
+-- seriously affect performance. What you might not realise, though,
+-- is that the most important component is the *order of the arguments*.
+-- For instance, if we change:
 --
 --   (x , xs) ⟦∷⟧ (ρ , ρs) = ρ * ⅀⟦ xs ⟧ (ρ , ρs) + ⟦ x ⟧ ρs
 --
diff --git a/src/Tactic/RingSolver/NonReflective.agda b/src/Tactic/RingSolver/NonReflective.agda
index 1c65a6c1bb..cc0b747037 100644
--- a/src/Tactic/RingSolver/NonReflective.agda
+++ b/src/Tactic/RingSolver/NonReflective.agda
@@ -18,13 +18,13 @@ module Tactic.RingSolver.NonReflective
   where
 
 open import Algebra.Morphism
-open import Function
+open import Function.Base using (id; _⟨_⟩_)
 open import Data.Bool.Base using (Bool; true; false; T; if_then_else_)
 open import Data.Maybe.Base
 open import Data.Empty using (⊥-elim)
 open import Data.Nat.Base using (ℕ)
-open import Data.Product
-open import Data.Vec hiding (_⊛_)
+open import Data.Product.Base using (_×_; proj₁; proj₂; _,_)
+open import Data.Vec.Base using (Vec)
 open import Data.Vec.N-ary
 
 open import Tactic.RingSolver.Core.Polynomial.Parameters
diff --git a/src/Test/Golden.agda b/src/Test/Golden.agda
index 81f9f2af1a..7e592a3ff2 100644
--- a/src/Test/Golden.agda
+++ b/src/Test/Golden.agda
@@ -56,7 +56,7 @@
 --
 -- We provide an options parser (`options`) that takes the list of command line
 -- arguments and constructs this for you.
----
+--
 
 ------------------------------------------------------------------------
 -- Usage
@@ -88,15 +88,16 @@ open import Data.List.Relation.Binary.Infix.Heterogeneous.Properties using (infi
 open import Data.List.Relation.Unary.Any using (any?)
 open import Data.Maybe.Base using (Maybe; just; nothing; fromMaybe)
 open import Data.Nat.Base using (ℕ; _≡ᵇ_; _<ᵇ_; _+_; _∸_)
-import Data.Nat.Show as ℕ
-open import Data.Product using (_×_; _,_)
-open import Data.String as String using (String; lines; unlines; unwords; concat; _≟_)
+import Data.Nat.Show as ℕ using (show)
+open import Data.Product.Base using (_×_; _,_)
+open import Data.String.Base as String using (String; lines; unlines; unwords; concat)
+open import Data.String.Properties as String using (_≟_)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 open import Data.Unit.Base using (⊤)
 
 open import Function.Base using (id; _$_; case_of_)
 
-open import Relation.Nullary.Decidable using (does)
+open import Relation.Nullary.Decidable.Core using (does)
 
 open import Codata.Musical.Notation using (♯_)
 open import IO
diff --git a/src/Text/Format.agda b/src/Text/Format.agda
index b597c419cf..ffa6501b27 100644
--- a/src/Text/Format.agda
+++ b/src/Text/Format.agda
@@ -12,11 +12,11 @@ open import Data.Maybe.Base
 open import Text.Format.Generic
 
 -- Formatted types
-open import Data.Char.Base
-open import Data.Integer.Base
-open import Data.Float
-open import Data.Nat.Base
-open import Data.String.Base
+open import Data.Char.Base using (Char)
+open import Data.Integer.Base using (ℤ)
+open import Data.Float.Base using (Float)
+open import Data.Nat.Base using (ℕ)
+open import Data.String.Base using (String)
 
 ------------------------------------------------------------------------
 -- Basic types
diff --git a/src/Text/Format/Generic.agda b/src/Text/Format/Generic.agda
index d0fe551041..9969801832 100644
--- a/src/Text/Format/Generic.agda
+++ b/src/Text/Format/Generic.agda
@@ -14,7 +14,7 @@ open import Data.Char.Base using (Char)
 open import Data.List.Base as List
 open import Data.Maybe.Base as Maybe
 open import Data.Nat.Base
-open import Data.Product
+open import Data.Product.Base using (_,_)
 open import Data.Product.Nary.NonDependent
 open import Data.Sum.Base
 open import Data.String.Base
@@ -49,7 +49,7 @@ module Format (spec : FormatSpec) where
 
   open FormatSpec spec
 
-  ------------------------------------------------------------------------
+  ----------------------------------------------------------------------
   -- Basic types
 
   data Chunk : Set where
@@ -59,7 +59,7 @@ module Format (spec : FormatSpec) where
   Format : Set
   Format = List Chunk
 
-  ------------------------------------------------------------------------
+  ----------------------------------------------------------------------
   -- Semantics
 
   size : Format → ℕ
@@ -72,11 +72,11 @@ module Format (spec : FormatSpec) where
   ⟦ Arg a  ∷ cs ⟧ = ArgType a , ⟦ cs ⟧
   ⟦ Raw _  ∷ cs ⟧ =             ⟦ cs ⟧
 
-  ------------------------------------------------------------------------
+  ----------------------------------------------------------------------
   -- Lexer: from Strings to Formats
 
-  -- Lexing may fail. To have a useful error message, we defined the following
-  -- enumerated type
+  -- Lexing may fail. To have a useful error message, we defined the
+  -- following enumerated type
 
   data Error : Set where
     UnexpectedEndOfString : String → Error
diff --git a/src/Text/Pretty.agda b/src/Text/Pretty.agda
index 08c60701bf..a9202b1f82 100644
--- a/src/Text/Pretty.agda
+++ b/src/Text/Pretty.agda
@@ -13,21 +13,21 @@ open import Data.Nat.Base using (ℕ)
 module Text.Pretty (width : ℕ) where
 
 import Level
-open import Data.Char.Base     using (Char)
+open import Data.Char.Base using (Char)
 open import Data.List.Base
   using (List; _∷_; []; [_]; uncons; _++_; map; filter)
 open import Data.List.NonEmpty as List⁺ using (foldr₁)
-open import Data.Maybe.Base    using (maybe′)
-open import Data.Product       using (uncurry)
-open import Data.String.Base   using (String; fromList; replicate)
-open import Function.Base
+open import Data.Maybe.Base using (maybe′)
+open import Data.Product.Base using (uncurry)
+open import Data.String.Base using (String; fromList; replicate)
+open import Function.Base using (_∘_; _∘′_; _$_)
 
 open import Effect.Monad using (RawMonad)
-import Data.List.Effectful as Cat
-open RawMonad (Cat.monad {Level.zero})
+import Data.List.Effectful as List
+open RawMonad (List.monad {Level.zero})
 
-import Data.Nat.Properties as ℕₚ
-open import Data.List.Extrema.Core ℕₚ.≤-totalOrder using (⊓ᴸ)
+import Data.Nat.Properties as ℕ
+open import Data.List.Extrema.Core ℕ.≤-totalOrder using (⊓ᴸ)
 
 ------------------------------------------------------------------------
 -- Internal representation of documents and rendering function
diff --git a/src/Text/Pretty/Core.agda b/src/Text/Pretty/Core.agda
index f546bc5962..6883054ae8 100644
--- a/src/Text/Pretty/Core.agda
+++ b/src/Text/Pretty/Core.agda
@@ -16,37 +16,42 @@ open import Data.Bool.Base using (Bool)
 open import Data.Irrelevant as Irrelevant using (Irrelevant) hiding (module Irrelevant)
 open import Data.List.Base as List   using (List; []; _∷_)
 open import Data.Nat.Base            using (ℕ; zero; suc; _+_; _⊔_; _≤_; z≤n)
-open import Data.Nat.Properties
-open import Data.Product as Prod using (_×_; _,_; uncurry; proj₁; proj₂)
+open import Data.Nat.Properties      using (≤-refl; ≤-trans; +-identityʳ;
+  module ≤-Reasoning; m≤n⊔m; +-monoʳ-≤; m≤m⊔n; +-comm; _≤?_)
+open import Data.Product.Base as Prod using (_×_; _,_; uncurry; proj₁; proj₂)
 import Data.Product.Relation.Unary.All as Allᴾ
 
 open import Data.Tree.Binary as Tree using (Tree; leaf; node; #nodes; mapₙ)
 open import Data.Tree.Binary.Relation.Unary.All as Allᵀ using (leaf; node)
-open import Data.Unit using (⊤; tt)
-import Data.Tree.Binary.Relation.Unary.All.Properties as Allᵀₚ
-import Data.Tree.Binary.Properties as Treeₚ
+open import Data.Unit.Base using (⊤; tt)
+import Data.Tree.Binary.Relation.Unary.All.Properties as Allᵀ
+import Data.Tree.Binary.Properties as Tree
 
 open import Data.Maybe.Base as Maybe using (Maybe; nothing; just; maybe′)
 open import Data.Maybe.Relation.Unary.All as Allᴹ using (nothing; just)
 
 open import Data.String.Base as String
   using (String; length; replicate; _++_; unlines)
-open import Data.String.Unsafe as Stringₚ
-open import Function.Base
-open import Relation.Nullary.Decidable using (Dec)
+import Data.String.Unsafe as String
+open import Function.Base using (_∘_; flip; _on_; id; _∘′_; _$_)
+open import Relation.Nullary.Decidable.Core using (Dec)
 open import Relation.Unary using (IUniversal; _⇒_; U)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core
+  using (_≡_; refl; sym; cong; cong₂; subst)
+open import Relation.Binary.PropositionalEquality.Properties
+  using (module ≡-Reasoning)
 
-open import Data.Refinement hiding (map)
+open import Data.Refinement using (Refinement-syntax; _,_; value; proof)
 import Data.Refinement.Relation.Unary.All as Allᴿ
 
 ------------------------------------------------------------------------
 -- Block of text
 
--- Content is a representation of the first line and the middle of the block.
--- We use a tree rather than a list for the middle of the block so that we can
--- extend it with lines on the left and on the line for free. We will ultimately
--- render the block by traversing the tree left to right in a depth-first manner.
+-- Content is a representation of the first line and the middle of the
+-- block. We use a tree rather than a list for the middle of the block
+-- so that we can extend it with lines on the left and on the line for
+-- free. We will ultimately render the block by traversing the tree left
+-- to right in a depth-first manner.
 
 Content : Set
 Content = Maybe (String × Tree String ⊤)
@@ -140,13 +145,13 @@ private
 
     pad : Maybe String
     pad with x.lastWidth
-    ... | 0 = nothing
-    ... | l = just (replicate l ' ')
+    ... | 0         = nothing
+    ... | l@(suc _) = just (replicate l ' ')
 
     size-pad : maybe′ length 0 pad ≡ x.lastWidth
     size-pad with x.lastWidth
     ... | 0         = refl
-    ... | l@(suc _) = length-replicate l
+    ... | l@(suc _) = String.length-replicate l
 
     indent : Maybe String → String → String
     indent = maybe′ _++_ id
@@ -154,17 +159,17 @@ private
     size-indent : ∀ ma str → length (indent ma str)
                 ≡ maybe′ length 0 ma + length str
     size-indent nothing    str = refl
-    size-indent (just pad) str = length-++ pad str
+    size-indent (just pad) str = String.length-++ pad str
 
     indents : Maybe String → Tree String ⊤ → Tree String ⊤
     indents = maybe′ (mapₙ ∘ _++_) id
 
     size-indents : ∀ ma t → #nodes (indents ma t) ≡ #nodes t
     size-indents nothing    t = refl
-    size-indents (just pad) t = Treeₚ.#nodes-mapₙ (pad ++_) t
+    size-indents (just pad) t = Tree.#nodes-mapₙ (pad ++_) t
 
     unfold-indents : ∀ ma t → indents ma t ≡ mapₙ (indent ma) t
-    unfold-indents nothing    t = sym (Treeₚ.map-id t)
+    unfold-indents nothing    t = sym (Tree.map-id t)
     unfold-indents (just pad) t = refl
 
     vContent : Content × String
@@ -189,7 +194,7 @@ private
     isBlock ∣x∣ ∣y∣ with blocky
     ... | nothing        = begin
       size blockx         ≡⟨ ∣x∣ ⟩
-      x.height            ≡˘⟨ +-identityʳ x.height ⟩
+      x.height            ≡⟨ +-identityʳ x.height ⟨
       x.height + 0        ≡⟨ cong (_ +_) ∣y∣ ⟩
       x.height + y.height ∎ where open ≡-Reasoning
     ... | just (hd , tl) = begin
@@ -215,7 +220,7 @@ private
                  length vLast ≡ lastWidth
     isLastLine ∣x∣ ∣y∣ with blocky
     ... | nothing        = begin
-      length (lastx ++ lasty)       ≡⟨ length-++ lastx lasty ⟩
+      length (lastx ++ lasty)       ≡⟨ String.length-++ lastx lasty ⟩
       length lastx + length lasty   ≡⟨ cong₂ _+_ ∣x∣ ∣y∣ ⟩
       x.lastWidth + y.lastWidth     ∎ where open ≡-Reasoning
     ... | just (hd , tl) = begin
@@ -249,12 +254,12 @@ private
       All≤-node? (≤-Content (m≤m⊔n _ _) ∣xs∣)
                  middle
                  (subst (Allᵀ.All _ U) (sym $ unfold-indents pad tl)
-                 $ Allᵀₚ.mapₙ⁺ (indent pad) (Allᵀ.mapₙ (indented _) ∣tl∣))
+                 $ Allᵀ.mapₙ⁺ (indent pad) (Allᵀ.mapₙ (indented _) ∣tl∣))
       where
 
       middle : length (lastx ++ hd) ≤ vMaxWidth
       middle = begin
-        length (lastx ++ hd)     ≡⟨ length-++ lastx hd ⟩
+        length (lastx ++ hd)     ≡⟨ String.length-++ lastx hd ⟩
         length lastx + length hd ≡⟨ cong (_+ _) ∣x∣≡ ⟩
         x.lastWidth + length hd  ≤⟨ +-monoʳ-≤ x.lastWidth ∣hd∣ ⟩
         x.lastWidth + widthy     ≤⟨ m≤n⊔m _ _ ⟩
diff --git a/src/Text/Printf.agda b/src/Text/Printf.agda
index 7397f908f0..caa59b8a8c 100644
--- a/src/Text/Printf.agda
+++ b/src/Text/Printf.agda
@@ -8,30 +8,20 @@
 
 module Text.Printf where
 
-open import Level using (0ℓ; Lift)
-open import Data.List.Base as List using (List; []; _∷_)
-open import Data.Nat.Base using (ℕ)
-open import Data.Product
-open import Data.Product.Nary.NonDependent
-open import Data.String.Base
-open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
-open import Data.Unit using (⊤)
-open import Function.Nary.NonDependent
-open import Function
-open import Function.Strict
-
-import Data.Char.Base    as Cₛ
-import Data.Integer.Show as ℤₛ
-import Data.Float        as Fₛ
-import Data.Nat.Show     as ℕₛ
+open import Data.String.Base using (String; fromChar; concat)
+open import Function.Base using (id)
+
+import Data.Integer.Show as ℤ
+import Data.Float.Base   as Float
+import Data.Nat.Show     as ℕ
 
 open import Text.Format as Format hiding (Error)
 open import Text.Printf.Generic
 
 printfSpec : PrintfSpec formatSpec String
-printfSpec .PrintfSpec.renderArg ℕArg      = ℕₛ.show
-printfSpec .PrintfSpec.renderArg ℤArg      = ℤₛ.show
-printfSpec .PrintfSpec.renderArg FloatArg  = Fₛ.show
+printfSpec .PrintfSpec.renderArg ℕArg      = ℕ.show
+printfSpec .PrintfSpec.renderArg ℤArg      = ℤ.show
+printfSpec .PrintfSpec.renderArg FloatArg  = Float.show
 printfSpec .PrintfSpec.renderArg CharArg   = fromChar
 printfSpec .PrintfSpec.renderArg StringArg = id
 printfSpec .PrintfSpec.renderStr           = id
diff --git a/src/Text/Printf/Generic.agda b/src/Text/Printf/Generic.agda
index 6272351756..21aa36133a 100644
--- a/src/Text/Printf/Generic.agda
+++ b/src/Text/Printf/Generic.agda
@@ -13,9 +13,9 @@ open import Data.List.Base as List using (List; []; _∷_)
 open import Data.Char.Base
 open import Data.Maybe.Base hiding (map)
 open import Data.Nat.Base using (ℕ)
-open import Data.Product hiding (map)
+open import Data.Product.Base hiding (map)
 open import Data.Product.Nary.NonDependent
-open import Data.String.Base
+open import Data.String.Base using (String)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 open import Data.Unit.Base using (⊤)
 open import Function.Nary.NonDependent
diff --git a/src/Text/Regex.agda b/src/Text/Regex.agda
index b6454f36ae..9b818d15b5 100644
--- a/src/Text/Regex.agda
+++ b/src/Text/Regex.agda
@@ -10,7 +10,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (DecPoset)
+open import Relation.Binary.Bundles using (DecPoset)
 
 module Text.Regex {a e r} (decPoset : DecPoset a e r) where
 
diff --git a/src/Text/Regex/Base.agda b/src/Text/Regex/Base.agda
index 7fe7d56cbf..e5cc2c24a4 100644
--- a/src/Text/Regex/Base.agda
+++ b/src/Text/Regex/Base.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Preorder)
+open import Relation.Binary.Bundles using (Preorder)
 
 module Text.Regex.Base {a e r} (P : Preorder a e r) where
 
@@ -16,12 +16,9 @@ open import Data.Bool.Base using (Bool)
 open import Data.List.Base as L using (List; []; _∷_)
 open import Data.List.Relation.Unary.Any using (Any)
 open import Data.List.Relation.Unary.All using (All)
-open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
+open import Data.Sum.Base using (_⊎_)
 
-open import Relation.Nullary.Negation using (¬_)
-open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Unary using (Pred)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Nullary.Negation.Core using (¬_)
 
 open Preorder P using (_≈_) renaming (Carrier to A; _∼_ to _≤_)
 open import Data.List.Relation.Ternary.Appending.Propositional {A = A}
diff --git a/src/Text/Regex/Derivative/Brzozowski.agda b/src/Text/Regex/Derivative/Brzozowski.agda
index ca3768296b..178986eb65 100644
--- a/src/Text/Regex/Derivative/Brzozowski.agda
+++ b/src/Text/Regex/Derivative/Brzozowski.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (DecPoset)
+open import Relation.Binary.Bundles using (DecPoset)
 
 module Text.Regex.Derivative.Brzozowski {a e r} (P? : DecPoset a e r) where
 
@@ -18,8 +18,8 @@ open import Function.Base using (_$_; _∘′_; case_of_)
 open import Relation.Nullary.Decidable using (Dec; yes; no)
 open import Relation.Nullary.Negation using (contradiction)
 open import Relation.Nullary.Decidable using (map′; ¬?)
-open import Relation.Binary using (Decidable)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong)
+open import Relation.Binary.Definitions using (Decidable)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
 
 open DecPoset P? using (preorder) renaming (Carrier to A)
 open import Text.Regex.Base preorder as R hiding (_∣_; _∙_; _⋆)
@@ -107,6 +107,8 @@ eat-complete′ x (e R.⋆) (refl ∷ eq) (star (sum (inj₂ (prod (refl ∷ app
 ------------------------------------------------------------------------
 -- Consequence: matching is decidable
 
+infix 4 _∈?_ _∉?_
+
 _∈?_ : Decidable _∈_
 []       ∈? e = []∈? e
 (x ∷ xs) ∈? e = map′ (eat-sound x e) (eat-complete x e) (xs ∈? eat x e)
diff --git a/src/Text/Regex/Properties.agda b/src/Text/Regex/Properties.agda
index 2652f9c8cf..6b24e0aa16 100644
--- a/src/Text/Regex/Properties.agda
+++ b/src/Text/Regex/Properties.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (DecPoset)
+open import Relation.Binary.Bundles using (DecPoset)
 
 module Text.Regex.Properties {a e r} (P? : DecPoset a e r) where
 
@@ -23,13 +23,11 @@ open import Relation.Nullary.Negation
   using (¬_; contradiction)
 
 import Relation.Unary  as U
-open import Relation.Binary using (Decidable)
-import Relation.Binary.PropositionalEquality as P
+open import Relation.Binary.Definitions using (Decidable)
 
 open DecPoset P? renaming (Carrier to A)
 open import Text.Regex.Base preorder
-
-open import Data.List.Relation.Binary.Pointwise using ([])
+open import Data.List.Relation.Binary.Pointwise.Base using ([])
 open import Data.List.Relation.Ternary.Appending.Propositional {A = A}
 open import Data.List.Relation.Ternary.Appending.Propositional.Properties {A = A}
 
@@ -51,6 +49,8 @@ open import Text.Regex.Properties.Core preorder public
              $ ([]∈? e) ×-dec ([]∈? f)
 []∈? (e ⋆)   = yes (star (sum (inj₁ ε)))
 
+infix 4 _∈ᴿ?_ _∉ᴿ?_ _∈?ε _∈?[_] _∈?[^_]
+
 _∈ᴿ?_ : Decidable _∈ᴿ_
 c ∈ᴿ? [ a ]     = map′ [_] (λ where [ eq ] → eq) (c ≟ a)
 c ∈ᴿ? (lb ─ ub) = map′ (uncurry _─_) (λ where (ge ─ le) → ge , le)
diff --git a/src/Text/Regex/Properties/Core.agda b/src/Text/Regex/Properties/Core.agda
index 64faba7029..40e1cdf15b 100644
--- a/src/Text/Regex/Properties/Core.agda
+++ b/src/Text/Regex/Properties/Core.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Preorder)
+open import Relation.Binary.Bundles using (Preorder)
 
 module Text.Regex.Properties.Core {a e r} (P : Preorder a e r) where
 
@@ -17,19 +17,19 @@ open import Data.List.Base as List using (List; []; _∷_; _++_)
 
 open import Data.List.Relation.Unary.Any using (Any; here; there)
 open import Data.List.Relation.Unary.All using (All; []; _∷_)
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Data.Sum.Base using (_⊎_; inj₁; inj₂)
 
 open import Relation.Nullary using (¬_; Dec; yes; no)
 open import Relation.Nullary.Negation using (contradiction)
 open import Relation.Unary using (Pred)
-open import Relation.Binary.PropositionalEquality
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl)
 
 open Preorder P using (_≈_) renaming (Carrier to A; _∼_ to _≤_)
 open import Text.Regex.Base P
 
-open import Data.List.Relation.Ternary.Appending.Propositional {A = A}
 open import Data.List.Relation.Ternary.Appending.Propositional.Properties {A = A}
+  using (++[]⁻¹; []++⁻¹; conicalˡ; conicalʳ)
 
 ------------------------------------------------------------------------
 -- Views
diff --git a/src/Text/Regex/Search.agda b/src/Text/Regex/Search.agda
index af10c2784a..efa1f74684 100644
--- a/src/Text/Regex/Search.agda
+++ b/src/Text/Regex/Search.agda
@@ -6,7 +6,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (DecPoset)
+open import Relation.Binary.Bundles using (DecPoset)
 
 module Text.Regex.Search {a e r} (P? : DecPoset a e r) where
 
@@ -29,8 +29,9 @@ open import Data.List.Relation.Binary.Suffix.Heterogeneous
 open import Relation.Nullary using (Dec; ¬_; yes; no)
 open import Relation.Nullary.Decidable using (map′)
 open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Binary using (Rel; Decidable; _⇒_)
-open import Relation.Binary.PropositionalEquality hiding (preorder)
+open import Relation.Binary.Core using (Rel; _⇒_)
+open import Relation.Binary.Definitions using (Decidable)
+open import Relation.Binary.PropositionalEquality.Core
 
 open DecPoset P? using (preorder) renaming (Carrier to A)
 open import Text.Regex.Base preorder
@@ -40,9 +41,9 @@ open import Text.Regex.Derivative.Brzozowski P?
 ------------------------------------------------------------------------
 -- Type corresponding to a match
 
--- Users have control over whether the match should start at the beginning
--- or stop at the end. So we have a precise type of spans ensuring their
--- demands are respected
+-- Users have control over whether the match should start at the
+-- beginning or stop at the end. So we have a precise type of spans
+-- ensuring their demands are respected
 Span : ∀ {r} → Regex → Rel A r → Rel (List A) (a ⊔ r)
 Span regex =
   if Regex.fromStart regex
@@ -87,6 +88,8 @@ module Prefix where
   []⁻¹ᴹ : ∀ {e} → Match (Prefix _≡_) [] e → [] ∈ e
   []⁻¹ᴹ (mkMatch .[] p []) = p
 
+  infixr 5 _∷ᴹ_ _∷⁻¹ᴹ_
+
   _∷ᴹ_ : ∀ {xs e} x → Match (Prefix _≡_) xs (eat x e) → Match (Prefix _≡_) (x ∷ xs) e
   x ∷ᴹ (mkMatch ys ys∈e\x ys≤xs) = mkMatch (x ∷ ys) (eat-sound x _ ys∈e\x) (refl ∷ ys≤xs)
 
@@ -141,8 +144,8 @@ module Infix where
   step⁻¹ {e} {acc} x []∉e []∉acc (inj₂ (mkMatch (.x ∷ ys) ys∈e (refl ∷ p)))
     = inj₂ (mkMatch ys (eat-complete x (acc ∣ e) (sum (inj₁ ys∈e))) p)
 
-  -- search non-deterministically: at each step, the `acc` regex is changed
-  -- to accomodate the fact the match may be starting just now
+  -- search non-deterministically: at each step, the `acc` regex is
+  -- changed to accomodate the fact the match may be starting just now
   searchND : ∀ xs e acc → [] ∉ e → Dec (Match (Infix _≡_) xs e ⊎ Match (Prefix _≡_) xs acc)
   searchND xs e acc []∉e with []∈? acc
   ... | yes []∈acc with Prefix.longest xs acc -- get the best match possible
diff --git a/src/Text/Regex/SmartConstructors.agda b/src/Text/Regex/SmartConstructors.agda
index eecda1284f..3269d22da5 100644
--- a/src/Text/Regex/SmartConstructors.agda
+++ b/src/Text/Regex/SmartConstructors.agda
@@ -9,7 +9,7 @@
 
 {-# OPTIONS --cubical-compatible --safe #-}
 
-open import Relation.Binary using (Preorder)
+open import Relation.Binary.Bundles using (Preorder)
 
 module Text.Regex.SmartConstructors {a e r} (P : Preorder a e r) where
 
@@ -19,7 +19,7 @@ open import Data.Sum.Base using (inj₁; inj₂; fromInj₁; fromInj₂)
 
 open import Relation.Nullary.Decidable using (yes; no)
 open import Relation.Nullary.Negation using (contradiction)
-open import Relation.Binary.PropositionalEquality using (refl)
+open import Relation.Binary.PropositionalEquality.Core using (refl)
 
 open import Text.Regex.Base P as R hiding (_∣_; _∙_; _⋆)
 open import Text.Regex.Properties.Core P
diff --git a/src/Text/Regex/String.agda b/src/Text/Regex/String.agda
index 911c130dc0..b526c77827 100644
--- a/src/Text/Regex/String.agda
+++ b/src/Text/Regex/String.agda
@@ -8,9 +8,9 @@
 
 module Text.Regex.String where
 
-import Data.Char.Properties as Charₚ
+import Data.Char.Properties as Char
 
 ------------------------------------------------------------------------
 -- Re-exporting definitions
 
-open import Text.Regex Charₚ.≤-decPoset public
+open import Text.Regex Char.≤-decPoset public
diff --git a/src/Text/Regex/String/Unsafe.agda b/src/Text/Regex/String/Unsafe.agda
index bc6c9fc0d7..c8c5eb7781 100644
--- a/src/Text/Regex/String/Unsafe.agda
+++ b/src/Text/Regex/String/Unsafe.agda
@@ -12,8 +12,9 @@ open import Data.String.Base using (String; toList; fromList)
 import Data.String.Unsafe as Stringₚ
 open import Function.Base using (_on_; id)
 open import Level using (0ℓ)
-open import Relation.Binary using (Rel; Decidable)
-open import Relation.Binary.PropositionalEquality using (_≡_; sym; subst)
+open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Definitions using (Decidable)
+open import Relation.Binary.PropositionalEquality.Core using (_≡_; sym; subst)
 open import Relation.Nullary.Decidable using (map′)
 
 ------------------------------------------------------------------------
@@ -25,6 +26,8 @@ open import Text.Regex.String as Regex public
 ------------------------------------------------------------------------
 -- Specialised definitions
 
+infix 4 _∈_ _∉_ _∈?_ _∉?_
+
 _∈_ : String → Exp → Set
 str ∈ e = toList str Regex.∈ e
 
diff --git a/src/Text/Tabular/List.agda b/src/Text/Tabular/List.agda
index dd06ea809a..ca8cce5b70 100644
--- a/src/Text/Tabular/List.agda
+++ b/src/Text/Tabular/List.agda
@@ -8,10 +8,10 @@
 
 module Text.Tabular.List where
 
-open import Data.String using (String)
+open import Data.String.Base using (String)
 open import Data.List.Base
-import Data.Nat.Properties as ℕₚ
-open import Data.Product using (-,_; proj₂)
+import Data.Nat.Properties as ℕ
+open import Data.Product.Base using (-,_; proj₂)
 open import Data.Vec.Base as Vec using (Vec)
 open import Data.Vec.Bounded.Base as Vec≤ using (Vec≤)
 open import Function.Base
@@ -24,7 +24,7 @@ display c a rows = Show.display c alignment rectangle
   where
   alignment : Vec Alignment _
   alignment = Vec≤.padRight Left
-            $ Vec≤.≤-cast (ℕₚ.m⊓n≤m _ _)
+            $ Vec≤.≤-cast (ℕ.m⊓n≤m _ _)
             $ Vec≤.take _ (Vec≤.fromList a)
 
   rectangle : Vec (Vec String _) _
diff --git a/src/Text/Tabular/Vec.agda b/src/Text/Tabular/Vec.agda
index 74f899905c..1286ab1e14 100644
--- a/src/Text/Tabular/Vec.agda
+++ b/src/Text/Tabular/Vec.agda
@@ -9,7 +9,7 @@
 module Text.Tabular.Vec where
 
 open import Data.List.Base using (List)
-open import Data.Product as Prod using (uncurry)
+open import Data.Product.Base as Prod using (uncurry)
 open import Data.String using (String; rectangle; fromAlignment)
 open import Data.Vec.Base
 open import Function.Base
diff --git a/stack-9.0.2.yaml b/stack-9.0.2.yaml
index 76871b383c..22f6eadaf6 100644
--- a/stack-9.0.2.yaml
+++ b/stack-9.0.2.yaml
@@ -1,10 +1,6 @@
-resolver: nightly-2022-01-27
+resolver: lts-19.33
 compiler: ghc-9.0.2
 compiler-check: match-exact
 
-# extra-deps:
-#   - filemanip-0.3.6.3
-#   - unix-compat-0.5.2
-
 packages:
 - '.'
diff --git a/stack-9.2.8.yaml b/stack-9.2.8.yaml
new file mode 100644
index 0000000000..3df1c335fb
--- /dev/null
+++ b/stack-9.2.8.yaml
@@ -0,0 +1,6 @@
+resolver: lts-20.26
+compiler: ghc-9.2.8
+compiler-check: match-exact
+
+packages:
+- '.'
diff --git a/stack-9.4.5.yaml b/stack-9.4.5.yaml
new file mode 100644
index 0000000000..790630b2e2
--- /dev/null
+++ b/stack-9.4.5.yaml
@@ -0,0 +1,6 @@
+resolver: lts-21.7
+compiler: ghc-9.4.5
+compiler-check: match-exact
+
+packages:
+- '.'
diff --git a/stack-9.6.2.yaml b/stack-9.6.2.yaml
new file mode 100644
index 0000000000..dab6c80ebf
--- /dev/null
+++ b/stack-9.6.2.yaml
@@ -0,0 +1,6 @@
+resolver: nightly-2023-08-27
+compiler: ghc-9.6.2
+compiler-check: match-exact
+
+packages:
+- '.'
diff --git a/standard-library.agda-lib b/standard-library.agda-lib
index 30ce05e7dc..ba7ae571b9 100644
--- a/standard-library.agda-lib
+++ b/standard-library.agda-lib
@@ -1,4 +1,4 @@
-name: standard-library-2.0
+name: standard-library-2.1
 include: src
 flags:
   --warning=noUnsupportedIndexedMatch
diff --git a/tests/data/appending/Main.agda b/tests/data/appending/Main.agda
index 93ece5eda0..2015b0bc9a 100644
--- a/tests/data/appending/Main.agda
+++ b/tests/data/appending/Main.agda
@@ -3,11 +3,11 @@
 module Main where
 
 
-open import Data.List using (replicate)
+open import Data.List.Base using (replicate)
 open import Data.String using (toList; fromList)
 
 open import IO
-open import Function using (_$_)
+open import Function.Base using (_$_)
 
 open import TakeWhile
 
diff --git a/tests/data/appending/TakeWhile.agda b/tests/data/appending/TakeWhile.agda
index 9030fb3c0c..50f582df27 100644
--- a/tests/data/appending/TakeWhile.agda
+++ b/tests/data/appending/TakeWhile.agda
@@ -3,11 +3,11 @@
 module TakeWhile where
 
 open import Level
-open import Data.List hiding (takeWhile)
+open import Data.List.Base hiding (takeWhile)
 open import Data.List.Relation.Unary.All as List using ([]; _∷_)
 open import Data.List.Relation.Binary.Pointwise using (Pointwise; []; _∷_; refl)
 open import Data.List.Relation.Ternary.Appending.Propositional
-open import Data.Product using (_×_; proj₁)
+open import Data.Product.Base using (_×_; proj₁)
 open import Data.Maybe.Relation.Unary.All as Maybe using (nothing; just)
 import Data.Nat
 open import Relation.Unary
diff --git a/tests/data/bytestring/Main.agda b/tests/data/bytestring/Main.agda
new file mode 100644
index 0000000000..85721598da
--- /dev/null
+++ b/tests/data/bytestring/Main.agda
@@ -0,0 +1,66 @@
+{-# OPTIONS --guardedness #-}
+
+module Main where
+
+open import Agda.Builtin.FromNat
+
+open import Data.Bytestring.Base as Bytestring
+open import Data.Bytestring.Builder.Base
+open import Data.List.Base using ([]; _∷_)
+import Data.Nat.Literals; instance numberNat = Data.Nat.Literals.number
+open import Data.Product.Base using (_×_; _,_)
+open import Data.String using (String; _++_; fromVec)
+open import Data.Unit.Base using (⊤; tt)
+import Data.Vec.Base as Vec
+open import Data.Word8.Base as Word8
+import Data.Word8.Show as Word8
+import Data.Word8.Literals; instance numberWord8 = Data.Word8.Literals.number
+open import Data.Word64.Base as Word64 using (Word64)
+import Data.Word64.Unsafe as Word64
+import Data.Word64.Show as Word64
+import Data.Word64.Literals; instance numberWord64 = Data.Word64.Literals.number
+
+open import Function.Base using (_$_)
+
+open import IO.Base
+open import IO.Finite
+
+1⋯3 : Bytestring
+1⋯3 = toBytestring
+    $ List.concat
+    $ word8 1
+    ∷ word64LE 2
+    ∷ word64BE 3
+    ∷ []
+
+1,⋯,3 : Word8 × Word64 × Word64
+1,⋯,3 = getWord8 1⋯3 0
+      , getWord64LE 1⋯3 1
+      , getWord64BE 1⋯3 9
+
+main : Main
+main = run $ do
+  let separation = fromVec (Vec.replicate 72 '-')
+  putStrLn (Bytestring.show 1⋯3)
+  putStrLn separation
+  let (one , two , three) = 1,⋯,3
+
+  let word8test : Word8 → IO _
+      word8test w = do
+        putStrLn (Word8.show w ++ " = " ++ Word8.showBits w)
+        putStrLn (Word8.show w ++ " = " ++ Word8.showHexa w)
+        putStrLn (Word8.show w ++ " = " ++ Word8.show (Word8.fromBits (Word8.toBits w)))
+
+
+  let word64test : Word64 → IO _
+      word64test w = do
+        putStrLn separation
+        putStrLn (Word64.show w ++ " = " ++ Word64.showBits w)
+        putStrLn (Word64.show w ++ " = " ++ Word64.showHexa w)
+        putStrLn (Word64.show w ++ " = " ++ Word64.show (Word64.fromBits (Word64.toBits w)))
+
+  word8test one
+  word8test (Word8.fromℕ 144)
+  word64test two
+  word64test three
+  word64test (Word64.fromℕ 2024)
diff --git a/tests/data/bytestring/bytestring.agda-lib b/tests/data/bytestring/bytestring.agda-lib
new file mode 100644
index 0000000000..325830a199
--- /dev/null
+++ b/tests/data/bytestring/bytestring.agda-lib
@@ -0,0 +1,2 @@
+name: bytestring
+include: ../../../src/ .
diff --git a/tests/data/bytestring/expected b/tests/data/bytestring/expected
new file mode 100644
index 0000000000..240520e413
--- /dev/null
+++ b/tests/data/bytestring/expected
@@ -0,0 +1,20 @@
+"\SOH\STX\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\NUL\ETX"
+------------------------------------------------------------------------
+1 = 0b00000001
+1 = 0x01
+1 = 1
+144 = 0b10010000
+144 = 0x90
+144 = 144
+------------------------------------------------------------------------
+2 = 0b0000000000000000000000000000000000000000000000000000000000000010
+2 = 0x00000002
+2 = 2
+------------------------------------------------------------------------
+3 = 0b0000000000000000000000000000000000000000000000000000000000000011
+3 = 0x00000003
+3 = 3
+------------------------------------------------------------------------
+2024 = 0b0000000000000000000000000000000000000000000000000000011111101000
+2024 = 0x000007e8
+2024 = 2024
diff --git a/tests/data/bytestring/run b/tests/data/bytestring/run
new file mode 100644
index 0000000000..f6e7c9b3c0
--- /dev/null
+++ b/tests/data/bytestring/run
@@ -0,0 +1,5 @@
+$1 --compile-dir=../../_build -c Main.agda > log
+./../../_build/Main > output
+
+rm ../../_build/Main
+rm ../../_build/MAlonzo/Code/Main*
\ No newline at end of file
diff --git a/tests/data/colist/Main.agda b/tests/data/colist/Main.agda
index a50b5b85fe..d47585dd6e 100644
--- a/tests/data/colist/Main.agda
+++ b/tests/data/colist/Main.agda
@@ -11,7 +11,7 @@ import Data.Fin.Show as Fin
 open import Data.String.Base using (String; _++_; parens)
 open import Data.Unit.Polymorphic.Base using (⊤)
 open import Codata.Sized.Thunk
-open import Function using (_$_; _∘_; id)
+open import Function.Base using (_$_; _∘_; id)
 open import Relation.Nullary
 
 open import Codata.Musical.Notation
diff --git a/tests/data/list/Main.agda b/tests/data/list/Main.agda
index f2b11de8ae..f7f12cd63d 100644
--- a/tests/data/list/Main.agda
+++ b/tests/data/list/Main.agda
@@ -3,7 +3,7 @@
 module Main where
 
 open import Level
-open import Data.List as List using (List; _∷_; []; _++_; reverse)
+open import Data.List.Base as List using (List; _∷_; []; _++_; reverse)
 open import Data.List.Zipper
 import Data.List.Sort as Sort
 open import Data.Maybe.Base
diff --git a/tests/data/trie/Main.agda b/tests/data/trie/Main.agda
index 4eab3cfd40..3ce2ad3ecb 100644
--- a/tests/data/trie/Main.agda
+++ b/tests/data/trie/Main.agda
@@ -7,18 +7,18 @@ module Main where
 open import Level
 open import Data.Unit
 open import Data.Bool
-open import Data.Char        as Char hiding (show)
-import Data.Char.Properties  as Char
-open import Data.List        as List using (List; []; _∷_)
-open import Data.List.Fresh  as List# using (List#; []; _∷#_)
-open import Data.Maybe       as Maybe
-open import Data.Product     as Prod
-open import Data.String      as String using (String; unlines; _++_)
-open import Data.These       as These
+open import Data.Char         as Char hiding (show)
+import Data.Char.Properties   as Char
+open import Data.List.Base    as List using (List; []; _∷_)
+open import Data.List.Fresh   as List# using (List#; []; _∷#_)
+open import Data.Maybe        as Maybe
+open import Data.Product      as Prod
+open import Data.String       as String using (String; unlines; _++_)
+open import Data.These        as These
 
 open import Function.Base using (case_of_; _$_; _∘′_; id; _on_)
 open import Relation.Nary
-open import Relation.Binary using (Rel)
+open import Relation.Binary.Core using (Rel)
 open import Relation.Nullary.Decidable using (¬?)
 
 open import Data.Trie Char.<-strictTotalOrder
diff --git a/tests/monad/counting/Main.agda b/tests/monad/counting/Main.agda
index e3613b4741..0660e0f224 100644
--- a/tests/monad/counting/Main.agda
+++ b/tests/monad/counting/Main.agda
@@ -4,7 +4,7 @@ module Main where
 
 open import Data.Nat.Base
 open import Data.Nat.Show using (show)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Data.String.Base using (String; _++_)
 open import IO.Base as IO using (IO; Main; run)
 open import IO.Finite using (putStrLn)
diff --git a/tests/monad/fibonacci/Main.agda b/tests/monad/fibonacci/Main.agda
index 93d7ab4e85..d1e46181bd 100644
--- a/tests/monad/fibonacci/Main.agda
+++ b/tests/monad/fibonacci/Main.agda
@@ -5,7 +5,7 @@ module Main where
 open import Data.Bool.Base using (Bool; true; false)
 open import Data.Nat.Base using (ℕ; zero; suc; _+_)
 open import Data.Nat.Show using (show)
-open import Data.Product using (_,_)
+open import Data.Product.Base using (_,_)
 open import Data.String.Base using (String; _++_)
 
 open import Data.Default
diff --git a/tests/monad/pythagorean/Main.agda b/tests/monad/pythagorean/Main.agda
index d89de60e04..97bdea2064 100644
--- a/tests/monad/pythagorean/Main.agda
+++ b/tests/monad/pythagorean/Main.agda
@@ -10,7 +10,7 @@ open import Data.Maybe.Base using (just; nothing)
 open import Data.Maybe.Effectful.Transformer
 open import Data.Nat.Base using (ℕ; zero; suc; _+_; _^_; _≡ᵇ_)
 open import Data.Nat.Show using (show)
-open import Data.Product using (_×_; _,_)
+open import Data.Product.Base using (_×_; _,_)
 open import Data.String.Base using (_++_)
 open import Function.Base using (_$_)
 
diff --git a/tests/reflection/assumption/Main.agda b/tests/reflection/assumption/Main.agda
index d7f30d3118..cf0d21b514 100644
--- a/tests/reflection/assumption/Main.agda
+++ b/tests/reflection/assumption/Main.agda
@@ -7,6 +7,7 @@ open import Data.Bool.Base using (if_then_else_)
 open import Data.List.Base using (List; []; _∷_; concatMap; map)
 open import Data.Maybe.Base using (Maybe; nothing; just)
 open import Data.Nat.Base using (ℕ; suc)
+open import Data.Product.Base using (_×_; _,_)
 open import Level using (Level)
 open import Data.Unit.Base using (⊤)
 open import Function.Base using (case_of_; _$_)
@@ -39,11 +40,11 @@ private
 -- before being compared to the type of the most local variable. The goal
 -- indeed lives below that variable's binding site!
 
-searchEntry : ℕ → Type → List Type → Maybe ℕ
+searchEntry : ℕ → Type → List (String × Arg Type) → Maybe ℕ
 searchEntry n ty [] = nothing
-searchEntry n ty (e ∷ es) = do
+searchEntry n ty ((_ , e) ∷ es) = do
   ty ← strengthen ty
-  if does (ty ≟ e)
+  if does (ty ≟ unArg e)
     then just n
     else searchEntry (suc n) ty es
 
@@ -54,8 +55,8 @@ macro
     goal ← inferType hole
     debugPrint "" 10
       (strErr "Context : "
-       ∷ concatMap (λ where (arg info ty) → strErr "\n  " ∷ termErr ty ∷ []) asss)
-    let res = searchEntry 0 goal (map unArg asss)
+       ∷ concatMap (λ where (_ , arg info ty) → strErr "\n  " ∷ termErr ty ∷ []) asss)
+    let res = searchEntry 0 goal asss
     case res of λ where
       nothing → typeError (strErr "Couldn't find an assumption of type: " ∷ termErr goal ∷ [])
       (just idx) → unify hole (var idx [])
diff --git a/tests/runtests.agda b/tests/runtests.agda
index cf9af60245..480b890d72 100644
--- a/tests/runtests.agda
+++ b/tests/runtests.agda
@@ -16,6 +16,7 @@ dataTests = mkTestPool "Data structures"
   ∷ "rational"
   ∷ "rational-unnormalised"
   ∷ "trie"
+  ∷ "bytestring"
   ∷ []
 
 systemTests : TestPool
@@ -23,6 +24,8 @@ systemTests = mkTestPool "System modules"
   $ "ansi"
   ∷ "directory"
   ∷ "environment"
+  ∷ "io"
+  ∷ "random"
   ∷ []
 
 showTests : TestPool
diff --git a/tests/system/directory/Main.agda b/tests/system/directory/Main.agda
index 0cde09f459..dabcdd433c 100644
--- a/tests/system/directory/Main.agda
+++ b/tests/system/directory/Main.agda
@@ -10,7 +10,7 @@ import Data.String.Properties as Stringₚ
 open import IO
 open import Function.Base using (_$_)
 
-open import Relation.Binary
+open import Relation.Binary.Bundles using (DecTotalOrder)
 import Relation.Binary.Construct.On as On
 
 open import System.Directory
diff --git a/tests/system/io/Main.agda b/tests/system/io/Main.agda
new file mode 100644
index 0000000000..4d2697ea27
--- /dev/null
+++ b/tests/system/io/Main.agda
@@ -0,0 +1,24 @@
+{-# OPTIONS --guardedness #-}
+
+module Main where
+
+open import Data.String.Base
+open import Function.Base using (_$_; case_of_)
+open import IO
+open import System.Exit using (exitSuccess)
+
+main : Main
+main = run $ do
+  -- Ensure no buffering so that the prompt "echo< "
+  -- gets outputed immediately
+  hSetBuffering stdout noBuffering
+  forever $ do
+    putStr "echo< "
+    -- Get a line from the user and immediately inspect it
+    -- If it's a magic "exit" keyword then we exit, otherwise
+    -- we print the echo'd message and let the `forever` action
+    -- continue
+    str ← getLine
+    case str of λ where
+      "exit" → exitSuccess
+      _ → putStrLn ("echo> " ++ str)
diff --git a/tests/system/io/expected b/tests/system/io/expected
new file mode 100644
index 0000000000..361d15957e
--- /dev/null
+++ b/tests/system/io/expected
@@ -0,0 +1,6 @@
+echo< echo> hello
+echo< echo> my
+echo< echo> name
+echo< echo> is
+echo< echo> Agda
+echo< 
\ No newline at end of file
diff --git a/tests/system/io/input b/tests/system/io/input
new file mode 100644
index 0000000000..bba046a9d5
--- /dev/null
+++ b/tests/system/io/input
@@ -0,0 +1,6 @@
+hello
+my
+name
+is
+Agda
+exit
\ No newline at end of file
diff --git a/tests/system/io/io.agda-lib b/tests/system/io/io.agda-lib
new file mode 100644
index 0000000000..74c23d5ccc
--- /dev/null
+++ b/tests/system/io/io.agda-lib
@@ -0,0 +1,2 @@
+name: io
+include: ../../../src/ .
diff --git a/tests/system/io/run b/tests/system/io/run
new file mode 100644
index 0000000000..ad42dc90b2
--- /dev/null
+++ b/tests/system/io/run
@@ -0,0 +1,5 @@
+$1 --compile-dir=../../_build -c Main.agda > log
+./../../_build/Main hello world < input > output
+
+rm ../../_build/Main
+rm ../../_build/MAlonzo/Code/Main*
\ No newline at end of file
diff --git a/tests/system/random/.gitignore b/tests/system/random/.gitignore
new file mode 100644
index 0000000000..3ef413e285
--- /dev/null
+++ b/tests/system/random/.gitignore
@@ -0,0 +1 @@
+random_values
diff --git a/tests/system/random/Main.agda b/tests/system/random/Main.agda
new file mode 100644
index 0000000000..379b14ab44
--- /dev/null
+++ b/tests/system/random/Main.agda
@@ -0,0 +1,53 @@
+{-# OPTIONS --guardedness #-}
+
+module Main where
+
+open import Level using (0ℓ)
+open import Data.Unit.Polymorphic.Base using (⊤)
+import Data.Char.Base as Char
+import Data.Fin.Base as Fin
+import Data.Fin.Show as Fin
+import Data.Float.Base as Float
+open import Data.Integer.Base using (-[1+_]; +_; -≤+)
+import Data.Integer.Show as ℤ
+open import Data.List.Base as List using ([]; _∷_)
+import Data.List.Show as List
+import Data.Nat.Base
+import Data.Nat.Properties as ℕ
+import Data.Nat.Show as ℕ
+open import Data.String.Base as String
+import Data.Vec.Show as Vec
+import Data.Word.Base as Word64
+open import IO.Base
+open import IO.Finite
+open import Function.Base using (_$_; _∘_)
+open import System.Random
+import Data.Vec.Bounded.Show as Vec≤
+
+open import Relation.Binary.Construct.Closure.Reflexive
+
+asA : String → String → IO {0ℓ} ⊤
+asA ty str = putStrLn (ty ++ ": " ++ str)
+
+main : Main
+main = run $ do
+  asA "Char" ∘ Char.show =<< Char.randomIO
+  asA "Char" ∘ Char.show ∘ InBounds.value =<< Char.randomRIO ' ' '~' [ ℕ.≤ᵇ⇒≤ _ _ _ ]
+  asA "Float" ∘ Float.show =<< Float.randomIO
+  asA "Float" ∘ Float.show ∘ InBounds.value =<< Float.randomRIO 0.0 1.0 _
+  asA "Integer" ∘ ℤ.show =<< ℤ.randomIO
+  asA "Integer" ∘ ℤ.show ∘ InBounds.value =<< ℤ.randomRIO -[1+ 2 ] (+ 5) -≤+
+  asA "Nat" ∘ ℕ.show =<< ℕ.randomIO
+  asA "Nat" ∘ ℕ.show ∘ InBounds.value =<< ℕ.randomRIO 1 10 (ℕ.≤ᵇ⇒≤ _ _ _)
+  asA "Word" ∘ ℕ.show ∘ Word64.toℕ =<< Word64.randomIO
+  asA "Word" ∘ ℕ.show ∘ Word64.toℕ ∘ InBounds.value =<<
+    Word64.randomRIO (Word64.fromℕ 10) (Word64.fromℕ 20) (ℕ.≤ᵇ⇒≤ _ _ _)
+  asA "Fin 10" ∘ Fin.show =<< Fin.randomIO {n = 10}
+  asA "Fin 10" ∘ Fin.show ∘ InBounds.value =<<
+    Fin.randomRIO {n = 10}
+      (Fin.fromℕ< {m = 3} (ℕ.≤ᵇ⇒≤ _ _ _))
+      (Fin.fromℕ< {m = 8} (ℕ.≤ᵇ⇒≤ _ _ _))
+      (ℕ.≤ᵇ⇒≤ _ _ _)
+  asA "Vec≤ Integer 10" ∘ Vec≤.show (ℤ.show ∘ InBounds.value) =<< Vec≤.randomIO (ℤ.randomRIO -[1+ 10 ] (+ 11) -≤+) 10
+  asA "Vec Float 5" ∘ Vec.show (Float.show ∘ InBounds.value) =<< Vec.randomIO (Float.randomRIO -20.0 20.0 _) 5
+  asA "String≤ 20" ∘ String.show =<< RangedString≤.randomIO ' ' '~' [ ℕ.≤ᵇ⇒≤ _ _ _ ] 20
diff --git a/tests/system/random/expected b/tests/system/random/expected
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/system/random/random.agda-lib b/tests/system/random/random.agda-lib
new file mode 100644
index 0000000000..367219e74b
--- /dev/null
+++ b/tests/system/random/random.agda-lib
@@ -0,0 +1,2 @@
+name: ansi
+include: ../../../src/ .
diff --git a/tests/system/random/run b/tests/system/random/run
new file mode 100644
index 0000000000..79772d89db
--- /dev/null
+++ b/tests/system/random/run
@@ -0,0 +1,6 @@
+$1 --compile-dir=../../_build -c Main.agda > log
+./../../_build/Main > random_values
+touch output
+
+rm ../../_build/Main
+rm ../../_build/MAlonzo/Code/Main*
\ No newline at end of file
