perf: precise cache for expr_eq_fn

We also add `m_check_set` flag for controlling whether `check_cache`
should also inspect set of hashconsed objects or not.

.github/PULL_REQUEST_TEMPLATE.md

@@ -5,7 +5,6 @@
 * Include the link to your `RFC` or `bug` issue in the description.
 * If the issue does not already have approval from a developer, submit the PR as draft.
 * The PR title/description will become the commit message. Keep it up-to-date as the PR evolves.
-* A toolchain of the form `leanprover/lean4-pr-releases:pr-release-NNNN` for Linux and M-series Macs will be generated upon build. To generate binaries for Windows and Intel-based Macs as well, write a comment containing `release-ci` on its own line.
 * If you rebase your PR onto `nightly-with-mathlib` then CI will test Mathlib against your PR.
 * You can manage the `awaiting-review`, `awaiting-author`, and `WIP` labels yourself, by writing a comment containing one of these labels on its own line.
 * Remove this section, up to and including the `---` before submitting.

.github/workflows/ci.yml

@@ -114,7 +114,7 @@ jobs:
           elif [[ "${{ github.event_name }}" != "pull_request" ]]; then
             check_level=1
           else
-            labels="$(gh api repos/${{ github.repository_owner }}/${{ github.event.repository.name }}/pulls/${{ github.event.pull_request.number }} --jq '.labels')"
+            labels="$(gh api repos/${{ github.repository_owner }}/${{ github.event.repository.name }}/pulls/${{ github.event.pull_request.number }}) --jq '.labels'"
             if echo "$labels" | grep -q "release-ci"; then
               check_level=2
             elif echo "$labels" | grep -q "merge-ci"; then
@@ -176,7 +176,7 @@ jobs:
                 "check-level": 2,
                 "CMAKE_PRESET": "debug",
                 // exclude seriously slow tests
-                "CTEST_OPTIONS": "-E 'interactivetest|leanpkgtest|laketest|benchtest|bv_bitblast_stress'"
+                "CTEST_OPTIONS": "-E 'interactivetest|leanpkgtest|laketest|benchtest'"
               },
               // TODO: suddenly started failing in CI
               /*{
@@ -204,7 +204,7 @@ jobs:
                 "os": "macos-14",
                 "CMAKE_OPTIONS": "-DLEAN_INSTALL_SUFFIX=-darwin_aarch64",
                 "release": true,
-                "check-level": 0,
+                "check-level": 1,
                 "shell": "bash -euxo pipefail {0}",
                 "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/15.0.1/lean-llvm-aarch64-apple-darwin.tar.zst",
                 "prepare-llvm": "../script/prepare-llvm-macos.sh lean-llvm*",
@@ -226,19 +226,21 @@ jobs:
               },
               {
                 "name": "Linux aarch64",
-                "os": "nscloud-ubuntu-22.04-arm64-4x8",
+                "os": "ubuntu-latest",
                 "CMAKE_OPTIONS": "-DUSE_GMP=OFF -DLEAN_INSTALL_SUFFIX=-linux_aarch64",
                 "release": true,
                 "check-level": 2,
+                "cross": true,
+                "cross_target": "aarch64-unknown-linux-gnu",
                 "shell": "nix develop .#oldGlibcAArch -c bash -euxo pipefail {0}",
-                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/15.0.1/lean-llvm-aarch64-linux-gnu.tar.zst",
-                "prepare-llvm": "../script/prepare-llvm-linux.sh lean-llvm*"
+                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/15.0.1/lean-llvm-x86_64-linux-gnu.tar.zst https://github.com/leanprover/lean-llvm/releases/download/15.0.1/lean-llvm-aarch64-linux-gnu.tar.zst",
+                "prepare-llvm": "../script/prepare-llvm-linux.sh lean-llvm-aarch64-* lean-llvm-x86_64-*"
               },
               {
                 "name": "Linux 32bit",
                 "os": "ubuntu-latest",
                 // Use 32bit on stage0 and stage1 to keep oleans compatible
-                "CMAKE_OPTIONS": "-DSTAGE0_USE_GMP=OFF -DSTAGE0_LEAN_EXTRA_CXX_FLAGS='-m32' -DSTAGE0_LEANC_OPTS='-m32' -DSTAGE0_MMAP=OFF -DUSE_GMP=OFF -DLEAN_EXTRA_CXX_FLAGS='-m32' -DLEANC_OPTS='-m32' -DMMAP=OFF -DLEAN_INSTALL_SUFFIX=-linux_x86 -DCMAKE_LIBRARY_PATH=/usr/lib/i386-linux-gnu/ -DSTAGE0_CMAKE_LIBRARY_PATH=/usr/lib/i386-linux-gnu/",
+                "CMAKE_OPTIONS": "-DSTAGE0_USE_GMP=OFF -DSTAGE0_LEAN_EXTRA_CXX_FLAGS='-m32' -DSTAGE0_LEANC_OPTS='-m32' -DSTAGE0_MMAP=OFF -DUSE_GMP=OFF -DLEAN_EXTRA_CXX_FLAGS='-m32' -DLEANC_OPTS='-m32' -DMMAP=OFF -DLEAN_INSTALL_SUFFIX=-linux_x86",
                 "cmultilib": true,
                 "release": true,
                 "check-level": 2,
@@ -249,7 +251,7 @@ jobs:
                 "name": "Web Assembly",
                 "os": "ubuntu-latest",
                 // Build a native 32bit binary in stage0 and use it to compile the oleans and the wasm build
-                "CMAKE_OPTIONS": "-DCMAKE_C_COMPILER_WORKS=1 -DSTAGE0_USE_GMP=OFF -DSTAGE0_LEAN_EXTRA_CXX_FLAGS='-m32' -DSTAGE0_LEANC_OPTS='-m32' -DSTAGE0_CMAKE_CXX_COMPILER=clang++ -DSTAGE0_CMAKE_C_COMPILER=clang -DSTAGE0_CMAKE_EXECUTABLE_SUFFIX=\"\" -DUSE_GMP=OFF -DMMAP=OFF -DSTAGE0_MMAP=OFF -DCMAKE_AR=../emsdk/emsdk-main/upstream/emscripten/emar -DCMAKE_TOOLCHAIN_FILE=../emsdk/emsdk-main/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake -DLEAN_INSTALL_SUFFIX=-linux_wasm32 -DSTAGE0_CMAKE_LIBRARY_PATH=/usr/lib/i386-linux-gnu/",
+                "CMAKE_OPTIONS": "-DCMAKE_C_COMPILER_WORKS=1 -DSTAGE0_USE_GMP=OFF -DSTAGE0_LEAN_EXTRA_CXX_FLAGS='-m32' -DSTAGE0_LEANC_OPTS='-m32' -DSTAGE0_CMAKE_CXX_COMPILER=clang++ -DSTAGE0_CMAKE_C_COMPILER=clang -DSTAGE0_CMAKE_EXECUTABLE_SUFFIX=\"\" -DUSE_GMP=OFF -DMMAP=OFF -DSTAGE0_MMAP=OFF -DCMAKE_AR=../emsdk/emsdk-main/upstream/emscripten/emar -DCMAKE_TOOLCHAIN_FILE=../emsdk/emsdk-main/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake -DLEAN_INSTALL_SUFFIX=-linux_wasm32",
                 "wasm": true,
                 "cmultilib": true,
                 "release": true,
@@ -257,7 +259,7 @@ jobs:
                 "cross": true,
                 "shell": "bash -euxo pipefail {0}",
                 // Just a few selected tests because wasm is slow
-                "CTEST_OPTIONS": "-R \"leantest_1007\\.lean|leantest_Format\\.lean|leanruntest\\_1037.lean|leanruntest_ac_rfl\\.lean|leanruntest_libuv\\.lean\""
+                "CTEST_OPTIONS": "-R \"leantest_1007\\.lean|leantest_Format\\.lean|leanruntest\\_1037.lean|leanruntest_ac_rfl\\.lean\""
               }
             ];
             console.log(`matrix:\n${JSON.stringify(matrix, null, 2)}`)
@@ -297,11 +299,11 @@ jobs:
         with:
           msystem: clang64
           # `:` means do not prefix with msystem
-          pacboy: "make: python: cmake clang ccache gmp libuv git: zip: unzip: diffutils: binutils: tree: zstd tar:"
+          pacboy: "make: python: cmake clang ccache gmp git: zip: unzip: diffutils: binutils: tree: zstd tar:"
         if: runner.os == 'Windows'
       - name: Install Brew Packages
         run: |
-          brew install ccache tree zstd coreutils gmp libuv
+          brew install ccache tree zstd coreutils gmp
         if: runner.os == 'macOS'
       - name: Checkout
         uses: actions/checkout@v4
@@ -325,19 +327,17 @@ jobs:
         if: matrix.wasm
       - name: Install 32bit c libs
         run: |
-          sudo dpkg --add-architecture i386
           sudo apt-get update
-          sudo apt-get install -y gcc-multilib g++-multilib ccache libuv1-dev:i386
+          sudo apt-get install -y gcc-multilib g++-multilib ccache
         if: matrix.cmultilib
       - name: Cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         with:
           path: .ccache
           key: ${{ matrix.name }}-build-v3-${{ github.event.pull_request.head.sha }}
           # fall back to (latest) previous cache
           restore-keys: |
             ${{ matrix.name }}-build-v3
-          save-always: true
       # open nix-shell once for initial setup
       - name: Setup
         run: |
@@ -382,12 +382,6 @@ jobs:
           make -C build install
       - name: Check Binaries
         run: ${{ matrix.binary-check }} lean-*/bin/* || true
-      - name: Count binary symbols
-        run: |
-          for f in lean-*/bin/*; do
-            echo "$f: $(nm $f | grep " T " | wc -l) exported symbols"
-          done
-        if: matrix.name == 'Windows'
       - name: List Install Tree
         run: |
           # omit contents of Init/, ...

.github/workflows/labels-from-comments.yml

@@ -1,7 +1,6 @@
-# This workflow allows any user to add one of the `awaiting-review`, `awaiting-author`, `WIP`,
-# or `release-ci` labels by commenting on the PR or issue.
-# If any labels from the set {`awaiting-review`, `awaiting-author`, `WIP`} are added, other labels
-# from that set are removed automatically at the same time.
+# This workflow allows any user to add one of the `awaiting-review`, `awaiting-author`, or `WIP` labels,
+# by commenting on the PR or issue.
+# Other labels from this set are removed automatically at the same time.
 
 name: Label PR based on Comment
 
@@ -11,7 +10,7 @@ on:
 
 jobs:
   update-label:
-    if: github.event.issue.pull_request != null && (contains(github.event.comment.body, 'awaiting-review') || contains(github.event.comment.body, 'awaiting-author') || contains(github.event.comment.body, 'WIP') || contains(github.event.comment.body, 'release-ci'))
+    if: github.event.issue.pull_request != null && (contains(github.event.comment.body, 'awaiting-review') || contains(github.event.comment.body, 'awaiting-author') || contains(github.event.comment.body, 'WIP'))
     runs-on: ubuntu-latest
 
     steps:
@@ -26,7 +25,6 @@ jobs:
           const awaitingReview = commentLines.includes('awaiting-review');
           const awaitingAuthor = commentLines.includes('awaiting-author');
           const wip = commentLines.includes('WIP');
-          const releaseCI = commentLines.includes('release-ci');
 
           if (awaitingReview || awaitingAuthor || wip) {
             await github.rest.issues.removeLabel({ owner, repo, issue_number, name: 'awaiting-review' }).catch(() => {});
@@ -43,7 +41,3 @@ jobs:
           if (wip) {
             await github.rest.issues.addLabels({ owner, repo, issue_number, labels: ['WIP'] });
           }
-
-          if (releaseCI) {
-            await github.rest.issues.addLabels({ owner, repo, issue_number, labels: ['release-ci'] });
-          }

.github/workflows/nix-ci.yml

@@ -55,14 +55,13 @@ jobs:
           # the default is to use a virtual merge commit between the PR and master: just use the PR
           ref: ${{ github.event.pull_request.head.sha }}
       - name: Set Up Nix Cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         with:
           path: nix-store-cache
           key: ${{ matrix.name }}-nix-store-cache-${{ github.sha }}
           # fall back to (latest) previous cache
           restore-keys: |
             ${{ matrix.name }}-nix-store-cache
-          save-always: true
       - name: Further Set Up Nix Cache
         shell: bash -euxo pipefail {0}
         run: |
@@ -79,14 +78,13 @@ jobs:
           sudo mkdir -m0770 -p /nix/var/cache/ccache
           sudo chown -R $USER /nix/var/cache/ccache
       - name: Setup CCache Cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         with:
           path: /nix/var/cache/ccache
           key: ${{ matrix.name }}-nix-ccache-${{ github.sha }}
           # fall back to (latest) previous cache
           restore-keys: |
             ${{ matrix.name }}-nix-ccache
-          save-always: true
       - name: Further Set Up CCache Cache
         run: |
           sudo chown -R root:nixbld /nix/var/cache
@@ -105,7 +103,7 @@ jobs:
         continue-on-error: true
       - name: Build manual
         run: |
-          nix build $NIX_BUILD_ARGS --update-input lean --no-write-lock-file ./doc#{lean-mdbook,leanInk,alectryon,inked} -o push-doc
+          nix build $NIX_BUILD_ARGS --update-input lean --no-write-lock-file ./doc#{lean-mdbook,leanInk,alectryon,test,inked} -o push-doc
           nix build $NIX_BUILD_ARGS --update-input lean --no-write-lock-file ./doc
           # https://github.com/netlify/cli/issues/1809
           cp -r --dereference ./result ./dist
@@ -148,3 +146,5 @@ jobs:
       - name: Fixup CCache Cache
         run: |
           sudo chown -R $USER /nix/var/cache
+      - name: CCache stats
+        run: CCACHE_DIR=/nix/var/cache/ccache nix run .#nixpkgs.ccache -- -s

.github/workflows/pr-release.yml

@@ -163,8 +163,7 @@ jobs:
             # so keep in sync
 
             # Use GitHub API to check if a comment already exists
-            existing_comment="$(curl --retry 3 --location --silent \
-                                    -H "Authorization: token ${{ secrets.MATHLIB4_BOT }}" \
+            existing_comment="$(curl -L -s -H "Authorization: token ${{ secrets.MATHLIB4_BOT }}" \
                                     -H "Accept: application/vnd.github.v3+json" \
                                     "https://api.github.com/repos/leanprover/lean4/issues/${{ steps.workflow-info.outputs.pullRequestNumber }}/comments" \
                                     | jq 'first(.[] | select(.body | test("^- . Mathlib") or startswith("Mathlib CI status")) | select(.user.login == "leanprover-community-mathlib4-bot"))')"
@@ -329,7 +328,7 @@ jobs:
             git switch -c lean-pr-testing-${{ steps.workflow-info.outputs.pullRequestNumber }} "$BASE"
             echo "leanprover/lean4-pr-releases:pr-release-${{ steps.workflow-info.outputs.pullRequestNumber }}" > lean-toolchain
             git add lean-toolchain
-            sed -i 's,require "leanprover-community" / "batteries" @ git ".\+",require "leanprover-community" / "batteries" @ git "nightly-testing-'"${MOST_RECENT_NIGHTLY}"'",' lakefile.lean
+            sed -i 's,require "leanprover-community" / "batteries" @ ".\+",require "leanprover-community" / "batteries" @ "git#nightly-testing-'"${MOST_RECENT_NIGHTLY}"'",' lakefile.lean
             lake update batteries
             git add lakefile.lean lake-manifest.json
             git commit -m "Update lean-toolchain for testing https://github.com/leanprover/lean4/pull/${{ steps.workflow-info.outputs.pullRequestNumber }}"

.github/workflows/restart-on-label.yml

@@ -14,9 +14,8 @@ jobs:
         # (unfortunately cannot search by PR number, only base branch,
         # and that is't even unique given PRs from forks, but the risk
         # of confusion is low and the danger is mild)
-        echo "Trying to find a run with branch $head_ref and commit $head_sha"
-        run_id="$(gh run list -e pull_request -b "$head_ref" -c "$head_sha" \
-          --workflow 'CI' --limit 1 --json databaseId --jq '.[0].databaseId')"
+        run_id=$(gh run list -e pull_request -b "$head_ref" --workflow 'CI' --limit 1 \
+          --limit 1 --json databaseId --jq '.[0].databaseId')
         echo "Run id: ${run_id}"
         gh run view "$run_id"
         echo "Cancelling (just in case)"
@@ -30,6 +29,5 @@ jobs:
       shell: bash
       env:
         head_ref: ${{ github.head_ref }}
-        head_sha: ${{ github.event.pull_request.head.sha }}
         GH_TOKEN: ${{ github.token }}
         GH_REPO: ${{ github.repository }}

.github/workflows/update-stage0.yml

@@ -47,7 +47,7 @@ jobs:
     #  uses: DeterminateSystems/magic-nix-cache-action@v2
     - if: env.should_update_stage0 == 'yes'
       name: Restore Build Cache
-      uses: actions/cache/restore@v4
+      uses: actions/cache/restore@v3
       with:
         path: nix-store-cache
         key: Nix Linux-nix-store-cache-${{ github.sha }}

CMakeLists.txt

@@ -30,35 +30,6 @@ if(NOT (DEFINED STAGE0_CMAKE_EXECUTABLE_SUFFIX))
     set(STAGE0_CMAKE_EXECUTABLE_SUFFIX "${CMAKE_EXECUTABLE_SUFFIX}")
 endif()
 
-# Don't do anything with cadical on wasm
-if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-  # On CI Linux, we source cadical from Nix instead; see flake.nix
-  find_program(CADICAL cadical)
-  if(NOT CADICAL)
-    set(CADICAL_CXX c++)
-    find_program(CCACHE ccache)
-    if(CCACHE)
-      set(CADICAL_CXX "${CCACHE} ${CADICAL_CXX}")
-    endif()
-    # missing stdio locking API on Windows
-    if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-      string(APPEND CADICAL_CXXFLAGS " -DNUNLOCKED")
-    endif()
-    ExternalProject_add(cadical
-      PREFIX cadical
-      GIT_REPOSITORY https://github.com/arminbiere/cadical
-      GIT_TAG rel-1.9.5
-      CONFIGURE_COMMAND ""
-      # https://github.com/arminbiere/cadical/blob/master/BUILD.md#manual-build
-      BUILD_COMMAND $(MAKE) -f ${CMAKE_SOURCE_DIR}/src/cadical.mk CMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX} CXX=${CADICAL_CXX} CXXFLAGS=${CADICAL_CXXFLAGS}
-      BUILD_IN_SOURCE ON
-      INSTALL_COMMAND "")
-    set(CADICAL ${CMAKE_BINARY_DIR}/cadical/cadical${CMAKE_EXECUTABLE_SUFFIX} CACHE FILEPATH "path to cadical binary" FORCE)
-    set(EXTRA_DEPENDS "cadical")
-  endif()
-  list(APPEND CL_ARGS -DCADICAL=${CADICAL})
-endif()
-
 ExternalProject_add(stage0
   SOURCE_DIR "${LEAN_SOURCE_DIR}/stage0"
   SOURCE_SUBDIR src

CODEOWNERS

@@ -43,5 +43,3 @@
 /src/Init/Guard.lean @digama0
 /src/Lean/Server/CodeActions/ @digama0
 /src/Std/ @TwoFX
-/src/Std/Tactic/BVDecide/ @hargoniX
-/src/Lean/Elab/Tactic/BVDecide/ @hargoniX

LICENSES

@@ -1341,33 +1341,3 @@ whether future versions of the GNU Lesser General Public License shall
 apply, that proxy's public statement of acceptance of any version is
 permanent authorization for you to choose that version for the
 Library.
-==============================================================================
-CaDiCaL is under the MIT License:
-==============================================================================
-MIT License
-
-Copyright (c) 2016-2021 Armin Biere, Johannes Kepler University Linz, Austria
-Copyright (c) 2020-2021 Mathias Fleury, Johannes Kepler University Linz, Austria
-Copyright (c) 2020-2021 Nils Froleyks, Johannes Kepler University Linz, Austria
-Copyright (c) 2022-2024 Katalin Fazekas, Vienna University of Technology, Austria
-Copyright (c) 2021-2024 Armin Biere, University of Freiburg, Germany
-Copyright (c) 2021-2024 Mathias Fleury, University of Freiburg, Germany
-Copyright (c) 2023-2024 Florian Pollitt, University of Freiburg, Germany
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

RELEASES.md

@@ -8,349 +8,9 @@ This file contains work-in-progress notes for the upcoming release, as well as p
 Please check the [releases](https://github.com/leanprover/lean4/releases) page for the current status
 of each version.
 
-v4.12.0
-----------
-Development in progress.
-
 v4.11.0
 ----------
-
-### Language features, tactics, and metaprograms
-
-* The variable inclusion mechanism has been changed. Like before, when a definition mentions a variable, Lean will add it as an argument of the definition, but now in theorem bodies, variables are not included based on usage in order to ensure that changes to the proof cannot change the statement of the overall theorem. Instead, variables are only available to the proof if they have been mentioned in the theorem header or in an **`include` command** or are instance implicit and depend only on such variables. The **`omit` command** can be used to omit included variables.
-
-  See breaking changes below.
-
-  PRs: [#4883](https://github.com/leanprover/lean4/pull/4883), [1242ff](https://github.com/leanprover/lean4/commit/1242ffbfb5a79296041683682268e770fc3cf820), [#5000](https://github.com/leanprover/lean4/pull/5000), [#5036](https://github.com/leanprover/lean4/pull/5036), [#5138](https://github.com/leanprover/lean4/pull/5138), [0edf1b](https://github.com/leanprover/lean4/commit/0edf1bac392f7e2fe0266b28b51c498306363a84).
-
-* **Recursive definitions**
-  * Structural recursion can now be explicitly requested using
-    ```
-    termination_by structural x
-    ```
-    in analogy to the existing `termination_by x` syntax that causes well-founded recursion to be used.
-    [#4542](https://github.com/leanprover/lean4/pull/4542)
-  * [#4672](https://github.com/leanprover/lean4/pull/4672) fixes a bug that could lead to ill-typed terms.
-  * The `termination_by?` syntax no longer forces the use of well-founded recursion, and when structural
-    recursion is inferred, it will print the result using the `termination_by structural` syntax.
-  * **Mutual structural recursion** is now supported. This feature supports both mutual recursion over a non-mutual
-    data type, as well as recursion over mutual or nested data types:
-
-    ```lean
-    mutual
-    def Even : Nat → Prop
-      | 0 => True
-      | n+1 => Odd n
-
-    def Odd : Nat → Prop
-      | 0 => False
-      | n+1 => Even n
-    end
-
-    mutual
-    inductive A
-    | other : B → A
-    | empty
-    inductive B
-    | other : A → B
-    | empty
-    end
-
-    mutual
-    def A.size : A → Nat
-    | .other b => b.size + 1
-    | .empty => 0
-
-    def B.size : B → Nat
-    | .other a => a.size + 1
-    | .empty => 0
-    end
-
-    inductive Tree where | node : List Tree → Tree
-
-    mutual
-    def Tree.size : Tree → Nat
-    | node ts => Tree.list_size ts
-
-    def Tree.list_size : List Tree → Nat
-    | [] => 0
-    | t::ts => Tree.size t + Tree.list_size ts
-    end
-    ```
-
-    Functional induction principles are generated for these functions as well (`A.size.induct`, `A.size.mutual_induct`).
-
-    Nested structural recursion is still not supported.
-
-    PRs: [#4639](https://github.com/leanprover/lean4/pull/4639), [#4715](https://github.com/leanprover/lean4/pull/4715), [#4642](https://github.com/leanprover/lean4/pull/4642), [#4656](https://github.com/leanprover/lean4/pull/4656), [#4684](https://github.com/leanprover/lean4/pull/4684), [#4715](https://github.com/leanprover/lean4/pull/4715), [#4728](https://github.com/leanprover/lean4/pull/4728), [#4575](https://github.com/leanprover/lean4/pull/4575), [#4731](https://github.com/leanprover/lean4/pull/4731), [#4658](https://github.com/leanprover/lean4/pull/4658), [#4734](https://github.com/leanprover/lean4/pull/4734), [#4738](https://github.com/leanprover/lean4/pull/4738), [#4718](https://github.com/leanprover/lean4/pull/4718), [#4733](https://github.com/leanprover/lean4/pull/4733), [#4787](https://github.com/leanprover/lean4/pull/4787), [#4788](https://github.com/leanprover/lean4/pull/4788), [#4789](https://github.com/leanprover/lean4/pull/4789), [#4807](https://github.com/leanprover/lean4/pull/4807), [#4772](https://github.com/leanprover/lean4/pull/4772)
-  * [#4809](https://github.com/leanprover/lean4/pull/4809) makes unnecessary `termination_by` clauses cause warnings, not errors.
-  * [#4831](https://github.com/leanprover/lean4/pull/4831) improves handling of nested structural recursion through non-recursive types.
-  * [#4839](https://github.com/leanprover/lean4/pull/4839) improves support for structural recursive over inductive predicates when there are reflexive arguments.
-* `simp` tactic
-  * [#4784](https://github.com/leanprover/lean4/pull/4784) sets configuration `Simp.Config.implicitDefEqProofs` to `true` by default.
-
-* `omega` tactic
-  * [#4612](https://github.com/leanprover/lean4/pull/4612) normalizes the order that constraints appear in error messages.
-  * [#4695](https://github.com/leanprover/lean4/pull/4695) prevents pushing casts into multiplications unless it produces a non-trivial linear combination.
-  * [#4989](https://github.com/leanprover/lean4/pull/4989) fixes a regression.
-
-* `decide` tactic
-  * [#4711](https://github.com/leanprover/lean4/pull/4711) switches from using default transparency to *at least* default transparency when reducing the `Decidable` instance.
-  * [#4674](https://github.com/leanprover/lean4/pull/4674) adds detailed feedback on `decide` tactic failure. It tells you which `Decidable` instances it unfolded, if it get stuck on `Eq.rec` it gives a hint about avoiding tactics when defining `Decidable` instances, and if it gets stuck on `Classical.choice` it gives hints about classical instances being in scope. During this process, it processes `Decidable.rec`s and matches to pin blame on a non-reducing instance.
-
-* `@[ext]` attribute
-  * [#4543](https://github.com/leanprover/lean4/pull/4543) and [#4762](https://github.com/leanprover/lean4/pull/4762) make `@[ext]` realize `ext_iff` theorems from user `ext` theorems. Fixes the attribute so that `@[local ext]` and `@[scoped ext]` are usable. The `@[ext (iff := false)]` option can be used to turn off `ext_iff` realization.
-  * [#4694](https://github.com/leanprover/lean4/pull/4694) makes "go to definition" work for the generated lemmas. Also adjusts the core library to make use of `ext_iff` generation.
-  * [#4710](https://github.com/leanprover/lean4/pull/4710) makes `ext_iff` theorem preserve inst implicit binder types, rather than making all binder types implicit.
-
-* `#eval` command
-  * [#4810](https://github.com/leanprover/lean4/pull/4810) introduces a safer `#eval` command that prevents evaluation of terms that contain `sorry`. The motivation is that failing tactics, in conjunction with operations such as array accesses, can lead to the Lean process crashing. Users can use the new `#eval!` command to use the previous unsafe behavior. ([#4829](https://github.com/leanprover/lean4/pull/4829) adjusts a test.)
-
-* [#4447](https://github.com/leanprover/lean4/pull/4447) adds `#discr_tree_key` and `#discr_tree_simp_key` commands, for helping debug discrimination tree failures. The `#discr_tree_key t` command prints the discrimination tree keys for a term `t` (or, if it is a single identifier, the type of that constant). It uses the default configuration for generating keys. The `#discr_tree_simp_key` command is similar to `#discr_tree_key`, but treats the underlying type as one of a simp lemma, that is it transforms it into an equality and produces the key of the left-hand side.
-
-  For example,
-  ```
-  #discr_tree_key (∀ {a n : Nat}, bar a (OfNat.ofNat n))
-  -- bar _ (@OfNat.ofNat Nat _ _)
-
-  #discr_tree_simp_key Nat.add_assoc
-  -- @HAdd.hAdd Nat Nat Nat _ (@HAdd.hAdd Nat Nat Nat _ _ _) _
-  ```
-
-* [#4741](https://github.com/leanprover/lean4/pull/4741) changes option parsing to allow user-defined options from the command line. Initial options are now re-parsed and validated after importing. Command line option assignments prefixed with `weak.` are silently discarded if the option name without the prefix does not exist.
-
-* **Deriving handlers**
-  * [7253ef](https://github.com/leanprover/lean4/commit/7253ef8751f76bcbe0e6f46dcfa8069699a2bac7) and [a04f3c](https://github.com/leanprover/lean4/commit/a04f3cab5a9fe2870825af6544ca13c5bb766706) improve the construction of the `BEq` deriving handler.
-  * [86af04](https://github.com/leanprover/lean4/commit/86af04cc08c0dbbe0e735ea13d16edea3465f850) makes `BEq` deriving handler work when there are dependently typed fields.
-  * [#4826](https://github.com/leanprover/lean4/pull/4826) refactors the `DecidableEq` deriving handle to use `termination_by structural`.
-
-* **Metaprogramming**
-  * [#4593](https://github.com/leanprover/lean4/pull/4593) adds `unresolveNameGlobalAvoidingLocals`.
-  * [#4618](https://github.com/leanprover/lean4/pull/4618) deletes deprecated functions from 2022.
-  * [#4642](https://github.com/leanprover/lean4/pull/4642) adds `Meta.lambdaBoundedTelescope`.
-  * [#4731](https://github.com/leanprover/lean4/pull/4731) adds `Meta.withErasedFVars`, to enter a context with some fvars erased from the local context.
-  * [#4777](https://github.com/leanprover/lean4/pull/4777) adds assignment validation at `closeMainGoal`, preventing users from circumventing the occurs check for tactics such as `exact`.
-  * [#4807](https://github.com/leanprover/lean4/pull/4807) introduces `Lean.Meta.PProdN` module for packing and projecting nested `PProd`s.
-  * [#5170](https://github.com/leanprover/lean4/pull/5170) fixes `Syntax.unsetTrailing`. A consequence of this is that "go to definition" now works on the last module name in an `import` block (issue [#4958](https://github.com/leanprover/lean4/issues/4958)).
-
-
-### Language server, widgets, and IDE extensions
-
-* [#4727](https://github.com/leanprover/lean4/pull/4727) makes it so that responses to info view requests come as soon as the relevant tactic has finished execution.
-* [#4580](https://github.com/leanprover/lean4/pull/4580) makes it so that whitespace changes do not invalidate imports, and so starting to type the first declaration after imports should no longer cause them to reload.
-* [#4780](https://github.com/leanprover/lean4/pull/4780) fixes an issue where hovering over unimported builtin names could result in a panic.
-
-### Pretty printing
-
-* [#4558](https://github.com/leanprover/lean4/pull/4558) fixes the `pp.instantiateMVars` setting and changes the default value to `true`.
-* [#4631](https://github.com/leanprover/lean4/pull/4631) makes sure syntax nodes always run their formatters. Fixes an issue where if `ppSpace` appears in a `macro` or `elab` command then it does not format with a space.
-* [#4665](https://github.com/leanprover/lean4/pull/4665) fixes a bug where pretty printed signatures (for example in `#check`) were overly hoverable due to `pp.tagAppFns` being set.
-* [#4724](https://github.com/leanprover/lean4/pull/4724) makes `match` pretty printer be sensitive to `pp.explicit`, which makes hovering over a `match` in the Infoview show the underlying term.
-* [#4764](https://github.com/leanprover/lean4/pull/4764) documents why anonymous constructor notation isn't pretty printed with flattening.
-* [#4786](https://github.com/leanprover/lean4/pull/4786) adjusts the parenthesizer so that only the parentheses are hoverable, implemented by having the parentheses "steal" the term info from the parenthesized expression.
-* [#4854](https://github.com/leanprover/lean4/pull/4854) allows arbitrarily long sequences of optional arguments to be omitted from the end of applications, versus the previous conservative behavior of omitting up to one optional argument.
-
-### Library
-
-* `Nat`
-  * [#4597](https://github.com/leanprover/lean4/pull/4597) adds bitwise lemmas `Nat.and_le_(left|right)`.
-  * [#4874](https://github.com/leanprover/lean4/pull/4874) adds simprocs for simplifying bit expressions.
-* `Int`
-  * [#4903](https://github.com/leanprover/lean4/pull/4903) fixes performance of `HPow Int Nat Int` synthesis by rewriting it as a `NatPow Int` instance.
-* `UInt*` and `Fin`
-  * [#4605](https://github.com/leanprover/lean4/pull/4605) adds lemmas.
-  * [#4629](https://github.com/leanprover/lean4/pull/4629) adds `*.and_toNat`.
-* `Option`
-  * [#4599](https://github.com/leanprover/lean4/pull/4599) adds `get` lemmas.
-  * [#4600](https://github.com/leanprover/lean4/pull/4600) adds `Option.or`, a version of `Option.orElse` that is strict in the second argument.
-* `GetElem`
-  * [#4603](https://github.com/leanprover/lean4/pull/4603) adds `getElem_congr` to help with rewriting indices.
-* `List` and `Array`
-  * Upstreamed from Batteries: [#4586](https://github.com/leanprover/lean4/pull/4586) upstreams `List.attach` and `Array.attach`, [#4697](https://github.com/leanprover/lean4/pull/4697) upstreams `List.Subset` and `List.Sublist` and API, [#4706](https://github.com/leanprover/lean4/pull/4706) upstreams basic material on `List.Pairwise` and `List.Nodup`, [#4720](https://github.com/leanprover/lean4/pull/4720) upstreams more `List.erase` API, [#4836](https://github.com/leanprover/lean4/pull/4836) and [#4837](https://github.com/leanprover/lean4/pull/4837) upstream `List.IsPrefix`/`List.IsSuffix`/`List.IsInfix` and add `Decidable` instances, [#4855](https://github.com/leanprover/lean4/pull/4855) upstreams `List.tail`, `List.findIdx`, `List.indexOf`, `List.countP`, `List.count`, and `List.range'`, [#4856](https://github.com/leanprover/lean4/pull/4856) upstreams more List lemmas, [#4866](https://github.com/leanprover/lean4/pull/4866) upstreams `List.pairwise_iff_getElem`, [#4865](https://github.com/leanprover/lean4/pull/4865) upstreams `List.eraseIdx` lemmas.
-  * [#4687](https://github.com/leanprover/lean4/pull/4687) adjusts `List.replicate` simp lemmas and simprocs.
-  * [#4704](https://github.com/leanprover/lean4/pull/4704) adds characterizations of `List.Sublist`.
-  * [#4707](https://github.com/leanprover/lean4/pull/4707) adds simp normal form tests for `List.Pairwise` and `List.Nodup`.
-  * [#4708](https://github.com/leanprover/lean4/pull/4708) and [#4815](https://github.com/leanprover/lean4/pull/4815) reorganize lemmas on list getters.
-  * [#4765](https://github.com/leanprover/lean4/pull/4765) adds simprocs for literal array accesses such as `#[1,2,3,4,5][2]`.
-  * [#4790](https://github.com/leanprover/lean4/pull/4790) removes typeclass assumptions for `List.Nodup.eraseP`.
-  * [#4801](https://github.com/leanprover/lean4/pull/4801) adds efficient `usize` functions for array types.
-  * [#4820](https://github.com/leanprover/lean4/pull/4820) changes `List.filterMapM` to run left-to-right.
-  * [#4835](https://github.com/leanprover/lean4/pull/4835) fills in and cleans up gaps in List API.
-  * [#4843](https://github.com/leanprover/lean4/pull/4843), [#4868](https://github.com/leanprover/lean4/pull/4868), and [#4877](https://github.com/leanprover/lean4/pull/4877) correct `List.Subset` lemmas.
-  * [#4863](https://github.com/leanprover/lean4/pull/4863) splits `Init.Data.List.Lemmas` into function-specific files.
-  * [#4875](https://github.com/leanprover/lean4/pull/4875) fixes statement of `List.take_takeWhile`.
-  * Lemmas: [#4602](https://github.com/leanprover/lean4/pull/4602), [#4627](https://github.com/leanprover/lean4/pull/4627), [#4678](https://github.com/leanprover/lean4/pull/4678) for `List.head` and `list.getLast`, [#4723](https://github.com/leanprover/lean4/pull/4723) for `List.erase`, [#4742](https://github.com/leanprover/lean4/pull/4742)
-* `ByteArray`
-  * [#4582](https://github.com/leanprover/lean4/pull/4582) eliminates `partial` from `ByteArray.toList` and `ByteArray.findIdx?`.
-* `BitVec`
-  * [#4568](https://github.com/leanprover/lean4/pull/4568) adds recurrence theorems for bitblasting multiplication.
-  * [#4571](https://github.com/leanprover/lean4/pull/4571) adds `shiftLeftRec` lemmas.
-  * [#4872](https://github.com/leanprover/lean4/pull/4872) adds `ushiftRightRec` and lemmas.
-  * [#4873](https://github.com/leanprover/lean4/pull/4873) adds `getLsb_replicate`.
-* `Std.HashMap` added:
-  * [#4583](https://github.com/leanprover/lean4/pull/4583) **adds `Std.HashMap`** as a verified replacement for `Lean.HashMap`. See the PR for naming differences, but [#4725](https://github.com/leanprover/lean4/pull/4725) renames `HashMap.remove` to `HashMap.erase`.
-  * [#4682](https://github.com/leanprover/lean4/pull/4682) adds `Inhabited` instances.
-  * [#4732](https://github.com/leanprover/lean4/pull/4732) improves `BEq` argument order in hash map lemmas.
-  * [#4759](https://github.com/leanprover/lean4/pull/4759) makes lemmas resolve instances via unification.
-  * [#4771](https://github.com/leanprover/lean4/pull/4771) documents that hash maps should be used linearly to avoid expensive copies.
-  * [#4791](https://github.com/leanprover/lean4/pull/4791) removes `bif` from hash map lemmas, which is inconvenient to work with in practice.
-  * [#4803](https://github.com/leanprover/lean4/pull/4803) adds more lemmas.
-* `SMap`
-  * [#4690](https://github.com/leanprover/lean4/pull/4690) upstreams `SMap.foldM`.
-* `BEq`
-  * [#4607](https://github.com/leanprover/lean4/pull/4607) adds `PartialEquivBEq`, `ReflBEq`, `EquivBEq`, and `LawfulHashable` classes.
-* `IO`
-  * [#4660](https://github.com/leanprover/lean4/pull/4660) adds `IO.Process.Child.tryWait`.
-* [#4747](https://github.com/leanprover/lean4/pull/4747), [#4730](https://github.com/leanprover/lean4/pull/4730), and [#4756](https://github.com/leanprover/lean4/pull/4756) add `×'` syntax for `PProd`. Adds a delaborator for `PProd` and `MProd` values to pretty print as flattened angle bracket tuples.
-* **Other fixes or improvements**
-  * [#4604](https://github.com/leanprover/lean4/pull/4604) adds lemmas for cond.
-  * [#4619](https://github.com/leanprover/lean4/pull/4619) changes some definitions into theorems.
-  * [#4616](https://github.com/leanprover/lean4/pull/4616) fixes some names with duplicated namespaces.
-  * [#4620](https://github.com/leanprover/lean4/pull/4620) fixes simp lemmas flagged by the simpNF linter.
-  * [#4666](https://github.com/leanprover/lean4/pull/4666) makes the `Antisymm` class be a `Prop`.
-  * [#4621](https://github.com/leanprover/lean4/pull/4621) cleans up unused arguments flagged by linter.
-  * [#4680](https://github.com/leanprover/lean4/pull/4680) adds imports for orphaned `Init` modules.
-  * [#4679](https://github.com/leanprover/lean4/pull/4679) adds imports for orphaned `Std.Data` modules.
-  * [#4688](https://github.com/leanprover/lean4/pull/4688) adds forward and backward directions of `not_exists`.
-  * [#4689](https://github.com/leanprover/lean4/pull/4689) upstreams `eq_iff_true_of_subsingleton`.
-  * [#4709](https://github.com/leanprover/lean4/pull/4709) fixes precedence handling for `Repr` instances for negative numbers for `Int` and `Float`.
-  * [#4760](https://github.com/leanprover/lean4/pull/4760) renames `TC` ("transitive closure") to `Relation.TransGen`.
-  * [#4842](https://github.com/leanprover/lean4/pull/4842) fixes `List` deprecations.
-  * [#4852](https://github.com/leanprover/lean4/pull/4852) upstreams some Mathlib attributes applied to lemmas.
-  * [93ac63](https://github.com/leanprover/lean4/commit/93ac635a89daa5a8e8ef33ec96b0bcbb5d7ec1ea) improves proof.
-  * [#4862](https://github.com/leanprover/lean4/pull/4862) and [#4878](https://github.com/leanprover/lean4/pull/4878) generalize the universe for `PSigma.exists` and rename it to `Exists.of_psigma_prop`.
-  * Typos: [#4737](https://github.com/leanprover/lean4/pull/4737), [7d2155](https://github.com/leanprover/lean4/commit/7d2155943c67c743409420b4546d47fadf73af1c)
-  * Docs: [#4782](https://github.com/leanprover/lean4/pull/4782), [#4869](https://github.com/leanprover/lean4/pull/4869), [#4648](https://github.com/leanprover/lean4/pull/4648)
-
-### Lean internals
-* **Elaboration**
-  * [#4596](https://github.com/leanprover/lean4/pull/4596) enforces `isDefEqStuckEx` at `unstuckMVar` procedure, causing isDefEq to throw a stuck defeq exception if the metavariable was created in a previous level. This results in some better error messages, and it helps `rw` succeed in synthesizing instances (see issue [#2736](https://github.com/leanprover/lean4/issues/2736)).
-  * [#4713](https://github.com/leanprover/lean4/pull/4713) fixes deprecation warnings when there are overloaded symbols.
-  * `elab_as_elim` algorithm:
-    * [#4722](https://github.com/leanprover/lean4/pull/4722) adds check that inferred motive is type-correct.
-    * [#4800](https://github.com/leanprover/lean4/pull/4800) elaborates arguments for parameters appearing in the types of targets.
-    * [#4817](https://github.com/leanprover/lean4/pull/4817) makes the algorithm correctly handle eliminators with explicit motive arguments.
-  * [#4792](https://github.com/leanprover/lean4/pull/4792) adds term elaborator for `Lean.Parser.Term.namedPattern` (e.g. `n@(n' + 1)`) to report errors when used in non-pattern-matching contexts.
-  * [#4818](https://github.com/leanprover/lean4/pull/4818) makes anonymous dot notation work when the expected type is a pi-type-valued type synonym.
-* **Typeclass inference**
-  * [#4646](https://github.com/leanprover/lean4/pull/4646) improves `synthAppInstances`, the function responsible for synthesizing instances for the `rw` and `apply` tactics. Adds a synthesis loop to handle functions whose instances need to be synthesized in a complex order.
-* **Inductive types**
-  * [#4684](https://github.com/leanprover/lean4/pull/4684) (backported as [98ee78](https://github.com/leanprover/lean4/commit/98ee789990f91ff5935627787b537911ef8773c4)) refactors `InductiveVal` to have a `numNested : Nat` field instead of `isNested : Bool`. This modifies the kernel.
-* **Definitions**
-  * [#4776](https://github.com/leanprover/lean4/pull/4776) improves performance of `Replacement.apply`.
-  * [#4712](https://github.com/leanprover/lean4/pull/4712) fixes `.eq_def` theorem generation with messy universes.
-  * [#4841](https://github.com/leanprover/lean4/pull/4841) improves success of finding `T.below x` hypothesis when transforming `match` statements for `IndPredBelow`.
-* **Diagnostics and profiling**
-  * [#4611](https://github.com/leanprover/lean4/pull/4611) makes kernel diagnostics appear when `diagnostics` is enabled even if it is the only section.
-  * [#4753](https://github.com/leanprover/lean4/pull/4753) adds missing `profileitM` functions.
-  * [#4754](https://github.com/leanprover/lean4/pull/4754) adds `Lean.Expr.numObjs` to compute the number of allocated sub-expressions in a given expression, primarily for diagnosing performance issues.
-  * [#4769](https://github.com/leanprover/lean4/pull/4769) adds missing `withTraceNode`s to improve `trace.profiler` output.
-  * [#4781](https://github.com/leanprover/lean4/pull/4781) and [#4882](https://github.com/leanprover/lean4/pull/4882) make the "use `set_option diagnostics true`" message be conditional on current setting of `diagnostics`.
-* **Performance**
-  * [#4767](https://github.com/leanprover/lean4/pull/4767), [#4775](https://github.com/leanprover/lean4/pull/4775), and [#4887](https://github.com/leanprover/lean4/pull/4887) add `ShareCommon.shareCommon'` for sharing common terms. In an example with 16 million subterms, it is 20 times faster than the old `shareCommon` procedure.
-  * [#4779](https://github.com/leanprover/lean4/pull/4779) ensures `Expr.replaceExpr` preserves DAG structure in `Expr`s.
-  * [#4783](https://github.com/leanprover/lean4/pull/4783) documents performance issue in `Expr.replaceExpr`.
-  * [#4794](https://github.com/leanprover/lean4/pull/4794), [#4797](https://github.com/leanprover/lean4/pull/4797), [#4798](https://github.com/leanprover/lean4/pull/4798) make `for_each` use precise cache.
-  * [#4795](https://github.com/leanprover/lean4/pull/4795) makes `Expr.find?` and `Expr.findExt?` use the kernel implementations.
-  * [#4799](https://github.com/leanprover/lean4/pull/4799) makes `Expr.replace` use the kernel implementation.
-  * [#4871](https://github.com/leanprover/lean4/pull/4871) makes `Expr.foldConsts` use a precise cache.
-  * [#4890](https://github.com/leanprover/lean4/pull/4890) makes `expr_eq_fn` use a precise cache.
-* **Utilities**
-  * [#4453](https://github.com/leanprover/lean4/pull/4453) upstreams `ToExpr FilePath` and `compile_time_search_path%`.
-* **Module system**
-  * [#4652](https://github.com/leanprover/lean4/pull/4652) fixes handling of `const2ModIdx` in `finalizeImport`, making it prefer the original module for a declaration when a declaration is re-declared.
-* **Kernel**
-  * [#4637](https://github.com/leanprover/lean4/pull/4637) adds a check to prevent large `Nat` exponentiations from evaluating. Elaborator reduction is controlled by the option `exponentiation.threshold`.
-  * [#4683](https://github.com/leanprover/lean4/pull/4683) updates comments in `kernel/declaration.h`, making sure they reflect the current Lean 4 types.
-  * [#4796](https://github.com/leanprover/lean4/pull/4796) improves performance by using `replace` with a precise cache.
-  * [#4700](https://github.com/leanprover/lean4/pull/4700) improves performance by fixing the implementation of move constructors and move assignment operators. Expression copying was taking 10% of total runtime in some workloads. See issue [#4698](https://github.com/leanprover/lean4/issues/4698).
-  * [#4702](https://github.com/leanprover/lean4/pull/4702) improves performance in `replace_rec_fn::apply` by avoiding expression copies. These copies represented about 13% of time spent in `save_result` in some workloads. See the same issue.
-* **Other fixes or improvements**
-  * [#4590](https://github.com/leanprover/lean4/pull/4590) fixes a typo in some constants and `trace.profiler.useHeartbeats`.
-  * [#4617](https://github.com/leanprover/lean4/pull/4617) add 'since' dates to `deprecated` attributes.
-  * [#4625](https://github.com/leanprover/lean4/pull/4625) improves the robustness of the constructor-as-variable test.
-  * [#4740](https://github.com/leanprover/lean4/pull/4740) extends test with nice example reported on Zulip.
-  * [#4766](https://github.com/leanprover/lean4/pull/4766) moves `Syntax.hasIdent` to be available earlier and shakes dependencies.
-  * [#4881](https://github.com/leanprover/lean4/pull/4881) splits out `Lean.Language.Lean.Types`.
-  * [#4893](https://github.com/leanprover/lean4/pull/4893) adds `LEAN_EXPORT` for `sharecommon` functions.
-  * Typos: [#4635](https://github.com/leanprover/lean4/pull/4635), [#4719](https://github.com/leanprover/lean4/pull/4719), [af40e6](https://github.com/leanprover/lean4/commit/af40e618111581c82fc44de922368a02208b499f)
-  * Docs: [#4748](https://github.com/leanprover/lean4/pull/4748) (`Command.Scope`)
-
-### Compiler, runtime, and FFI
-* [#4661](https://github.com/leanprover/lean4/pull/4661) moves `Std` from `libleanshared` to much smaller `libInit_shared`. This fixes the Windows build.
-* [#4668](https://github.com/leanprover/lean4/pull/4668) fixes initialization, explicitly initializing `Std` in `lean_initialize`.
-* [#4746](https://github.com/leanprover/lean4/pull/4746) adjusts `shouldExport` to exclude more symbols to get below Windows symbol limit. Some exceptions are added by [#4884](https://github.com/leanprover/lean4/pull/4884) and [#4956](https://github.com/leanprover/lean4/pull/4956) to support Verso.
-* [#4778](https://github.com/leanprover/lean4/pull/4778) adds `lean_is_exclusive_obj` (`Lean.isExclusiveUnsafe`) and `lean_set_external_data`.
-* [#4515](https://github.com/leanprover/lean4/pull/4515) fixes calling programs with spaces on Windows.
-
-### Lake
-
-* [#4735](https://github.com/leanprover/lean4/pull/4735) improves a number of elements related to Git checkouts, cloud releases,
-and related error handling.
-
-  * On error, Lake now prints all top-level logs. Top-level logs are those produced by Lake outside of the job monitor (e.g., when cloning dependencies).
-  * When fetching a remote for a dependency, Lake now forcibly fetches tags. This prevents potential errors caused by a repository recreating tags already fetched.
-  * Git error handling is now more informative.
-  * The builtin package facets `release`, `optRelease`, `extraDep` are now captions in the same manner as other facets.
-  * `afterReleaseSync` and `afterReleaseAsync` now fetch `optRelease` rather than `release`.
-  * Added support for optional jobs, whose failure does not cause the whole build to failure. Now `optRelease` is such a job.
-
-* [#4608](https://github.com/leanprover/lean4/pull/4608) adds draft CI workflow when creating new projects.
-* [#4847](https://github.com/leanprover/lean4/pull/4847) adds CLI options to control log levels. The `--log-level=<lv>` controls the minimum log level Lake should output. For instance, `--log-level=error` will only print errors (not warnings or info). Also, adds an analogous `--fail-level` option to control the minimum log level for build failures. The existing `--iofail` and `--wfail` options are respectively equivalent to `--fail-level=info` and `--fail-level=warning`.
-
-* Docs: [#4853](https://github.com/leanprover/lean4/pull/4853)
-
-
-### DevOps/CI
-
-* **Workflows**
-  * [#4531](https://github.com/leanprover/lean4/pull/4531) makes release trigger an update of `release.lean-lang.org`.
-  * [#4598](https://github.com/leanprover/lean4/pull/4598) adjusts `pr-release` to the new `lakefile.lean` syntax.
-  * [#4632](https://github.com/leanprover/lean4/pull/4632) makes `pr-release` use the correct tag name.
-  * [#4638](https://github.com/leanprover/lean4/pull/4638) adds ability to manually trigger nightly release.
-  * [#4640](https://github.com/leanprover/lean4/pull/4640) adds more debugging output for `restart-on-label` CI.
-  * [#4663](https://github.com/leanprover/lean4/pull/4663) bumps up waiting for 10s to 30s for `restart-on-label`.
-  * [#4664](https://github.com/leanprover/lean4/pull/4664) bumps versions for `actions/checkout` and `actions/upload-artifacts`.
-  * [582d6e](https://github.com/leanprover/lean4/commit/582d6e7f7168e0dc0819099edaace27d913b893e) bumps version for `actions/download-artifact`.
-  * [6d9718](https://github.com/leanprover/lean4/commit/6d971827e253a4dc08cda3cf6524d7f37819eb47) adds back dropped `check-stage3`.
-  * [0768ad](https://github.com/leanprover/lean4/commit/0768ad4eb9020af0777587a25a692d181e857c14) adds Jira sync (for FRO).
-  * [#4830](https://github.com/leanprover/lean4/pull/4830) adds support to report CI errors on FRO Zulip.
-  * [#4838](https://github.com/leanprover/lean4/pull/4838) adds trigger for `nightly_bump_toolchain` on mathlib4 upon nightly release.
-  * [abf420](https://github.com/leanprover/lean4/commit/abf4206e9c0fcadf17b6f7933434fd1580175015) fixes msys2.
-  * [#4895](https://github.com/leanprover/lean4/pull/4895) deprecates Nix-based builds and removes interactive components. Users who prefer the flake build should maintain it externally.
-* [#4693](https://github.com/leanprover/lean4/pull/4693), [#4458](https://github.com/leanprover/lean4/pull/4458), and [#4876](https://github.com/leanprover/lean4/pull/4876) update the **release checklist**.
-* [#4669](https://github.com/leanprover/lean4/pull/4669) fixes the "max dynamic symbols" metric per static library.
-* [#4691](https://github.com/leanprover/lean4/pull/4691) improves compatibility of `tests/list_simp` for retesting simp normal forms with Mathlib.
-* [#4806](https://github.com/leanprover/lean4/pull/4806) updates the quickstart guide.
-* [c02aa9](https://github.com/leanprover/lean4/commit/c02aa98c6a08c3a9b05f68039c071085a4ef70d7) documents the **triage team** in the contribution guide.
-
-
-### Breaking changes
-
-* For `@[ext]`-generated `ext` and `ext_iff` lemmas, the `x` and `y` term arguments are now implicit. Furthermore these two lemmas are now protected ([#4543](https://github.com/leanprover/lean4/pull/4543)).
-
-* Now `trace.profiler.useHearbeats` is `trace.profiler.useHeartbeats` ([#4590](https://github.com/leanprover/lean4/pull/4590)).
-
-* A bugfix in the structural recursion code may in some cases break existing code, when a parameter of the type of the recursive argument is bound behind indices of that type. This can usually be fixed by reordering the parameters of the function ([#4672](https://github.com/leanprover/lean4/pull/4672)).
-
-* Now `List.filterMapM` sequences monadic actions left-to-right ([#4820](https://github.com/leanprover/lean4/pull/4820)).
-
-* The effect of the `variable` command on proofs of `theorem`s has been changed. Whether such section variables are accessible in the proof now depends only on the theorem signature and other top-level commands, not on the proof itself. This change ensures that
-  * the statement of a theorem is independent of its proof. In other words, changes in the proof cannot change the theorem statement.
-  * tactics such as `induction` cannot accidentally include a section variable.
-  * the proof can be elaborated in parallel to subsequent declarations in a future version of Lean.
-
-  The effect of `variable`s on the theorem header as well as on other kinds of declarations is unchanged.
-
-  Specifically, section variables are included if they
-  * are directly referenced by the theorem header,
-  * are included via the new `include` command in the current section and not subsequently mentioned in an `omit` statement,
-  * are directly referenced by any variable included by these rules, OR
-  * are instance-implicit variables that reference only variables included by these rules.
-
-  For porting, a new option `deprecated.oldSectionVars` is included to locally switch back to the old behavior.
-
-
+Development in progress.
 
 v4.10.0
 ----------
@@ -863,7 +523,7 @@ v4.9.0
     fixing a pretty printing error in hovers and strengthening the unused variable linter.
   * [dfb496](https://github.com/leanprover/lean4/commit/dfb496a27123c3864571aec72f6278e2dad1cecf) fixes `declareBuiltin` to allow it to be called multiple times per declaration.
   * [#4569](https://github.com/leanprover/lean4/pull/4569) fixes an issue introduced in a merge conflict, where the interrupt exception was swallowed by some `tryCatchRuntimeEx` uses.
-  * [#4584](https://github.com/leanprover/lean4/pull/4584) (backported as [b056a0](https://github.com/leanprover/lean4/commit/b056a0b395bb728512a3f3e83bf9a093059d4301)) adapts kernel interruption to the new cancellation system.
+  * [b056a0](https://github.com/leanprover/lean4/commit/b056a0b395bb728512a3f3e83bf9a093059d4301) adapts kernel interruption to the new cancellation system.
   * Cleanup: [#4112](https://github.com/leanprover/lean4/pull/4112), [#4126](https://github.com/leanprover/lean4/pull/4126), [#4091](https://github.com/leanprover/lean4/pull/4091), [#4139](https://github.com/leanprover/lean4/pull/4139), [#4153](https://github.com/leanprover/lean4/pull/4153).
   * Tests: [030406](https://github.com/leanprover/lean4/commit/03040618b8f9b35b7b757858483e57340900cdc4), [#4133](https://github.com/leanprover/lean4/pull/4133).
 

debug.log

@@ -1 +0,0 @@
-[0829/202002.254:ERROR:crashpad_client_win.cc(868)] not connected

doc/dev/debugging.md

@@ -5,7 +5,7 @@ Some notes on how to debug Lean, which may also be applicable to debugging Lean
 
 ## Tracing
 
-In `CoreM` and derived monads, we use `trace[traceCls] "msg with {interpolations}"` to fill the structured trace viewable with `set_option trace.traceCls true`.
+In `CoreM` and derived monads, we use `trace![traceCls] "msg with {interpolations}"` to fill the structured trace viewable with `set_option trace.traceCls true`.
 New trace classes have to be registered using `registerTraceClass` first.
 
 Notable trace classes:
@@ -22,9 +22,7 @@ Notable trace classes:
 
 In pure contexts or when execution is aborted before the messages are finally printed, one can instead use the term `dbg_trace "msg with {interpolations}"; val` (`;` can also be replaced by a newline), which will print the message to stderr before evaluating `val`. `dbgTraceVal val` can be used as a shorthand for `dbg_trace "{val}"; val`.
 Note that if the return value is not actually used, the trace code is silently dropped as well.
-
-By default, such stderr output is buffered and shown as messages after a command has been elaborated, which is necessary to ensure deterministic ordering of messages under parallelism.
-If Lean aborts the process before it can finish the command or takes too long to do that, using `-DstderrAsMessages=false` avoids this buffering and shows `dbg_trace` output (but not `trace`s or other diagnostics) immediately.
+In the language server, stderr output is buffered and shown as messages after a command has been elaborated, unless the option `server.stderrAsMessages` is deactivated.
 
 ## Debuggers
 

doc/dev/release_checklist.md

@@ -147,31 +147,33 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
   - You can monitor this at `https://github.com/leanprover/lean4/actions/workflows/ci.yml`, looking for the `v4.7.0-rc1` tag.
   - This step can take up to an hour.
 - (GitHub release notes) Once the release appears at https://github.com/leanprover/lean4/releases/
-  - Verify that the release is marked as a prerelease (this should have been done automatically by the CI release job).
-  - In the "previous tag" dropdown, select `v4.6.0`, and click "Generate release notes".
+  - Edit the release notes on Github to select the "Set as a pre-release box".
+  - If release notes have been written already, copy the section of `RELEASES.md` for this version into the Github release notes
+    and use the title "Changes since v4.6.0 (from RELEASES.md)".
+  - Otherwise, in the "previous tag" dropdown, select `v4.6.0`, and click "Generate release notes".
     This will add a list of all the commits since the last stable version.
+    - Delete anything already mentioned in the hand-written release notes above.
     - Delete "update stage0" commits, and anything with a completely inscrutable commit message.
+    - Briefly rearrange the remaining items by category (e.g. `simp`, `lake`, `bug fixes`),
+      but for minor items don't put any work in expanding on commit messages.
+  - (How we want to release notes to look is evolving: please update this section if it looks wrong!)
 - Next, we will move a curated list of downstream repos to the release candidate.
-  - This assumes that for each repository either:
-    * There is already a *reviewed* branch `bump/v4.7.0` containing the required adaptations.
-      The preparation of this branch is beyond the scope of this document.
-    * The repository does not need any changes to move to the new version.
+  - This assumes that there is already a *reviewed* branch `bump/v4.7.0` on each repository
+    containing the required adaptations (or no adaptations are required).
+    The preparation of this branch is beyond the scope of this document.
   - For each of the target repositories:
-    - If the repository does not need any changes (i.e. `bump/v4.7.0` does not exist) then create
-      a new PR updating `lean-toolchain` to `leanprover/lean4:v4.7.0-rc1` and running `lake update`.
-    - Otherwise:
-      - Checkout the `bump/v4.7.0` branch.
-      - Verify that the `lean-toolchain` is set to the nightly from which the release candidate was created.
-      - `git merge origin/master`
-      - Change the `lean-toolchain` to `leanprover/lean4:v4.7.0-rc1`
-      - In `lakefile.lean`, change any dependencies which were using `nightly-testing` or `bump/v4.7.0` branches
-        back to `master` or `main`, and run `lake update` for those dependencies.
-      - Run `lake build` to ensure that dependencies are found (but it's okay to stop it after a moment).
-      - `git commit`
-      - `git push`
-      - Open a PR from `bump/v4.7.0` to `master`, and either merge it yourself after CI, if appropriate,
-        or notify the maintainers that it is ready to go.
-    - Once the PR has been merged, tag `master` with `v4.7.0-rc1` and push this tag.
+    - Checkout the `bump/v4.7.0` branch.
+    - Verify that the `lean-toolchain` is set to the nightly from which the release candidate was created.
+    - `git merge origin/master`
+    - Change the `lean-toolchain` to `leanprover/lean4:v4.7.0-rc1`
+    - In `lakefile.lean`, change any dependencies which were using `nightly-testing` or `bump/v4.7.0` branches
+      back to `master` or `main`, and run `lake update` for those dependencies.
+    - Run `lake build` to ensure that dependencies are found (but it's okay to stop it after a moment).
+    - `git commit`
+    - `git push`
+    - Open a PR from `bump/v4.7.0` to `master`, and either merge it yourself after CI, if appropriate,
+      or notify the maintainers that it is ready to go.
+    - Once this PR has been merged, tag `master` with `v4.7.0-rc1` and push this tag.
   - We do this for the same list of repositories as for stable releases, see above.
     As above, there are dependencies between these, and so the process above is iterative.
     It greatly helps if you can merge the `bump/v4.7.0` PRs yourself!
@@ -192,7 +194,7 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
     finalized release notes from the `releases/v4.6.0` branch.
   - Replaces the "development in progress" in the `v4.7.0` section of `RELEASES.md` with
     ```
-    Release candidate, release notes will be copied from the branch `releases/v4.7.0` once completed.
+    Release candidate, release notes will be copied from `branch releases/v4.7.0` once completed.
     ```
     and inserts the following section before that section:
     ```
@@ -201,8 +203,6 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
     Development in progress.
     ```
   - Removes all the entries from the `./releases_drafts/` folder.
-  - Titled "chore: begin development cycle for v4.8.0"
-
 
 ## Time estimates:
 Slightly longer than the corresponding steps for a stable release.

doc/examples/widgets.lean

@@ -4,18 +4,15 @@ open Lean Widget
 /-!
 # The user-widgets system
 
-Proving and programming are inherently interactive tasks.
-Lots of mathematical objects and data structures are visual in nature.
-*User widgets* let you associate custom interactive UIs
-with sections of a Lean document.
-User widgets are rendered in the Lean infoview.
+Proving and programming are inherently interactive tasks. Lots of mathematical objects and data
+structures are visual in nature. *User widgets* let you associate custom interactive UIs with
+sections of a Lean document. User widgets are rendered in the Lean infoview.
 
 ![Rubik's cube](../images/widgets_rubiks.png)
 
 ## Trying it out
 
-To try it out, type in the following code and place your cursor over the `#widget` command.
-You can also [view this manual entry in the online editor](https://live.lean-lang.org/#url=https%3A%2F%2Fraw.githubusercontent.com%2Fleanprover%2Flean4%2Fmaster%2Fdoc%2Fexamples%2Fwidgets.lean).
+To try it out, simply type in the following code and place your cursor over the `#widget` command.
 -/
 
 @[widget_module]
@@ -24,37 +21,38 @@ def helloWidget : Widget.Module where
     import * as React from 'react';
     export default function(props) {
       const name = props.name || 'world'
-      return React.createElement('p', {}, 'Hello ' + name + '!')
+      return React.createElement('p', {}, name + '!')
     }"
 
 #widget helloWidget
 
 /-!
 If you want to dive into a full sample right away, check out
-[`Rubiks`](https://github.com/leanprover-community/ProofWidgets4/blob/main/ProofWidgets/Demos/Rubiks.lean).
-This sample uses higher-level widget components from the ProofWidgets library.
-
+[`RubiksCube`](https://github.com/leanprover/lean4-samples/blob/main/RubiksCube/).
 Below, we'll explain the system piece by piece.
 
 ⚠️ WARNING: All of the user widget APIs are **unstable** and subject to breaking changes.
 
-## Widget modules and instances
+## Widget sources and instances
 
-A [widget module](https://leanprover-community.github.io/mathlib4_docs/Lean/Widget/UserWidget.html#Lean.Widget.Module)
-is a valid JavaScript [ESModule](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules)
-that can execute in the Lean infoview.
-Most widget modules export a [React component](https://reactjs.org/docs/components-and-props.html)
-as the piece of user interface to be rendered.
-To access React, the module can use `import * as React from 'react'`.
-Our first example of a widget module is `helloWidget` above.
-Widget modules must be registered with the `@[widget_module]` attribute.
+A *widget source* is a valid JavaScript [ESModule](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules)
+which exports a [React component](https://reactjs.org/docs/components-and-props.html). To access
+React, the module must use `import * as React from 'react'`. Our first example of a widget source
+is of course the value of `helloWidget.javascript`.
 
-A [widget instance](https://leanprover-community.github.io/mathlib4_docs/Lean/Widget/Types.html#Lean.Widget.WidgetInstance)
-is then the identifier of a widget module (e.g. `` `helloWidget ``)
-bundled with a value for its props.
-This value is passed as the argument to the React component.
-In our first invocation of `#widget`, we set it to `.null`.
-Try out what happens when you type in:
+We can register a widget source with the `@[widget]` attribute, giving it a friendlier name
+in the `name` field. This is bundled together in a `UserWidgetDefinition`.
+
+A *widget instance* is then the identifier of a `UserWidgetDefinition` (so `` `helloWidget ``,
+not `"Hello"`) associated with a range of positions in the Lean source code. Widget instances
+are stored in the *infotree* in the same manner as other information about the source file
+such as the type of every expression. In our example, the `#widget` command stores a widget instance
+with the entire line as its range. We can think of a widget instance as an instruction for the
+infoview: "when the user places their cursor here, please render the following widget".
+
+Every widget instance also contains a `props : Json` value. This value is passed as an argument
+to the React component. In our first invocation of `#widget`, we set it to `.null`. Try out what
+happens when you type in:
 -/
 
 structure HelloWidgetProps where
@@ -64,37 +62,21 @@ structure HelloWidgetProps where
 #widget helloWidget with { name? := "<your name here>" : HelloWidgetProps }
 
 /-!
-Under the hood, widget instances are associated with a range of positions in the source file.
-Widget instances are stored in the *infotree*
-in the same manner as other information about the source file
-such as the type of every expression.
-In our example, the `#widget` command stores a widget instance
-with the entire line as its range.
-One can think of the infotree entry as an instruction for the infoview:
-"when the user places their cursor here, please render the following widget".
--/
+💡 NOTE: The RPC system presented below does not depend on JavaScript. However the primary use case
+is the web-based infoview in VSCode.
 
-/-!
 ## Querying the Lean server
 
-💡 NOTE: The RPC system presented below does not depend on JavaScript.
-However, the primary use case is the web-based infoview in VSCode.
+Besides enabling us to create cool client-side visualizations, user widgets come with the ability
+to communicate with the Lean server. Thanks to this, they have the same metaprogramming capabilities
+as custom elaborators or the tactic framework. To see this in action, let's implement a `#check`
+command as a web input form. This example assumes some familiarity with React.
 
-Besides enabling us to create cool client-side visualizations,
-user widgets have the ability to communicate with the Lean server.
-Thanks to this, they have the same metaprogramming capabilities
-as custom elaborators or the tactic framework.
-To see this in action, let's implement a `#check` command as a web input form.
-This example assumes some familiarity with React.
-
-The first thing we'll need is to create an *RPC method*.
-Meaning "Remote Procedure Call",this is a Lean function callable from widget code
-(possibly remotely over the internet).
+The first thing we'll need is to create an *RPC method*. Meaning "Remote Procedure Call", this
+is basically a Lean function callable from widget code (possibly remotely over the internet).
 Our method will take in the `name : Name` of a constant in the environment and return its type.
-By convention, we represent the input data as a `structure`.
-Since it will be sent over from JavaScript,
-we need `FromJson` and `ToJson` instnace.
-We'll see why the position field is needed later.
+By convention, we represent the input data as a `structure`. Since it will be sent over from JavaScript,
+we need `FromJson` and `ToJson`. We'll see below why the position field is needed.
 -/
 
 structure GetTypeParams where
@@ -105,33 +87,25 @@ structure GetTypeParams where
   deriving FromJson, ToJson
 
 /-!
-After its argument structure, we define the `getType` method.
-RPCs method execute in the `RequestM` monad and must return a `RequestTask α`
-where `α` is the "actual" return type.
-The `Task` is so that requests can be handled concurrently.
-As a first guess, we'd use `Expr` as `α`.
-However, expressions in general can be large objects
-which depend on an `Environment` and `LocalContext`.
-Thus we cannot directly serialize an `Expr` and send it to JavaScript.
-Instead, there are two options:
+After its arguments, we define the `getType` method. Every RPC method executes in the `RequestM`
+monad and must return a `RequestTask α` where `α` is its "actual" return type. The `Task` is so
+that requests can be handled concurrently. A first guess for `α` might be `Expr`. However,
+expressions in general can be large objects which depend on an `Environment` and `LocalContext`.
+Thus we cannot directly serialize an `Expr` and send it to the widget. Instead, there are two
+options:
+- One is to send a *reference* which points to an object residing on the server. From JavaScript's
+  point of view, references are entirely opaque, but they can be sent back to other RPC methods for
+  further processing.
+- Two is to pretty-print the expression and send its textual representation called `CodeWithInfos`.
+  This representation contains extra data which the infoview uses for interactivity. We take this
+  strategy here.
 
-- One is to send a *reference* which points to an object residing on the server.
-  From JavaScript's point of view, references are entirely opaque,
-  but they can be sent back to other RPC methods for further processing.
-- The other is to pretty-print the expression and send its textual representation called `CodeWithInfos`.
-  This representation contains extra data which the infoview uses for interactivity.
-  We take this strategy here.
-
-RPC methods execute in the context of a file,
-but not of any particular `Environment`,
-so they don't know about the available `def`initions and `theorem`s.
-Thus, we need to pass in a position at which we want to use the local `Environment`.
-This is why we store it in `GetTypeParams`.
-The `withWaitFindSnapAtPos` method launches a concurrent computation
-whose job is to find such an `Environment` for us,
-in the form of a `snap : Snapshot`.
-With this in hand, we can call `MetaM` procedures
-to find out the type of `name` and pretty-print it.
+RPC methods execute in the context of a file, but not any particular `Environment` so they don't
+know about the available `def`initions and `theorem`s. Thus, we need to pass in a position at which
+we want to use the local `Environment`. This is why we store it in `GetTypeParams`. The `withWaitFindSnapAtPos`
+method launches a concurrent computation whose job is to find such an `Environment` and a bit
+more information for us, in the form of a `snap : Snapshot`. With this in hand, we can call
+`MetaM` procedures to find out the type of `name` and pretty-print it.
 -/
 
 open Server RequestM in
@@ -147,22 +121,18 @@ def getType (params : GetTypeParams) : RequestM (RequestTask CodeWithInfos) :=
 /-!
 ## Using infoview components
 
-Now that we have all we need on the server side, let's write the widget module.
-By importing `@leanprover/infoview`, widgets can render UI components used to implement the infoview itself.
-For example, the `<InteractiveCode>` component displays expressions
-with `term : type` tooltips as seen in the goal view.
-We will use it to implement our custom `#check` display.
+Now that we have all we need on the server side, let's write the widget source. By importing
+`@leanprover/infoview`, widgets can render UI components used to implement the infoview itself.
+For example, the `<InteractiveCode>` component displays expressions with `term : type` tooltips
+as seen in the goal view. We will use it to implement our custom `#check` display.
 
 ⚠️ WARNING: Like the other widget APIs, the infoview JS API is **unstable** and subject to breaking changes.
 
-The code below demonstrates useful parts of the API.
-To make RPC method calls, we invoke the `useRpcSession` hook.
-The `useAsync` helper packs the results of an RPC call into an `AsyncState` structure
-which indicates whether the call has resolved successfully,
-has returned an error, or is still in-flight.
-Based on this we either display an `InteractiveCode` component with the result,
-`mapRpcError` the error in order to turn it into a readable message,
-or show a `Loading..` message, respectively.
+The code below demonstrates useful parts of the API. To make RPC method calls, we use the `RpcContext`.
+The `useAsync` helper packs the results of a call into an `AsyncState` structure which indicates
+whether the call has resolved successfully, has returned an error, or is still in-flight. Based
+on this we either display an `InteractiveCode` with the type, `mapRpcError` the error in order
+to turn it into a readable message, or show a `Loading..` message, respectively.
 -/
 
 @[widget_module]
@@ -170,10 +140,10 @@ def checkWidget : Widget.Module where
   javascript := "
 import * as React from 'react';
 const e = React.createElement;
-import { useRpcSession, InteractiveCode, useAsync, mapRpcError } from '@leanprover/infoview';
+import { RpcContext, InteractiveCode, useAsync, mapRpcError } from '@leanprover/infoview';
 
 export default function(props) {
-  const rs = useRpcSession()
+  const rs = React.useContext(RpcContext)
   const [name, setName] = React.useState('getType')
 
   const st = useAsync(() =>
@@ -189,7 +159,7 @@ export default function(props) {
 "
 
 /-!
-We can now try out the widget.
+Finally we can try out the widget.
 -/
 
 #widget checkWidget
@@ -199,31 +169,30 @@ We can now try out the widget.
 
 ## Building widget sources
 
-While typing JavaScript inline is fine for a simple example,
-for real developments we want to use packages from NPM, a proper build system, and JSX.
-Thus, most actual widget sources are built with Lake and NPM.
-They consist of multiple files and may import libraries which don't work as ESModules by default.
-On the other hand a widget module must be a single, self-contained ESModule in the form of a string.
-Readers familiar with web development may already have guessed that to obtain such a string, we need a *bundler*.
-Two popular choices are [`rollup.js`](https://rollupjs.org/guide/en/)
-and [`esbuild`](https://esbuild.github.io/).
-If we go with `rollup.js`, to make a widget work with the infoview we need to:
+While typing JavaScript inline is fine for a simple example, for real developments we want to use
+packages from NPM, a proper build system, and JSX. Thus, most actual widget sources are built with
+Lake and NPM. They consist of multiple files and may import libraries which don't work as ESModules
+by default. On the other hand a widget source must be a single, self-contained ESModule in the form
+of a string. Readers familiar with web development may already have guessed that to obtain such a
+string, we need a *bundler*. Two popular choices are [`rollup.js`](https://rollupjs.org/guide/en/)
+and [`esbuild`](https://esbuild.github.io/). If we go with `rollup.js`, to make a widget work with
+the infoview we need to:
 - Set [`output.format`](https://rollupjs.org/guide/en/#outputformat) to `'es'`.
 - [Externalize](https://rollupjs.org/guide/en/#external) `react`, `react-dom`, `@leanprover/infoview`.
   These libraries are already loaded by the infoview so they should not be bundled.
 
-ProofWidgets provides a working `rollup.js` build configuration in
-[rollup.config.js](https://github.com/leanprover-community/ProofWidgets4/blob/main/widget/rollup.config.js).
+In the RubiksCube sample, we provide a working `rollup.js` build configuration in
+[rollup.config.js](https://github.com/leanprover/lean4-samples/blob/main/RubiksCube/widget/rollup.config.js).
 
 ## Inserting text
 
-Besides making RPC calls, widgets can instruct the editor to carry out certain actions.
-We can insert text, copy text to the clipboard, or highlight a certain location in the document.
-To do this, use the `EditorContext` React context.
-This will return an `EditorConnection`
-whose `api` field contains a number of methods that interact with the editor.
+We can also instruct the editor to insert text, copy text to the clipboard, or
+reveal a certain location in the document.
+To do this, use the `React.useContext(EditorContext)` React context.
+This will return an `EditorConnection` whose `api` field contains a number of methods to
+interact with the text editor.
 
-The full API can be viewed [here](https://github.com/leanprover/vscode-lean4/blob/master/lean4-infoview-api/src/infoviewApi.ts#L52).
+You can see the full API for this [here](https://github.com/leanprover/vscode-lean4/blob/master/lean4-infoview-api/src/infoviewApi.ts#L52)
 -/
 
 @[widget_module]
@@ -243,4 +212,6 @@ export default function(props) {
 }
 "
 
+/-! Finally, we can try this out: -/
+
 #widget insertTextWidget

doc/flake.lock

@@ -18,15 +18,12 @@
       }
     },
     "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
       "locked": {
-        "lastModified": 1710146030,
-        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "lastModified": 1656928814,
+        "narHash": "sha256-RIFfgBuKz6Hp89yRr7+NR5tzIAbn52h8vT6vXkYjZoM=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "rev": "7e2a3b3dfd9af950a856d66b0a7d01e3c18aa249",
         "type": "github"
       },
       "original": {
@@ -38,12 +35,13 @@
     "lean": {
       "inputs": {
         "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs",
-        "nixpkgs-old": "nixpkgs-old"
+        "lean4-mode": "lean4-mode",
+        "nix": "nix",
+        "nixpkgs": "nixpkgs_2"
       },
       "locked": {
         "lastModified": 0,
-        "narHash": "sha256-saRAtQ6VautVXKDw1XH35qwP0KEBKTKZbg/TRa4N9Vw=",
+        "narHash": "sha256-YnYbmG0oou1Q/GE4JbMNb8/yqUVXBPIvcdQQJHBqtPk=",
         "path": "../.",
         "type": "path"
       },
@@ -52,6 +50,22 @@
         "type": "path"
       }
     },
+    "lean4-mode": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1659020985,
+        "narHash": "sha256-+dRaXB7uvN/weSZiKcfSKWhcdJVNg9Vg8k0pJkDNjpc=",
+        "owner": "leanprover",
+        "repo": "lean4-mode",
+        "rev": "37d5c99b7b29c80ab78321edd6773200deb0bca6",
+        "type": "github"
+      },
+      "original": {
+        "owner": "leanprover",
+        "repo": "lean4-mode",
+        "type": "github"
+      }
+    },
     "leanInk": {
       "flake": false,
       "locked": {
@@ -69,6 +83,22 @@
         "type": "github"
       }
     },
+    "lowdown-src": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1633514407,
+        "narHash": "sha256-Dw32tiMjdK9t3ETl5fzGrutQTzh2rufgZV4A/BbxuD4=",
+        "owner": "kristapsdz",
+        "repo": "lowdown",
+        "rev": "d2c2b44ff6c27b936ec27358a2653caaef8f73b8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "kristapsdz",
+        "repo": "lowdown",
+        "type": "github"
+      }
+    },
     "mdBook": {
       "flake": false,
       "locked": {
@@ -85,13 +115,65 @@
         "type": "github"
       }
     },
+    "nix": {
+      "inputs": {
+        "lowdown-src": "lowdown-src",
+        "nixpkgs": "nixpkgs",
+        "nixpkgs-regression": "nixpkgs-regression"
+      },
+      "locked": {
+        "lastModified": 1657097207,
+        "narHash": "sha256-SmeGmjWM3fEed3kQjqIAO8VpGmkC2sL1aPE7kKpK650=",
+        "owner": "NixOS",
+        "repo": "nix",
+        "rev": "f6316b49a0c37172bca87ede6ea8144d7d89832f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nix",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1710889954,
-        "narHash": "sha256-Pr6F5Pmd7JnNEMHHmspZ0qVqIBVxyZ13ik1pJtm2QXk=",
+        "lastModified": 1653988320,
+        "narHash": "sha256-ZaqFFsSDipZ6KVqriwM34T739+KLYJvNmCWzErjAg7c=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "7872526e9c5332274ea5932a0c3270d6e4724f3b",
+        "rev": "2fa57ed190fd6c7c746319444f34b5917666e5c1",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-22.05-small",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-regression": {
+      "locked": {
+        "lastModified": 1643052045,
+        "narHash": "sha256-uGJ0VXIhWKGXxkeNnq4TvV3CIOkUJ3PAoLZ3HMzNVMw=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1657208011,
+        "narHash": "sha256-BlIFwopAykvdy1DYayEkj6ZZdkn+cVgPNX98QVLc0jM=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "2770cc0b1e8faa0e20eb2c6aea64c256a706d4f2",
         "type": "github"
       },
       "original": {
@@ -101,23 +183,6 @@
         "type": "github"
       }
     },
-    "nixpkgs-old": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1581379743,
-        "narHash": "sha256-i1XCn9rKuLjvCdu2UeXKzGLF6IuQePQKFt4hEKRU5oc=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "34c7eb7545d155cc5b6f499b23a7cb1c96ab4d59",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-19.03",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
     "root": {
       "inputs": {
         "alectryon": "alectryon",
@@ -129,21 +194,6 @@
         "leanInk": "leanInk",
         "mdBook": "mdBook"
       }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
     }
   },
   "root": "root",

doc/flake.nix

@@ -17,7 +17,7 @@
   };
 
   outputs = inputs@{ self, ... }: inputs.flake-utils.lib.eachDefaultSystem (system:
-    with inputs.lean.packages.${system}.deprecated; with nixpkgs;
+    with inputs.lean.packages.${system}; with nixpkgs;
     let
       doc-src = lib.sourceByRegex ../. ["doc.*" "tests(/lean(/beginEndAsMacro.lean)?)?"];
     in {
@@ -44,6 +44,21 @@
           mdbook build -d $out
         '';
       };
+      # We use a separate derivation instead of `checkPhase` so we can push it but not `doc` to the binary cache
+      test = stdenv.mkDerivation {
+        name ="lean-doc-test";
+        src = doc-src;
+        buildInputs = [ lean-mdbook stage1.Lean.lean-package strace ];
+        patchPhase = ''
+          cd doc
+          patchShebangs test
+        '';
+        buildPhase = ''
+          mdbook test
+          touch $out
+        '';
+        dontInstall = true;
+      };
       leanInk = (buildLeanPackage {
         name = "Main";
         src = inputs.leanInk;

doc/make/index.md

@@ -8,7 +8,6 @@ Requirements
 - C++14 compatible compiler
 - [CMake](http://www.cmake.org)
 - [GMP (GNU multiprecision library)](http://gmplib.org/)
-- [LibUV](https://libuv.org/)
 
 Platform-Specific Setup
 -----------------------
@@ -28,9 +27,9 @@ Setting up a basic parallelized release build:
 git clone https://github.com/leanprover/lean4
 cd lean4
 cmake --preset release
-make -C build/release -j$(nproc || sysctl -n hw.logicalcpu)
+make -C build/release -j$(nproc)  # see below for macOS
 ```
-You can replace `$(nproc || sysctl -n hw.logicalcpu)` with the desired parallelism amount.
+You can replace `$(nproc)`, which is not available on macOS and some alternative shells, with the desired parallelism amount.
 
 The above commands will compile the Lean library and binaries into the
 `stage1` subfolder; see below for details.

doc/make/msys2.md

@@ -25,7 +25,7 @@ MSYS2 has a package management system, [pacman][pacman], which is used in Arch L
 Here are the commands to install all dependencies needed to compile Lean on your machine.
 
 ```bash
-pacman -S make python mingw-w64-x86_64-cmake mingw-w64-x86_64-clang mingw-w64-x86_64-ccache mingw-w64-x86_64-libuv mingw-w64-x86_64-gmp git unzip diffutils binutils
+pacman -S make python mingw-w64-x86_64-cmake mingw-w64-x86_64-clang mingw-w64-x86_64-ccache git unzip diffutils binutils
 ```
 
 You should now be able to run these commands:
@@ -64,7 +64,6 @@ they are installed in your MSYS setup:
 - libgcc_s_seh-1.dll
 - libstdc++-6.dll
 - libgmp-10.dll
-- libuv-1.dll
 - libwinpthread-1.dll
 
 The following linux command will do that:

doc/make/osx-10.9.md

@@ -32,16 +32,15 @@ following to use `g++`.
 cmake -DCMAKE_CXX_COMPILER=g++ ...
 ```
 
-## Required Packages: CMake, GMP, libuv
+## Required Packages: CMake, GMP
 
 ```bash
 brew install cmake
 brew install gmp
-brew install libuv
 ```
 
 ## Recommended Packages: CCache
 
 ```bash
 brew install ccache
-```
+```

doc/make/ubuntu.md

@@ -8,5 +8,5 @@ follow the [generic build instructions](index.md).
 ## Basic packages
 
 ```bash
-sudo apt-get install git libgmp-dev libuv1-dev cmake ccache clang
+sudo apt-get install git libgmp-dev cmake ccache clang
 ```

doc/quickstart.md

@@ -5,11 +5,11 @@ See [Setup](./setup.md) for supported platforms and other ways to set up Lean 4.
 
 1. Install [VS Code](https://code.visualstudio.com/).
 
-1. Launch VS Code and install the `Lean 4` extension by clicking on the 'Extensions' sidebar entry and searching for 'Lean 4'.
+1. Launch VS Code and install the `lean4` extension by clicking on the "Extensions" sidebar entry and searching for "lean4".
 
    ![installing the vscode-lean4 extension](images/code-ext.png)
 
-1. Open the Lean 4 setup guide by creating a new text file using 'File > New Text File' (`Ctrl+N` / `Cmd+N`), clicking on the ∀-symbol in the top right and selecting 'Documentation… > Docs: Show Setup Guide'.
+1. Open the Lean 4 setup guide by creating a new text file using "File > New Text File" (`Ctrl+N` / `Cmd+N`), clicking on the ∀-symbol in the top right and selecting "Documentation… > Docs: Show Setup Guide".
 
    ![show setup guide](images/show-setup-guide.png)
 

flake.lock

@@ -1,5 +1,21 @@
 {
   "nodes": {
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1673956053,
+        "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
     "flake-utils": {
       "inputs": {
         "systems": "systems"
@@ -18,35 +34,72 @@
         "type": "github"
       }
     },
-    "nixpkgs": {
+    "lean4-mode": {
+      "flake": false,
       "locked": {
-        "lastModified": 1710889954,
-        "narHash": "sha256-Pr6F5Pmd7JnNEMHHmspZ0qVqIBVxyZ13ik1pJtm2QXk=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "7872526e9c5332274ea5932a0c3270d6e4724f3b",
+        "lastModified": 1709737301,
+        "narHash": "sha256-uT9JN2kLNKJK9c/S/WxLjiHmwijq49EgLb+gJUSDpz0=",
+        "owner": "leanprover",
+        "repo": "lean4-mode",
+        "rev": "f1f24c15134dee3754b82c9d9924866fe6bc6b9f",
         "type": "github"
       },
       "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
+        "owner": "leanprover",
+        "repo": "lean4-mode",
         "type": "github"
       }
     },
-    "nixpkgs-cadical": {
+    "libgit2": {
+      "flake": false,
       "locked": {
-        "lastModified": 1722221733,
-        "narHash": "sha256-sga9SrrPb+pQJxG1ttJfMPheZvDOxApFfwXCFO0H9xw=",
+        "lastModified": 1697646580,
+        "narHash": "sha256-oX4Z3S9WtJlwvj0uH9HlYcWv+x1hqp8mhXl7HsLu2f0=",
+        "owner": "libgit2",
+        "repo": "libgit2",
+        "rev": "45fd9ed7ae1a9b74b957ef4f337bc3c8b3df01b5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "libgit2",
+        "repo": "libgit2",
+        "type": "github"
+      }
+    },
+    "nix": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "libgit2": "libgit2",
+        "nixpkgs": "nixpkgs",
+        "nixpkgs-regression": "nixpkgs-regression"
+      },
+      "locked": {
+        "lastModified": 1711102798,
+        "narHash": "sha256-CXOIJr8byjolqG7eqCLa+Wfi7rah62VmLoqSXENaZnw=",
         "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "12bf09802d77264e441f48e25459c10c93eada2e",
+        "repo": "nix",
+        "rev": "a22328066416650471c3545b0b138669ea212ab4",
         "type": "github"
       },
       "original": {
+        "owner": "NixOS",
+        "repo": "nix",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1709083642,
+        "narHash": "sha256-7kkJQd4rZ+vFrzWu8sTRtta5D1kBG0LSRYAfhtmMlSo=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "12bf09802d77264e441f48e25459c10c93eada2e",
+        "rev": "b550fe4b4776908ac2a861124307045f8e717c8e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "release-23.11",
+        "repo": "nixpkgs",
         "type": "github"
       }
     },
@@ -67,11 +120,44 @@
         "type": "github"
       }
     },
+    "nixpkgs-regression": {
+      "locked": {
+        "lastModified": 1643052045,
+        "narHash": "sha256-uGJ0VXIhWKGXxkeNnq4TvV3CIOkUJ3PAoLZ3HMzNVMw=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1710889954,
+        "narHash": "sha256-Pr6F5Pmd7JnNEMHHmspZ0qVqIBVxyZ13ik1pJtm2QXk=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "7872526e9c5332274ea5932a0c3270d6e4724f3b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
         "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs",
-        "nixpkgs-cadical": "nixpkgs-cadical",
+        "lean4-mode": "lean4-mode",
+        "nix": "nix",
+        "nixpkgs": "nixpkgs_2",
         "nixpkgs-old": "nixpkgs-old"
       }
     },

flake.nix

@@ -1,36 +1,48 @@
 {
-  description = "Lean development flake. Not intended for end users.";
+  description = "Lean interactive theorem prover";
 
   inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
   # old nixpkgs used for portable release with older glibc (2.27)
   inputs.nixpkgs-old.url = "github:NixOS/nixpkgs/nixos-19.03";
   inputs.nixpkgs-old.flake = false;
-  # for cadical 1.9.5; sync with CMakeLists.txt
-  inputs.nixpkgs-cadical.url = "github:NixOS/nixpkgs/12bf09802d77264e441f48e25459c10c93eada2e";
   inputs.flake-utils.url = "github:numtide/flake-utils";
+  inputs.nix.url = "github:NixOS/nix";
+  inputs.lean4-mode = {
+    url = "github:leanprover/lean4-mode";
+    flake = false;
+  };
+  # used *only* by `stage0-from-input` below
+  #inputs.lean-stage0 = {
+  #  url = github:leanprover/lean4;
+  #  inputs.nixpkgs.follows = "nixpkgs";
+  #  inputs.flake-utils.follows = "flake-utils";
+  #  inputs.nix.follows = "nix";
+  #  inputs.lean4-mode.follows = "lean4-mode";
+  #};
 
-  outputs = { self, nixpkgs, nixpkgs-old, flake-utils, ... }@inputs: flake-utils.lib.eachDefaultSystem (system:
+  outputs = { self, nixpkgs, nixpkgs-old, flake-utils, nix, lean4-mode, ... }@inputs: flake-utils.lib.eachDefaultSystem (system:
     let
-      pkgs = import nixpkgs { inherit system; };
+      pkgs = import nixpkgs {
+        inherit system;
+        # for `vscode-with-extensions`
+        config.allowUnfree = true;
+      };
       # An old nixpkgs for creating releases with an old glibc
       pkgsDist-old = import nixpkgs-old { inherit system; };
       # An old nixpkgs for creating releases with an old glibc
       pkgsDist-old-aarch = import nixpkgs-old { localSystem.config = "aarch64-unknown-linux-gnu"; };
-      pkgsCadical = import inputs.nixpkgs-cadical { inherit system; };
-      cadical = if pkgs.stdenv.isLinux then
-        # use statically-linked cadical on Linux to avoid glibc versioning troubles
-        pkgsCadical.pkgsStatic.cadical.overrideAttrs { doCheck = false; }
-      else pkgsCadical.cadical;
 
-      lean-packages = pkgs.callPackage (./nix/packages.nix) { src = ./.; };
+      lean-packages = pkgs.callPackage (./nix/packages.nix) { src = ./.; inherit nix lean4-mode; };
 
       devShellWithDist = pkgsDist: pkgs.mkShell.override {
           stdenv = pkgs.overrideCC pkgs.stdenv lean-packages.llvmPackages.clang;
         } ({
           buildInputs = with pkgs; [
-            cmake gmp libuv ccache cadical
+            cmake gmp ccache
             lean-packages.llvmPackages.llvm  # llvm-symbolizer for asan/lsan
             gdb
+            # TODO: only add when proven to not affect the flakification
+            #pkgs.python3
             tree  # for CI
           ];
           # https://github.com/NixOS/nixpkgs/issues/60919
@@ -39,7 +51,6 @@
           CTEST_OUTPUT_ON_FAILURE = 1;
         } // pkgs.lib.optionalAttrs pkgs.stdenv.isLinux {
           GMP = pkgsDist.gmp.override { withStatic = true; };
-          LIBUV = pkgsDist.libuv.overrideAttrs (attrs: { configureFlags = ["--enable-static"]; });
           GLIBC = pkgsDist.glibc;
           GLIBC_DEV = pkgsDist.glibc.dev;
           GCC_LIB = pkgsDist.gcc.cc.lib;
@@ -47,15 +58,41 @@
           GDB = pkgsDist.gdb;
         });
     in {
-      packages = {
-        # to be removed when Nix CI is not needed anymore
-        inherit (lean-packages) cacheRoots test update-stage0-commit ciShell;
-        deprecated = lean-packages;
+      packages = lean-packages // rec {
+        debug = lean-packages.override { debug = true; };
+        stage0debug = lean-packages.override { stage0debug = true; };
+        asan = lean-packages.override { extraCMakeFlags = [ "-DLEAN_EXTRA_CXX_FLAGS=-fsanitize=address" "-DLEANC_EXTRA_FLAGS=-fsanitize=address" "-DSMALL_ALLOCATOR=OFF" "-DSYMBOLIC=OFF" ]; };
+        asandebug = asan.override { debug = true; };
+        tsan = lean-packages.override {
+          extraCMakeFlags = [ "-DLEAN_EXTRA_CXX_FLAGS=-fsanitize=thread" "-DLEANC_EXTRA_FLAGS=-fsanitize=thread" "-DCOMPRESSED_OBJECT_HEADER=OFF" ];
+          stage0 = (lean-packages.override {
+            # Compressed headers currently trigger data race reports in tsan.
+            # Turn them off for stage 0 as well so stage 1 can read its own stdlib.
+            extraCMakeFlags = [ "-DCOMPRESSED_OBJECT_HEADER=OFF" ];
+          }).stage1;
+        };
+        tsandebug = tsan.override { debug = true; };
+        stage0-from-input = lean-packages.override {
+          stage0 = pkgs.writeShellScriptBin "lean" ''
+            exec ${inputs.lean-stage0.packages.${system}.lean}/bin/lean -Dinterpreter.prefer_native=false "$@"
+          '';
+        };
+        inherit self;
       };
+      defaultPackage = lean-packages.lean-all;
 
       # The default development shell for working on lean itself
       devShells.default = devShellWithDist pkgs;
       devShells.oldGlibc = devShellWithDist pkgsDist-old;
       devShells.oldGlibcAArch = devShellWithDist pkgsDist-old-aarch;
-    });
+
+      checks.lean = lean-packages.test;
+    }) // rec {
+      templates.pkg = {
+        path = ./nix/templates/pkg;
+        description = "A custom Lean package";
+      };
+
+      defaultTemplate = templates.pkg;
+    };
 }

nix/bootstrap.nix

@@ -1,13 +1,13 @@
 { src, debug ? false, stage0debug ? false, extraCMakeFlags ? [],
-  stdenv, lib, cmake, gmp, libuv, cadical, git, gnumake, bash, buildLeanPackage, writeShellScriptBin, runCommand, symlinkJoin, lndir, perl, gnused, darwin, llvmPackages, linkFarmFromDrvs,
+  stdenv, lib, cmake, gmp, git, gnumake, bash, buildLeanPackage, writeShellScriptBin, runCommand, symlinkJoin, lndir, perl, gnused, darwin, llvmPackages, linkFarmFromDrvs,
   ... } @ args:
 with builtins;
-lib.warn "The Nix-based build is deprecated" rec {
+rec {
   inherit stdenv;
   sourceByRegex = p: rs: lib.sourceByRegex p (map (r: "(/src/)?${r}") rs);
   buildCMake = args: stdenv.mkDerivation ({
     nativeBuildInputs = [ cmake ];
-    buildInputs = [ gmp libuv llvmPackages.llvm ];
+    buildInputs = [ gmp llvmPackages.llvm ];
     # https://github.com/NixOS/nixpkgs/issues/60919
     hardeningDisable = [ "all" ];
     dontStrip = (args.debug or debug);
@@ -17,7 +17,7 @@ lib.warn "The Nix-based build is deprecated" rec {
     '';
   } // args // {
     src = args.realSrc or (sourceByRegex args.src [ "[a-z].*" "CMakeLists\.txt" ]);
-    cmakeFlags = (args.cmakeFlags or [ "-DSTAGE=1" "-DPREV_STAGE=./faux-prev-stage" "-DUSE_GITHASH=OFF" "-DCADICAL=${cadical}/bin/cadical" ]) ++ (args.extraCMakeFlags or extraCMakeFlags) ++ lib.optional (args.debug or debug) [ "-DCMAKE_BUILD_TYPE=Debug" ];
+    cmakeFlags = (args.cmakeFlags or [ "-DSTAGE=1" "-DPREV_STAGE=./faux-prev-stage" "-DUSE_GITHASH=OFF" ]) ++ (args.extraCMakeFlags or extraCMakeFlags) ++ lib.optional (args.debug or debug) [ "-DCMAKE_BUILD_TYPE=Debug" ];
     preConfigure = args.preConfigure or "" + ''
       # ignore absence of submodule
       sed -i 's!lake/Lake.lean!!' CMakeLists.txt
@@ -26,7 +26,11 @@ lib.warn "The Nix-based build is deprecated" rec {
   lean-bin-tools-unwrapped = buildCMake {
     name = "lean-bin-tools";
     outputs = [ "out" "leanc_src" ];
-    realSrc = sourceByRegex (src + "/src") [ "CMakeLists\.txt" "[a-z].*" ".*\.in" "Leanc\.lean" ];
+    realSrc = sourceByRegex (src + "/src") [ "CMakeLists\.txt" "cmake.*" "bin.*" "include.*" ".*\.in" "Leanc\.lean" ];
+    preConfigure = ''
+      touch empty.cpp
+      sed -i 's/add_subdirectory.*//;s/set(LEAN_OBJS.*/set(LEAN_OBJS empty.cpp)/' CMakeLists.txt
+    '';
     dontBuild = true;
     installPhase = ''
       mkdir $out $leanc_src
@@ -41,10 +45,11 @@ lib.warn "The Nix-based build is deprecated" rec {
   leancpp = buildCMake {
     name = "leancpp";
     src = src + "/src";
-    buildFlags = [ "leancpp" "leanrt" "leanrt_initial-exec" "leanshell" "leanmain" ];
+    buildFlags = [ "leancpp" "leanrt" "leanrt_initial-exec" "shell" ];
     installPhase = ''
       mkdir -p $out
       mv lib/ $out/
+      mv shell/CMakeFiles/shell.dir/lean.cpp.o $out/lib
       mv runtime/libleanrt_initial-exec.a $out/lib
     '';
   };
@@ -95,13 +100,12 @@ lib.warn "The Nix-based build is deprecated" rec {
       Lean = attachSharedLib leanshared Lean' // { allExternalDeps = [ Std ]; };
       Lake = build {
         name = "Lake";
-        sharedLibName = "Lake_shared";
         src = src + "/src/lake";
         deps = [ Init Lean ];
       };
       Lake-Main = build {
-        name = "LakeMain";
-        roots = [{ glob = "one"; mod = "LakeMain"; }];
+        name = "Lake.Main";
+        roots = [ "Lake.Main" ];
         executableName = "lake";
         deps = [ Lake ];
         linkFlags = lib.optional stdenv.isLinux "-rdynamic";
@@ -118,15 +122,12 @@ lib.warn "The Nix-based build is deprecated" rec {
         touch empty.c
         ${stdenv.cc}/bin/cc -shared -o $out/$libName empty.c
       '';
-      leanshared_1 = runCommand "leanshared_1" { buildInputs = [ stdenv.cc ]; libName = "leanshared_1${stdenv.hostPlatform.extensions.sharedLibrary}"; } ''
-        mkdir $out
-        touch empty.c
-        ${stdenv.cc}/bin/cc -shared -o $out/$libName empty.c
-      '';
       leanshared = runCommand "leanshared" { buildInputs = [ stdenv.cc ]; libName = "libleanshared${stdenv.hostPlatform.extensions.sharedLibrary}"; } ''
         mkdir $out
         LEAN_CC=${stdenv.cc}/bin/cc ${lean-bin-tools-unwrapped}/bin/leanc -shared ${lib.optionalString stdenv.isLinux "-Wl,-Bsymbolic"} \
-          -Wl,--whole-archive ${leancpp}/lib/temp/libleanshell.a -lInit -lStd -lLean -lleancpp ${leancpp}/lib/libleanrt_initial-exec.a -Wl,--no-whole-archive -lstdc++ \
+          ${if stdenv.isDarwin
+            then "-Wl,-force_load,${Init.staticLib}/libInit.a -Wl,-force_load,${Std.staticLib}/libStd.a -Wl,-force_load,${Lean.staticLib}/libLean.a -Wl,-force_load,${leancpp}/lib/lean/libleancpp.a ${leancpp}/lib/libleanrt_initial-exec.a -lc++"
+            else "-Wl,--whole-archive -lInit -lStd -lLean -lleancpp ${leancpp}/lib/libleanrt_initial-exec.a -Wl,--no-whole-archive -lstdc++"} \
           -lm ${stdlibLinkFlags} \
           $(${llvmPackages.libllvm.dev}/bin/llvm-config --ldflags --libs) \
           -o $out/$libName
@@ -134,18 +135,18 @@ lib.warn "The Nix-based build is deprecated" rec {
       mods = foldl' (mods: pkg: mods // pkg.mods) {} stdlib;
       print-paths = Lean.makePrintPathsFor [] mods;
       leanc = writeShellScriptBin "leanc" ''
-        LEAN_CC=${stdenv.cc}/bin/cc ${Leanc.executable}/bin/leanc -I${lean-bin-tools-unwrapped}/include ${stdlibLinkFlags} -L${libInit_shared} -L${leanshared_1} -L${leanshared} -L${Lake.sharedLib} "$@"
+        LEAN_CC=${stdenv.cc}/bin/cc ${Leanc.executable}/bin/leanc -I${lean-bin-tools-unwrapped}/include ${stdlibLinkFlags} -L${libInit_shared} -L${leanshared} "$@"
       '';
       lean = runCommand "lean" { buildInputs = lib.optional stdenv.isDarwin darwin.cctools; } ''
         mkdir -p $out/bin
-        ${leanc}/bin/leanc ${leancpp}/lib/temp/libleanmain.a ${libInit_shared}/* ${leanshared_1}/* ${leanshared}/* -o $out/bin/lean
+        ${leanc}/bin/leanc ${leancpp}/lib/lean.cpp.o ${libInit_shared}/* ${leanshared}/* -o $out/bin/lean
       '';
       # derivation following the directory layout of the "basic" setup, mostly useful for running tests
       lean-all = stdenv.mkDerivation {
         name = "lean-${desc}";
         buildCommand = ''
           mkdir -p $out/bin $out/lib/lean
-          ln -sf ${leancpp}/lib/lean/* ${lib.concatMapStringsSep " " (l: "${l.modRoot}/* ${l.staticLib}/*") (lib.reverseList stdlib)} ${libInit_shared}/* ${leanshared_1}/* ${leanshared}/* ${Lake.sharedLib}/* $out/lib/lean/
+          ln -sf ${leancpp}/lib/lean/* ${lib.concatMapStringsSep " " (l: "${l.modRoot}/* ${l.staticLib}/*") (lib.reverseList stdlib)} ${libInit_shared}/* ${leanshared}/* $out/lib/lean/
           # put everything in a single final derivation so `IO.appDir` references work
           cp ${lean}/bin/lean ${leanc}/bin/leanc ${Lake-Main.executable}/bin/lake $out/bin
           # NOTE: `lndir` will not override existing `bin/leanc`
@@ -159,7 +160,7 @@ lib.warn "The Nix-based build is deprecated" rec {
       test = buildCMake {
         name = "lean-test-${desc}";
         realSrc = lib.sourceByRegex src [ "src.*" "tests.*" ];
-        buildInputs = [ gmp libuv perl git cadical ];
+        buildInputs = [ gmp perl git ];
         preConfigure = ''
           cd src
         '';
@@ -170,7 +171,7 @@ lib.warn "The Nix-based build is deprecated" rec {
           ln -sf ${lean-all}/* .
         '';
         buildPhase = ''
-          ctest --output-junit test-results.xml --output-on-failure -E 'leancomptest_(doc_example|foreign)|leanlaketest_reverse-ffi' -j$NIX_BUILD_CORES
+          ctest --output-junit test-results.xml --output-on-failure -E 'leancomptest_(doc_example|foreign)' -j$NIX_BUILD_CORES
         '';
         installPhase = ''
           mkdir $out
@@ -178,7 +179,7 @@ lib.warn "The Nix-based build is deprecated" rec {
         '';
       };
       update-stage0 =
-        let cTree = symlinkJoin { name = "cs"; paths = map (lib: lib.cTree) (stdlib ++ [Lake-Main]); }; in
+        let cTree = symlinkJoin { name = "cs"; paths = map (lib: lib.cTree) stdlib; }; in
         writeShellScriptBin "update-stage0" ''
           CSRCS=${cTree} CP_C_PARAMS="--dereference --no-preserve=all" ${src + "/script/lib/update-stage0"}
         '';

nix/buildLeanPackage.nix

@@ -1,5 +1,5 @@
 { lean, lean-leanDeps ? lean, lean-final ? lean, leanc,
-  stdenv, lib, coreutils, gnused, writeShellScriptBin, bash, substituteAll, symlinkJoin, linkFarmFromDrvs,
+  stdenv, lib, coreutils, gnused, writeShellScriptBin, bash, lean-emacs, lean-vscode, nix, substituteAll, symlinkJoin, linkFarmFromDrvs,
   runCommand, darwin, mkShell, ... }:
 let lean-final' = lean-final; in
 lib.makeOverridable (
@@ -30,7 +30,7 @@ lib.makeOverridable (
   pluginDeps ? [],
   # `overrideAttrs` for `buildMod`
   overrideBuildModAttrs ? null,
-  debug ? false, leanFlags ? [], leancFlags ? [], linkFlags ? [], executableName ? lib.toLower name, libName ? name, sharedLibName ? libName,
+  debug ? false, leanFlags ? [], leancFlags ? [], linkFlags ? [], executableName ? lib.toLower name, libName ? name,
   srcTarget ? "..#stage0", srcArgs ? "(\${args[*]})", lean-final ? lean-final' }@args:
 with builtins; let
   # "Init.Core" ~> "Init/Core"
@@ -197,6 +197,19 @@ with builtins; let
              then map (m: m.module) header.imports
              else abort "errors while parsing imports of ${mod}:\n${lib.concatStringsSep "\n" header.errors}";
     in mkMod mod (map (dep: if modDepsMap ? ${dep} then modCandidates.${dep} else externalModMap.${dep}) deps)) modDepsMap;
+  makeEmacsWrapper = name: emacs: lean: writeShellScriptBin name ''
+    ${emacs} --eval "(progn (setq lean4-rootdir \"${lean}\"))" "$@"
+  '';
+  makeVSCodeWrapper = name: lean: writeShellScriptBin name ''
+    PATH=${lean}/bin:$PATH ${lean-vscode}/bin/code "$@"
+  '';
+  printPaths = deps: writeShellScriptBin "print-paths" ''
+    echo '${toJSON {
+      oleanPath = [(depRoot "print-paths" deps)];
+      srcPath = ["."] ++ map (dep: dep.src) allExternalDeps;
+      loadDynlibPaths = map pathOfSharedLib (loadDynlibsOfDeps deps);
+    }}'
+  '';
   expandGlob = g:
     if typeOf g == "string" then [g]
     else if g.glob == "one" then [g.mod]
@@ -233,7 +246,7 @@ in rec {
   cTree     = symlinkJoin { name = "${name}-cTree"; paths = map (mod: mod.c) (attrValues mods); };
   oTree     = symlinkJoin { name = "${name}-oTree"; paths = (attrValues objects); };
   iTree     = symlinkJoin { name = "${name}-iTree"; paths = map (mod: mod.ilean) (attrValues mods); };
-  sharedLib = mkSharedLib "lib${sharedLibName}" ''
+  sharedLib = mkSharedLib "lib${libName}" ''
     ${if stdenv.isDarwin then "-Wl,-force_load,${staticLib}/lib${libName}.a" else "-Wl,--whole-archive ${staticLib}/lib${libName}.a -Wl,--no-whole-archive"} \
     ${lib.concatStringsSep " " (map (d: "${d.sharedLib}/*") deps)}'';
   executable = lib.makeOverridable ({ withSharedStdlib ? true }: let
@@ -244,4 +257,48 @@ in rec {
         -o $out/bin/${executableName} \
         ${lib.concatStringsSep " " allLinkFlags}
     '') {};
+
+  lean-package = writeShellScriptBin "lean" ''
+    LEAN_PATH=${modRoot}:$LEAN_PATH LEAN_SRC_PATH=$LEAN_SRC_PATH:${src} exec ${lean-final}/bin/lean "$@"
+  '';
+  emacs-package = makeEmacsWrapper "emacs-package" lean-package;
+  vscode-package = makeVSCodeWrapper "vscode-package" lean-package;
+
+  link-ilean = writeShellScriptBin "link-ilean" ''
+    dest=''${1:-.}
+    mkdir -p $dest/build/lib
+    ln -sf ${iTree}/* $dest/build/lib
+  '';
+
+  makePrintPathsFor = deps: mods: printPaths deps // mapAttrs (_: mod: makePrintPathsFor (deps ++ [mod]) mods) mods;
+  print-paths = makePrintPathsFor [] (mods' // externalModMap);
+  # `lean` wrapper that dynamically runs Nix for the actual `lean` executable so the same editor can be
+  # used for multiple projects/after upgrading the `lean` input/for editing both stage 1 and the tests
+  lean-bin-dev = substituteAll {
+    name = "lean";
+    dir = "bin";
+    src = ./lean-dev.in;
+    isExecutable = true;
+    srcRoot = fullSrc;  # use root flake.nix in case of Lean repo
+    inherit bash nix srcTarget srcArgs;
+  };
+  lake-dev = substituteAll {
+    name = "lake";
+    dir = "bin";
+    src = ./lake-dev.in;
+    isExecutable = true;
+    srcRoot = fullSrc;  # use root flake.nix in case of Lean repo
+    inherit bash nix srcTarget srcArgs;
+  };
+  lean-dev = symlinkJoin { name = "lean-dev"; paths = [ lean-bin-dev lake-dev ]; };
+  emacs-dev = makeEmacsWrapper "emacs-dev" "${lean-emacs}/bin/emacs" lean-dev;
+  emacs-path-dev = makeEmacsWrapper "emacs-path-dev" "emacs" lean-dev;
+  vscode-dev = makeVSCodeWrapper "vscode-dev" lean-dev;
+
+  devShell = mkShell {
+    buildInputs = [ nix ];
+    shellHook = ''
+      export LEAN_SRC_PATH="${srcPath}"
+    '';
+  };
 })

nix/packages.nix

@@ -1,6 +1,9 @@
-{ src, pkgs, ... } @ args:
+{ src, pkgs, nix, ... } @ args:
 with pkgs;
 let
+  nix-pinned = writeShellScriptBin "nix" ''
+    ${nix.packages.${system}.default}/bin/nix --experimental-features 'nix-command flakes' --extra-substituters https://lean4.cachix.org/ --option warn-dirty false "$@"
+  '';
   # https://github.com/NixOS/nixpkgs/issues/130963
   llvmPackages = if stdenv.isDarwin then llvmPackages_11 else llvmPackages_15;
   cc = (ccacheWrapper.override rec {
@@ -39,9 +42,40 @@ let
     inherit (lean) stdenv;
     lean = lean.stage1;
     inherit (lean.stage1) leanc;
+    inherit lean-emacs lean-vscode;
+    nix = nix-pinned;
   }));
+  lean4-mode = emacsPackages.melpaBuild {
+    pname = "lean4-mode";
+    version = "1";
+    commit = "1";
+    src = args.lean4-mode;
+    packageRequires = with pkgs.emacsPackages.melpaPackages; [ dash f flycheck magit-section lsp-mode s ];
+    recipe = pkgs.writeText "recipe" ''
+      (lean4-mode
+       :repo "leanprover/lean4-mode"
+       :fetcher github
+       :files ("*.el" "data"))
+    '';
+  };
+  lean-emacs = emacsWithPackages [ lean4-mode ];
+  # updating might be nicer by building from source from a flake input, but this is good enough for now
+  vscode-lean4 = vscode-utils.extensionFromVscodeMarketplace {
+      name = "lean4";
+      publisher = "leanprover";
+      version = "0.0.63";
+      sha256 = "sha256-kjEex7L0F2P4pMdXi4NIZ1y59ywJVubqDqsoYagZNkI=";
+  };
+  lean-vscode = vscode-with-extensions.override {
+    vscodeExtensions = [ vscode-lean4 ];
+  };
 in {
-  inherit cc buildLeanPackage llvmPackages;
+  inherit cc lean4-mode buildLeanPackage llvmPackages vscode-lean4;
+  lean = lean.stage1;
+  stage0print-paths = lean.stage1.Lean.print-paths;
+  HEAD-as-stage0 = (lean.stage1.Lean.overrideArgs { srcTarget = "..#stage0-from-input.stage0"; srcArgs = "(--override-input lean-stage0 ..\?rev=$(git rev-parse HEAD) -- -Dinterpreter.prefer_native=false \"$@\")"; });
+  HEAD-as-stage1 = (lean.stage1.Lean.overrideArgs { srcTarget = "..\?rev=$(git rev-parse HEAD)#stage0"; });
+  nix = nix-pinned;
   nixpkgs = pkgs;
   ciShell = writeShellScriptBin "ciShell" ''
     set -o pipefail
@@ -49,4 +83,5 @@ in {
     # prefix lines with cumulative and individual execution time
     "$@" |& ts -i "(%.S)]" | ts -s "[%M:%S"
   '';
-} // lean.stage1
+  vscode = lean-vscode;
+} // lean.stage1.Lean // lean.stage1 // lean

releases_drafts/hashmap.md

@@ -1,3 +0,0 @@
-* The `Lean` module has switched from `Lean.HashMap` and `Lean.HashSet` to `Std.HashMap` and `Std.HashSet`. `Lean.HashMap` and `Lean.HashSet` are now deprecated and will be removed in a future release. Users of `Lean` APIs that interact with hash maps, for example `Lean.Environment.const2ModIdx`, might encounter minor breakage due to the following breaking changes from `Lean.HashMap` to `Std.HashMap`:
-    * query functions use the term `get` instead of `find`,
-    * the notation `map[key]` no longer returns an optional value but expects a proof that the key is present in the map instead. The previous behavior is available via the `map[key]?` notation.

releases_drafts/libuv.md

@@ -1 +0,0 @@
-* #4963 [LibUV](https://libuv.org/) is now required to build Lean. This change only affects developers who compile Lean themselves instead of obtaining toolchains via `elan`. We have updated the official build instructions with information on how to obtain LibUV on our supported platforms.

releases_drafts/mutualStructural.md

@@ -0,0 +1,65 @@
+* Structural recursion can now be explicitly requested using
+  ```
+  termination_by structural x
+  ```
+  in analogy to the existing `termination_by x` syntax that causes well-founded recursion to be used.
+  (#4542)
+
+* The `termination_by?` syntax no longer forces the use of well-founded recursion, and when structural
+  recursion is inferred, will print the result using the `termination_by` syntax.
+
+* Mutual structural recursion is supported now. This supports both mutual recursion over a non-mutual
+  data type, as well as recursion over mutual or nested data types:
+
+  ```lean
+  mutual
+  def Even : Nat → Prop
+    | 0 => True
+    | n+1 => Odd n
+
+  def Odd : Nat → Prop
+    | 0 => False
+    | n+1 => Even n
+  end
+
+  mutual
+  inductive A
+  | other : B → A
+  | empty
+  inductive B
+  | other : A → B
+  | empty
+  end
+
+  mutual
+  def A.size : A → Nat
+  | .other b => b.size + 1
+  | .empty => 0
+
+  def B.size : B → Nat
+  | .other a => a.size + 1
+  | .empty => 0
+  end
+
+  inductive Tree where | node : List Tree → Tree
+
+  mutual
+  def Tree.size : Tree → Nat
+  | node ts => Tree.list_size ts
+
+  def Tree.list_size : List Tree → Nat
+  | [] => 0
+  | t::ts => Tree.size t + Tree.list_size ts
+  end
+  ```
+
+  Functional induction principles are generated for these functions as well (`A.size.induct`, `A.size.mutual_induct`).
+
+  Nested structural recursion is still not supported.
+
+  PRs #4639, #4715, #4642, #4656, #4684, #4715, #4728, #4575, #4731, #4658, #4734, #4738, #4718,
+  #4733, #4787, #4788, #4789, #4807, #4772
+
+* A bugfix in the structural recursion code may in some cases break existing code, when a parameter
+  of the type of the recursive argument is bound behind indices of that type. This can usually be
+  fixed by reordering the parameters of the function (PR #4672)

script/lib/update-stage0

@@ -18,7 +18,7 @@ done
 
 # special handling for Lake files due to its nested directory
 # copy the README to ensure the `stage0/src/lake` directory is comitted
-for f in $(git ls-files 'src/lake/Lake/*' src/lake/Lake.lean src/lake/LakeMain.lean src/lake/README.md ':!:src/lakefile.toml'); do
+for f in $(git ls-files 'src/lake/Lake/*' src/lake/Lake.lean src/lake/README.md ':!:src/lakefile.toml'); do
     if [[ $f == *.lean ]]; then
         f=${f#src/lake}
         f=${f%.lean}.c

script/prepare-llvm-linux.sh

@@ -38,7 +38,7 @@ $CP $GLIBC/lib/*crt* llvm/lib/
 $CP $GLIBC/lib/*crt* stage1/lib/
 # runtime
 (cd llvm; $CP --parents lib/clang/*/lib/*/{clang_rt.*.o,libclang_rt.builtins*} ../stage1)
-$CP llvm/lib/*/lib{c++,c++abi,unwind}.* $GMP/lib/libgmp.a $LIBUV/lib/libuv.a stage1/lib/
+$CP llvm/lib/*/lib{c++,c++abi,unwind}.* $GMP/lib/libgmp.a stage1/lib/
 # LLVM 15 appears to ship the dependencies in 'llvm/lib/<target-triple>/' and 'llvm/include/<target-triple>/'
 # but clang-15 that we use to compile is linked against 'llvm/lib/' and 'llvm/include'
 # https://github.com/llvm/llvm-project/issues/54955
@@ -62,8 +62,8 @@ fi
 # use `-nostdinc` to make sure headers are not visible by default (in particular, not to `#include_next` in the clang headers),
 # but do not change sysroot so users can still link against system libs
 echo -n " -DLEANC_INTERNAL_FLAGS='-nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang"
-echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -L ROOT/lib/glibc ROOT/lib/glibc/libc_nonshared.a -Wl,--as-needed -Wl,-Bstatic -lgmp -lunwind -luv -Wl,-Bdynamic -Wl,--no-as-needed -fuse-ld=lld'"
+echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -L ROOT/lib/glibc ROOT/lib/glibc/libc_nonshared.a -Wl,--as-needed -Wl,-Bstatic -lgmp -lunwind -Wl,-Bdynamic -Wl,--no-as-needed -fuse-ld=lld'"
 # when not using the above flags, link GMP dynamically/as usual
-echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-Wl,--as-needed -lgmp -luv -Wl,--no-as-needed'"
+echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-Wl,--as-needed -lgmp -Wl,--no-as-needed'"
 # do not set `LEAN_CC` for tests
 echo -n " -DLEAN_TEST_VARS=''"

script/prepare-llvm-macos.sh

@@ -9,7 +9,6 @@ set -uxo pipefail
 # use full LLVM release for compiling C++ code, but subset for compiling C code and distribution
 
 GMP=${GMP:-$(brew --prefix)}
-LIBUV=${LIBUV:-$(brew --prefix)}
 
 [[ -d llvm ]] || (mkdir llvm; gtar xf $1 --strip-components 1 --directory llvm)
 [[ -d llvm-host ]] || if [[ "$#" -gt 1 ]]; then
@@ -47,9 +46,8 @@ echo -n " -DLEAN_EXTRA_CXX_FLAGS='${EXTRA_FLAGS:-}'"
 if [[ -L llvm-host ]]; then
   echo -n " -DCMAKE_C_COMPILER=$PWD/stage1/bin/clang"
   gcp $GMP/lib/libgmp.a stage1/lib/
-  gcp $LIBUV/lib/libuv.a stage1/lib/
   echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -L ROOT/lib/libc -fuse-ld=lld'"
-  echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-lgmp -luv'"
+  echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-lgmp'"
 else
   echo -n " -DCMAKE_C_COMPILER=$PWD/llvm-host/bin/clang -DLEANC_OPTS='--sysroot $PWD/stage1 -resource-dir $PWD/stage1/lib/clang/15.0.1 ${EXTRA_FLAGS:-}'"
   echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -L ROOT/lib/libc -fuse-ld=lld'"

script/prepare-llvm-mingw.sh

@@ -31,15 +31,15 @@ cp /clang64/lib/{crtbegin,crtend,crt2,dllcrt2}.o stage1/lib/
 # runtime
 (cd llvm; cp --parents lib/clang/*/lib/*/libclang_rt.builtins* ../stage1)
 # further dependencies
-cp /clang64/lib/lib{m,bcrypt,mingw32,moldname,mingwex,msvcrt,pthread,advapi32,shell32,user32,kernel32,ucrtbase}.* /clang64/lib/libgmp.a /clang64/lib/libuv.a llvm/lib/lib{c++,c++abi,unwind}.a stage1/lib/
+cp /clang64/lib/lib{m,bcrypt,mingw32,moldname,mingwex,msvcrt,pthread,advapi32,shell32,user32,kernel32,ucrtbase}.* /clang64/lib/libgmp.a llvm/lib/lib{c++,c++abi,unwind}.a stage1/lib/
 echo -n " -DLEAN_STANDALONE=ON"
 echo -n " -DCMAKE_C_COMPILER=$PWD/stage1/bin/clang.exe -DCMAKE_C_COMPILER_WORKS=1 -DCMAKE_CXX_COMPILER=$PWD/llvm/bin/clang++.exe -DCMAKE_CXX_COMPILER_WORKS=1 -DLEAN_CXX_STDLIB='-lc++ -lc++abi'"
 echo -n " -DSTAGE0_CMAKE_C_COMPILER=clang -DSTAGE0_CMAKE_CXX_COMPILER=clang++"
 echo -n " -DLEAN_EXTRA_CXX_FLAGS='--sysroot $PWD/llvm -idirafter /clang64/include/'"
 echo -n " -DLEANC_INTERNAL_FLAGS='--sysroot ROOT -nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang.exe"
-echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -static-libgcc -Wl,-Bstatic -lgmp -luv -lunwind -Wl,-Bdynamic -fuse-ld=lld'"
+echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -static-libgcc -Wl,-Bstatic -lgmp -lunwind -Wl,-Bdynamic -fuse-ld=lld'"
 # when not using the above flags, link GMP dynamically/as usual
-echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-lgmp -luv -lucrtbase'"
+echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-lgmp -lucrtbase'"
 # do not set `LEAN_CC` for tests
 echo -n " -DAUTO_THREAD_FINALIZATION=OFF -DSTAGE0_AUTO_THREAD_FINALIZATION=OFF"
 echo -n " -DLEAN_TEST_VARS=''"

src/CMakeLists.txt

@@ -10,7 +10,7 @@ endif()
 include(ExternalProject)
 project(LEAN CXX C)
 set(LEAN_VERSION_MAJOR 4)
-set(LEAN_VERSION_MINOR 12)
+set(LEAN_VERSION_MINOR 11)
 set(LEAN_VERSION_PATCH 0)
 set(LEAN_VERSION_IS_RELEASE 0)  # This number is 1 in the release revision, and 0 otherwise.
 set(LEAN_SPECIAL_VERSION_DESC "" CACHE STRING "Additional version description like 'nightly-2018-03-11'")
@@ -243,15 +243,6 @@ if("${USE_GMP}" MATCHES "ON")
   endif()
 endif()
 
-if(NOT "${CMAKE_SYSTEM_NAME}" MATCHES "Emscripten")
-  # LibUV
-  find_package(LibUV 1.0.0 REQUIRED)
-  include_directories(${LIBUV_INCLUDE_DIR})
-endif()
-if(NOT LEAN_STANDALONE)
-  string(APPEND LEAN_EXTRA_LINKER_FLAGS " ${LIBUV_LIBRARIES}")
-endif()
-
 # ccache
 if(CCACHE AND NOT CMAKE_CXX_COMPILER_LAUNCHER AND NOT CMAKE_C_COMPILER_LAUNCHER)
   find_program(CCACHE_PATH ccache)
@@ -333,12 +324,7 @@ if(NOT LEAN_STANDALONE)
 endif()
 
 # flags for user binaries = flags for toolchain binaries + Lake
-set(LEANC_STATIC_LINKER_FLAGS " ${TOOLCHAIN_STATIC_LINKER_FLAGS} -lLake")
-if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-  set(LEANC_SHARED_LINKER_FLAGS " ${TOOLCHAIN_SHARED_LINKER_FLAGS} -Wl,--as-needed -lLake_shared -Wl,--no-as-needed")
-else()
-  set(LEANC_SHARED_LINKER_FLAGS " ${TOOLCHAIN_SHARED_LINKER_FLAGS} -lLake_shared")
-endif()
+string(APPEND LEANC_STATIC_LINKER_FLAGS " ${TOOLCHAIN_STATIC_LINKER_FLAGS} -lLake")
 
 if (LLVM)
   string(APPEND LEANSHARED_LINKER_FLAGS " -L${LLVM_CONFIG_LIBDIR} ${LLVM_CONFIG_LDFLAGS} ${LLVM_CONFIG_LIBS} ${LLVM_CONFIG_SYSTEM_LIBS}")
@@ -383,20 +369,15 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
   string(APPEND CMAKE_CXX_FLAGS " -fPIC -ftls-model=initial-exec")
   string(APPEND LEANC_EXTRA_FLAGS " -fPIC")
   string(APPEND TOOLCHAIN_SHARED_LINKER_FLAGS " -Wl,-rpath=\\$$ORIGIN/..:\\$$ORIGIN")
-  string(APPEND LAKESHARED_LINKER_FLAGS " -Wl,--whole-archive ${CMAKE_BINARY_DIR}/lib/temp/libLake.a.export -Wl,--no-whole-archive")
   string(APPEND CMAKE_EXE_LINKER_FLAGS " -Wl,-rpath=\\\$ORIGIN/../lib:\\\$ORIGIN/../lib/lean")
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   string(APPEND CMAKE_CXX_FLAGS " -ftls-model=initial-exec")
   string(APPEND INIT_SHARED_LINKER_FLAGS " -install_name @rpath/libInit_shared.dylib")
-  string(APPEND LEANSHARED_1_LINKER_FLAGS " -install_name @rpath/libleanshared_1.dylib")
   string(APPEND LEANSHARED_LINKER_FLAGS " -install_name @rpath/libleanshared.dylib")
-  string(APPEND LAKESHARED_LINKER_FLAGS " -Wl,-force_load,${CMAKE_BINARY_DIR}/lib/temp/libLake.a.export -install_name @rpath/libLake_shared.dylib")
   string(APPEND CMAKE_EXE_LINKER_FLAGS " -Wl,-rpath,@executable_path/../lib -Wl,-rpath,@executable_path/../lib/lean")
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
   string(APPEND CMAKE_CXX_FLAGS " -fPIC")
   string(APPEND LEANC_EXTRA_FLAGS " -fPIC")
-elseif(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-  string(APPEND LAKESHARED_LINKER_FLAGS " -Wl,--out-implib,${CMAKE_BINARY_DIR}/lib/lean/libLake_shared.dll.a -Wl,--whole-archive ${CMAKE_BINARY_DIR}/lib/temp/libLake.a.export -Wl,--no-whole-archive")
 endif()
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
@@ -421,8 +402,8 @@ endif()
 # executable or `leanshared`, plugins would try to look them up at load time (even though they
 # are already loaded) and probably fail unless we set up LD_LIBRARY_PATH.
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-  # import libraries created by the stdlib.make targets
-  string(APPEND LEANC_SHARED_LINKER_FLAGS " -lInit_shared -lleanshared_1 -lleanshared")
+  # import library created by the `leanshared` target
+  string(APPEND LEANC_SHARED_LINKER_FLAGS " -lInit_shared -lleanshared")
 elseif("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
   string(APPEND LEANC_SHARED_LINKER_FLAGS " -Wl,-undefined,dynamic_lookup")
 endif()
@@ -479,22 +460,6 @@ if(CMAKE_OSX_SYSROOT AND NOT LEAN_STANDALONE)
   string(APPEND LEANC_EXTRA_FLAGS " ${CMAKE_CXX_SYSROOT_FLAG}${CMAKE_OSX_SYSROOT}")
 endif()
 
-add_subdirectory(initialize)
-add_subdirectory(shell)
-# to be included in `leanshared` but not the smaller `leanshared_1` (as it would pull
-# in the world)
-add_library(leaninitialize STATIC $<TARGET_OBJECTS:initialize>)
-set_target_properties(leaninitialize PROPERTIES
-  ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib/temp
-  OUTPUT_NAME leaninitialize)
-add_library(leanshell STATIC util/shell.cpp)
-set_target_properties(leanshell PROPERTIES
-  ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib/temp
-  OUTPUT_NAME leanshell)
-if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-  string(APPEND CMAKE_EXE_LINKER_FLAGS " -Wl,--whole-archive -lleanmanifest -Wl,--no-whole-archive")
-endif()
-
 if(${STAGE} GREATER 1)
   # reuse C++ parts, which don't change
   add_library(leanrt_initial-exec STATIC IMPORTED)
@@ -503,17 +468,13 @@ if(${STAGE} GREATER 1)
   add_library(leanrt STATIC IMPORTED)
   set_target_properties(leanrt PROPERTIES
     IMPORTED_LOCATION "${CMAKE_BINARY_DIR}/lib/lean/libleanrt.a")
-  add_library(leancpp_1 STATIC IMPORTED)
-  set_target_properties(leancpp_1 PROPERTIES
-    IMPORTED_LOCATION "${CMAKE_BINARY_DIR}/lib/temp/libleancpp_1.a")
   add_library(leancpp STATIC IMPORTED)
   set_target_properties(leancpp PROPERTIES
     IMPORTED_LOCATION "${CMAKE_BINARY_DIR}/lib/lean/libleancpp.a")
   add_custom_target(copy-leancpp
     COMMAND cmake -E copy_if_different "${PREV_STAGE}/runtime/libleanrt_initial-exec.a" "${CMAKE_BINARY_DIR}/runtime/libleanrt_initial-exec.a"
     COMMAND cmake -E copy_if_different "${PREV_STAGE}/lib/lean/libleanrt.a" "${CMAKE_BINARY_DIR}/lib/lean/libleanrt.a"
-    COMMAND cmake -E copy_if_different "${PREV_STAGE}/lib/lean/libleancpp.a" "${CMAKE_BINARY_DIR}/lib/lean/libleancpp.a"
-    COMMAND cmake -E copy_if_different "${PREV_STAGE}/lib/temp/libleancpp_1.a" "${CMAKE_BINARY_DIR}/lib/temp/libleancpp_1.a")
+    COMMAND cmake -E copy_if_different "${PREV_STAGE}/lib/lean/libleancpp.a" "${CMAKE_BINARY_DIR}/lib/lean/libleancpp.a")
   add_dependencies(leancpp copy-leancpp)
   if(LLVM)
       add_custom_target(copy-lean-h-bc
@@ -533,23 +494,14 @@ else()
   set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:constructions>)
   add_subdirectory(library/compiler)
   set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:compiler>)
+  add_subdirectory(initialize)
+  set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:initialize>)
 
-  # leancpp without `initialize` (see `leaninitialize` above)
-  add_library(leancpp_1 STATIC ${LEAN_OBJS})
-  set_target_properties(leancpp_1 PROPERTIES
-    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib/temp
-    OUTPUT_NAME leancpp_1)
-  add_library(leancpp STATIC ${LEAN_OBJS} $<TARGET_OBJECTS:initialize>)
+  add_library(leancpp STATIC ${LEAN_OBJS})
   set_target_properties(leancpp PROPERTIES
     OUTPUT_NAME leancpp)
 endif()
 
-if((${STAGE} GREATER 0) AND CADICAL)
-  add_custom_target(copy-cadical
-    COMMAND cmake -E copy_if_different "${CADICAL}" "${CMAKE_BINARY_DIR}/bin/cadical${CMAKE_EXECUTABLE_SUFFIX}")
-  add_dependencies(leancpp copy-cadical)
-endif()
-
 # MSYS2 bash usually handles Windows paths relatively well, but not when putting them in the PATH
 string(REGEX REPLACE "^([a-zA-Z]):" "/\\1" LEAN_BIN "${CMAKE_BINARY_DIR}/bin")
 
@@ -557,12 +509,25 @@ string(REGEX REPLACE "^([a-zA-Z]):" "/\\1" LEAN_BIN "${CMAKE_BINARY_DIR}/bin")
 # (also looks nicer in the build log)
 file(RELATIVE_PATH LIB ${LEAN_SOURCE_DIR} ${CMAKE_BINARY_DIR}/lib)
 
+# set up libInit_shared only on Windows; see also stdlib.make.in
+if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+  set(INIT_SHARED_LINKER_FLAGS "-Wl,--whole-archive ${CMAKE_BINARY_DIR}/lib/temp/libInit.a.export ${CMAKE_BINARY_DIR}/lib/temp/libStd.a.export ${CMAKE_BINARY_DIR}/runtime/libleanrt_initial-exec.a -Wl,--no-whole-archive -Wl,--out-implib,${CMAKE_BINARY_DIR}/lib/lean/libInit_shared.dll.a")
+endif()
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+  set(LEANSHARED_LINKER_FLAGS "-Wl,-force_load,${CMAKE_BINARY_DIR}/lib/lean/libInit.a -Wl,-force_load,${CMAKE_BINARY_DIR}/lib/lean/libStd.a -Wl,-force_load,${CMAKE_BINARY_DIR}/lib/lean/libLean.a -Wl,-force_load,${CMAKE_BINARY_DIR}/lib/lean/libleancpp.a ${CMAKE_BINARY_DIR}/runtime/libleanrt_initial-exec.a ${LEANSHARED_LINKER_FLAGS}")
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+  set(LEANSHARED_LINKER_FLAGS "-Wl,--whole-archive ${CMAKE_BINARY_DIR}/lib/temp/libLean.a.export -lleancpp -Wl,--no-whole-archive -lInit_shared -Wl,--out-implib,${CMAKE_BINARY_DIR}/lib/lean/libleanshared.dll.a")
+else()
+  set(LEANSHARED_LINKER_FLAGS "-Wl,--whole-archive -lInit -lStd -lLean -lleancpp -Wl,--no-whole-archive ${CMAKE_BINARY_DIR}/runtime/libleanrt_initial-exec.a ${LEANSHARED_LINKER_FLAGS}")
+endif()
+
 if (${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
   # We do not use dynamic linking via leanshared for Emscripten to keep things
   # simple. (And we are not interested in `Lake` anyway.) To use dynamic
   # linking, we would probably have to set MAIN_MODULE=2 on `leanshared`,
   # SIDE_MODULE=2 on `lean`, and set CMAKE_SHARED_LIBRARY_SUFFIX to ".js".
-  string(APPEND LEAN_EXE_LINKER_FLAGS " ${LIB}/temp/libleanshell.a ${TOOLCHAIN_STATIC_LINKER_FLAGS} ${EMSCRIPTEN_SETTINGS} -lnodefs.js -s EXIT_RUNTIME=1 -s MAIN_MODULE=1 -s LINKABLE=1 -s EXPORT_ALL=1")
+  string(APPEND LEAN_EXE_LINKER_FLAGS " ${TOOLCHAIN_STATIC_LINKER_FLAGS} ${EMSCRIPTEN_SETTINGS} -lnodefs.js -s EXIT_RUNTIME=1 -s MAIN_MODULE=1 -s LINKABLE=1 -s EXPORT_ALL=1")
 endif()
 
 # Build the compiler using the bootstrapped C sources for stage0, and use
@@ -596,13 +561,8 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
   )
   add_custom_target(leanshared ALL
     DEPENDS Init_shared leancpp
-    COMMAND touch ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libleanshared_1${CMAKE_SHARED_LIBRARY_SUFFIX}
     COMMAND touch ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libleanshared${CMAKE_SHARED_LIBRARY_SUFFIX}
   )
-  add_custom_target(lake_shared ALL
-    DEPENDS leanshared
-    COMMAND touch ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libLake_shared${CMAKE_SHARED_LIBRARY_SUFFIX}
-  )
 else()
   add_custom_target(Init_shared ALL
     WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
@@ -612,29 +572,19 @@ else()
 
   add_custom_target(leanshared ALL
     WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
-    DEPENDS Init_shared leancpp_1 leancpp leanshell leaninitialize
+    DEPENDS Init_shared leancpp
     COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make leanshared
     VERBATIM)
 
-  string(APPEND CMAKE_EXE_LINKER_FLAGS " -lInit_shared -lleanshared_1 -lleanshared")
+  string(APPEND CMAKE_EXE_LINKER_FLAGS " -lInit_shared -lleanshared")
 endif()
 
 if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-  add_custom_target(lake_lib ALL
+  add_custom_target(lake ALL
     WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
     DEPENDS leanshared
     COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make Lake
     VERBATIM)
-  add_custom_target(lake_shared ALL
-    WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
-    DEPENDS lake_lib
-    COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make libLake_shared
-    VERBATIM)
-  add_custom_target(lake ALL
-    WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
-    DEPENDS lake_shared
-    COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make lake
-    VERBATIM)
 endif()
 
 if(PREV_STAGE)
@@ -663,9 +613,7 @@ file(COPY ${LEAN_SOURCE_DIR}/bin/leanmake DESTINATION ${CMAKE_BINARY_DIR}/bin)
 
 install(DIRECTORY "${CMAKE_BINARY_DIR}/bin/" USE_SOURCE_PERMISSIONS DESTINATION bin)
 
-if (${STAGE} GREATER 0 AND CADICAL)
-  install(PROGRAMS "${CADICAL}" DESTINATION bin)
-endif()
+add_subdirectory(shell)
 
 add_custom_target(clean-stdlib
   COMMAND rm -rf "${CMAKE_BINARY_DIR}/lib" || true)

src/Init/ByCases.lean

@@ -37,13 +37,27 @@ theorem apply_ite (f : α → β) (P : Prop) [Decidable P] (x y : α) :
     f (ite P x y) = ite P (f x) (f y) :=
   apply_dite f P (fun _ => x) (fun _ => y)
 
+@[simp] theorem dite_eq_left_iff {P : Prop} [Decidable P] {B : ¬ P → α} :
+    dite P (fun _ => a) B = a ↔ ∀ h, B h = a := by
+  by_cases P <;> simp [*, forall_prop_of_true, forall_prop_of_false]
+
+@[simp] theorem dite_eq_right_iff {P : Prop} [Decidable P] {A : P → α} :
+    (dite P A fun _ => b) = b ↔ ∀ h, A h = b := by
+  by_cases P <;> simp [*, forall_prop_of_true, forall_prop_of_false]
+
+@[simp] theorem ite_eq_left_iff {P : Prop} [Decidable P] : ite P a b = a ↔ ¬P → b = a :=
+  dite_eq_left_iff
+
+@[simp] theorem ite_eq_right_iff {P : Prop} [Decidable P] : ite P a b = b ↔ P → a = b :=
+  dite_eq_right_iff
+
 /-- A `dite` whose results do not actually depend on the condition may be reduced to an `ite`. -/
 @[simp] theorem dite_eq_ite [Decidable P] : (dite P (fun _ => a) fun _ => b) = ite P a b := rfl
 
 -- We don't mark this as `simp` as it is already handled by `ite_eq_right_iff`.
 theorem ite_some_none_eq_none [Decidable P] :
     (if P then some x else none) = none ↔ ¬ P := by
-  simp only [ite_eq_right_iff, reduceCtorEq]
+  simp only [ite_eq_right_iff]
   rfl
 
 @[simp] theorem ite_some_none_eq_some [Decidable P] :

src/Init/Classical.lean

@@ -134,30 +134,6 @@ The left-to-right direction, double negation elimination (DNE),
 is classically true but not constructively. -/
 @[simp] theorem not_not : ¬¬a ↔ a := Decidable.not_not
 
-/-- Transfer decidability of `¬ p` to decidability of `p`. -/
--- This can not be an instance as it would be tried everywhere.
-def decidable_of_decidable_not (p : Prop) [h : Decidable (¬ p)] : Decidable p :=
-  match h with
-  | isFalse h => isTrue (Classical.not_not.mp h)
-  | isTrue h => isFalse h
-
-attribute [local instance] decidable_of_decidable_not in
-/-- Negation of the condition `P : Prop` in a `dite` is the same as swapping the branches. -/
-@[simp low] protected theorem dite_not [hn : Decidable (¬p)] (x : ¬p → α) (y : ¬¬p → α) :
-    dite (¬p) x y = dite p (fun h => y (not_not_intro h)) x := by
-  cases hn <;> rename_i g
-  · simp [not_not.mp g]
-  · simp [g]
-
-attribute [local instance] decidable_of_decidable_not in
-/-- Negation of the condition `P : Prop` in a `ite` is the same as swapping the branches. -/
-@[simp low] protected theorem ite_not (p : Prop) [Decidable (¬ p)] (x y : α) : ite (¬p) x y = ite p y x :=
-  dite_not (fun _ => x) (fun _ => y)
-
-attribute [local instance] decidable_of_decidable_not in
-@[simp low] protected theorem decide_not (p : Prop) [Decidable (¬ p)] : decide (¬p) = !decide p :=
-  byCases (fun h : p => by simp_all) (fun h => by simp_all)
-
 @[simp low] theorem not_forall {p : α → Prop} : (¬∀ x, p x) ↔ ∃ x, ¬p x := Decidable.not_forall
 
 theorem not_forall_not {p : α → Prop} : (¬∀ x, ¬p x) ↔ ∃ x, p x := Decidable.not_forall_not
@@ -184,7 +160,7 @@ theorem not_iff : ¬(a ↔ b) ↔ (¬a ↔ b) := Decidable.not_iff
 
 @[simp] theorem not_imp : ¬(a → b) ↔ a ∧ ¬b := Decidable.not_imp_iff_and_not
 
-@[simp] theorem imp_and_neg_imp_iff (p : Prop) {q : Prop} : (p → q) ∧ (¬p → q) ↔ q :=
+@[simp] theorem imp_and_neg_imp_iff (p q : Prop) : (p → q) ∧ (¬p → q) ↔ q :=
   Iff.intro (fun (a : _ ∧ _) => (Classical.em p).rec a.left a.right)
             (fun a => And.intro (fun _ => a) (fun _ => a))
 

src/Init/Control/Basic.lean

@@ -28,7 +28,7 @@ Important instances include
 * `Option`, where `failure := none` and `<|>` returns the left-most `some`.
 * Parser combinators typically provide an `Applicative` instance for error-handling and
   backtracking.
-
+  
 Error recovery and state can interact subtly. For example, the implementation of `Alternative` for `OptionT (StateT σ Id)` keeps modifications made to the state while recovering from failure, while `StateT σ (OptionT Id)` discards them.
 -/
 -- NB: List instance is in mathlib. Once upstreamed, add

src/Init/Control/ExceptCps.lean

@@ -34,7 +34,7 @@ instance : Monad (ExceptCpsT ε m) where
   bind x f := fun _ k₁ k₂ => x _ (fun a => f a _ k₁ k₂) k₂
 
 instance : LawfulMonad (ExceptCpsT σ m) := by
-  refine LawfulMonad.mk' _ ?_ ?_ ?_ <;> intros <;> rfl
+  refine' { .. } <;> intros <;> rfl
 
 instance : MonadExceptOf ε (ExceptCpsT ε m) where
   throw e  := fun _ _ k => k e

src/Init/Control/Lawful/Basic.lean

@@ -153,7 +153,7 @@ namespace Id
 @[simp] theorem pure_eq (a : α) : (pure a : Id α) = a := rfl
 
 instance : LawfulMonad Id := by
-  refine LawfulMonad.mk' _ ?_ ?_ ?_ <;> intros <;> rfl
+  refine' { .. } <;> intros <;> rfl
 
 end Id
 

src/Init/Control/StateCps.lean

@@ -35,7 +35,7 @@ instance : Monad (StateCpsT σ m) where
   bind x f := fun δ s k => x δ s fun a s => f a δ s k
 
 instance : LawfulMonad (StateCpsT σ m) := by
-  refine LawfulMonad.mk' _ ?_ ?_ ?_ <;> intros <;> rfl
+  refine' { .. } <;> intros <;> rfl
 
 @[always_inline]
 instance : MonadStateOf σ (StateCpsT σ m) where

src/Init/Conv.lean

@@ -97,18 +97,11 @@ Users should prefer `unfold` for unfolding definitions. -/
 syntax (name := delta) "delta" (ppSpace colGt ident)+ : conv
 
 /--
-* `unfold id` unfolds all occurrences of definition `id` in the target.
+* `unfold foo` unfolds all occurrences of `foo` in the target.
 * `unfold id1 id2 ...` is equivalent to `unfold id1; unfold id2; ...`.
-
-Definitions can be either global or local definitions.
-
-For non-recursive global definitions, this tactic is identical to `delta`.
-For recursive global definitions, it uses the "unfolding lemma" `id.eq_def`,
-which is generated for each recursive definition, to unfold according to the recursive definition given by the user.
-Only one level of unfolding is performed, in contrast to `simp only [id]`, which unfolds definition `id` recursively.
-
-This is the `conv` version of the `unfold` tactic.
--/
+Like the `unfold` tactic, this uses equational lemmas for the chosen definition
+to rewrite the target. For recursive definitions,
+only one layer of unfolding is performed. -/
 syntax (name := unfold) "unfold" (ppSpace colGt ident)+ : conv
 
 /--

src/Init/Core.lean

@@ -36,17 +36,6 @@ and `flip (·<·)` is the greater-than relation.
 
 theorem Function.comp_def {α β δ} (f : β → δ) (g : α → β) : f ∘ g = fun x => f (g x) := rfl
 
-@[simp] theorem Function.const_comp {f : α → β} {c : γ} :
-    (Function.const β c ∘ f) = Function.const α c := by
-  rfl
-@[simp] theorem Function.comp_const {f : β → γ} {b : β} :
-    (f ∘ Function.const α b) = Function.const α (f b) := by
-  rfl
-@[simp] theorem Function.true_comp {f : α → β} : ((fun _ => true) ∘ f) = fun _ => true := by
-  rfl
-@[simp] theorem Function.false_comp {f : α → β} : ((fun _ => false) ∘ f) = fun _ => false := by
-  rfl
-
 attribute [simp] namedPattern
 
 /--
@@ -165,23 +154,9 @@ inductive PSum (α : Sort u) (β : Sort v) where
 
 @[inherit_doc] infixr:30 " ⊕' " => PSum
 
-/--
-`PSum α β` is inhabited if `α` is inhabited.
-This is not an instance to avoid non-canonical instances.
--/
-@[reducible] def  PSum.inhabitedLeft {α β} [Inhabited α] : Inhabited (PSum α β) := ⟨PSum.inl default⟩
+instance {α β} [Inhabited α] : Inhabited (PSum α β) := ⟨PSum.inl default⟩
 
-/--
-`PSum α β` is inhabited if `β` is inhabited.
-This is not an instance to avoid non-canonical instances.
--/
-@[reducible] def PSum.inhabitedRight {α β} [Inhabited β] : Inhabited (PSum α β) := ⟨PSum.inr default⟩
-
-instance PSum.nonemptyLeft [h : Nonempty α] : Nonempty (PSum α β) :=
-  Nonempty.elim h (fun a => ⟨PSum.inl a⟩)
-
-instance PSum.nonemptyRight [h : Nonempty β] : Nonempty (PSum α β) :=
-  Nonempty.elim h (fun b => ⟨PSum.inr b⟩)
+instance {α β} [Inhabited β] : Inhabited (PSum α β) := ⟨PSum.inr default⟩
 
 /--
 `Sigma β`, also denoted `Σ a : α, β a` or `(a : α) × β a`, is the type of dependent pairs
@@ -814,15 +789,17 @@ theorem cast_heq {α β : Sort u} : (h : α = β) → (a : α) → HEq (cast h a
 
 variable {a b c d : Prop}
 
-theorem iff_iff_implies_and_implies {a b : Prop} : (a ↔ b) ↔ (a → b) ∧ (b → a) :=
+theorem iff_iff_implies_and_implies (a b : Prop) : (a ↔ b) ↔ (a → b) ∧ (b → a) :=
   Iff.intro (fun h => And.intro h.mp h.mpr) (fun h => Iff.intro h.left h.right)
 
-@[refl] theorem Iff.refl (a : Prop) : a ↔ a :=
+theorem Iff.refl (a : Prop) : a ↔ a :=
   Iff.intro (fun h => h) (fun h => h)
 
 protected theorem Iff.rfl {a : Prop} : a ↔ a :=
   Iff.refl a
 
+macro_rules | `(tactic| rfl) => `(tactic| exact Iff.rfl)
+
 theorem Iff.of_eq (h : a = b) : a ↔ b := h ▸ Iff.rfl
 
 theorem Iff.trans (h₁ : a ↔ b) (h₂ : b ↔ c) : a ↔ c :=
@@ -908,7 +885,7 @@ theorem byContradiction [dec : Decidable p] (h : ¬p → False) : p :=
 theorem of_not_not [Decidable p] : ¬ ¬ p → p :=
   fun hnn => byContradiction (fun hn => absurd hn hnn)
 
-theorem not_and_iff_or_not {p q : Prop} [d₁ : Decidable p] [d₂ : Decidable q] : ¬ (p ∧ q) ↔ ¬ p ∨ ¬ q :=
+theorem not_and_iff_or_not (p q : Prop) [d₁ : Decidable p] [d₂ : Decidable q] : ¬ (p ∧ q) ↔ ¬ p ∨ ¬ q :=
   Iff.intro
     (fun h => match d₁, d₂ with
       | isTrue h₁,  isTrue h₂   => absurd (And.intro h₁ h₂) h
@@ -1127,13 +1104,6 @@ inductive Relation.TransGen {α : Sort u} (r : α → α → Prop) : α → α
 /-- Deprecated synonym for `Relation.TransGen`. -/
 @[deprecated Relation.TransGen (since := "2024-07-16")] abbrev TC := @Relation.TransGen
 
-theorem Relation.TransGen.trans {α : Sort u} {r : α → α → Prop} {a b c} :
-    TransGen r a b → TransGen r b c → TransGen r a c := by
-  intro hab hbc
-  induction hbc with
-  | single h => exact TransGen.tail hab h
-  | tail _ h ih => exact TransGen.tail ih h
-
 /-! # Subtype -/
 
 namespace Subtype
@@ -1162,20 +1132,12 @@ end Subtype
 section
 variable {α : Type u} {β : Type v}
 
-/-- This is not an instance to avoid non-canonical instances. -/
-@[reducible] def Sum.inhabitedLeft [Inhabited α] : Inhabited (Sum α β) where
+instance Sum.inhabitedLeft [Inhabited α] : Inhabited (Sum α β) where
   default := Sum.inl default
 
-/-- This is not an instance to avoid non-canonical instances. -/
-@[reducible] def Sum.inhabitedRight [Inhabited β] : Inhabited (Sum α β) where
+instance Sum.inhabitedRight [Inhabited β] : Inhabited (Sum α β) where
   default := Sum.inr default
 
-instance Sum.nonemptyLeft [h : Nonempty α] : Nonempty (Sum α β) :=
-  Nonempty.elim h (fun a => ⟨Sum.inl a⟩)
-
-instance Sum.nonemptyRight [h : Nonempty β] : Nonempty (Sum α β) :=
-  Nonempty.elim h (fun b => ⟨Sum.inr b⟩)
-
 instance {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] : DecidableEq (Sum α β) := fun a b =>
   match a, b with
   | Sum.inl a, Sum.inl b =>
@@ -1371,7 +1333,7 @@ theorem Nat.succ.inj {m n : Nat} : m.succ = n.succ → m = n :=
 theorem Nat.succ.injEq (u v : Nat) : (u.succ = v.succ) = (u = v) :=
   Eq.propIntro Nat.succ.inj (congrArg Nat.succ)
 
-@[simp] theorem beq_iff_eq [BEq α] [LawfulBEq α] {a b : α} : a == b ↔ a = b :=
+@[simp] theorem beq_iff_eq [BEq α] [LawfulBEq α] (a b : α) : a == b ↔ a = b :=
   ⟨eq_of_beq, by intro h; subst h; exact LawfulBEq.rfl⟩
 
 /-! # Prop lemmas -/
@@ -1436,7 +1398,7 @@ theorem false_of_true_eq_false  (h : True = False) : False := false_of_true_iff_
 
 theorem true_eq_false_of_false : False → (True = False) := False.elim
 
-theorem iff_def  : (a ↔ b) ↔ (a → b) ∧ (b → a) := iff_iff_implies_and_implies
+theorem iff_def  : (a ↔ b) ↔ (a → b) ∧ (b → a) := iff_iff_implies_and_implies a b
 theorem iff_def' : (a ↔ b) ↔ (b → a) ∧ (a → b) := Iff.trans iff_def And.comm
 
 theorem true_iff_false : (True ↔ False) ↔ False := iff_false_intro (·.mp  True.intro)
@@ -1464,7 +1426,7 @@ theorem imp_true_iff (α : Sort u) : (α → True) ↔ True := iff_true_intro (f
 
 theorem false_imp_iff (a : Prop) : (False → a) ↔ True := iff_true_intro False.elim
 
-theorem true_imp_iff {α : Prop} : (True → α) ↔ α := imp_iff_right True.intro
+theorem true_imp_iff (α : Prop) : (True → α) ↔ α := imp_iff_right True.intro
 
 @[simp high] theorem imp_self : (a → a) ↔ True := iff_true_intro id
 
@@ -1584,7 +1546,7 @@ so you should consider the simpler versions if they apply:
 * `Quot.recOnSubsingleton`, when the target type is a `Subsingleton`
 * `Quot.hrecOn`, which uses `HEq (f a) (f b)` instead of a `sound p ▸ f a = f b` assummption
 -/
-@[elab_as_elim] protected abbrev rec
+protected abbrev rec
     (f : (a : α) → motive (Quot.mk r a))
     (h : (a b : α) → (p : r a b) → Eq.ndrec (f a) (sound p) = f b)
     (q : Quot r) : motive q :=
@@ -1670,7 +1632,7 @@ protected theorem ind {α : Sort u} {s : Setoid α} {motive : Quotient s → Pro
 
 /--
 The analogue of `Quot.liftOn`: if `f : α → β` respects the equivalence relation `≈`,
-then it lifts to a function on `Quotient s` such that `liftOn (mk a) f h = f a`.
+then it lifts to a function on `Quotient s` such that `lift (mk a) f h = f a`.
 -/
 protected abbrev liftOn {α : Sort u} {β : Sort v} {s : Setoid α} (q : Quotient s) (f : α → β) (c : (a b : α) → a ≈ b → f a = f b) : β :=
   Quot.liftOn q f c

src/Init/Data.lean

@@ -37,7 +37,3 @@ import Init.Data.Cast
 import Init.Data.Sum
 import Init.Data.BEq
 import Init.Data.Subtype
-import Init.Data.ULift
-import Init.Data.PLift
-import Init.Data.Zero
-import Init.Data.NeZero

src/Init/Data/AC.lean

@@ -6,7 +6,7 @@ Authors: Dany Fabian
 
 prelude
 import Init.Classical
-import Init.ByCases
+import Init.Data.List
 
 namespace Lean.Data.AC
 inductive Expr
@@ -260,7 +260,7 @@ theorem Context.evalList_sort (ctx : Context α) (h : ContextInformation.isComm
     simp [ContextInformation.isComm, Option.isSome] at h
     match h₂ : ctx.comm with
     | none =>
-      simp [h₂] at h
+      simp only [h₂] at h
     | some val =>
       simp [h₂] at h
       exact val.down

src/Init/Data/Array.lean

@@ -14,4 +14,3 @@ import Init.Data.Array.Attach
 import Init.Data.Array.BasicAux
 import Init.Data.Array.Lemmas
 import Init.Data.Array.TakeDrop
-import Init.Data.Array.Bootstrap

src/Init/Data/Array/Attach.lean

@@ -20,7 +20,7 @@ Unsafe implementation of `attachWith`, taking advantage of the fact that the rep
   with the same elements but in the type `{x // P x}`. -/
 @[implemented_by attachWithImpl] def attachWith
     (xs : Array α) (P : α → Prop) (H : ∀ x ∈ xs, P x) : Array {x // P x} :=
-  ⟨xs.toList.attachWith P fun x h => H x (Array.Mem.mk h)⟩
+  ⟨xs.data.attachWith P fun x h => H x (Array.Mem.mk h)⟩
 
 /-- `O(1)`. "Attach" the proof that the elements of `xs` are in `xs` to produce a new array
   with the same elements but in the type `{x // x ∈ xs}`. -/

src/Init/Data/Array/Basic.lean

@@ -16,11 +16,10 @@ universe u v w
 namespace Array
 variable {α : Type u}
 
-@[deprecated Array.toList (since := "2024-09-10")] abbrev Array.data := @Array.toList
-
 @[extern "lean_mk_array"]
-def mkArray {α : Type u} (n : Nat) (v : α) : Array α where
-  toList := List.replicate n v
+def mkArray {α : Type u} (n : Nat) (v : α) : Array α := {
+  data := List.replicate n v
+}
 
 /--
 `ofFn f` with `f : Fin n → α` returns the list whose ith element is `f i`.
@@ -135,8 +134,9 @@ def swapAt! (a : Array α) (i : Nat) (v : α) : α × Array α :=
     panic! ("index " ++ toString i ++ " out of bounds")
 
 @[extern "lean_array_pop"]
-def pop (a : Array α) : Array α where
-  toList := a.toList.dropLast
+def pop (a : Array α) : Array α := {
+  data := a.data.dropLast
+}
 
 def shrink (a : Array α) (n : Nat) : Array α :=
   let rec loop
@@ -499,10 +499,10 @@ def elem [BEq α] (a : α) (as : Array α) : Bool :=
       (true, r)
 
 /-- Convert a `Array α` into an `List α`. This is O(n) in the size of the array.  -/
--- This function is exported to C, where it is called by `Array.toList`
+-- This function is exported to C, where it is called by `Array.data`
 -- (the projection) to implement this functionality.
-@[export lean_array_to_list_impl]
-def toListImpl (as : Array α) : List α :=
+@[export lean_array_to_list]
+def toList (as : Array α) : List α :=
   as.foldr List.cons []
 
 /-- Prepends an `Array α` onto the front of a list.  Equivalent to `as.toList ++ l`. -/
@@ -793,32 +793,28 @@ def toListLitAux (a : Array α) (n : Nat) (hsz : a.size = n) : ∀ (i : Nat), i
 def toArrayLit (a : Array α) (n : Nat) (hsz : a.size = n) : Array α :=
   List.toArray <| toListLitAux a n hsz n (hsz ▸ Nat.le_refl _) []
 
-theorem ext' {as bs : Array α} (h : as.toList = bs.toList) : as = bs := by
+theorem ext' {as bs : Array α} (h : as.data = bs.data) : as = bs := by
   cases as; cases bs; simp at h; rw [h]
 
-@[simp] theorem toArrayAux_eq (as : List α) (acc : Array α) : (as.toArrayAux acc).toList = acc.toList ++ as := by
+@[simp] theorem toArrayAux_eq (as : List α) (acc : Array α) : (as.toArrayAux acc).data = acc.data ++ as := by
   induction as generalizing acc <;> simp [*, List.toArrayAux, Array.push, List.append_assoc, List.concat_eq_append]
 
-@[simp] theorem toList_toArray (as : List α) : as.toArray.toList = as := by
+theorem data_toArray (as : List α) : as.toArray.data = as := by
   simp [List.toArray, Array.mkEmpty]
 
-@[deprecated toList_toArray (since := "2024-09-09")] abbrev data_toArray := @toList_toArray
-
-@[simp] theorem size_toArray (as : List α) : as.toArray.size = as.length := by simp [size]
-
 theorem toArrayLit_eq (as : Array α) (n : Nat) (hsz : as.size = n) : as = toArrayLit as n hsz := by
   apply ext'
-  simp [toArrayLit, toList_toArray]
+  simp [toArrayLit, data_toArray]
   have hle : n ≤ as.size := hsz ▸ Nat.le_refl _
   have hge : as.size ≤ n := hsz ▸ Nat.le_refl _
   have := go n hle
   rw [List.drop_eq_nil_of_le hge] at this
   rw [this]
 where
-  getLit_eq (as : Array α) (i : Nat) (h₁ : as.size = n) (h₂ : i < n) : as.getLit i h₁ h₂ = getElem as.toList i ((id (α := as.toList.length = n) h₁) ▸ h₂) :=
+  getLit_eq (as : Array α) (i : Nat) (h₁ : as.size = n) (h₂ : i < n) : as.getLit i h₁ h₂ = getElem as.data i ((id (α := as.data.length = n) h₁) ▸ h₂) :=
     rfl
 
-  go (i : Nat) (hi : i ≤ as.size) : toListLitAux as n hsz i hi (as.toList.drop i) = as.toList := by
+  go (i : Nat) (hi : i ≤ as.size) : toListLitAux as n hsz i hi (as.data.drop i) = as.data := by
     induction i <;> simp [getLit_eq, List.get_drop_eq_drop, toListLitAux, List.drop, *]
 
 def isPrefixOfAux [BEq α] (as bs : Array α) (hle : as.size ≤ bs.size) (i : Nat) : Bool :=

src/Init/Data/Array/BasicAux.lean

@@ -38,7 +38,7 @@ private theorem List.of_toArrayAux_eq_toArrayAux {as bs : List α} {cs ds : Arra
   · intro h; rw [h]
 
 def Array.mapM' [Monad m] (f : α → m β) (as : Array α) : m { bs : Array β // bs.size = as.size } :=
-  go 0 ⟨mkEmpty as.size, rfl⟩ (by simp)
+  go 0 ⟨mkEmpty as.size, rfl⟩ (by simp_arith)
 where
   go (i : Nat) (acc : { bs : Array β // bs.size = i }) (hle : i ≤ as.size) : m { bs : Array β // bs.size = as.size } := do
     if h : i = as.size then

src/Init/Data/Array/Bootstrap.lean

@@ -1,120 +0,0 @@
-/-
-Copyright (c) 2022 Mario Carneiro. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Mario Carneiro
--/
-
-prelude
-import Init.Data.List.TakeDrop
-
-/-!
-## Bootstrapping theorems about arrays
-
-This file contains some theorems about `Array` and `List` needed for `Init.Data.List.Impl`.
--/
-
-namespace Array
-
-theorem foldlM_eq_foldlM_toList.aux [Monad m]
-    (f : β → α → m β) (arr : Array α) (i j) (H : arr.size ≤ i + j) (b) :
-    foldlM.loop f arr arr.size (Nat.le_refl _) i j b = (arr.toList.drop j).foldlM f b := by
-  unfold foldlM.loop
-  split; split
-  · cases Nat.not_le_of_gt ‹_› (Nat.zero_add _ ▸ H)
-  · rename_i i; rw [Nat.succ_add] at H
-    simp [foldlM_eq_foldlM_toList.aux f arr i (j+1) H]
-    rw (config := {occs := .pos [2]}) [← List.get_drop_eq_drop _ _ ‹_›]
-    rfl
-  · rw [List.drop_of_length_le (Nat.ge_of_not_lt ‹_›)]; rfl
-
-theorem foldlM_eq_foldlM_toList [Monad m]
-    (f : β → α → m β) (init : β) (arr : Array α) :
-    arr.foldlM f init = arr.toList.foldlM f init := by
-  simp [foldlM, foldlM_eq_foldlM_toList.aux]
-
-theorem foldl_eq_foldl_toList (f : β → α → β) (init : β) (arr : Array α) :
-    arr.foldl f init = arr.toList.foldl f init :=
-  List.foldl_eq_foldlM .. ▸ foldlM_eq_foldlM_toList ..
-
-theorem foldrM_eq_reverse_foldlM_toList.aux [Monad m]
-    (f : α → β → m β) (arr : Array α) (init : β) (i h) :
-    (arr.toList.take i).reverse.foldlM (fun x y => f y x) init = foldrM.fold f arr 0 i h init := by
-  unfold foldrM.fold
-  match i with
-  | 0 => simp [List.foldlM, List.take]
-  | i+1 => rw [← List.take_concat_get _ _ h]; simp [← (aux f arr · i)]; rfl
-
-theorem foldrM_eq_reverse_foldlM_toList [Monad m] (f : α → β → m β) (init : β) (arr : Array α) :
-    arr.foldrM f init = arr.toList.reverse.foldlM (fun x y => f y x) init := by
-  have : arr = #[] ∨ 0 < arr.size :=
-    match arr with | ⟨[]⟩ => .inl rfl | ⟨a::l⟩ => .inr (Nat.zero_lt_succ _)
-  match arr, this with | _, .inl rfl => rfl | arr, .inr h => ?_
-  simp [foldrM, h, ← foldrM_eq_reverse_foldlM_toList.aux, List.take_length]
-
-theorem foldrM_eq_foldrM_toList [Monad m]
-    (f : α → β → m β) (init : β) (arr : Array α) :
-    arr.foldrM f init = arr.toList.foldrM f init := by
-  rw [foldrM_eq_reverse_foldlM_toList, List.foldlM_reverse]
-
-theorem foldr_eq_foldr_toList (f : α → β → β) (init : β) (arr : Array α) :
-    arr.foldr f init = arr.toList.foldr f init :=
-  List.foldr_eq_foldrM .. ▸ foldrM_eq_foldrM_toList ..
-
-@[simp] theorem push_toList (arr : Array α) (a : α) : (arr.push a).toList = arr.toList ++ [a] := by
-  simp [push, List.concat_eq_append]
-
-@[simp] theorem toListAppend_eq (arr : Array α) (l) : arr.toListAppend l = arr.toList ++ l := by
-  simp [toListAppend, foldr_eq_foldr_toList]
-
-@[simp] theorem toListImpl_eq (arr : Array α) : arr.toListImpl = arr.toList := by
-  simp [toListImpl, foldr_eq_foldr_toList]
-
-@[simp] theorem pop_toList (arr : Array α) : arr.pop.toList = arr.toList.dropLast := rfl
-
-@[simp] theorem append_eq_append (arr arr' : Array α) : arr.append arr' = arr ++ arr' := rfl
-
-@[simp] theorem append_toList (arr arr' : Array α) :
-    (arr ++ arr').toList = arr.toList ++ arr'.toList := by
-  rw [← append_eq_append]; unfold Array.append
-  rw [foldl_eq_foldl_toList]
-  induction arr'.toList generalizing arr <;> simp [*]
-
-@[simp] theorem appendList_eq_append
-    (arr : Array α) (l : List α) : arr.appendList l = arr ++ l := rfl
-
-@[simp] theorem appendList_toList (arr : Array α) (l : List α) :
-    (arr ++ l).toList = arr.toList ++ l := by
-  rw [← appendList_eq_append]; unfold Array.appendList
-  induction l generalizing arr <;> simp [*]
-
-@[deprecated foldlM_eq_foldlM_toList (since := "2024-09-09")]
-abbrev foldlM_eq_foldlM_data := @foldlM_eq_foldlM_toList
-
-@[deprecated foldl_eq_foldl_toList (since := "2024-09-09")]
-abbrev foldl_eq_foldl_data := @foldl_eq_foldl_toList
-
-@[deprecated foldrM_eq_reverse_foldlM_toList (since := "2024-09-09")]
-abbrev foldrM_eq_reverse_foldlM_data := @foldrM_eq_reverse_foldlM_toList
-
-@[deprecated foldrM_eq_foldrM_toList (since := "2024-09-09")]
-abbrev foldrM_eq_foldrM_data := @foldrM_eq_foldrM_toList
-
-@[deprecated foldr_eq_foldr_toList (since := "2024-09-09")]
-abbrev foldr_eq_foldr_data := @foldr_eq_foldr_toList
-
-@[deprecated push_toList (since := "2024-09-09")]
-abbrev push_data := @push_toList
-
-@[deprecated toListImpl_eq (since := "2024-09-09")]
-abbrev toList_eq := @toListImpl_eq
-
-@[deprecated pop_toList (since := "2024-09-09")]
-abbrev pop_data := @pop_toList
-
-@[deprecated append_toList (since := "2024-09-09")]
-abbrev append_data := @append_toList
-
-@[deprecated appendList_toList (since := "2024-09-09")]
-abbrev appendList_data := @appendList_toList
-
-end Array

src/Init/Data/Array/Lemmas.lean

@@ -4,10 +4,10 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
 -/
 prelude
+import Init.Data.Nat.MinMax
 import Init.Data.Nat.Lemmas
-import Init.Data.List.Impl
 import Init.Data.List.Monadic
-import Init.Data.List.Range
+import Init.Data.Fin.Basic
 import Init.Data.Array.Mem
 import Init.TacticsExtra
 
@@ -23,34 +23,75 @@ attribute [simp] data_toArray uset
 
 @[simp] theorem singleton_def (v : α) : singleton v = #[v] := rfl
 
-@[simp] theorem toArray_toList : (a : Array α) → a.toList.toArray = a
-  | ⟨l⟩ => ext' (toList_toArray l)
+@[simp] theorem toArray_data : (a : Array α) → a.data.toArray = a
+  | ⟨l⟩ => ext' (data_toArray l)
 
-@[deprecated toArray_toList (since := "2024-09-09")]
-abbrev toArray_data := @toArray_toList
-
-@[simp] theorem toList_length {l : Array α} : l.toList.length = l.size := rfl
-
-@[deprecated toList_length (since := "2024-09-09")]
-abbrev data_length := @toList_length
+@[simp] theorem data_length {l : Array α} : l.data.length = l.size := rfl
 
 @[simp] theorem mkEmpty_eq (α n) : @mkEmpty α n = #[] := rfl
 
+@[simp] theorem size_toArray (as : List α) : as.toArray.size = as.length := by simp [size]
+
 @[simp] theorem size_mk (as : List α) : (Array.mk as).size = as.length := by simp [size]
 
-theorem getElem_eq_toList_getElem (a : Array α) (h : i < a.size) : a[i] = a.toList[i] := by
+theorem getElem_eq_data_getElem (a : Array α) (h : i < a.size) : a[i] = a.data[i] := by
   by_cases i < a.size <;> (try simp [*]) <;> rfl
 
-@[deprecated getElem_eq_toList_getElem (since := "2024-09-09")]
-abbrev getElem_eq_data_getElem := @getElem_eq_toList_getElem
+@[deprecated getElem_eq_data_getElem (since := "2024-06-12")]
+theorem getElem_eq_data_get (a : Array α) (h : i < a.size) : a[i] = a.data.get ⟨i, h⟩ := by
+  simp [getElem_eq_data_getElem]
 
-@[deprecated getElem_eq_toList_getElem (since := "2024-06-12")]
-theorem getElem_eq_toList_get (a : Array α) (h : i < a.size) : a[i] = a.toList.get ⟨i, h⟩ := by
-  simp [getElem_eq_toList_getElem]
+theorem foldlM_eq_foldlM_data.aux [Monad m]
+    (f : β → α → m β) (arr : Array α) (i j) (H : arr.size ≤ i + j) (b) :
+    foldlM.loop f arr arr.size (Nat.le_refl _) i j b = (arr.data.drop j).foldlM f b := by
+  unfold foldlM.loop
+  split; split
+  · cases Nat.not_le_of_gt ‹_› (Nat.zero_add _ ▸ H)
+  · rename_i i; rw [Nat.succ_add] at H
+    simp [foldlM_eq_foldlM_data.aux f arr i (j+1) H]
+    rw (config := {occs := .pos [2]}) [← List.get_drop_eq_drop _ _ ‹_›]
+    rfl
+  · rw [List.drop_of_length_le (Nat.ge_of_not_lt ‹_›)]; rfl
+
+theorem foldlM_eq_foldlM_data [Monad m]
+    (f : β → α → m β) (init : β) (arr : Array α) :
+    arr.foldlM f init = arr.data.foldlM f init := by
+  simp [foldlM, foldlM_eq_foldlM_data.aux]
+
+theorem foldl_eq_foldl_data (f : β → α → β) (init : β) (arr : Array α) :
+    arr.foldl f init = arr.data.foldl f init :=
+  List.foldl_eq_foldlM .. ▸ foldlM_eq_foldlM_data ..
+
+theorem foldrM_eq_reverse_foldlM_data.aux [Monad m]
+    (f : α → β → m β) (arr : Array α) (init : β) (i h) :
+    (arr.data.take i).reverse.foldlM (fun x y => f y x) init = foldrM.fold f arr 0 i h init := by
+  unfold foldrM.fold
+  match i with
+  | 0 => simp [List.foldlM, List.take]
+  | i+1 => rw [← List.take_concat_get _ _ h]; simp [← (aux f arr · i)]; rfl
+
+theorem foldrM_eq_reverse_foldlM_data [Monad m] (f : α → β → m β) (init : β) (arr : Array α) :
+    arr.foldrM f init = arr.data.reverse.foldlM (fun x y => f y x) init := by
+  have : arr = #[] ∨ 0 < arr.size :=
+    match arr with | ⟨[]⟩ => .inl rfl | ⟨a::l⟩ => .inr (Nat.zero_lt_succ _)
+  match arr, this with | _, .inl rfl => rfl | arr, .inr h => ?_
+  simp [foldrM, h, ← foldrM_eq_reverse_foldlM_data.aux, List.take_length]
+
+theorem foldrM_eq_foldrM_data [Monad m]
+    (f : α → β → m β) (init : β) (arr : Array α) :
+    arr.foldrM f init = arr.data.foldrM f init := by
+  rw [foldrM_eq_reverse_foldlM_data, List.foldlM_reverse]
+
+theorem foldr_eq_foldr_data (f : α → β → β) (init : β) (arr : Array α) :
+    arr.foldr f init = arr.data.foldr f init :=
+  List.foldr_eq_foldrM .. ▸ foldrM_eq_foldrM_data ..
+
+@[simp] theorem push_data (arr : Array α) (a : α) : (arr.push a).data = arr.data ++ [a] := by
+  simp [push, List.concat_eq_append]
 
 theorem foldrM_push [Monad m] (f : α → β → m β) (init : β) (arr : Array α) (a : α) :
     (arr.push a).foldrM f init = f a init >>= arr.foldrM f := by
-  simp [foldrM_eq_reverse_foldlM_toList, -size_push]
+  simp [foldrM_eq_reverse_foldlM_data, -size_push]
 
 @[simp] theorem foldrM_push' [Monad m] (f : α → β → m β) (init : β) (arr : Array α) (a : α) :
     (arr.push a).foldrM f init (start := arr.size + 1) = f a init >>= arr.foldrM f := by
@@ -62,20 +103,26 @@ theorem foldr_push (f : α → β → β) (init : β) (arr : Array α) (a : α)
 @[simp] theorem foldr_push' (f : α → β → β) (init : β) (arr : Array α) (a : α) :
     (arr.push a).foldr f init (start := arr.size + 1) = arr.foldr f (f a init) := foldrM_push' ..
 
+@[simp] theorem toListAppend_eq (arr : Array α) (l) : arr.toListAppend l = arr.data ++ l := by
+  simp [toListAppend, foldr_eq_foldr_data]
+
+@[simp] theorem toList_eq (arr : Array α) : arr.toList = arr.data := by
+  simp [toList, foldr_eq_foldr_data]
+
 /-- A more efficient version of `arr.toList.reverse`. -/
 @[inline] def toListRev (arr : Array α) : List α := arr.foldl (fun l t => t :: l) []
 
-@[simp] theorem toListRev_eq (arr : Array α) : arr.toListRev = arr.toList.reverse := by
-  rw [toListRev, foldl_eq_foldl_toList, ← List.foldr_reverse, List.foldr_cons_nil]
+@[simp] theorem toListRev_eq (arr : Array α) : arr.toListRev = arr.data.reverse := by
+  rw [toListRev, foldl_eq_foldl_data, ← List.foldr_reverse, List.foldr_self]
 
 theorem get_push_lt (a : Array α) (x : α) (i : Nat) (h : i < a.size) :
     have : i < (a.push x).size := by simp [*, Nat.lt_succ_of_le, Nat.le_of_lt]
     (a.push x)[i] = a[i] := by
-  simp only [push, getElem_eq_toList_getElem, List.concat_eq_append, List.getElem_append_left, h]
+  simp only [push, getElem_eq_data_getElem, List.concat_eq_append, List.getElem_append_left, h]
 
 @[simp] theorem get_push_eq (a : Array α) (x : α) : (a.push x)[a.size] = x := by
-  simp only [push, getElem_eq_toList_getElem, List.concat_eq_append]
-  rw [List.getElem_append_right] <;> simp [getElem_eq_toList_getElem, Nat.zero_lt_one]
+  simp only [push, getElem_eq_data_getElem, List.concat_eq_append]
+  rw [List.getElem_append_right] <;> simp [getElem_eq_data_getElem, Nat.zero_lt_one]
 
 theorem get_push (a : Array α) (x : α) (i : Nat) (h : i < (a.push x).size) :
     (a.push x)[i] = if h : i < a.size then a[i] else x := by
@@ -86,54 +133,62 @@ theorem get_push (a : Array α) (x : α) (i : Nat) (h : i < (a.push x).size) :
 
 theorem mapM_eq_foldlM [Monad m] [LawfulMonad m] (f : α → m β) (arr : Array α) :
     arr.mapM f = arr.foldlM (fun bs a => bs.push <$> f a) #[] := by
-  rw [mapM, aux, foldlM_eq_foldlM_toList]; rfl
+  rw [mapM, aux, foldlM_eq_foldlM_data]; rfl
 where
   aux (i r) :
-      mapM.map f arr i r = (arr.toList.drop i).foldlM (fun bs a => bs.push <$> f a) r := by
+      mapM.map f arr i r = (arr.data.drop i).foldlM (fun bs a => bs.push <$> f a) r := by
     unfold mapM.map; split
     · rw [← List.get_drop_eq_drop _ i ‹_›]
-      simp only [aux (i + 1), map_eq_pure_bind, toList_length, List.foldlM_cons, bind_assoc,
-        pure_bind]
+      simp only [aux (i + 1), map_eq_pure_bind, data_length, List.foldlM_cons, bind_assoc, pure_bind]
       rfl
     · rw [List.drop_of_length_le (Nat.ge_of_not_lt ‹_›)]; rfl
   termination_by arr.size - i
   decreasing_by decreasing_trivial_pre_omega
 
-@[simp] theorem map_toList (f : α → β) (arr : Array α) : (arr.map f).toList = arr.toList.map f := by
+@[simp] theorem map_data (f : α → β) (arr : Array α) : (arr.map f).data = arr.data.map f := by
   rw [map, mapM_eq_foldlM]
-  apply congrArg toList (foldl_eq_foldl_toList (fun bs a => push bs (f a)) #[] arr) |>.trans
-  have H (l arr) : List.foldl (fun bs a => push bs (f a)) arr l = ⟨arr.toList ++ l.map f⟩ := by
+  apply congrArg data (foldl_eq_foldl_data (fun bs a => push bs (f a)) #[] arr) |>.trans
+  have H (l arr) : List.foldl (fun bs a => push bs (f a)) arr l = ⟨arr.data ++ l.map f⟩ := by
     induction l generalizing arr <;> simp [*]
   simp [H]
 
-@[deprecated map_toList (since := "2024-09-09")]
-abbrev map_data := @map_toList
-
 @[simp] theorem size_map (f : α → β) (arr : Array α) : (arr.map f).size = arr.size := by
-  simp only [← toList_length]
+  simp only [← data_length]
   simp
 
+@[simp] theorem pop_data (arr : Array α) : arr.pop.data = arr.data.dropLast := rfl
+
+@[simp] theorem append_eq_append (arr arr' : Array α) : arr.append arr' = arr ++ arr' := rfl
+
+@[simp] theorem append_data (arr arr' : Array α) :
+    (arr ++ arr').data = arr.data ++ arr'.data := by
+  rw [← append_eq_append]; unfold Array.append
+  rw [foldl_eq_foldl_data]
+  induction arr'.data generalizing arr <;> simp [*]
+
+@[simp] theorem appendList_eq_append
+    (arr : Array α) (l : List α) : arr.appendList l = arr ++ l := rfl
+
+@[simp] theorem appendList_data (arr : Array α) (l : List α) :
+    (arr ++ l).data = arr.data ++ l := by
+  rw [← appendList_eq_append]; unfold Array.appendList
+  induction l generalizing arr <;> simp [*]
+
 @[simp] theorem appendList_nil (arr : Array α) : arr ++ ([] : List α) = arr := Array.ext' (by simp)
 
 @[simp] theorem appendList_cons (arr : Array α) (a : α) (l : List α) :
     arr ++ (a :: l) = arr.push a ++ l := Array.ext' (by simp)
 
-theorem foldl_toList_eq_bind (l : List α) (acc : Array β)
+theorem foldl_data_eq_bind (l : List α) (acc : Array β)
     (F : Array β → α → Array β) (G : α → List β)
-    (H : ∀ acc a, (F acc a).toList = acc.toList ++ G a) :
-    (l.foldl F acc).toList = acc.toList ++ l.bind G := by
+    (H : ∀ acc a, (F acc a).data = acc.data ++ G a) :
+    (l.foldl F acc).data = acc.data ++ l.bind G := by
   induction l generalizing acc <;> simp [*, List.bind]
 
-@[deprecated foldl_toList_eq_bind (since := "2024-09-09")]
-abbrev foldl_data_eq_bind := @foldl_toList_eq_bind
-
-theorem foldl_toList_eq_map (l : List α) (acc : Array β) (G : α → β) :
-    (l.foldl (fun acc a => acc.push (G a)) acc).toList = acc.toList ++ l.map G := by
+theorem foldl_data_eq_map (l : List α) (acc : Array β) (G : α → β) :
+    (l.foldl (fun acc a => acc.push (G a)) acc).data = acc.data ++ l.map G := by
   induction l generalizing acc <;> simp [*]
 
-@[deprecated foldl_toList_eq_map (since := "2024-09-09")]
-abbrev foldl_data_eq_map := @foldl_toList_eq_map
-
 theorem size_uset (a : Array α) (v i h) : (uset a i v h).size = a.size := by simp
 
 theorem anyM_eq_anyM_loop [Monad m] (p : α → m Bool) (as : Array α) (start stop) :
@@ -144,12 +199,9 @@ theorem anyM_stop_le_start [Monad m] (p : α → m Bool) (as : Array α) (start
     (h : min stop as.size ≤ start) : anyM p as start stop = pure false := by
   rw [anyM_eq_anyM_loop, anyM.loop, dif_neg (Nat.not_lt.2 h)]
 
-theorem mem_def {a : α} {as : Array α} : a ∈ as ↔ a ∈ as.toList :=
+theorem mem_def (a : α) (as : Array α) : a ∈ as ↔ a ∈ as.data :=
   ⟨fun | .mk h => h, Array.Mem.mk⟩
 
-@[simp] theorem not_mem_empty (a : α) : ¬(a ∈ #[]) := by
-  simp [mem_def]
-
 /-! # get -/
 
 @[simp] theorem get_eq_getElem (a : Array α) (i : Fin _) : a.get i = a[i.1] := rfl
@@ -186,11 +238,11 @@ theorem get!_eq_getD [Inhabited α] (a : Array α) : a.get! n = a.getD n default
 @[simp] theorem getElem_set_eq (a : Array α) (i : Fin a.size) (v : α) {j : Nat}
       (eq : i.val = j) (p : j < (a.set i v).size) :
     (a.set i v)[j]'p = v := by
-  simp [set, getElem_eq_toList_getElem, ←eq]
+  simp [set, getElem_eq_data_getElem, ←eq]
 
 @[simp] theorem getElem_set_ne (a : Array α) (i : Fin a.size) (v : α) {j : Nat} (pj : j < (a.set i v).size)
     (h : i.val ≠ j) : (a.set i v)[j]'pj = a[j]'(size_set a i v ▸ pj) := by
-  simp only [set, getElem_eq_toList_getElem, List.getElem_set_ne h]
+  simp only [set, getElem_eq_data_getElem, List.getElem_set_ne h]
 
 theorem getElem_set (a : Array α) (i : Fin a.size) (v : α) (j : Nat)
     (h : j < (a.set i v).size) :
@@ -271,87 +323,42 @@ termination_by n - i
 
 /-- # mkArray -/
 
-@[simp] theorem toList_mkArray (n : Nat) (v : α) : (mkArray n v).toList = List.replicate n v := rfl
-
-@[deprecated toList_mkArray (since := "2024-09-09")]
-abbrev mkArray_data := @toList_mkArray
+@[simp] theorem mkArray_data (n : Nat) (v : α) : (mkArray n v).data = List.replicate n v := rfl
 
 @[simp] theorem getElem_mkArray (n : Nat) (v : α) (h : i < (mkArray n v).size) :
-    (mkArray n v)[i] = v := by simp [Array.getElem_eq_toList_getElem]
+    (mkArray n v)[i] = v := by simp [Array.getElem_eq_data_getElem]
 
 /-- # mem -/
 
-theorem mem_toList {a : α} {l : Array α} : a ∈ l.toList ↔ a ∈ l := mem_def.symm
-
-@[deprecated mem_toList (since := "2024-09-09")]
-abbrev mem_data := @mem_toList
+theorem mem_data {a : α} {l : Array α} : a ∈ l.data ↔ a ∈ l := (mem_def _ _).symm
 
 theorem not_mem_nil (a : α) : ¬ a ∈ #[] := nofun
 
-theorem getElem_of_mem {a : α} {as : Array α} :
-    a ∈ as → (∃ (n : Nat) (h : n < as.size), as[n]'h = a) := by
-  intro ha
-  rcases List.getElem_of_mem ha.val with ⟨i, hbound, hi⟩
-  exists i
-  exists hbound
-
-@[simp] theorem mem_dite_empty_left {x : α} [Decidable p] {l : ¬ p → Array α} :
-    (x ∈ if h : p then #[] else l h) ↔ ∃ h : ¬ p, x ∈ l h := by
-  split <;> simp_all [mem_def]
-
-@[simp] theorem mem_dite_empty_right {x : α} [Decidable p] {l : p → Array α} :
-    (x ∈ if h : p then l h else #[]) ↔ ∃ h : p, x ∈ l h := by
-  split <;> simp_all [mem_def]
-
-@[simp] theorem mem_ite_empty_left {x : α} [Decidable p] {l : Array α} :
-    (x ∈ if p then #[] else l) ↔ ¬ p ∧ x ∈ l := by
-  split <;> simp_all [mem_def]
-
-@[simp] theorem mem_ite_empty_right {x : α} [Decidable p] {l : Array α} :
-    (x ∈ if p then l else #[]) ↔ p ∧ x ∈ l := by
-  split <;> simp_all [mem_def]
-
 /-- # get lemmas -/
 
-theorem lt_of_getElem {x : α} {a : Array α} {idx : Nat} {hidx : idx < a.size} (_ : a[idx] = x) :
-    idx < a.size :=
-  hidx
-
 theorem getElem?_mem {l : Array α} {i : Fin l.size} : l[i] ∈ l := by
-  erw [Array.mem_def, getElem_eq_toList_getElem]
+  erw [Array.mem_def, getElem_eq_data_getElem]
   apply List.get_mem
 
-theorem getElem_fin_eq_toList_get (a : Array α) (i : Fin _) : a[i] = a.toList.get i := rfl
-
-@[deprecated getElem_fin_eq_toList_get (since := "2024-09-09")]
-abbrev getElem_fin_eq_data_get := @getElem_fin_eq_toList_get
+theorem getElem_fin_eq_data_get (a : Array α) (i : Fin _) : a[i] = a.data.get i := rfl
 
 @[simp] theorem ugetElem_eq_getElem (a : Array α) {i : USize} (h : i.toNat < a.size) :
   a[i] = a[i.toNat] := rfl
 
-theorem getElem?_eq_getElem (a : Array α) (i : Nat) (h : i < a.size) : a[i]? = some a[i] :=
+theorem getElem?_eq_getElem (a : Array α) (i : Nat) (h : i < a.size) : a[i]? = a[i] :=
   getElem?_pos ..
 
 theorem get?_len_le (a : Array α) (i : Nat) (h : a.size ≤ i) : a[i]? = none := by
   simp [getElem?_neg, h]
 
-theorem getElem_mem_toList (a : Array α) (h : i < a.size) : a[i] ∈ a.toList := by
-  simp only [getElem_eq_toList_getElem, List.getElem_mem]
+theorem getElem_mem_data (a : Array α) (h : i < a.size) : a[i] ∈ a.data := by
+  simp only [getElem_eq_data_getElem, List.getElem_mem]
 
-@[deprecated getElem_mem_toList (since := "2024-09-09")]
-abbrev getElem_mem_data := @getElem_mem_toList
-
-theorem getElem?_eq_toList_get? (a : Array α) (i : Nat) : a[i]? = a.toList.get? i := by
+theorem getElem?_eq_data_get? (a : Array α) (i : Nat) : a[i]? = a.data.get? i := by
   by_cases i < a.size <;> simp_all [getElem?_pos, getElem?_neg, List.get?_eq_get, eq_comm]; rfl
 
-@[deprecated getElem?_eq_toList_get? (since := "2024-09-09")]
-abbrev getElem?_eq_data_get? := @getElem?_eq_toList_get?
-
-theorem get?_eq_toList_get? (a : Array α) (i : Nat) : a.get? i = a.toList.get? i :=
-  getElem?_eq_toList_get? ..
-
-@[deprecated get?_eq_toList_get? (since := "2024-09-09")]
-abbrev get?_eq_data_get? := @get?_eq_toList_get?
+theorem get?_eq_data_get? (a : Array α) (i : Nat) : a.get? i = a.data.get? i :=
+  getElem?_eq_data_get? ..
 
 theorem get!_eq_get? [Inhabited α] (a : Array α) : a.get! n = (a.get? n).getD default := by
   simp [get!_eq_getD]
@@ -360,7 +367,7 @@ theorem get!_eq_get? [Inhabited α] (a : Array α) : a.get! n = (a.get? n).getD
   simp [back, back?]
 
 @[simp] theorem back?_push (a : Array α) : (a.push x).back? = some x := by
-  simp [back?, getElem?_eq_toList_get?]
+  simp [back?, getElem?_eq_data_get?]
 
 theorem back_push [Inhabited α] (a : Array α) : (a.push x).back = x := by simp
 
@@ -389,14 +396,11 @@ theorem get?_push {a : Array α} : (a.push x)[i]? = if i = a.size then some x el
 @[simp] theorem get?_size {a : Array α} : a[a.size]? = none := by
   simp only [getElem?_def, Nat.lt_irrefl, dite_false]
 
-@[simp] theorem toList_set (a : Array α) (i v) : (a.set i v).toList = a.toList.set i.1 v := rfl
-
-@[deprecated toList_set (since := "2024-09-09")]
-abbrev data_set := @toList_set
+@[simp] theorem data_set (a : Array α) (i v) : (a.set i v).data = a.data.set i.1 v := rfl
 
 theorem get_set_eq (a : Array α) (i : Fin a.size) (v : α) :
     (a.set i v)[i.1] = v := by
-  simp only [set, getElem_eq_toList_getElem, List.getElem_set_self]
+  simp only [set, getElem_eq_data_getElem, List.getElem_set_eq]
 
 theorem get?_set_eq (a : Array α) (i : Fin a.size) (v : α) :
     (a.set i v)[i.1]? = v := by simp [getElem?_pos, i.2]
@@ -415,7 +419,7 @@ theorem get_set (a : Array α) (i : Fin a.size) (j : Nat) (hj : j < a.size) (v :
 
 @[simp] theorem get_set_ne (a : Array α) (i : Fin a.size) {j : Nat} (v : α) (hj : j < a.size)
     (h : i.1 ≠ j) : (a.set i v)[j]'(by simp [*]) = a[j] := by
-  simp only [set, getElem_eq_toList_getElem, List.getElem_set_ne h]
+  simp only [set, getElem_eq_data_getElem, List.getElem_set_ne h]
 
 theorem getElem_setD (a : Array α) (i : Nat) (v : α) (h : i < (setD a i v).size) :
   (setD a i v)[i] = v := by
@@ -431,15 +435,12 @@ theorem swap_def (a : Array α) (i j : Fin a.size) :
     a.swap i j = (a.set i (a.get j)).set ⟨j.1, by simp [j.2]⟩ (a.get i) := by
   simp [swap, fin_cast_val]
 
-theorem toList_swap (a : Array α) (i j : Fin a.size) :
-    (a.swap i j).toList = (a.toList.set i (a.get j)).set j (a.get i) := by simp [swap_def]
-
-@[deprecated toList_swap (since := "2024-09-09")]
-abbrev data_swap := @toList_swap
+theorem data_swap (a : Array α) (i j : Fin a.size) :
+    (a.swap i j).data = (a.data.set i (a.get j)).set j (a.get i) := by simp [swap_def]
 
 theorem get?_swap (a : Array α) (i j : Fin a.size) (k : Nat) : (a.swap i j)[k]? =
     if j = k then some a[i.1] else if i = k then some a[j.1] else a[k]? := by
-  simp [swap_def, get?_set, ← getElem_fin_eq_toList_get]
+  simp [swap_def, get?_set, ← getElem_fin_eq_data_get]
 
 @[simp] theorem swapAt_def (a : Array α) (i : Fin a.size) (v : α) :
     a.swapAt i v = (a[i.1], a.set i v) := rfl
@@ -448,10 +449,7 @@ theorem get?_swap (a : Array α) (i j : Fin a.size) (k : Nat) : (a.swap i j)[k]?
 theorem swapAt!_def (a : Array α) (i : Nat) (v : α) (h : i < a.size) :
     a.swapAt! i v = (a[i], a.set ⟨i, h⟩ v) := by simp [swapAt!, h]
 
-@[simp] theorem toList_pop (a : Array α) : a.pop.toList = a.toList.dropLast := by simp [pop]
-
-@[deprecated toList_pop (since := "2024-09-09")]
-abbrev data_pop := @toList_pop
+@[simp] theorem data_pop (a : Array α) : a.pop.data = a.data.dropLast := by simp [pop]
 
 @[simp] theorem pop_empty : (#[] : Array α).pop = #[] := rfl
 
@@ -483,10 +481,7 @@ theorem eq_push_of_size_ne_zero {as : Array α} (h : as.size ≠ 0) :
   let _ : Inhabited α := ⟨as[0]⟩
   ⟨as.pop, as.back, eq_push_pop_back_of_size_ne_zero h⟩
 
-theorem size_eq_length_toList (as : Array α) : as.size = as.toList.length := rfl
-
-@[deprecated size_eq_length_toList (since := "2024-09-09")]
-abbrev size_eq_length_data := @size_eq_length_toList
+theorem size_eq_length_data (as : Array α) : as.size = as.data.length := rfl
 
 @[simp] theorem size_swap! (a : Array α) (i j) :
     (a.swap! i j).size = a.size := by unfold swap!; split <;> (try split) <;> simp [size_swap]
@@ -510,22 +505,12 @@ abbrev size_eq_length_data := @size_eq_length_toList
     simp only [mkEmpty_eq, size_push] at *
     omega
 
-@[simp] theorem toList_range (n : Nat) : (range n).toList = List.range n := by
-  induction n <;> simp_all [range, Nat.fold, flip, List.range_succ]
-
-@[deprecated toList_range (since := "2024-09-09")]
-abbrev data_range := @toList_range
-
-@[simp]
-theorem getElem_range {n : Nat} {x : Nat} (h : x < (Array.range n).size) : (Array.range n)[x] = x := by
-  simp [getElem_eq_toList_getElem]
-
 set_option linter.deprecated false in
-@[simp] theorem reverse_toList (a : Array α) : a.reverse.toList = a.toList.reverse := by
+@[simp] theorem reverse_data (a : Array α) : a.reverse.data = a.data.reverse := by
   let rec go (as : Array α) (i j hj)
       (h : i + j + 1 = a.size) (h₂ : as.size = a.size)
-      (H : ∀ k, as.toList.get? k = if i ≤ k ∧ k ≤ j then a.toList.get? k else a.toList.reverse.get? k)
-      (k) : (reverse.loop as i ⟨j, hj⟩).toList.get? k = a.toList.reverse.get? k := by
+      (H : ∀ k, as.data.get? k = if i ≤ k ∧ k ≤ j then a.data.get? k else a.data.reverse.get? k)
+      (k) : (reverse.loop as i ⟨j, hj⟩).data.get? k = a.data.reverse.get? k := by
     rw [reverse.loop]; dsimp; split <;> rename_i h₁
     · have p := reverse.termination h₁
       match j with | j+1 => ?_
@@ -534,9 +519,8 @@ set_option linter.deprecated false in
       · rwa [Nat.add_right_comm i]
       · simp [size_swap, h₂]
       · intro k
-        rw [← getElem?_eq_toList_get?, get?_swap]
-        simp only [H, getElem_eq_toList_get, ← List.get?_eq_get, Nat.le_of_lt h₁,
-          getElem?_eq_toList_get?]
+        rw [← getElem?_eq_data_get?, get?_swap]
+        simp only [H, getElem_eq_data_get, ← List.get?_eq_get, Nat.le_of_lt h₁, getElem?_eq_data_get?]
         split <;> rename_i h₂
         · simp only [← h₂, Nat.not_le.2 (Nat.lt_succ_self _), Nat.le_refl, and_false]
           exact (List.get?_reverse' (j+1) i (Eq.trans (by simp_arith) h)).symm
@@ -561,7 +545,7 @@ set_option linter.deprecated false in
     · rename_i h
       simp only [← show k < _ + 1 ↔ _ from Nat.lt_succ (n := a.size - 1), this, Nat.zero_le,
         true_and, Nat.not_lt] at h
-      rw [List.get?_eq_none.2 ‹_›, List.get?_eq_none.2 (a.toList.length_reverse ▸ ‹_›)]
+      rw [List.get?_eq_none.2 ‹_›, List.get?_eq_none.2 (a.data.length_reverse ▸ ‹_›)]
 
 /-! ### foldl / foldr -/
 
@@ -601,19 +585,16 @@ theorem foldr_induction
 /-! ### map -/
 
 @[simp] theorem mem_map {f : α → β} {l : Array α} : b ∈ l.map f ↔ ∃ a, a ∈ l ∧ f a = b := by
-  simp only [mem_def, map_toList, List.mem_map]
+  simp only [mem_def, map_data, List.mem_map]
 
-theorem mapM_eq_mapM_toList [Monad m] [LawfulMonad m] (f : α → m β) (arr : Array α) :
-    arr.mapM f = return mk (← arr.toList.mapM f) := by
-  rw [mapM_eq_foldlM, foldlM_eq_foldlM_toList, ← List.foldrM_reverse]
-  conv => rhs; rw [← List.reverse_reverse arr.toList]
-  induction arr.toList.reverse with
+theorem mapM_eq_mapM_data [Monad m] [LawfulMonad m] (f : α → m β) (arr : Array α) :
+    arr.mapM f = return mk (← arr.data.mapM f) := by
+  rw [mapM_eq_foldlM, foldlM_eq_foldlM_data, ← List.foldrM_reverse]
+  conv => rhs; rw [← List.reverse_reverse arr.data]
+  induction arr.data.reverse with
   | nil => simp; rfl
   | cons a l ih => simp [ih]; simp [map_eq_pure_bind, push]
 
-@[deprecated mapM_eq_mapM_toList (since := "2024-09-09")]
-abbrev mapM_eq_mapM_data := @mapM_eq_mapM_toList
-
 theorem mapM_map_eq_foldl (as : Array α) (f : α → β) (i) :
     mapM.map (m := Id) f as i b = as.foldl (start := i) (fun r a => r.push (f a)) b := by
   unfold mapM.map
@@ -726,119 +707,95 @@ theorem mapIdx_spec (as : Array α) (f : Fin as.size → α → β)
   unfold modify modifyM Id.run
   split <;> simp
 
-theorem getElem_modify {as : Array α} {x i} (h : i < as.size) :
-    (as.modify x f)[i]'(by simp [h]) = if x = i then f as[i] else as[i] := by
-  simp only [modify, modifyM, get_eq_getElem, Id.run, Id.pure_eq]
-  split
-  · simp only [Id.bind_eq, get_set _ _ _ h]; split <;> simp [*]
-  · rw [if_neg (mt (by rintro rfl; exact h) ‹_›)]
-
-theorem getElem_modify_self {as : Array α} {i : Nat} (h : i < as.size) (f : α → α) :
-    (as.modify i f)[i]'(by simp [h]) = f as[i] := by
-  simp [getElem_modify h]
-
-theorem getElem_modify_of_ne {as : Array α} {i : Nat} (hj : j < as.size)
-    (f : α → α) (h : i ≠ j) :
-    (as.modify i f)[j]'(by rwa [size_modify]) = as[j] := by
-  simp [getElem_modify hj, h]
-
-@[deprecated getElem_modify (since := "2024-08-08")]
 theorem get_modify {arr : Array α} {x i} (h : i < arr.size) :
     (arr.modify x f).get ⟨i, by simp [h]⟩ =
     if x = i then f (arr.get ⟨i, h⟩) else arr.get ⟨i, h⟩ := by
-  simp [getElem_modify h]
+  simp [modify, modifyM, Id.run]; split
+  · simp [get_set _ _ _ h]; split <;> simp [*]
+  · rw [if_neg (mt (by rintro rfl; exact h) ‹_›)]
 
 /-! ### filter -/
 
-@[simp] theorem filter_toList (p : α → Bool) (l : Array α) :
-    (l.filter p).toList = l.toList.filter p := by
+@[simp] theorem filter_data (p : α → Bool) (l : Array α) :
+    (l.filter p).data = l.data.filter p := by
   dsimp only [filter]
-  rw [foldl_eq_foldl_toList]
-  generalize l.toList = l
-  suffices ∀ a, (List.foldl (fun r a => if p a = true then push r a else r) a l).toList =
-      a.toList ++ List.filter p l by
+  rw [foldl_eq_foldl_data]
+  generalize l.data = l
+  suffices ∀ a, (List.foldl (fun r a => if p a = true then push r a else r) a l).data =
+      a.data ++ List.filter p l by
     simpa using this #[]
   induction l with simp
   | cons => split <;> simp [*]
 
-@[deprecated filter_toList (since := "2024-09-09")]
-abbrev filter_data := @filter_toList
-
 @[simp] theorem filter_filter (q) (l : Array α) :
-    filter p (filter q l) = filter (fun a => p a && q a) l := by
+    filter p (filter q l) = filter (fun a => p a ∧ q a) l := by
   apply ext'
-  simp only [filter_toList, List.filter_filter]
+  simp only [filter_data, List.filter_filter]
 
 @[simp] theorem mem_filter : x ∈ filter p as ↔ x ∈ as ∧ p x := by
-  simp only [mem_def, filter_toList, List.mem_filter]
+  simp only [mem_def, filter_data, List.mem_filter]
 
 theorem mem_of_mem_filter {a : α} {l} (h : a ∈ filter p l) : a ∈ l :=
   (mem_filter.mp h).1
 
 /-! ### filterMap -/
 
-@[simp] theorem filterMap_toList (f : α → Option β) (l : Array α) :
-    (l.filterMap f).toList = l.toList.filterMap f := by
+@[simp] theorem filterMap_data (f : α → Option β) (l : Array α) :
+    (l.filterMap f).data = l.data.filterMap f := by
   dsimp only [filterMap, filterMapM]
-  rw [foldlM_eq_foldlM_toList]
-  generalize l.toList = l
-  have this : ∀ a : Array β, (Id.run (List.foldlM (m := Id) ?_ a l)).toList =
-    a.toList ++ List.filterMap f l := ?_
+  rw [foldlM_eq_foldlM_data]
+  generalize l.data = l
+  have this : ∀ a : Array β, (Id.run (List.foldlM (m := Id) ?_ a l)).data =
+    a.data ++ List.filterMap f l := ?_
   exact this #[]
   induction l
   · simp_all [Id.run]
   · simp_all [Id.run, List.filterMap_cons]
     split <;> simp_all
 
-@[deprecated filterMap_toList (since := "2024-09-09")]
-abbrev filterMap_data := @filterMap_toList
-
-@[simp] theorem mem_filterMap {f : α → Option β} {l : Array α} {b : β} :
+@[simp] theorem mem_filterMap (f : α → Option β) (l : Array α) {b : β} :
     b ∈ filterMap f l ↔ ∃ a, a ∈ l ∧ f a = some b := by
-  simp only [mem_def, filterMap_toList, List.mem_filterMap]
+  simp only [mem_def, filterMap_data, List.mem_filterMap]
 
 /-! ### empty -/
 
 theorem size_empty : (#[] : Array α).size = 0 := rfl
 
-theorem toList_empty : (#[] : Array α).toList = [] := rfl
-
-@[deprecated toList_empty (since := "2024-09-09")]
-abbrev empty_data := @toList_empty
+theorem empty_data : (#[] : Array α).data = [] := rfl
 
 /-! ### append -/
 
 theorem push_eq_append_singleton (as : Array α) (x) : as.push x = as ++ #[x] := rfl
 
 @[simp] theorem mem_append {a : α} {s t : Array α} : a ∈ s ++ t ↔ a ∈ s ∨ a ∈ t := by
-  simp only [mem_def, append_toList, List.mem_append]
+  simp only [mem_def, append_data, List.mem_append]
 
 theorem size_append (as bs : Array α) : (as ++ bs).size = as.size + bs.size := by
-  simp only [size, append_toList, List.length_append]
+  simp only [size, append_data, List.length_append]
 
 theorem get_append_left {as bs : Array α} {h : i < (as ++ bs).size} (hlt : i < as.size) :
     (as ++ bs)[i] = as[i] := by
-  simp only [getElem_eq_toList_getElem]
-  have h' : i < (as.toList ++ bs.toList).length := by rwa [← toList_length, append_toList] at h
-  conv => rhs; rw [← List.getElem_append_left (bs := bs.toList) (h' := h')]
-  apply List.get_of_eq; rw [append_toList]
+  simp only [getElem_eq_data_getElem]
+  have h' : i < (as.data ++ bs.data).length := by rwa [← data_length, append_data] at h
+  conv => rhs; rw [← List.getElem_append_left (bs := bs.data) (h' := h')]
+  apply List.get_of_eq; rw [append_data]
 
 theorem get_append_right {as bs : Array α} {h : i < (as ++ bs).size} (hle : as.size ≤ i)
     (hlt : i - as.size < bs.size := Nat.sub_lt_left_of_lt_add hle (size_append .. ▸ h)) :
     (as ++ bs)[i] = bs[i - as.size] := by
-  simp only [getElem_eq_toList_getElem]
-  have h' : i < (as.toList ++ bs.toList).length := by rwa [← toList_length, append_toList] at h
-  conv => rhs; rw [← List.getElem_append_right (h₁ := hle) (h₂ := h')]
-  apply List.get_of_eq; rw [append_toList]
+  simp only [getElem_eq_data_getElem]
+  have h' : i < (as.data ++ bs.data).length := by rwa [← data_length, append_data] at h
+  conv => rhs; rw [← List.getElem_append_right (h' := h') (h := Nat.not_lt_of_ge hle)]
+  apply List.get_of_eq; rw [append_data]
 
 @[simp] theorem append_nil (as : Array α) : as ++ #[] = as := by
-  apply ext'; simp only [append_toList, toList_empty, List.append_nil]
+  apply ext'; simp only [append_data, empty_data, List.append_nil]
 
 @[simp] theorem nil_append (as : Array α) : #[] ++ as = as := by
-  apply ext'; simp only [append_toList, toList_empty, List.nil_append]
+  apply ext'; simp only [append_data, empty_data, List.nil_append]
 
 theorem append_assoc (as bs cs : Array α) : as ++ bs ++ cs = as ++ (bs ++ cs) := by
-  apply ext'; simp only [append_toList, List.append_assoc]
+  apply ext'; simp only [append_data, List.append_assoc]
 
 /-! ### extract -/
 
@@ -975,7 +932,7 @@ theorem extract_empty_of_size_le_start (as : Array α) {start stop : Nat} (h : a
 /-! ### any -/
 
 -- Auxiliary for `any_iff_exists`.
-theorem anyM_loop_iff_exists {p : α → Bool} {as : Array α} {start stop} (h : stop ≤ as.size) :
+theorem anyM_loop_iff_exists (p : α → Bool) (as : Array α) (start stop) (h : stop ≤ as.size) :
     anyM.loop (m := Id) p as stop h start = true ↔
       ∃ i : Fin as.size, start ≤ ↑i ∧ ↑i < stop ∧ p as[i] = true := by
   unfold anyM.loop
@@ -997,7 +954,7 @@ theorem anyM_loop_iff_exists {p : α → Bool} {as : Array α} {start stop} (h :
 termination_by stop - start
 
 -- This could also be proved from `SatisfiesM_anyM_iff_exists` in `Batteries.Data.Array.Init.Monadic`
-theorem any_iff_exists {p : α → Bool} {as : Array α} {start stop} :
+theorem any_iff_exists (p : α → Bool) (as : Array α) (start stop) :
     any as p start stop ↔ ∃ i : Fin as.size, start ≤ i.1 ∧ i.1 < stop ∧ p as[i] := by
   dsimp [any, anyM, Id.run]
   split
@@ -1009,10 +966,10 @@ theorem any_iff_exists {p : α → Bool} {as : Array α} {start stop} :
     · rintro ⟨i, ge, _, h⟩
       exact ⟨i, by omega, by omega, h⟩
 
-theorem any_eq_true {p : α → Bool} {as : Array α} :
+theorem any_eq_true (p : α → Bool) (as : Array α) :
     any as p ↔ ∃ i : Fin as.size, p as[i] := by simp [any_iff_exists, Fin.isLt]
 
-theorem any_def {p : α → Bool} (as : Array α) : as.any p = as.toList.any p := by
+theorem any_def {p : α → Bool} (as : Array α) : as.any p = as.data.any p := by
   rw [Bool.eq_iff_iff, any_eq_true, List.any_eq_true]; simp only [List.mem_iff_get]
   exact ⟨fun ⟨i, h⟩ => ⟨_, ⟨i, rfl⟩, h⟩, fun ⟨_, ⟨i, rfl⟩, h⟩ => ⟨i, h⟩⟩
 
@@ -1023,7 +980,7 @@ theorem all_eq_not_any_not (p : α → Bool) (as : Array α) (start stop) :
   dsimp [all, allM]
   rfl
 
-theorem all_iff_forall {p : α → Bool} {as : Array α} {start stop} :
+theorem all_iff_forall (p : α → Bool) (as : Array α) (start stop) :
     all as p start stop ↔ ∀ i : Fin as.size, start ≤ i.1 ∧ i.1 < stop → p as[i] := by
   rw [all_eq_not_any_not]
   suffices ¬(any as (!p ·) start stop = true) ↔
@@ -1032,17 +989,17 @@ theorem all_iff_forall {p : α → Bool} {as : Array α} {start stop} :
   rw [any_iff_exists]
   simp
 
-theorem all_eq_true {p : α → Bool} {as : Array α} : all as p ↔ ∀ i : Fin as.size, p as[i] := by
+theorem all_eq_true (p : α → Bool) (as : Array α) : all as p ↔ ∀ i : Fin as.size, p as[i] := by
   simp [all_iff_forall, Fin.isLt]
 
-theorem all_def {p : α → Bool} (as : Array α) : as.all p = as.toList.all p := by
+theorem all_def {p : α → Bool} (as : Array α) : as.all p = as.data.all p := by
   rw [Bool.eq_iff_iff, all_eq_true, List.all_eq_true]; simp only [List.mem_iff_getElem]
   constructor
   · rintro w x ⟨r, h, rfl⟩
-    rw [← getElem_eq_toList_getElem]
+    rw [← getElem_eq_data_getElem]
     exact w ⟨r, h⟩
   · intro w i
-    exact w as[i] ⟨i, i.2, (getElem_eq_toList_getElem as i.2).symm⟩
+    exact w as[i] ⟨i, i.2, (getElem_eq_data_getElem as i.2).symm⟩
 
 theorem all_eq_true_iff_forall_mem {l : Array α} : l.all p ↔ ∀ x, x ∈ l → p x := by
   simp only [all_def, List.all_eq_true, mem_def]

src/Init/Data/Array/Mem.lean

@@ -13,11 +13,11 @@ namespace Array
 /-- `a ∈ as` is a predicate which asserts that `a` is in the array `as`. -/
 -- NB: This is defined as a structure rather than a plain def so that a lemma
 -- like `sizeOf_lt_of_mem` will not apply with no actual arrays around.
-structure Mem (as : Array α) (a : α) : Prop where
-  val : a ∈ as.toList
+structure Mem (a : α) (as : Array α) : Prop where
+  val : a ∈ as.data
 
 instance : Membership α (Array α) where
-  mem := Mem
+  mem a as := Mem a as
 
 theorem sizeOf_lt_of_mem [SizeOf α] {as : Array α} (h : a ∈ as) : sizeOf a < sizeOf as := by
   cases as with | _ as =>
@@ -38,8 +38,8 @@ macro "array_get_dec" : tactic =>
     -- subsumed by simp
     -- | with_reducible apply sizeOf_get
     -- | with_reducible apply sizeOf_getElem
-    | (with_reducible apply Nat.lt_of_lt_of_le (sizeOf_get ..)); simp_arith
-    | (with_reducible apply Nat.lt_of_lt_of_le (sizeOf_getElem ..)); simp_arith
+    | (with_reducible apply Nat.lt_trans (sizeOf_get ..)); simp_arith
+    | (with_reducible apply Nat.lt_trans (sizeOf_getElem ..)); simp_arith
     )
 
 macro_rules | `(tactic| decreasing_trivial) => `(tactic| array_get_dec)
@@ -52,7 +52,7 @@ macro "array_mem_dec" : tactic =>
   `(tactic| first
     | with_reducible apply Array.sizeOf_lt_of_mem; assumption; done
     | with_reducible
-        apply Nat.lt_of_lt_of_le (Array.sizeOf_lt_of_mem ?h)
+        apply Nat.lt_trans (Array.sizeOf_lt_of_mem ?h)
         case' h => assumption
       simp_arith)
 

src/Init/Data/Array/TakeDrop.lean

@@ -10,8 +10,8 @@ import Init.Data.List.Nat.TakeDrop
 namespace Array
 
 theorem exists_of_uset (self : Array α) (i d h) :
-    ∃ l₁ l₂, self.toList = l₁ ++ self[i] :: l₂ ∧ List.length l₁ = i.toNat ∧
-      (self.uset i d h).toList = l₁ ++ d :: l₂ := by
-  simpa [Array.getElem_eq_toList_getElem] using List.exists_of_set _
+    ∃ l₁ l₂, self.data = l₁ ++ self[i] :: l₂ ∧ List.length l₁ = i.toNat ∧
+      (self.uset i d h).data = l₁ ++ d :: l₂ := by
+  simpa [Array.getElem_eq_data_getElem] using List.exists_of_set _
 
 end Array

src/Init/Data/BEq.lean

@@ -56,5 +56,5 @@ theorem BEq.neq_of_beq_of_neq [BEq α] [PartialEquivBEq α] {a b c : α} :
 
 instance (priority := low) [BEq α] [LawfulBEq α] : EquivBEq α where
   refl := LawfulBEq.rfl
-  symm h := beq_iff_eq.2 <| Eq.symm <| beq_iff_eq.1 h
-  trans hab hbc := beq_iff_eq.2 <| (beq_iff_eq.1 hab).trans <| beq_iff_eq.1 hbc
+  symm h := (beq_iff_eq _ _).2 <| Eq.symm <| (beq_iff_eq _ _).1 h
+  trans hab hbc := (beq_iff_eq _ _).2 <| ((beq_iff_eq _ _).1 hab).trans <| (beq_iff_eq _ _).1 hbc

src/Init/Data/BitVec/Basic.lean

@@ -20,8 +20,6 @@ We define many of the bitvector operations from the
 of SMT-LIBv2.
 -/
 
-set_option linter.missingDocs true
-
 /--
 A bitvector of the specified width.
 
@@ -36,14 +34,14 @@ structure BitVec (w : Nat) where
   O(1), because we use `Fin` as the internal representation of a bitvector. -/
   toFin : Fin (2^w)
 
-/--
-Bitvectors have decidable equality. This should be used via the instance `DecidableEq (BitVec n)`.
--/
+@[deprecated (since := "2024-04-12")]
+protected abbrev Std.BitVec := _root_.BitVec
+
 -- We manually derive the `DecidableEq` instances for `BitVec` because
 -- we want to have builtin support for bit-vector literals, and we
 -- need a name for this function to implement `canUnfoldAtMatcher` at `WHNF.lean`.
-def BitVec.decEq (x y : BitVec n) : Decidable (x = y) :=
-  match x, y with
+def BitVec.decEq (a b : BitVec n) : Decidable (a = b) :=
+  match a, b with
   | ⟨n⟩, ⟨m⟩ =>
     if h : n = m then
       isTrue (h ▸ rfl)
@@ -64,14 +62,14 @@ protected def ofNatLt {n : Nat} (i : Nat) (p : i < 2^n) : BitVec n where
 /-- The `BitVec` with value `i mod 2^n`. -/
 @[match_pattern]
 protected def ofNat (n : Nat) (i : Nat) : BitVec n where
-  toFin := Fin.ofNat' (2^n) i
+  toFin := Fin.ofNat' i (Nat.two_pow_pos n)
 
 instance instOfNat : OfNat (BitVec n) i where ofNat := .ofNat n i
 instance natCastInst : NatCast (BitVec w) := ⟨BitVec.ofNat w⟩
 
-/-- Given a bitvector `x`, return the underlying `Nat`. This is O(1) because `BitVec` is a
+/-- Given a bitvector `a`, return the underlying `Nat`. This is O(1) because `BitVec` is a
 (zero-cost) wrapper around a `Nat`. -/
-protected def toNat (x : BitVec n) : Nat := x.toFin.val
+protected def toNat (a : BitVec n) : Nat := a.toFin.val
 
 /-- Return the bound in terms of toNat. -/
 theorem isLt (x : BitVec w) : x.toNat < 2^w := x.toFin.isLt
@@ -116,73 +114,25 @@ end zero_allOnes
 
 section getXsb
 
-/--
-Return the `i`-th least significant bit.
-
-This will be renamed `getLsb` after the existing deprecated alias is removed.
--/
-@[inline] def getLsb' (x : BitVec w) (i : Fin w) : Bool := x.toNat.testBit i
-
-/-- Return the `i`-th least significant bit or `none` if `i ≥ w`. -/
-@[inline] def getLsb? (x : BitVec w) (i : Nat) : Option Bool :=
-  if h : i < w then some (getLsb' x ⟨i, h⟩) else none
-
-/--
-Return the `i`-th most significant bit.
-
-This will be renamed `getMsb` after the existing deprecated alias is removed.
--/
-@[inline] def getMsb' (x : BitVec w) (i : Fin w) : Bool := x.getLsb' ⟨w-1-i, by omega⟩
-
-/-- Return the `i`-th most significant bit or `none` if `i ≥ w`. -/
-@[inline] def getMsb? (x : BitVec w) (i : Nat) : Option Bool :=
-  if h : i < w then some (getMsb' x ⟨i, h⟩) else none
-
 /-- Return the `i`-th least significant bit or `false` if `i ≥ w`. -/
-@[inline] def getLsbD (x : BitVec w) (i : Nat) : Bool :=
-  x.toNat.testBit i
-
-@[deprecated getLsbD (since := "2024-08-29"), inherit_doc getLsbD]
-def getLsb (x : BitVec w) (i : Nat) : Bool := x.getLsbD i
+@[inline] def getLsb (x : BitVec w) (i : Nat) : Bool := x.toNat.testBit i
 
 /-- Return the `i`-th most significant bit or `false` if `i ≥ w`. -/
-@[inline] def getMsbD (x : BitVec w) (i : Nat) : Bool :=
-  i < w && x.getLsbD (w-1-i)
-
-@[deprecated getMsbD (since := "2024-08-29"), inherit_doc getMsbD]
-def getMsb (x : BitVec w) (i : Nat) : Bool := x.getMsbD i
+@[inline] def getMsb (x : BitVec w) (i : Nat) : Bool := i < w && getLsb x (w-1-i)
 
 /-- Return most-significant bit in bitvector. -/
-@[inline] protected def msb (x : BitVec n) : Bool := getMsbD x 0
+@[inline] protected def msb (a : BitVec n) : Bool := getMsb a 0
 
 end getXsb
 
-section getElem
-
-instance : GetElem (BitVec w) Nat Bool fun _ i => i < w where
-  getElem xs i h := xs.getLsb' ⟨i, h⟩
-
-/-- We prefer `x[i]` as the simp normal form for `getLsb'` -/
-@[simp] theorem getLsb'_eq_getElem (x : BitVec w) (i : Fin w) :
-    x.getLsb' i = x[i] := rfl
-
-/-- We prefer `x[i]?` as the simp normal form for `getLsb?` -/
-@[simp] theorem getLsb?_eq_getElem? (x : BitVec w) (i : Nat) :
-    x.getLsb? i = x[i]? := rfl
-
-theorem getElem_eq_testBit_toNat (x : BitVec w) (i : Nat) (h : i < w) :
-  x[i] = x.toNat.testBit i := rfl
-
-end getElem
-
 section Int
 
 /-- Interpret the bitvector as an integer stored in two's complement form. -/
-protected def toInt (x : BitVec n) : Int :=
-  if 2 * x.toNat < 2^n then
-    x.toNat
+protected def toInt (a : BitVec n) : Int :=
+  if 2 * a.toNat < 2^n then
+    a.toNat
   else
-    (x.toNat : Int) - (2^n : Nat)
+    (a.toNat : Int) - (2^n : Nat)
 
 /-- The `BitVec` with value `(2^n + (i mod 2^n)) mod 2^n`.  -/
 protected def ofInt (n : Nat) (i : Int) : BitVec n := .ofNatLt (i % (Int.ofNat (2^n))).toNat (by
@@ -263,7 +213,7 @@ instance : Neg (BitVec n) := ⟨.neg⟩
 /--
 Return the absolute value of a signed bitvector.
 -/
-protected def abs (x : BitVec n) : BitVec n := if x.msb then .neg x else x
+protected def abs (s : BitVec n) : BitVec n := if s.msb then .neg s else s
 
 /--
 Multiplication for bit vectors. This can be interpreted as either signed or unsigned negation
@@ -310,12 +260,12 @@ sdiv 5#4 -2 = -2#4
 sdiv (-7#4) (-2) = 3#4
 ```
 -/
-def sdiv (x y : BitVec n) : BitVec n :=
-  match x.msb, y.msb with
-  | false, false => udiv x y
-  | false, true  => .neg (udiv x (.neg y))
-  | true,  false => .neg (udiv (.neg x) y)
-  | true,  true  => udiv (.neg x) (.neg y)
+def sdiv (s t : BitVec n) : BitVec n :=
+  match s.msb, t.msb with
+  | false, false => udiv s t
+  | false, true  => .neg (udiv s (.neg t))
+  | true,  false => .neg (udiv (.neg s) t)
+  | true,  true  => udiv (.neg s) (.neg t)
 
 /--
 Signed division for bit vectors using SMTLIB rules for division by zero.
@@ -324,40 +274,40 @@ Specifically, `smtSDiv x 0 = if x >= 0 then -1 else 1`
 
 SMT-Lib name: `bvsdiv`.
 -/
-def smtSDiv (x y : BitVec n) : BitVec n :=
-  match x.msb, y.msb with
-  | false, false => smtUDiv x y
-  | false, true  => .neg (smtUDiv x (.neg y))
-  | true,  false => .neg (smtUDiv (.neg x) y)
-  | true,  true  => smtUDiv (.neg x) (.neg y)
+def smtSDiv (s t : BitVec n) : BitVec n :=
+  match s.msb, t.msb with
+  | false, false => smtUDiv s t
+  | false, true  => .neg (smtUDiv s (.neg t))
+  | true,  false => .neg (smtUDiv (.neg s) t)
+  | true,  true  => smtUDiv (.neg s) (.neg t)
 
 /--
 Remainder for signed division rounding to zero.
 
 SMT_Lib name: `bvsrem`.
 -/
-def srem (x y : BitVec n) : BitVec n :=
-  match x.msb, y.msb with
-  | false, false => umod x y
-  | false, true  => umod x (.neg y)
-  | true,  false => .neg (umod (.neg x) y)
-  | true,  true  => .neg (umod (.neg x) (.neg y))
+def srem (s t : BitVec n) : BitVec n :=
+  match s.msb, t.msb with
+  | false, false => umod s t
+  | false, true  => umod s (.neg t)
+  | true,  false => .neg (umod (.neg s) t)
+  | true,  true  => .neg (umod (.neg s) (.neg t))
 
 /--
 Remainder for signed division rounded to negative infinity.
 
 SMT_Lib name: `bvsmod`.
 -/
-def smod (x y : BitVec m) : BitVec m :=
-  match x.msb, y.msb with
-  | false, false => umod x y
+def smod (s t : BitVec m) : BitVec m :=
+  match s.msb, t.msb with
+  | false, false => umod s t
   | false, true =>
-    let u := umod x (.neg y)
-    (if u = .zero m then u else .add u y)
+    let u := umod s (.neg t)
+    (if u = .zero m then u else .add u t)
   | true, false =>
-    let u := umod (.neg x) y
-    (if u = .zero m then u else .sub y u)
-  | true, true => .neg (umod (.neg x) (.neg y))
+    let u := umod (.neg s) t
+    (if u = .zero m then u else .sub t u)
+  | true, true => .neg (umod (.neg s) (.neg t))
 
 end arithmetic
 
@@ -421,8 +371,8 @@ end relations
 
 section cast
 
-/-- `cast eq x` embeds `x` into an equal `BitVec` type. -/
-@[inline] def cast (eq : n = m) (x : BitVec n) : BitVec m := .ofNatLt x.toNat (eq ▸ x.isLt)
+/-- `cast eq i` embeds `i` into an equal `BitVec` type. -/
+@[inline] def cast (eq : n = m) (i : BitVec n) : BitVec m := .ofNatLt i.toNat (eq ▸ i.isLt)
 
 @[simp] theorem cast_ofNat {n m : Nat} (h : n = m) (x : Nat) :
     cast h (BitVec.ofNat n x) = BitVec.ofNat m x := by
@@ -439,7 +389,7 @@ Extraction of bits `start` to `start + len - 1` from a bit vector of size `n` to
 new bitvector of size `len`. If `start + len > n`, then the vector will be zero-padded in the
 high bits.
 -/
-def extractLsb' (start len : Nat) (x : BitVec n) : BitVec len := .ofNat _ (x.toNat >>> start)
+def extractLsb' (start len : Nat) (a : BitVec n) : BitVec len := .ofNat _ (a.toNat >>> start)
 
 /--
 Extraction of bits `hi` (inclusive) down to `lo` (inclusive) from a bit vector of size `n` to
@@ -447,12 +397,12 @@ yield a new bitvector of size `hi - lo + 1`.
 
 SMT-Lib name: `extract`.
 -/
-def extractLsb (hi lo : Nat) (x : BitVec n) : BitVec (hi - lo + 1) := extractLsb' lo _ x
+def extractLsb (hi lo : Nat) (a : BitVec n) : BitVec (hi - lo + 1) := extractLsb' lo _ a
 
 /--
 A version of `zeroExtend` that requires a proof, but is a noop.
 -/
-def zeroExtend' {n w : Nat} (le : n ≤ w) (x : BitVec n) : BitVec w :=
+def zeroExtend' {n w : Nat} (le : n ≤ w) (x : BitVec n)  : BitVec w :=
   x.toNat#'(by
     apply Nat.lt_of_lt_of_le x.isLt
     exact Nat.pow_le_pow_of_le_right (by trivial) le)
@@ -461,8 +411,8 @@ def zeroExtend' {n w : Nat} (le : n ≤ w) (x : BitVec n) : BitVec w :=
 `shiftLeftZeroExtend x n` returns `zeroExtend (w+n) x <<< n` without
 needing to compute `x % 2^(2+n)`.
 -/
-def shiftLeftZeroExtend (msbs : BitVec w) (m : Nat) : BitVec (w + m) :=
-  let shiftLeftLt {x : Nat} (p : x < 2^w) (m : Nat) : x <<< m < 2^(w + m) := by
+def shiftLeftZeroExtend (msbs : BitVec w) (m : Nat) : BitVec (w+m) :=
+  let shiftLeftLt {x : Nat} (p : x < 2^w) (m : Nat) : x <<< m < 2^(w+m) := by
         simp [Nat.shiftLeft_eq, Nat.pow_add]
         apply Nat.mul_lt_mul_of_pos_right p
         exact (Nat.two_pow_pos m)
@@ -550,24 +500,24 @@ instance : Complement (BitVec w) := ⟨.not⟩
 
 /--
 Left shift for bit vectors. The low bits are filled with zeros. As a numeric operation, this is
-equivalent to `x * 2^s`, modulo `2^n`.
+equivalent to `a * 2^s`, modulo `2^n`.
 
 SMT-Lib name: `bvshl` except this operator uses a `Nat` shift value.
 -/
-protected def shiftLeft (x : BitVec n) (s : Nat) : BitVec n := BitVec.ofNat n (x.toNat <<< s)
+protected def shiftLeft (a : BitVec n) (s : Nat) : BitVec n := BitVec.ofNat n (a.toNat <<< s)
 instance : HShiftLeft (BitVec w) Nat (BitVec w) := ⟨.shiftLeft⟩
 
 /--
 (Logical) right shift for bit vectors. The high bits are filled with zeros.
-As a numeric operation, this is equivalent to `x / 2^s`, rounding down.
+As a numeric operation, this is equivalent to `a / 2^s`, rounding down.
 
 SMT-Lib name: `bvlshr` except this operator uses a `Nat` shift value.
 -/
-def ushiftRight (x : BitVec n) (s : Nat) : BitVec n :=
-  (x.toNat >>> s)#'(by
-  let ⟨x, lt⟩ := x
+def ushiftRight (a : BitVec n) (s : Nat) : BitVec n :=
+  (a.toNat >>> s)#'(by
+  let ⟨a, lt⟩ := a
   simp only [BitVec.toNat, Nat.shiftRight_eq_div_pow, Nat.div_lt_iff_lt_mul (Nat.two_pow_pos s)]
-  rw [←Nat.mul_one x]
+  rw [←Nat.mul_one a]
   exact Nat.mul_lt_mul_of_lt_of_le' lt (Nat.two_pow_pos s) (Nat.le_refl 1))
 
 instance : HShiftRight (BitVec w) Nat (BitVec w) := ⟨.ushiftRight⟩
@@ -575,24 +525,15 @@ instance : HShiftRight (BitVec w) Nat (BitVec w) := ⟨.ushiftRight⟩
 /--
 Arithmetic right shift for bit vectors. The high bits are filled with the
 most-significant bit.
-As a numeric operation, this is equivalent to `x.toInt >>> s`.
+As a numeric operation, this is equivalent to `a.toInt >>> s`.
 
 SMT-Lib name: `bvashr` except this operator uses a `Nat` shift value.
 -/
-def sshiftRight (x : BitVec n) (s : Nat) : BitVec n := .ofInt n (x.toInt >>> s)
+def sshiftRight (a : BitVec n) (s : Nat) : BitVec n := .ofInt n (a.toInt >>> s)
 
 instance {n} : HShiftLeft  (BitVec m) (BitVec n) (BitVec m) := ⟨fun x y => x <<< y.toNat⟩
 instance {n} : HShiftRight (BitVec m) (BitVec n) (BitVec m) := ⟨fun x y => x >>> y.toNat⟩
 
-/--
-Arithmetic right shift for bit vectors. The high bits are filled with the
-most-significant bit.
-As a numeric operation, this is equivalent to `a.toInt >>> s.toNat`.
-
-SMT-Lib name: `bvashr`.
--/
-def sshiftRight' (a : BitVec n) (s : BitVec m) : BitVec n := a.sshiftRight s.toNat
-
 /-- Auxiliary function for `rotateLeft`, which does not take into account the case where
 the rotation amount is greater than the bitvector width. -/
 def rotateLeftAux (x : BitVec w) (n : Nat) : BitVec w :=
@@ -642,9 +583,11 @@ instance : HAppend (BitVec w) (BitVec v) (BitVec (w + v)) := ⟨.append⟩
 -- TODO: write this using multiplication
 /-- `replicate i x` concatenates `i` copies of `x` into a new vector of length `w*i`. -/
 def replicate : (i : Nat) → BitVec w → BitVec (w*i)
-  | 0,   _ => 0#0
+  | 0,   _ => 0
   | n+1, x =>
-    (x ++ replicate n x).cast (by rw [Nat.mul_succ]; omega)
+    have hEq : w + w*n = w*(n + 1) := by
+      rw [Nat.mul_add, Nat.add_comm, Nat.mul_one]
+    hEq ▸ (x ++ replicate n x)
 
 /-!
 ### Cons and Concat

src/Init/Data/BitVec/Bitblast.lean

@@ -28,8 +28,6 @@ https://github.com/mhk119/lean-smt/blob/bitvec/Smt/Data/Bitwise.lean.
 
 -/
 
-set_option linter.missingDocs true
-
 open Nat Bool
 
 namespace Bool
@@ -92,8 +90,8 @@ def carry (i : Nat) (x y : BitVec w) (c : Bool) : Bool :=
   cases c <;> simp [carry, mod_one]
 
 theorem carry_succ (i : Nat) (x y : BitVec w) (c : Bool) :
-    carry (i+1) x y c = atLeastTwo (x.getLsbD i) (y.getLsbD i) (carry i x y c) := by
-  simp only [carry, mod_two_pow_succ, atLeastTwo, getLsbD]
+    carry (i+1) x y c = atLeastTwo (x.getLsb i) (y.getLsb i) (carry i x y c) := by
+  simp only [carry, mod_two_pow_succ, atLeastTwo, getLsb]
   simp only [Nat.pow_succ']
   have sum_bnd : x.toNat%2^i + (y.toNat%2^i + c.toNat) < 2*2^i := by
     simp only [← Nat.pow_succ']
@@ -110,7 +108,7 @@ theorem carry_of_and_eq_zero {x y : BitVec w} (h : x &&& y = 0#w) : carry i x y
   induction i with
   | zero => simp
   | succ i ih =>
-    replace h := congrArg (·.getLsbD i) h
+    replace h := congrArg (·.getLsb i) h
     simp_all [carry_succ]
 
 /-- The final carry bit when computing `x + y + c` is `true` iff `x.toNat + y.toNat + c.toNat ≥ 2^w`. -/
@@ -136,14 +134,14 @@ def adcb (x y c : Bool) : Bool × Bool := (atLeastTwo x y c, Bool.xor x (Bool.xo
 
 /-- Bitwise addition implemented via a ripple carry adder. -/
 def adc (x y : BitVec w) : Bool → Bool × BitVec w :=
-  iunfoldr fun (i : Fin w) c => adcb (x.getLsbD i) (y.getLsbD i) c
+  iunfoldr fun (i : Fin w) c => adcb (x.getLsb i) (y.getLsb i) c
 
-theorem getLsbD_add_add_bool {i : Nat} (i_lt : i < w) (x y : BitVec w) (c : Bool) :
-    getLsbD (x + y + zeroExtend w (ofBool c)) i =
-      Bool.xor (getLsbD x i) (Bool.xor (getLsbD y i) (carry i x y c)) := by
+theorem getLsb_add_add_bool {i : Nat} (i_lt : i < w) (x y : BitVec w) (c : Bool) :
+    getLsb (x + y + zeroExtend w (ofBool c)) i =
+      Bool.xor (getLsb x i) (Bool.xor (getLsb y i) (carry i x y c)) := by
   let ⟨x, x_lt⟩ := x
   let ⟨y, y_lt⟩ := y
-  simp only [getLsbD, toNat_add, toNat_zeroExtend, i_lt, toNat_ofFin, toNat_ofBool,
+  simp only [getLsb, toNat_add, toNat_zeroExtend, i_lt, toNat_ofFin, toNat_ofBool,
     Nat.mod_add_mod, Nat.add_mod_mod]
   apply Eq.trans
   rw [← Nat.div_add_mod x (2^i), ← Nat.div_add_mod y (2^i)]
@@ -159,10 +157,10 @@ theorem getLsbD_add_add_bool {i : Nat} (i_lt : i < w) (x y : BitVec w) (c : Bool
     ]
   simp [testBit_to_div_mod, carry, Nat.add_assoc]
 
-theorem getLsbD_add {i : Nat} (i_lt : i < w) (x y : BitVec w) :
-    getLsbD (x + y) i =
-      Bool.xor (getLsbD x i) (Bool.xor (getLsbD y i) (carry i x y false)) := by
-  simpa using getLsbD_add_add_bool i_lt x y false
+theorem getLsb_add {i : Nat} (i_lt : i < w) (x y : BitVec w) :
+    getLsb (x + y) i =
+      Bool.xor (getLsb x i) (Bool.xor (getLsb y i) (carry i x y false)) := by
+  simpa using getLsb_add_add_bool i_lt x y false
 
 theorem adc_spec (x y : BitVec w) (c : Bool) :
     adc x y c = (carry w x y c, x + y + zeroExtend w (ofBool c)) := by
@@ -175,7 +173,7 @@ theorem adc_spec (x y : BitVec w) (c : Bool) :
     simp [carry, Nat.mod_one]
     cases c <;> rfl
   case step =>
-    simp [adcb, Prod.mk.injEq, carry_succ, getLsbD_add_add_bool]
+    simp [adcb, Prod.mk.injEq, carry_succ, getLsb_add_add_bool]
 
 theorem add_eq_adc (w : Nat) (x y : BitVec w) : x + y = (adc x y false).snd := by
   simp [adc_spec]
@@ -197,37 +195,37 @@ theorem add_eq_or_of_and_eq_zero {w : Nat} (x y : BitVec w)
     (h : x &&& y = 0#w) : x + y = x ||| y := by
   rw [add_eq_adc, adc, iunfoldr_replace (fun _ => false) (x ||| y)]
   · rfl
-  · simp only [adcb, atLeastTwo, Bool.and_false, Bool.or_false, bne_false, getLsbD_or,
+  · simp only [adcb, atLeastTwo, Bool.and_false, Bool.or_false, bne_false, getLsb_or,
     Prod.mk.injEq, and_eq_false_imp]
     intros i
-    replace h : (x &&& y).getLsbD i = (0#w).getLsbD i := by rw [h]
-    simp only [getLsbD_and, getLsbD_zero, and_eq_false_imp] at h
+    replace h : (x &&& y).getLsb i = (0#w).getLsb i := by rw [h]
+    simp only [getLsb_and, getLsb_zero, and_eq_false_imp] at h
     constructor
     · intros hx
       simp_all [hx]
-    · by_cases hx : x.getLsbD i <;> simp_all [hx]
+    · by_cases hx : x.getLsb i <;> simp_all [hx]
 
 /-! ### Negation -/
 
 theorem bit_not_testBit (x : BitVec w) (i : Fin w) :
-  getLsbD (((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsbD i)))) ()).snd) i.val = !(getLsbD x i.val) := by
-  apply iunfoldr_getLsbD (fun _ => ()) i (by simp)
+  getLsb (((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsb i)))) ()).snd) i.val = !(getLsb x i.val) := by
+  apply iunfoldr_getLsb (fun _ => ()) i (by simp)
 
 theorem bit_not_add_self (x : BitVec w) :
-  ((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsbD i)))) ()).snd + x  = -1 := by
+  ((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsb i)))) ()).snd + x  = -1 := by
   simp only [add_eq_adc]
   apply iunfoldr_replace_snd (fun _ => false) (-1) false rfl
   intro i; simp only [ BitVec.not, adcb, testBit_toNat]
-  rw [iunfoldr_replace_snd (fun _ => ()) (((iunfoldr (fun i c => (c, !(x.getLsbD i)))) ()).snd)]
-  <;> simp [bit_not_testBit, negOne_eq_allOnes, getLsbD_allOnes]
+  rw [iunfoldr_replace_snd (fun _ => ()) (((iunfoldr (fun i c => (c, !(x.getLsb i)))) ()).snd)]
+  <;> simp [bit_not_testBit, negOne_eq_allOnes, getLsb_allOnes]
 
 theorem bit_not_eq_not (x : BitVec w) :
-  ((iunfoldr (fun i c => (c, !(x.getLsbD i)))) ()).snd = ~~~ x := by
+  ((iunfoldr (fun i c => (c, !(x.getLsb i)))) ()).snd = ~~~ x := by
   simp [←allOnes_sub_eq_not, BitVec.eq_sub_iff_add_eq.mpr (bit_not_add_self x), ←negOne_eq_allOnes]
 
-theorem bit_neg_eq_neg (x : BitVec w) : -x = (adc (((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsbD i)))) ()).snd) (BitVec.ofNat w 1) false).snd:= by
+theorem bit_neg_eq_neg (x : BitVec w) : -x = (adc (((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsb i)))) ()).snd) (BitVec.ofNat w 1) false).snd:= by
   simp only [← add_eq_adc]
-  rw [iunfoldr_replace_snd ((fun _ => ())) (((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsbD i)))) ()).snd) _ rfl]
+  rw [iunfoldr_replace_snd ((fun _ => ())) (((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsb i)))) ()).snd) _ rfl]
   · rw [BitVec.eq_sub_iff_add_eq.mpr (bit_not_add_self x), sub_toAdd, BitVec.add_comm _ (-x)]
     simp [← sub_toAdd, BitVec.sub_add_cancel]
   · simp [bit_not_testBit x _]
@@ -289,18 +287,18 @@ theorem sle_eq_carry (x y : BitVec w) :
 A recurrence that describes multiplication as repeated addition.
 Is useful for bitblasting multiplication.
 -/
-def mulRec (x y : BitVec w) (s : Nat) : BitVec w :=
-  let cur := if y.getLsbD s then (x <<< s) else 0
+def mulRec (l r : BitVec w) (s : Nat) : BitVec w :=
+  let cur := if r.getLsb s then (l <<< s) else 0
   match s with
   | 0 => cur
-  | s + 1 => mulRec x y s + cur
+  | s + 1 => mulRec l r s + cur
 
-theorem mulRec_zero_eq (x y : BitVec w) :
-    mulRec x y 0 = if y.getLsbD 0 then x else 0 := by
+theorem mulRec_zero_eq (l r : BitVec w) :
+    mulRec l r 0 = if r.getLsb 0 then l else 0 := by
   simp [mulRec]
 
-theorem mulRec_succ_eq (x y : BitVec w) (s : Nat) :
-    mulRec x y (s + 1) = mulRec x y s + if y.getLsbD (s + 1) then (x <<< (s + 1)) else 0 := rfl
+theorem mulRec_succ_eq (l r : BitVec w) (s : Nat) :
+    mulRec l r (s + 1) = mulRec l r s + if r.getLsb (s + 1) then (l <<< (s + 1)) else 0 := rfl
 
 /--
 Recurrence lemma: truncating to `i+1` bits and then zero extending to `w`
@@ -311,49 +309,48 @@ theorem zeroExtend_truncate_succ_eq_zeroExtend_truncate_add_twoPow (x : BitVec w
       zeroExtend w (x.truncate i) + (x &&& twoPow w i) := by
   rw [add_eq_or_of_and_eq_zero]
   · ext k
-    simp only [getLsbD_zeroExtend, Fin.is_lt, decide_True, Bool.true_and, getLsbD_or, getLsbD_and]
+    simp only [getLsb_zeroExtend, Fin.is_lt, decide_True, Bool.true_and, getLsb_or, getLsb_and]
     by_cases hik : i = k
     · subst hik
       simp
-    · simp only [getLsbD_twoPow, hik, decide_False, Bool.and_false, Bool.or_false]
+    · simp only [getLsb_twoPow, hik, decide_False, Bool.and_false, Bool.or_false]
       by_cases hik' : k < (i + 1)
       · have hik'' : k < i := by omega
         simp [hik', hik'']
       · have hik'' : ¬ (k < i) := by omega
         simp [hik', hik'']
   · ext k
-    simp only [and_twoPow, getLsbD_and, getLsbD_zeroExtend, Fin.is_lt, decide_True, Bool.true_and,
-      getLsbD_zero, and_eq_false_imp, and_eq_true, decide_eq_true_eq, and_imp]
-    by_cases hi : x.getLsbD i <;> simp [hi] <;> omega
+    simp
+    by_cases hi : x.getLsb i <;> simp [hi] <;> omega
 
 /--
-Recurrence lemma: multiplying `x` with the first `s` bits of `y` is the
-same as truncating `y` to `s` bits, then zero extending to the original length,
+Recurrence lemma: multiplying `l` with the first `s` bits of `r` is the
+same as truncating `r` to `s` bits, then zero extending to the original length,
 and performing the multplication. -/
-theorem mulRec_eq_mul_signExtend_truncate (x y : BitVec w) (s : Nat) :
-    mulRec x y s = x * ((y.truncate (s + 1)).zeroExtend w) := by
+theorem mulRec_eq_mul_signExtend_truncate (l r : BitVec w) (s : Nat) :
+    mulRec l r s = l * ((r.truncate (s + 1)).zeroExtend w) := by
   induction s
   case zero =>
     simp only [mulRec_zero_eq, ofNat_eq_ofNat, Nat.reduceAdd]
-    by_cases y.getLsbD 0
-    case pos hy =>
-      simp only [hy, ↓reduceIte, truncate, zeroExtend_one_eq_ofBool_getLsb_zero,
-        ofBool_true, ofNat_eq_ofNat]
+    by_cases r.getLsb 0
+    case pos hr =>
+      simp only [hr, ↓reduceIte, truncate, zeroExtend_one_eq_ofBool_getLsb_zero,
+        hr, ofBool_true, ofNat_eq_ofNat]
       rw [zeroExtend_ofNat_one_eq_ofNat_one_of_lt (by omega)]
       simp
-    case neg hy =>
-      simp [hy, zeroExtend_one_eq_ofBool_getLsb_zero]
+    case neg hr =>
+      simp [hr, zeroExtend_one_eq_ofBool_getLsb_zero]
   case succ s' hs =>
     rw [mulRec_succ_eq, hs]
     have heq :
-      (if y.getLsbD (s' + 1) = true then x <<< (s' + 1) else 0) =
-        (x * (y &&& (BitVec.twoPow w (s' + 1)))) := by
+      (if r.getLsb (s' + 1) = true then l <<< (s' + 1) else 0) =
+        (l * (r &&& (BitVec.twoPow w (s' + 1)))) := by
       simp only [ofNat_eq_ofNat, and_twoPow]
-      by_cases hy : y.getLsbD (s' + 1) <;> simp [hy]
+      by_cases hr : r.getLsb (s' + 1) <;> simp [hr]
     rw [heq, ← BitVec.mul_add, ← zeroExtend_truncate_succ_eq_zeroExtend_truncate_add_twoPow]
 
-theorem getLsbD_mul (x y : BitVec w) (i : Nat) :
-    (x * y).getLsbD i = (mulRec x y w).getLsbD i := by
+theorem getLsb_mul (x y : BitVec w) (i : Nat) :
+    (x * y).getLsb i = (mulRec x y w).getLsb i := by
   simp only [mulRec_eq_mul_signExtend_truncate]
   rw [truncate, ← truncate_eq_zeroExtend, ← truncate_eq_zeroExtend,
     truncate_truncate_of_le]
@@ -407,17 +404,17 @@ theorem shiftLeftRec_eq {x : BitVec w₁} {y : BitVec w₂} {n : Nat} :
   case zero =>
     ext i
     simp only [shiftLeftRec_zero, twoPow_zero, Nat.reduceAdd, truncate_one,
-      and_one_eq_zeroExtend_ofBool_getLsbD]
+      and_one_eq_zeroExtend_ofBool_getLsb]
   case succ n ih =>
     simp only [shiftLeftRec_succ, and_twoPow]
     rw [ih]
-    by_cases h : y.getLsbD (n + 1)
+    by_cases h : y.getLsb (n + 1)
     · simp only [h, ↓reduceIte]
-      rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_or_twoPow_of_getLsbD_true h,
+      rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_or_twoPow_of_getLsb_true h,
         shiftLeft_or_of_and_eq_zero]
-      simp [and_twoPow]
+      simp
     · simp only [h, false_eq_true, ↓reduceIte, shiftLeft_zero']
-      rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_of_getLsbD_false (i := n + 1)]
+      rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_of_getLsb_false (i := n + 1)]
       simp [h]
 
 /--
@@ -430,67 +427,6 @@ theorem shiftLeft_eq_shiftLeftRec (x : BitVec w₁) (y : BitVec w₂) :
   · simp [of_length_zero]
   · simp [shiftLeftRec_eq]
 
-/- ### Arithmetic shift right (sshiftRight) recurrence -/
-
-/--
-`sshiftRightRec x y n` shifts `x` arithmetically/signed to the right by the first `n` bits of `y`.
-The theorem `sshiftRight_eq_sshiftRightRec` proves the equivalence of `(x.sshiftRight y)` and `sshiftRightRec`.
-Together with equations `sshiftRightRec_zero`, `sshiftRightRec_succ`,
-this allows us to unfold `sshiftRight` into a circuit for bitblasting.
--/
-def sshiftRightRec (x : BitVec w₁) (y : BitVec w₂) (n : Nat) : BitVec w₁ :=
-  let shiftAmt := (y &&& (twoPow w₂ n))
-  match n with
-  | 0 => x.sshiftRight' shiftAmt
-  | n + 1 => (sshiftRightRec x y n).sshiftRight' shiftAmt
-
-@[simp]
-theorem sshiftRightRec_zero_eq (x : BitVec w₁) (y : BitVec w₂) :
-    sshiftRightRec x y 0 = x.sshiftRight' (y &&& 1#w₂) := by
-  simp only [sshiftRightRec, twoPow_zero]
-
-@[simp]
-theorem sshiftRightRec_succ_eq (x : BitVec w₁) (y : BitVec w₂) (n : Nat) :
-    sshiftRightRec x y (n + 1) = (sshiftRightRec x y n).sshiftRight' (y &&& twoPow w₂ (n + 1)) := by
-  simp [sshiftRightRec]
-
-/--
-If `y &&& z = 0`, `x.sshiftRight (y ||| z) = (x.sshiftRight y).sshiftRight z`.
-This follows as `y &&& z = 0` implies `y ||| z = y + z`,
-and thus `x.sshiftRight (y ||| z) = x.sshiftRight (y + z) = (x.sshiftRight y).sshiftRight z`.
--/
-theorem sshiftRight'_or_of_and_eq_zero {x : BitVec w₁} {y z : BitVec w₂}
-    (h : y &&& z = 0#w₂) :
-    x.sshiftRight' (y ||| z) = (x.sshiftRight' y).sshiftRight' z := by
-  simp [sshiftRight', ← add_eq_or_of_and_eq_zero _ _ h,
-    toNat_add_of_and_eq_zero h, sshiftRight_add]
-
-theorem sshiftRightRec_eq (x : BitVec w₁) (y : BitVec w₂) (n : Nat) :
-    sshiftRightRec x y n = x.sshiftRight' ((y.truncate (n + 1)).zeroExtend w₂) := by
-  induction n generalizing x y
-  case zero =>
-    ext i
-    simp [twoPow_zero, Nat.reduceAdd, and_one_eq_zeroExtend_ofBool_getLsbD, truncate_one]
-  case succ n ih =>
-    simp only [sshiftRightRec_succ_eq, and_twoPow, ih]
-    by_cases h : y.getLsbD (n + 1)
-    · rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_or_twoPow_of_getLsbD_true h,
-        sshiftRight'_or_of_and_eq_zero (by simp [and_twoPow]), h]
-      simp
-    · rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_of_getLsbD_false (i := n + 1)
-        (by simp [h])]
-      simp [h]
-
-/--
-Show that `x.sshiftRight y` can be written in terms of `sshiftRightRec`.
-This can be unfolded in terms of `sshiftRightRec_zero_eq`, `sshiftRightRec_succ_eq` for bitblasting.
--/
-theorem sshiftRight_eq_sshiftRightRec (x : BitVec w₁) (y : BitVec w₂) :
-    (x.sshiftRight' y).getLsbD i = (sshiftRightRec x y (w₂ - 1)).getLsbD i := by
-  rcases w₂ with rfl | w₂
-  · simp [of_length_zero]
-  · simp [sshiftRightRec_eq]
-
 /- ### Logical shift right (ushiftRight) recurrence for bitblasting -/
 
 /--
@@ -534,15 +470,15 @@ theorem ushiftRightRec_eq (x : BitVec w₁) (y : BitVec w₂) (n : Nat) :
   case zero =>
     ext i
     simp only [ushiftRightRec_zero, twoPow_zero, Nat.reduceAdd,
-      and_one_eq_zeroExtend_ofBool_getLsbD, truncate_one]
+      and_one_eq_zeroExtend_ofBool_getLsb, truncate_one]
   case succ n ih =>
     simp only [ushiftRightRec_succ, and_twoPow]
     rw [ih]
-    by_cases h : y.getLsbD (n + 1) <;> simp only [h, ↓reduceIte]
-    · rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_or_twoPow_of_getLsbD_true h,
+    by_cases h : y.getLsb (n + 1) <;> simp only [h, ↓reduceIte]
+    · rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_or_twoPow_of_getLsb_true h,
         ushiftRight'_or_of_and_eq_zero]
-      simp [and_twoPow]
-    · simp [zeroExtend_truncate_succ_eq_zeroExtend_truncate_of_getLsbD_false, h]
+      simp
+    · simp [zeroExtend_truncate_succ_eq_zeroExtend_truncate_of_getLsb_false, h]
 
 /--
 Show that `x >>> y` can be written in terms of `ushiftRightRec`.

src/Init/Data/BitVec/Folds.lean

@@ -8,8 +8,6 @@ import Init.Data.BitVec.Lemmas
 import Init.Data.Nat.Lemmas
 import Init.Data.Fin.Iterate
 
-set_option linter.missingDocs true
-
 namespace BitVec
 
 /--
@@ -41,7 +39,7 @@ theorem iunfoldr.fst_eq
 private theorem iunfoldr.eq_test
     {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α)
     (init : state 0 = a)
-    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsbD i.val)) :
+    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsb i.val)) :
     iunfoldr f a = (state w, BitVec.truncate w value) := by
   apply Fin.hIterate_eq (fun i => ((state i, BitVec.truncate i value) : α × BitVec i))
   case init =>
@@ -50,15 +48,15 @@ private theorem iunfoldr.eq_test
     intro i
     simp_all [truncate_succ]
 
-theorem iunfoldr_getLsbD' {f : Fin w → α → α × Bool} (state : Nat → α)
+theorem iunfoldr_getLsb' {f : Fin w → α → α × Bool} (state : Nat → α)
     (ind : ∀(i : Fin w), (f i (state i.val)).fst = state (i.val+1)) :
-  (∀ i : Fin w, getLsbD (iunfoldr f (state 0)).snd i.val = (f i (state i.val)).snd)
+  (∀ i : Fin w, getLsb (iunfoldr f (state 0)).snd i.val = (f i (state i.val)).snd)
   ∧ (iunfoldr f (state 0)).fst = state w := by
   unfold iunfoldr
   simp
   apply Fin.hIterate_elim
         (fun j (p : α × BitVec j) => (hj : j ≤ w) →
-         (∀ i : Fin j,  getLsbD p.snd i.val = (f ⟨i.val, Nat.lt_of_lt_of_le i.isLt hj⟩ (state i.val)).snd)
+         (∀ i : Fin j,  getLsb p.snd i.val = (f ⟨i.val, Nat.lt_of_lt_of_le i.isLt hj⟩ (state i.val)).snd)
           ∧ p.fst = state j)
   case hj => simp
   case init =>
@@ -73,7 +71,7 @@ theorem iunfoldr_getLsbD' {f : Fin w → α → α × Bool} (state : Nat → α)
     apply And.intro
     case left =>
       intro i
-      simp only [getLsbD_cons]
+      simp only [getLsb_cons]
       have hj2 : j.val ≤ w := by simp
       cases (Nat.lt_or_eq_of_le (Nat.lt_succ.mp i.isLt)) with
       | inl h3 => simp [if_neg, (Nat.ne_of_lt h3)]
@@ -90,10 +88,10 @@ theorem iunfoldr_getLsbD' {f : Fin w → α → α × Bool} (state : Nat → α)
       rw [← ind j, ← (ih hj2).2]
 
 
-theorem iunfoldr_getLsbD {f : Fin w → α → α × Bool} (state : Nat → α) (i : Fin w)
+theorem iunfoldr_getLsb {f : Fin w → α → α × Bool} (state : Nat → α) (i : Fin w)
     (ind : ∀(i : Fin w), (f i (state i.val)).fst = state (i.val+1)) :
-  getLsbD (iunfoldr f (state 0)).snd i.val = (f i (state i.val)).snd := by
-  exact (iunfoldr_getLsbD' state ind).1 i
+  getLsb (iunfoldr f (state 0)).snd i.val = (f i (state i.val)).snd := by
+  exact (iunfoldr_getLsb' state ind).1 i
 
 /--
 Correctness theorem for `iunfoldr`.
@@ -101,14 +99,14 @@ Correctness theorem for `iunfoldr`.
 theorem iunfoldr_replace
     {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α)
     (init : state 0 = a)
-    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsbD i.val)) :
+    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsb i.val)) :
     iunfoldr f a = (state w, value) := by
   simp [iunfoldr.eq_test state value a init step]
 
 theorem iunfoldr_replace_snd
   {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α)
     (init : state 0 = a)
-    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsbD i.val)) :
+    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsb i.val)) :
     (iunfoldr f a).snd = value := by
   simp [iunfoldr.eq_test state value a init step]
 

src/Init/Data/Bool.lean

@@ -4,14 +4,19 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: F. G. Dorais
 -/
 prelude
-import Init.NotationExtra
-
-
-namespace Bool
+import Init.BinderPredicates
 
 /-- Boolean exclusive or -/
 abbrev xor : Bool → Bool → Bool := bne
 
+namespace Bool
+
+/- Namespaced versions that can be used instead of prefixing `_root_` -/
+@[inherit_doc not] protected abbrev not := not
+@[inherit_doc or]  protected abbrev or  := or
+@[inherit_doc and] protected abbrev and := and
+@[inherit_doc xor] protected abbrev xor := xor
+
 instance (p : Bool → Prop) [inst : DecidablePred p] : Decidable (∀ x, p x) :=
   match inst true, inst false with
   | isFalse ht, _ => isFalse fun h => absurd (h _) ht
@@ -50,16 +55,10 @@ theorem eq_iff_iff {a b : Bool} : a = b ↔ (a ↔ b) := by cases b <;> simp
 theorem decide_true_eq  {b : Bool} [Decidable (true = b)]  : decide (true  = b) =  b := by cases b <;> simp
 theorem decide_false_eq {b : Bool} [Decidable (false = b)] : decide (false = b) = !b := by cases b <;> simp
 
--- These lemmas assist with confluence.
-@[simp] theorem eq_false_imp_eq_true_iff :
-    ∀ (a b : Bool), ((a = false → b = true) ↔ (b = false → a = true)) = True := by decide
-@[simp] theorem eq_true_imp_eq_false_iff :
-    ∀ (a b : Bool), ((a = true → b = false) ↔ (b = true → a = false)) = True := by decide
-
 /-! ### and -/
 
-@[simp] theorem and_self_left  : ∀ (a b : Bool), (a && (a && b)) = (a && b) := by decide
-@[simp] theorem and_self_right : ∀ (a b : Bool), ((a && b) && b) = (a && b) := by decide
+@[simp] theorem and_self_left  : ∀(a b : Bool), (a && (a && b)) = (a && b) := by decide
+@[simp] theorem and_self_right : ∀(a b : Bool), ((a && b) && b) = (a && b) := by decide
 
 @[simp] theorem not_and_self : ∀ (x : Bool), (!x && x) = false := by decide
 @[simp] theorem and_not_self : ∀ (x : Bool), (x && !x) = false := by decide
@@ -71,8 +70,8 @@ Added for confluence with `not_and_self` `and_not_self` on term
 1. `(b = true ∨ !b = true)` via `Bool.and_eq_true`
 2. `false = true` via `Bool.and_not_self`
 -/
-@[simp] theorem eq_true_and_eq_false_self : ∀ (b : Bool), (b = true ∧ b = false) ↔ False := by decide
-@[simp] theorem eq_false_and_eq_true_self : ∀ (b : Bool), (b = false ∧ b = true) ↔ False := by decide
+@[simp] theorem eq_true_and_eq_false_self : ∀(b : Bool), (b = true ∧ b = false) ↔ False := by decide
+@[simp] theorem eq_false_and_eq_true_self : ∀(b : Bool), (b = false ∧ b = true) ↔ False := by decide
 
 theorem and_comm : ∀ (x y : Bool), (x && y) = (y && x) := by decide
 instance : Std.Commutative (· && ·) := ⟨and_comm⟩
@@ -87,20 +86,15 @@ Needed for confluence of term `(a && b) ↔ a` which reduces to `(a && b) = a` v
 `Bool.coe_iff_coe` and `a → b` via `Bool.and_eq_true` and
 `and_iff_left_iff_imp`.
 -/
-@[simp] theorem and_iff_left_iff_imp  : ∀ {a b : Bool}, ((a && b) = a) ↔ (a → b) := by decide
-@[simp] theorem and_iff_right_iff_imp : ∀ {a b : Bool}, ((a && b) = b) ↔ (b → a) := by decide
-@[simp] theorem iff_self_and : ∀ {a b : Bool}, (a = (a && b)) ↔ (a → b) := by decide
-@[simp] theorem iff_and_self : ∀ {a b : Bool}, (b = (a && b)) ↔ (b → a) := by decide
-
-@[simp] theorem not_and_iff_left_iff_imp  : ∀ {a b : Bool}, ((!a && b) = a) ↔ !a ∧ !b := by decide
-@[simp] theorem and_not_iff_right_iff_imp : ∀ {a b : Bool}, ((a && !b) = b) ↔ !a ∧ !b := by decide
-@[simp] theorem iff_not_self_and : ∀ {a b : Bool}, (a = (!a && b)) ↔ !a ∧ !b := by decide
-@[simp] theorem iff_and_not_self : ∀ {a b : Bool}, (b = (a && !b)) ↔ !a ∧ !b := by decide
+@[simp] theorem and_iff_left_iff_imp  : ∀(a b : Bool), ((a && b) = a) ↔ (a → b) := by decide
+@[simp] theorem and_iff_right_iff_imp : ∀(a b : Bool), ((a && b) = b) ↔ (b → a) := by decide
+@[simp] theorem iff_self_and : ∀(a b : Bool), (a = (a && b)) ↔ (a → b) := by decide
+@[simp] theorem iff_and_self : ∀(a b : Bool), (b = (a && b)) ↔ (b → a) := by decide
 
 /-! ### or -/
 
-@[simp] theorem or_self_left  : ∀ (a b : Bool), (a || (a || b)) = (a || b) := by decide
-@[simp] theorem or_self_right : ∀ (a b : Bool), ((a || b) || b) = (a || b) := by decide
+@[simp] theorem or_self_left  : ∀(a b : Bool), (a || (a || b)) = (a || b) := by decide
+@[simp] theorem or_self_right : ∀(a b : Bool), ((a || b) || b) = (a || b) := by decide
 
 @[simp] theorem not_or_self : ∀ (x : Bool), (!x || x) = true := by decide
 @[simp] theorem or_not_self : ∀ (x : Bool), (x || !x) = true := by decide
@@ -121,15 +115,10 @@ Needed for confluence of term `(a || b) ↔ a` which reduces to `(a || b) = a` v
 `Bool.coe_iff_coe` and `a → b` via `Bool.or_eq_true` and
 `and_iff_left_iff_imp`.
 -/
-@[simp] theorem or_iff_left_iff_imp  : ∀ {a b : Bool}, ((a || b) = a) ↔ (b → a) := by decide
-@[simp] theorem or_iff_right_iff_imp : ∀ {a b : Bool}, ((a || b) = b) ↔ (a → b) := by decide
-@[simp] theorem iff_self_or : ∀ {a b : Bool}, (a = (a || b)) ↔ (b → a) := by decide
-@[simp] theorem iff_or_self : ∀ {a b : Bool}, (b = (a || b)) ↔ (a → b) := by decide
-
-@[simp] theorem not_or_iff_left_iff_imp  : ∀ {a b : Bool}, ((!a || b) = a) ↔ a ∧ b := by decide
-@[simp] theorem or_not_iff_right_iff_imp : ∀ {a b : Bool}, ((a || !b) = b) ↔ a ∧ b := by decide
-@[simp] theorem iff_not_self_or : ∀ {a b : Bool}, (a = (!a || b)) ↔ a ∧ b := by decide
-@[simp] theorem iff_or_not_self : ∀ {a b : Bool}, (b = (a || !b)) ↔ a ∧ b := by decide
+@[simp] theorem or_iff_left_iff_imp  : ∀(a b : Bool), ((a || b) = a) ↔ (b → a) := by decide
+@[simp] theorem or_iff_right_iff_imp : ∀(a b : Bool), ((a || b) = b) ↔ (a → b) := by decide
+@[simp] theorem iff_self_or : ∀(a b : Bool), (a = (a || b)) ↔ (b → a) := by decide
+@[simp] theorem iff_or_self : ∀(a b : Bool), (b = (a || b)) ↔ (a → b) := by decide
 
 theorem or_comm : ∀ (x y : Bool), (x || y) = (y || x) := by decide
 instance : Std.Commutative (· || ·) := ⟨or_comm⟩
@@ -145,7 +134,7 @@ theorem and_or_distrib_right : ∀ (x y z : Bool), ((x || y) && z) = (x && z ||
 theorem or_and_distrib_left  : ∀ (x y z : Bool), (x || y && z) = ((x || y) && (x || z)) := by decide
 theorem or_and_distrib_right : ∀ (x y z : Bool), (x && y || z) = ((x || z) && (y || z)) := by decide
 
-theorem and_xor_distrib_left  : ∀ (x y z : Bool), (x && xor y z) = xor (x && y) (x && z) := by decide
+theorem and_xor_distrib_left : ∀ (x y z : Bool), (x && xor y z) = xor (x && y) (x && z) := by decide
 theorem and_xor_distrib_right : ∀ (x y z : Bool), (xor x y && z) = xor (x && z) (y && z) := by decide
 
 /-- De Morgan's law for boolean and -/
@@ -154,10 +143,10 @@ theorem and_xor_distrib_right : ∀ (x y z : Bool), (xor x y && z) = xor (x && z
 /-- De Morgan's law for boolean or -/
 @[simp] theorem not_or : ∀ (x y : Bool), (!(x || y)) = (!x && !y) := by decide
 
-theorem and_eq_true_iff {x y : Bool} : (x && y) = true ↔ x = true ∧ y = true :=
+theorem and_eq_true_iff (x y : Bool) : (x && y) = true ↔ x = true ∧ y = true :=
   Iff.of_eq (and_eq_true x y)
 
-theorem and_eq_false_iff : ∀ {x y : Bool}, (x && y) = false ↔ x = false ∨ y = false := by decide
+theorem and_eq_false_iff : ∀ (x y : Bool), (x && y) = false ↔ x = false ∨ y = false := by decide
 
 /-
 New simp rule that replaces `Bool.and_eq_false_eq_eq_false_or_eq_false` in
@@ -172,11 +161,11 @@ Consider the term: `¬((b && c) = true)`:
 1. Further reduces to `b = false ∨ c = false` via `Bool.and_eq_false_eq_eq_false_or_eq_false`.
 2. Further reduces to `b = true → c = false` via `not_and` and `Bool.not_eq_true`.
 -/
-@[simp] theorem and_eq_false_imp : ∀ {x y : Bool}, (x && y) = false ↔ (x = true → y = false) := by decide
+@[simp] theorem and_eq_false_imp : ∀ (x y : Bool), (x && y) = false ↔ (x = true → y = false) := by decide
 
-theorem or_eq_true_iff : ∀ {x y : Bool}, (x || y) = true ↔ x = true ∨ y = true := by simp
+theorem or_eq_true_iff : ∀ (x y : Bool), (x || y) = true ↔ x = true ∨ y = true := by simp
 
-@[simp] theorem or_eq_false_iff : ∀ {x y : Bool}, (x || y) = false ↔ x = false ∧ y = false := by decide
+@[simp] theorem or_eq_false_iff : ∀ (x y : Bool), (x || y) = false ↔ x = false ∧ y = false := by decide
 
 /-! ### eq/beq/bne -/
 
@@ -213,11 +202,8 @@ instance : Std.LawfulIdentity (· != ·) false where
 @[simp] theorem not_beq_self : ∀ (x : Bool), ((!x) == x) = false := by decide
 @[simp] theorem beq_not_self : ∀ (x : Bool), (x   == !x) = false := by decide
 
-@[simp] theorem not_bne : ∀ (a b : Bool), ((!a) != b) = !(a != b) := by decide
-@[simp] theorem bne_not : ∀ (a b : Bool), (a != !b) = !(a != b) := by decide
-
-theorem not_bne_self : ∀ (x : Bool), ((!x) != x) = true := by decide
-theorem bne_not_self : ∀ (x : Bool), (x   != !x) = true := by decide
+@[simp] theorem not_bne_self : ∀ (x : Bool), ((!x) != x) = true := by decide
+@[simp] theorem bne_not_self : ∀ (x : Bool), (x   != !x) = true := by decide
 
 /-
 Added for equivalence with `Bool.not_beq_self` and needed for confluence
@@ -231,13 +217,13 @@ due to `beq_iff_eq`.
 @[simp] theorem bne_self_left  : ∀(a b : Bool), (a != (a != b)) = b := by decide
 @[simp] theorem bne_self_right : ∀(a b : Bool), ((a != b) != b) = a := by decide
 
-theorem not_bne_not : ∀ (x y : Bool), ((!x) != (!y)) = (x != y) := by simp
+@[simp] theorem not_bne_not : ∀ (x y : Bool), ((!x) != (!y)) = (x != y) := by decide
 
 @[simp] theorem bne_assoc : ∀ (x y z : Bool), ((x != y) != z) = (x != (y != z)) := by decide
 instance : Std.Associative (· != ·) := ⟨bne_assoc⟩
 
-@[simp] theorem bne_left_inj  : ∀ {x y z : Bool}, (x != y) = (x != z) ↔ y = z := by decide
-@[simp] theorem bne_right_inj : ∀ {x y z : Bool}, (x != z) = (y != z) ↔ x = y := by decide
+@[simp] theorem bne_left_inj  : ∀ (x y z : Bool), (x != y) = (x != z) ↔ y = z := by decide
+@[simp] theorem bne_right_inj : ∀ (x y z : Bool), (x != z) = (y != z) ↔ x = y := by decide
 
 theorem eq_not_of_ne : ∀ {x y : Bool}, x ≠ y → x = !y := by decide
 
@@ -249,28 +235,20 @@ theorem beq_eq_decide_eq [BEq α] [LawfulBEq α] [DecidableEq α] (a b : α) :
   · simp [ne_of_beq_false h]
   · simp [eq_of_beq h]
 
-theorem eq_not : ∀ {a b : Bool}, (a = (!b)) ↔ (a ≠ b) := by decide
-theorem not_eq : ∀ {a b : Bool}, ((!a) = b) ↔ (a ≠ b) := by decide
-
 @[simp] theorem not_eq_not : ∀ {a b : Bool}, ¬a = !b ↔ a = b := by decide
+
 @[simp] theorem not_not_eq : ∀ {a b : Bool}, ¬(!a) = b ↔ a = b := by decide
 
-/--
-We move `!` from the left hand side of an equality to the right hand side.
-This helps confluence, and also helps combining pairs of `!`s.
--/
-@[simp] theorem not_eq_eq_eq_not : ∀ {a b : Bool}, ((!a) = b) ↔ (a = !b) := by decide
+@[simp] theorem coe_iff_coe : ∀(a b : Bool), (a ↔ b) ↔ a = b := by decide
 
-@[simp] theorem coe_iff_coe : ∀{a b : Bool}, (a ↔ b) ↔ a = b := by decide
-
-@[simp] theorem coe_true_iff_false  : ∀{a b : Bool}, (a ↔ b = false) ↔ a = (!b) := by decide
-@[simp] theorem coe_false_iff_true  : ∀{a b : Bool}, (a = false ↔ b) ↔ (!a) = b := by decide
-@[simp] theorem coe_false_iff_false : ∀{a b : Bool}, (a = false ↔ b = false) ↔ (!a) = (!b) := by decide
+@[simp] theorem coe_true_iff_false  : ∀(a b : Bool), (a ↔ b = false) ↔ a = (!b) := by decide
+@[simp] theorem coe_false_iff_true  : ∀(a b : Bool), (a = false ↔ b) ↔ (!a) = b := by decide
+@[simp] theorem coe_false_iff_false : ∀(a b : Bool), (a = false ↔ b = false) ↔ (!a) = (!b) := by decide
 
 /-! ### beq properties -/
 
 theorem beq_comm {α} [BEq α] [LawfulBEq α] {a b : α} : (a == b) = (b == a) :=
-  Bool.coe_iff_coe.mp (by simp [@eq_comm α])
+  (Bool.coe_iff_coe (a == b) (b == a)).mp (by simp [@eq_comm α])
 
 /-! ### xor -/
 
@@ -302,9 +280,9 @@ theorem xor_right_comm : ∀ (x y z : Bool), xor (xor x y) z = xor (xor x z) y :
 
 theorem xor_assoc : ∀ (x y z : Bool), xor (xor x y) z = xor x (xor y z) := bne_assoc
 
-theorem xor_left_inj : ∀ {x y z : Bool}, xor x y = xor x z ↔ y = z := bne_left_inj
+theorem xor_left_inj : ∀ (x y z : Bool), xor x y = xor x z ↔ y = z := bne_left_inj
 
-theorem xor_right_inj : ∀ {x y z : Bool}, xor x z = xor y z ↔ x = y := bne_right_inj
+theorem xor_right_inj : ∀ (x y z : Bool), xor x z = xor y z ↔ x = y := bne_right_inj
 
 /-! ### le/lt -/
 
@@ -382,12 +360,15 @@ def toNat (b : Bool) : Nat := cond b 1 0
 theorem toNat_le (c : Bool) : c.toNat ≤ 1 := by
   cases c <;> trivial
 
+@[deprecated toNat_le (since := "2024-02-23")]
+abbrev toNat_le_one := toNat_le
+
 theorem toNat_lt (b : Bool) : b.toNat < 2 :=
   Nat.lt_succ_of_le (toNat_le _)
 
-@[simp] theorem toNat_eq_zero {b : Bool} : b.toNat = 0 ↔ b = false := by
+@[simp] theorem toNat_eq_zero (b : Bool) : b.toNat = 0 ↔ b = false := by
   cases b <;> simp
-@[simp] theorem toNat_eq_one  {b : Bool} : b.toNat = 1 ↔ b = true := by
+@[simp] theorem toNat_eq_one  (b : Bool) : b.toNat = 1 ↔ b = true := by
   cases b <;> simp
 
 /-! ### ite -/
@@ -412,13 +393,6 @@ theorem toNat_lt (b : Bool) : b.toNat < 2 :=
     (ite p t f = false) = ite p (t = false) (f = false) := by
   cases h with | _ p => simp [p]
 
-@[simp] theorem ite_eq_false : (if b = false then p else q) ↔ if b then q else p := by
-  cases b <;> simp
-
-@[simp] theorem ite_eq_true_else_eq_false {q : Prop} :
-    (if b = true then q else b = false) ↔ (b = true → q) := by
-  cases b <;> simp
-
 /-
 `not_ite_eq_true_eq_true` and related theorems below are added for
 non-confluence.  A motivating example is
@@ -433,57 +407,37 @@ lemmas.
 -/
 
 @[simp]
-theorem not_ite_eq_true_eq_true {p : Prop} [h : Decidable p] {b c : Bool} :
+theorem not_ite_eq_true_eq_true (p : Prop) [h : Decidable p] (b c : Bool) :
   ¬(ite p (b = true) (c = true)) ↔ (ite p (b = false) (c = false)) := by
   cases h with | _ p => simp [p]
 
 @[simp]
-theorem not_ite_eq_false_eq_false {p : Prop} [h : Decidable p] {b c : Bool} :
+theorem not_ite_eq_false_eq_false (p : Prop) [h : Decidable p] (b c : Bool) :
   ¬(ite p (b = false) (c = false)) ↔ (ite p (b = true) (c = true)) := by
   cases h with | _ p => simp [p]
 
 @[simp]
-theorem not_ite_eq_true_eq_false {p : Prop} [h : Decidable p] {b c : Bool} :
+theorem not_ite_eq_true_eq_false (p : Prop) [h : Decidable p] (b c : Bool) :
   ¬(ite p (b = true) (c = false)) ↔ (ite p (b = false) (c = true)) := by
   cases h with | _ p => simp [p]
 
 @[simp]
-theorem not_ite_eq_false_eq_true {p : Prop} [h : Decidable p] {b c : Bool} :
+theorem not_ite_eq_false_eq_true (p : Prop) [h : Decidable p] (b c : Bool) :
   ¬(ite p (b = false) (c = true)) ↔ (ite p (b = true) (c = false)) := by
   cases h with | _ p => simp [p]
 
 /-
-It would be nice to have this for confluence between `if_true_left` and `ite_false_same` on
-`if b = true then True else b = true`.
-However the discrimination tree key is just `→`, so this is tried too often.
+Added for confluence between `if_true_left` and `ite_false_same` on
+`if b = true then True else b = true`
 -/
-theorem eq_false_imp_eq_true : ∀ {b : Bool}, (b = false → b = true) ↔ (b = true) := by decide
+@[simp] theorem eq_false_imp_eq_true : ∀(b:Bool), (b = false → b = true) ↔ (b = true) := by decide
 
 /-
-It would be nice to have this for confluence between `if_true_left` and `ite_false_same` on
-`if b = false then True else b = false`.
-However the discrimination tree key is just `→`, so this is tried too often.
+Added for confluence between `if_true_left` and `ite_false_same` on
+`if b = false then True else b = false`
 -/
-theorem eq_true_imp_eq_false : ∀ {b : Bool}, (b = true → b = false) ↔ (b = false) := by decide
+@[simp] theorem eq_true_imp_eq_false : ∀(b:Bool), (b = true → b = false) ↔ (b = false) := by decide
 
-/-! ### forall -/
-
-theorem forall_bool' {p : Bool → Prop} (b : Bool) : (∀ x, p x) ↔ p b ∧ p !b :=
-  ⟨fun h ↦ ⟨h _, h _⟩, fun ⟨h₁, h₂⟩ x ↦ by cases b <;> cases x <;> assumption⟩
-
-@[simp]
-theorem forall_bool {p : Bool → Prop} : (∀ b, p b) ↔ p false ∧ p true :=
-  forall_bool' false
-
-/-! ### exists -/
-
-theorem exists_bool' {p : Bool → Prop} (b : Bool) : (∃ x, p x) ↔ p b ∨ p !b :=
-  ⟨fun ⟨x, hx⟩ ↦ by cases x <;> cases b <;> first | exact .inl ‹_› | exact .inr ‹_›,
-    fun h ↦ by cases h <;> exact ⟨_, ‹_›⟩⟩
-
-@[simp]
-theorem exists_bool {p : Bool → Prop} : (∃ b, p b) ↔ p false ∨ p true :=
-  exists_bool' false
 
 /-! ### cond -/
 
@@ -497,11 +451,6 @@ theorem cond_eq_if : (bif b then x else y) = (if b then x else y) := cond_eq_ite
 
 @[simp] theorem cond_self (c : Bool) (t : α) : cond c t t = t := by cases c <;> rfl
 
-/-- If the return values are propositions, there is no harm in simplifying a `bif` to an `if`. -/
-@[simp] theorem cond_prop {b : Bool} {p q : Prop} :
-    (bif b then p else q) ↔ if b then p else q := by
-  cases b <;> simp
-
 /-
 This is a simp rule in Mathlib, but results in non-confluence that is difficult
 to fix as decide distributes over propositions. As an example, observe that
@@ -519,11 +468,11 @@ theorem cond_decide {α} (p : Prop) [Decidable p] (t e : α) :
     cond (decide p) t e = if p then t else e := by
   simp [cond_eq_ite]
 
-@[simp] theorem cond_eq_ite_iff {a : Bool} {p : Prop} [h : Decidable p] {x y u v : α} :
+@[simp] theorem cond_eq_ite_iff (a : Bool) (p : Prop) [h : Decidable p] (x y u v : α) :
   (cond a x y = ite p u v) ↔ ite a x y = ite p u v := by
   simp [Bool.cond_eq_ite]
 
-@[simp] theorem ite_eq_cond_iff {p : Prop} {a : Bool} [h : Decidable p] {x y u v : α} :
+@[simp] theorem ite_eq_cond_iff (p : Prop) [h : Decidable p] (a : Bool) (x y u v : α) :
   (ite p x y = cond a u v) ↔ ite p x y = ite a u v := by
   simp [Bool.cond_eq_ite]
 
@@ -542,10 +491,6 @@ protected theorem cond_false {α : Type u} {a b : α} : cond false a b = b := co
 @[simp] theorem cond_true_right  : ∀(c t : Bool), cond c t true  = (!c || t) := by decide
 @[simp] theorem cond_false_right : ∀(c t : Bool), cond c t false = ( c && t) := by decide
 
--- These restore confluence between the above lemmas and `cond_not`.
-@[simp] theorem cond_true_not_same  : ∀ (c b : Bool), cond c (!c) b = (!c && b) := by decide
-@[simp] theorem cond_false_not_same : ∀ (c b : Bool), cond c b (!c) = (!c || b) := by decide
-
 @[simp] theorem cond_true_same  : ∀(c b : Bool), cond c c b = (c || b) := by decide
 @[simp] theorem cond_false_same : ∀(c b : Bool), cond c b c = (c && b) := by decide
 
@@ -559,7 +504,7 @@ theorem apply_cond (f : α → β) {b : Bool} {a a' : α} :
     f (bif b then a else a') = bif b then f a else f a' := by
   cases b <;> simp
 
-/-! # decidability -/
+/-# decidability -/
 
 protected theorem decide_coe (b : Bool) [Decidable (b = true)] : decide (b = true) = b := decide_eq_true
 
@@ -575,24 +520,9 @@ protected theorem decide_coe (b : Bool) [Decidable (b = true)] : decide (b = tru
     decide (p ↔ q) = (decide p == decide q) := by
   cases dp with | _ p => simp [p]
 
-@[boolToPropSimps]
-theorem and_eq_decide (p q : Prop) [dpq : Decidable (p ∧ q)] [dp : Decidable p] [dq : Decidable q] :
-    (p && q) = decide (p ∧ q) := by
-  cases dp with | _ p => simp [p]
-
-@[boolToPropSimps]
-theorem or_eq_decide (p q : Prop) [dpq : Decidable (p ∨ q)] [dp : Decidable p] [dq : Decidable q] :
-    (p || q) = decide (p ∨ q) := by
-  cases dp with | _ p => simp [p]
-
-@[boolToPropSimps]
-theorem decide_beq_decide (p q : Prop) [dpq : Decidable (p ↔ q)] [dp : Decidable p] [dq : Decidable q] :
-    (decide p == decide q) = decide (p ↔ q) := by
-  cases dp with | _ p => simp [p]
-
 end Bool
 
-export Bool (cond_eq_if xor and or not)
+export Bool (cond_eq_if)
 
 /-! ### decide -/
 
@@ -601,19 +531,3 @@ export Bool (cond_eq_if xor and or not)
 
 @[simp] theorem true_eq_decide_iff {p : Prop} [h : Decidable p] : true = decide p ↔ p := by
   cases h with | _ q => simp [q]
-
-/-! ### coercions -/
-
-/--
-This should not be turned on globally as an instance because it degrades performance in Mathlib,
-but may be used locally.
--/
-def boolPredToPred : Coe (α → Bool) (α  → Prop) where
-  coe r := fun a => Eq (r a) true
-
-/--
-This should not be turned on globally as an instance because it degrades performance in Mathlib,
-but may be used locally.
--/
-def boolRelToRel : Coe (α → α → Bool) (α → α → Prop) where
-  coe r := fun a b => Eq (r a b) true

src/Init/Data/ByteArray/Basic.lean

@@ -191,137 +191,6 @@ def foldlM {β : Type v} {m : Type v → Type w} [Monad m] (f : β → UInt8 →
 def foldl {β : Type v} (f : β → UInt8 → β) (init : β) (as : ByteArray) (start := 0) (stop := as.size) : β :=
   Id.run <| as.foldlM f init start stop
 
-/-- Iterator over the bytes (`UInt8`) of a `ByteArray`.
-
-Typically created by `arr.iter`, where `arr` is a `ByteArray`.
-
-An iterator is *valid* if the position `i` is *valid* for the array `arr`, meaning `0 ≤ i ≤ arr.size`
-
-Most operations on iterators return arbitrary values if the iterator is not valid. The functions in
-the `ByteArray.Iterator` API should rule out the creation of invalid iterators, with two exceptions:
-
-- `Iterator.next iter` is invalid if `iter` is already at the end of the array (`iter.atEnd` is
-  `true`)
-- `Iterator.forward iter n`/`Iterator.nextn iter n` is invalid if `n` is strictly greater than the
-  number of remaining bytes.
--/
-structure Iterator where
-  /-- The array the iterator is for. -/
-  array : ByteArray
-  /-- The current position.
-
-  This position is not necessarily valid for the array, for instance if one keeps calling
-  `Iterator.next` when `Iterator.atEnd` is true. If the position is not valid, then the
-  current byte is `(default : UInt8)`. -/
-  idx : Nat
-  deriving Inhabited
-
-/-- Creates an iterator at the beginning of an array. -/
-def mkIterator (arr : ByteArray) : Iterator :=
-  ⟨arr, 0⟩
-
-@[inherit_doc mkIterator]
-abbrev iter := mkIterator
-
-/-- The size of an array iterator is the number of bytes remaining. -/
-instance : SizeOf Iterator where
-  sizeOf i := i.array.size - i.idx
-
-theorem Iterator.sizeOf_eq (i : Iterator) : sizeOf i = i.array.size - i.idx :=
-  rfl
-
-namespace Iterator
-
-/-- Number of bytes remaining in the iterator. -/
-def remainingBytes : Iterator → Nat
-  | ⟨arr, i⟩ => arr.size - i
-
-@[inherit_doc Iterator.idx]
-def pos := Iterator.idx
-
-/-- The byte at the current position.
-
-On an invalid position, returns `(default : UInt8)`. -/
-@[inline]
-def curr : Iterator → UInt8
-  | ⟨arr, i⟩ =>
-    if h:i < arr.size then
-      arr[i]'h
-    else
-      default
-
-/-- Moves the iterator's position forward by one byte, unconditionally.
-
-It is only valid to call this function if the iterator is not at the end of the array, *i.e.*
-`Iterator.atEnd` is `false`; otherwise, the resulting iterator will be invalid. -/
-@[inline]
-def next : Iterator → Iterator
-  | ⟨arr, i⟩ => ⟨arr, i + 1⟩
-
-/-- Decreases the iterator's position.
-
-If the position is zero, this function is the identity. -/
-@[inline]
-def prev : Iterator → Iterator
-  | ⟨arr, i⟩ => ⟨arr, i - 1⟩
-
-/-- True if the iterator is past the array's last byte. -/
-@[inline]
-def atEnd : Iterator → Bool
-  | ⟨arr, i⟩ => i ≥ arr.size
-
-/-- True if the iterator is not past the array's last byte. -/
-@[inline]
-def hasNext : Iterator → Bool
-  | ⟨arr, i⟩ => i < arr.size
-
-/-- The byte at the current position. --/
-@[inline]
-def curr' (it : Iterator) (h : it.hasNext) : UInt8 :=
-  match it with
-  | ⟨arr, i⟩ =>
-    have : i < arr.size := by
-      simp only [hasNext, decide_eq_true_eq] at h
-      assumption
-    arr[i]
-
-/-- Moves the iterator's position forward by one byte. --/
-@[inline]
-def next' (it : Iterator) (_h : it.hasNext) : Iterator :=
-  match it with
-  | ⟨arr, i⟩ => ⟨arr, i + 1⟩
-
-/-- True if the position is not zero. -/
-@[inline]
-def hasPrev : Iterator → Bool
-  | ⟨_, i⟩ => i > 0
-
-/-- Moves the iterator's position to the end of the array.
-
-Note that `i.toEnd.atEnd` is always `true`. -/
-@[inline]
-def toEnd : Iterator → Iterator
-  | ⟨arr, _⟩ => ⟨arr, arr.size⟩
-
-/-- Moves the iterator's position several bytes forward.
-
-The resulting iterator is only valid if the number of bytes to skip is less than or equal to
-the number of bytes left in the iterator. -/
-@[inline]
-def forward : Iterator → Nat → Iterator
-  | ⟨arr, i⟩, f => ⟨arr, i + f⟩
-
-@[inherit_doc forward, inline]
-def nextn : Iterator → Nat → Iterator := forward
-
-/-- Moves the iterator's position several bytes back.
-
-If asked to go back more bytes than available, stops at the beginning of the array. -/
-@[inline]
-def prevn : Iterator → Nat → Iterator
-  | ⟨arr, i⟩, f => ⟨arr, i - f⟩
-
-end Iterator
 end ByteArray
 
 def List.toByteArray (bs : List UInt8) : ByteArray :=

src/Init/Data/Char/Basic.lean

@@ -63,27 +63,27 @@ instance : Inhabited Char where
   default := 'A'
 
 /-- Is the character a space (U+0020) a tab (U+0009), a carriage return (U+000D) or a newline (U+000A)? -/
-@[inline] def isWhitespace (c : Char) : Bool :=
+def isWhitespace (c : Char) : Bool :=
   c = ' ' || c = '\t' || c = '\r' || c = '\n'
 
 /-- Is the character in `ABCDEFGHIJKLMNOPQRSTUVWXYZ`? -/
-@[inline] def isUpper (c : Char) : Bool :=
+def isUpper (c : Char) : Bool :=
   c.val ≥ 65 && c.val ≤ 90
 
 /-- Is the character in `abcdefghijklmnopqrstuvwxyz`? -/
-@[inline] def isLower (c : Char) : Bool :=
+def isLower (c : Char) : Bool :=
   c.val ≥ 97 && c.val ≤ 122
 
 /-- Is the character in `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`? -/
-@[inline] def isAlpha (c : Char) : Bool :=
+def isAlpha (c : Char) : Bool :=
   c.isUpper || c.isLower
 
 /-- Is the character in `0123456789`? -/
-@[inline] def isDigit (c : Char) : Bool :=
+def isDigit (c : Char) : Bool :=
   c.val ≥ 48 && c.val ≤ 57
 
 /-- Is the character in `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`? -/
-@[inline] def isAlphanum (c : Char) : Bool :=
+def isAlphanum (c : Char) : Bool :=
   c.isAlpha || c.isDigit
 
 /-- Convert an upper case character to its lower case character.

src/Init/Data/Fin/Basic.lean

@@ -31,7 +31,7 @@ This differs from addition, which wraps around:
 (2 : Fin 3) + 1 = (0 : Fin 3)
 ```
 -/
-def succ : Fin n → Fin (n + 1)
+def succ : Fin n → Fin n.succ
   | ⟨i, h⟩ => ⟨i+1, Nat.succ_lt_succ h⟩
 
 variable {n : Nat}
@@ -39,20 +39,16 @@ variable {n : Nat}
 /--
 Returns `a` modulo `n + 1` as a `Fin n.succ`.
 -/
-protected def ofNat {n : Nat} (a : Nat) : Fin (n + 1) :=
+protected def ofNat {n : Nat} (a : Nat) : Fin n.succ :=
   ⟨a % (n+1), Nat.mod_lt _ (Nat.zero_lt_succ _)⟩
 
 /--
 Returns `a` modulo `n` as a `Fin n`.
 
-The assumption `NeZero n` ensures that `Fin n` is nonempty.
+The assumption `n > 0` ensures that `Fin n` is nonempty.
 -/
-protected def ofNat' (n : Nat) [NeZero n] (a : Nat) : Fin n :=
-  ⟨a % n, Nat.mod_lt _ (pos_of_neZero n)⟩
-
--- We intend to deprecate `Fin.ofNat` in favor of `Fin.ofNat'` (and later rename).
--- This is waiting on https://github.com/leanprover/lean4/pull/5323
--- attribute [deprecated Fin.ofNat' (since := "2024-09-16")] Fin.ofNat
+protected def ofNat' {n : Nat} (a : Nat) (h : n > 0) : Fin n :=
+  ⟨a % n, Nat.mod_lt _ h⟩
 
 private theorem mlt {b : Nat} : {a : Nat} → a < n → b % n < n
   | 0,   h => Nat.mod_lt _ h
@@ -145,17 +141,14 @@ instance : ShiftLeft (Fin n) where
 instance : ShiftRight (Fin n) where
   shiftRight := Fin.shiftRight
 
-instance instOfNat {n : Nat} [NeZero n] {i : Nat} : OfNat (Fin n) i where
-  ofNat := Fin.ofNat' n i
+instance instOfNat : OfNat (Fin (no_index (n+1))) i where
+  ofNat := Fin.ofNat i
 
-instance instInhabited {n : Nat} [NeZero n] : Inhabited (Fin n) where
+instance : Inhabited (Fin (no_index (n+1))) where
   default := 0
 
 @[simp] theorem zero_eta : (⟨0, Nat.zero_lt_succ _⟩ : Fin (n + 1)) = 0 := rfl
 
-theorem ne_of_val_ne {i j : Fin n} (h : val i ≠ val j) : i ≠ j :=
-  fun h' => absurd (val_eq_of_eq h') h
-
 theorem val_ne_of_ne {i j : Fin n} (h : i ≠ j) : val i ≠ val j :=
   fun h' => absurd (eq_of_val_eq h') h
 

src/Init/Data/Fin/Lemmas.lean

@@ -11,6 +11,9 @@ import Init.ByCases
 import Init.Conv
 import Init.Omega
 
+-- Remove after the next stage0 update
+set_option allowUnsafeReducibility true
+
 namespace Fin
 
 /-- If you actually have an element of `Fin n`, then the `n` is always positive -/
@@ -51,13 +54,11 @@ theorem eq_mk_iff_val_eq {a : Fin n} {k : Nat} {hk : k < n} :
 
 theorem mk_val (i : Fin n) : (⟨i, i.isLt⟩ : Fin n) = i := Fin.eta ..
 
-@[simp] theorem val_ofNat' (n : Nat) [NeZero n] (a : Nat) :
-  (Fin.ofNat' n a).val = a % n := rfl
+@[simp] theorem val_ofNat' (a : Nat) (is_pos : n > 0) :
+  (Fin.ofNat' a is_pos).val = a % n := rfl
 
-@[simp] theorem ofNat'_val_eq_self [NeZero n](x : Fin n) : (Fin.ofNat' n x) = x := by
-  ext
-  rw [val_ofNat', Nat.mod_eq_of_lt]
-  exact x.2
+@[deprecated ofNat'_zero_val (since := "2024-02-22")]
+theorem ofNat'_zero_val : (Fin.ofNat' 0 h).val = 0 := Nat.zero_mod _
 
 @[simp] theorem mod_val (a b : Fin n) : (a % b).val = a.val % b.val :=
   rfl
@@ -140,12 +141,6 @@ theorem eq_zero_or_eq_succ {n : Nat} : ∀ i : Fin (n + 1), i = 0 ∨ ∃ j : Fi
 theorem eq_succ_of_ne_zero {n : Nat} {i : Fin (n + 1)} (hi : i ≠ 0) : ∃ j : Fin n, i = j.succ :=
   (eq_zero_or_eq_succ i).resolve_left hi
 
-protected theorem le_antisymm_iff {x y : Fin n} : x = y ↔ x ≤ y ∧ y ≤ x :=
-  Fin.ext_iff.trans Nat.le_antisymm_iff
-
-protected theorem le_antisymm {x y : Fin n} (h1 : x ≤ y) (h2 : y ≤ x) : x = y :=
-  Fin.le_antisymm_iff.2 ⟨h1, h2⟩
-
 @[simp] theorem val_rev (i : Fin n) : rev i = n - (i + 1) := rfl
 
 @[simp] theorem rev_rev (i : Fin n) : rev (rev i) = i := Fin.ext <| by
@@ -388,7 +383,7 @@ theorem castSucc_lt_iff_succ_le {n : Nat} {i : Fin n} {j : Fin (n + 1)} :
 
 @[simp] theorem succ_last (n : Nat) : (last n).succ = last n.succ := rfl
 
-@[simp] theorem succ_eq_last_succ {n : Nat} {i : Fin n.succ} :
+@[simp] theorem succ_eq_last_succ {n : Nat} (i : Fin n.succ) :
     i.succ = last (n + 1) ↔ i = last n := by rw [← succ_last, succ_inj]
 
 @[simp] theorem castSucc_castLT (i : Fin (n + 1)) (h : (i : Nat) < n) :
@@ -412,10 +407,10 @@ theorem castSucc_lt_last (a : Fin n) : castSucc a < last n := a.is_lt
 theorem castSucc_pos {i : Fin (n + 1)} (h : 0 < i) : 0 < castSucc i := by
   simpa [lt_def] using h
 
-@[simp] theorem castSucc_eq_zero_iff {a : Fin (n + 1)} : castSucc a = 0 ↔ a = 0 := by simp [Fin.ext_iff]
+@[simp] theorem castSucc_eq_zero_iff (a : Fin (n + 1)) : castSucc a = 0 ↔ a = 0 := by simp [Fin.ext_iff]
 
-theorem castSucc_ne_zero_iff {a : Fin (n + 1)} : castSucc a ≠ 0 ↔ a ≠ 0 :=
-  not_congr <| castSucc_eq_zero_iff
+theorem castSucc_ne_zero_iff (a : Fin (n + 1)) : castSucc a ≠ 0 ↔ a ≠ 0 :=
+  not_congr <| castSucc_eq_zero_iff a
 
 theorem castSucc_fin_succ (n : Nat) (j : Fin n) :
     castSucc (Fin.succ j) = Fin.succ (castSucc j) := by simp [Fin.ext_iff]
@@ -530,7 +525,7 @@ theorem pred_succ (i : Fin n) {h : i.succ ≠ 0} : i.succ.pred h = i := by
   cases i
   rfl
 
-theorem pred_eq_iff_eq_succ {n : Nat} {i : Fin (n + 1)} (hi : i ≠ 0) {j : Fin n} :
+theorem pred_eq_iff_eq_succ {n : Nat} (i : Fin (n + 1)) (hi : i ≠ 0) (j : Fin n) :
     i.pred hi = j ↔ i = j.succ :=
   ⟨fun h => by simp only [← h, Fin.succ_pred], fun h => by simp only [h, Fin.pred_succ]⟩
 
@@ -750,13 +745,13 @@ theorem addCases_right {m n : Nat} {motive : Fin (m + n) → Sort _} {left right
 
 /-! ### add -/
 
-@[simp] theorem ofNat'_add [NeZero n] (x : Nat) (y : Fin n) :
-    Fin.ofNat' n x + y = Fin.ofNat' n (x + y.val) := by
+@[simp] theorem ofNat'_add (x : Nat) (lt : 0 < n) (y : Fin n) :
+    Fin.ofNat' x lt + y = Fin.ofNat' (x + y.val) lt := by
   apply Fin.eq_of_val_eq
   simp [Fin.ofNat', Fin.add_def]
 
-@[simp] theorem add_ofNat' [NeZero n] (x : Fin n) (y : Nat) :
-    x + Fin.ofNat' n y = Fin.ofNat' n (x.val + y) := by
+@[simp] theorem add_ofNat' (x : Fin n) (y : Nat) (lt : 0 < n) :
+    x + Fin.ofNat' y lt = Fin.ofNat' (x.val + y) lt := by
   apply Fin.eq_of_val_eq
   simp [Fin.ofNat', Fin.add_def]
 
@@ -765,13 +760,13 @@ theorem addCases_right {m n : Nat} {motive : Fin (m + n) → Sort _} {left right
 protected theorem coe_sub (a b : Fin n) : ((a - b : Fin n) : Nat) = ((n - b) + a) % n := by
   cases a; cases b; rfl
 
-@[simp] theorem ofNat'_sub [NeZero n] (x : Nat) (y : Fin n) :
-    Fin.ofNat' n x - y = Fin.ofNat' n ((n - y.val) + x) := by
+@[simp] theorem ofNat'_sub (x : Nat) (lt : 0 < n) (y : Fin n) :
+    Fin.ofNat' x lt - y = Fin.ofNat' ((n - y.val) + x) lt := by
   apply Fin.eq_of_val_eq
   simp [Fin.ofNat', Fin.sub_def]
 
-@[simp] theorem sub_ofNat' [NeZero n] (x : Fin n) (y : Nat) :
-    x - Fin.ofNat' n y = Fin.ofNat' n ((n - y % n) + x.val) := by
+@[simp] theorem sub_ofNat' (x : Fin n) (y : Nat) (lt : 0 < n) :
+    x - Fin.ofNat' y lt = Fin.ofNat' ((n - y % n) + x.val) lt := by
   apply Fin.eq_of_val_eq
   simp [Fin.ofNat', Fin.sub_def]
 

src/Init/Data/Int.lean

@@ -10,6 +10,5 @@ import Init.Data.Int.DivMod
 import Init.Data.Int.DivModLemmas
 import Init.Data.Int.Gcd
 import Init.Data.Int.Lemmas
-import Init.Data.Int.LemmasAux
 import Init.Data.Int.Order
 import Init.Data.Int.Pow

src/Init/Data/Int/Basic.lean

@@ -8,7 +8,7 @@ The integers, with addition, multiplication, and subtraction.
 prelude
 import Init.Data.Cast
 import Init.Data.Nat.Div
-
+import Init.Data.List.Basic
 set_option linter.missingDocs true -- keep it documented
 open Nat
 
@@ -322,8 +322,8 @@ protected def pow (m : Int) : Nat → Int
   | 0      => 1
   | succ n => Int.pow m n * m
 
-instance : NatPow Int where
-  pow := Int.pow
+instance : HPow Int Nat Int where
+  hPow := Int.pow
 
 instance : LawfulBEq Int where
   eq_of_beq h := by simp [BEq.beq] at h; assumption

src/Init/Data/Int/DivMod.lean

@@ -16,99 +16,83 @@ There are three main conventions for integer division,
 referred here as the E, F, T rounding conventions.
 All three pairs satisfy the identity `x % y + (x / y) * y = x` unconditionally,
 and satisfy `x / 0 = 0` and `x % 0 = x`.
-
-### Historical notes
-In early versions of Lean, the typeclasses provided by `/` and `%`
-were defined in terms of `tdiv` and `tmod`, and these were named simply as `div` and `mod`.
-
-However we decided it was better to use `ediv` and `emod`,
-as they are consistent with the conventions used in SMTLib, and Mathlib,
-and often mathematical reasoning is easier with these conventions.
-
-At that time, we did not rename `div` and `mod` to `tdiv` and `tmod` (along with all their lemma).
-In September 2024, we decided to do this rename (with deprecations in place),
-and later we intend to rename `ediv` and `emod` to `div` and `mod`, as nearly all users will only
-ever need to use these functions and their associated lemmas.
 -/
 
 /-! ### T-rounding division -/
 
 /--
-`tdiv` uses the [*"T-rounding"*][t-rounding]
+`div` uses the [*"T-rounding"*][t-rounding]
 (**T**runcation-rounding) convention, meaning that it rounds toward
 zero. Also note that division by zero is defined to equal zero.
 
   The relation between integer division and modulo is found in
-  `Int.tmod_add_tdiv` which states that
-  `tmod a b + b * (tdiv a b) = a`, unconditionally.
+  `Int.mod_add_div` which states that
+  `a % b + b * (a / b) = a`, unconditionally.
 
-  [t-rounding]: https://dl.acm.org/doi/pdf/10.1145/128861.128862
-  [theo tmod_add_tdiv]: https://leanprover-community.github.io/mathlib4_docs/find/?pattern=Int.tmod_add_tdiv#doc
+  [t-rounding]: https://dl.acm.org/doi/pdf/10.1145/128861.128862 [theo
+  mod_add_div]:
+  https://leanprover-community.github.io/mathlib4_docs/find/?pattern=Int.mod_add_div#doc
 
   Examples:
 
   ```
-  #eval (7 : Int).tdiv (0 : Int) -- 0
-  #eval (0 : Int).tdiv (7 : Int) -- 0
+  #eval (7 : Int) / (0 : Int) -- 0
+  #eval (0 : Int) / (7 : Int) -- 0
 
-  #eval (12 : Int).tdiv (6 : Int) -- 2
-  #eval (12 : Int).tdiv (-6 : Int) -- -2
-  #eval (-12 : Int).tdiv (6 : Int) -- -2
-  #eval (-12 : Int).tdiv (-6 : Int) -- 2
+  #eval (12 : Int) / (6 : Int) -- 2
+  #eval (12 : Int) / (-6 : Int) -- -2
+  #eval (-12 : Int) / (6 : Int) -- -2
+  #eval (-12 : Int) / (-6 : Int) -- 2
 
-  #eval (12 : Int).tdiv (7 : Int) -- 1
-  #eval (12 : Int).tdiv (-7 : Int) -- -1
-  #eval (-12 : Int).tdiv (7 : Int) -- -1
-  #eval (-12 : Int).tdiv (-7 : Int) -- 1
+  #eval (12 : Int) / (7 : Int) -- 1
+  #eval (12 : Int) / (-7 : Int) -- -1
+  #eval (-12 : Int) / (7 : Int) -- -1
+  #eval (-12 : Int) / (-7 : Int) -- 1
   ```
 
   Implemented by efficient native code.
 -/
 @[extern "lean_int_div"]
-def tdiv : (@& Int) → (@& Int) → Int
+def div : (@& Int) → (@& Int) → Int
   | ofNat m, ofNat n =>  ofNat (m / n)
   | ofNat m, -[n +1] => -ofNat (m / succ n)
   | -[m +1], ofNat n => -ofNat (succ m / n)
   | -[m +1], -[n +1] =>  ofNat (succ m / succ n)
 
-@[deprecated tdiv (since := "2024-09-11")] abbrev div := tdiv
-
 /-- Integer modulo. This function uses the
   [*"T-rounding"*][t-rounding] (**T**runcation-rounding) convention
-  to pair with `Int.tdiv`, meaning that `tmod a b + b * (tdiv a b) = a`
-  unconditionally (see [`Int.tmod_add_tdiv`][theo tmod_add_tdiv]). In
+  to pair with `Int.div`, meaning that `a % b + b * (a / b) = a`
+  unconditionally (see [`Int.mod_add_div`][theo mod_add_div]). In
   particular, `a % 0 = a`.
 
   [t-rounding]: https://dl.acm.org/doi/pdf/10.1145/128861.128862
-  [theo tmod_add_tdiv]: https://leanprover-community.github.io/mathlib4_docs/find/?pattern=Int.tmod_add_tdiv#doc
+  [theo mod_add_div]: https://leanprover-community.github.io/mathlib4_docs/find/?pattern=Int.mod_add_div#doc
 
   Examples:
 
   ```
-  #eval (7 : Int).tmod (0 : Int) -- 7
-  #eval (0 : Int).tmod (7 : Int) -- 0
+  #eval (7 : Int) % (0 : Int) -- 7
+  #eval (0 : Int) % (7 : Int) -- 0
 
-  #eval (12 : Int).tmod (6 : Int) -- 0
-  #eval (12 : Int).tmod (-6 : Int) -- 0
-  #eval (-12 : Int).tmod (6 : Int) -- 0
-  #eval (-12 : Int).tmod (-6 : Int) -- 0
+  #eval (12 : Int) % (6 : Int) -- 0
+  #eval (12 : Int) % (-6 : Int) -- 0
+  #eval (-12 : Int) % (6 : Int) -- 0
+  #eval (-12 : Int) % (-6 : Int) -- 0
 
-  #eval (12 : Int).tmod (7 : Int) -- 5
-  #eval (12 : Int).tmod (-7 : Int) -- 5
-  #eval (-12 : Int).tmod (7 : Int) -- -5
-  #eval (-12 : Int).tmod (-7 : Int) -- -5
+  #eval (12 : Int) % (7 : Int) -- 5
+  #eval (12 : Int) % (-7 : Int) -- 5
+  #eval (-12 : Int) % (7 : Int) -- 2
+  #eval (-12 : Int) % (-7 : Int) -- 2
   ```
 
   Implemented by efficient native code. -/
 @[extern "lean_int_mod"]
-def tmod : (@& Int) → (@& Int) → Int
+def mod : (@& Int) → (@& Int) → Int
   | ofNat m, ofNat n =>  ofNat (m % n)
   | ofNat m, -[n +1] =>  ofNat (m % succ n)
   | -[m +1], ofNat n => -ofNat (succ m % n)
   | -[m +1], -[n +1] => -ofNat (succ m % succ n)
 
-@[deprecated tmod (since := "2024-09-11")] abbrev mod := tmod
-
 /-! ### F-rounding division
 This pair satisfies `fdiv x y = floor (x / y)`.
 -/
@@ -117,22 +101,6 @@ This pair satisfies `fdiv x y = floor (x / y)`.
 Integer division. This version of division uses the F-rounding convention
 (flooring division), in which `Int.fdiv x y` satisfies `fdiv x y = floor (x / y)`
 and `Int.fmod` is the unique function satisfying `fmod x y + (fdiv x y) * y = x`.
-
-Examples:
-```
-#eval (7 : Int).fdiv (0 : Int) -- 0
-#eval (0 : Int).fdiv (7 : Int) -- 0
-
-#eval (12 : Int).fdiv (6 : Int) -- 2
-#eval (12 : Int).fdiv (-6 : Int) -- -2
-#eval (-12 : Int).fdiv (6 : Int) -- -2
-#eval (-12 : Int).fdiv (-6 : Int) -- 2
-
-#eval (12 : Int).fdiv (7 : Int) -- 1
-#eval (12 : Int).fdiv (-7 : Int) -- -2
-#eval (-12 : Int).fdiv (7 : Int) -- -2
-#eval (-12 : Int).fdiv (-7 : Int) -- 1
-```
 -/
 def fdiv : Int → Int → Int
   | 0,       _       => 0
@@ -146,23 +114,6 @@ def fdiv : Int → Int → Int
 Integer modulus. This version of `Int.mod` uses the F-rounding convention
 (flooring division), in which `Int.fdiv x y` satisfies `fdiv x y = floor (x / y)`
 and `Int.fmod` is the unique function satisfying `fmod x y + (fdiv x y) * y = x`.
-
-Examples:
-
-```
-#eval (7 : Int).fmod (0 : Int) -- 7
-#eval (0 : Int).fmod (7 : Int) -- 0
-
-#eval (12 : Int).fmod (6 : Int) -- 0
-#eval (12 : Int).fmod (-6 : Int) -- 0
-#eval (-12 : Int).fmod (6 : Int) -- 0
-#eval (-12 : Int).fmod (-6 : Int) -- 0
-
-#eval (12 : Int).fmod (7 : Int) -- 5
-#eval (12 : Int).fmod (-7 : Int) -- -2
-#eval (-12 : Int).fmod (7 : Int) -- 2
-#eval (-12 : Int).fmod (-7 : Int) -- -5
-```
 -/
 def fmod : Int → Int → Int
   | 0,       _       => 0
@@ -179,26 +130,6 @@ This pair satisfies `0 ≤ mod x y < natAbs y` for `y ≠ 0`.
 Integer division. This version of `Int.div` uses the E-rounding convention
 (euclidean division), in which `Int.emod x y` satisfies `0 ≤ mod x y < natAbs y` for `y ≠ 0`
 and `Int.ediv` is the unique function satisfying `emod x y + (ediv x y) * y = x`.
-
-This is the function powering the `/` notation on integers.
-
-Examples:
-```
-#eval (7 : Int) / (0 : Int) -- 0
-#eval (0 : Int) / (7 : Int) -- 0
-
-#eval (12 : Int) / (6 : Int) -- 2
-#eval (12 : Int) / (-6 : Int) -- -2
-#eval (-12 : Int) / (6 : Int) -- -2
-#eval (-12 : Int) / (-6 : Int) -- 2
-
-#eval (12 : Int) / (7 : Int) -- 1
-#eval (12 : Int) / (-7 : Int) -- -1
-#eval (-12 : Int) / (7 : Int) -- -2
-#eval (-12 : Int) / (-7 : Int) -- 2
-```
-
-Implemented by efficient native code.
 -/
 @[extern "lean_int_ediv"]
 def ediv : (@& Int) → (@& Int) → Int
@@ -212,26 +143,6 @@ def ediv : (@& Int) → (@& Int) → Int
 Integer modulus. This version of `Int.mod` uses the E-rounding convention
 (euclidean division), in which `Int.emod x y` satisfies `0 ≤ emod x y < natAbs y` for `y ≠ 0`
 and `Int.ediv` is the unique function satisfying `emod x y + (ediv x y) * y = x`.
-
-This is the function powering the `%` notation on integers.
-
-Examples:
-```
-#eval (7 : Int) % (0 : Int) -- 7
-#eval (0 : Int) % (7 : Int) -- 0
-
-#eval (12 : Int) % (6 : Int) -- 0
-#eval (12 : Int) % (-6 : Int) -- 0
-#eval (-12 : Int) % (6 : Int) -- 0
-#eval (-12 : Int) % (-6 : Int) -- 0
-
-#eval (12 : Int) % (7 : Int) -- 5
-#eval (12 : Int) % (-7 : Int) -- 5
-#eval (-12 : Int) % (7 : Int) -- 2
-#eval (-12 : Int) % (-7 : Int) -- 2
-```
-
-Implemented by efficient native code.
 -/
 @[extern "lean_int_emod"]
 def emod : (@& Int) → (@& Int) → Int
@@ -249,9 +160,7 @@ instance : Mod Int where
 
 @[simp, norm_cast] theorem ofNat_ediv (m n : Nat) : (↑(m / n) : Int) = ↑m / ↑n := rfl
 
-theorem ofNat_tdiv (m n : Nat) : ↑(m / n) = tdiv ↑m ↑n := rfl
-
-@[deprecated ofNat_tdiv (since := "2024-09-11")] abbrev ofNat_div := ofNat_tdiv
+theorem ofNat_div (m n : Nat) : ↑(m / n) = div ↑m ↑n := rfl
 
 theorem ofNat_fdiv : ∀ m n : Nat, ↑(m / n) = fdiv ↑m ↑n
   | 0, _ => by simp [fdiv]

src/Init/Data/Int/DivModLemmas.lean

@@ -14,6 +14,9 @@ import Init.RCases
 # Lemmas about integer division needed to bootstrap `omega`.
 -/
 
+-- Remove after the next stage0 update
+set_option allowUnsafeReducibility true
+
 open Nat (succ)
 
 namespace Int
@@ -54,7 +57,7 @@ protected theorem dvd_mul_right (a b : Int) : a ∣ a * b := ⟨_, rfl⟩
 
 protected theorem dvd_mul_left (a b : Int) : b ∣ a * b := ⟨_, Int.mul_comm ..⟩
 
-@[simp] protected theorem neg_dvd {a b : Int} : -a ∣ b ↔ a ∣ b := by
+protected theorem neg_dvd {a b : Int} : -a ∣ b ↔ a ∣ b := by
   constructor <;> exact fun ⟨k, e⟩ =>
     ⟨-k, by simp [e, Int.neg_mul, Int.mul_neg, Int.neg_neg]⟩
 
@@ -137,12 +140,12 @@ theorem eq_one_of_mul_eq_one_left {a b : Int} (H : 0 ≤ b) (H' : a * b = 1) : b
   | ofNat _ => show ofNat _ = _ by simp
   | -[_+1] => rfl
 
-@[simp] protected theorem zero_tdiv : ∀ b : Int, tdiv 0 b = 0
+@[simp] protected theorem zero_div : ∀ b : Int, div 0 b = 0
   | ofNat _ => show ofNat _ = _ by simp
   | -[_+1] => show -ofNat _ = _ by simp
 
 unseal Nat.div in
-@[simp] protected theorem tdiv_zero : ∀ a : Int, tdiv a 0 = 0
+@[simp] protected theorem div_zero : ∀ a : Int, div a 0 = 0
   | ofNat _ => show ofNat _ = _ by simp
   | -[_+1] => rfl
 
@@ -156,17 +159,16 @@ unseal Nat.div in
 
 /-! ### div equivalences  -/
 
-theorem tdiv_eq_ediv : ∀ {a b : Int}, 0 ≤ a → 0 ≤ b → a.tdiv b = a / b
+theorem div_eq_ediv : ∀ {a b : Int}, 0 ≤ a → 0 ≤ b → a.div b = a / b
   | 0, _, _, _ | _, 0, _, _ => by simp
   | succ _, succ _, _, _ => rfl
 
-
 theorem fdiv_eq_ediv : ∀ (a : Int) {b : Int}, 0 ≤ b → fdiv a b = a / b
   | 0, _, _ | -[_+1], 0, _ => by simp
   | succ _, ofNat _, _ | -[_+1], succ _, _ => rfl
 
-theorem fdiv_eq_tdiv {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : fdiv a b = tdiv a b :=
-  tdiv_eq_ediv Ha Hb ▸ fdiv_eq_ediv _ Hb
+theorem fdiv_eq_div {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : fdiv a b = div a b :=
+  div_eq_ediv Ha Hb ▸ fdiv_eq_ediv _ Hb
 
 /-! ### mod zero -/
 
@@ -176,9 +178,9 @@ theorem fdiv_eq_tdiv {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : fdiv a b = tdiv
   | ofNat _ => congrArg ofNat <| Nat.mod_zero _
   | -[_+1]  => congrArg negSucc <| Nat.mod_zero _
 
-@[simp] theorem zero_tmod (b : Int) : tmod 0 b = 0 := by cases b <;> simp [tmod]
+@[simp] theorem zero_mod (b : Int) : mod 0 b = 0 := by cases b <;> simp [mod]
 
-@[simp] theorem tmod_zero : ∀ a : Int, tmod a 0 = a
+@[simp] theorem mod_zero : ∀ a : Int, mod a 0 = a
   | ofNat _ => congrArg ofNat <| Nat.mod_zero _
   | -[_+1] => congrArg (fun n => -ofNat n) <| Nat.mod_zero _
 
@@ -222,7 +224,7 @@ theorem ediv_add_emod' (a b : Int) : a / b * b + a % b = a := by
 theorem emod_def (a b : Int) : a % b = a - b * (a / b) := by
   rw [← Int.add_sub_cancel (a % b), emod_add_ediv]
 
-theorem tmod_add_tdiv : ∀ a b : Int, tmod a b + b * (a.tdiv b) = a
+theorem mod_add_div : ∀ a b : Int, mod a b + b * (a.div b) = a
   | ofNat _, ofNat _ => congrArg ofNat (Nat.mod_add_div ..)
   | ofNat m, -[n+1] => by
     show (m % succ n + -↑(succ n) * -↑(m / succ n) : Int) = m
@@ -239,17 +241,17 @@ theorem tmod_add_tdiv : ∀ a b : Int, tmod a b + b * (a.tdiv b) = a
     rw [Int.neg_mul, ← Int.neg_add]
     exact congrArg (-ofNat ·) (Nat.mod_add_div ..)
 
-theorem tdiv_add_tmod (a b : Int) : b * a.tdiv b + tmod a b = a := by
-  rw [Int.add_comm]; apply tmod_add_tdiv ..
+theorem div_add_mod (a b : Int) : b * a.div b + mod a b = a := by
+  rw [Int.add_comm]; apply mod_add_div ..
 
-theorem tmod_add_tdiv' (m k : Int) : tmod m k + m.tdiv k * k = m := by
-  rw [Int.mul_comm]; apply tmod_add_tdiv
+theorem mod_add_div' (m k : Int) : mod m k + m.div k * k = m := by
+  rw [Int.mul_comm]; apply mod_add_div
 
-theorem tdiv_add_tmod' (m k : Int) : m.tdiv k * k + tmod m k = m := by
-  rw [Int.mul_comm]; apply tdiv_add_tmod
+theorem div_add_mod' (m k : Int) : m.div k * k + mod m k = m := by
+  rw [Int.mul_comm]; apply div_add_mod
 
-theorem tmod_def (a b : Int) : tmod a b = a - b * a.tdiv b := by
-  rw [← Int.add_sub_cancel (tmod a b), tmod_add_tdiv]
+theorem mod_def (a b : Int) : mod a b = a - b * a.div b := by
+  rw [← Int.add_sub_cancel (mod a b), mod_add_div]
 
 theorem fmod_add_fdiv : ∀ a b : Int, a.fmod b + b * a.fdiv b = a
   | 0, ofNat _ | 0, -[_+1] => congrArg ofNat <| by simp
@@ -279,11 +281,11 @@ theorem fmod_def (a b : Int) : a.fmod b = a - b * a.fdiv b := by
 theorem fmod_eq_emod (a : Int) {b : Int} (hb : 0 ≤ b) : fmod a b = a % b := by
   simp [fmod_def, emod_def, fdiv_eq_ediv _ hb]
 
-theorem tmod_eq_emod {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : tmod a b = a % b := by
-  simp [emod_def, tmod_def, tdiv_eq_ediv ha hb]
+theorem mod_eq_emod {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : mod a b = a % b := by
+  simp [emod_def, mod_def, div_eq_ediv ha hb]
 
-theorem fmod_eq_tmod {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : fmod a b = tmod a b :=
-  tmod_eq_emod Ha Hb ▸ fmod_eq_emod _ Hb
+theorem fmod_eq_mod {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : fmod a b = mod a b :=
+  mod_eq_emod Ha Hb ▸ fmod_eq_emod _ Hb
 
 /-! ### `/` ediv -/
 
@@ -298,7 +300,7 @@ theorem ediv_neg' {a b : Int} (Ha : a < 0) (Hb : 0 < b) : a / b < 0 :=
 
 protected theorem div_def (a b : Int) : a / b = Int.ediv a b := rfl
 
-theorem negSucc_ediv (m : Nat) {b : Int} (H : 0 < b) : -[m+1] / b = -(ediv m b + 1) :=
+theorem negSucc_ediv (m : Nat) {b : Int} (H : 0 < b) : -[m+1] / b = -(div m b + 1) :=
   match b, eq_succ_of_zero_lt H with
   | _, ⟨_, rfl⟩ => rfl
 
@@ -306,22 +308,6 @@ theorem ediv_nonneg {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : 0 ≤ a / b :=
   match a, b, eq_ofNat_of_zero_le Ha, eq_ofNat_of_zero_le Hb with
   | _, _, ⟨_, rfl⟩, ⟨_, rfl⟩ => ofNat_zero_le _
 
-theorem ediv_nonneg_of_nonpos_of_nonpos {a b : Int} (Ha : a ≤ 0) (Hb : b ≤ 0) : 0 ≤ a / b := by
-  match a, b with
-  | ofNat a, b =>
-    match Int.le_antisymm Ha (ofNat_zero_le a) with
-    | h1 =>
-      rw [h1, zero_ediv]
-      exact Int.le_refl 0
-  | a, ofNat b =>
-    match Int.le_antisymm Hb (ofNat_zero_le  b) with
-    | h1 =>
-      rw [h1, Int.ediv_zero]
-      exact Int.le_refl 0
-  | negSucc a, negSucc b =>
-    rw [Int.div_def, ediv]
-    exact le_add_one (ediv_nonneg (ofNat_zero_le a) (Int.le_trans (ofNat_zero_le b) (le.intro 1 rfl)))
-
 theorem ediv_nonpos {a b : Int} (Ha : 0 ≤ a) (Hb : b ≤ 0) : a / b ≤ 0 :=
   Int.nonpos_of_neg_nonneg <| Int.ediv_neg .. ▸ Int.ediv_nonneg Ha (Int.neg_nonneg_of_nonpos Hb)
 
@@ -371,7 +357,6 @@ theorem add_ediv_of_dvd_left {a b c : Int} (H : c ∣ a) : (a + b) / c = a / c +
 @[simp] theorem mul_ediv_cancel_left (b : Int) (H : a ≠ 0) : (a * b) / a = b :=
   Int.mul_comm .. ▸ Int.mul_ediv_cancel _ H
 
-
 theorem div_nonneg_iff_of_pos {a b : Int} (h : 0 < b) : a / b ≥ 0 ↔ a ≥ 0 := by
   rw [Int.div_def]
   match b, h with
@@ -469,12 +454,6 @@ theorem lt_mul_ediv_self_add {x k : Int} (h : 0 < k) : x < k * (x / k) + k :=
 @[simp] theorem add_mul_emod_self_left (a b c : Int) : (a + b * c) % b = a % b := by
   rw [Int.mul_comm, Int.add_mul_emod_self]
 
-@[simp] theorem add_neg_mul_emod_self {a b c : Int} : (a + -(b * c)) % c = a % c := by
-  rw [Int.neg_mul_eq_neg_mul, add_mul_emod_self]
-
-@[simp] theorem add_neg_mul_emod_self_left {a b c : Int} : (a + -(b * c)) % b = a % b := by
-  rw [Int.neg_mul_eq_mul_neg, add_mul_emod_self_left]
-
 @[simp] theorem add_emod_self {a b : Int} : (a + b) % b = a % b := by
   have := add_mul_emod_self_left a b 1; rwa [Int.mul_one] at this
 
@@ -519,12 +498,9 @@ theorem mul_emod (a b n : Int) : (a * b) % n = (a % n) * (b % n) % n := by
     Int.mul_assoc, Int.mul_assoc, ← Int.mul_add n _ _, add_mul_emod_self_left,
     ← Int.mul_assoc, add_mul_emod_self]
 
-@[simp] theorem emod_self {a : Int} : a % a = 0 := by
+@[local simp] theorem emod_self {a : Int} : a % a = 0 := by
   have := mul_emod_left 1 a; rwa [Int.one_mul] at this
 
-@[simp] theorem neg_emod_self (a : Int) : -a % a = 0 := by
-  rw [neg_emod, Int.sub_self, zero_emod]
-
 @[simp] theorem emod_emod_of_dvd (n : Int) {m k : Int}
     (h : m ∣ k) : (n % k) % m = n % m := by
   conv => rhs; rw [← emod_add_ediv n k]
@@ -617,17 +593,9 @@ theorem dvd_emod_sub_self {x : Int} {m : Nat} : (m : Int) ∣ x % m - x := by
 theorem emod_eq_zero_of_dvd : ∀ {a b : Int}, a ∣ b → b % a = 0
   | _, _, ⟨_, rfl⟩ => mul_emod_right ..
 
-theorem dvd_iff_emod_eq_zero {a b : Int} : a ∣ b ↔ b % a = 0 :=
+theorem dvd_iff_emod_eq_zero (a b : Int) : a ∣ b ↔ b % a = 0 :=
   ⟨emod_eq_zero_of_dvd, dvd_of_emod_eq_zero⟩
 
-@[simp] theorem neg_mul_emod_left (a b : Int) : -(a * b) % b = 0 := by
-  rw [← dvd_iff_emod_eq_zero, Int.dvd_neg]
-  exact Int.dvd_mul_left a b
-
-@[simp] theorem neg_mul_emod_right (a b : Int) : -(a * b) % a = 0 := by
-  rw [← dvd_iff_emod_eq_zero, Int.dvd_neg]
-  exact Int.dvd_mul_right a b
-
 instance decidableDvd : DecidableRel (α := Int) (· ∣ ·) := fun _ _ =>
   decidable_of_decidable_of_iff (dvd_iff_emod_eq_zero ..).symm
 
@@ -652,12 +620,6 @@ theorem neg_ediv_of_dvd : ∀ {a b : Int}, b ∣ a → (-a) / b = -(a / b)
     · simp [bz]
     · rw [Int.neg_mul_eq_mul_neg, Int.mul_ediv_cancel_left _ bz, Int.mul_ediv_cancel_left _ bz]
 
-@[simp] theorem neg_mul_ediv_cancel (a b : Int) (h : b ≠ 0) : -(a * b) / b = -a := by
-  rw [neg_ediv_of_dvd (Int.dvd_mul_left a b), mul_ediv_cancel _ h]
-
-@[simp] theorem neg_mul_ediv_cancel_left (a b : Int) (h : a ≠ 0) : -(a * b) / a = -b := by
-  rw [neg_ediv_of_dvd (Int.dvd_mul_right a b), mul_ediv_cancel_left _ h]
-
 theorem sub_ediv_of_dvd (a : Int) {b c : Int}
     (hcb : c ∣ b) : (a - b) / c = a / c - b / c := by
   rw [Int.sub_eq_add_neg, Int.sub_eq_add_neg, Int.add_ediv_of_dvd_right (Int.dvd_neg.2 hcb)]
@@ -673,22 +635,13 @@ theorem sub_ediv_of_dvd (a : Int) {b c : Int}
 @[simp] protected theorem ediv_self {a : Int} (H : a ≠ 0) : a / a = 1 := by
   have := Int.mul_ediv_cancel 1 H; rwa [Int.one_mul] at this
 
-@[simp] protected theorem neg_ediv_self (a : Int) (h : a ≠ 0) : (-a) / a = -1 := by
-  rw [neg_ediv_of_dvd (Int.dvd_refl a), Int.ediv_self h]
-
 @[simp]
-theorem emod_sub_cancel (x y : Int): (x - y) % y = x % y := by
+theorem emod_sub_cancel (x y : Int): (x - y)%y = x%y := by
   by_cases h : y = 0
   · simp [h]
   · simp only [Int.emod_def, Int.sub_ediv_of_dvd, Int.dvd_refl, Int.ediv_self h, Int.mul_sub]
     simp [Int.mul_one, Int.sub_sub, Int.add_comm y]
 
-@[simp] theorem add_neg_emod_self (a b : Int) : (a + -b) % b = a % b := by
-  rw [← Int.sub_eq_add_neg, emod_sub_cancel]
-
-@[simp] theorem neg_add_emod_self (a b : Int) : (-a + b) % a = b % a := by
-  rw [Int.add_comm, add_neg_emod_self]
-
 /-- If `a % b = c` then `b` divides `a - c`. -/
 theorem dvd_sub_of_emod_eq {a b c : Int} (h : a % b = c) : b ∣ a - c := by
   have hx : (a % b) % b = c % b := by
@@ -801,7 +754,7 @@ protected theorem lt_ediv_of_mul_lt {a b c : Int} (H1 : 0 ≤ b) (H2 : b ∣ c)
     a < c / b :=
   Int.lt_of_not_ge <| mt (Int.le_mul_of_ediv_le H1 H2) (Int.not_le_of_gt H3)
 
-protected theorem lt_ediv_iff_mul_lt {a b : Int} {c : Int} (H : 0 < c) (H' : c ∣ b) :
+protected theorem lt_ediv_iff_mul_lt {a b : Int} (c : Int) (H : 0 < c) (H' : c ∣ b) :
     a < b / c ↔ a * c < b :=
   ⟨Int.mul_lt_of_lt_ediv H, Int.lt_ediv_of_mul_lt (Int.le_of_lt H) H'⟩
 
@@ -813,191 +766,179 @@ theorem ediv_eq_ediv_of_mul_eq_mul {a b c d : Int}
   Int.ediv_eq_of_eq_mul_right H3 <| by
     rw [← Int.mul_ediv_assoc _ H2]; exact (Int.ediv_eq_of_eq_mul_left H4 H5.symm).symm
 
-/-! ### tdiv -/
+/-! ### div -/
 
-@[simp] protected theorem tdiv_one : ∀ a : Int, a.tdiv 1 = a
+@[simp] protected theorem div_one : ∀ a : Int, a.div 1 = a
   | (n:Nat) => congrArg ofNat (Nat.div_one _)
-  | -[n+1] => by simp [Int.tdiv, neg_ofNat_succ]; rfl
+  | -[n+1] => by simp [Int.div, neg_ofNat_succ]; rfl
 
 unseal Nat.div in
-@[simp] protected theorem tdiv_neg : ∀ a b : Int, a.tdiv (-b) = -(a.tdiv b)
+@[simp] protected theorem div_neg : ∀ a b : Int, a.div (-b) = -(a.div b)
   | ofNat m, 0 => show ofNat (m / 0) = -↑(m / 0) by rw [Nat.div_zero]; rfl
   | ofNat m, -[n+1] | -[m+1], succ n => (Int.neg_neg _).symm
   | ofNat m, succ n | -[m+1], 0 | -[m+1], -[n+1] => rfl
 
 unseal Nat.div in
-@[simp] protected theorem neg_tdiv : ∀ a b : Int, (-a).tdiv b = -(a.tdiv b)
+@[simp] protected theorem neg_div : ∀ a b : Int, (-a).div b = -(a.div b)
   | 0, n => by simp [Int.neg_zero]
   | succ m, (n:Nat) | -[m+1], 0 | -[m+1], -[n+1] => rfl
   | succ m, -[n+1] | -[m+1], succ n => (Int.neg_neg _).symm
 
-protected theorem neg_tdiv_neg (a b : Int) : (-a).tdiv (-b) = a.tdiv b := by
-  simp [Int.tdiv_neg, Int.neg_tdiv, Int.neg_neg]
+protected theorem neg_div_neg (a b : Int) : (-a).div (-b) = a.div b := by
+  simp [Int.div_neg, Int.neg_div, Int.neg_neg]
 
-protected theorem tdiv_nonneg {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : 0 ≤ a.tdiv b :=
+protected theorem div_nonneg {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : 0 ≤ a.div b :=
   match a, b, eq_ofNat_of_zero_le Ha, eq_ofNat_of_zero_le Hb with
   | _, _, ⟨_, rfl⟩, ⟨_, rfl⟩ => ofNat_zero_le _
 
-protected theorem tdiv_nonpos {a b : Int} (Ha : 0 ≤ a) (Hb : b ≤ 0) : a.tdiv b ≤ 0 :=
-  Int.nonpos_of_neg_nonneg <| Int.tdiv_neg .. ▸ Int.tdiv_nonneg Ha (Int.neg_nonneg_of_nonpos Hb)
+protected theorem div_nonpos {a b : Int} (Ha : 0 ≤ a) (Hb : b ≤ 0) : a.div b ≤ 0 :=
+  Int.nonpos_of_neg_nonneg <| Int.div_neg .. ▸ Int.div_nonneg Ha (Int.neg_nonneg_of_nonpos Hb)
 
-theorem tdiv_eq_zero_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a.tdiv b = 0 :=
+theorem div_eq_zero_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a.div b = 0 :=
   match a, b, eq_ofNat_of_zero_le H1, eq_succ_of_zero_lt (Int.lt_of_le_of_lt H1 H2) with
   | _, _, ⟨_, rfl⟩, ⟨_, rfl⟩ => congrArg Nat.cast <| Nat.div_eq_of_lt <| ofNat_lt.1 H2
 
-@[simp] protected theorem mul_tdiv_cancel (a : Int) {b : Int} (H : b ≠ 0) : (a * b).tdiv b = a :=
-  have : ∀ {a b : Nat}, (b : Int) ≠ 0 → (tdiv (a * b) b : Int) = a := fun H => by
-    rw [← ofNat_mul, ← ofNat_tdiv,
+@[simp] protected theorem mul_div_cancel (a : Int) {b : Int} (H : b ≠ 0) : (a * b).div b = a :=
+  have : ∀ {a b : Nat}, (b : Int) ≠ 0 → (div (a * b) b : Int) = a := fun H => by
+    rw [← ofNat_mul, ← ofNat_div,
       Nat.mul_div_cancel _ <| Nat.pos_of_ne_zero <| Int.ofNat_ne_zero.1 H]
   match a, b, a.eq_nat_or_neg, b.eq_nat_or_neg with
   | _, _, ⟨a, .inl rfl⟩, ⟨b, .inl rfl⟩ => this H
   | _, _, ⟨a, .inl rfl⟩, ⟨b, .inr rfl⟩ => by
-    rw [Int.mul_neg, Int.neg_tdiv, Int.tdiv_neg, Int.neg_neg,
+    rw [Int.mul_neg, Int.neg_div, Int.div_neg, Int.neg_neg,
       this (Int.neg_ne_zero.1 H)]
-  | _, _, ⟨a, .inr rfl⟩, ⟨b, .inl rfl⟩ => by rw [Int.neg_mul, Int.neg_tdiv, this H]
+  | _, _, ⟨a, .inr rfl⟩, ⟨b, .inl rfl⟩ => by rw [Int.neg_mul, Int.neg_div, this H]
   | _, _, ⟨a, .inr rfl⟩, ⟨b, .inr rfl⟩ => by
-    rw [Int.neg_mul_neg, Int.tdiv_neg, this (Int.neg_ne_zero.1 H)]
+    rw [Int.neg_mul_neg, Int.div_neg, this (Int.neg_ne_zero.1 H)]
 
-@[simp] protected theorem mul_tdiv_cancel_left (b : Int) (H : a ≠ 0) : (a * b).tdiv a = b :=
-  Int.mul_comm .. ▸ Int.mul_tdiv_cancel _ H
+@[simp] protected theorem mul_div_cancel_left (b : Int) (H : a ≠ 0) : (a * b).div a = b :=
+  Int.mul_comm .. ▸ Int.mul_div_cancel _ H
 
-@[simp] protected theorem tdiv_self {a : Int} (H : a ≠ 0) : a.tdiv a = 1 := by
-  have := Int.mul_tdiv_cancel 1 H; rwa [Int.one_mul] at this
+@[simp] protected theorem div_self {a : Int} (H : a ≠ 0) : a.div a = 1 := by
+  have := Int.mul_div_cancel 1 H; rwa [Int.one_mul] at this
 
-theorem mul_tdiv_cancel_of_tmod_eq_zero {a b : Int} (H : a.tmod b = 0) : b * (a.tdiv b) = a := by
-  have := tmod_add_tdiv a b; rwa [H, Int.zero_add] at this
+theorem mul_div_cancel_of_mod_eq_zero {a b : Int} (H : a.mod b = 0) : b * (a.div b) = a := by
+  have := mod_add_div a b; rwa [H, Int.zero_add] at this
 
-theorem tdiv_mul_cancel_of_tmod_eq_zero {a b : Int} (H : a.tmod b = 0) : a.tdiv b * b = a := by
-  rw [Int.mul_comm, mul_tdiv_cancel_of_tmod_eq_zero H]
+theorem div_mul_cancel_of_mod_eq_zero {a b : Int} (H : a.mod b = 0) : a.div b * b = a := by
+  rw [Int.mul_comm, mul_div_cancel_of_mod_eq_zero H]
 
-theorem dvd_of_tmod_eq_zero {a b : Int} (H : tmod b a = 0) : a ∣ b :=
-  ⟨b.tdiv a, (mul_tdiv_cancel_of_tmod_eq_zero H).symm⟩
+theorem dvd_of_mod_eq_zero {a b : Int} (H : mod b a = 0) : a ∣ b :=
+  ⟨b.div a, (mul_div_cancel_of_mod_eq_zero H).symm⟩
 
-protected theorem mul_tdiv_assoc (a : Int) : ∀ {b c : Int}, c ∣ b → (a * b).tdiv c = a * (b.tdiv c)
+protected theorem mul_div_assoc (a : Int) : ∀ {b c : Int}, c ∣ b → (a * b).div c = a * (b.div c)
   | _, c, ⟨d, rfl⟩ =>
     if cz : c = 0 then by simp [cz, Int.mul_zero] else by
-      rw [Int.mul_left_comm, Int.mul_tdiv_cancel_left _ cz, Int.mul_tdiv_cancel_left _ cz]
+      rw [Int.mul_left_comm, Int.mul_div_cancel_left _ cz, Int.mul_div_cancel_left _ cz]
 
-protected theorem mul_tdiv_assoc' (b : Int) {a c : Int} (h : c ∣ a) :
-    (a * b).tdiv c = a.tdiv c * b := by
-  rw [Int.mul_comm, Int.mul_tdiv_assoc _ h, Int.mul_comm]
+protected theorem mul_div_assoc' (b : Int) {a c : Int} (h : c ∣ a) :
+    (a * b).div c = a.div c * b := by
+  rw [Int.mul_comm, Int.mul_div_assoc _ h, Int.mul_comm]
 
-theorem tdiv_dvd_tdiv : ∀ {a b c : Int}, a ∣ b → b ∣ c → b.tdiv a ∣ c.tdiv a
+theorem div_dvd_div : ∀ {a b c : Int}, a ∣ b → b ∣ c → b.div a ∣ c.div a
   | a, _, _, ⟨b, rfl⟩, ⟨c, rfl⟩ => by
     by_cases az : a = 0
     · simp [az]
-    · rw [Int.mul_tdiv_cancel_left _ az, Int.mul_assoc, Int.mul_tdiv_cancel_left _ az]
+    · rw [Int.mul_div_cancel_left _ az, Int.mul_assoc, Int.mul_div_cancel_left _ az]
       apply Int.dvd_mul_right
 
-@[simp] theorem natAbs_tdiv (a b : Int) : natAbs (a.tdiv b) = (natAbs a).div (natAbs b) :=
+@[simp] theorem natAbs_div (a b : Int) : natAbs (a.div b) = (natAbs a).div (natAbs b) :=
   match a, b, eq_nat_or_neg a, eq_nat_or_neg b with
   | _, _, ⟨_, .inl rfl⟩, ⟨_, .inl rfl⟩ => rfl
-  | _, _, ⟨_, .inl rfl⟩, ⟨_, .inr rfl⟩ => by rw [Int.tdiv_neg, natAbs_neg, natAbs_neg]; rfl
-  | _, _, ⟨_, .inr rfl⟩, ⟨_, .inl rfl⟩ => by rw [Int.neg_tdiv, natAbs_neg, natAbs_neg]; rfl
-  | _, _, ⟨_, .inr rfl⟩, ⟨_, .inr rfl⟩ => by rw [Int.neg_tdiv_neg, natAbs_neg, natAbs_neg]; rfl
+  | _, _, ⟨_, .inl rfl⟩, ⟨_, .inr rfl⟩ => by rw [Int.div_neg, natAbs_neg, natAbs_neg]; rfl
+  | _, _, ⟨_, .inr rfl⟩, ⟨_, .inl rfl⟩ => by rw [Int.neg_div, natAbs_neg, natAbs_neg]; rfl
+  | _, _, ⟨_, .inr rfl⟩, ⟨_, .inr rfl⟩ => by rw [Int.neg_div_neg, natAbs_neg, natAbs_neg]; rfl
 
-protected theorem tdiv_eq_of_eq_mul_right {a b c : Int}
-    (H1 : b ≠ 0) (H2 : a = b * c) : a.tdiv b = c := by rw [H2, Int.mul_tdiv_cancel_left _ H1]
+protected theorem div_eq_of_eq_mul_right {a b c : Int}
+    (H1 : b ≠ 0) (H2 : a = b * c) : a.div b = c := by rw [H2, Int.mul_div_cancel_left _ H1]
 
-protected theorem eq_tdiv_of_mul_eq_right {a b c : Int}
-    (H1 : a ≠ 0) (H2 : a * b = c) : b = c.tdiv a :=
-  (Int.tdiv_eq_of_eq_mul_right H1 H2.symm).symm
+protected theorem eq_div_of_mul_eq_right {a b c : Int}
+    (H1 : a ≠ 0) (H2 : a * b = c) : b = c.div a :=
+  (Int.div_eq_of_eq_mul_right H1 H2.symm).symm
 
 /-! ### (t-)mod -/
 
-theorem ofNat_tmod (m n : Nat) : (↑(m % n) : Int) = tmod m n := rfl
+theorem ofNat_mod (m n : Nat) : (↑(m % n) : Int) = mod m n := rfl
 
-@[simp] theorem tmod_one (a : Int) : tmod a 1 = 0 := by
-  simp [tmod_def, Int.tdiv_one, Int.one_mul, Int.sub_self]
+@[simp] theorem mod_one (a : Int) : mod a 1 = 0 := by
+  simp [mod_def, Int.div_one, Int.one_mul, Int.sub_self]
 
-theorem tmod_eq_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : tmod a b = a := by
-  rw [tmod_eq_emod H1 (Int.le_trans H1 (Int.le_of_lt H2)), emod_eq_of_lt H1 H2]
+theorem mod_eq_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : mod a b = a := by
+  rw [mod_eq_emod H1 (Int.le_trans H1 (Int.le_of_lt H2)), emod_eq_of_lt H1 H2]
 
-theorem tmod_lt_of_pos (a : Int) {b : Int} (H : 0 < b) : tmod a b < b :=
+theorem mod_lt_of_pos (a : Int) {b : Int} (H : 0 < b) : mod a b < b :=
   match a, b, eq_succ_of_zero_lt H with
   | ofNat _, _, ⟨n, rfl⟩ => ofNat_lt.2 <| Nat.mod_lt _ n.succ_pos
   | -[_+1], _, ⟨n, rfl⟩ => Int.lt_of_le_of_lt
     (Int.neg_nonpos_of_nonneg <| Int.ofNat_nonneg _) (ofNat_pos.2 n.succ_pos)
 
-theorem tmod_nonneg : ∀ {a : Int} (b : Int), 0 ≤ a → 0 ≤ tmod a b
+theorem mod_nonneg : ∀ {a : Int} (b : Int), 0 ≤ a → 0 ≤ mod a b
   | ofNat _, -[_+1], _ | ofNat _, ofNat _, _ => ofNat_nonneg _
 
-@[simp] theorem tmod_neg (a b : Int) : tmod a (-b) = tmod a b := by
-  rw [tmod_def, tmod_def, Int.tdiv_neg, Int.neg_mul_neg]
+@[simp] theorem mod_neg (a b : Int) : mod a (-b) = mod a b := by
+  rw [mod_def, mod_def, Int.div_neg, Int.neg_mul_neg]
 
-@[simp] theorem mul_tmod_left (a b : Int) : (a * b).tmod b = 0 :=
+@[simp] theorem mul_mod_left (a b : Int) : (a * b).mod b = 0 :=
   if h : b = 0 then by simp [h, Int.mul_zero] else by
-    rw [Int.tmod_def, Int.mul_tdiv_cancel _ h, Int.mul_comm, Int.sub_self]
+    rw [Int.mod_def, Int.mul_div_cancel _ h, Int.mul_comm, Int.sub_self]
 
-@[simp] theorem mul_tmod_right (a b : Int) : (a * b).tmod a = 0 := by
-  rw [Int.mul_comm, mul_tmod_left]
+@[simp] theorem mul_mod_right (a b : Int) : (a * b).mod a = 0 := by
+  rw [Int.mul_comm, mul_mod_left]
 
-theorem tmod_eq_zero_of_dvd : ∀ {a b : Int}, a ∣ b → tmod b a = 0
-  | _, _, ⟨_, rfl⟩ => mul_tmod_right ..
+theorem mod_eq_zero_of_dvd : ∀ {a b : Int}, a ∣ b → mod b a = 0
+  | _, _, ⟨_, rfl⟩ => mul_mod_right ..
 
-theorem dvd_iff_tmod_eq_zero {a b : Int} : a ∣ b ↔ tmod b a = 0 :=
-  ⟨tmod_eq_zero_of_dvd, dvd_of_tmod_eq_zero⟩
+theorem dvd_iff_mod_eq_zero (a b : Int) : a ∣ b ↔ mod b a = 0 :=
+  ⟨mod_eq_zero_of_dvd, dvd_of_mod_eq_zero⟩
 
-@[simp] theorem neg_mul_tmod_right (a b : Int) : (-(a * b)).tmod a = 0 := by
-  rw [← dvd_iff_tmod_eq_zero, Int.dvd_neg]
-  exact Int.dvd_mul_right a b
+protected theorem div_mul_cancel {a b : Int} (H : b ∣ a) : a.div b * b = a :=
+  div_mul_cancel_of_mod_eq_zero (mod_eq_zero_of_dvd H)
 
-@[simp] theorem neg_mul_tmod_left (a b : Int) : (-(a * b)).tmod b = 0 := by
-  rw [← dvd_iff_tmod_eq_zero, Int.dvd_neg]
-  exact Int.dvd_mul_left a b
+protected theorem mul_div_cancel' {a b : Int} (H : a ∣ b) : a * b.div a = b := by
+  rw [Int.mul_comm, Int.div_mul_cancel H]
 
-protected theorem tdiv_mul_cancel {a b : Int} (H : b ∣ a) : a.tdiv b * b = a :=
-  tdiv_mul_cancel_of_tmod_eq_zero (tmod_eq_zero_of_dvd H)
+protected theorem eq_mul_of_div_eq_right {a b c : Int}
+    (H1 : b ∣ a) (H2 : a.div b = c) : a = b * c := by rw [← H2, Int.mul_div_cancel' H1]
 
-protected theorem mul_tdiv_cancel' {a b : Int} (H : a ∣ b) : a * b.tdiv a = b := by
-  rw [Int.mul_comm, Int.tdiv_mul_cancel H]
+@[simp] theorem mod_self {a : Int} : a.mod a = 0 := by
+  have := mul_mod_left 1 a; rwa [Int.one_mul] at this
 
-protected theorem eq_mul_of_tdiv_eq_right {a b c : Int}
-    (H1 : b ∣ a) (H2 : a.tdiv b = c) : a = b * c := by rw [← H2, Int.mul_tdiv_cancel' H1]
-
-@[simp] theorem tmod_self {a : Int} : a.tmod a = 0 := by
-  have := mul_tmod_left 1 a; rwa [Int.one_mul] at this
-
-@[simp] theorem neg_tmod_self (a : Int) : (-a).tmod a = 0 := by
-  rw [← dvd_iff_tmod_eq_zero, Int.dvd_neg]
-  exact Int.dvd_refl a
-
-theorem lt_tdiv_add_one_mul_self (a : Int) {b : Int} (H : 0 < b) : a < (a.tdiv b + 1) * b := by
+theorem lt_div_add_one_mul_self (a : Int) {b : Int} (H : 0 < b) : a < (a.div b + 1) * b := by
   rw [Int.add_mul, Int.one_mul, Int.mul_comm]
-  exact Int.lt_add_of_sub_left_lt <| Int.tmod_def .. ▸ tmod_lt_of_pos _ H
+  exact Int.lt_add_of_sub_left_lt <| Int.mod_def .. ▸ mod_lt_of_pos _ H
 
-protected theorem tdiv_eq_iff_eq_mul_right {a b c : Int}
-    (H : b ≠ 0) (H' : b ∣ a) : a.tdiv b = c ↔ a = b * c :=
-  ⟨Int.eq_mul_of_tdiv_eq_right H', Int.tdiv_eq_of_eq_mul_right H⟩
+protected theorem div_eq_iff_eq_mul_right {a b c : Int}
+    (H : b ≠ 0) (H' : b ∣ a) : a.div b = c ↔ a = b * c :=
+  ⟨Int.eq_mul_of_div_eq_right H', Int.div_eq_of_eq_mul_right H⟩
 
-protected theorem tdiv_eq_iff_eq_mul_left {a b c : Int}
-    (H : b ≠ 0) (H' : b ∣ a) : a.tdiv b = c ↔ a = c * b := by
-  rw [Int.mul_comm]; exact Int.tdiv_eq_iff_eq_mul_right H H'
+protected theorem div_eq_iff_eq_mul_left {a b c : Int}
+    (H : b ≠ 0) (H' : b ∣ a) : a.div b = c ↔ a = c * b := by
+  rw [Int.mul_comm]; exact Int.div_eq_iff_eq_mul_right H H'
 
-protected theorem eq_mul_of_tdiv_eq_left {a b c : Int}
-    (H1 : b ∣ a) (H2 : a.tdiv b = c) : a = c * b := by
-  rw [Int.mul_comm, Int.eq_mul_of_tdiv_eq_right H1 H2]
+protected theorem eq_mul_of_div_eq_left {a b c : Int}
+    (H1 : b ∣ a) (H2 : a.div b = c) : a = c * b := by
+  rw [Int.mul_comm, Int.eq_mul_of_div_eq_right H1 H2]
 
-protected theorem tdiv_eq_of_eq_mul_left {a b c : Int}
-    (H1 : b ≠ 0) (H2 : a = c * b) : a.tdiv b = c :=
-  Int.tdiv_eq_of_eq_mul_right H1 (by rw [Int.mul_comm, H2])
+protected theorem div_eq_of_eq_mul_left {a b c : Int}
+    (H1 : b ≠ 0) (H2 : a = c * b) : a.div b = c :=
+  Int.div_eq_of_eq_mul_right H1 (by rw [Int.mul_comm, H2])
 
-protected theorem eq_zero_of_tdiv_eq_zero {d n : Int} (h : d ∣ n) (H : n.tdiv d = 0) : n = 0 := by
-  rw [← Int.mul_tdiv_cancel' h, H, Int.mul_zero]
+protected theorem eq_zero_of_div_eq_zero {d n : Int} (h : d ∣ n) (H : n.div d = 0) : n = 0 := by
+  rw [← Int.mul_div_cancel' h, H, Int.mul_zero]
 
-@[simp] protected theorem tdiv_left_inj {a b d : Int}
-    (hda : d ∣ a) (hdb : d ∣ b) : a.tdiv d = b.tdiv d ↔ a = b := by
-  refine ⟨fun h => ?_, congrArg (tdiv · d)⟩
-  rw [← Int.mul_tdiv_cancel' hda, ← Int.mul_tdiv_cancel' hdb, h]
+@[simp] protected theorem div_left_inj {a b d : Int}
+    (hda : d ∣ a) (hdb : d ∣ b) : a.div d = b.div d ↔ a = b := by
+  refine ⟨fun h => ?_, congrArg (div · d)⟩
+  rw [← Int.mul_div_cancel' hda, ← Int.mul_div_cancel' hdb, h]
 
-theorem tdiv_sign : ∀ a b, a.tdiv (sign b) = a * sign b
+theorem div_sign : ∀ a b, a.div (sign b) = a * sign b
   | _, succ _ => by simp [sign, Int.mul_one]
   | _, 0 => by simp [sign, Int.mul_zero]
   | _, -[_+1] => by simp [sign, Int.mul_neg, Int.mul_one]
 
-protected theorem sign_eq_tdiv_abs (a : Int) : sign a = a.tdiv (natAbs a) :=
+protected theorem sign_eq_div_abs (a : Int) : sign a = a.div (natAbs a) :=
   if az : a = 0 then by simp [az] else
-    (Int.tdiv_eq_of_eq_mul_left (ofNat_ne_zero.2 <| natAbs_ne_zero.2 az)
+    (Int.div_eq_of_eq_mul_left (ofNat_ne_zero.2 <| natAbs_ne_zero.2 az)
       (sign_mul_natAbs _).symm).symm
 
 /-! ### fdiv -/
@@ -1050,7 +991,7 @@ theorem fmod_eq_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a.fmod b = a :=
   rw [fmod_eq_emod _ (Int.le_trans H1 (Int.le_of_lt H2)), emod_eq_of_lt H1 H2]
 
 theorem fmod_nonneg {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a.fmod b :=
-  fmod_eq_tmod ha hb ▸ tmod_nonneg _ ha
+  fmod_eq_mod ha hb ▸ mod_nonneg _ ha
 
 theorem fmod_nonneg' (a : Int) {b : Int} (hb : 0 < b) : 0 ≤ a.fmod b :=
   fmod_eq_emod _ (Int.le_of_lt hb) ▸ emod_nonneg _ (Int.ne_of_lt hb).symm
@@ -1070,10 +1011,10 @@ theorem fmod_lt_of_pos (a : Int) {b : Int} (H : 0 < b) : a.fmod b < b :=
 
 /-! ### Theorems crossing div/mod versions -/
 
-theorem tdiv_eq_ediv_of_dvd {a b : Int} (h : b ∣ a) : a.tdiv b = a / b := by
+theorem div_eq_ediv_of_dvd {a b : Int} (h : b ∣ a) : a.div b = a / b := by
   by_cases b0 : b = 0
   · simp [b0]
-  · rw [Int.tdiv_eq_iff_eq_mul_left b0 h, ← Int.ediv_eq_iff_eq_mul_left b0 h]
+  · rw [Int.div_eq_iff_eq_mul_left b0 h, ← Int.ediv_eq_iff_eq_mul_left b0 h]
 
 theorem fdiv_eq_ediv_of_dvd : ∀ {a b : Int}, b ∣ a → a.fdiv b = a / b
   | _, b, ⟨c, rfl⟩ => by
@@ -1150,7 +1091,8 @@ theorem bmod_mul_bmod : Int.bmod (Int.bmod x n * y) n = Int.bmod (x * y) n := by
   next p =>
     simp
   next p =>
-    rw [Int.sub_mul, Int.sub_eq_add_neg, ← Int.mul_neg, bmod_add_mul_cancel, emod_mul_bmod_congr]
+    rw [Int.sub_mul, Int.sub_eq_add_neg, ← Int.mul_neg]
+    simp
 
 @[simp] theorem mul_bmod_bmod : Int.bmod (x * Int.bmod y n) n = Int.bmod (x * y) n := by
   rw [Int.mul_comm x, bmod_mul_bmod, Int.mul_comm x]
@@ -1167,7 +1109,7 @@ theorem emod_bmod {x : Int} {m : Nat} : bmod (x % m) m = bmod x m := by
 
 @[simp] theorem bmod_zero : Int.bmod 0 m = 0 := by
   dsimp [bmod]
-  simp only [Int.zero_sub, ite_eq_left_iff, Int.neg_eq_zero]
+  simp only [zero_emod, Int.zero_sub, ite_eq_left_iff, Int.neg_eq_zero]
   intro h
   rw [@Int.not_lt] at h
   match m with
@@ -1285,65 +1227,3 @@ theorem bmod_natAbs_plus_one (x : Int) (w : 1 < x.natAbs) : bmod x (x.natAbs + 1
           all_goals decide
     · exact ofNat_nonneg x
     · exact succ_ofNat_pos (x + 1)
-
-/-! ### Deprecations -/
-
-@[deprecated Int.zero_tdiv (since := "2024-09-11")] protected abbrev zero_div := @Int.zero_tdiv
-@[deprecated Int.tdiv_zero (since := "2024-09-11")] protected abbrev div_zero := @Int.tdiv_zero
-@[deprecated tdiv_eq_ediv (since := "2024-09-11")] abbrev div_eq_ediv := @tdiv_eq_ediv
-@[deprecated fdiv_eq_tdiv (since := "2024-09-11")] abbrev fdiv_eq_div := @fdiv_eq_tdiv
-@[deprecated zero_tmod (since := "2024-09-11")] abbrev zero_mod := @zero_tmod
-@[deprecated tmod_zero (since := "2024-09-11")] abbrev mod_zero := @tmod_zero
-@[deprecated tmod_add_tdiv (since := "2024-09-11")] abbrev mod_add_div := @tmod_add_tdiv
-@[deprecated tdiv_add_tmod (since := "2024-09-11")] abbrev div_add_mod := @tdiv_add_tmod
-@[deprecated tmod_add_tdiv' (since := "2024-09-11")] abbrev mod_add_div' := @tmod_add_tdiv'
-@[deprecated tdiv_add_tmod' (since := "2024-09-11")] abbrev div_add_mod' := @tdiv_add_tmod'
-@[deprecated tmod_def (since := "2024-09-11")] abbrev mod_def := @tmod_def
-@[deprecated tmod_eq_emod (since := "2024-09-11")] abbrev mod_eq_emod := @tmod_eq_emod
-@[deprecated fmod_eq_tmod (since := "2024-09-11")] abbrev fmod_eq_mod := @fmod_eq_tmod
-@[deprecated Int.tdiv_one (since := "2024-09-11")] protected abbrev div_one := @Int.tdiv_one
-@[deprecated Int.tdiv_neg (since := "2024-09-11")] protected abbrev div_neg := @Int.tdiv_neg
-@[deprecated Int.neg_tdiv (since := "2024-09-11")] protected abbrev neg_div := @Int.neg_tdiv
-@[deprecated Int.neg_tdiv_neg (since := "2024-09-11")] protected abbrev neg_div_neg := @Int.neg_tdiv_neg
-@[deprecated Int.tdiv_nonneg (since := "2024-09-11")] protected abbrev div_nonneg := @Int.tdiv_nonneg
-@[deprecated Int.tdiv_nonpos (since := "2024-09-11")] protected abbrev div_nonpos := @Int.tdiv_nonpos
-@[deprecated Int.tdiv_eq_zero_of_lt (since := "2024-09-11")] abbrev div_eq_zero_of_lt := @Int.tdiv_eq_zero_of_lt
-@[deprecated Int.mul_tdiv_cancel (since := "2024-09-11")] protected abbrev mul_div_cancel := @Int.mul_tdiv_cancel
-@[deprecated Int.mul_tdiv_cancel_left (since := "2024-09-11")] protected abbrev mul_div_cancel_left := @Int.mul_tdiv_cancel_left
-@[deprecated Int.tdiv_self (since := "2024-09-11")] protected abbrev div_self := @Int.tdiv_self
-@[deprecated Int.mul_tdiv_cancel_of_tmod_eq_zero (since := "2024-09-11")] abbrev mul_div_cancel_of_mod_eq_zero := @Int.mul_tdiv_cancel_of_tmod_eq_zero
-@[deprecated Int.tdiv_mul_cancel_of_tmod_eq_zero (since := "2024-09-11")] abbrev div_mul_cancel_of_mod_eq_zero := @Int.tdiv_mul_cancel_of_tmod_eq_zero
-@[deprecated Int.dvd_of_tmod_eq_zero (since := "2024-09-11")] abbrev dvd_of_mod_eq_zero := @Int.dvd_of_tmod_eq_zero
-@[deprecated Int.mul_tdiv_assoc (since := "2024-09-11")] protected abbrev mul_div_assoc := @Int.mul_tdiv_assoc
-@[deprecated Int.mul_tdiv_assoc' (since := "2024-09-11")] protected abbrev mul_div_assoc' := @Int.mul_tdiv_assoc'
-@[deprecated Int.tdiv_dvd_tdiv (since := "2024-09-11")] abbrev div_dvd_div := @Int.tdiv_dvd_tdiv
-@[deprecated Int.natAbs_tdiv (since := "2024-09-11")] abbrev natAbs_div := @Int.natAbs_tdiv
-@[deprecated Int.tdiv_eq_of_eq_mul_right (since := "2024-09-11")] protected abbrev div_eq_of_eq_mul_right := @Int.tdiv_eq_of_eq_mul_right
-@[deprecated Int.eq_tdiv_of_mul_eq_right (since := "2024-09-11")] protected abbrev eq_div_of_mul_eq_right := @Int.eq_tdiv_of_mul_eq_right
-@[deprecated Int.ofNat_tmod (since := "2024-09-11")] abbrev ofNat_mod := @Int.ofNat_tmod
-@[deprecated Int.tmod_one (since := "2024-09-11")] abbrev mod_one := @Int.tmod_one
-@[deprecated Int.tmod_eq_of_lt (since := "2024-09-11")] abbrev mod_eq_of_lt := @Int.tmod_eq_of_lt
-@[deprecated Int.tmod_lt_of_pos (since := "2024-09-11")] abbrev mod_lt_of_pos := @Int.tmod_lt_of_pos
-@[deprecated Int.tmod_nonneg (since := "2024-09-11")] abbrev mod_nonneg := @Int.tmod_nonneg
-@[deprecated Int.tmod_neg (since := "2024-09-11")] abbrev mod_neg := @Int.tmod_neg
-@[deprecated Int.mul_tmod_left (since := "2024-09-11")] abbrev mul_mod_left := @Int.mul_tmod_left
-@[deprecated Int.mul_tmod_right (since := "2024-09-11")] abbrev mul_mod_right := @Int.mul_tmod_right
-@[deprecated Int.tmod_eq_zero_of_dvd (since := "2024-09-11")] abbrev mod_eq_zero_of_dvd := @Int.tmod_eq_zero_of_dvd
-@[deprecated Int.dvd_iff_tmod_eq_zero (since := "2024-09-11")] abbrev dvd_iff_mod_eq_zero := @Int.dvd_iff_tmod_eq_zero
-@[deprecated Int.neg_mul_tmod_right (since := "2024-09-11")] abbrev neg_mul_mod_right := @Int.neg_mul_tmod_right
-@[deprecated Int.neg_mul_tmod_left (since := "2024-09-11")] abbrev neg_mul_mod_left := @Int.neg_mul_tmod_left
-@[deprecated Int.tdiv_mul_cancel (since := "2024-09-11")] protected abbrev div_mul_cancel := @Int.tdiv_mul_cancel
-@[deprecated Int.mul_tdiv_cancel' (since := "2024-09-11")] protected abbrev mul_div_cancel' := @Int.mul_tdiv_cancel'
-@[deprecated Int.eq_mul_of_tdiv_eq_right (since := "2024-09-11")] protected abbrev eq_mul_of_div_eq_right := @Int.eq_mul_of_tdiv_eq_right
-@[deprecated Int.tmod_self (since := "2024-09-11")] abbrev mod_self := @Int.tmod_self
-@[deprecated Int.neg_tmod_self (since := "2024-09-11")] abbrev neg_mod_self := @Int.neg_tmod_self
-@[deprecated Int.lt_tdiv_add_one_mul_self (since := "2024-09-11")] abbrev lt_div_add_one_mul_self := @Int.lt_tdiv_add_one_mul_self
-@[deprecated Int.tdiv_eq_iff_eq_mul_right (since := "2024-09-11")] protected abbrev div_eq_iff_eq_mul_right := @Int.tdiv_eq_iff_eq_mul_right
-@[deprecated Int.tdiv_eq_iff_eq_mul_left (since := "2024-09-11")] protected abbrev div_eq_iff_eq_mul_left := @Int.tdiv_eq_iff_eq_mul_left
-@[deprecated Int.eq_mul_of_tdiv_eq_left (since := "2024-09-11")] protected abbrev eq_mul_of_div_eq_left := @Int.eq_mul_of_tdiv_eq_left
-@[deprecated Int.tdiv_eq_of_eq_mul_left (since := "2024-09-11")] protected abbrev div_eq_of_eq_mul_left := @Int.tdiv_eq_of_eq_mul_left
-@[deprecated Int.eq_zero_of_tdiv_eq_zero (since := "2024-09-11")] protected abbrev eq_zero_of_div_eq_zero := @Int.eq_zero_of_tdiv_eq_zero
-@[deprecated Int.tdiv_left_inj (since := "2024-09-11")] protected abbrev div_left_inj := @Int.tdiv_left_inj
-@[deprecated Int.tdiv_sign (since := "2024-09-11")] abbrev div_sign := @Int.tdiv_sign
-@[deprecated Int.sign_eq_tdiv_abs (since := "2024-09-11")] protected abbrev sign_eq_div_abs := @Int.sign_eq_tdiv_abs
-@[deprecated Int.tdiv_eq_ediv_of_dvd (since := "2024-09-11")] abbrev div_eq_ediv_of_dvd := @Int.tdiv_eq_ediv_of_dvd

src/Init/Data/Int/Lemmas.lean

@@ -7,7 +7,6 @@ prelude
 import Init.Data.Int.Basic
 import Init.Conv
 import Init.NotationExtra
-import Init.PropLemmas
 
 namespace Int
 
@@ -289,7 +288,7 @@ protected theorem neg_sub (a b : Int) : -(a - b) = b - a := by
 protected theorem sub_sub_self (a b : Int) : a - (a - b) = b := by
   simp [Int.sub_eq_add_neg, ← Int.add_assoc]
 
-@[simp] protected theorem sub_neg (a b : Int) : a - -b = a + b := by simp [Int.sub_eq_add_neg]
+protected theorem sub_neg (a b : Int) : a - -b = a + b := by simp [Int.sub_eq_add_neg]
 
 @[simp] protected theorem sub_add_cancel (a b : Int) : a - b + b = a :=
   Int.neg_add_cancel_right a b
@@ -329,22 +328,22 @@ theorem toNat_sub (m n : Nat) : toNat (m - n) = m - n := by
 /- ## add/sub injectivity -/
 
 @[simp]
-protected theorem add_right_inj {i j : Int} (k : Int) : (i + k = j + k) ↔ i = j := by
+protected theorem add_right_inj (i j k : Int) : (i + k = j + k) ↔ i = j := by
   apply Iff.intro
   · intro p
     rw [←Int.add_sub_cancel i k, ←Int.add_sub_cancel j k, p]
   · exact congrArg (· + k)
 
 @[simp]
-protected theorem add_left_inj {i j : Int} (k : Int) : (k + i = k + j) ↔ i = j := by
+protected theorem add_left_inj (i j k : Int) : (k + i = k + j) ↔ i = j := by
   simp [Int.add_comm k]
 
 @[simp]
-protected theorem sub_left_inj {i j : Int} (k : Int) : (k - i = k - j) ↔ i = j := by
+protected theorem sub_left_inj (i j k : Int) : (k - i = k - j) ↔ i = j := by
   simp [Int.sub_eq_add_neg, Int.neg_inj]
 
 @[simp]
-protected theorem sub_right_inj {i j : Int} (k : Int) : (i - k = j - k) ↔ i = j := by
+protected theorem sub_right_inj (i j k : Int) : (i - k = j - k) ↔ i = j := by
   simp [Int.sub_eq_add_neg]
 
 /- ## Ring properties -/
@@ -445,10 +444,10 @@ protected theorem neg_mul_eq_neg_mul (a b : Int) : -(a * b) = -a * b :=
 protected theorem neg_mul_eq_mul_neg (a b : Int) : -(a * b) = a * -b :=
   Int.neg_eq_of_add_eq_zero <| by rw [← Int.mul_add, Int.add_right_neg, Int.mul_zero]
 
-@[simp] protected theorem neg_mul (a b : Int) : -a * b = -(a * b) :=
+@[local simp] protected theorem neg_mul (a b : Int) : -a * b = -(a * b) :=
   (Int.neg_mul_eq_neg_mul a b).symm
 
-@[simp] protected theorem mul_neg (a b : Int) : a * -b = -(a * b) :=
+@[local simp] protected theorem mul_neg (a b : Int) : a * -b = -(a * b) :=
   (Int.neg_mul_eq_mul_neg a b).symm
 
 protected theorem neg_mul_neg (a b : Int) : -a * -b = a * b := by simp
@@ -487,9 +486,6 @@ protected theorem mul_eq_zero {a b : Int} : a * b = 0 ↔ a = 0 ∨ b = 0 := by
 protected theorem mul_ne_zero {a b : Int} (a0 : a ≠ 0) (b0 : b ≠ 0) : a * b ≠ 0 :=
   Or.rec a0 b0 ∘ Int.mul_eq_zero.mp
 
-@[simp] protected theorem mul_ne_zero_iff {a b : Int} : a * b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0 := by
-  rw [ne_eq, Int.mul_eq_zero, not_or, ne_eq]
-
 protected theorem eq_of_mul_eq_mul_right {a b c : Int} (ha : a ≠ 0) (h : b * a = c * a) : b = c :=
   have : (b - c) * a = 0 := by rwa [Int.sub_mul, Int.sub_eq_zero]
   Int.sub_eq_zero.1 <| (Int.mul_eq_zero.mp this).resolve_right ha

src/Init/Data/Int/LemmasAux.lean

@@ -1,41 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.Int.Order
-import Init.Omega
-
-
-/-!
-# Further lemmas about `Int` relying on `omega` automation.
--/
-
-namespace Int
-
-@[simp] theorem toNat_sub' (a : Int) (b : Nat) : (a - b).toNat = a.toNat - b := by
-  symm
-  simp only [Int.toNat]
-  split <;> rename_i x a
-  · simp only [Int.ofNat_eq_coe]
-    split <;> rename_i y b h
-    · simp at h
-      omega
-    · simp [Int.negSucc_eq] at h
-      omega
-  · simp only [Nat.zero_sub]
-    split <;> rename_i y b h
-    · simp [Int.negSucc_eq] at h
-      omega
-    · rfl
-
-@[simp] theorem toNat_sub_max_self (a : Int) : (a - max a 0).toNat = 0 := by
-  simp [toNat]
-  split <;> simp_all <;> omega
-
-@[simp] theorem toNat_sub_self_max (a : Int) : (a - max 0 a).toNat = 0 := by
-  simp [toNat]
-  split <;> simp_all <;> omega
-
-end Int

src/Init/Data/Int/Order.lean

@@ -26,9 +26,9 @@ theorem nonneg_or_nonneg_neg : ∀ (a : Int), NonNeg a ∨ NonNeg (-a)
   | (_:Nat) => .inl ⟨_⟩
   | -[_+1]  => .inr ⟨_⟩
 
-theorem le_def {a b : Int} : a ≤ b ↔ NonNeg (b - a) := .rfl
+theorem le_def (a b : Int) : a ≤ b ↔ NonNeg (b - a) := .rfl
 
-theorem lt_iff_add_one_le {a b : Int} : a < b ↔ a + 1 ≤ b := .rfl
+theorem lt_iff_add_one_le (a b : Int) : a < b ↔ a + 1 ≤ b := .rfl
 
 theorem le.intro_sub {a b : Int} (n : Nat) (h : b - a = n) : a ≤ b := by
   simp [le_def, h]; constructor
@@ -240,24 +240,9 @@ theorem le_natAbs {a : Int} : a ≤ natAbs a :=
 theorem negSucc_lt_zero (n : Nat) : -[n+1] < 0 :=
   Int.not_le.1 fun h => let ⟨_, h⟩ := eq_ofNat_of_zero_le h; nomatch h
 
-theorem negSucc_le_zero (n : Nat) : -[n+1] ≤ 0 :=
-  Int.le_of_lt (negSucc_lt_zero n)
-
 @[simp] theorem negSucc_not_nonneg (n : Nat) : 0 ≤ -[n+1] ↔ False := by
   simp only [Int.not_le, iff_false]; exact Int.negSucc_lt_zero n
 
-@[simp] theorem ofNat_max_zero (n : Nat) : (max (n : Int) 0) = n := by
-  rw [Int.max_eq_left (ofNat_zero_le n)]
-
-@[simp] theorem zero_max_ofNat (n : Nat) : (max 0 (n : Int)) = n := by
-  rw [Int.max_eq_right (ofNat_zero_le n)]
-
-@[simp] theorem negSucc_max_zero (n : Nat) : (max (Int.negSucc n) 0) = 0 := by
-  rw [Int.max_eq_right (negSucc_le_zero _)]
-
-@[simp] theorem zero_max_negSucc (n : Nat) : (max 0 (Int.negSucc n)) = 0 := by
-  rw [Int.max_eq_left (negSucc_le_zero _)]
-
 protected theorem add_le_add_left {a b : Int} (h : a ≤ b) (c : Int) : c + a ≤ c + b :=
   let ⟨n, hn⟩ := le.dest h; le.intro n <| by rw [Int.add_assoc, hn]
 
@@ -480,21 +465,13 @@ theorem toNat_eq_max : ∀ a : Int, (toNat a : Int) = max a 0
 
 @[simp] theorem toNat_one : (1 : Int).toNat = 1 := rfl
 
-theorem toNat_of_nonneg {a : Int} (h : 0 ≤ a) : (toNat a : Int) = a := by
+@[simp] theorem toNat_of_nonneg {a : Int} (h : 0 ≤ a) : (toNat a : Int) = a := by
   rw [toNat_eq_max, Int.max_eq_left h]
 
 @[simp] theorem toNat_ofNat (n : Nat) : toNat ↑n = n := rfl
 
-@[simp] theorem toNat_negSucc (n : Nat) : (Int.negSucc n).toNat = 0 := by
-  simp [toNat]
-
 @[simp] theorem toNat_ofNat_add_one {n : Nat} : ((n : Int) + 1).toNat = n + 1 := rfl
 
-@[simp] theorem ofNat_toNat (a : Int) : (a.toNat : Int) = max a 0 := by
-  match a with
-  | Int.ofNat n => simp
-  | Int.negSucc n => simp
-
 theorem self_le_toNat (a : Int) : a ≤ toNat a := by rw [toNat_eq_max]; apply Int.le_max_left
 
 @[simp] theorem le_toNat {n : Nat} {z : Int} (h : 0 ≤ z) : n ≤ z.toNat ↔ (n : Int) ≤ z := by
@@ -515,7 +492,7 @@ theorem toNat_add_nat {a : Int} (ha : 0 ≤ a) (n : Nat) : (a + n).toNat = a.toN
   | (n+1:Nat) => by simp [ofNat_add]
   | -[n+1] => rfl
 
-theorem toNat_sub_toNat_neg : ∀ n : Int, ↑n.toNat - ↑(-n).toNat = n
+@[simp] theorem toNat_sub_toNat_neg : ∀ n : Int, ↑n.toNat - ↑(-n).toNat = n
   | 0 => rfl
   | (_+1:Nat) => Int.sub_zero _
   | -[_+1] => Int.zero_sub _
@@ -531,7 +508,7 @@ theorem toNat_sub_toNat_neg : ∀ n : Int, ↑n.toNat - ↑(-n).toNat = n
 
 /-! ### toNat' -/
 
-theorem mem_toNat' : ∀ {a : Int} {n : Nat}, toNat' a = some n ↔ a = n
+theorem mem_toNat' : ∀ (a : Int) (n : Nat), toNat' a = some n ↔ a = n
   | (m : Nat), n => by simp [toNat', Int.ofNat_inj]
   | -[m+1], n => by constructor <;> nofun
 
@@ -829,10 +806,10 @@ protected theorem lt_add_of_neg_lt_sub_right {a b c : Int} (h : -b < a - c) : c
 protected theorem neg_lt_sub_right_of_lt_add {a b c : Int} (h : c < a + b) : -b < a - c :=
   Int.lt_sub_left_of_add_lt (Int.sub_right_lt_of_lt_add h)
 
-protected theorem add_lt_iff {a b c : Int} : a + b < c ↔ a < -b + c := by
+protected theorem add_lt_iff (a b c : Int) : a + b < c ↔ a < -b + c := by
   rw [← Int.add_lt_add_iff_left (-b), Int.add_comm (-b), Int.add_neg_cancel_right]
 
-protected theorem sub_lt_iff {a b c : Int} : a - b < c ↔ a < c + b :=
+protected theorem sub_lt_iff (a b c : Int) : a - b < c ↔ a < c + b :=
   Iff.intro Int.lt_add_of_sub_right_lt Int.sub_right_lt_of_lt_add
 
 protected theorem sub_lt_of_sub_lt {a b c : Int} (h : a - b < c) : a - c < b :=
@@ -853,10 +830,12 @@ protected theorem lt_of_sub_lt_sub_left {a b c : Int} (h : c - a < c - b) : b <
 protected theorem lt_of_sub_lt_sub_right {a b c : Int} (h : a - c < b - c) : a < b :=
   Int.lt_of_add_lt_add_right h
 
-@[simp] protected theorem sub_lt_sub_left_iff {a b c : Int} : c - a < c - b ↔ b < a :=
+@[simp] protected theorem sub_lt_sub_left_iff (a b c : Int) :
+    c - a < c - b ↔ b < a :=
   ⟨Int.lt_of_sub_lt_sub_left, (Int.sub_lt_sub_left · c)⟩
 
-@[simp] protected theorem sub_lt_sub_right_iff {a b c : Int} : a - c < b - c ↔ a < b :=
+@[simp] protected theorem sub_lt_sub_right_iff (a b c : Int) :
+    a - c < b - c ↔ a < b :=
   ⟨Int.lt_of_sub_lt_sub_right, (Int.sub_lt_sub_right · c)⟩
 
 protected theorem sub_lt_sub_of_le_of_lt {a b c d : Int}
@@ -988,13 +967,13 @@ theorem neg_of_sign_eq_neg_one : ∀ {a : Int}, sign a = -1 → a < 0
   | 0, h => nomatch h
   | -[_+1], _ => negSucc_lt_zero _
 
-theorem sign_eq_one_iff_pos {a : Int} : sign a = 1 ↔ 0 < a :=
+theorem sign_eq_one_iff_pos (a : Int) : sign a = 1 ↔ 0 < a :=
   ⟨pos_of_sign_eq_one, sign_eq_one_of_pos⟩
 
-theorem sign_eq_neg_one_iff_neg {a : Int} : sign a = -1 ↔ a < 0 :=
+theorem sign_eq_neg_one_iff_neg (a : Int) : sign a = -1 ↔ a < 0 :=
   ⟨neg_of_sign_eq_neg_one, sign_eq_neg_one_of_neg⟩
 
-@[simp] theorem sign_eq_zero_iff_zero {a : Int} : sign a = 0 ↔ a = 0 :=
+@[simp] theorem sign_eq_zero_iff_zero (a : Int) : sign a = 0 ↔ a = 0 :=
   ⟨eq_zero_of_sign_eq_zero, fun h => by rw [h, sign_zero]⟩
 
 @[simp] theorem sign_sign : sign (sign x) = sign x := by
@@ -1027,7 +1006,7 @@ theorem natAbs_mul_self : ∀ {a : Int}, ↑(natAbs a * natAbs a) = a * a
 theorem eq_nat_or_neg (a : Int) : ∃ n : Nat, a = n ∨ a = -↑n := ⟨_, natAbs_eq a⟩
 
 theorem natAbs_mul_natAbs_eq {a b : Int} {c : Nat}
-    (h : a * b = (c : Int)) : a.natAbs * b.natAbs = c := by rw [← natAbs_mul, h, natAbs.eq_def]
+    (h : a * b = (c : Int)) : a.natAbs * b.natAbs = c := by rw [← natAbs_mul, h, natAbs]
 
 @[simp] theorem natAbs_mul_self' (a : Int) : (natAbs a * natAbs a : Int) = a * a := by
   rw [← Int.ofNat_mul, natAbs_mul_self]

src/Init/Data/List.lean

@@ -21,5 +21,3 @@ import Init.Data.List.Pairwise
 import Init.Data.List.Sublist
 import Init.Data.List.TakeDrop
 import Init.Data.List.Zip
-import Init.Data.List.Perm
-import Init.Data.List.Sort

src/Init/Data/List/Attach.lean

@@ -48,8 +48,6 @@ Unsafe implementation of `attachWith`, taking advantage of the fact that the rep
 
 @[simp] theorem attach_nil : ([] : List α).attach = [] := rfl
 
-@[simp] theorem attachWith_nil : ([] : List α).attachWith P H = [] := rfl
-
 @[simp]
 theorem pmap_eq_map (p : α → Prop) (f : α → β) (l : List α) (H) :
     @pmap _ _ p (fun a _ => f a) l H = map f l := by
@@ -57,14 +55,11 @@ theorem pmap_eq_map (p : α → Prop) (f : α → β) (l : List α) (H) :
   · rfl
   · simp only [*, pmap, map]
 
-theorem pmap_congr_left {p q : α → Prop} {f : ∀ a, p a → β} {g : ∀ a, q a → β} (l : List α) {H₁ H₂}
+theorem pmap_congr {p q : α → Prop} {f : ∀ a, p a → β} {g : ∀ a, q a → β} (l : List α) {H₁ H₂}
     (h : ∀ a ∈ l, ∀ (h₁ h₂), f a h₁ = g a h₂) : pmap f l H₁ = pmap g l H₂ := by
   induction l with
   | nil => rfl
-  | cons x l ih =>
-    rw [pmap, pmap, h _ (mem_cons_self _ _), ih fun a ha => h a (mem_cons_of_mem _ ha)]
-
-@[deprecated pmap_congr_left (since := "2024-09-06")] abbrev pmap_congr := @pmap_congr_left
+  | cons x l ih => rw [pmap, pmap, h _ (mem_cons_self _ _), ih fun a ha => h a (mem_cons_of_mem _ ha)]
 
 theorem map_pmap {p : α → Prop} (g : β → γ) (f : ∀ a, p a → β) (l H) :
     map g (pmap f l H) = pmap (fun a h => g (f a h)) l H := by
@@ -78,33 +73,9 @@ theorem pmap_map {p : β → Prop} (g : ∀ b, p b → γ) (f : α → β) (l H)
   · rfl
   · simp only [*, pmap, map]
 
-theorem attach_congr {l₁ l₂ : List α} (h : l₁ = l₂) :
-    l₁.attach = l₂.attach.map (fun x => ⟨x.1, h ▸ x.2⟩) := by
-  subst h
-  simp
-
-theorem attachWith_congr {l₁ l₂ : List α} (w : l₁ = l₂) {P : α → Prop} {H : ∀ x ∈ l₁, P x} :
-    l₁.attachWith P H = l₂.attachWith P fun x h => H _ (w ▸ h) := by
-  subst w
-  simp
-
-@[simp] theorem attach_cons {x : α} {xs : List α} :
-    (x :: xs).attach =
-      ⟨x, mem_cons_self x xs⟩ :: xs.attach.map fun ⟨y, h⟩ => ⟨y, mem_cons_of_mem x h⟩ := by
-  simp only [attach, attachWith, pmap, map_pmap, cons.injEq, true_and]
-  apply pmap_congr_left
-  intros a _ m' _
-  rfl
-
-@[simp]
-theorem attachWith_cons {x : α} {xs : List α} {p : α → Prop} (h : ∀ a ∈ x :: xs, p a) :
-    (x :: xs).attachWith p h = ⟨x, h x (mem_cons_self x xs)⟩ ::
-      xs.attachWith p (fun a ha ↦ h a (mem_cons_of_mem x ha)) :=
-  rfl
-
 theorem pmap_eq_map_attach {p : α → Prop} (f : ∀ a, p a → β) (l H) :
     pmap f l H = l.attach.map fun x => f x.1 (H _ x.2) := by
-  rw [attach, attachWith, map_pmap]; exact pmap_congr_left l fun _ _ _ _ => rfl
+  rw [attach, attachWith, map_pmap]; exact pmap_congr l fun _ _ _ _ => rfl
 
 theorem attach_map_coe (l : List α) (f : α → β) :
     (l.attach.map fun (i : {i // i ∈ l}) => f i) = l.map f := by
@@ -115,39 +86,15 @@ theorem attach_map_val (l : List α) (f : α → β) : (l.attach.map fun i => f
 
 @[simp]
 theorem attach_map_subtype_val (l : List α) : l.attach.map Subtype.val = l :=
-  (attach_map_coe _ _).trans (List.map_id _)
+  (attach_map_coe _ _).trans l.map_id
 
-theorem attachWith_map_coe {p : α → Prop} (f : α → β) (l : List α) (H : ∀ a ∈ l, p a) :
-    ((l.attachWith p H).map fun (i : { i // p i}) => f i) = l.map f := by
-  rw [attachWith, map_pmap]; exact pmap_eq_map _ _ _ _
-
-theorem attachWith_map_val {p : α → Prop} (f : α → β) (l : List α) (H : ∀ a ∈ l, p a) :
-    ((l.attachWith p H).map fun i => f i.val) = l.map f :=
-  attachWith_map_coe _ _ _
-
-@[simp]
-theorem attachWith_map_subtype_val {p : α → Prop} (l : List α) (H : ∀ a ∈ l, p a) :
-    (l.attachWith p H).map Subtype.val = l :=
-  (attachWith_map_coe _ _ _).trans (List.map_id _)
-
-theorem countP_attach (l : List α) (p : α → Bool) :
-    l.attach.countP (fun a : {x // x ∈ l} => p a) = l.countP p := by
+theorem countP_attach (l : List α) (p : α → Bool) : l.attach.countP (fun a : {x // x ∈ l} => p a) = l.countP p := by
   simp only [← Function.comp_apply (g := Subtype.val), ← countP_map, attach_map_subtype_val]
 
-theorem countP_attachWith {p : α → Prop} (l : List α) (H : ∀ a ∈ l, p a) (q : α → Bool) :
-    (l.attachWith p H).countP (fun a : {x // p x} => q a) = l.countP q := by
-  simp only [← Function.comp_apply (g := Subtype.val), ← countP_map, attachWith_map_subtype_val]
-
 @[simp]
-theorem count_attach [DecidableEq α] (l : List α) (a : {x // x ∈ l}) :
-    l.attach.count a = l.count ↑a :=
+theorem count_attach [DecidableEq α] (l : List α) (a : {x // x ∈ l}) : l.attach.count a = l.count ↑a :=
   Eq.trans (countP_congr fun _ _ => by simp [Subtype.ext_iff]) <| countP_attach _ _
 
-@[simp]
-theorem count_attachWith [DecidableEq α] {p : α → Prop} (l : List α) (H : ∀ a ∈ l, p a) (a : {x // p x}) :
-    (l.attachWith p H).count a = l.count ↑a :=
-  Eq.trans (countP_congr fun _ _ => by simp [Subtype.ext_iff]) <| countP_attachWith _ _ _
-
 @[simp]
 theorem mem_attach (l : List α) : ∀ x, x ∈ l.attach
   | ⟨a, h⟩ => by
@@ -160,11 +107,6 @@ theorem mem_pmap {p : α → Prop} {f : ∀ a, p a → β} {l H b} :
     b ∈ pmap f l H ↔ ∃ (a : _) (h : a ∈ l), f a (H a h) = b := by
   simp only [pmap_eq_map_attach, mem_map, mem_attach, true_and, Subtype.exists, eq_comm]
 
-theorem mem_pmap_of_mem {p : α → Prop} {f : ∀ a, p a → β} {l H} {a} (h : a ∈ l) :
-    f a (H a h) ∈ pmap f l H := by
-  rw [mem_pmap]
-  exact ⟨a, h, rfl⟩
-
 @[simp]
 theorem length_pmap {p : α → Prop} {f : ∀ a, p a → β} {l H} : length (pmap f l H) = length l := by
   induction l
@@ -172,43 +114,30 @@ theorem length_pmap {p : α → Prop} {f : ∀ a, p a → β} {l H} : length (pm
   · simp only [*, pmap, length]
 
 @[simp]
-theorem length_attach {L : List α} : L.attach.length = L.length :=
+theorem length_attach (L : List α) : L.attach.length = L.length :=
   length_pmap
 
 @[simp]
-theorem length_attachWith {p : α → Prop} {l H} : length (l.attachWith p H) = length l :=
-  length_pmap
-
-@[simp]
-theorem pmap_eq_nil_iff {p : α → Prop} {f : ∀ a, p a → β} {l H} : pmap f l H = [] ↔ l = [] := by
+theorem pmap_eq_nil {p : α → Prop} {f : ∀ a, p a → β} {l H} : pmap f l H = [] ↔ l = [] := by
   rw [← length_eq_zero, length_pmap, length_eq_zero]
 
-theorem pmap_ne_nil_iff {P : α → Prop} (f : (a : α) → P a → β) {xs : List α}
-    (H : ∀ (a : α), a ∈ xs → P a) : xs.pmap f H ≠ [] ↔ xs ≠ [] := by
-  simp
-
 @[simp]
-theorem attach_eq_nil_iff {l : List α} : l.attach = [] ↔ l = [] :=
-  pmap_eq_nil_iff
+theorem attach_eq_nil (l : List α) : l.attach = [] ↔ l = [] :=
+  pmap_eq_nil
 
-theorem attach_ne_nil_iff {l : List α} : l.attach ≠ [] ↔ l ≠ [] :=
-  pmap_ne_nil_iff _ _
+theorem getLast_pmap (p : α → Prop) (f : ∀ a, p a → β) (l : List α)
+    (hl₁ : ∀ a ∈ l, p a) (hl₂ : l ≠ []) :
+    (l.pmap f hl₁).getLast (mt List.pmap_eq_nil.1 hl₂) =
+      f (l.getLast hl₂) (hl₁ _ (List.getLast_mem hl₂)) := by
+  induction l with
+  | nil => apply (hl₂ rfl).elim
+  | cons l_hd l_tl l_ih =>
+    by_cases hl_tl : l_tl = []
+    · simp [hl_tl]
+    · simp only [pmap]
+      rw [getLast_cons, l_ih _ hl_tl]
+      simp only [getLast_cons hl_tl]
 
-@[simp]
-theorem attachWith_eq_nil_iff {l : List α} {P : α → Prop} {H : ∀ a ∈ l, P a} :
-    l.attachWith P H = [] ↔ l = [] :=
-  pmap_eq_nil_iff
-
-theorem attachWith_ne_nil_iff {l : List α} {P : α → Prop} {H : ∀ a ∈ l, P a} :
-    l.attachWith P H ≠ [] ↔ l ≠ [] :=
-  pmap_ne_nil_iff _ _
-
-@[deprecated pmap_eq_nil_iff (since := "2024-09-06")] abbrev pmap_eq_nil := @pmap_eq_nil_iff
-@[deprecated pmap_ne_nil_iff (since := "2024-09-06")] abbrev pmap_ne_nil := @pmap_ne_nil_iff
-@[deprecated attach_eq_nil_iff (since := "2024-09-06")] abbrev attach_eq_nil := @attach_eq_nil_iff
-@[deprecated attach_ne_nil_iff (since := "2024-09-06")] abbrev attach_ne_nil := @attach_ne_nil_iff
-
-@[simp]
 theorem getElem?_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h : ∀ a ∈ l, p a) (n : Nat) :
     (pmap f l h)[n]? = Option.pmap f l[n]? fun x H => h x (getElem?_mem H) := by
   induction l generalizing n with
@@ -230,12 +159,11 @@ theorem get?_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h :
   simp only [get?_eq_getElem?]
   simp [getElem?_pmap, h]
 
-@[simp]
 theorem getElem_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h : ∀ a ∈ l, p a) {n : Nat}
     (hn : n < (pmap f l h).length) :
     (pmap f l h)[n] =
       f (l[n]'(@length_pmap _ _ p f l h ▸ hn))
-        (h _ (getElem_mem (@length_pmap _ _ p f l h ▸ hn))) := by
+        (h _ (getElem_mem l n (@length_pmap _ _ p f l h ▸ hn))) := by
   induction l generalizing n with
   | nil =>
     simp only [length, pmap] at hn
@@ -253,145 +181,7 @@ theorem get_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h :
   simp only [get_eq_getElem]
   simp [getElem_pmap]
 
-@[simp]
-theorem getElem?_attachWith {xs : List α} {i : Nat} {P : α → Prop} {H : ∀ a ∈ xs, P a} :
-    (xs.attachWith P H)[i]? = xs[i]?.pmap Subtype.mk (fun _ a => H _ (getElem?_mem a)) :=
-  getElem?_pmap ..
-
-@[simp]
-theorem getElem?_attach {xs : List α} {i : Nat} :
-    xs.attach[i]? = xs[i]?.pmap Subtype.mk (fun _ a => getElem?_mem a) :=
-  getElem?_attachWith
-
-@[simp]
-theorem getElem_attachWith {xs : List α} {P : α → Prop} {H : ∀ a ∈ xs, P a}
-    {i : Nat} (h : i < (xs.attachWith P H).length) :
-    (xs.attachWith P H)[i] = ⟨xs[i]'(by simpa using h), H _ (getElem_mem (by simpa using h))⟩ :=
-  getElem_pmap ..
-
-@[simp]
-theorem getElem_attach {xs : List α} {i : Nat} (h : i < xs.attach.length) :
-    xs.attach[i] = ⟨xs[i]'(by simpa using h), getElem_mem (by simpa using h)⟩ :=
-  getElem_attachWith h
-
-@[simp] theorem head?_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
-    (H : ∀ (a : α), a ∈ xs → P a) :
-    (xs.pmap f H).head? = xs.attach.head?.map fun ⟨a, m⟩ => f a (H a m) := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp at ih
-    simp [head?_pmap, ih]
-
-@[simp] theorem head_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
-    (H : ∀ (a : α), a ∈ xs → P a) (h : xs.pmap f H ≠ []) :
-    (xs.pmap f H).head h = f (xs.head (by simpa using h)) (H _ (head_mem _)) := by
-  induction xs with
-  | nil => simp at h
-  | cons x xs ih => simp [head_pmap, ih]
-
-@[simp] theorem head?_attachWith {P : α → Prop} {xs : List α}
-    (H : ∀ (a : α), a ∈ xs → P a) :
-    (xs.attachWith P H).head? = xs.head?.pbind (fun a h => some ⟨a, H _ (mem_of_mem_head? h)⟩) := by
-  cases xs <;> simp_all
-
-@[simp] theorem head_attachWith {P : α → Prop} {xs : List α}
-    {H : ∀ (a : α), a ∈ xs → P a} (h : xs.attachWith P H ≠ []) :
-    (xs.attachWith P H).head h = ⟨xs.head (by simpa using h), H _ (head_mem _)⟩ := by
-  cases xs with
-  | nil => simp at h
-  | cons x xs => simp [head_attachWith, h]
-
-@[simp] theorem head?_attach (xs : List α) :
-    xs.attach.head? = xs.head?.pbind (fun a h => some ⟨a, mem_of_mem_head? h⟩) := by
-  cases xs <;> simp_all
-
-@[simp] theorem head_attach {xs : List α} (h) :
-    xs.attach.head h = ⟨xs.head (by simpa using h), head_mem (by simpa using h)⟩ := by
-  cases xs with
-  | nil => simp at h
-  | cons x xs => simp [head_attach, h]
-
-theorem attach_map {l : List α} (f : α → β) :
-    (l.map f).attach = l.attach.map (fun ⟨x, h⟩ => ⟨f x, mem_map_of_mem f h⟩) := by
-  induction l <;> simp [*]
-
-theorem attachWith_map {l : List α} (f : α → β) {P : β → Prop} {H : ∀ (b : β), b ∈ l.map f → P b} :
-    (l.map f).attachWith P H = (l.attachWith (P ∘ f) (fun a h => H _ (mem_map_of_mem f h))).map
-      fun ⟨x, h⟩ => ⟨f x, h⟩ := by
-  induction l <;> simp [*]
-
-theorem map_attachWith {l : List α} {P : α → Prop} {H : ∀ (a : α), a ∈ l → P a}
-    (f : { x // P x } → β) :
-    (l.attachWith P H).map f =
-      l.pmap (fun a (h : a ∈ l ∧ P a) => f ⟨a, H _ h.1⟩) (fun a h => ⟨h, H a h⟩) := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [attachWith_cons, map_cons, ih, pmap, cons.injEq, true_and]
-    apply pmap_congr_left
-    simp
-
-/-- See also `pmap_eq_map_attach` for writing `pmap` in terms of `map` and `attach`. -/
-theorem map_attach {l : List α} (f : { x // x ∈ l } → β) :
-    l.attach.map f = l.pmap (fun a h => f ⟨a, h⟩) (fun _ => id) := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [attach_cons, map_cons, map_map, Function.comp_apply, pmap, cons.injEq, true_and, ih]
-    apply pmap_congr_left
-    simp
-
-theorem attach_filterMap {l : List α} {f : α → Option β} :
-    (l.filterMap f).attach = l.attach.filterMap
-      fun ⟨x, h⟩ => (f x).pbind (fun b m => some ⟨b, mem_filterMap.mpr ⟨x, h, m⟩⟩) := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [filterMap_cons, attach_cons, ih, filterMap_map]
-    split <;> rename_i h
-    · simp only [Option.pbind_eq_none_iff, reduceCtorEq, Option.mem_def, exists_false,
-        or_false] at h
-      rw [attach_congr]
-      rotate_left
-      · simp only [h]
-        rfl
-      rw [ih]
-      simp only [map_filterMap, Option.map_pbind, Option.map_some']
-      rfl
-    · simp only [Option.pbind_eq_some_iff] at h
-      obtain ⟨a, h, w⟩ := h
-      simp only [Option.some.injEq] at w
-      subst w
-      simp only [Option.mem_def] at h
-      rw [attach_congr]
-      rotate_left
-      · simp only [h]
-        rfl
-      rw [attach_cons, map_cons, map_map, ih, map_filterMap]
-      congr
-      ext
-      simp
-
-theorem attach_filter {l : List α} (p : α → Bool) :
-    (l.filter p).attach = l.attach.filterMap
-      fun x => if w : p x.1 then some ⟨x.1, mem_filter.mpr ⟨x.2, w⟩⟩ else none := by
-  rw [attach_congr (congrFun (filterMap_eq_filter _).symm _), attach_filterMap, map_filterMap]
-  simp only [Option.guard]
-  congr
-  ext1
-  split <;> simp
-
--- We are still missing here `attachWith_filterMap` and `attachWith_filter`.
--- Also missing are `filterMap_attach`, `filter_attach`, `filterMap_attachWith` and `filter_attachWith`.
-
-theorem pmap_pmap {p : α → Prop} {q : β → Prop} (g : ∀ a, p a → β) (f : ∀ b, q b → γ) (l H₁ H₂) :
-    pmap f (pmap g l H₁) H₂ =
-      pmap (α := { x // x ∈ l }) (fun a h => f (g a h) (H₂ (g a h) (mem_pmap_of_mem a.2))) l.attach
-        (fun a _ => H₁ a a.2) := by
-  simp [pmap_eq_map_attach, attach_map]
-
-@[simp] theorem pmap_append {p : ι → Prop} (f : ∀ a : ι, p a → α) (l₁ l₂ : List ι)
+theorem pmap_append {p : ι → Prop} (f : ∀ a : ι, p a → α) (l₁ l₂ : List ι)
     (h : ∀ a ∈ l₁ ++ l₂, p a) :
     (l₁ ++ l₂).pmap f h =
       (l₁.pmap f fun a ha => h a (mem_append_left l₂ ha)) ++
@@ -407,89 +197,3 @@ theorem pmap_append' {p : α → Prop} (f : ∀ a : α, p a → β) (l₁ l₂ :
     ((l₁ ++ l₂).pmap f fun a ha => (List.mem_append.1 ha).elim (h₁ a) (h₂ a)) =
       l₁.pmap f h₁ ++ l₂.pmap f h₂ :=
   pmap_append f l₁ l₂ _
-
-@[simp] theorem attach_append (xs ys : List α) :
-    (xs ++ ys).attach = xs.attach.map (fun ⟨x, h⟩ => ⟨x, mem_append_of_mem_left ys h⟩) ++
-      ys.attach.map fun ⟨x, h⟩ => ⟨x, mem_append_of_mem_right xs h⟩ := by
-  simp only [attach, attachWith, pmap, map_pmap, pmap_append]
-  congr 1 <;>
-  exact pmap_congr_left _ fun _ _ _ _ => rfl
-
-@[simp] theorem attachWith_append {P : α → Prop} {xs ys : List α}
-    {H : ∀ (a : α), a ∈ xs ++ ys → P a} :
-    (xs ++ ys).attachWith P H = xs.attachWith P (fun a h => H a (mem_append_of_mem_left ys h)) ++
-      ys.attachWith P (fun a h => H a (mem_append_of_mem_right xs h)) := by
-  simp only [attachWith, attach_append, map_pmap, pmap_append]
-
-@[simp] theorem pmap_reverse {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
-    (H : ∀ (a : α), a ∈ xs.reverse → P a) :
-    xs.reverse.pmap f H = (xs.pmap f (fun a h => H a (by simpa using h))).reverse := by
-  induction xs <;> simp_all
-
-theorem reverse_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
-    (H : ∀ (a : α), a ∈ xs → P a) :
-    (xs.pmap f H).reverse = xs.reverse.pmap f (fun a h => H a (by simpa using h)) := by
-  rw [pmap_reverse]
-
-@[simp] theorem attachWith_reverse {P : α → Prop} {xs : List α}
-    {H : ∀ (a : α), a ∈ xs.reverse → P a} :
-    xs.reverse.attachWith P H =
-      (xs.attachWith P (fun a h => H a (by simpa using h))).reverse :=
-  pmap_reverse ..
-
-theorem reverse_attachWith {P : α → Prop} {xs : List α}
-    {H : ∀ (a : α), a ∈ xs → P a} :
-    (xs.attachWith P H).reverse = (xs.reverse.attachWith P (fun a h => H a (by simpa using h))) :=
-  reverse_pmap ..
-
-@[simp] theorem attach_reverse (xs : List α) :
-    xs.reverse.attach = xs.attach.reverse.map fun ⟨x, h⟩ => ⟨x, by simpa using h⟩ := by
-  simp only [attach, attachWith, reverse_pmap, map_pmap]
-  apply pmap_congr_left
-  intros
-  rfl
-
-theorem reverse_attach (xs : List α) :
-    xs.attach.reverse = xs.reverse.attach.map fun ⟨x, h⟩ => ⟨x, by simpa using h⟩ := by
-  simp only [attach, attachWith, reverse_pmap, map_pmap]
-  apply pmap_congr_left
-  intros
-  rfl
-
-@[simp] theorem getLast?_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
-    (H : ∀ (a : α), a ∈ xs → P a) :
-    (xs.pmap f H).getLast? = xs.attach.getLast?.map fun ⟨a, m⟩ => f a (H a m) := by
-  simp only [getLast?_eq_head?_reverse]
-  rw [reverse_pmap, reverse_attach, head?_map, pmap_eq_map_attach, head?_map]
-  simp only [Option.map_map]
-  congr
-
-@[simp] theorem getLast_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
-    (H : ∀ (a : α), a ∈ xs → P a) (h : xs.pmap f H ≠ []) :
-    (xs.pmap f H).getLast h = f (xs.getLast (by simpa using h)) (H _ (getLast_mem _)) := by
-  simp only [getLast_eq_head_reverse]
-  simp only [reverse_pmap, head_pmap, head_reverse]
-
-@[simp] theorem getLast?_attachWith {P : α → Prop} {xs : List α}
-    {H : ∀ (a : α), a ∈ xs → P a} :
-    (xs.attachWith P H).getLast? = xs.getLast?.pbind (fun a h => some ⟨a, H _ (mem_of_getLast?_eq_some h)⟩) := by
-  rw [getLast?_eq_head?_reverse, reverse_attachWith, head?_attachWith]
-  simp
-
-@[simp] theorem getLast_attachWith {P : α → Prop} {xs : List α}
-    {H : ∀ (a : α), a ∈ xs → P a} (h : xs.attachWith P H ≠ []) :
-    (xs.attachWith P H).getLast h = ⟨xs.getLast (by simpa using h), H _ (getLast_mem _)⟩ := by
-  simp only [getLast_eq_head_reverse, reverse_attachWith, head_attachWith, head_map]
-
-@[simp]
-theorem getLast?_attach {xs : List α} :
-    xs.attach.getLast? = xs.getLast?.pbind fun a h => some ⟨a, mem_of_getLast?_eq_some h⟩ := by
-  rw [getLast?_eq_head?_reverse, reverse_attach, head?_map, head?_attach]
-  simp
-
-@[simp]
-theorem getLast_attach {xs : List α} (h : xs.attach ≠ []) :
-    xs.attach.getLast h = ⟨xs.getLast (by simpa using h), getLast_mem (by simpa using h)⟩ := by
-  simp only [getLast_eq_head_reverse, reverse_attach, head_map, head_attach]
-
-end List

src/Init/Data/List/Basic.lean

@@ -96,7 +96,7 @@ namespace List
 
 /-! ### concat -/
 
-theorem length_concat (as : List α) (a : α) : (concat as a).length = as.length + 1 := by
+@[simp high] theorem length_concat (as : List α) (a : α) : (concat as a).length = as.length + 1 := by
   induction as with
   | nil => rfl
   | cons _ xs ih => simp [concat, ih]
@@ -278,9 +278,8 @@ def getLastD : (as : List α) → (fallback : α) → α
   | [],   a₀ => a₀
   | a::as, _ => getLast (a::as) (fun h => List.noConfusion h)
 
--- These aren't `simp` lemmas since we always simplify `getLastD` in terms of `getLast?`.
-theorem getLastD_nil (a) : @getLastD α [] a = a := rfl
-theorem getLastD_cons (a b l) : @getLastD α (b::l) a = getLastD l b := by cases l <;> rfl
+@[simp] theorem getLastD_nil (a) : @getLastD α [] a = a := rfl
+@[simp] theorem getLastD_cons (a b l) : @getLastD α (b::l) a = getLastD l b := by cases l <;> rfl
 
 /-! ## Head and tail -/
 
@@ -689,7 +688,7 @@ inductive Mem (a : α) : List α → Prop
   | tail (b : α) {as : List α} : Mem a as → Mem a (b::as)
 
 instance : Membership α (List α) where
-  mem l a := Mem a l
+  mem := Mem
 
 theorem mem_of_elem_eq_true [BEq α] [LawfulBEq α] {a : α} {as : List α} : elem a as = true → a ∈ as := by
   match as with
@@ -963,26 +962,6 @@ def IsInfix (l₁ : List α) (l₂ : List α) : Prop := Exists fun s => Exists f
 
 @[inherit_doc] infixl:50 " <:+: " => IsInfix
 
-/-! ### splitAt -/
-
-/--
-Split a list at an index.
-```
-splitAt 2 [a, b, c] = ([a, b], [c])
-```
--/
-def splitAt (n : Nat) (l : List α) : List α × List α := go l n [] where
-  /--
-  Auxiliary for `splitAt`:
-  `splitAt.go l xs n acc = (acc.reverse ++ take n xs, drop n xs)` if `n < xs.length`,
-  and `(l, [])` otherwise.
-  -/
-  go : List α → Nat → List α → List α × List α
-  | [], _, _ => (l, []) -- This branch ensures the pointer equality of the result with the input
-                        -- without any runtime branching cost.
-  | x :: xs, n+1, acc => go xs n (x :: acc)
-  | xs, _, acc => (acc.reverse, xs)
-
 /-! ### rotateLeft -/
 
 /--
@@ -1244,36 +1223,6 @@ theorem lookup_cons [BEq α] {k : α} :
     ((k,b)::es).lookup a = match a == k with | true => some b | false => es.lookup a :=
   rfl
 
-/-! ## Permutations -/
-
-/-! ### Perm -/
-
-/--
-`Perm l₁ l₂` or `l₁ ~ l₂` asserts that `l₁` and `l₂` are permutations
-of each other. This is defined by induction using pairwise swaps.
--/
-inductive Perm : List α → List α → Prop
-  /-- `[] ~ []` -/
-  | nil : Perm [] []
-  /-- `l₁ ~ l₂ → x::l₁ ~ x::l₂` -/
-  | cons (x : α) {l₁ l₂ : List α} : Perm l₁ l₂ → Perm (x :: l₁) (x :: l₂)
-  /-- `x::y::l ~ y::x::l` -/
-  | swap (x y : α) (l : List α) : Perm (y :: x :: l) (x :: y :: l)
-  /-- `Perm` is transitive. -/
-  | trans {l₁ l₂ l₃ : List α} : Perm l₁ l₂ → Perm l₂ l₃ → Perm l₁ l₃
-
-@[inherit_doc] scoped infixl:50 " ~ " => Perm
-
-/-! ### isPerm -/
-
-/--
-`O(|l₁| * |l₂|)`. Computes whether `l₁` is a permutation of `l₂`. See `isPerm_iff` for a
-characterization in terms of `List.Perm`.
--/
-def isPerm [BEq α] : List α → List α → Bool
-  | [], l₂ => l₂.isEmpty
-  | a :: l₁, l₂ => l₂.contains a && l₁.isPerm (l₂.erase a)
-
 /-! ## Logical operations -/
 
 /-! ### any -/
@@ -1588,14 +1537,6 @@ such that adjacent elements are related by `R`.
   | []    => []
   | a::as => loop as a [] []
 where
-  /--
-  The arguments of `groupBy.loop l ag g gs` represent the following:
-
-  - `l : List α` are the elements which we still need to group.
-  - `ag : α` is the previous element for which a comparison was performed.
-  - `g : List α` is the group currently being assembled, in **reverse order**.
-  - `gs : List (List α)` is all of the groups that have been completed, in **reverse order**.
-  -/
   @[specialize] loop : List α → α → List α → List (List α) → List (List α)
   | a::as, ag, g, gs => match R ag a with
     | true  => loop as a (ag::g) gs
@@ -1611,178 +1552,4 @@ by filtering out all elements of `xs` which are also in `ys`.
 def removeAll [BEq α] (xs ys : List α) : List α :=
   xs.filter (fun x => !ys.elem x)
 
-/-!
-# Runtime re-implementations using `@[csimp]`
-
-More of these re-implementations are provided in `Init/Data/List/Impl.lean`.
-They can not be here, because the remaining ones required `Array` for their implementation.
-
-This leaves a dangerous situation: if you import this file, but not `Init/Data/List/Impl.lean`,
-then at runtime you will get non tail-recursive versions.
--/
-
-/-! ### length -/
-
-theorem length_add_eq_lengthTRAux (as : List α) (n : Nat) : as.length + n = as.lengthTRAux n := by
-  induction as generalizing n with
-  | nil  => simp [length, lengthTRAux]
-  | cons a as ih =>
-    simp [length, lengthTRAux, ← ih, Nat.succ_add]
-    rfl
-
-@[csimp] theorem length_eq_lengthTR : @List.length = @List.lengthTR := by
-  apply funext; intro α; apply funext; intro as
-  simp [lengthTR, ← length_add_eq_lengthTRAux]
-
-/-! ### map -/
-
-/-- Tail-recursive version of `List.map`. -/
-@[inline] def mapTR (f : α → β) (as : List α) : List β :=
-  loop as []
-where
-  @[specialize] loop : List α → List β → List β
-  | [],    bs => bs.reverse
-  | a::as, bs => loop as (f a :: bs)
-
-theorem mapTR_loop_eq (f : α → β) (as : List α) (bs : List β) :
-    mapTR.loop f as bs = bs.reverse ++ map f as := by
-  induction as generalizing bs with
-  | nil => simp [mapTR.loop, map]
-  | cons a as ih =>
-    simp only [mapTR.loop, map]
-    rw [ih (f a :: bs), reverse_cons, append_assoc]
-    rfl
-
-@[csimp] theorem map_eq_mapTR : @map = @mapTR :=
-  funext fun α => funext fun β => funext fun f => funext fun as => by
-    simp [mapTR, mapTR_loop_eq]
-
-/-! ### filter -/
-
-/-- Tail-recursive version of `List.filter`. -/
-@[inline] def filterTR (p : α → Bool) (as : List α) : List α :=
-  loop as []
-where
-  @[specialize] loop : List α → List α → List α
-  | [],    rs => rs.reverse
-  | a::as, rs => match p a with
-     | true  => loop as (a::rs)
-     | false => loop as rs
-
-theorem filterTR_loop_eq (p : α → Bool) (as bs : List α) :
-    filterTR.loop p as bs = bs.reverse ++ filter p as := by
-  induction as generalizing bs with
-  | nil => simp [filterTR.loop, filter]
-  | cons a as ih =>
-    simp only [filterTR.loop, filter]
-    split <;> simp_all
-
-@[csimp] theorem filter_eq_filterTR : @filter = @filterTR := by
-  apply funext; intro α; apply funext; intro p; apply funext; intro as
-  simp [filterTR, filterTR_loop_eq]
-
-/-! ### replicate -/
-
-/-- Tail-recursive version of `List.replicate`. -/
-def replicateTR {α : Type u} (n : Nat) (a : α) : List α :=
-  let rec loop : Nat → List α → List α
-    | 0, as => as
-    | n+1, as => loop n (a::as)
-  loop n []
-
-theorem replicateTR_loop_replicate_eq (a : α) (m n : Nat) :
-  replicateTR.loop a n (replicate m a) = replicate (n + m) a := by
-  induction n generalizing m with simp [replicateTR.loop]
-  | succ n ih => simp [Nat.succ_add]; exact ih (m+1)
-
-theorem replicateTR_loop_eq : ∀ n, replicateTR.loop a n acc = replicate n a ++ acc
-  | 0 => rfl
-  | n+1 => by rw [← replicateTR_loop_replicate_eq _ 1 n, replicate, replicate,
-    replicateTR.loop, replicateTR_loop_eq n, replicateTR_loop_eq n, append_assoc]; rfl
-
-@[csimp] theorem replicate_eq_replicateTR : @List.replicate = @List.replicateTR := by
-  apply funext; intro α; apply funext; intro n; apply funext; intro a
-  exact (replicateTR_loop_replicate_eq _ 0 n).symm
-
-/-! ## Additional functions -/
-
-/-! ### leftpad -/
-
-/-- Optimized version of `leftpad`. -/
-@[inline] def leftpadTR (n : Nat) (a : α) (l : List α) : List α :=
-  replicateTR.loop a (n - length l) l
-
-@[csimp] theorem leftpad_eq_leftpadTR : @leftpad = @leftpadTR := by
-  repeat (apply funext; intro)
-  simp [leftpad, leftpadTR, replicateTR_loop_eq]
-
-
-/-! ## Zippers -/
-
-/-! ### unzip -/
-
-/-- Tail recursive version of `List.unzip`. -/
-def unzipTR (l : List (α × β)) : List α × List β :=
-  l.foldr (fun (a, b) (al, bl) => (a::al, b::bl)) ([], [])
-
-@[csimp] theorem unzip_eq_unzipTR : @unzip = @unzipTR := by
-  apply funext; intro α; apply funext; intro β; apply funext; intro l
-  simp [unzipTR]; induction l <;> simp [*]
-
-/-! ## Ranges and enumeration -/
-
-/-! ### range' -/
-
-/-- Optimized version of `range'`. -/
-@[inline] def range'TR (s n : Nat) (step : Nat := 1) : List Nat := go n (s + step * n) [] where
-  /-- Auxiliary for `range'TR`: `range'TR.go n e = [e-n, ..., e-1] ++ acc`. -/
-  go : Nat → Nat → List Nat → List Nat
-  | 0, _, acc => acc
-  | n+1, e, acc => go n (e-step) ((e-step) :: acc)
-
-@[csimp] theorem range'_eq_range'TR : @range' = @range'TR := by
-  apply funext; intro s; apply funext; intro n; apply funext; intro step
-  let rec go (s) : ∀ n m,
-    range'TR.go step n (s + step * n) (range' (s + step * n) m step) = range' s (n + m) step
-  | 0, m => by simp [range'TR.go]
-  | n+1, m => by
-    simp [range'TR.go]
-    rw [Nat.mul_succ, ← Nat.add_assoc, Nat.add_sub_cancel, Nat.add_right_comm n]
-    exact go s n (m + 1)
-  exact (go s n 0).symm
-
-/-! ### iota -/
-
-/-- Tail-recursive version of `List.iota`. -/
-def iotaTR (n : Nat) : List Nat :=
-  let rec go : Nat → List Nat → List Nat
-    | 0, r => r.reverse
-    | m@(n+1), r => go n (m::r)
-  go n []
-
-@[csimp]
-theorem iota_eq_iotaTR : @iota = @iotaTR :=
-  have aux (n : Nat) (r : List Nat) : iotaTR.go n r = r.reverse ++ iota n := by
-    induction n generalizing r with
-    | zero => simp [iota, iotaTR.go]
-    | succ n ih => simp [iota, iotaTR.go, ih, append_assoc]
-  funext fun n => by simp [iotaTR, aux]
-
-/-! ## Other list operations -/
-
-/-! ### intersperse -/
-
-/-- Tail recursive version of `List.intersperse`. -/
-def intersperseTR (sep : α) : List α → List α
-  | [] => []
-  | [x] => [x]
-  | x::y::xs => x :: sep :: y :: xs.foldr (fun a r => sep :: a :: r) []
-
-@[csimp] theorem intersperse_eq_intersperseTR : @intersperse = @intersperseTR := by
-  apply funext; intro α; apply funext; intro sep; apply funext; intro l
-  simp [intersperseTR]
-  match l with
-  | [] | [_] => rfl
-  | x::y::xs => simp [intersperse]; induction xs generalizing y <;> simp [*]
-
 end List

src/Init/Data/List/BasicAux.lean

@@ -155,7 +155,7 @@ def mapMono (as : List α) (f : α → α) : List α :=
 
 /-! ## Additional lemmas required for bootstrapping `Array`. -/
 
-theorem getElem_append_left {as bs : List α} (h : i < as.length) {h'} : (as ++ bs)[i] = as[i] := by
+theorem getElem_append_left (as bs : List α) (h : i < as.length) {h'} : (as ++ bs)[i] = as[i] := by
   induction as generalizing i with
   | nil => trivial
   | cons a as ih =>
@@ -163,14 +163,12 @@ theorem getElem_append_left {as bs : List α} (h : i < as.length) {h'} : (as ++
     | zero => rfl
     | succ i => apply ih
 
-theorem getElem_append_right {as bs : List α} {i : Nat} (h₁ : as.length ≤ i) {h₂} :
-    (as ++ bs)[i]'h₂ =
-      bs[i - as.length]'(by rw [length_append] at h₂; exact Nat.sub_lt_left_of_lt_add h₁ h₂) := by
+theorem getElem_append_right (as bs : List α) (h : ¬ i < as.length) {h' h''} : (as ++ bs)[i]'h' = bs[i - as.length]'h'' := by
   induction as generalizing i with
   | nil => trivial
   | cons a as ih =>
-    cases i with simp [get, Nat.succ_sub_succ] <;> simp [Nat.succ_sub_succ] at h₁
-    | succ i => apply ih; simp [h₁]
+    cases i with simp [get, Nat.succ_sub_succ] <;> simp_arith [Nat.succ_sub_succ] at h
+    | succ i => apply ih; simp_arith [h]
 
 theorem get_last {as : List α} {i : Fin (length (as ++ [a]))} (h : ¬ i.1 < as.length) : (as ++ [a] : List _).get i = a := by
   cases i; rename_i i h'
@@ -179,8 +177,8 @@ theorem get_last {as : List α} {i : Fin (length (as ++ [a]))} (h : ¬ i.1 < as.
     | zero => simp [List.get]
     | succ => simp_arith at h'
   | cons a as ih =>
-    cases i with simp at h
-    | succ i => apply ih; simp [h]
+    cases i with simp_arith at h
+    | succ i => apply ih; simp_arith [h]
 
 theorem sizeOf_lt_of_mem [SizeOf α] {as : List α} (h : a ∈ as) : sizeOf a < sizeOf as := by
   induction h with
@@ -194,7 +192,7 @@ macro "sizeOf_list_dec" : tactic =>
   `(tactic| first
     | with_reducible apply sizeOf_lt_of_mem; assumption; done
     | with_reducible
-        apply Nat.lt_of_lt_of_le (sizeOf_lt_of_mem ?h)
+        apply Nat.lt_trans (sizeOf_lt_of_mem ?h)
         case' h => assumption
       simp_arith)
 
@@ -224,7 +222,7 @@ theorem append_cancel_right {as bs cs : List α} (h : as ++ bs = cs ++ bs) : as
   next => apply append_cancel_right
   next => intro h; simp [h]
 
-theorem sizeOf_get [SizeOf α] (as : List α) (i : Fin as.length) : sizeOf (as.get i) < sizeOf as := by
+@[simp] theorem sizeOf_get [SizeOf α] (as : List α) (i : Fin as.length) : sizeOf (as.get i) < sizeOf as := by
   match as, i with
   | a::as, ⟨0, _⟩  => simp_arith [get]
   | a::as, ⟨i+1, h⟩ =>

src/Init/Data/List/Count.lean

@@ -40,9 +40,6 @@ protected theorem countP_go_eq_add (l) : countP.go p l n = n + countP.go p l 0 :
 theorem countP_cons (a : α) (l) : countP p (a :: l) = countP p l + if p a then 1 else 0 := by
   by_cases h : p a <;> simp [h]
 
-theorem countP_singleton (a : α) : countP p [a] = if p a then 1 else 0 := by
-  simp [countP_cons]
-
 theorem length_eq_countP_add_countP (l) : length l = countP p l + countP (fun a => ¬p a) l := by
   induction l with
   | nil => rfl
@@ -50,11 +47,11 @@ theorem length_eq_countP_add_countP (l) : length l = countP p l + countP (fun a
     if h : p x then
       rw [countP_cons_of_pos _ _ h, countP_cons_of_neg _ _ _, length, ih]
       · rw [Nat.add_assoc, Nat.add_comm _ 1, Nat.add_assoc]
-      · simp [h]
+      · simp only [h, not_true_eq_false, decide_False, not_false_eq_true]
     else
       rw [countP_cons_of_pos (fun a => ¬p a) _ _, countP_cons_of_neg _ _ h, length, ih]
       · rfl
-      · simp [h]
+      · simp only [h, not_false_eq_true, decide_True]
 
 theorem countP_eq_length_filter (l) : countP p l = length (filter p l) := by
   induction l with
@@ -64,10 +61,6 @@ theorem countP_eq_length_filter (l) : countP p l = length (filter p l) := by
     then rw [countP_cons_of_pos p l h, ih, filter_cons_of_pos h, length]
     else rw [countP_cons_of_neg p l h, ih, filter_cons_of_neg h]
 
-theorem countP_eq_length_filter' : countP p = length ∘ filter p := by
-  funext l
-  apply countP_eq_length_filter
-
 theorem countP_le_length : countP p l ≤ l.length := by
   simp only [countP_eq_length_filter]
   apply length_filter_le
@@ -75,56 +68,29 @@ theorem countP_le_length : countP p l ≤ l.length := by
 @[simp] theorem countP_append (l₁ l₂) : countP p (l₁ ++ l₂) = countP p l₁ + countP p l₂ := by
   simp only [countP_eq_length_filter, filter_append, length_append]
 
-@[simp] theorem countP_pos_iff {p} : 0 < countP p l ↔ ∃ a ∈ l, p a := by
+theorem countP_pos : 0 < countP p l ↔ ∃ a ∈ l, p a := by
   simp only [countP_eq_length_filter, length_pos_iff_exists_mem, mem_filter, exists_prop]
 
-@[deprecated countP_pos_iff (since := "2024-09-09")] abbrev countP_pos := @countP_pos_iff
+theorem countP_eq_zero : countP p l = 0 ↔ ∀ a ∈ l, ¬p a := by
+  simp only [countP_eq_length_filter, length_eq_zero, filter_eq_nil]
 
-@[simp] theorem one_le_countP_iff {p} : 1 ≤ countP p l ↔ ∃ a ∈ l, p a :=
-  countP_pos_iff
-
-@[simp] theorem countP_eq_zero {p} : countP p l = 0 ↔ ∀ a ∈ l, ¬p a := by
-  simp only [countP_eq_length_filter, length_eq_zero, filter_eq_nil_iff]
-
-@[simp] theorem countP_eq_length {p} : countP p l = l.length ↔ ∀ a ∈ l, p a := by
+theorem countP_eq_length : countP p l = l.length ↔ ∀ a ∈ l, p a := by
   rw [countP_eq_length_filter, filter_length_eq_length]
 
-theorem countP_replicate (p : α → Bool) (a : α) (n : Nat) :
-    countP p (replicate n a) = if p a then n else 0 := by
-  simp only [countP_eq_length_filter, filter_replicate]
-  split <;> simp
-
-theorem boole_getElem_le_countP (p : α → Bool) (l : List α) (i : Nat) (h : i < l.length) :
-    (if p l[i] then 1 else 0) ≤ l.countP p := by
-  induction l generalizing i with
-  | nil => simp at h
-  | cons x l ih =>
-    cases i with
-    | zero => simp [countP_cons]
-    | succ i =>
-      simp only [length_cons, add_one_lt_add_one_iff] at h
-      simp only [getElem_cons_succ, countP_cons]
-      specialize ih _ h
-      exact le_add_right_of_le ih
-
 theorem Sublist.countP_le (s : l₁ <+ l₂) : countP p l₁ ≤ countP p l₂ := by
   simp only [countP_eq_length_filter]
   apply s.filter _ |>.length_le
 
-theorem IsPrefix.countP_le (s : l₁ <+: l₂) : countP p l₁ ≤ countP p l₂ := s.sublist.countP_le _
-theorem IsSuffix.countP_le (s : l₁ <:+ l₂) : countP p l₁ ≤ countP p l₂ := s.sublist.countP_le _
-theorem IsInfix.countP_le (s : l₁ <:+: l₂) : countP p l₁ ≤ countP p l₂ := s.sublist.countP_le _
-
 theorem countP_filter (l : List α) :
-    countP p (filter q l) = countP (fun a => p a && q a) l := by
+    countP p (filter q l) = countP (fun a => p a ∧ q a) l := by
   simp only [countP_eq_length_filter, filter_filter]
 
-@[simp] theorem countP_true : (countP fun (_ : α) => true) = length := by
-  funext l
+@[simp] theorem countP_true {l : List α} : (l.countP fun _ => true) = l.length := by
+  rw [countP_eq_length]
   simp
 
-@[simp] theorem countP_false : (countP fun (_ : α) => false) = Function.const _ 0 := by
-  funext l
+@[simp] theorem countP_false {l : List α} : (l.countP fun _ => false) = 0 := by
+  rw [countP_eq_zero]
   simp
 
 @[simp] theorem countP_map (p : β → Bool) (f : α → β) :
@@ -132,30 +98,6 @@ theorem countP_filter (l : List α) :
   | [] => rfl
   | a :: l => by rw [map_cons, countP_cons, countP_cons, countP_map p f l]; rfl
 
-theorem length_filterMap_eq_countP (f : α → Option β) (l : List α) :
-    (filterMap f l).length = countP (fun a => (f a).isSome) l := by
-  induction l with
-  | nil => rfl
-  | cons x l ih =>
-    simp only [filterMap_cons, countP_cons]
-    split <;> simp [ih, *]
-
-theorem countP_filterMap (p : β → Bool) (f : α → Option β) (l : List α) :
-    countP p (filterMap f l) = countP (fun a => ((f a).map p).getD false) l := by
-  simp only [countP_eq_length_filter, filter_filterMap, ← filterMap_eq_filter]
-  simp only [length_filterMap_eq_countP]
-  congr
-  ext a
-  simp (config := { contextual := true }) [Option.getD_eq_iff]
-
-@[simp] theorem countP_join (l : List (List α)) :
-    countP p l.join = Nat.sum (l.map (countP p)) := by
-  simp only [countP_eq_length_filter, filter_join]
-  simp [countP_eq_length_filter']
-
-@[simp] theorem countP_reverse (l : List α) : countP p l.reverse = countP p l := by
-  simp [countP_eq_length_filter, filter_reverse]
-
 variable {p q}
 
 theorem countP_mono_left (h : ∀ x ∈ l, p x → q x) : countP p l ≤ countP q l := by
@@ -190,11 +132,6 @@ theorem count_cons (a b : α) (l : List α) :
     count a (b :: l) = count a l + if b == a then 1 else 0 := by
   simp [count, countP_cons]
 
-theorem count_eq_countP (a : α) (l : List α) : count a l = countP (· == a) l := rfl
-theorem count_eq_countP' {a : α} : count a = countP (· == a) := by
-  funext l
-  apply count_eq_countP
-
 theorem count_tail : ∀ (l : List α) (a : α) (h : l ≠ []),
       l.tail.count a = l.count a - if l.head h == a then 1 else 0
   | head :: tail, a, _ => by simp [count_cons]
@@ -203,10 +140,6 @@ theorem count_le_length (a : α) (l : List α) : count a l ≤ l.length := count
 
 theorem Sublist.count_le (h : l₁ <+ l₂) (a : α) : count a l₁ ≤ count a l₂ := h.countP_le _
 
-theorem IsPrefix.count_le (h : l₁ <+: l₂) (a : α) : count a l₁ ≤ count a l₂ := h.sublist.count_le _
-theorem IsSuffix.count_le (h : l₁ <:+ l₂) (a : α) : count a l₁ ≤ count a l₂ := h.sublist.count_le _
-theorem IsInfix.count_le (h : l₁ <:+: l₂) (a : α) : count a l₁ ≤ count a l₂ := h.sublist.count_le _
-
 theorem count_le_count_cons (a b : α) (l : List α) : count a l ≤ count a (b :: l) :=
   (sublist_cons_self _ _).count_le _
 
@@ -216,17 +149,6 @@ theorem count_singleton (a b : α) : count a [b] = if b == a then 1 else 0 := by
 @[simp] theorem count_append (a : α) : ∀ l₁ l₂, count a (l₁ ++ l₂) = count a l₁ + count a l₂ :=
   countP_append _
 
-theorem count_join (a : α) (l : List (List α)) : count a l.join = Nat.sum (l.map (count a)) := by
-  simp only [count_eq_countP, countP_join, count_eq_countP']
-
-@[simp] theorem count_reverse (a : α) (l : List α) : count a l.reverse = count a l := by
-  simp only [count_eq_countP, countP_eq_length_filter, filter_reverse, length_reverse]
-
-theorem boole_getElem_le_count (a : α) (l : List α) (i : Nat) (h : i < l.length) :
-    (if l[i] == a then 1 else 0) ≤ l.count a := by
-  rw [count_eq_countP]
-  apply boole_getElem_le_countP (· == a)
-
 variable [LawfulBEq α]
 
 @[simp] theorem count_cons_self (a : α) (l : List α) : count a (a :: l) = count a l + 1 := by
@@ -242,19 +164,14 @@ theorem count_concat_self (a : α) (l : List α) :
     count a (concat l a) = (count a l) + 1 := by simp
 
 @[simp]
-theorem count_pos_iff {a : α} {l : List α} : 0 < count a l ↔ a ∈ l := by
-  simp only [count, countP_pos_iff, beq_iff_eq, exists_eq_right]
-
-@[deprecated count_pos_iff (since := "2024-09-09")] abbrev count_pos_iff_mem := @count_pos_iff
-
-@[simp] theorem one_le_count_iff {a : α} {l : List α} : 1 ≤ count a l ↔ a ∈ l :=
-  count_pos_iff
+theorem count_pos_iff_mem {a : α} {l : List α} : 0 < count a l ↔ a ∈ l := by
+  simp only [count, countP_pos, beq_iff_eq, exists_eq_right]
 
 theorem count_eq_zero_of_not_mem {a : α} {l : List α} (h : a ∉ l) : count a l = 0 :=
-  Decidable.byContradiction fun h' => h <| count_pos_iff.1 (Nat.pos_of_ne_zero h')
+  Decidable.byContradiction fun h' => h <| count_pos_iff_mem.1 (Nat.pos_of_ne_zero h')
 
 theorem not_mem_of_count_eq_zero {a : α} {l : List α} (h : count a l = 0) : a ∉ l :=
-  fun h' => Nat.ne_of_lt (count_pos_iff.2 h') h.symm
+  fun h' => Nat.ne_of_lt (count_pos_iff_mem.2 h') h.symm
 
 theorem count_eq_zero {l : List α} : count a l = 0 ↔ a ∉ l :=
   ⟨not_mem_of_count_eq_zero, count_eq_zero_of_not_mem⟩
@@ -274,7 +191,7 @@ theorem count_replicate (a b : α) (n : Nat) : count a (replicate n b) = if b ==
   · exact count_eq_zero.2 <| mt eq_of_mem_replicate (Ne.symm h)
 
 theorem filter_beq (l : List α) (a : α) : l.filter (· == a) = replicate (count a l) a := by
-  simp only [count, countP_eq_length_filter, eq_replicate_iff, mem_filter, beq_iff_eq]
+  simp only [count, countP_eq_length_filter, eq_replicate, mem_filter, beq_iff_eq]
   exact ⟨trivial, fun _ h => h.2⟩
 
 theorem filter_eq {α} [DecidableEq α] (l : List α) (a : α) : l.filter (· = a) = replicate (count a l) a :=
@@ -299,29 +216,20 @@ theorem count_le_count_map [DecidableEq β] (l : List α) (f : α → β) (x :
   rw [count, count, countP_map]
   apply countP_mono_left; simp (config := { contextual := true })
 
-theorem count_filterMap {α} [BEq β] (b : β) (f : α → Option β) (l : List α) :
-    count b (filterMap f l) = countP (fun a => f a == some b) l := by
-  rw [count_eq_countP, countP_filterMap]
-  congr
-  ext a
-  obtain _ | b := f a
-  · simp
-  · simp
-
 theorem count_erase (a b : α) :
     ∀ l : List α, count a (l.erase b) = count a l - if b == a then 1 else 0
   | [] => by simp
   | c :: l => by
     rw [erase_cons]
     if hc : c = b then
-      have hc_beq := beq_iff_eq.mpr hc
+      have hc_beq := (beq_iff_eq _ _).mpr hc
       rw [if_pos hc_beq, hc, count_cons, Nat.add_sub_cancel]
     else
       have hc_beq := beq_false_of_ne hc
-      simp only [hc_beq, if_false, count_cons, count_cons, count_erase a b l, reduceCtorEq]
+      simp only [hc_beq, if_false, count_cons, count_cons, count_erase a b l]
       if ha : b = a then
         rw [ha, eq_comm] at hc
-        rw [if_pos (beq_iff_eq.2 ha), if_neg (by simpa using Ne.symm hc), Nat.add_zero, Nat.add_zero]
+        rw [if_pos ((beq_iff_eq _ _).2 ha), if_neg (by simpa using Ne.symm hc), Nat.add_zero, Nat.add_zero]
       else
         rw [if_neg (by simpa using ha), Nat.sub_zero, Nat.sub_zero]
 

src/Init/Data/List/Erase.lean

@@ -33,25 +33,6 @@ theorem eraseP_of_forall_not {l : List α} (h : ∀ a, a ∈ l → ¬p a) : l.er
   | nil => rfl
   | cons _ _ ih => simp [h _ (.head ..), ih (forall_mem_cons.1 h).2]
 
-@[simp] theorem eraseP_eq_nil {xs : List α} {p : α → Bool} : xs.eraseP p = [] ↔ xs = [] ∨ ∃ x, p x ∧ xs = [x] := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [eraseP_cons, cond_eq_if]
-    split <;> rename_i h
-    · simp only [reduceCtorEq, cons.injEq, false_or]
-      constructor
-      · rintro rfl
-        simpa
-      · rintro ⟨_, _, rfl, rfl⟩
-        rfl
-    · simp only [reduceCtorEq, cons.injEq, false_or, false_iff, not_exists, not_and]
-      rintro x h' rfl
-      simp_all
-
-theorem eraseP_ne_nil {xs : List α} {p : α → Bool} : xs.eraseP p ≠ [] ↔ xs ≠ [] ∧ ∀ x, p x → xs ≠ [x] := by
-  simp
-
 theorem exists_of_eraseP : ∀ {l : List α} {a} (al : a ∈ l) (pa : p a),
     ∃ a l₁ l₂, (∀ b ∈ l₁, ¬p b) ∧ p a ∧ l = l₁ ++ a :: l₂ ∧ l.eraseP p = l₁ ++ l₂
   | b :: l, a, al, pa =>
@@ -178,23 +159,6 @@ theorem eraseP_append (l₁ l₂ : List α) :
     rw [eraseP_append_right _]
     simp_all
 
-theorem eraseP_replicate (n : Nat) (a : α) (p : α → Bool) :
-    (replicate n a).eraseP p = if p a then replicate (n - 1) a else replicate n a := by
-  induction n with
-  | zero => simp
-  | succ n ih =>
-    simp only [replicate_succ, eraseP_cons]
-    split <;> simp [*]
-
-protected theorem IsPrefix.eraseP (h : l₁ <+: l₂) : l₁.eraseP p <+: l₂.eraseP p := by
-  rw [IsPrefix] at h
-  obtain ⟨t, rfl⟩ := h
-  rw [eraseP_append]
-  split
-  · exact prefix_append (eraseP p l₁) t
-  · rw [eraseP_of_forall_not (by simp_all)]
-    exact prefix_append l₁ (eraseP p t)
-
 theorem eraseP_eq_iff {p} {l : List α} :
     l.eraseP p = l' ↔
       ((∀ a ∈ l, ¬ p a) ∧ l = l') ∨
@@ -240,11 +204,8 @@ theorem eraseP_eq_iff {p} {l : List α} :
     (replicate n a).eraseP p = replicate n a := by
   rw [eraseP_of_forall_not (by simp_all)]
 
-theorem Pairwise.eraseP (q) : Pairwise p l → Pairwise p (l.eraseP q) :=
-  Pairwise.sublist <| eraseP_sublist _
-
 theorem Nodup.eraseP (p) : Nodup l → Nodup (l.eraseP p) :=
-  Pairwise.eraseP p
+  Nodup.sublist <| eraseP_sublist _
 
 theorem eraseP_comm {l : List α} (h : ∀ a ∈ l, ¬ p a ∨ ¬ q a) :
     (l.eraseP p).eraseP q = (l.eraseP q).eraseP p := by
@@ -260,12 +221,6 @@ theorem eraseP_comm {l : List α} (h : ∀ a ∈ l, ¬ p a ∨ ¬ q a) :
       · simp [h₁, h₂, ih (fun b m => h b (mem_cons_of_mem _ m))]
       · simp [h₁, h₂, ih (fun b m => h b (mem_cons_of_mem _ m))]
 
-theorem head_eraseP_mem (xs : List α) (p : α → Bool) (h) : (xs.eraseP p).head h ∈ xs :=
-  (eraseP_sublist xs).head_mem h
-
-theorem getLast_eraseP_mem (xs : List α) (p : α → Bool) (h) : (xs.eraseP p).getLast h ∈ xs :=
-  (eraseP_sublist xs).getLast_mem h
-
 /-! ### erase -/
 section erase
 variable [BEq α]
@@ -294,16 +249,6 @@ theorem erase_eq_eraseP [LawfulBEq α] (a : α) : ∀ l : List α,  l.erase a =
   | b :: l => by
     if h : a = b then simp [h] else simp [h, Ne.symm h, erase_eq_eraseP a l]
 
-@[simp] theorem erase_eq_nil [LawfulBEq α] {xs : List α} {a : α} :
-    xs.erase a = [] ↔ xs = [] ∨ xs = [a] := by
-  rw [erase_eq_eraseP]
-  simp
-
-theorem erase_ne_nil [LawfulBEq α] {xs : List α} {a : α} :
-    xs.erase a ≠ [] ↔ xs ≠ [] ∧ xs ≠ [a] := by
-  rw [erase_eq_eraseP]
-  simp
-
 theorem exists_erase_eq [LawfulBEq α] {a : α} {l : List α} (h : a ∈ l) :
     ∃ l₁ l₂, a ∉ l₁ ∧ l = l₁ ++ a :: l₂ ∧ l.erase a = l₁ ++ l₂ := by
   let ⟨_, l₁, l₂, h₁, e, h₂, h₃⟩ := exists_of_eraseP h (beq_self_eq_true _)
@@ -326,9 +271,6 @@ theorem erase_subset (a : α) (l : List α) : l.erase a ⊆ l := (erase_sublist
 theorem Sublist.erase (a : α) {l₁ l₂ : List α} (h : l₁ <+ l₂) : l₁.erase a <+ l₂.erase a := by
   simp only [erase_eq_eraseP']; exact h.eraseP
 
-theorem IsPrefix.erase (a : α) {l₁ l₂ : List α} (h : l₁ <+: l₂) : l₁.erase a <+: l₂.erase a := by
-  simp only [erase_eq_eraseP']; exact h.eraseP
-
 theorem length_erase_le (a : α) (l : List α) : (l.erase a).length ≤ l.length :=
   (erase_sublist a l).length_le
 
@@ -340,7 +282,7 @@ theorem mem_of_mem_erase {a b : α} {l : List α} (h : a ∈ l.erase b) : a ∈
 
 @[simp] theorem erase_eq_self_iff [LawfulBEq α] {l : List α} : l.erase a = l ↔ a ∉ l := by
   rw [erase_eq_eraseP', eraseP_eq_self_iff]
-  simp [forall_mem_ne']
+  simp
 
 theorem erase_filter [LawfulBEq α] (f : α → Bool) (l : List α) :
     (filter f l).erase a = filter f (l.erase a) := by
@@ -373,11 +315,6 @@ theorem erase_append [LawfulBEq α] {a : α} {l₁ l₂ : List α} :
     (l₁ ++ l₂).erase a = if a ∈ l₁ then l₁.erase a ++ l₂ else l₁ ++ l₂.erase a := by
   simp [erase_eq_eraseP, eraseP_append]
 
-theorem erase_replicate [LawfulBEq α] (n : Nat) (a b : α) :
-    (replicate n a).erase b = if b == a then replicate (n - 1) a else replicate n a := by
-  rw [erase_eq_eraseP]
-  simp [eraseP_replicate]
-
 theorem erase_comm [LawfulBEq α] (a b : α) (l : List α) :
     (l.erase a).erase b = (l.erase b).erase a := by
   if ab : a == b then rw [eq_of_beq ab] else ?_
@@ -417,10 +354,7 @@ theorem erase_eq_iff [LawfulBEq α] {a : α} {l : List α} :
   rw [erase_of_not_mem]
   simp_all
 
-theorem Pairwise.erase [LawfulBEq α] {l : List α} (a) : Pairwise p l → Pairwise p (l.erase a) :=
-  Pairwise.sublist <| erase_sublist _ _
-
-theorem Nodup.erase_eq_filter [LawfulBEq α] {l} (d : Nodup l) (a : α) : l.erase a = l.filter (· != a) := by
+theorem Nodup.erase_eq_filter [BEq α] [LawfulBEq α] {l} (d : Nodup l) (a : α) : l.erase a = l.filter (· != a) := by
   induction d with
   | nil => rfl
   | cons m _n ih =>
@@ -433,20 +367,14 @@ theorem Nodup.erase_eq_filter [LawfulBEq α] {l} (d : Nodup l) (a : α) : l.eras
       simpa [@eq_comm α] using m
     · simp [beq_false_of_ne h, ih, h]
 
-theorem Nodup.mem_erase_iff [LawfulBEq α] {a : α} (d : Nodup l) : a ∈ l.erase b ↔ a ≠ b ∧ a ∈ l := by
+theorem Nodup.mem_erase_iff [BEq α] [LawfulBEq α] {a : α} (d : Nodup l) : a ∈ l.erase b ↔ a ≠ b ∧ a ∈ l := by
   rw [Nodup.erase_eq_filter d, mem_filter, and_comm, bne_iff_ne]
 
-theorem Nodup.not_mem_erase [LawfulBEq α] {a : α} (h : Nodup l) : a ∉ l.erase a := fun H => by
+theorem Nodup.not_mem_erase [BEq α] [LawfulBEq α] {a : α} (h : Nodup l) : a ∉ l.erase a := fun H => by
   simpa using ((Nodup.mem_erase_iff h).mp H).left
 
-theorem Nodup.erase [LawfulBEq α] (a : α) : Nodup l → Nodup (l.erase a) :=
-  Pairwise.erase a
-
-theorem head_erase_mem (xs : List α) (a : α) (h) : (xs.erase a).head h ∈ xs :=
-  (erase_sublist a xs).head_mem h
-
-theorem getLast_erase_mem (xs : List α) (a : α) (h) : (xs.erase a).getLast h ∈ xs :=
-  (erase_sublist a xs).getLast_mem h
+theorem Nodup.erase [BEq α] [LawfulBEq α] (a : α) : Nodup l → Nodup (l.erase a) :=
+  Nodup.sublist <| erase_sublist _ _
 
 end erase
 
@@ -468,26 +396,11 @@ theorem eraseIdx_eq_take_drop_succ :
   | a::l, 0 => by simp
   | a::l, i + 1 => by simp [eraseIdx_eq_take_drop_succ l i]
 
-@[simp] theorem eraseIdx_eq_nil {l : List α} {i : Nat} : eraseIdx l i = [] ↔ l = [] ∨ (length l = 1 ∧ i = 0) := by
-  match l, i with
-  | [], _
-  | a::l, 0
-  | a::l, i + 1 => simp [Nat.succ_inj']
-
-theorem eraseIdx_ne_nil {l : List α} {i : Nat} : eraseIdx l i ≠ [] ↔ 2 ≤ l.length ∨ (l.length = 1 ∧ i ≠ 0) := by
-  match l with
-  | []
-  | [a]
-  | a::b::l => simp [Nat.succ_inj']
-
 theorem eraseIdx_sublist : ∀ (l : List α) (k : Nat), eraseIdx l k <+ l
   | [], _ => by simp
   | a::l, 0 => by simp
   | a::l, k + 1 => by simp [eraseIdx_sublist l k]
 
-theorem mem_of_mem_eraseIdx {l : List α} {i : Nat} {a : α} (h : a ∈ l.eraseIdx i) : a ∈ l :=
-  (eraseIdx_sublist _ _).mem h
-
 theorem eraseIdx_subset (l : List α) (k : Nat) : eraseIdx l k ⊆ l := (eraseIdx_sublist l k).subset
 
 @[simp]
@@ -517,23 +430,6 @@ theorem eraseIdx_append_of_length_le {l : List α} {k : Nat} (hk : length l ≤
     | zero => simp_all
     | succ k => simp_all [eraseIdx_cons_succ, Nat.succ_sub_succ]
 
-theorem eraseIdx_replicate {n : Nat} {a : α} {k : Nat} :
-    (replicate n a).eraseIdx k = if k < n then replicate (n - 1) a else replicate n a := by
-  split <;> rename_i h
-  · rw [eq_replicate_iff, length_eraseIdx (by simpa using h)]
-    simp only [length_replicate, true_and]
-    intro b m
-    replace m := mem_of_mem_eraseIdx m
-    simp only [mem_replicate] at m
-    exact m.2
-  · rw [eraseIdx_of_length_le (by simpa using h)]
-
-theorem Pairwise.eraseIdx {l : List α} (k) : Pairwise p l → Pairwise p (l.eraseIdx k) :=
-  Pairwise.sublist <| eraseIdx_sublist _ _
-
-theorem Nodup.eraseIdx {l : List α} (k) : Nodup l → Nodup (l.eraseIdx k) :=
-  Pairwise.eraseIdx k
-
 protected theorem IsPrefix.eraseIdx {l l' : List α} (h : l <+: l') (k : Nat) :
     eraseIdx l k <+: eraseIdx l' k := by
   rcases h with ⟨t, rfl⟩

src/Init/Data/List/Find.lean

@@ -1,22 +1,71 @@
 /-
 Copyright (c) 2014 Parikshit Khanna. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro,
-  Kim Morrison, Jannis Limperg
+Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
 -/
 prelude
 import Init.Data.List.Lemmas
-import Init.Data.List.Sublist
-import Init.Data.List.Range
 
 /-!
-# Lemmas about `List.findSome?`, `List.find?`, `List.findIdx`, `List.findIdx?`, and `List.indexOf`.
+# Lemmas about `List.find?`, `List.findSome?`, `List.findIdx`, `List.findIdx?`, and `List.indexOf`.
 -/
 
 namespace List
 
 open Nat
 
+/-! ### find? -/
+
+@[simp] theorem find?_cons_of_pos (l) (h : p a) : find? p (a :: l) = some a := by
+  simp [find?, h]
+
+@[simp] theorem find?_cons_of_neg (l) (h : ¬p a) : find? p (a :: l) = find? p l := by
+  simp [find?, h]
+
+@[simp] theorem find?_eq_none : find? p l = none ↔ ∀ x ∈ l, ¬ p x := by
+  induction l <;> simp [find?_cons]; split <;> simp [*]
+
+theorem find?_some : ∀ {l}, find? p l = some a → p a
+  | b :: l, H => by
+    by_cases h : p b <;> simp [find?, h] at H
+    · exact H ▸ h
+    · exact find?_some H
+
+@[simp] theorem mem_of_find?_eq_some : ∀ {l}, find? p l = some a → a ∈ l
+  | b :: l, H => by
+    by_cases h : p b <;> simp [find?, h] at H
+    · exact H ▸ .head _
+    · exact .tail _ (mem_of_find?_eq_some H)
+
+@[simp] theorem find?_map (f : β → α) (l : List β) : find? p (l.map f) = (l.find? (p ∘ f)).map f := by
+  induction l with
+  | nil => simp
+  | cons x xs ih =>
+    simp only [map_cons, find?]
+    by_cases h : p (f x) <;> simp [h, ih]
+
+theorem find?_replicate : find? p (replicate n a) = if n = 0 then none else if p a then some a else none := by
+  cases n
+  · simp
+  · by_cases p a <;> simp_all [replicate_succ]
+
+@[simp] theorem find?_replicate_of_length_pos (h : 0 < n) : find? p (replicate n a) = if p a then some a else none := by
+  simp [find?_replicate, Nat.ne_of_gt h]
+
+@[simp] theorem find?_replicate_of_pos (h : p a) : find? p (replicate n a) = if n = 0 then none else some a := by
+  simp [find?_replicate, h]
+
+@[simp] theorem find?_replicate_of_neg (h : ¬ p a) : find? p (replicate n a) = none := by
+  simp [find?_replicate, h]
+
+theorem find?_isSome_of_sublist {l₁ l₂ : List α} (h : l₁ <+ l₂) : (l₁.find? p).isSome → (l₂.find? p).isSome := by
+  induction h with
+  | slnil => simp
+  | cons a h ih
+  | cons₂ a h ih =>
+    simp only [find?]
+    split <;> simp_all
+
 /-! ### findSome? -/
 
 @[simp] theorem findSome?_cons_of_isSome (l) (h : (f a).isSome) : findSome? f (a :: l) = f a := by
@@ -35,116 +84,17 @@ theorem exists_of_findSome?_eq_some {l : List α} {f : α → Option β} (w : l.
     simp_all only [findSome?_cons, mem_cons, exists_eq_or_imp]
     split at w <;> simp_all
 
-@[simp] theorem findSome?_eq_none_iff : findSome? p l = none ↔ ∀ x ∈ l, p x = none := by
-  induction l <;> simp [findSome?_cons]; split <;> simp [*]
-
-@[deprecated findSome?_eq_none_iff (since := "2024-09-05")] abbrev findSome?_eq_none := @findSome?_eq_none_iff
-
-@[simp] theorem findSome?_isSome_iff {f : α → Option β} {l : List α} :
-    (l.findSome? f).isSome ↔ ∃ x, x ∈ l ∧ (f x).isSome := by
-  induction l with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [findSome?_cons]
-    split <;> simp_all
-
-theorem findSome?_eq_some_iff {f : α → Option β} {l : List α} {b : β} :
-    l.findSome? f = some b ↔ ∃ l₁ a l₂, l = l₁ ++ a :: l₂ ∧ f a = some b ∧ ∀ x ∈ l₁, f x = none := by
-  induction l with
-  | nil => simp
-  | cons p l ih =>
-    simp only [findSome?_cons]
-    split <;> rename_i b' h
-    · simp only [Option.some.injEq, exists_and_right]
-      constructor
-      · rintro rfl
-        exact ⟨[], p, ⟨l, rfl⟩, h, by simp⟩
-      · rintro ⟨(⟨⟩ | ⟨p', l₁⟩), a, ⟨l₂, h₁⟩, h₂, h₃⟩
-        · simp only [nil_append, cons.injEq] at h₁
-          apply Option.some.inj
-          simp [← h, ← h₂, h₁.1]
-        · simp only [cons_append, cons.injEq] at h₁
-          obtain ⟨rfl, rfl⟩ := h₁
-          specialize h₃ p
-          simp_all
-    · rw [ih]
-      constructor
-      · rintro ⟨l₁, a, l₂, rfl, h₁, h₂⟩
-        refine ⟨p :: l₁, a, l₂, rfl, h₁, ?_⟩
-        intro a w
-        simp at w
-        rcases w with rfl | w
-        · exact h
-        · exact h₂ _ w
-      · rintro ⟨l₁, a, l₂, h₁, h₂, h₃⟩
-        rcases l₁ with (⟨⟩ | ⟨a', l₁⟩)
-        · simp_all
-        · simp only [cons_append, cons.injEq] at h₁
-          obtain ⟨⟨rfl, rfl⟩, rfl⟩ := h₁
-          exact ⟨l₁, a, l₂, rfl, h₂, fun a' w => h₃ a' (mem_cons_of_mem p w)⟩
-
-@[simp] theorem findSome?_guard (l : List α) : findSome? (Option.guard fun x => p x) l = find? p l := by
-  induction l with
-  | nil => simp
-  | cons x xs ih =>
-    simp [guard, findSome?, find?]
-    split <;> rename_i h
-    · simp only [Option.guard_eq_some] at h
-      obtain ⟨rfl, h⟩ := h
-      simp [h]
-    · simp only [Option.guard_eq_none] at h
-      simp [ih, h]
-
-@[simp] theorem filterMap_head? (f : α → Option β) (l : List α) : (l.filterMap f).head? = l.findSome? f := by
-  induction l with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [filterMap_cons, findSome?_cons]
-    split <;> simp [*]
-
-@[simp] theorem filterMap_head (f : α → Option β) (l : List α) (h) :
-    (l.filterMap f).head h = (l.findSome? f).get (by simp_all [Option.isSome_iff_ne_none])  := by
-  simp [head_eq_iff_head?_eq_some]
-
-@[simp] theorem filterMap_getLast? (f : α → Option β) (l : List α) : (l.filterMap f).getLast? = l.reverse.findSome? f := by
-  rw [getLast?_eq_head?_reverse]
-  simp [← filterMap_reverse]
-
-@[simp] theorem filterMap_getLast (f : α → Option β) (l : List α) (h) :
-    (l.filterMap f).getLast h = (l.reverse.findSome? f).get (by simp_all [Option.isSome_iff_ne_none]) := by
-  simp [getLast_eq_iff_getLast_eq_some]
-
-@[simp] theorem map_findSome? (f : α → Option β) (g : β → γ) (l : List α) :
-    (l.findSome? f).map g = l.findSome? (Option.map g ∘ f) := by
-  induction l <;> simp [findSome?_cons]; split <;> simp [*]
-
-theorem findSome?_map (f : β → γ) (l : List β) : findSome? p (l.map f) = l.findSome? (p ∘ f) := by
+@[simp] theorem findSome?_map (f : β → γ) (l : List β) : findSome? p (l.map f) = l.findSome? (p ∘ f) := by
   induction l with
   | nil => simp
   | cons x xs ih =>
     simp only [map_cons, findSome?]
     split <;> simp_all
 
-theorem findSome?_append {l₁ l₂ : List α} : (l₁ ++ l₂).findSome? f = (l₁.findSome? f).or (l₂.findSome? f) := by
-  induction l₁ with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [cons_append, findSome?]
-    split <;> simp_all
-
-theorem head_join {L : List (List α)} (h : ∃ l, l ∈ L ∧ l ≠ []) :
-    (join L).head (by simpa using h) = (L.findSome? fun l => l.head?).get (by simpa using h) := by
-  simp [head_eq_iff_head?_eq_some, head?_join]
-
-theorem getLast_join {L : List (List α)} (h : ∃ l, l ∈ L ∧ l ≠ []) :
-    (join L).getLast (by simpa using h) =
-      (L.reverse.findSome? fun l => l.getLast?).get (by simpa using h) := by
-  simp [getLast_eq_iff_getLast_eq_some, getLast?_join]
-
 theorem findSome?_replicate : findSome? f (replicate n a) = if n = 0 then none else f a := by
-  cases n with
+  induction n with
   | zero => simp
-  | succ n =>
+  | succ n ih =>
     simp only [replicate_succ, findSome?_cons]
     split <;> simp_all
 
@@ -152,304 +102,22 @@ theorem findSome?_replicate : findSome? f (replicate n a) = if n = 0 then none e
   simp [findSome?_replicate, Nat.ne_of_gt h]
 
 -- Argument is unused, but used to decide whether `simp` should unfold.
-@[simp] theorem findSome?_replicate_of_isSome (_ : (f a).isSome) : findSome? f (replicate n a) = if n = 0 then none else f a := by
+@[simp] theorem find?_replicate_of_isSome (_ : (f a).isSome) : findSome? f (replicate n a) = if n = 0 then none else f a := by
   simp [findSome?_replicate]
 
-@[simp] theorem findSome?_replicate_of_isNone (h : (f a).isNone) : findSome? f (replicate n a) = none := by
+@[simp] theorem find?_replicate_of_isNone (h : (f a).isNone) : findSome? f (replicate n a) = none := by
   rw [Option.isNone_iff_eq_none] at h
   simp [findSome?_replicate, h]
 
-theorem Sublist.findSome?_isSome {l₁ l₂ : List α} (h : l₁ <+ l₂) :
+theorem findSome?_isSome_of_sublist {l₁ l₂ : List α} (h : l₁ <+ l₂) :
     (l₁.findSome? f).isSome → (l₂.findSome? f).isSome := by
   induction h with
   | slnil => simp
   | cons a h ih
   | cons₂ a h ih =>
     simp only [findSome?]
-    split
-    · simp_all
-    · exact ih
-
-theorem Sublist.findSome?_eq_none {l₁ l₂ : List α} (h : l₁ <+ l₂) :
-    l₂.findSome? f = none → l₁.findSome? f = none := by
-  simp only [List.findSome?_eq_none_iff, Bool.not_eq_true]
-  exact fun w x m => w x (Sublist.mem m h)
-
-theorem IsPrefix.findSome?_eq_some {l₁ l₂ : List α} {f : α → Option β} (h : l₁ <+: l₂) :
-    List.findSome? f l₁ = some b → List.findSome? f l₂ = some b := by
-  rw [IsPrefix] at h
-  obtain ⟨t, rfl⟩ := h
-  simp (config := {contextual := true}) [findSome?_append]
-
-theorem IsPrefix.findSome?_eq_none {l₁ l₂ : List α} {f : α → Option β} (h : l₁ <+: l₂) :
-    List.findSome? f l₂ = none → List.findSome? f l₁ = none :=
-  h.sublist.findSome?_eq_none
-theorem IsSuffix.findSome?_eq_none {l₁ l₂ : List α} {f : α → Option β} (h : l₁ <:+ l₂) :
-    List.findSome? f l₂ = none → List.findSome? f l₁ = none :=
-  h.sublist.findSome?_eq_none
-theorem IsInfix.findSome?_eq_none {l₁ l₂ : List α} {f : α → Option β} (h : l₁ <:+: l₂) :
-    List.findSome? f l₂ = none → List.findSome? f l₁ = none :=
-  h.sublist.findSome?_eq_none
-
-/-! ### find? -/
-
-@[simp] theorem find?_singleton (a : α) (p : α → Bool) : [a].find? p = if p a then some a else none := by
-  simp only [find?]
-  split <;> simp_all
-
-@[simp] theorem find?_cons_of_pos (l) (h : p a) : find? p (a :: l) = some a := by
-  simp [find?, h]
-
-@[simp] theorem find?_cons_of_neg (l) (h : ¬p a) : find? p (a :: l) = find? p l := by
-  simp [find?, h]
-
-@[simp] theorem find?_eq_none : find? p l = none ↔ ∀ x ∈ l, ¬ p x := by
-  induction l <;> simp [find?_cons]; split <;> simp [*]
-
-theorem find?_eq_some : xs.find? p = some b ↔ p b ∧ ∃ as bs, xs = as ++ b :: bs ∧ ∀ a ∈ as, !p a := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [find?_cons, exists_and_right]
-    split <;> rename_i h
-    · simp only [Option.some.injEq]
-      constructor
-      · rintro rfl
-        exact ⟨h, [], ⟨xs, rfl⟩, by simp⟩
-      · rintro ⟨-, ⟨as, ⟨⟨bs, h₁⟩, h₂⟩⟩⟩
-        cases as with
-        | nil => simp_all
-        | cons a as =>
-          specialize h₂ a (mem_cons_self _ _)
-          simp only [cons_append] at h₁
-          obtain ⟨rfl, -⟩ := h₁
-          simp_all
-    · simp only [ih, Bool.not_eq_true', exists_and_right, and_congr_right_iff]
-      intro pb
-      constructor
-      · rintro ⟨as, ⟨⟨bs, rfl⟩, h₁⟩⟩
-        refine ⟨x :: as, ⟨⟨bs, rfl⟩, ?_⟩⟩
-        intro a m
-        simp at m
-        obtain (rfl|m) := m
-        · exact h
-        · exact h₁ a m
-      · rintro ⟨as, ⟨bs, h₁⟩, h₂⟩
-        cases as with
-        | nil => simp_all
-        | cons a as =>
-          refine ⟨as, ⟨⟨bs, ?_⟩, fun a m => h₂ a (mem_cons_of_mem _ m)⟩⟩
-          cases h₁
-          simp
-
-@[simp]
-theorem find?_cons_eq_some : (a :: xs).find? p = some b ↔ (p a ∧ a = b) ∨ (!p a ∧ xs.find? p = some b) := by
-  rw [find?_cons]
-  split <;> simp_all
-
-@[simp] theorem find?_isSome {xs : List α} {p : α → Bool} : (xs.find? p).isSome ↔ ∃ x, x ∈ xs ∧ p x := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [find?_cons, mem_cons, exists_eq_or_imp]
     split <;> simp_all
 
-theorem find?_some : ∀ {l}, find? p l = some a → p a
-  | b :: l, H => by
-    by_cases h : p b <;> simp [find?, h] at H
-    · exact H ▸ h
-    · exact find?_some H
-
-theorem mem_of_find?_eq_some : ∀ {l}, find? p l = some a → a ∈ l
-  | b :: l, H => by
-    by_cases h : p b <;> simp [find?, h] at H
-    · exact H ▸ .head _
-    · exact .tail _ (mem_of_find?_eq_some H)
-
-theorem get_find?_mem (xs : List α) (p : α → Bool) (h) : (xs.find? p).get h ∈ xs := by
-  induction xs with
-  | nil => simp at h
-  | cons x xs ih =>
-    simp only [find?_cons]
-    by_cases h : p x
-    · simp [h]
-    · simp only [h]
-      right
-      apply ih
-
-@[simp] theorem find?_filter (xs : List α) (p : α → Bool) (q : α → Bool) :
-    (xs.filter p).find? q = xs.find? (fun a => p a ∧ q a) := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [filter_cons]
-    split <;>
-    · simp only [find?_cons]
-      split <;> simp_all
-
-@[simp] theorem filter_head? (p : α → Bool) (l : List α) : (l.filter p).head? = l.find? p := by
-  rw [← filterMap_eq_filter, filterMap_head?, findSome?_guard]
-
-@[simp] theorem filter_head (p : α → Bool) (l : List α) (h) :
-    (l.filter p).head h = (l.find? p).get (by simp_all [Option.isSome_iff_ne_none]) := by
-  simp [head_eq_iff_head?_eq_some]
-
-@[simp] theorem filter_getLast? (p : α → Bool) (l : List α) : (l.filter p).getLast? = l.reverse.find? p := by
-  rw [getLast?_eq_head?_reverse]
-  simp [← filter_reverse]
-
-@[simp] theorem filter_getLast (p : α → Bool) (l : List α) (h) :
-    (l.filter p).getLast h = (l.reverse.find? p).get (by simp_all [Option.isSome_iff_ne_none]) := by
-  simp [getLast_eq_iff_getLast_eq_some]
-
-@[simp] theorem find?_filterMap (xs : List α) (f : α → Option β) (p : β → Bool) :
-    (xs.filterMap f).find? p = (xs.find? (fun a => (f a).any p)).bind f := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [filterMap_cons]
-    split <;>
-    · simp only [find?_cons]
-      split <;> simp_all
-
-@[simp] theorem find?_map (f : β → α) (l : List β) : find? p (l.map f) = (l.find? (p ∘ f)).map f := by
-  induction l with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [map_cons, find?]
-    by_cases h : p (f x) <;> simp [h, ih]
-
-@[simp] theorem find?_append {l₁ l₂ : List α} : (l₁ ++ l₂).find? p = (l₁.find? p).or (l₂.find? p) := by
-  induction l₁ with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [cons_append, find?]
-    by_cases h : p x <;> simp [h, ih]
-
-@[simp] theorem find?_join (xs : List (List α)) (p : α → Bool) :
-    xs.join.find? p = xs.findSome? (·.find? p) := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [join_cons, find?_append, findSome?_cons, ih]
-    split <;> simp [*]
-
-theorem find?_join_eq_none {xs : List (List α)} {p : α → Bool} :
-    xs.join.find? p = none ↔ ∀ ys ∈ xs, ∀ x ∈ ys, !p x := by
-  simp
-
-/--
-If `find? p` returns `some a` from `xs.join`, then `p a` holds, and
-some list in `xs` contains `a`, and no earlier element of that list satisfies `p`.
-Moreover, no earlier list in `xs` has an element satisfying `p`.
--/
-theorem find?_join_eq_some {xs : List (List α)} {p : α → Bool} {a : α} :
-    xs.join.find? p = some a ↔
-      p a ∧ ∃ as ys zs bs, xs = as ++ (ys ++ a :: zs) :: bs ∧
-        (∀ a ∈ as, ∀ x ∈ a, !p x) ∧ (∀ x ∈ ys, !p x) := by
-  rw [find?_eq_some]
-  constructor
-  · rintro ⟨h, ⟨ys, zs, h₁, h₂⟩⟩
-    refine ⟨h, ?_⟩
-    rw [join_eq_append_iff] at h₁
-    obtain (⟨as, bs, rfl, rfl, h₁⟩ | ⟨as, bs, c, cs, ds, rfl, rfl, h₁⟩) := h₁
-    · replace h₁ := h₁.symm
-      rw [join_eq_cons_iff] at h₁
-      obtain ⟨bs, cs, ds, rfl, h₁, rfl⟩ := h₁
-      refine ⟨as ++ bs, [], cs, ds, by simp, ?_⟩
-      simp
-      rintro a (ma | mb) x m
-      · simpa using h₂ x (by simpa using ⟨a, ma, m⟩)
-      · specialize h₁ _ mb
-        simp_all
-    · simp [h₁]
-      refine ⟨as, bs, ?_⟩
-      refine ⟨?_, ?_, ?_⟩
-      · simp_all
-      · intro l ml a m
-        simpa using h₂ a (by simpa using .inl ⟨l, ml, m⟩)
-      · intro x m
-        simpa using h₂ x (by simpa using .inr m)
-  · rintro ⟨h, ⟨as, ys, zs, bs, rfl, h₁, h₂⟩⟩
-    refine ⟨h, as.join ++ ys, zs ++ bs.join, by simp, ?_⟩
-    intro a m
-    simp at m
-    obtain ⟨l, ml, m⟩ | m := m
-    · exact h₁ l ml a m
-    · exact h₂ a m
-
-@[simp] theorem find?_bind (xs : List α) (f : α → List β) (p : β → Bool) :
-    (xs.bind f).find? p = xs.findSome? (fun x => (f x).find? p) := by
-  simp [bind_def, findSome?_map]; rfl
-
-theorem find?_bind_eq_none {xs : List α} {f : α → List β} {p : β → Bool} :
-    (xs.bind f).find? p = none ↔ ∀ x ∈ xs, ∀ y ∈ f x, !p y := by
-  simp
-
-theorem find?_replicate : find? p (replicate n a) = if n = 0 then none else if p a then some a else none := by
-  cases n
-  · simp
-  · by_cases p a <;> simp_all [replicate_succ]
-
-@[simp] theorem find?_replicate_of_length_pos (h : 0 < n) : find? p (replicate n a) = if p a then some a else none := by
-  simp [find?_replicate, Nat.ne_of_gt h]
-
-@[simp] theorem find?_replicate_of_pos (h : p a) : find? p (replicate n a) = if n = 0 then none else some a := by
-  simp [find?_replicate, h]
-
-@[simp] theorem find?_replicate_of_neg (h : ¬ p a) : find? p (replicate n a) = none := by
-  simp [find?_replicate, h]
-
--- This isn't a `@[simp]` lemma since there is already a lemma for `l.find? p = none` for any `l`.
-theorem find?_replicate_eq_none {n : Nat} {a : α} {p : α → Bool} :
-    (replicate n a).find? p = none ↔ n = 0 ∨ !p a := by
-  simp [Classical.or_iff_not_imp_left]
-
-@[simp] theorem find?_replicate_eq_some {n : Nat} {a b : α} {p : α → Bool} :
-    (replicate n a).find? p = some b ↔ n ≠ 0 ∧ p a ∧ a = b := by
-  cases n <;> simp
-
-@[simp] theorem get_find?_replicate (n : Nat) (a : α) (p : α → Bool) (h) : ((replicate n a).find? p).get h = a := by
-  cases n with
-  | zero => simp at h
-  | succ n => simp
-
-theorem Sublist.find?_isSome {l₁ l₂ : List α} (h : l₁ <+ l₂) : (l₁.find? p).isSome → (l₂.find? p).isSome := by
-  induction h with
-  | slnil => simp
-  | cons a h ih
-  | cons₂ a h ih =>
-    simp only [find?]
-    split
-    · simp
-    · simpa using ih
-
-theorem Sublist.find?_eq_none {l₁ l₂ : List α} (h : l₁ <+ l₂) : l₂.find? p = none → l₁.find? p = none := by
-  simp only [List.find?_eq_none, Bool.not_eq_true]
-  exact fun w x m => w x (Sublist.mem m h)
-
-theorem IsPrefix.find?_eq_some {l₁ l₂ : List α} {p : α → Bool} (h : l₁ <+: l₂) :
-    List.find? p l₁ = some b → List.find? p l₂ = some b := by
-  rw [IsPrefix] at h
-  obtain ⟨t, rfl⟩ := h
-  simp (config := {contextual := true}) [find?_append]
-
-theorem IsPrefix.find?_eq_none {l₁ l₂ : List α} {p : α → Bool} (h : l₁ <+: l₂) :
-    List.find? p l₂ = none → List.find? p l₁ = none :=
-  h.sublist.find?_eq_none
-theorem IsSuffix.find?_eq_none {l₁ l₂ : List α} {p : α → Bool} (h : l₁ <:+ l₂) :
-    List.find? p l₂ = none → List.find? p l₁ = none :=
-  h.sublist.find?_eq_none
-theorem IsInfix.find?_eq_none {l₁ l₂ : List α} {p : α → Bool} (h : l₁ <:+: l₂) :
-    List.find? p l₂ = none → List.find? p l₁ = none :=
-  h.sublist.find?_eq_none
-
-theorem find?_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
-    (H : ∀ (a : α), a ∈ xs → P a) (p : β → Bool) :
-    (xs.pmap f H).find? p = (xs.attach.find? (fun ⟨a, m⟩ => p (f a (H a m)))).map fun ⟨a, m⟩ => f a (H a m) := by
-  simp only [pmap_eq_map_attach, find?_map]
-  rfl
-
 /-! ### findIdx -/
 
 theorem findIdx_cons (p : α → Bool) (b : α) (l : List α) :
@@ -467,23 +135,14 @@ where
       cases p head <;> simp only [cond_false, cond_true]
       exact findIdx_go_succ p tail (n + 1)
 
-theorem findIdx_of_getElem?_eq_some {xs : List α} (w : xs[xs.findIdx p]? = some y) : p y := by
+theorem findIdx_of_get?_eq_some {xs : List α} (w : xs.get? (xs.findIdx p) = some y) : p y := by
   induction xs with
   | nil => simp_all
   | cons x xs ih => by_cases h : p x <;> simp_all [findIdx_cons]
 
-theorem findIdx_getElem {xs : List α} {w : xs.findIdx p < xs.length} :
-    p xs[xs.findIdx p] :=
-  xs.findIdx_of_getElem?_eq_some (getElem?_eq_getElem w)
-
-@[deprecated findIdx_of_getElem?_eq_some (since := "2024-08-12")]
-theorem findIdx_of_get?_eq_some {xs : List α} (w : xs.get? (xs.findIdx p) = some y) : p y :=
-  findIdx_of_getElem?_eq_some (by simpa using w)
-
-@[deprecated findIdx_getElem (since := "2024-08-12")]
 theorem findIdx_get {xs : List α} {w : xs.findIdx p < xs.length} :
     p (xs.get ⟨xs.findIdx p, w⟩) :=
-  xs.findIdx_of_getElem?_eq_some (getElem?_eq_getElem w)
+  xs.findIdx_of_get?_eq_some (get?_eq_get w)
 
 theorem findIdx_lt_length_of_exists {xs : List α} (h : ∃ x ∈ xs, p x) :
     xs.findIdx p < xs.length := by
@@ -494,252 +153,37 @@ theorem findIdx_lt_length_of_exists {xs : List α} (h : ∃ x ∈ xs, p x) :
     · simp_all only [forall_exists_index, and_imp, mem_cons, exists_eq_or_imp, true_or,
         findIdx_cons, cond_true, length_cons]
       apply Nat.succ_pos
-    · simp_all [findIdx_cons, Nat.succ_lt_succ_iff]
+    · simp_all [findIdx_cons]
+      refine Nat.succ_lt_succ ?_
       obtain ⟨x', m', h'⟩ := h
       exact ih x' m' h'
 
-theorem findIdx_getElem?_eq_getElem_of_exists {xs : List α} (h : ∃ x ∈ xs, p x) :
-    xs[xs.findIdx p]? = some (xs[xs.findIdx p]'(xs.findIdx_lt_length_of_exists h)) :=
-  getElem?_eq_getElem (findIdx_lt_length_of_exists h)
-
-@[deprecated findIdx_getElem?_eq_getElem_of_exists (since := "2024-08-12")]
 theorem findIdx_get?_eq_get_of_exists {xs : List α} (h : ∃ x ∈ xs, p x) :
     xs.get? (xs.findIdx p) = some (xs.get ⟨xs.findIdx p, xs.findIdx_lt_length_of_exists h⟩) :=
   get?_eq_get (findIdx_lt_length_of_exists h)
 
-@[simp]
-theorem findIdx_eq_length {p : α → Bool} {xs : List α} :
-    xs.findIdx p = xs.length ↔ ∀ x ∈ xs, p x = false := by
-  induction xs with
-  | nil => simp_all
-  | cons x xs ih =>
-    rw [findIdx_cons, length_cons]
-    simp only [cond_eq_if]
-    split <;> simp_all [Nat.succ.injEq]
-
-theorem findIdx_eq_length_of_false {p : α → Bool} {xs : List α} (h : ∀ x ∈ xs, p x = false) :
-    xs.findIdx p = xs.length := by
-  rw [findIdx_eq_length]
-  exact h
-
-theorem findIdx_le_length (p : α → Bool) {xs : List α} : xs.findIdx p ≤ xs.length := by
-  by_cases e : ∃ x ∈ xs, p x
-  · exact Nat.le_of_lt (findIdx_lt_length_of_exists e)
-  · simp at e
-    exact Nat.le_of_eq (findIdx_eq_length.mpr e)
-
-@[simp]
-theorem findIdx_lt_length {p : α → Bool} {xs : List α} :
-    xs.findIdx p < xs.length ↔ ∃ x ∈ xs, p x := by
-  rw [← Decidable.not_iff_not, Nat.not_lt]
-  have := @Nat.le_antisymm_iff (xs.findIdx p) xs.length
-  simp only [findIdx_le_length, true_and] at this
-  rw [← this, findIdx_eq_length, not_exists]
-  simp only [Bool.not_eq_true, not_and]
-
-/-- `p` does not hold for elements with indices less than `xs.findIdx p`. -/
-theorem not_of_lt_findIdx {p : α → Bool} {xs : List α} {i : Nat} (h : i < xs.findIdx p) :
-    p (xs[i]'(Nat.le_trans h (findIdx_le_length p))) = false := by
-  revert i
-  induction xs with
-  | nil => intro i h; rw [findIdx_nil] at h; simp at h
-  | cons x xs ih =>
-    intro i h
-    have ho := h
-    rw [findIdx_cons] at h
-    have npx : p x = false := by
-      apply eq_false_of_ne_true
-      intro y
-      rw [y, cond_true] at h
-      simp at h
-    simp [npx, cond_false] at h
-    cases i.eq_zero_or_pos with
-    | inl e => simpa [e, Fin.zero_eta, get_cons_zero]
-    | inr e =>
-      have ipm := Nat.succ_pred_eq_of_pos e
-      have ilt := Nat.le_trans ho (findIdx_le_length p)
-      simp (config := { singlePass := true }) only [← ipm, getElem_cons_succ]
-      rw [← ipm, Nat.succ_lt_succ_iff] at h
-      simpa using ih h
-
-/-- If `¬ p xs[j]` for all `j < i`, then `i ≤ xs.findIdx p`. -/
-theorem le_findIdx_of_not {p : α → Bool} {xs : List α} {i : Nat} (h : i < xs.length)
-    (h2 : ∀ j (hji : j < i), p (xs[j]'(Nat.lt_trans hji h)) = false) : i ≤ xs.findIdx p := by
-  apply Decidable.byContradiction
-  intro f
-  simp only [Nat.not_le] at f
-  exact absurd (@findIdx_getElem _ p xs (Nat.lt_trans f h)) (by simpa using h2 (xs.findIdx p) f)
-
-/-- If `¬ p xs[j]` for all `j ≤ i`, then `i < xs.findIdx p`. -/
-theorem lt_findIdx_of_not {p : α → Bool} {xs : List α} {i : Nat} (h : i < xs.length)
-    (h2 : ∀ j (hji : j ≤ i), ¬p (xs.get ⟨j, Nat.lt_of_le_of_lt hji h⟩)) : i < xs.findIdx p := by
-  apply Decidable.byContradiction
-  intro f
-  simp only [Nat.not_lt] at f
-  exact absurd (@findIdx_getElem _ p xs (Nat.lt_of_le_of_lt f h)) (h2 (xs.findIdx p) f)
-
-/-- `xs.findIdx p = i` iff `p xs[i]` and `¬ p xs [j]` for all `j < i`. -/
-theorem findIdx_eq {p : α → Bool} {xs : List α} {i : Nat} (h : i < xs.length) :
-    xs.findIdx p = i ↔ p xs[i] ∧ ∀ j (hji : j < i), p (xs[j]'(Nat.lt_trans hji h)) = false := by
-  refine ⟨fun f ↦ ⟨f ▸ (@findIdx_getElem _ p xs (f ▸ h)), fun _ hji ↦ not_of_lt_findIdx (f ▸ hji)⟩,
-    fun ⟨_, h2⟩ ↦ ?_⟩
-  apply Nat.le_antisymm _ (le_findIdx_of_not h h2)
-  apply Decidable.byContradiction
-  intro h3
-  simp at h3
-  simp_all [not_of_lt_findIdx h3]
-
-theorem findIdx_append (p : α → Bool) (l₁ l₂ : List α) :
-    (l₁ ++ l₂).findIdx p =
-      if ∃ x, x ∈ l₁ ∧ p x = true then l₁.findIdx p else l₂.findIdx p + l₁.length := by
-  induction l₁ with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [findIdx_cons, length_cons, cons_append]
-    by_cases h : p x
-    · simp [h]
-    · simp only [h, ih, cond_eq_if, Bool.false_eq_true, ↓reduceIte, mem_cons, exists_eq_or_imp,
-        false_or]
-      split <;> simp [Nat.add_assoc]
-
-theorem IsPrefix.findIdx_le {l₁ l₂ : List α} {p : α → Bool} (h : l₁ <+: l₂) :
-    l₁.findIdx p ≤ l₂.findIdx p := by
-  rw [IsPrefix] at h
-  obtain ⟨t, rfl⟩ := h
-  simp only [findIdx_append, findIdx_lt_length]
-  split
-  · exact Nat.le_refl ..
-  · simp_all [findIdx_eq_length_of_false]
-
-theorem IsPrefix.findIdx_eq_of_findIdx_lt_length {l₁ l₂ : List α} {p : α → Bool} (h : l₁ <+: l₂)
-    (lt : l₁.findIdx p < l₁.length) : l₂.findIdx p = l₁.findIdx p := by
-  rw [IsPrefix] at h
-  obtain ⟨t, rfl⟩ := h
-  simp only [findIdx_append, findIdx_lt_length]
-  split
-  · rfl
-  · simp_all
-
-/-! ### findIdx? -/
+  /-! ### findIdx? -/
 
 @[simp] theorem findIdx?_nil : ([] : List α).findIdx? p i = none := rfl
 
 @[simp] theorem findIdx?_cons :
     (x :: xs).findIdx? p i = if p x then some i else findIdx? p xs (i + 1) := rfl
 
-theorem findIdx?_succ :
+@[simp] theorem findIdx?_succ :
     (xs : List α).findIdx? p (i+1) = (xs.findIdx? p i).map fun i => i + 1 := by
   induction xs generalizing i with simp
   | cons _ _ _ => split <;> simp_all
 
-@[simp] theorem findIdx?_start_succ :
-    (xs : List α).findIdx? p (i+1) = (xs.findIdx? p 0).map fun k => k + (i + 1) := by
-  induction xs generalizing i with
-  | nil => simp
-  | cons _ _ _ =>
-    simp only [findIdx?_succ, findIdx?_cons, Nat.zero_add]
-    split
-    · simp_all
-    · simp_all only [findIdx?_succ, Bool.not_eq_true, Option.map_map, Nat.zero_add]
-      congr
-      ext
-      simp only [Nat.add_comm i, Function.comp_apply, Nat.add_assoc]
-
-@[simp]
-theorem findIdx?_eq_none_iff {xs : List α} {p : α → Bool} :
-    xs.findIdx? p = none ↔ ∀ x, x ∈ xs → p x = false := by
-  induction xs with
-  | nil => simp_all
-  | cons x xs ih =>
-    simp only [findIdx?_cons]
-    split <;> simp_all [cond_eq_if]
-
-theorem findIdx?_isSome {xs : List α} {p : α → Bool} :
-    (xs.findIdx? p).isSome = xs.any p := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [findIdx?_cons]
-    split <;> simp_all
-
-theorem findIdx?_isNone {xs : List α} {p : α → Bool} :
-    (xs.findIdx? p).isNone = xs.all (¬p ·) := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [findIdx?_cons]
-    split <;> simp_all
-
-theorem findIdx?_eq_some_iff_findIdx_eq {xs : List α} {p : α → Bool} {i : Nat} :
-    xs.findIdx? p = some i ↔ i < xs.length ∧ xs.findIdx p = i := by
-  induction xs generalizing i with
-  | nil => simp_all
-  | cons x xs ih =>
-    simp only [findIdx?_cons, findIdx_cons]
-    split
-    · simp_all [cond_eq_if]
-      rintro rfl
-      exact zero_lt_succ xs.length
-    · simp_all [cond_eq_if, and_assoc]
-      constructor
-      · rintro ⟨a, lt, rfl, rfl⟩
-        simp_all [Nat.succ_lt_succ_iff]
-      · rintro ⟨h, rfl⟩
-        exact ⟨_, by simp_all [Nat.succ_lt_succ_iff], rfl, rfl⟩
-
-theorem findIdx?_eq_some_of_exists {xs : List α} {p : α → Bool} (h : ∃ x, x ∈ xs ∧ p x) :
-    xs.findIdx? p = some (xs.findIdx p) := by
-  rw [findIdx?_eq_some_iff_findIdx_eq]
-  exact ⟨findIdx_lt_length_of_exists h, rfl⟩
-
-theorem findIdx?_eq_none_iff_findIdx_eq {xs : List α} {p : α → Bool} :
-    xs.findIdx? p = none ↔ xs.findIdx p = xs.length := by
-  simp
-
-theorem findIdx?_eq_guard_findIdx_lt {xs : List α} {p : α → Bool} :
-    xs.findIdx? p = Option.guard (fun i => i < xs.length) (xs.findIdx p) := by
-  match h : xs.findIdx? p with
-  | none =>
-    simp only [findIdx?_eq_none_iff] at h
-    simp [findIdx_eq_length_of_false h, Option.guard]
-  | some i =>
-    simp only [findIdx?_eq_some_iff_findIdx_eq] at h
-    simp [h]
-
-theorem findIdx?_eq_some_iff_getElem {xs : List α} {p : α → Bool} {i : Nat} :
-    xs.findIdx? p = some i ↔
-      ∃ h : i < xs.length, p xs[i] ∧ ∀ j (hji : j < i), ¬p (xs[j]'(Nat.lt_trans hji h)) := by
+theorem findIdx?_eq_some_iff (xs : List α) (p : α → Bool) :
+    xs.findIdx? p = some i ↔ (xs.take (i + 1)).map p = replicate i false ++ [true] := by
   induction xs generalizing i with
   | nil => simp
   | cons x xs ih =>
-    simp only [findIdx?_cons, Nat.zero_add, findIdx?_succ]
-    split
-    · simp only [Option.some.injEq, Bool.not_eq_true, length_cons]
-      cases i with
-      | zero => simp_all
-      | succ i =>
-        simp only [Bool.not_eq_true, zero_ne_add_one, getElem_cons_succ, false_iff, not_exists,
-          not_and, Classical.not_forall, Bool.not_eq_false]
-        intros
-        refine ⟨0, zero_lt_succ i, ‹_›⟩
-    · simp only [Option.map_eq_some', ih, Bool.not_eq_true, length_cons]
-      constructor
-      · rintro ⟨a, ⟨⟨h, h₁, h₂⟩, rfl⟩⟩
-        refine ⟨Nat.succ_lt_succ_iff.mpr h, by simpa, fun j hj => ?_⟩
-        cases j with
-        | zero => simp_all
-        | succ j =>
-          apply h₂
-          simp_all [Nat.succ_lt_succ_iff]
-      · rintro ⟨h, h₁, h₂⟩
-        cases i with
-        | zero => simp_all
-        | succ i =>
-          refine ⟨i, ⟨Nat.succ_lt_succ_iff.mp h, by simpa, fun j hj => ?_⟩, rfl⟩
-          simpa using h₂ (j + 1) (Nat.succ_lt_succ_iff.mpr hj)
+    simp only [findIdx?_cons, Nat.zero_add, findIdx?_succ, take_succ_cons, map_cons]
+    split <;> cases i <;> simp_all [replicate_succ, succ_inj']
 
 theorem findIdx?_of_eq_some {xs : List α} {p : α → Bool} (w : xs.findIdx? p = some i) :
-    match xs[i]? with | some a => p a | none => false := by
+    match xs.get? i with | some a => p a | none => false := by
   induction xs generalizing i with
   | nil => simp_all
   | cons x xs ih =>
@@ -747,7 +191,7 @@ theorem findIdx?_of_eq_some {xs : List α} {p : α → Bool} (w : xs.findIdx? p
     split at w <;> cases i <;> simp_all [succ_inj']
 
 theorem findIdx?_of_eq_none {xs : List α} {p : α → Bool} (w : xs.findIdx? p = none) :
-    ∀ i : Nat, match xs[i]? with | some a => ¬ p a | none => true := by
+    ∀ i, match xs.get? i with | some a => ¬ p a | none => true := by
   intro i
   induction xs generalizing i with
   | nil => simp_all
@@ -757,90 +201,24 @@ theorem findIdx?_of_eq_none {xs : List α} {p : α → Bool} (w : xs.findIdx? p
     | zero =>
       split at w <;> simp_all
     | succ i =>
-      simp only [getElem?_cons_succ]
+      simp only [get?_cons_succ]
       apply ih
       split at w <;> simp_all
 
-@[simp] theorem findIdx?_map (f : β → α) (l : List β) : findIdx? p (l.map f) = l.findIdx? (p ∘ f) := by
-  induction l with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [map_cons, findIdx?]
-    split <;> simp_all
-
 @[simp] theorem findIdx?_append :
     (xs ++ ys : List α).findIdx? p =
-      (xs.findIdx? p).or ((ys.findIdx? p).map fun i => i + xs.length) := by
+      (xs.findIdx? p <|> (ys.findIdx? p).map fun i => i + xs.length) := by
   induction xs with simp
-  | cons _ _ _ => split <;> simp_all [Option.map_or', Option.map_map]; rfl
-
-theorem findIdx?_join {l : List (List α)} {p : α → Bool} :
-    l.join.findIdx? p =
-      (l.findIdx? (·.any p)).map
-        fun i => Nat.sum ((l.take i).map List.length) +
-          (l[i]?.map fun xs => xs.findIdx p).getD 0 := by
-  induction l with
-  | nil => simp
-  | cons xs l ih =>
-    simp only [join, findIdx?_append, map_take, map_cons, findIdx?, any_eq_true, Nat.zero_add,
-      findIdx?_succ]
-    split
-    · simp only [Option.map_some', take_zero, sum_nil, length_cons, zero_lt_succ,
-        getElem?_eq_getElem, getElem_cons_zero, Option.getD_some, Nat.zero_add]
-      rw [Option.or_of_isSome (by simpa [findIdx?_isSome])]
-      rw [findIdx?_eq_some_of_exists ‹_›]
-    · simp_all only [map_take, not_exists, not_and, Bool.not_eq_true, Option.map_map]
-      rw [Option.or_of_isNone (by simpa [findIdx?_isNone])]
-      congr 1
-      ext i
-      simp [Nat.add_comm, Nat.add_assoc]
+  | cons _ _ _ => split <;> simp_all [Option.map_orElse, Option.map_map]; rfl
 
 @[simp] theorem findIdx?_replicate :
     (replicate n a).findIdx? p = if 0 < n ∧ p a then some 0 else none := by
-  cases n with
+  induction n with
   | zero => simp
-  | succ n =>
-    simp only [replicate, findIdx?_cons, Nat.zero_add, findIdx?_succ, zero_lt_succ, true_and]
+  | succ n ih =>
+    simp only [replicate, findIdx?_cons, Nat.zero_add, findIdx?_succ, Nat.zero_lt_succ, true_and]
     split <;> simp_all
 
-theorem findIdx?_eq_enum_findSome? {xs : List α} {p : α → Bool} :
-    xs.findIdx? p = xs.enum.findSome? fun ⟨i, a⟩ => if p a then some i else none := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [findIdx?_cons, Nat.zero_add, findIdx?_succ, enum]
-    split
-    · simp_all
-    · simp_all only [enumFrom_cons, ite_false, Option.isNone_none, findSome?_cons_of_isNone, reduceCtorEq]
-      simp [Function.comp_def, ← map_fst_add_enum_eq_enumFrom, findSome?_map]
-
-theorem Sublist.findIdx?_isSome {l₁ l₂ : List α} (h : l₁ <+ l₂) :
-    (l₁.findIdx? p).isSome → (l₂.findIdx? p).isSome := by
-  simp only [List.findIdx?_isSome, any_eq_true]
-  rintro ⟨w, m, q⟩
-  exact ⟨w, h.mem m, q⟩
-
-theorem Sublist.findIdx?_eq_none {l₁ l₂ : List α} (h : l₁ <+ l₂) :
-    l₂.findIdx? p = none → l₁.findIdx? p = none := by
-  simp only [findIdx?_eq_none_iff]
-  exact fun w x m => w x (h.mem m)
-
-theorem IsPrefix.findIdx?_eq_some {l₁ l₂ : List α} {p : α → Bool} (h : l₁ <+: l₂) :
-    List.findIdx? p l₁ = some i → List.findIdx? p l₂ = some i := by
-  rw [IsPrefix] at h
-  obtain ⟨t, rfl⟩ := h
-  intro h
-  simp [findIdx?_append, h]
-theorem IsPrefix.findIdx?_eq_none {l₁ l₂ : List α} {p : α → Bool} (h : l₁ <+: l₂) :
-    List.findIdx? p l₂ = none → List.findIdx? p l₁ = none :=
-  h.sublist.findIdx?_eq_none
-theorem IsSuffix.findIdx?_eq_none {l₁ l₂ : List α} {p : α → Bool} (h : l₁ <:+ l₂) :
-    List.findIdx? p l₂ = none → List.findIdx? p l₁ = none :=
-  h.sublist.findIdx?_eq_none
-theorem IsInfix.findIdx?_eq_none {l₁ l₂ : List α} {p : α → Bool} (h : l₁ <:+: l₂) :
-    List.findIdx? p l₂ = none → List.findIdx? p l₁ = none :=
-  h.sublist.findIdx?_eq_none
-
 /-! ### indexOf -/
 
 theorem indexOf_cons [BEq α] :
@@ -848,96 +226,4 @@ theorem indexOf_cons [BEq α] :
   dsimp [indexOf]
   simp [findIdx_cons]
 
-/-! ### lookup -/
-section lookup
-variable [BEq α] [LawfulBEq α]
-
-@[simp] theorem lookup_cons_self  {k : α} : ((k,b) :: es).lookup k = some b := by
-  simp [lookup_cons]
-
-theorem lookup_eq_findSome? (l : List (α × β)) (k : α) :
-    l.lookup k = l.findSome? fun p => if k == p.1 then some p.2 else none := by
-  induction l with
-  | nil => rfl
-  | cons p l ih =>
-    match p with
-    | (k', v) =>
-      simp only [lookup_cons, findSome?_cons]
-      split <;> simp_all
-
-@[simp] theorem lookup_eq_none_iff {l : List (α × β)} {k : α} :
-    l.lookup k = none ↔ ∀ p ∈ l, k != p.1 := by
-  simp [lookup_eq_findSome?]
-
-@[simp] theorem lookup_isSome_iff {l : List (α × β)} {k : α} :
-    (l.lookup k).isSome ↔ ∃ p ∈ l, k == p.1 := by
-  simp [lookup_eq_findSome?]
-
-theorem lookup_eq_some_iff {l : List (α × β)} {k : α} {b : β} :
-    l.lookup k = some b ↔ ∃ l₁ l₂, l = l₁ ++ (k, b) :: l₂ ∧ ∀ p ∈ l₁, k != p.1 := by
-  simp only [lookup_eq_findSome?, findSome?_eq_some_iff]
-  constructor
-  · rintro ⟨l₁, a, l₂, rfl, h₁, h₂⟩
-    simp only [beq_iff_eq, ite_some_none_eq_some] at h₁
-    obtain ⟨rfl, rfl⟩ := h₁
-    simp at h₂
-    exact ⟨l₁, l₂, rfl, by simpa using h₂⟩
-  · rintro ⟨l₁, l₂, rfl, h⟩
-    exact ⟨l₁, (k, b), l₂, rfl, by simp, by simpa using h⟩
-
-theorem lookup_append {l₁ l₂ : List (α × β)} {k : α} :
-    (l₁ ++ l₂).lookup k = (l₁.lookup k).or (l₂.lookup k) := by
-  simp [lookup_eq_findSome?, findSome?_append]
-
-theorem lookup_replicate {k : α} :
-    (replicate n (a,b)).lookup k = if n = 0 then none else if k == a then some b else none := by
-  induction n with
-  | zero => simp
-  | succ n ih =>
-    simp only [replicate_succ, lookup_cons]
-    split <;> simp_all
-
-theorem lookup_replicate_of_pos {k : α} (h : 0 < n) :
-    (replicate n (a, b)).lookup k = if k == a then some b else none := by
-  simp [lookup_replicate, Nat.ne_of_gt h]
-
-theorem lookup_replicate_self {a : α} :
-    (replicate n (a, b)).lookup a = if n = 0 then none else some b := by
-  simp [lookup_replicate]
-
-@[simp] theorem lookup_replicate_self_of_pos {a : α} (h : 0 < n) :
-    (replicate n (a, b)).lookup a = some b := by
-  simp [lookup_replicate_self, Nat.ne_of_gt h]
-
-@[simp] theorem lookup_replicate_ne {k : α} (h : !k == a) :
-    (replicate n (a, b)).lookup k = none := by
-  simp_all [lookup_replicate]
-
-theorem Sublist.lookup_isSome {l₁ l₂ : List (α × β)} (h : l₁ <+ l₂) :
-    (l₁.lookup k).isSome → (l₂.lookup k).isSome := by
-  simp only [lookup_eq_findSome?]
-  exact h.findSome?_isSome
-
-theorem Sublist.lookup_eq_none {l₁ l₂ : List (α × β)} (h : l₁ <+ l₂) :
-    l₂.lookup k = none → l₁.lookup k = none := by
-  simp only [lookup_eq_findSome?]
-  exact h.findSome?_eq_none
-
-theorem IsPrefix.lookup_eq_some {l₁ l₂ : List (α × β)} (h : l₁ <+: l₂) :
-    List.lookup k l₁ = some b → List.lookup k l₂ = some b := by
-  simp only [lookup_eq_findSome?]
-  exact h.findSome?_eq_some
-
-theorem IsPrefix.lookup_eq_none {l₁ l₂ : List (α × β)} (h : l₁ <+: l₂) :
-    List.lookup k l₂ = none → List.lookup k l₁ = none :=
-  h.sublist.lookup_eq_none
-theorem IsSuffix.lookup_eq_none {l₁ l₂ : List (α × β)} (h : l₁ <:+ l₂) :
-    List.lookup k l₂ = none → List.lookup k l₁ = none :=
-  h.sublist.lookup_eq_none
-theorem IsInfix.lookup_eq_none {l₁ l₂ : List (α × β)} (h : l₁ <:+: l₂) :
-    List.lookup k l₂ = none → List.lookup k l₁ = none :=
-  h.sublist.lookup_eq_none
-
-end lookup
-
 end List

src/Init/Data/List/Impl.lean

@@ -3,17 +3,15 @@ Copyright (c) 2016 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
+
 prelude
-import Init.Data.Array.Bootstrap
+import Init.Data.Array.Lemmas
 
 /-!
 ## Tail recursive implementations for `List` definitions.
 
 Many of the proofs require theorems about `Array`,
 so these are in a separate file to minimize imports.
-
-If you import `Init.Data.List.Basic` but do not import this file,
-then at runtime you will get non-tail recursive versions of the following definitions.
 -/
 
 namespace List
@@ -33,16 +31,25 @@ The following operations are not recursive to begin with
 `isEmpty`, `isSuffixOf`, `isSuffixOf?`, `rotateLeft`, `rotateRight`, `insert`, `zip`, `enum`,
 `minimum?`, `maximum?`, and `removeAll`.
 
-The following operations were already given `@[csimp]` replacements in `Init/Data/List/Basic.lean`:
-`length`, `map`, `filter`, `replicate`, `leftPad`, `unzip`, `range'`, `iota`, `intersperse`.
-
 The following operations are given `@[csimp]` replacements below:
-`set`, `filterMap`, `foldr`, `append`, `bind`, `join`,
-`take`, `takeWhile`, `dropLast`, `replace`, `erase`, `eraseIdx`, `zipWith`,
-`enumFrom`, and `intercalate`.
+`length`, `set`, `map`, `filter`, `filterMap`, `foldr`, `append`, `bind`, `join`, `replicate`,
+`take`, `takeWhile`, `dropLast`, `replace`, `erase`, `eraseIdx`, `zipWith`, `unzip`, `iota`,
+`enumFrom`, `intersperse`, and `intercalate`.
 
 -/
 
+/-! ### length -/
+
+theorem length_add_eq_lengthTRAux (as : List α) (n : Nat) : as.length + n = as.lengthTRAux n := by
+  induction as generalizing n with
+  | nil  => simp [length, lengthTRAux]
+  | cons a as ih =>
+    simp [length, lengthTRAux, ← ih, Nat.succ_add]
+    rfl
+
+@[csimp] theorem length_eq_lengthTR : @List.length = @List.lengthTR := by
+  apply funext; intro α; apply funext; intro as
+  simp [lengthTR, ← length_add_eq_lengthTRAux]
 
 /-! ### set -/
 
@@ -57,13 +64,60 @@ The following operations are given `@[csimp]` replacements below:
 
 @[csimp] theorem set_eq_setTR : @set = @setTR := by
   funext α l n a; simp [setTR]
-  let rec go (acc) : ∀ xs n, l = acc.toList ++ xs →
-    setTR.go l a xs n acc = acc.toList ++ xs.set n a
+  let rec go (acc) : ∀ xs n, l = acc.data ++ xs →
+    setTR.go l a xs n acc = acc.data ++ xs.set n a
   | [], _ => fun h => by simp [setTR.go, set, h]
   | x::xs, 0 => by simp [setTR.go, set]
   | x::xs, n+1 => fun h => by simp only [setTR.go, set]; rw [go _ xs] <;> simp [h]
   exact (go #[] _ _ rfl).symm
 
+/-! ### map -/
+
+/-- Tail-recursive version of `List.map`. -/
+@[inline] def mapTR (f : α → β) (as : List α) : List β :=
+  loop as []
+where
+  @[specialize] loop : List α → List β → List β
+  | [],    bs => bs.reverse
+  | a::as, bs => loop as (f a :: bs)
+
+theorem mapTR_loop_eq (f : α → β) (as : List α) (bs : List β) :
+    mapTR.loop f as bs = bs.reverse ++ map f as := by
+  induction as generalizing bs with
+  | nil => simp [mapTR.loop, map]
+  | cons a as ih =>
+    simp only [mapTR.loop, map]
+    rw [ih (f a :: bs), reverse_cons, append_assoc]
+    rfl
+
+@[csimp] theorem map_eq_mapTR : @map = @mapTR :=
+  funext fun α => funext fun β => funext fun f => funext fun as => by
+    simp [mapTR, mapTR_loop_eq]
+
+/-! ### filter -/
+
+/-- Tail-recursive version of `List.filter`. -/
+@[inline] def filterTR (p : α → Bool) (as : List α) : List α :=
+  loop as []
+where
+  @[specialize] loop : List α → List α → List α
+  | [],    rs => rs.reverse
+  | a::as, rs => match p a with
+     | true  => loop as (a::rs)
+     | false => loop as rs
+
+theorem filterTR_loop_eq (p : α → Bool) (as bs : List α) :
+    filterTR.loop p as bs = bs.reverse ++ filter p as := by
+  induction as generalizing bs with
+  | nil => simp [filterTR.loop, filter]
+  | cons a as ih =>
+    simp only [filterTR.loop, filter]
+    split <;> simp_all
+
+@[csimp] theorem filter_eq_filterTR : @filter = @filterTR := by
+  apply funext; intro α; apply funext; intro p; apply funext; intro as
+  simp [filterTR, filterTR_loop_eq]
+
 /-! ### filterMap -/
 
 /-- Tail recursive version of `filterMap`. -/
@@ -77,11 +131,10 @@ The following operations are given `@[csimp]` replacements below:
 
 @[csimp] theorem filterMap_eq_filterMapTR : @List.filterMap = @filterMapTR := by
   funext α β f l
-  let rec go : ∀ as acc, filterMapTR.go f as acc = acc.toList ++ as.filterMap f
+  let rec go : ∀ as acc, filterMapTR.go f as acc = acc.data ++ as.filterMap f
     | [], acc => by simp [filterMapTR.go, filterMap]
     | a::as, acc => by
-      simp only [filterMapTR.go, go as, Array.push_toList, append_assoc, singleton_append,
-        filterMap]
+      simp only [filterMapTR.go, go as, Array.push_data, append_assoc, singleton_append, filterMap]
       split <;> simp [*]
   exact (go l #[]).symm
 
@@ -91,7 +144,7 @@ The following operations are given `@[csimp]` replacements below:
 @[specialize] def foldrTR (f : α → β → β) (init : β) (l : List α) : β := l.toArray.foldr f init
 
 @[csimp] theorem foldr_eq_foldrTR : @foldr = @foldrTR := by
-  funext α β f init l; simp [foldrTR, Array.foldr_eq_foldr_toList, -Array.size_toArray]
+  funext α β f init l; simp [foldrTR, Array.foldr_eq_foldr_data, -Array.size_toArray]
 
 /-! ### bind  -/
 
@@ -104,7 +157,7 @@ The following operations are given `@[csimp]` replacements below:
 
 @[csimp] theorem bind_eq_bindTR : @List.bind = @bindTR := by
   funext α β as f
-  let rec go : ∀ as acc, bindTR.go f as acc = acc.toList ++ as.bind f
+  let rec go : ∀ as acc, bindTR.go f as acc = acc.data ++ as.bind f
     | [], acc => by simp [bindTR.go, bind]
     | x::xs, acc => by simp [bindTR.go, bind, go xs]
   exact (go as #[]).symm
@@ -117,6 +170,40 @@ The following operations are given `@[csimp]` replacements below:
 @[csimp] theorem join_eq_joinTR : @join = @joinTR := by
   funext α l; rw [← List.bind_id, List.bind_eq_bindTR]; rfl
 
+/-! ### replicate -/
+
+/-- Tail-recursive version of `List.replicate`. -/
+def replicateTR {α : Type u} (n : Nat) (a : α) : List α :=
+  let rec loop : Nat → List α → List α
+    | 0, as => as
+    | n+1, as => loop n (a::as)
+  loop n []
+
+theorem replicateTR_loop_replicate_eq (a : α) (m n : Nat) :
+  replicateTR.loop a n (replicate m a) = replicate (n + m) a := by
+  induction n generalizing m with simp [replicateTR.loop]
+  | succ n ih => simp [Nat.succ_add]; exact ih (m+1)
+
+theorem replicateTR_loop_eq : ∀ n, replicateTR.loop a n acc = replicate n a ++ acc
+  | 0 => rfl
+  | n+1 => by rw [← replicateTR_loop_replicate_eq _ 1 n, replicate, replicate,
+    replicateTR.loop, replicateTR_loop_eq n, replicateTR_loop_eq n, append_assoc]; rfl
+
+@[csimp] theorem replicate_eq_replicateTR : @List.replicate = @List.replicateTR := by
+  apply funext; intro α; apply funext; intro n; apply funext; intro a
+  exact (replicateTR_loop_replicate_eq _ 0 n).symm
+
+/-! ## Additional functions -/
+
+/-! ### leftpad -/
+
+/-- Optimized version of `leftpad`. -/
+@[inline] def leftpadTR (n : Nat) (a : α) (l : List α) : List α :=
+  replicateTR.loop a (n - length l) l
+
+@[csimp] theorem leftpad_eq_leftpadTR : @leftpad = @leftpadTR := by
+  funext α n a l; simp [leftpad, leftpadTR, replicateTR_loop_eq]
+
 /-! ## Sublists -/
 
 /-! ### take -/
@@ -132,7 +219,7 @@ The following operations are given `@[csimp]` replacements below:
 
 @[csimp] theorem take_eq_takeTR : @take = @takeTR := by
   funext α n l; simp [takeTR]
-  suffices ∀ xs acc, l = acc.toList ++ xs → takeTR.go l xs n acc = acc.toList ++ xs.take n from
+  suffices ∀ xs acc, l = acc.data ++ xs → takeTR.go l xs n acc = acc.data ++ xs.take n from
     (this l #[] (by simp)).symm
   intro xs; induction xs generalizing n with intro acc
   | nil => cases n <;> simp [take, takeTR.go]
@@ -153,13 +240,13 @@ The following operations are given `@[csimp]` replacements below:
 
 @[csimp] theorem takeWhile_eq_takeWhileTR : @takeWhile = @takeWhileTR := by
   funext α p l; simp [takeWhileTR]
-  suffices ∀ xs acc, l = acc.toList ++ xs →
-      takeWhileTR.go p l xs acc = acc.toList ++ xs.takeWhile p from
+  suffices ∀ xs acc, l = acc.data ++ xs →
+      takeWhileTR.go p l xs acc = acc.data ++ xs.takeWhile p from
     (this l #[] (by simp)).symm
   intro xs; induction xs with intro acc
   | nil => simp [takeWhile, takeWhileTR.go]
   | cons x xs IH =>
-    simp only [takeWhileTR.go, Array.toListImpl_eq, takeWhile]
+    simp only [takeWhileTR.go, Array.toList_eq, takeWhile]
     split
     · intro h; rw [IH] <;> simp_all
     · simp [*]
@@ -186,8 +273,8 @@ The following operations are given `@[csimp]` replacements below:
 
 @[csimp] theorem replace_eq_replaceTR : @List.replace = @replaceTR := by
   funext α _ l b c; simp [replaceTR]
-  suffices ∀ xs acc, l = acc.toList ++ xs →
-      replaceTR.go l b c xs acc = acc.toList ++ xs.replace b c from
+  suffices ∀ xs acc, l = acc.data ++ xs →
+      replaceTR.go l b c xs acc = acc.data ++ xs.replace b c from
     (this l #[] (by simp)).symm
   intro xs; induction xs with intro acc
   | nil => simp [replace, replaceTR.go]
@@ -209,7 +296,7 @@ The following operations are given `@[csimp]` replacements below:
 
 @[csimp] theorem erase_eq_eraseTR : @List.erase = @eraseTR := by
   funext α _ l a; simp [eraseTR]
-  suffices ∀ xs acc, l = acc.toList ++ xs → eraseTR.go l a xs acc = acc.toList ++ xs.erase a from
+  suffices ∀ xs acc, l = acc.data ++ xs → eraseTR.go l a xs acc = acc.data ++ xs.erase a from
     (this l #[] (by simp)).symm
   intro xs; induction xs with intro acc h
   | nil => simp [List.erase, eraseTR.go, h]
@@ -229,8 +316,8 @@ The following operations are given `@[csimp]` replacements below:
 
 @[csimp] theorem eraseP_eq_erasePTR : @eraseP = @erasePTR := by
   funext α p l; simp [erasePTR]
-  let rec go (acc) : ∀ xs, l = acc.toList ++ xs →
-    erasePTR.go p l xs acc = acc.toList ++ xs.eraseP p
+  let rec go (acc) : ∀ xs, l = acc.data ++ xs →
+    erasePTR.go p l xs acc = acc.data ++ xs.eraseP p
   | [] => fun h => by simp [erasePTR.go, eraseP, h]
   | x::xs => by
     simp [erasePTR.go, eraseP]; cases p x <;> simp
@@ -250,7 +337,7 @@ The following operations are given `@[csimp]` replacements below:
 
 @[csimp] theorem eraseIdx_eq_eraseIdxTR : @eraseIdx = @eraseIdxTR := by
   funext α l n; simp [eraseIdxTR]
-  suffices ∀ xs acc, l = acc.toList ++ xs → eraseIdxTR.go l xs n acc = acc.toList ++ xs.eraseIdx n from
+  suffices ∀ xs acc, l = acc.data ++ xs → eraseIdxTR.go l xs n acc = acc.data ++ xs.eraseIdx n from
     (this l #[] (by simp)).symm
   intro xs; induction xs generalizing n with intro acc h
   | nil => simp [eraseIdx, eraseIdxTR.go, h]
@@ -274,13 +361,59 @@ The following operations are given `@[csimp]` replacements below:
 
 @[csimp] theorem zipWith_eq_zipWithTR : @zipWith = @zipWithTR := by
   funext α β γ f as bs
-  let rec go : ∀ as bs acc, zipWithTR.go f as bs acc = acc.toList ++ as.zipWith f bs
+  let rec go : ∀ as bs acc, zipWithTR.go f as bs acc = acc.data ++ as.zipWith f bs
     | [], _, acc | _::_, [], acc => by simp [zipWithTR.go, zipWith]
     | a::as, b::bs, acc => by simp [zipWithTR.go, zipWith, go as bs]
   exact (go as bs #[]).symm
 
+/-! ### unzip -/
+
+/-- Tail recursive version of `List.unzip`. -/
+def unzipTR (l : List (α × β)) : List α × List β :=
+  l.foldr (fun (a, b) (al, bl) => (a::al, b::bl)) ([], [])
+
+@[csimp] theorem unzip_eq_unzipTR : @unzip = @unzipTR := by
+  funext α β l; simp [unzipTR]; induction l <;> simp [*]
+
 /-! ## Ranges and enumeration -/
 
+/-! ### range' -/
+
+/-- Optimized version of `range'`. -/
+@[inline] def range'TR (s n : Nat) (step : Nat := 1) : List Nat := go n (s + step * n) [] where
+  /-- Auxiliary for `range'TR`: `range'TR.go n e = [e-n, ..., e-1] ++ acc`. -/
+  go : Nat → Nat → List Nat → List Nat
+  | 0, _, acc => acc
+  | n+1, e, acc => go n (e-step) ((e-step) :: acc)
+
+@[csimp] theorem range'_eq_range'TR : @range' = @range'TR := by
+  funext s n step
+  let rec go (s) : ∀ n m,
+    range'TR.go step n (s + step * n) (range' (s + step * n) m step) = range' s (n + m) step
+  | 0, m => by simp [range'TR.go]
+  | n+1, m => by
+    simp [range'TR.go]
+    rw [Nat.mul_succ, ← Nat.add_assoc, Nat.add_sub_cancel, Nat.add_right_comm n]
+    exact go s n (m + 1)
+  exact (go s n 0).symm
+
+/-! ### iota -/
+
+/-- Tail-recursive version of `List.iota`. -/
+def iotaTR (n : Nat) : List Nat :=
+  let rec go : Nat → List Nat → List Nat
+    | 0, r => r.reverse
+    | m@(n+1), r => go n (m::r)
+  go n []
+
+@[csimp]
+theorem iota_eq_iotaTR : @iota = @iotaTR :=
+  have aux (n : Nat) (r : List Nat) : iotaTR.go n r = r.reverse ++ iota n := by
+    induction n generalizing r with
+    | zero => simp [iota, iotaTR.go]
+    | succ n ih => simp [iota, iotaTR.go, ih, append_assoc]
+  funext fun n => by simp [iotaTR, aux]
+
 /-! ### enumFrom -/
 
 /-- Tail recursive version of `List.enumFrom`. -/
@@ -296,11 +429,25 @@ def enumFromTR (n : Nat) (l : List α) : List (Nat × α) :=
     | a::as, n => by
       rw [← show _ + as.length = n + (a::as).length from Nat.succ_add .., foldr, go as]
       simp [enumFrom, f]
-  rw [Array.foldr_eq_foldr_toList]
+  rw [Array.foldr_eq_foldr_data]
   simp [go]
 
 /-! ## Other list operations -/
 
+/-! ### intersperse -/
+
+/-- Tail recursive version of `List.intersperse`. -/
+def intersperseTR (sep : α) : List α → List α
+  | [] => []
+  | [x] => [x]
+  | x::y::xs => x :: sep :: y :: xs.foldr (fun a r => sep :: a :: r) []
+
+@[csimp] theorem intersperse_eq_intersperseTR : @intersperse = @intersperseTR := by
+  funext α sep l; simp [intersperseTR]
+  match l with
+  | [] | [_] => rfl
+  | x::y::xs => simp [intersperse]; induction xs generalizing y <;> simp [*]
+
 /-! ### intercalate -/
 
 /-- Tail recursive version of `List.intercalate`. -/
@@ -322,7 +469,7 @@ where
   | [_] => simp
   | x::y::xs =>
     let rec go {acc x} : ∀ xs,
-      intercalateTR.go sep.toArray x xs acc = acc.toList ++ join (intersperse sep (x::xs))
+      intercalateTR.go sep.toArray x xs acc = acc.data ++ join (intersperse sep (x::xs))
     | [] => by simp [intercalateTR.go]
     | _::_ => by simp [intercalateTR.go, go]
     simp [intersperse, go]

src/Init/Data/List/MinMax.lean

@@ -51,7 +51,7 @@ theorem minimum?_mem [Min α] (min_eq_or : ∀ a b : α, min a b = a ∨ min a b
 
 theorem le_minimum?_iff [Min α] [LE α]
     (le_min_iff : ∀ a b c : α, a ≤ min b c ↔ a ≤ b ∧ a ≤ c) :
-    {xs : List α} → xs.minimum? = some a → ∀ {x}, x ≤ a ↔ ∀ b, b ∈ xs → x ≤ b
+    {xs : List α} → xs.minimum? = some a → ∀ x, x ≤ a ↔ ∀ b, b ∈ xs → x ≤ b
   | nil => by simp
   | cons x xs => by
     rw [minimum?]
@@ -72,13 +72,13 @@ theorem minimum?_eq_some_iff [Min α] [LE α] [anti : Antisymm ((· : α) ≤ ·
     (min_eq_or : ∀ a b : α, min a b = a ∨ min a b = b)
     (le_min_iff : ∀ a b c : α, a ≤ min b c ↔ a ≤ b ∧ a ≤ c) {xs : List α} :
     xs.minimum? = some a ↔ a ∈ xs ∧ ∀ b, b ∈ xs → a ≤ b := by
-  refine ⟨fun h => ⟨minimum?_mem min_eq_or h, (le_minimum?_iff le_min_iff h).1 (le_refl _)⟩, ?_⟩
+  refine ⟨fun h => ⟨minimum?_mem min_eq_or h, (le_minimum?_iff le_min_iff h _).1 (le_refl _)⟩, ?_⟩
   intro ⟨h₁, h₂⟩
   cases xs with
   | nil => simp at h₁
   | cons x xs =>
     exact congrArg some <| anti.1
-      ((le_minimum?_iff le_min_iff (xs := x::xs) rfl).1 (le_refl _) _ h₁)
+      ((le_minimum?_iff le_min_iff (xs := x::xs) rfl _).1 (le_refl _) _ h₁)
       (h₂ _ (minimum?_mem min_eq_or (xs := x::xs) rfl))
 
 theorem minimum?_replicate [Min α] {n : Nat} {a : α} (w : min a a = a) :
@@ -116,7 +116,7 @@ theorem maximum?_mem [Max α] (min_eq_or : ∀ a b : α, max a b = a ∨ max a b
 
 theorem maximum?_le_iff [Max α] [LE α]
     (max_le_iff : ∀ a b c : α, max b c ≤ a ↔ b ≤ a ∧ c ≤ a) :
-    {xs : List α} → xs.maximum? = some a → ∀ {x}, a ≤ x ↔ ∀ b ∈ xs, b ≤ x
+    {xs : List α} → xs.maximum? = some a → ∀ x, a ≤ x ↔ ∀ b ∈ xs, b ≤ x
   | nil => by simp
   | cons x xs => by
     rw [maximum?]; rintro ⟨⟩ y
@@ -131,14 +131,14 @@ theorem maximum?_eq_some_iff [Max α] [LE α] [anti : Antisymm ((· : α) ≤ ·
     (max_eq_or : ∀ a b : α, max a b = a ∨ max a b = b)
     (max_le_iff : ∀ a b c : α, max b c ≤ a ↔ b ≤ a ∧ c ≤ a) {xs : List α} :
     xs.maximum? = some a ↔ a ∈ xs ∧ ∀ b ∈ xs, b ≤ a := by
-  refine ⟨fun h => ⟨maximum?_mem max_eq_or h, (maximum?_le_iff max_le_iff h).1 (le_refl _)⟩, ?_⟩
+  refine ⟨fun h => ⟨maximum?_mem max_eq_or h, (maximum?_le_iff max_le_iff h _).1 (le_refl _)⟩, ?_⟩
   intro ⟨h₁, h₂⟩
   cases xs with
   | nil => simp at h₁
   | cons x xs =>
     exact congrArg some <| anti.1
       (h₂ _ (maximum?_mem max_eq_or (xs := x::xs) rfl))
-      ((maximum?_le_iff max_le_iff (xs := x::xs) rfl).1 (le_refl _) _ h₁)
+      ((maximum?_le_iff max_le_iff (xs := x::xs) rfl _).1 (le_refl _) _ h₁)
 
 theorem maximum?_replicate [Max α] {n : Nat} {a : α} (w : max a a = a) :
     (replicate n a).maximum? = if n = 0 then none else some a := by

src/Init/Data/List/Nat.lean

@@ -7,6 +7,4 @@ prelude
 import Init.Data.List.Nat.Basic
 import Init.Data.List.Nat.Pairwise
 import Init.Data.List.Nat.Range
-import Init.Data.List.Nat.Sublist
 import Init.Data.List.Nat.TakeDrop
-import Init.Data.List.Nat.Count

src/Init/Data/List/Nat/Basic.lean

@@ -20,18 +20,10 @@ namespace List
 
 /-! ### filter -/
 
-theorem length_filter_lt_length_iff_exists {l} :
+theorem length_filter_lt_length_iff_exists (l) :
     length (filter p l) < length l ↔ ∃ x ∈ l, ¬p x := by
   simpa [length_eq_countP_add_countP p l, countP_eq_length_filter] using
-    countP_pos_iff (p := fun x => ¬p x)
-
-/-! ### reverse -/
-
-theorem getElem_eq_getElem_reverse {l : List α} {i} (h : i < l.length) :
-    l[i] = l.reverse[l.length - 1 - i]'(by simpa using Nat.sub_one_sub_lt_of_lt h) := by
-  rw [getElem_reverse]
-  congr
-  omega
+  countP_pos (fun x => ¬p x) (l := l)
 
 /-! ### leftpad -/
 
@@ -61,7 +53,7 @@ theorem mem_eraseIdx_iff_getElem? {x : α} {l} {k} : x ∈ eraseIdx l k ↔ ∃
   constructor
   · rintro ⟨_, h⟩; exact h
   · rintro h;
-    obtain ⟨h', -⟩ := getElem?_eq_some_iff.1 h
+    obtain ⟨h', -⟩ := getElem?_eq_some.1 h
     exact ⟨h', h⟩
 
 /-! ### minimum? -/

src/Init/Data/List/Nat/Count.lean

@@ -1,31 +0,0 @@
-/-
-Copyright (c) 2024 Kim Morrison. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.List.Count
-import Init.Data.Nat.Lemmas
-
-namespace List
-
-open Nat
-
-theorem countP_set (p : α → Bool) (l : List α) (i : Nat) (a : α) (h : i < l.length) :
-    (l.set i a).countP p = l.countP p - (if p l[i] then 1 else 0) + (if p a then 1 else 0) := by
-  induction l generalizing i with
-  | nil => simp at h
-  | cons x l ih =>
-    cases i with
-    | zero => simp [countP_cons]
-    | succ i =>
-      simp [add_one_lt_add_one_iff] at h
-      simp [countP_cons, ih _ h]
-      have : (if p l[i] = true then 1 else 0) ≤ l.countP p := boole_getElem_le_countP p l i h
-      omega
-
-theorem count_set [BEq α] (a b : α) (l : List α) (i : Nat) (h : i < l.length) :
-    (l.set i a).count b = l.count b - (if l[i] == b then 1 else 0) + (if a == b then 1 else 0) := by
-  simp [count_eq_countP, countP_set, h]
-
-end List

src/Init/Data/List/Nat/Pairwise.lean

@@ -50,7 +50,7 @@ theorem sublist_eq_map_getElem {l l' : List α} (h : l' <+ l) : ∃ is : List (F
   | cons₂ _ _ IH =>
     rcases IH with ⟨is,IH⟩
     refine ⟨⟨0, by simp [Nat.zero_lt_succ]⟩ :: is.map (·.succ), ?_⟩
-    simp [Function.comp_def, pairwise_map, IH, ← get_eq_getElem, get_cons_zero, get_cons_succ']
+    simp [Function.comp_def, pairwise_map, IH, ← get_eq_getElem]
 
 @[deprecated sublist_eq_map_getElem (since := "2024-07-30")]
 theorem sublist_eq_map_get (h : l' <+ l) : ∃ is : List (Fin l.length),

src/Init/Data/List/Nat/Range.lean

@@ -5,10 +5,7 @@ Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, M
 -/
 prelude
 import Init.Data.List.Nat.TakeDrop
-import Init.Data.List.Range
 import Init.Data.List.Pairwise
-import Init.Data.List.Find
-import Init.Data.List.Erase
 
 /-!
 # Lemmas about `List.range` and `List.enum`
@@ -22,28 +19,31 @@ open Nat
 
 /-! ### range' -/
 
+theorem range'_succ (s n step) : range' s (n + 1) step = s :: range' (s + step) n step := by
+  simp [range', Nat.add_succ, Nat.mul_succ]
+
+@[simp] theorem range'_one {s step : Nat} : range' s 1 step = [s] := rfl
+
+@[simp] theorem length_range' (s step) : ∀ n : Nat, length (range' s n step) = n
+  | 0 => rfl
+  | _ + 1 => congrArg succ (length_range' _ _ _)
+
+@[simp] theorem range'_eq_nil : range' s n step = [] ↔ n = 0 := by
+  rw [← length_eq_zero, length_range']
+
+theorem mem_range' : ∀{n}, m ∈ range' s n step ↔ ∃ i < n, m = s + step * i
+  | 0 => by simp [range', Nat.not_lt_zero]
+  | n + 1 => by
+    have h (i) : i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n := by
+      cases i <;> simp [Nat.succ_le, Nat.succ_inj']
+    simp [range', mem_range', Nat.lt_succ, h]; simp only [← exists_and_right, and_assoc]
+    rw [exists_comm]; simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
+
 @[simp] theorem mem_range'_1 : m ∈ range' s n ↔ s ≤ m ∧ m < s + n := by
   simp [mem_range']; exact ⟨
     fun ⟨i, h, e⟩ => e ▸ ⟨Nat.le_add_right .., Nat.add_lt_add_left h _⟩,
     fun ⟨h₁, h₂⟩ => ⟨m - s, Nat.sub_lt_left_of_lt_add h₁ h₂, (Nat.add_sub_cancel' h₁).symm⟩⟩
 
-theorem getLast?_range' (n : Nat) : (range' s n).getLast? = if n = 0 then none else some (s + n - 1) := by
-  induction n generalizing s with
-  | zero => simp
-  | succ n ih =>
-    rw [range'_succ, getLast?_cons, ih]
-    by_cases h : n = 0
-    · rw [if_pos h]
-      simp [h]
-    · rw [if_neg h]
-      simp
-      omega
-
-@[simp] theorem getLast_range' (n : Nat) (h) : (range' s n).getLast h = s + n - 1 := by
-  cases n with
-  | zero => simp at h
-  | succ n => simp [getLast?_range', getLast_eq_iff_getLast_eq_some]
-
 theorem pairwise_lt_range' s n (step := 1) (pos : 0 < step := by simp) :
     Pairwise (· < ·) (range' s n step) :=
   match s, n, step, pos with
@@ -71,87 +71,71 @@ theorem pairwise_le_range' s n (step := 1) :
 theorem nodup_range' (s n : Nat) (step := 1) (h : 0 < step := by simp) : Nodup (range' s n step) :=
   (pairwise_lt_range' s n step h).imp Nat.ne_of_lt
 
+@[simp]
+theorem map_add_range' (a) : ∀ s n step, map (a + ·) (range' s n step) = range' (a + s) n step
+  | _, 0, _ => rfl
+  | s, n + 1, step => by simp [range', map_add_range' _ (s + step) n step, Nat.add_assoc]
+
 theorem map_sub_range' (a s n : Nat) (h : a ≤ s) :
     map (· - a) (range' s n step) = range' (s - a) n step := by
   conv => lhs; rw [← Nat.add_sub_cancel' h]
   rw [← map_add_range', map_map, (?_ : _∘_ = _), map_id]
   funext x; apply Nat.add_sub_cancel_left
 
-@[simp] theorem range'_eq_singleton {s n a : Nat} : range' s n = [a] ↔ s = a ∧ n = 1 := by
-  rw [range'_eq_cons_iff]
-  simp only [nil_eq, range'_eq_nil, and_congr_right_iff]
-  rintro rfl
-  omega
+theorem range'_append : ∀ s m n step : Nat,
+    range' s m step ++ range' (s + step * m) n step = range' s (n + m) step
+  | s, 0, n, step => rfl
+  | s, m + 1, n, step => by
+    simpa [range', Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
+      using range'_append (s + step) m n step
 
-theorem range'_eq_append_iff : range' s n = xs ++ ys ↔ ∃ k, k ≤ n ∧ xs = range' s k ∧ ys = range' (s + k) (n - k) := by
-  induction n generalizing s xs ys with
-  | zero => simp
-  | succ n ih =>
-    simp only [range'_succ]
-    rw [cons_eq_append_iff]
-    constructor
-    · rintro (⟨rfl, rfl⟩ | ⟨a, rfl, h⟩)
-      · exact ⟨0, by simp [range'_succ]⟩
-      · simp only [ih] at h
-        obtain ⟨k, h, rfl, rfl⟩ := h
-        refine ⟨k + 1, ?_⟩
-        simp_all [range'_succ]
-        omega
-    · rintro ⟨k, h, rfl, rfl⟩
-      cases k with
-      | zero => simp [range'_succ]
-      | succ k =>
-        simp only [range'_succ, reduceCtorEq, false_and, cons.injEq, true_and, ih, range'_inj, exists_eq_left', or_true, and_true, false_or]
-        refine ⟨k, ?_⟩
-        simp_all
-        omega
+@[simp] theorem range'_append_1 (s m n : Nat) :
+    range' s m ++ range' (s + m) n = range' s (n + m) := by simpa using range'_append s m n 1
 
-@[simp] theorem find?_range'_eq_some {s n : Nat} {i : Nat} {p : Nat → Bool} :
-    (range' s n).find? p = some i ↔ p i ∧ i ∈ range' s n ∧ ∀ j, s ≤ j → j < i → !p j := by
-  rw [find?_eq_some]
-  simp only [Bool.not_eq_true', exists_and_right, mem_range'_1, and_congr_right_iff]
-  simp only [range'_eq_append_iff, eq_comm (a := i :: _), range'_eq_cons_iff]
-  intro h
-  constructor
-  · rintro ⟨as, ⟨x, k, h₁, rfl, rfl, h₂, rfl⟩, h₃⟩
-    constructor
-    · omega
-    · simpa using h₃
-  · rintro ⟨⟨h₁, h₂⟩, h₃⟩
-    refine ⟨range' s (i - s), ⟨⟨range' (i + 1) (n - (i - s) - 1), i - s, ?_⟩ , ?_⟩⟩
-    · simp; omega
-    · simp only [mem_range'_1, and_imp]
-      intro a a₁ a₂
-      exact h₃ a a₁ (by omega)
+theorem range'_sublist_right {s m n : Nat} : range' s m step <+ range' s n step ↔ m ≤ n :=
+  ⟨fun h => by simpa only [length_range'] using h.length_le,
+   fun h => by rw [← Nat.sub_add_cancel h, ← range'_append]; apply sublist_append_left⟩
 
-theorem find?_range'_eq_none {s n : Nat} {p : Nat → Bool} :
-    (range' s n).find? p = none ↔ ∀ i, s ≤ i → i < s + n → !p i := by
-  simp
+theorem range'_subset_right {s m n : Nat} (step0 : 0 < step) :
+    range' s m step ⊆ range' s n step ↔ m ≤ n := by
+  refine ⟨fun h => Nat.le_of_not_lt fun hn => ?_, fun h => (range'_sublist_right.2 h).subset⟩
+  have ⟨i, h', e⟩ := mem_range'.1 <| h <| mem_range'.2 ⟨_, hn, rfl⟩
+  exact Nat.ne_of_gt h' (Nat.eq_of_mul_eq_mul_left step0 (Nat.add_left_cancel e))
 
-theorem erase_range' :
-    (range' s n).erase i =
-      range' s (min n (i - s)) ++ range' (max s (i + 1)) (min s (i + 1) + n - (i + 1)) := by
-  by_cases h : i ∈ range' s n
-  · obtain ⟨as, bs, h₁, h₂⟩ := eq_append_cons_of_mem h
-    rw [h₁, erase_append_right _ h₂, erase_cons_head]
-    rw [range'_eq_append_iff] at h₁
-    obtain ⟨k, -, rfl, hbs⟩ := h₁
-    rw [eq_comm, range'_eq_cons_iff] at hbs
-    obtain ⟨rfl, -, rfl⟩ := hbs
-    simp at h
-    congr 2 <;> omega
-  · rw [erase_of_not_mem h]
-    simp only [mem_range'_1, not_and, Nat.not_lt] at h
-    by_cases h' : s ≤ i
-    · have p : min s (i + 1) + n - (i + 1) = 0 := by omega
-      simp [p]
-      omega
-    · have p : i - s = 0 := by omega
-      simp [p]
-      omega
+theorem range'_subset_right_1 {s m n : Nat} : range' s m ⊆ range' s n ↔ m ≤ n :=
+  range'_subset_right (by decide)
+
+theorem getElem?_range' (s step) :
+    ∀ {m n : Nat}, m < n → (range' s n step)[m]? = some (s + step * m)
+  | 0, n + 1, _ => by simp [range'_succ]
+  | m + 1, n + 1, h => by
+    simp only [range'_succ, getElem?_cons_succ]
+    exact (getElem?_range' (s + step) step (Nat.lt_of_add_lt_add_right h)).trans <| by
+      simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
+
+@[simp] theorem getElem_range' {n m step} (i) (H : i < (range' n m step).length) :
+    (range' n m step)[i] = n + step * i :=
+  (getElem?_eq_some.1 <| getElem?_range' n step (by simpa using H)).2
+
+theorem range'_concat (s n : Nat) : range' s (n + 1) step = range' s n step ++ [s + step * n] := by
+  rw [Nat.add_comm n 1]; exact (range'_append s n 1 step).symm
+
+theorem range'_1_concat (s n : Nat) : range' s (n + 1) = range' s n ++ [s + n] := by
+  simp [range'_concat]
 
 /-! ### range -/
 
+theorem range_loop_range' : ∀ s n : Nat, range.loop s (range' s n) = range' 0 (n + s)
+  | 0, n => rfl
+  | s + 1, n => by rw [← Nat.add_assoc, Nat.add_right_comm n s 1]; exact range_loop_range' s (n + 1)
+
+theorem range_eq_range' (n : Nat) : range n = range' 0 n :=
+  (range_loop_range' n 0).trans <| by rw [Nat.zero_add]
+
+theorem range_succ_eq_map (n : Nat) : range (n + 1) = 0 :: map succ (range n) := by
+  rw [range_eq_range', range_eq_range', range', Nat.add_comm, ← map_add_range']
+  congr; exact funext (Nat.add_comm 1)
+
 theorem reverse_range' : ∀ s n : Nat, reverse (range' s n) = map (s + n - 1 - ·) (range n)
   | s, 0 => rfl
   | s, n + 1 => by
@@ -159,6 +143,23 @@ theorem reverse_range' : ∀ s n : Nat, reverse (range' s n) = map (s + n - 1 -
       show s + (n + 1) - 1 = s + n from rfl, map, map_map]
     simp [reverse_range', Nat.sub_right_comm, Nat.sub_sub]
 
+theorem range'_eq_map_range (s n : Nat) : range' s n = map (s + ·) (range n) := by
+  rw [range_eq_range', map_add_range']; rfl
+
+@[simp] theorem length_range (n : Nat) : length (range n) = n := by
+  simp only [range_eq_range', length_range']
+
+@[simp] theorem range_eq_nil {n : Nat} : range n = [] ↔ n = 0 := by
+  rw [← length_eq_zero, length_range]
+
+@[simp]
+theorem range_sublist {m n : Nat} : range m <+ range n ↔ m ≤ n := by
+  simp only [range_eq_range', range'_sublist_right]
+
+@[simp]
+theorem range_subset {m n : Nat} : range m ⊆ range n ↔ m ≤ n := by
+  simp only [range_eq_range', range'_subset_right, lt_succ_self]
+
 @[simp]
 theorem mem_range {m n : Nat} : m ∈ range n ↔ m < n := by
   simp only [range_eq_range', mem_range'_1, Nat.zero_le, true_and, Nat.zero_add]
@@ -173,25 +174,27 @@ theorem pairwise_lt_range (n : Nat) : Pairwise (· < ·) (range n) := by
 theorem pairwise_le_range (n : Nat) : Pairwise (· ≤ ·) (range n) :=
   Pairwise.imp Nat.le_of_lt (pairwise_lt_range _)
 
+theorem getElem?_range {m n : Nat} (h : m < n) : (range n)[m]? = some m := by
+  simp [range_eq_range', getElem?_range' _ _ h]
+
+@[simp] theorem getElem_range {n : Nat} (m) (h : m < (range n).length) : (range n)[m] = m := by
+  simp [range_eq_range']
+
+theorem range_succ (n : Nat) : range (succ n) = range n ++ [n] := by
+  simp only [range_eq_range', range'_1_concat, Nat.zero_add]
+
+theorem range_add (a b : Nat) : range (a + b) = range a ++ (range b).map (a + ·) := by
+  rw [← range'_eq_map_range]
+  simpa [range_eq_range', Nat.add_comm] using (range'_append_1 0 a b).symm
+
 theorem take_range (m n : Nat) : take m (range n) = range (min m n) := by
   apply List.ext_getElem
   · simp
-  · simp (config := { contextual := true }) [getElem_take, Nat.lt_min]
+  · simp (config := { contextual := true }) [← getElem_take, Nat.lt_min]
 
 theorem nodup_range (n : Nat) : Nodup (range n) := by
   simp (config := {decide := true}) only [range_eq_range', nodup_range']
 
-@[simp] theorem find?_range_eq_some {n : Nat} {i : Nat} {p : Nat → Bool} :
-    (range n).find? p = some i ↔ p i ∧ i ∈ range n ∧ ∀ j, j < i → !p j := by
-  simp [range_eq_range']
-
-theorem find?_range_eq_none {n : Nat} {p : Nat → Bool} :
-    (range n).find? p = none ↔ ∀ i, i < n → !p i := by
-  simp
-
-theorem erase_range : (range n).erase i = range (min n i) ++ range' (i + 1) (n - (i + 1)) := by
-  simp [range_eq_range', erase_range']
-
 /-! ### iota -/
 
 theorem iota_eq_reverse_range' : ∀ n : Nat, iota n = reverse (range' 1 n)
@@ -200,49 +203,9 @@ theorem iota_eq_reverse_range' : ∀ n : Nat, iota n = reverse (range' 1 n)
 
 @[simp] theorem length_iota (n : Nat) : length (iota n) = n := by simp [iota_eq_reverse_range']
 
-@[simp] theorem iota_eq_nil {n : Nat} : iota n = [] ↔ n = 0 := by
-  cases n <;> simp
-
-theorem iota_ne_nil {n : Nat} : iota n ≠ [] ↔ n ≠ 0 := by
-  cases n <;> simp
-
 @[simp]
-theorem mem_iota {m n : Nat} : m ∈ iota n ↔ 0 < m ∧ m ≤ n := by
+theorem mem_iota {m n : Nat} : m ∈ iota n ↔ 1 ≤ m ∧ m ≤ n := by
   simp [iota_eq_reverse_range', Nat.add_comm, Nat.lt_succ]
-  omega
-
-@[simp] theorem iota_inj : iota n = iota n' ↔ n = n' := by
-  constructor
-  · intro h
-    have h' := congrArg List.length h
-    simp at h'
-    exact h'
-  · rintro rfl
-    simp
-
-theorem iota_eq_cons_iff : iota n = a :: xs ↔ n = a ∧ 0 < n ∧ xs = iota (n - 1) := by
-  simp [iota_eq_reverse_range']
-  simp [range'_eq_append_iff, reverse_eq_iff]
-  constructor
-  · rintro ⟨k, h, rfl, h'⟩
-    rw [eq_comm, range'_eq_singleton] at h'
-    simp only [reverse_inj, range'_inj, or_true, and_true]
-    omega
-  · rintro ⟨rfl, h, rfl⟩
-    refine ⟨n - 1, by simp, rfl, ?_⟩
-    rw [eq_comm, range'_eq_singleton]
-    omega
-
-theorem iota_eq_append_iff : iota n = xs ++ ys ↔ ∃ k, k ≤ n ∧ xs = (range' (k + 1) (n - k)).reverse ∧ ys = iota k := by
-  simp only [iota_eq_reverse_range']
-  rw [reverse_eq_append_iff]
-  rw [range'_eq_append_iff]
-  simp only [reverse_eq_iff]
-  constructor
-  · rintro ⟨k, h, rfl, rfl⟩
-    simp; omega
-  · rintro ⟨k, h, rfl, rfl⟩
-    exact ⟨k, by simp; omega⟩
 
 theorem pairwise_gt_iota (n : Nat) : Pairwise (· > ·) (iota n) := by
   simpa only [iota_eq_reverse_range', pairwise_reverse] using pairwise_lt_range' 1 n
@@ -250,83 +213,36 @@ theorem pairwise_gt_iota (n : Nat) : Pairwise (· > ·) (iota n) := by
 theorem nodup_iota (n : Nat) : Nodup (iota n) :=
   (pairwise_gt_iota n).imp Nat.ne_of_gt
 
-@[simp] theorem head?_iota (n : Nat) : (iota n).head? = if n = 0 then none else some n := by
-  cases n <;> simp
-
-@[simp] theorem head_iota (n : Nat) (h) : (iota n).head h = n := by
-  cases n with
-  | zero => simp at h
-  | succ n => simp
-
-@[simp] theorem reverse_iota : reverse (iota n) = range' 1 n := by
-  induction n with
-  | zero => simp
-  | succ n ih =>
-    rw [iota_succ, reverse_cons, ih, range'_1_concat, Nat.add_comm]
-
-@[simp] theorem getLast?_iota (n : Nat) : (iota n).getLast? = if n = 0 then none else some 1 := by
-  rw [getLast?_eq_head?_reverse]
-  simp [head?_range']
-
-@[simp] theorem getLast_iota (n : Nat) (h) : (iota n).getLast h = 1 := by
-  rw [getLast_eq_head_reverse]
-  simp
-
-theorem find?_iota_eq_none {n : Nat} (p : Nat → Bool) :
-    (iota n).find? p = none ↔ ∀ i, 0 < i → i ≤ n → !p i := by
-  simp
-
-@[simp] theorem find?_iota_eq_some {n : Nat} {i : Nat} {p : Nat → Bool} :
-    (iota n).find? p = some i ↔ p i ∧ i ∈ iota n ∧ ∀ j, i < j → j ≤ n → !p j := by
-  rw [find?_eq_some]
-  simp only [iota_eq_reverse_range', reverse_eq_append_iff, reverse_cons, append_assoc,
-    singleton_append, Bool.not_eq_true', exists_and_right, mem_reverse, mem_range'_1,
-    and_congr_right_iff]
-  intro h
-  constructor
-  · rintro ⟨as, ⟨xs, h⟩, h'⟩
-    constructor
-    · replace h : i ∈ range' 1 n := by
-        rw [h]
-        exact mem_append_cons_self
-      simpa using h
-    · rw [range'_eq_append_iff] at h
-      simp [reverse_eq_iff] at h
-      obtain ⟨k, h₁, rfl, h₂⟩ := h
-      rw [eq_comm, range'_eq_cons_iff, reverse_eq_iff] at h₂
-      obtain ⟨rfl, -, rfl⟩ := h₂
-      intro j j₁ j₂
-      apply h'
-      simp; omega
-  · rintro ⟨⟨i₁, i₂⟩, h⟩
-    refine ⟨(range' (i+1) (n-i)).reverse, ⟨(range' 1 (i-1)).reverse, ?_⟩, ?_⟩
-    · simp [← range'_succ]
-      rw [range'_eq_append_iff]
-      refine ⟨i-1, ?_⟩
-      constructor
-      · omega
-      · simp
-        omega
-    · simp
-      intros a a₁ a₂
-      apply h
-      · omega
-      · omega
-
 /-! ### enumFrom -/
 
 @[simp]
 theorem enumFrom_singleton (x : α) (n : Nat) : enumFrom n [x] = [(n, x)] :=
   rfl
 
-@[simp] theorem head?_enumFrom (n : Nat) (l : List α) :
-    (enumFrom n l).head? = l.head?.map fun a => (n, a) := by
-  simp [head?_eq_getElem?]
+@[simp]
+theorem enumFrom_eq_nil {n : Nat} {l : List α} : List.enumFrom n l = [] ↔ l = [] := by
+  cases l <;> simp
 
-@[simp] theorem getLast?_enumFrom (n : Nat) (l : List α) :
-    (enumFrom n l).getLast? = l.getLast?.map fun a => (n + l.length - 1, a) := by
-  simp [getLast?_eq_getElem?]
-  cases l <;> simp; omega
+@[simp] theorem enumFrom_length : ∀ {n} {l : List α}, (enumFrom n l).length = l.length
+  | _, [] => rfl
+  | _, _ :: _ => congrArg Nat.succ enumFrom_length
+
+@[simp]
+theorem getElem?_enumFrom :
+    ∀ n (l : List α) m, (enumFrom n l)[m]? = l[m]?.map fun a => (n + m, a)
+  | n, [], m => rfl
+  | n, a :: l, 0 => by simp
+  | n, a :: l, m + 1 => by
+    simp only [enumFrom_cons, getElem?_cons_succ]
+    exact (getElem?_enumFrom (n + 1) l m).trans <| by rw [Nat.add_right_comm]; rfl
+
+@[simp]
+theorem getElem_enumFrom (l : List α) (n) (i : Nat) (h : i < (l.enumFrom n).length) :
+    (l.enumFrom n)[i] = (n + i, l[i]'(by simpa [enumFrom_length] using h)) := by
+  simp only [enumFrom_length] at h
+  rw [getElem_eq_getElem?]
+  simp only [getElem?_enumFrom, getElem?_eq_getElem h]
+  simp
 
 theorem mk_add_mem_enumFrom_iff_getElem? {n i : Nat} {x : α} {l : List α} :
     (n + i, x) ∈ enumFrom n l ↔ l[i]? = some x := by
@@ -368,24 +284,17 @@ theorem enumFrom_map_snd : ∀ (n) (l : List α), map Prod.snd (enumFrom n l) =
 theorem snd_mem_of_mem_enumFrom {x : Nat × α} {n : Nat} {l : List α} (h : x ∈ enumFrom n l) : x.2 ∈ l :=
   enumFrom_map_snd n l ▸ mem_map_of_mem _ h
 
-theorem snd_eq_of_mem_enumFrom {x : Nat × α} {n : Nat} {l : List α} (h : x ∈ enumFrom n l) :
-    x.2 = l[x.1 - n]'(by have := le_fst_of_mem_enumFrom h; have := fst_lt_add_of_mem_enumFrom h; omega) := by
-  induction l generalizing n with
-  | nil => cases h
-  | cons hd tl ih =>
-    cases h with
-    | head h => simp
-    | tail h m =>
-      specialize ih m
-      have : x.1 - n = x.1 - (n + 1) + 1 := by
-        have := le_fst_of_mem_enumFrom m
-        omega
-      simp [this, ih]
+theorem mem_enumFrom {x : α} {i j : Nat} (xs : List α) (h : (i, x) ∈ xs.enumFrom j) :
+    j ≤ i ∧ i < j + xs.length ∧ x ∈ xs :=
+  ⟨le_fst_of_mem_enumFrom h, fst_lt_add_of_mem_enumFrom h, snd_mem_of_mem_enumFrom h⟩
 
-theorem mem_enumFrom {x : α} {i j : Nat} {xs : List α} (h : (i, x) ∈ xs.enumFrom j) :
-    j ≤ i ∧ i < j + xs.length ∧
-      x = xs[i - j]'(by have := le_fst_of_mem_enumFrom h; have := fst_lt_add_of_mem_enumFrom h; omega) :=
-  ⟨le_fst_of_mem_enumFrom h, fst_lt_add_of_mem_enumFrom h, snd_eq_of_mem_enumFrom h⟩
+theorem map_fst_add_enumFrom_eq_enumFrom (l : List α) (n k : Nat) :
+    map (Prod.map (· + n) id) (enumFrom k l) = enumFrom (n + k) l :=
+  ext_getElem? fun i ↦ by simp [(· ∘ ·), Nat.add_comm, Nat.add_left_comm]; rfl
+
+theorem map_fst_add_enum_eq_enumFrom (l : List α) (n : Nat) :
+    map (Prod.map (· + n) id) (enum l) = enumFrom n l :=
+  map_fst_add_enumFrom_eq_enumFrom l _ _
 
 theorem enumFrom_cons' (n : Nat) (x : α) (xs : List α) :
     enumFrom n (x :: xs) = (n, x) :: (enumFrom n xs).map (Prod.map (· + 1) id) := by
@@ -440,14 +349,6 @@ theorem getElem_enum (l : List α) (i : Nat) (h : i < l.enum.length) :
     l.enum[i] = (i, l[i]'(by simpa [enum_length] using h)) := by
   simp [enum]
 
-@[simp] theorem head?_enum (l : List α) :
-    l.enum.head? = l.head?.map fun a => (0, a) := by
-  simp [head?_eq_getElem?]
-
-@[simp] theorem getLast?_enum (l : List α) :
-    l.enum.getLast? = l.getLast?.map fun a => (l.length - 1, a) := by
-  simp [getLast?_eq_getElem?]
-
 theorem mk_mem_enum_iff_getElem? {i : Nat} {x : α} {l : List α} : (i, x) ∈ enum l ↔ l[i]? = x := by
   simp [enum, mk_mem_enumFrom_iff_le_and_getElem?_sub]
 
@@ -460,14 +361,6 @@ theorem fst_lt_of_mem_enum {x : Nat × α} {l : List α} (h : x ∈ enum l) : x.
 theorem snd_mem_of_mem_enum {x : Nat × α} {l : List α} (h : x ∈ enum l) : x.2 ∈ l :=
   snd_mem_of_mem_enumFrom h
 
-theorem snd_eq_of_mem_enum {x : Nat × α} {l : List α} (h : x ∈ enum l) :
-    x.2 = l[x.1]'(fst_lt_of_mem_enum h) :=
-  snd_eq_of_mem_enumFrom h
-
-theorem mem_enum {x : α} {i : Nat} {xs : List α} (h : (i, x) ∈ xs.enum) :
-    i < xs.length ∧ x = xs[i]'(fst_lt_of_mem_enum h) :=
-  by simpa using mem_enumFrom h
-
 theorem map_enum (f : α → β) (l : List α) : map (Prod.map id f) (enum l) = enum (map f l) :=
   map_enumFrom f 0 l
 

src/Init/Data/List/Nat/Sublist.lean

@@ -1,174 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.List.Sublist
-import Init.Data.List.Nat.Basic
-import Init.Data.List.Nat.TakeDrop
-import Init.Data.Nat.Lemmas
-
-/-!
-# Further lemmas about `List.IsSuffix` / `List.IsPrefix` / `List.IsInfix`.
-
-These are in a separate file from most of the lemmas about `List.IsSuffix`
-as they required importing more lemmas about natural numbers, and use `omega`.
--/
-
-namespace List
-
-theorem IsSuffix.getElem {x y : List α} (h : x <:+ y) {n} (hn : n < x.length) :
-    x[n] = y[y.length - x.length + n]'(by have := h.length_le; omega) := by
-  rw [getElem_eq_getElem_reverse, h.reverse.getElem, getElem_reverse]
-  congr
-  have := h.length_le
-  omega
-
-theorem isSuffix_iff : l₁ <:+ l₂ ↔
-    l₁.length ≤ l₂.length ∧ ∀ i (h : i < l₁.length), l₂[i + l₂.length - l₁.length]? = some l₁[i] := by
-  suffices l₁.length ≤ l₂.length ∧ l₁ <:+ l₂ ↔
-      l₁.length ≤ l₂.length ∧ ∀ i (h : i < l₁.length), l₂[i + l₂.length - l₁.length]? = some l₁[i] by
-    constructor
-    · intro h
-      exact this.mp ⟨h.length_le, h⟩
-    · intro h
-      exact (this.mpr h).2
-  simp only [and_congr_right_iff]
-  intro le
-  rw [← reverse_prefix, isPrefix_iff]
-  simp only [length_reverse]
-  constructor
-  · intro w i h
-    specialize w (l₁.length - 1 - i) (by omega)
-    rw [getElem?_reverse (by omega)] at w
-    have p : l₂.length - 1 - (l₁.length - 1 - i) = i + l₂.length - l₁.length := by omega
-    rw [p] at w
-    rw [w, getElem_reverse]
-    congr
-    omega
-  · intro w i h
-    rw [getElem?_reverse]
-    specialize w (l₁.length - 1 - i) (by omega)
-    have p : l₁.length - 1 - i + l₂.length - l₁.length = l₂.length - 1 - i := by omega
-    rw [p] at w
-    rw [w, getElem_reverse]
-    exact Nat.lt_of_lt_of_le h le
-
-theorem isInfix_iff : l₁ <:+: l₂ ↔
-    ∃ k, l₁.length + k ≤ l₂.length ∧ ∀ i (h : i < l₁.length), l₂[i + k]? = some l₁[i] := by
-  constructor
-  · intro h
-    obtain ⟨t, p, s⟩ := infix_iff_suffix_prefix.mp h
-    refine ⟨t.length - l₁.length, by have := p.length_le; have := s.length_le; omega, ?_⟩
-    rw [isSuffix_iff] at p
-    obtain ⟨p', p⟩ := p
-    rw [isPrefix_iff] at s
-    intro i h
-    rw [s _ (by omega)]
-    specialize p i (by omega)
-    rw [Nat.add_sub_assoc (by omega)] at p
-    rw [← getElem?_eq_getElem, p]
-  · rintro ⟨k, le, w⟩
-    refine ⟨l₂.take k, l₂.drop (k + l₁.length), ?_⟩
-    ext1 i
-    rw [getElem?_append]
-    split
-    · rw [getElem?_append]
-      split
-      · rw [getElem?_take]; simp_all; omega
-      · simp_all
-        have p : i = (i - k) + k := by omega
-        rw [p, w _ (by omega), getElem?_eq_getElem]
-        · congr 2
-          omega
-        · omega
-    · rw [getElem?_drop]
-      congr
-      simp_all
-      omega
-
-theorem suffix_iff_eq_append : l₁ <:+ l₂ ↔ take (length l₂ - length l₁) l₂ ++ l₁ = l₂ :=
-  ⟨by rintro ⟨r, rfl⟩; simp only [length_append, Nat.add_sub_cancel_right, take_left], fun e =>
-    ⟨_, e⟩⟩
-
-theorem prefix_take_iff {x y : List α} {n : Nat} : x <+: y.take n ↔ x <+: y ∧ x.length ≤ n := by
-  constructor
-  · intro h
-    constructor
-    · exact List.IsPrefix.trans h <| List.take_prefix n y
-    · replace h := h.length_le
-      rw [length_take, Nat.le_min] at h
-      exact h.left
-  · intro ⟨hp, hl⟩
-    have hl' := hp.length_le
-    rw [List.prefix_iff_eq_take] at *
-    rw [hp, List.take_take]
-    simp [Nat.min_eq_left, hl, hl']
-
-theorem suffix_iff_eq_drop : l₁ <:+ l₂ ↔ l₁ = drop (length l₂ - length l₁) l₂ :=
-  ⟨fun h => append_cancel_left <| (suffix_iff_eq_append.1 h).trans (take_append_drop _ _).symm,
-    fun e => e.symm ▸ drop_suffix _ _⟩
-
-theorem prefix_take_le_iff {L : List α} (hm : m < L.length) :
-    L.take m <+: L.take n ↔ m ≤ n := by
-  simp only [prefix_iff_eq_take, length_take]
-  induction m generalizing L n with
-  | zero => simp [Nat.min_eq_left, eq_self_iff_true, Nat.zero_le, take]
-  | succ m IH =>
-    cases L with
-    | nil => simp_all
-    | cons l ls =>
-      cases n with
-      | zero =>
-        simp
-      | succ n =>
-        simp only [length_cons, Nat.succ_eq_add_one, Nat.add_lt_add_iff_right] at hm
-        simp [← @IH n ls hm, Nat.min_eq_left, Nat.le_of_lt hm]
-
-@[simp] theorem append_left_sublist_self {xs : List α} (ys : List α) : xs ++ ys <+ ys ↔ xs = [] := by
-  constructor
-  · intro h
-    replace h := h.length_le
-    simp only [length_append] at h
-    have : xs.length = 0 := by omega
-    simp_all
-  · rintro rfl
-    simp
-@[simp] theorem append_right_sublist_self (xs : List α) {ys : List α} : xs ++ ys <+ xs ↔ ys = [] := by
-  constructor
-  · intro h
-    replace h := h.length_le
-    simp only [length_append] at h
-    have : ys.length = 0 := by omega
-    simp_all
-  · rintro rfl
-    simp
-
-theorem append_sublist_of_sublist_left {xs ys zs : List α} (h : zs <+ xs) :
-    xs ++ ys <+ zs ↔ ys = [] ∧ xs = zs := by
-  constructor
-  · intro h'
-    have hl := h.length_le
-    have hl' := h'.length_le
-    simp only [length_append] at hl'
-    have : ys.length = 0 := by omega
-    simp_all only [Nat.add_zero, length_eq_zero, true_and, append_nil]
-    exact Sublist.eq_of_length_le h' hl
-  · rintro ⟨rfl, rfl⟩
-    simp
-
-theorem append_sublist_of_sublist_right {xs ys zs : List α} (h : zs <+ ys) :
-    xs ++ ys <+ zs ↔ xs = [] ∧ ys = zs := by
-  constructor
-  · intro h'
-    have hl := h.length_le
-    have hl' := h'.length_le
-    simp only [length_append] at hl'
-    have : xs.length = 0 := by omega
-    simp_all only [Nat.zero_add, length_eq_zero, true_and, append_nil]
-    exact Sublist.eq_of_length_le h' hl
-  · rintro ⟨rfl, rfl⟩
-    simp
-
-end List

src/Init/Data/List/Nat/TakeDrop.lean

@@ -5,8 +5,6 @@ Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, M
 -/
 prelude
 import Init.Data.List.Zip
-import Init.Data.List.Sublist
-import Init.Data.List.Find
 import Init.Data.Nat.Lemmas
 
 /-!
@@ -36,23 +34,23 @@ theorem length_take_of_le (h : n ≤ length l) : length (take n l) = n := by sim
 
 /-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
 length `> i`. Version designed to rewrite from the big list to the small list. -/
-theorem getElem_take' (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
+theorem getElem_take (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
     L[i] = (L.take j)[i]'(length_take .. ▸ Nat.lt_min.mpr ⟨hj, hi⟩) :=
-  getElem_of_eq (take_append_drop j L).symm _ ▸ getElem_append_left ..
+  getElem_of_eq (take_append_drop j L).symm _ ▸ getElem_append ..
 
 /-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
 length `> i`. Version designed to rewrite from the small list to the big list. -/
-theorem getElem_take (L : List α) {j i : Nat} {h : i < (L.take j).length} :
+theorem getElem_take' (L : List α) {j i : Nat} {h : i < (L.take j).length} :
     (L.take j)[i] =
     L[i]'(Nat.lt_of_lt_of_le h (length_take_le' _ _)) := by
-  rw [length_take, Nat.lt_min] at h; rw [getElem_take' L _ h.1]
+  rw [length_take, Nat.lt_min] at h; rw [getElem_take L _ h.1]
 
 /-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
 length `> i`. Version designed to rewrite from the big list to the small list. -/
-@[deprecated getElem_take' (since := "2024-06-12")]
+@[deprecated getElem_take (since := "2024-06-12")]
 theorem get_take (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
     get L ⟨i, hi⟩ = get (L.take j) ⟨i, length_take .. ▸ Nat.lt_min.mpr ⟨hj, hi⟩⟩ := by
-  simp [getElem_take' _ hi hj]
+  simp [getElem_take _ hi hj]
 
 /-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
 length `> i`. Version designed to rewrite from the small list to the big list. -/
@@ -60,7 +58,7 @@ length `> i`. Version designed to rewrite from the small list to the big list. -
 theorem get_take' (L : List α) {j i} :
     get (L.take j) i =
     get L ⟨i.1, Nat.lt_of_lt_of_le i.2 (length_take_le' _ _)⟩ := by
-  simp [getElem_take]
+  simp [getElem_take']
 
 theorem getElem?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
     (l.take n)[m]? = none :=
@@ -71,20 +69,20 @@ theorem get?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
     (l.take n).get? m = none := by
   simp [getElem?_take_eq_none h]
 
-theorem getElem?_take {l : List α} {n m : Nat} :
+theorem getElem?_take_eq_if {l : List α} {n m : Nat} :
     (l.take n)[m]? = if m < n then l[m]? else none := by
   split
-  · next h => exact getElem?_take_of_lt h
+  · next h => exact getElem?_take h
   · next h => exact getElem?_take_eq_none (Nat.le_of_not_lt h)
 
-@[deprecated getElem?_take (since := "2024-06-12")]
+@[deprecated getElem?_take_eq_if (since := "2024-06-12")]
 theorem get?_take_eq_if {l : List α} {n m : Nat} :
     (l.take n).get? m = if m < n then l.get? m else none := by
-  simp [getElem?_take]
+  simp [getElem?_take_eq_if]
 
 theorem head?_take {l : List α} {n : Nat} :
     (l.take n).head? = if n = 0 then none else l.head? := by
-  simp [head?_eq_getElem?, getElem?_take]
+  simp [head?_eq_getElem?, getElem?_take_eq_if]
   split
   · rw [if_neg (by omega)]
   · rw [if_pos (by omega)]
@@ -96,7 +94,7 @@ theorem head_take {l : List α} {n : Nat} (h : l.take n ≠ []) :
   simp_all
 
 theorem getLast?_take {l : List α} : (l.take n).getLast? = if n = 0 then none else l[n - 1]?.or l.getLast? := by
-  rw [getLast?_eq_getElem?, getElem?_take, length_take]
+  rw [getLast?_eq_getElem?, getElem?_take_eq_if, length_take]
   split
   · rw [if_neg (by omega)]
     rw [Nat.min_def]
@@ -110,7 +108,7 @@ theorem getLast?_take {l : List α} : (l.take n).getLast? = if n = 0 then none e
 
 theorem getLast_take {l : List α} (h : l.take n ≠ []) :
     (l.take n).getLast h = l[n - 1]?.getD (l.getLast (by simp_all)) := by
-  rw [getLast_eq_getElem, getElem_take]
+  rw [getLast_eq_getElem, getElem_take']
   simp [length_take, Nat.min_def]
   simp at h
   split
@@ -129,7 +127,7 @@ theorem take_take : ∀ (n m) (l : List α), take n (take m l) = take (min n m)
 theorem take_set_of_lt (a : α) {n m : Nat} (l : List α) (h : m < n) :
     (l.set n a).take m = l.take m :=
   List.ext_getElem? fun i => by
-    rw [getElem?_take, getElem?_take]
+    rw [getElem?_take_eq_if, getElem?_take_eq_if]
     split
     · next h' => rw [getElem?_set_ne (by omega)]
     · rfl
@@ -191,20 +189,15 @@ theorem dropLast_take {n : Nat} {l : List α} (h : n < l.length) :
     (l.take n).dropLast = l.take (n - 1) := by
   simp only [dropLast_eq_take, length_take, Nat.le_of_lt h, Nat.min_eq_left, take_take, sub_le]
 
-@[deprecated map_eq_append_iff (since := "2024-09-05")] abbrev map_eq_append_split := @map_eq_append_iff
-
-theorem take_prefix_take_left (l : List α) {m n : Nat} (h : m ≤ n) : take m l <+: take n l := by
-  rw [isPrefix_iff]
-  intro i w
-  rw [getElem?_take_of_lt, getElem_take, getElem?_eq_getElem]
-  simp only [length_take] at w
-  exact Nat.lt_of_lt_of_le (Nat.lt_of_lt_of_le w (Nat.min_le_left _ _)) h
-
-theorem take_sublist_take_left (l : List α) {m n : Nat} (h : m ≤ n) : take m l <+ take n l :=
-  (take_prefix_take_left l h).sublist
-
-theorem take_subset_take_left (l : List α) {m n : Nat} (h : m ≤ n) : take m l ⊆ take n l :=
-  (take_sublist_take_left l h).subset
+theorem map_eq_append_split {f : α → β} {l : List α} {s₁ s₂ : List β}
+    (h : map f l = s₁ ++ s₂) : ∃ l₁ l₂, l = l₁ ++ l₂ ∧ map f l₁ = s₁ ∧ map f l₂ = s₂ := by
+  have := h
+  rw [← take_append_drop (length s₁) l] at this ⊢
+  rw [map_append] at this
+  refine ⟨_, _, rfl, append_inj this ?_⟩
+  rw [length_map, length_take, Nat.min_eq_left]
+  rw [← length_map l f, h, length_append]
+  apply Nat.le_add_right
 
 /-! ### drop -/
 
@@ -216,27 +209,26 @@ theorem lt_length_drop (L : List α) {i j : Nat} (h : i + j < L.length) : j < (L
 
 /-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
 dropping the first `i` elements. Version designed to rewrite from the big list to the small list. -/
-theorem getElem_drop' (L : List α) {i j : Nat} (h : i + j < L.length) :
+theorem getElem_drop (L : List α) {i j : Nat} (h : i + j < L.length) :
     L[i + j] = (L.drop i)[j]'(lt_length_drop L h) := by
   have : i ≤ L.length := Nat.le_trans (Nat.le_add_right _ _) (Nat.le_of_lt h)
-  rw [getElem_of_eq (take_append_drop i L).symm h, getElem_append_right]
-  · simp [Nat.min_eq_left this, Nat.add_sub_cancel_left]
-  · simp [Nat.min_eq_left this, Nat.le_add_right]
+  rw [getElem_of_eq (take_append_drop i L).symm h, getElem_append_right'] <;>
+    simp [Nat.min_eq_left this, Nat.add_sub_cancel_left, Nat.le_add_right]
 
 /-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
 dropping the first `i` elements. Version designed to rewrite from the big list to the small list. -/
-@[deprecated getElem_drop' (since := "2024-06-12")]
+@[deprecated getElem_drop (since := "2024-06-12")]
 theorem get_drop (L : List α) {i j : Nat} (h : i + j < L.length) :
     get L ⟨i + j, h⟩ = get (L.drop i) ⟨j, lt_length_drop L h⟩ := by
-  simp [getElem_drop']
+  simp [getElem_drop]
 
 /-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
 dropping the first `i` elements. Version designed to rewrite from the small list to the big list. -/
-@[simp] theorem getElem_drop (L : List α) {i : Nat} {j : Nat} {h : j < (L.drop i).length} :
+theorem getElem_drop' (L : List α) {i : Nat} {j : Nat} {h : j < (L.drop i).length} :
     (L.drop i)[j] = L[i + j]'(by
       rw [Nat.add_comm]
       exact Nat.add_lt_of_lt_sub (length_drop i L ▸ h)) := by
-  rw [getElem_drop']
+  rw [getElem_drop]
 
 /-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
 dropping the first `i` elements. Version designed to rewrite from the small list to the big list. -/
@@ -245,12 +237,12 @@ theorem get_drop' (L : List α) {i j} :
     get (L.drop i) j = get L ⟨i + j, by
       rw [Nat.add_comm]
       exact Nat.add_lt_of_lt_sub (length_drop i L ▸ j.2)⟩ := by
-  simp
+  simp [getElem_drop']
 
 @[simp]
 theorem getElem?_drop (L : List α) (i j : Nat) : (L.drop i)[j]? = L[i + j]? := by
   ext
-  simp only [getElem?_eq_some_iff, getElem_drop, Option.mem_def]
+  simp only [getElem?_eq_some, getElem_drop', Option.mem_def]
   constructor <;> intro ⟨h, ha⟩
   · exact ⟨_, ha⟩
   · refine ⟨?_, ha⟩
@@ -262,26 +254,6 @@ theorem getElem?_drop (L : List α) (i j : Nat) : (L.drop i)[j]? = L[i + j]? :=
 theorem get?_drop (L : List α) (i j : Nat) : get? (L.drop i) j = get? L (i + j) := by
   simp
 
-theorem mem_take_iff_getElem {l : List α} {a : α} :
-    a ∈ l.take n ↔ ∃ (i : Nat) (hm : i < min n l.length), l[i] = a := by
-  rw [mem_iff_getElem]
-  constructor
-  · rintro ⟨i, hm, rfl⟩
-    simp at hm
-    refine ⟨i, by omega, by rw [getElem_take]⟩
-  · rintro ⟨i, hm, rfl⟩
-    refine ⟨i, by simpa, by rw [getElem_take]⟩
-
-theorem mem_drop_iff_getElem {l : List α} {a : α} :
-    a ∈ l.drop n ↔ ∃ (i : Nat) (hm : i + n < l.length), l[n + i] = a := by
-  rw [mem_iff_getElem]
-  constructor
-  · rintro ⟨i, hm, rfl⟩
-    simp at hm
-    refine ⟨i, by omega, by rw [getElem_drop]⟩
-  · rintro ⟨i, hm, rfl⟩
-    refine ⟨i, by simp; omega, by rw [getElem_drop]⟩
-
 theorem head?_drop (l : List α) (n : Nat) :
     (l.drop n).head? = l[n]? := by
   rw [head?_eq_getElem?, getElem?_drop, Nat.add_zero]
@@ -289,7 +261,7 @@ theorem head?_drop (l : List α) (n : Nat) :
 theorem head_drop {l : List α} {n : Nat} (h : l.drop n ≠ []) :
     (l.drop n).head h = l[n]'(by simp_all) := by
   have w : n < l.length := length_lt_of_drop_ne_nil h
-  simpa [getElem?_eq_getElem, h, w, head_eq_iff_head?_eq_some] using head?_drop l n
+  simpa [head?_eq_head, getElem?_eq_getElem, h, w] using head?_drop l n
 
 theorem getLast?_drop {l : List α} : (l.drop n).getLast? = if l.length ≤ n then none else l.getLast? := by
   rw [getLast?_eq_getElem?, getElem?_drop]
@@ -302,7 +274,7 @@ theorem getLast?_drop {l : List α} : (l.drop n).getLast? = if l.length ≤ n th
 
 theorem getLast_drop {l : List α} (h : l.drop n ≠ []) :
     (l.drop n).getLast h = l.getLast (ne_nil_of_length_pos (by simp at h; omega)) := by
-  simp only [ne_eq, drop_eq_nil_iff] at h
+  simp only [ne_eq, drop_eq_nil_iff_le] at h
   apply Option.some_inj.1
   simp only [← getLast?_eq_getLast, getLast?_drop, ite_eq_right_iff]
   omega
@@ -347,11 +319,11 @@ theorem set_eq_take_append_cons_drop {l : List α} {n : Nat} {a : α} :
   split <;> rename_i h
   · ext1 m
     by_cases h' : m < n
-    · rw [getElem?_append_left (by simp [length_take]; omega), getElem?_set_ne (by omega),
-        getElem?_take_of_lt h']
+    · rw [getElem?_append (by simp [length_take]; omega), getElem?_set_ne (by omega),
+        getElem?_take h']
     · by_cases h'' : m = n
       · subst h''
-        rw [getElem?_set_self ‹_›, getElem?_append_right, length_take,
+        rw [getElem?_set_eq ‹_›, getElem?_append_right, length_take,
           Nat.min_eq_left (by omega), Nat.sub_self, getElem?_cons_zero]
         rw [length_take]
         exact Nat.min_le_left m l.length
@@ -387,125 +359,40 @@ theorem drop_take : ∀ (m n : Nat) (l : List α), drop n (take m l) = take (m -
     congr 1
     omega
 
-theorem take_reverse {α} {xs : List α} {n : Nat} :
+theorem take_reverse {α} {xs : List α} {n : Nat} (h : n ≤ xs.length) :
     xs.reverse.take n = (xs.drop (xs.length - n)).reverse := by
-  by_cases h : n ≤ xs.length
-  · induction xs generalizing n <;>
-      simp only [reverse_cons, drop, reverse_nil, Nat.zero_sub, length, take_nil]
-    next xs_hd xs_tl xs_ih =>
-    cases Nat.lt_or_eq_of_le h with
-    | inl h' =>
-      have h' := Nat.le_of_succ_le_succ h'
-      rw [take_append_of_le_length, xs_ih h']
-      rw [show xs_tl.length + 1 - n = succ (xs_tl.length - n) from _, drop]
-      · rwa [succ_eq_add_one, Nat.sub_add_comm]
-      · rwa [length_reverse]
-    | inr h' =>
-      subst h'
-      rw [length, Nat.sub_self, drop]
-      suffices xs_tl.length + 1 = (xs_tl.reverse ++ [xs_hd]).length by
-        rw [this, take_length, reverse_cons]
-      rw [length_append, length_reverse]
-      rfl
-  · have w : xs.length - n = 0 := by omega
-    rw [take_of_length_le, w, drop_zero]
-    simp
-    omega
+  induction xs generalizing n <;>
+    simp only [reverse_cons, drop, reverse_nil, Nat.zero_sub, length, take_nil]
+  next xs_hd xs_tl xs_ih =>
+  cases Nat.lt_or_eq_of_le h with
+  | inl h' =>
+    have h' := Nat.le_of_succ_le_succ h'
+    rw [take_append_of_le_length, xs_ih h']
+    rw [show xs_tl.length + 1 - n = succ (xs_tl.length - n) from _, drop]
+    · rwa [succ_eq_add_one, Nat.sub_add_comm]
+    · rwa [length_reverse]
+  | inr h' =>
+    subst h'
+    rw [length, Nat.sub_self, drop]
+    suffices xs_tl.length + 1 = (xs_tl.reverse ++ [xs_hd]).length by
+      rw [this, take_length, reverse_cons]
+    rw [length_append, length_reverse]
+    rfl
 
-theorem drop_reverse {α} {xs : List α} {n : Nat} :
+@[deprecated (since := "2024-06-15")] abbrev reverse_take := @take_reverse
+
+theorem drop_reverse {α} {xs : List α} {n : Nat} (h : n ≤ xs.length) :
     xs.reverse.drop n = (xs.take (xs.length - n)).reverse := by
-  by_cases h : n ≤ xs.length
-  · conv =>
-      rhs
-      rw [← reverse_reverse xs]
-    rw [← reverse_reverse xs] at h
-    generalize xs.reverse = xs' at h ⊢
-    rw [take_reverse]
-    · simp only [length_reverse, reverse_reverse] at *
-      congr
-      omega
-  · have w : xs.length - n = 0 := by omega
-    rw [drop_of_length_le, w, take_zero, reverse_nil]
-    simp
-    omega
-
-theorem reverse_take {l : List α} {n : Nat} :
-    (l.take n).reverse = l.reverse.drop (l.length - n) := by
-  by_cases h : n ≤ l.length
-  · rw [drop_reverse]
+  conv =>
+    rhs
+    rw [← reverse_reverse xs]
+  rw [← reverse_reverse xs] at h
+  generalize xs.reverse = xs' at h ⊢
+  rw [take_reverse]
+  · simp only [length_reverse, reverse_reverse] at *
     congr
     omega
-  · have w : l.length - n = 0 := by omega
-    rw [w, drop_zero, take_of_length_le]
-    omega
-
-theorem reverse_drop {l : List α} {n : Nat} :
-    (l.drop n).reverse = l.reverse.take (l.length - n) := by
-  by_cases h : n ≤ l.length
-  · rw [take_reverse]
-    congr
-    omega
-  · have w : l.length - n = 0 := by omega
-    rw [w, take_zero, drop_of_length_le, reverse_nil]
-    omega
-
-/-! ### findIdx -/
-
-theorem false_of_mem_take_findIdx {xs : List α} {p : α → Bool} (h : x ∈ xs.take (xs.findIdx p)) :
-    p x = false := by
-  simp only [mem_take_iff_getElem, forall_exists_index] at h
-  obtain ⟨i, h, rfl⟩ := h
-  exact not_of_lt_findIdx (by omega)
-
-@[simp] theorem findIdx_take {xs : List α} {n : Nat} {p : α → Bool} :
-    (xs.take n).findIdx p = min n (xs.findIdx p) := by
-  induction xs generalizing n with
-  | nil => simp
-  | cons x xs ih =>
-    cases n
-    · simp
-    · simp only [take_succ_cons, findIdx_cons, ih, cond_eq_if]
-      split
-      · simp
-      · rw [Nat.add_min_add_right]
-
-@[simp] theorem findIdx?_take {xs : List α} {n : Nat} {p : α → Bool} :
-    (xs.take n).findIdx? p = (xs.findIdx? p).bind (Option.guard (fun i => i < n)) := by
-  induction xs generalizing n with
-  | nil => simp
-  | cons x xs ih =>
-    cases n
-    · simp
-    · simp only [take_succ_cons, findIdx?_cons]
-      split
-      · simp
-      · simp [ih, Option.guard_comp, Option.bind_map]
-
-@[simp] theorem min_findIdx_findIdx {xs : List α} {p q : α → Bool} :
-    min (xs.findIdx p) (xs.findIdx q) = xs.findIdx (fun a => p a || q a) := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp [findIdx_cons, cond_eq_if, Bool.not_eq_eq_eq_not, Bool.not_true]
-    split <;> split <;> simp_all [Nat.add_min_add_right]
-
-/-! ### takeWhile -/
-
-theorem takeWhile_eq_take_findIdx_not {xs : List α} {p : α → Bool} :
-    takeWhile p xs = take (xs.findIdx (fun a => !p a)) xs := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [takeWhile_cons, ih, findIdx_cons, cond_eq_if, Bool.not_eq_eq_eq_not, Bool.not_true]
-    split <;> simp_all
-
-theorem dropWhile_eq_drop_findIdx_not {xs : List α} {p : α → Bool} :
-    dropWhile p xs = drop (xs.findIdx (fun a => !p a)) xs := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [dropWhile_cons, ih, findIdx_cons, cond_eq_if, Bool.not_eq_eq_eq_not, Bool.not_true]
-    split <;> simp_all
+  · simp only [length_reverse, sub_le]
 
 /-! ### rotateLeft -/
 

src/Init/Data/List/Pairwise.lean

@@ -5,7 +5,6 @@ Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, M
 -/
 prelude
 import Init.Data.List.Sublist
-import Init.Data.List.Attach
 
 /-!
 # Lemmas about `List.Pairwise` and `List.Nodup`.
@@ -113,7 +112,7 @@ theorem Pairwise.map {S : β → β → Prop} (f : α → β) (H : ∀ a b : α,
     (p : Pairwise R l) : Pairwise S (map f l) :=
   pairwise_map.2 <| p.imp (H _ _)
 
-theorem pairwise_filterMap {f : β → Option α} {l : List β} :
+theorem pairwise_filterMap (f : β → Option α) {l : List β} :
     Pairwise R (filterMap f l) ↔ Pairwise (fun a a' : β => ∀ b ∈ f a, ∀ b' ∈ f a', R b b') l := by
   let _S (a a' : β) := ∀ b ∈ f a, ∀ b' ∈ f a', R b b'
   simp only [Option.mem_def]
@@ -123,7 +122,7 @@ theorem pairwise_filterMap {f : β → Option α} {l : List β} :
   match e : f a with
   | none =>
     rw [filterMap_cons_none e, pairwise_cons]
-    simp only [e, false_implies, implies_true, true_and, IH, reduceCtorEq]
+    simp only [e, false_implies, implies_true, true_and, IH]
   | some b =>
     rw [filterMap_cons_some e]
     simpa [IH, e] using fun _ =>
@@ -132,11 +131,11 @@ theorem pairwise_filterMap {f : β → Option α} {l : List β} :
 theorem Pairwise.filterMap {S : β → β → Prop} (f : α → Option β)
     (H : ∀ a a' : α, R a a' → ∀ b ∈ f a, ∀ b' ∈ f a', S b b') {l : List α} (p : Pairwise R l) :
     Pairwise S (filterMap f l) :=
-  pairwise_filterMap.2 <| p.imp (H _ _)
+  (pairwise_filterMap _).2 <| p.imp (H _ _)
 
 @[deprecated Pairwise.filterMap (since := "2024-07-29")] abbrev Pairwise.filter_map := @Pairwise.filterMap
 
-theorem pairwise_filter {p : α → Prop} [DecidablePred p] {l : List α} :
+theorem pairwise_filter (p : α → Prop) [DecidablePred p] {l : List α} :
     Pairwise R (filter p l) ↔ Pairwise (fun x y => p x → p y → R x y) l := by
   rw [← filterMap_eq_filter, pairwise_filterMap]
   simp
@@ -226,43 +225,6 @@ theorem pairwise_iff_forall_sublist : l.Pairwise R ↔ (∀ {a b}, [a,b] <+ l
         intro a b hab
         apply h; exact hab.cons _
 
-theorem Pairwise.rel_of_mem_take_of_mem_drop
-    {l : List α} (h : l.Pairwise R) (hx : x ∈ l.take n) (hy : y ∈ l.drop n) : R x y := by
-  apply pairwise_iff_forall_sublist.mp h
-  rw [← take_append_drop n l, sublist_append_iff]
-  refine ⟨[x], [y], rfl, by simpa, by simpa⟩
-
-theorem Pairwise.rel_of_mem_append
-    {l₁ l₂ : List α} (h : (l₁ ++ l₂).Pairwise R) (hx : x ∈ l₁) (hy : y ∈ l₂) : R x y := by
-  apply pairwise_iff_forall_sublist.mp h
-  rw [sublist_append_iff]
-  exact ⟨[x], [y], rfl, by simpa, by simpa⟩
-
-theorem pairwise_of_forall_mem_list {l : List α} {r : α → α → Prop} (h : ∀ a ∈ l, ∀ b ∈ l, r a b) :
-    l.Pairwise r := by
-  rw [pairwise_iff_forall_sublist]
-  intro a b hab
-  apply h <;> (apply hab.subset; simp)
-
-theorem pairwise_pmap {p : β → Prop} {f : ∀ b, p b → α} {l : List β} (h : ∀ x ∈ l, p x) :
-    Pairwise R (l.pmap f h) ↔
-      Pairwise (fun b₁ b₂ => ∀ (h₁ : p b₁) (h₂ : p b₂), R (f b₁ h₁) (f b₂ h₂)) l := by
-  induction l with
-  | nil => simp
-  | cons a l ihl =>
-    obtain ⟨_, hl⟩ : p a ∧ ∀ b, b ∈ l → p b := by simpa using h
-    simp only [ihl hl, pairwise_cons, exists₂_imp, pmap, and_congr_left_iff, mem_pmap]
-    refine fun _ => ⟨fun H b hb _ hpb => H _ _ hb rfl, ?_⟩
-    rintro H _ b hb rfl
-    exact H b hb _ _
-
-theorem Pairwise.pmap {l : List α} (hl : Pairwise R l) {p : α → Prop} {f : ∀ a, p a → β}
-    (h : ∀ x ∈ l, p x) {S : β → β → Prop}
-    (hS : ∀ ⦃x⦄ (hx : p x) ⦃y⦄ (hy : p y), R x y → S (f x hx) (f y hy)) :
-    Pairwise S (l.pmap f h) := by
-  refine (pairwise_pmap h).2 (Pairwise.imp_of_mem ?_ hl)
-  intros; apply hS; assumption
-
 /-! ### Nodup -/
 
 @[simp]

src/Init/Data/List/Perm.lean

@@ -1,463 +0,0 @@
-/-
-Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Leonardo de Moura, Jeremy Avigad, Mario Carneiro
--/
-prelude
-import Init.Data.List.Pairwise
-import Init.Data.List.Erase
-
-/-!
-# List Permutations
-
-This file introduces the `List.Perm` relation, which is true if two lists are permutations of one
-another.
-
-## Notation
-
-The notation `~` is used for permutation equivalence.
--/
-
-open Nat
-
-namespace List
-
-open Perm (swap)
-
-@[simp, refl] protected theorem Perm.refl : ∀ l : List α, l ~ l
-  | [] => .nil
-  | x :: xs => (Perm.refl xs).cons x
-
-protected theorem Perm.rfl {l : List α} : l ~ l := .refl _
-
-theorem Perm.of_eq (h : l₁ = l₂) : l₁ ~ l₂ := h ▸ .rfl
-
-protected theorem Perm.symm {l₁ l₂ : List α} (h : l₁ ~ l₂) : l₂ ~ l₁ := by
-  induction h with
-  | nil => exact nil
-  | cons _ _ ih => exact cons _ ih
-  | swap => exact swap ..
-  | trans _ _ ih₁ ih₂ => exact trans ih₂ ih₁
-
-theorem perm_comm {l₁ l₂ : List α} : l₁ ~ l₂ ↔ l₂ ~ l₁ := ⟨Perm.symm, Perm.symm⟩
-
-theorem Perm.swap' (x y : α) {l₁ l₂ : List α} (p : l₁ ~ l₂) : y :: x :: l₁ ~ x :: y :: l₂ :=
-  (swap ..).trans <| p.cons _ |>.cons _
-
-/--
-Similar to `Perm.recOn`, but the `swap` case is generalized to `Perm.swap'`,
-where the tail of the lists are not necessarily the same.
--/
-@[elab_as_elim] theorem Perm.recOnSwap'
-    {motive : (l₁ : List α) → (l₂ : List α) → l₁ ~ l₂ → Prop} {l₁ l₂ : List α} (p : l₁ ~ l₂)
-    (nil : motive [] [] .nil)
-    (cons : ∀ x {l₁ l₂}, (h : l₁ ~ l₂) → motive l₁ l₂ h → motive (x :: l₁) (x :: l₂) (.cons x h))
-    (swap' : ∀ x y {l₁ l₂}, (h : l₁ ~ l₂) → motive l₁ l₂ h →
-      motive (y :: x :: l₁) (x :: y :: l₂) (.swap' _ _ h))
-    (trans : ∀ {l₁ l₂ l₃}, (h₁ : l₁ ~ l₂) → (h₂ : l₂ ~ l₃) → motive l₁ l₂ h₁ → motive l₂ l₃ h₂ →
-      motive l₁ l₃ (.trans h₁ h₂)) : motive l₁ l₂ p :=
-  have motive_refl l : motive l l (.refl l) :=
-    List.recOn l nil fun x xs ih => cons x (.refl xs) ih
-  Perm.recOn p nil cons (fun x y l => swap' x y (.refl l) (motive_refl l)) trans
-
-theorem Perm.eqv (α) : Equivalence (@Perm α) := ⟨.refl, .symm, .trans⟩
-
-instance isSetoid (α) : Setoid (List α) := .mk Perm (Perm.eqv α)
-
-theorem Perm.mem_iff {a : α} {l₁ l₂ : List α} (p : l₁ ~ l₂) : a ∈ l₁ ↔ a ∈ l₂ := by
-  induction p with
-  | nil => rfl
-  | cons _ _ ih => simp only [mem_cons, ih]
-  | swap => simp only [mem_cons, or_left_comm]
-  | trans _ _ ih₁ ih₂ => simp only [ih₁, ih₂]
-
-theorem Perm.subset {l₁ l₂ : List α} (p : l₁ ~ l₂) : l₁ ⊆ l₂ := fun _ => p.mem_iff.mp
-
-theorem Perm.append_right {l₁ l₂ : List α} (t₁ : List α) (p : l₁ ~ l₂) : l₁ ++ t₁ ~ l₂ ++ t₁ := by
-  induction p with
-  | nil => rfl
-  | cons _ _ ih => exact cons _ ih
-  | swap => exact swap ..
-  | trans _ _ ih₁ ih₂ => exact trans ih₁ ih₂
-
-theorem Perm.append_left {t₁ t₂ : List α} : ∀ l : List α, t₁ ~ t₂ → l ++ t₁ ~ l ++ t₂
-  | [], p => p
-  | x :: xs, p => (p.append_left xs).cons x
-
-theorem Perm.append {l₁ l₂ t₁ t₂ : List α} (p₁ : l₁ ~ l₂) (p₂ : t₁ ~ t₂) : l₁ ++ t₁ ~ l₂ ++ t₂ :=
-  (p₁.append_right t₁).trans (p₂.append_left l₂)
-
-theorem Perm.append_cons (a : α) {h₁ h₂ t₁ t₂ : List α} (p₁ : h₁ ~ h₂) (p₂ : t₁ ~ t₂) :
-    h₁ ++ a :: t₁ ~ h₂ ++ a :: t₂ := p₁.append (p₂.cons a)
-
-@[simp] theorem perm_middle {a : α} : ∀ {l₁ l₂ : List α}, l₁ ++ a :: l₂ ~ a :: (l₁ ++ l₂)
-  | [], _ => .refl _
-  | b :: _, _ => (Perm.cons _ perm_middle).trans (swap a b _)
-
-@[simp] theorem perm_append_singleton (a : α) (l : List α) : l ++ [a] ~ a :: l :=
-  perm_middle.trans <| by rw [append_nil]
-
-theorem perm_append_comm : ∀ {l₁ l₂ : List α}, l₁ ++ l₂ ~ l₂ ++ l₁
-  | [], l₂ => by simp
-  | a :: t, l₂ => (perm_append_comm.cons _).trans perm_middle.symm
-
-theorem perm_append_comm_assoc (l₁ l₂ l₃ : List α) :
-    Perm (l₁ ++ (l₂ ++ l₃)) (l₂ ++ (l₁ ++ l₃)) := by
-  simpa only [List.append_assoc] using perm_append_comm.append_right _
-
-theorem concat_perm (l : List α) (a : α) : concat l a ~ a :: l := by simp
-
-theorem Perm.length_eq {l₁ l₂ : List α} (p : l₁ ~ l₂) : length l₁ = length l₂ := by
-  induction p with
-  | nil => rfl
-  | cons _ _ ih => simp only [length_cons, ih]
-  | swap => rfl
-  | trans _ _ ih₁ ih₂ => simp only [ih₁, ih₂]
-
-theorem Perm.eq_nil {l : List α} (p : l ~ []) : l = [] := eq_nil_of_length_eq_zero p.length_eq
-
-theorem Perm.nil_eq {l : List α} (p : [] ~ l) : [] = l := p.symm.eq_nil.symm
-
-@[simp] theorem perm_nil {l₁ : List α} : l₁ ~ [] ↔ l₁ = [] :=
-  ⟨fun p => p.eq_nil, fun e => e ▸ .rfl⟩
-
-@[simp] theorem nil_perm {l₁ : List α} : [] ~ l₁ ↔ l₁ = [] := perm_comm.trans perm_nil
-
-theorem not_perm_nil_cons (x : α) (l : List α) : ¬[] ~ x :: l := (nomatch ·.symm.eq_nil)
-
-theorem not_perm_cons_nil {l : List α} {a : α} : ¬(Perm (a::l) []) :=
-  fun h => by simpa using h.length_eq
-
-theorem Perm.isEmpty_eq {l l' : List α} (h : Perm l l') : l.isEmpty = l'.isEmpty := by
-  cases l <;> cases l' <;> simp_all
-
-@[simp] theorem reverse_perm : ∀ l : List α, reverse l ~ l
-  | [] => .nil
-  | a :: l => reverse_cons .. ▸ (perm_append_singleton _ _).trans ((reverse_perm l).cons a)
-
-theorem perm_cons_append_cons {l l₁ l₂ : List α} (a : α) (p : l ~ l₁ ++ l₂) :
-    a :: l ~ l₁ ++ a :: l₂ := (p.cons a).trans perm_middle.symm
-
-@[simp] theorem perm_replicate {n : Nat} {a : α} {l : List α} :
-    l ~ replicate n a ↔ l = replicate n a := by
-  refine ⟨fun p => eq_replicate_iff.2 ?_, fun h => h ▸ .rfl⟩
-  exact ⟨p.length_eq.trans <| length_replicate .., fun _b m => eq_of_mem_replicate <| p.subset m⟩
-
-@[simp] theorem replicate_perm {n : Nat} {a : α} {l : List α} :
-    replicate n a ~ l ↔ replicate n a = l := (perm_comm.trans perm_replicate).trans eq_comm
-
-@[simp] theorem perm_singleton {a : α} {l : List α} : l ~ [a] ↔ l = [a] := perm_replicate (n := 1)
-
-@[simp] theorem singleton_perm {a : α} {l : List α} : [a] ~ l ↔ [a] = l := replicate_perm (n := 1)
-
-theorem Perm.eq_singleton (h : l ~ [a]) : l = [a] := perm_singleton.mp h
-theorem Perm.singleton_eq (h : [a] ~ l) : [a] = l := singleton_perm.mp h
-
-theorem singleton_perm_singleton {a b : α} : [a] ~ [b] ↔ a = b := by simp
-
-theorem perm_cons_erase [DecidableEq α] {a : α} {l : List α} (h : a ∈ l) : l ~ a :: l.erase a :=
-  let ⟨_l₁, _l₂, _, e₁, e₂⟩ := exists_erase_eq h
-  e₂ ▸ e₁ ▸ perm_middle
-
-theorem Perm.filterMap (f : α → Option β) {l₁ l₂ : List α} (p : l₁ ~ l₂) :
-    filterMap f l₁ ~ filterMap f l₂ := by
-  induction p with
-  | nil => simp
-  | cons x _p IH => cases h : f x <;> simp [h, filterMap_cons, IH, Perm.cons]
-  | swap x y l₂ => cases hx : f x <;> cases hy : f y <;> simp [hx, hy, filterMap_cons, swap]
-  | trans _p₁ _p₂ IH₁ IH₂ => exact IH₁.trans IH₂
-
-theorem Perm.map (f : α → β) {l₁ l₂ : List α} (p : l₁ ~ l₂) : map f l₁ ~ map f l₂ :=
-  filterMap_eq_map f ▸ p.filterMap _
-
-theorem Perm.pmap {p : α → Prop} (f : ∀ a, p a → β) {l₁ l₂ : List α} (p : l₁ ~ l₂) {H₁ H₂} :
-    pmap f l₁ H₁ ~ pmap f l₂ H₂ := by
-  induction p with
-  | nil => simp
-  | cons x _p IH => simp [IH, Perm.cons]
-  | swap x y => simp [swap]
-  | trans _p₁ p₂ IH₁ IH₂ => exact IH₁.trans (IH₂ (H₁ := fun a m => H₂ a (p₂.subset m)))
-
-theorem Perm.filter (p : α → Bool) {l₁ l₂ : List α} (s : l₁ ~ l₂) :
-    filter p l₁ ~ filter p l₂ := by rw [← filterMap_eq_filter]; apply s.filterMap
-
-theorem filter_append_perm (p : α → Bool) (l : List α) :
-    filter p l ++ filter (fun x => !p x) l ~ l := by
-  induction l with
-  | nil => rfl
-  | cons x l ih =>
-    by_cases h : p x <;> simp [h]
-    · exact ih.cons x
-    · exact Perm.trans (perm_append_comm.trans (perm_append_comm.cons _)) (ih.cons x)
-
-theorem exists_perm_sublist {l₁ l₂ l₂' : List α} (s : l₁ <+ l₂) (p : l₂ ~ l₂') :
-    ∃ l₁', l₁' ~ l₁ ∧ l₁' <+ l₂' := by
-  induction p generalizing l₁ with
-  | nil => exact ⟨[], sublist_nil.mp s ▸ .rfl, nil_sublist _⟩
-  | cons x _ IH =>
-    match s with
-    | .cons _ s => let ⟨l₁', p', s'⟩ := IH s; exact ⟨l₁', p', s'.cons _⟩
-    | .cons₂ _ s => let ⟨l₁', p', s'⟩ := IH s; exact ⟨x :: l₁', p'.cons x, s'.cons₂ _⟩
-  | swap x y l' =>
-    match s with
-    | .cons _ (.cons _ s) => exact ⟨_, .rfl, (s.cons _).cons _⟩
-    | .cons _ (.cons₂ _ s) => exact ⟨x :: _, .rfl, (s.cons _).cons₂ _⟩
-    | .cons₂ _ (.cons _ s) => exact ⟨y :: _, .rfl, (s.cons₂ _).cons _⟩
-    | .cons₂ _ (.cons₂ _ s) => exact ⟨x :: y :: _, .swap .., (s.cons₂ _).cons₂ _⟩
-  | trans _ _ IH₁ IH₂ =>
-    let ⟨m₁, pm, sm⟩ := IH₁ s
-    let ⟨r₁, pr, sr⟩ := IH₂ sm
-    exact ⟨r₁, pr.trans pm, sr⟩
-
-theorem Perm.sizeOf_eq_sizeOf [SizeOf α] {l₁ l₂ : List α} (h : l₁ ~ l₂) :
-    sizeOf l₁ = sizeOf l₂ := by
-  induction h with
-  | nil => rfl
-  | cons _ _ h_sz₁₂ => simp [h_sz₁₂]
-  | swap => simp [Nat.add_left_comm]
-  | trans _ _ h_sz₁₂ h_sz₂₃ => simp [h_sz₁₂, h_sz₂₃]
-
-theorem Sublist.exists_perm_append {l₁ l₂ : List α} : l₁ <+ l₂ → ∃ l, l₂ ~ l₁ ++ l
-  | Sublist.slnil => ⟨nil, .rfl⟩
-  | Sublist.cons a s =>
-    let ⟨l, p⟩ := Sublist.exists_perm_append s
-    ⟨a :: l, (p.cons a).trans perm_middle.symm⟩
-  | Sublist.cons₂ a s =>
-    let ⟨l, p⟩ := Sublist.exists_perm_append s
-    ⟨l, p.cons a⟩
-
-theorem Perm.countP_eq (p : α → Bool) {l₁ l₂ : List α} (s : l₁ ~ l₂) :
-    countP p l₁ = countP p l₂ := by
-  simp only [countP_eq_length_filter]
-  exact (s.filter _).length_eq
-
-theorem Perm.countP_congr {l₁ l₂ : List α} (s : l₁ ~ l₂) {p p' : α → Bool}
-    (hp : ∀ x ∈ l₁, p x = p' x) : l₁.countP p = l₂.countP p' := by
-  rw [← s.countP_eq p']
-  clear s
-  induction l₁ with
-  | nil => rfl
-  | cons y s hs =>
-    simp only [mem_cons, forall_eq_or_imp] at hp
-    simp only [countP_cons, hs hp.2, hp.1]
-
-theorem countP_eq_countP_filter_add (l : List α) (p q : α → Bool) :
-    l.countP p = (l.filter q).countP p + (l.filter fun a => !q a).countP p :=
-  countP_append .. ▸ Perm.countP_eq _ (filter_append_perm _ _).symm
-
-theorem Perm.count_eq [DecidableEq α] {l₁ l₂ : List α} (p : l₁ ~ l₂) (a) :
-    count a l₁ = count a l₂ := p.countP_eq _
-
-theorem Perm.foldl_eq' {f : β → α → β} {l₁ l₂ : List α} (p : l₁ ~ l₂)
-    (comm : ∀ x ∈ l₁, ∀ y ∈ l₁, ∀ (z), f (f z x) y = f (f z y) x)
-    (init) : foldl f init l₁ = foldl f init l₂ := by
-  induction p using recOnSwap' generalizing init with
-  | nil => simp
-  | cons x _p IH =>
-    simp only [foldl]
-    apply IH; intros; apply comm <;> exact .tail _ ‹_›
-  | swap' x y _p IH =>
-    simp only [foldl]
-    rw [comm x (.tail _ <| .head _) y (.head _)]
-    apply IH; intros; apply comm <;> exact .tail _ (.tail _ ‹_›)
-  | trans p₁ _p₂ IH₁ IH₂ =>
-    refine (IH₁ comm init).trans (IH₂ ?_ _)
-    intros; apply comm <;> apply p₁.symm.subset <;> assumption
-
-theorem Perm.rec_heq {β : List α → Sort _} {f : ∀ a l, β l → β (a :: l)} {b : β []} {l l' : List α}
-    (hl : l ~ l') (f_congr : ∀ {a l l' b b'}, l ~ l' → HEq b b' → HEq (f a l b) (f a l' b'))
-    (f_swap : ∀ {a a' l b}, HEq (f a (a' :: l) (f a' l b)) (f a' (a :: l) (f a l b))) :
-    HEq (@List.rec α β b f l) (@List.rec α β b f l') := by
-  induction hl with
-  | nil => rfl
-  | cons a h ih => exact f_congr h ih
-  | swap a a' l => exact f_swap
-  | trans _h₁ _h₂ ih₁ ih₂ => exact ih₁.trans ih₂
-
-/-- Lemma used to destruct perms element by element. -/
-theorem perm_inv_core {a : α} {l₁ l₂ r₁ r₂ : List α} :
-    l₁ ++ a :: r₁ ~ l₂ ++ a :: r₂ → l₁ ++ r₁ ~ l₂ ++ r₂ := by
-  -- Necessary generalization for `induction`
-  suffices ∀ s₁ s₂ (_ : s₁ ~ s₂) {l₁ l₂ r₁ r₂},
-      l₁ ++ a :: r₁ = s₁ → l₂ ++ a :: r₂ = s₂ → l₁ ++ r₁ ~ l₂ ++ r₂ from (this _ _ · rfl rfl)
-  intro s₁ s₂ p
-  induction p using Perm.recOnSwap' with intro l₁ l₂ r₁ r₂ e₁ e₂
-  | nil =>
-    simp at e₁
-  | cons x p IH =>
-    cases l₁ <;> cases l₂ <;>
-      dsimp at e₁ e₂ <;> injections <;> subst_vars
-    · exact p
-    · exact p.trans perm_middle
-    · exact perm_middle.symm.trans p
-    · exact (IH rfl rfl).cons _
-  | swap' x y p IH =>
-    obtain _ | ⟨y, _ | ⟨z, l₁⟩⟩ := l₁
-      <;> obtain _ | ⟨u, _ | ⟨v, l₂⟩⟩ := l₂
-      <;> dsimp at e₁ e₂ <;> injections <;> subst_vars
-      <;> try exact p.cons _
-    · exact (p.trans perm_middle).cons u
-    · exact ((p.trans perm_middle).cons _).trans (swap _ _ _)
-    · exact (perm_middle.symm.trans p).cons y
-    · exact (swap _ _ _).trans ((perm_middle.symm.trans p).cons u)
-    · exact (IH rfl rfl).swap' _ _
-  | trans p₁ p₂ IH₁ IH₂ =>
-    subst e₁ e₂
-    obtain ⟨l₂, r₂, rfl⟩ := append_of_mem (a := a) (p₁.subset (by simp))
-    exact (IH₁ rfl rfl).trans (IH₂ rfl rfl)
-
-theorem Perm.cons_inv {a : α} {l₁ l₂ : List α} : a :: l₁ ~ a :: l₂ → l₁ ~ l₂ :=
-  perm_inv_core (l₁ := []) (l₂ := [])
-
-@[simp] theorem perm_cons (a : α) {l₁ l₂ : List α} : a :: l₁ ~ a :: l₂ ↔ l₁ ~ l₂ :=
-  ⟨.cons_inv, .cons a⟩
-
-theorem perm_append_left_iff {l₁ l₂ : List α} : ∀ l, l ++ l₁ ~ l ++ l₂ ↔ l₁ ~ l₂
-  | [] => .rfl
-  | a :: l => (perm_cons a).trans (perm_append_left_iff l)
-
-theorem perm_append_right_iff {l₁ l₂ : List α} (l) : l₁ ++ l ~ l₂ ++ l ↔ l₁ ~ l₂ := by
-  refine ⟨fun p => ?_, .append_right _⟩
-  exact (perm_append_left_iff _).1 <| perm_append_comm.trans <| p.trans perm_append_comm
-
-section DecidableEq
-
-variable [DecidableEq α]
-
-theorem Perm.erase (a : α) {l₁ l₂ : List α} (p : l₁ ~ l₂) : l₁.erase a ~ l₂.erase a :=
-  if h₁ : a ∈ l₁ then
-    have h₂ : a ∈ l₂ := p.subset h₁
-    .cons_inv <| (perm_cons_erase h₁).symm.trans <| p.trans (perm_cons_erase h₂)
-  else by
-    have h₂ : a ∉ l₂ := mt p.mem_iff.2 h₁
-    rw [erase_of_not_mem h₁, erase_of_not_mem h₂]; exact p
-
-theorem cons_perm_iff_perm_erase {a : α} {l₁ l₂ : List α} :
-    a :: l₁ ~ l₂ ↔ a ∈ l₂ ∧ l₁ ~ l₂.erase a := by
-  refine ⟨fun h => ?_, fun ⟨m, h⟩ => (h.cons a).trans (perm_cons_erase m).symm⟩
-  have : a ∈ l₂ := h.subset (mem_cons_self a l₁)
-  exact ⟨this, (h.trans <| perm_cons_erase this).cons_inv⟩
-
-theorem perm_iff_count {l₁ l₂ : List α} : l₁ ~ l₂ ↔ ∀ a, count a l₁ = count a l₂ := by
-  refine ⟨Perm.count_eq, fun H => ?_⟩
-  induction l₁ generalizing l₂ with
-  | nil =>
-    match l₂ with
-    | nil => rfl
-    | cons b l₂ =>
-      specialize H b
-      simp at H
-  | cons a l₁ IH =>
-    have : a ∈ l₂ := count_pos_iff.mp (by rw [← H]; simp)
-    refine ((IH fun b => ?_).cons a).trans (perm_cons_erase this).symm
-    specialize H b
-    rw [(perm_cons_erase this).count_eq] at H
-    by_cases h : b = a <;> simpa [h, count_cons, Nat.succ_inj'] using H
-
-theorem isPerm_iff : ∀ {l₁ l₂ : List α}, l₁.isPerm l₂ ↔ l₁ ~ l₂
-  | [], [] => by simp [isPerm, isEmpty]
-  | [], _ :: _ => by simp [isPerm, isEmpty, Perm.nil_eq]
-  | a :: l₁, l₂ => by simp [isPerm, isPerm_iff, cons_perm_iff_perm_erase]
-
-instance decidablePerm (l₁ l₂ : List α) : Decidable (l₁ ~ l₂) := decidable_of_iff _ isPerm_iff
-
-protected theorem Perm.insert (a : α) {l₁ l₂ : List α} (p : l₁ ~ l₂) :
-    l₁.insert a ~ l₂.insert a := by
-  if h : a ∈ l₁ then
-    simp [h, p.subset h, p]
-  else
-    have := p.cons a
-    simpa [h, mt p.mem_iff.2 h] using this
-
-theorem perm_insert_swap (x y : α) (l : List α) :
-    List.insert x (List.insert y l) ~ List.insert y (List.insert x l) := by
-  by_cases xl : x ∈ l <;> by_cases yl : y ∈ l <;> simp [xl, yl]
-  if xy : x = y then simp [xy] else
-  simp [List.insert, xl, yl, xy, Ne.symm xy]
-  constructor
-
-end DecidableEq
-
-theorem Perm.pairwise_iff {R : α → α → Prop} (S : ∀ {x y}, R x y → R y x) :
-    ∀ {l₁ l₂ : List α} (_p : l₁ ~ l₂), Pairwise R l₁ ↔ Pairwise R l₂ :=
-  suffices ∀ {l₁ l₂}, l₁ ~ l₂ → Pairwise R l₁ → Pairwise R l₂
-    from fun p => ⟨this p, this p.symm⟩
-  fun {l₁ l₂} p d => by
-    induction d generalizing l₂ with
-    | nil => rw [← p.nil_eq]; constructor
-    | cons h _ IH =>
-      have : _ ∈ l₂ := p.subset (mem_cons_self _ _)
-      obtain ⟨s₂, t₂, rfl⟩ := append_of_mem this
-      have p' := (p.trans perm_middle).cons_inv
-      refine (pairwise_middle S).2 (pairwise_cons.2 ⟨fun b m => ?_, IH p'⟩)
-      exact h _ (p'.symm.subset m)
-
-theorem Pairwise.perm {R : α → α → Prop} {l l' : List α} (hR : l.Pairwise R) (hl : l ~ l')
-    (hsymm : ∀ {x y}, R x y → R y x) : l'.Pairwise R := (hl.pairwise_iff hsymm).mp hR
-
-theorem Perm.pairwise {R : α → α → Prop} {l l' : List α} (hl : l ~ l') (hR : l.Pairwise R)
-    (hsymm : ∀ {x y}, R x y → R y x) : l'.Pairwise R := hR.perm hl hsymm
-
-/--
-If two lists are sorted by an antisymmetric relation, and permutations of each other,
-they must be equal.
--/
-theorem Perm.eq_of_sorted : ∀ {l₁ l₂ : List α}
-    (_ : ∀ a b, a ∈ l₁ → b ∈ l₂ → le a b → le b a → a = b)
-    (_ : l₁.Pairwise le) (_ : l₂.Pairwise le) (_ : l₁ ~ l₂), l₁ = l₂
-  | [], [], _, _, _, _ => rfl
-  | [], b :: l₂, _, _, _, h => by simp_all
-  | a :: l₁, [], _, _, _, h => by simp_all
-  | a :: l₁, b :: l₂, w, h₁, h₂, h => by
-    have am : a ∈ b :: l₂ := h.subset (mem_cons_self _ _)
-    have bm : b ∈ a :: l₁ := h.symm.subset (mem_cons_self _ _)
-    have ab : a = b := by
-      simp only [mem_cons] at am
-      rcases am with rfl | am
-      · rfl
-      · simp only [mem_cons] at bm
-        rcases bm with rfl | bm
-        · rfl
-        · exact w _ _ (mem_cons_self _ _) (mem_cons_self _ _)
-            (rel_of_pairwise_cons h₁ bm) (rel_of_pairwise_cons h₂ am)
-    subst ab
-    simp only [perm_cons] at h
-    have := Perm.eq_of_sorted
-      (fun x y hx hy => w x y (mem_cons_of_mem a hx) (mem_cons_of_mem a hy))
-      h₁.tail h₂.tail h
-    simp_all
-
-theorem Nodup.perm {l l' : List α} (hR : l.Nodup) (hl : l ~ l') : l'.Nodup :=
-  Pairwise.perm hR hl (by intro x y h h'; simp_all)
-
-theorem Perm.nodup {l l' : List α} (hl : l ~ l') (hR : l.Nodup) : l'.Nodup := hR.perm hl
-
-theorem Perm.nodup_iff {l₁ l₂ : List α} : l₁ ~ l₂ → (Nodup l₁ ↔ Nodup l₂) :=
-  Perm.pairwise_iff <| @Ne.symm α
-
-theorem Perm.join {l₁ l₂ : List (List α)} (h : l₁ ~ l₂) : l₁.join ~ l₂.join := by
-  induction h with
-  | nil => rfl
-  | cons _ _ ih => simp only [join_cons, perm_append_left_iff, ih]
-  | swap => simp only [join_cons, ← append_assoc, perm_append_right_iff]; exact perm_append_comm ..
-  | trans _ _ ih₁ ih₂ => exact trans ih₁ ih₂
-
-theorem Perm.bind_right {l₁ l₂ : List α} (f : α → List β) (p : l₁ ~ l₂) : l₁.bind f ~ l₂.bind f :=
-  (p.map _).join
-
-theorem Perm.eraseP (f : α → Bool) {l₁ l₂ : List α}
-    (H : Pairwise (fun a b => f a → f b → False) l₁) (p : l₁ ~ l₂) : eraseP f l₁ ~ eraseP f l₂ := by
-  induction p with
-  | nil => simp
-  | cons a p IH =>
-    if h : f a then simp [h, p]
-    else simp [h]; exact IH (pairwise_cons.1 H).2
-  | swap a b l =>
-    by_cases h₁ : f a <;> by_cases h₂ : f b <;> simp [h₁, h₂]
-    · cases (pairwise_cons.1 H).1 _ (mem_cons.2 (Or.inl rfl)) h₂ h₁
-    · apply swap
-  | trans p₁ _ IH₁ IH₂ =>
-    refine (IH₁ H).trans (IH₂ ((p₁.pairwise_iff ?_).1 H))
-    exact fun h h₁ h₂ => h h₂ h₁
-
-end List

src/Init/Data/List/Range.lean

@@ -1,230 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.Pairwise
-
-/-!
-# Lemmas about `List.range` and `List.enum`
-
-Most of the results are deferred to `Data.Init.List.Nat.Range`, where more results about
-natural arithmetic are available.
--/
-
-namespace List
-
-open Nat
-
-/-! ## Ranges and enumeration -/
-
-
-/-! ### range' -/
-
-theorem range'_succ (s n step) : range' s (n + 1) step = s :: range' (s + step) n step := by
-  simp [range', Nat.add_succ, Nat.mul_succ]
-
-@[simp] theorem length_range' (s step) : ∀ n : Nat, length (range' s n step) = n
-  | 0 => rfl
-  | _ + 1 => congrArg succ (length_range' _ _ _)
-
-@[simp] theorem range'_eq_nil : range' s n step = [] ↔ n = 0 := by
-  rw [← length_eq_zero, length_range']
-
-theorem range'_ne_nil (s : Nat) {n : Nat} : range' s n ≠ [] ↔ n ≠ 0 := by
-  cases n <;> simp
-
-@[simp] theorem range'_zero : range' s 0 = [] := by
-  simp
-
-@[simp] theorem range'_one {s step : Nat} : range' s 1 step = [s] := rfl
-
-@[simp] theorem range'_inj : range' s n = range' s' n' ↔ n = n' ∧ (n = 0 ∨ s = s') := by
-  constructor
-  · intro h
-    have h' := congrArg List.length h
-    simp at h'
-    subst h'
-    cases n with
-    | zero => simp
-    | succ n =>
-      simp only [range'_succ] at h
-      simp_all
-  · rintro ⟨rfl, rfl | rfl⟩ <;> simp
-
-theorem mem_range' : ∀{n}, m ∈ range' s n step ↔ ∃ i < n, m = s + step * i
-  | 0 => by simp [range', Nat.not_lt_zero]
-  | n + 1 => by
-    have h (i) : i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n := by
-      cases i <;> simp [Nat.succ_le, Nat.succ_inj']
-    simp [range', mem_range', Nat.lt_succ, h]; simp only [← exists_and_right, and_assoc]
-    rw [exists_comm]; simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
-
-theorem getElem?_range' (s step) :
-    ∀ {m n : Nat}, m < n → (range' s n step)[m]? = some (s + step * m)
-  | 0, n + 1, _ => by simp [range'_succ]
-  | m + 1, n + 1, h => by
-    simp only [range'_succ, getElem?_cons_succ]
-    exact (getElem?_range' (s + step) step (by exact succ_lt_succ_iff.mp h)).trans <| by
-      simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
-
-@[simp] theorem getElem_range' {n m step} (i) (H : i < (range' n m step).length) :
-    (range' n m step)[i] = n + step * i :=
-  (getElem?_eq_some_iff.1 <| getElem?_range' n step (by simpa using H)).2
-
-theorem head?_range' (n : Nat) : (range' s n).head? = if n = 0 then none else some s := by
-  induction n <;> simp_all [range'_succ, head?_append]
-
-@[simp] theorem head_range' (n : Nat) (h) : (range' s n).head h = s := by
-  repeat simp_all [head?_range', head_eq_iff_head?_eq_some]
-
-@[simp]
-theorem map_add_range' (a) : ∀ s n step, map (a + ·) (range' s n step) = range' (a + s) n step
-  | _, 0, _ => rfl
-  | s, n + 1, step => by simp [range', map_add_range' _ (s + step) n step, Nat.add_assoc]
-
-theorem range'_append : ∀ s m n step : Nat,
-    range' s m step ++ range' (s + step * m) n step = range' s (n + m) step
-  | s, 0, n, step => rfl
-  | s, m + 1, n, step => by
-    simpa [range', Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
-      using range'_append (s + step) m n step
-
-@[simp] theorem range'_append_1 (s m n : Nat) :
-    range' s m ++ range' (s + m) n = range' s (n + m) := by simpa using range'_append s m n 1
-
-theorem range'_sublist_right {s m n : Nat} : range' s m step <+ range' s n step ↔ m ≤ n :=
-  ⟨fun h => by simpa only [length_range'] using h.length_le,
-   fun h => by rw [← Nat.sub_add_cancel h, ← range'_append]; apply sublist_append_left⟩
-
-theorem range'_subset_right {s m n : Nat} (step0 : 0 < step) :
-    range' s m step ⊆ range' s n step ↔ m ≤ n := by
-  refine ⟨fun h => Nat.le_of_not_lt fun hn => ?_, fun h => (range'_sublist_right.2 h).subset⟩
-  have ⟨i, h', e⟩ := mem_range'.1 <| h <| mem_range'.2 ⟨_, hn, rfl⟩
-  exact Nat.ne_of_gt h' (Nat.eq_of_mul_eq_mul_left step0 (Nat.add_left_cancel e))
-
-theorem range'_subset_right_1 {s m n : Nat} : range' s m ⊆ range' s n ↔ m ≤ n :=
-  range'_subset_right (by decide)
-
-theorem range'_concat (s n : Nat) : range' s (n + 1) step = range' s n step ++ [s + step * n] := by
-  rw [Nat.add_comm n 1]; exact (range'_append s n 1 step).symm
-
-theorem range'_1_concat (s n : Nat) : range' s (n + 1) = range' s n ++ [s + n] := by
-  simp [range'_concat]
-
-theorem range'_eq_cons_iff : range' s n = a :: xs ↔ s = a ∧ 0 < n ∧ xs = range' (a + 1) (n - 1) := by
-  induction n generalizing s with
-  | zero => simp
-  | succ n ih =>
-    simp only [range'_succ]
-    simp only [cons.injEq, and_congr_right_iff]
-    rintro rfl
-    simp [eq_comm]
-
-/-! ### range -/
-
-theorem range_loop_range' : ∀ s n : Nat, range.loop s (range' s n) = range' 0 (n + s)
-  | 0, n => rfl
-  | s + 1, n => by rw [← Nat.add_assoc, Nat.add_right_comm n s 1]; exact range_loop_range' s (n + 1)
-
-theorem range_eq_range' (n : Nat) : range n = range' 0 n :=
-  (range_loop_range' n 0).trans <| by rw [Nat.zero_add]
-
-theorem getElem?_range {m n : Nat} (h : m < n) : (range n)[m]? = some m := by
-  simp [range_eq_range', getElem?_range' _ _ h]
-
-@[simp] theorem getElem_range {n : Nat} (m) (h : m < (range n).length) : (range n)[m] = m := by
-  simp [range_eq_range']
-
-theorem range_succ_eq_map (n : Nat) : range (n + 1) = 0 :: map succ (range n) := by
-  rw [range_eq_range', range_eq_range', range', Nat.add_comm, ← map_add_range']
-  congr; exact funext (Nat.add_comm 1)
-
-theorem range'_eq_map_range (s n : Nat) : range' s n = map (s + ·) (range n) := by
-  rw [range_eq_range', map_add_range']; rfl
-
-@[simp] theorem length_range (n : Nat) : length (range n) = n := by
-  simp only [range_eq_range', length_range']
-
-@[simp] theorem range_eq_nil {n : Nat} : range n = [] ↔ n = 0 := by
-  rw [← length_eq_zero, length_range]
-
-theorem range_ne_nil {n : Nat} : range n ≠ [] ↔ n ≠ 0 := by
-  cases n <;> simp
-
-@[simp]
-theorem range_sublist {m n : Nat} : range m <+ range n ↔ m ≤ n := by
-  simp only [range_eq_range', range'_sublist_right]
-
-@[simp]
-theorem range_subset {m n : Nat} : range m ⊆ range n ↔ m ≤ n := by
-  simp only [range_eq_range', range'_subset_right, lt_succ_self]
-
-theorem range_succ (n : Nat) : range (succ n) = range n ++ [n] := by
-  simp only [range_eq_range', range'_1_concat, Nat.zero_add]
-
-theorem range_add (a b : Nat) : range (a + b) = range a ++ (range b).map (a + ·) := by
-  rw [← range'_eq_map_range]
-  simpa [range_eq_range', Nat.add_comm] using (range'_append_1 0 a b).symm
-
-theorem head?_range (n : Nat) : (range n).head? = if n = 0 then none else some 0 := by
-  induction n with
-  | zero => simp
-  | succ n ih =>
-    simp only [range_succ, head?_append, ih]
-    split <;> simp_all
-
-@[simp] theorem head_range (n : Nat) (h) : (range n).head h = 0 := by
-  cases n with
-  | zero => simp at h
-  | succ n => simp [head?_range, head_eq_iff_head?_eq_some]
-
-theorem getLast?_range (n : Nat) : (range n).getLast? = if n = 0 then none else some (n - 1) := by
-  induction n with
-  | zero => simp
-  | succ n ih =>
-    simp only [range_succ, getLast?_append, ih]
-    split <;> simp_all
-
-@[simp] theorem getLast_range (n : Nat) (h) : (range n).getLast h = n - 1 := by
-  cases n with
-  | zero => simp at h
-  | succ n => simp [getLast?_range, getLast_eq_iff_getLast_eq_some]
-
-/-! ### enumFrom -/
-
-@[simp]
-theorem enumFrom_eq_nil {n : Nat} {l : List α} : List.enumFrom n l = [] ↔ l = [] := by
-  cases l <;> simp
-
-@[simp] theorem enumFrom_length : ∀ {n} {l : List α}, (enumFrom n l).length = l.length
-  | _, [] => rfl
-  | _, _ :: _ => congrArg Nat.succ enumFrom_length
-
-@[simp]
-theorem getElem?_enumFrom :
-    ∀ n (l : List α) m, (enumFrom n l)[m]? = l[m]?.map fun a => (n + m, a)
-  | n, [], m => rfl
-  | n, a :: l, 0 => by simp
-  | n, a :: l, m + 1 => by
-    simp only [enumFrom_cons, getElem?_cons_succ]
-    exact (getElem?_enumFrom (n + 1) l m).trans <| by rw [Nat.add_right_comm]; rfl
-
-@[simp]
-theorem getElem_enumFrom (l : List α) (n) (i : Nat) (h : i < (l.enumFrom n).length) :
-    (l.enumFrom n)[i] = (n + i, l[i]'(by simpa [enumFrom_length] using h)) := by
-  simp only [enumFrom_length] at h
-  rw [getElem_eq_getElem?_get]
-  simp only [getElem?_enumFrom, getElem?_eq_getElem h]
-  simp
-
-theorem map_fst_add_enumFrom_eq_enumFrom (l : List α) (n k : Nat) :
-    map (Prod.map (· + n) id) (enumFrom k l) = enumFrom (n + k) l :=
-  ext_getElem? fun i ↦ by simp [(· ∘ ·), Nat.add_comm, Nat.add_left_comm]; rfl
-
-theorem map_fst_add_enum_eq_enumFrom (l : List α) (n : Nat) :
-    map (Prod.map (· + n) id) (enum l) = enumFrom n l :=
-  map_fst_add_enumFrom_eq_enumFrom l _ _
-
-end List

src/Init/Data/List/Sort.lean

@@ -1,9 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.List.Sort.Basic
-import Init.Data.List.Sort.Impl
-import Init.Data.List.Sort.Lemmas

src/Init/Data/List/Sort/Basic.lean

@@ -1,83 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.List.Impl
-import Init.Data.List.Nat.TakeDrop
-
-/-!
-# Definition of `merge` and `mergeSort`.
-
-These definitions are intended for verification purposes,
-and are replaced at runtime by efficient versions in `Init.Data.List.Sort.Impl`.
--/
-
-namespace List
-
-/--
-`O(min |l| |r|)`. Merge two lists using `le` as a switch.
-
-This version is not tail-recursive,
-but it is replaced at runtime by `mergeTR` using a `@[csimp]` lemma.
--/
-def merge (xs ys : List α) (le : α → α → Bool := by exact fun a b => a ≤ b) : List α :=
-  match xs, ys with
-  | [], ys => ys
-  | xs, [] => xs
-  | x :: xs, y :: ys =>
-    if le x y then
-      x :: merge xs (y :: ys) le
-    else
-      y :: merge (x :: xs) ys le
-
-@[simp] theorem nil_merge (ys : List α) : merge [] ys le = ys := by simp [merge]
-@[simp] theorem merge_right (xs : List α) : merge xs [] le = xs := by
-  induction xs with
-  | nil => simp [merge]
-  | cons x xs ih => simp [merge, ih]
-
-/--
-Split a list in two equal parts. If the length is odd, the first part will be one element longer.
--/
-def splitInTwo (l : { l : List α // l.length = n }) :
-    { l : List α // l.length = (n+1)/2 } × { l : List α // l.length = n/2 } :=
-  let r := splitAt ((n+1)/2) l.1
-  (⟨r.1, by simp [r, splitAt_eq, l.2]; omega⟩, ⟨r.2, by simp [r, splitAt_eq, l.2]; omega⟩)
-
-set_option linter.unusedVariables false in
-/--
-Simplified implementation of stable merge sort.
-
-This function is designed for reasoning about the algorithm, and is not efficient.
-(It particular it uses the non tail-recursive `merge` function,
-and so can not be run on large lists, but also makes unnecessary traversals of lists.)
-It is replaced at runtime in the compiler by `mergeSortTR₂` using a `@[csimp]` lemma.
-
-Because we want the sort to be stable,
-it is essential that we split the list in two contiguous sublists.
--/
-def mergeSort : ∀ (xs : List α) (le : α → α → Bool := by exact fun a b => a ≤ b), List α
-  | [], _ => []
-  | [a], _ => [a]
-  | a :: b :: xs, le =>
-    let lr := splitInTwo ⟨a :: b :: xs, rfl⟩
-    have := by simpa using lr.2.2
-    have := by simpa using lr.1.2
-    merge (mergeSort lr.1 le) (mergeSort lr.2 le) le
-termination_by xs => xs.length
-
-/--
-Given an ordering relation `le : α → α → Bool`,
-construct the reverse lexicographic ordering on `Nat × α`.
-which first compares the second components using `le`,
-but if these are equivalent (in the sense `le a.2 b.2 && le b.2 a.2`)
-then compares the first components using `≤`.
-
-This function is only used in stating the stability properties of `mergeSort`.
--/
-def enumLE (le : α → α → Bool) (a b : Nat × α) : Bool :=
-  if le a.2 b.2 then if le b.2 a.2 then a.1 ≤ b.1 else true else false
-
-end List

src/Init/Data/List/Sort/Impl.lean

@@ -1,237 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.List.Sort.Lemmas
-
-/-!
-# Replacing `merge` and `mergeSort` at runtime with tail-recursive and faster versions.
-
-We replace `merge` with `mergeTR` using a `@[csimp]` lemma.
-
-We replace `mergeSort` in two steps:
-* first with `mergeSortTR`, which while not tail-recursive itself (it can't be),
-  uses `mergeTR` internally.
-* second with `mergeSortTR₂`, which achieves an ~20% speed-up over `mergeSortTR`
-  by avoiding some unnecessary list reversals.
-
-There is no public API in this file; it solely exists to implement the `@[csimp]` lemmas
-affecting runtime behaviour.
-
-## Future work
-The current runtime implementation could be further improved in a number of ways, e.g.:
-* only walking the list once during splitting,
-* using insertion sort for small chunks rather than splitting all the way down to singletons,
-* identifying already sorted or reverse sorted chunks and skipping them.
-
-Because the theory developed for `mergeSort` is independent of the runtime implementation,
-as long as such improvements are carefully validated by benchmarking,
-they can be done without changing the theory, as long as a `@[csimp]` lemma is provided.
--/
-
-open List
-
-namespace List.MergeSort.Internal
-
-/--
-`O(min |l| |r|)`. Merge two lists using `le` as a switch.
--/
-def mergeTR (l₁ l₂ : List α) (le : α → α → Bool) : List α :=
-  go l₁ l₂ []
-where go : List α → List α → List α → List α
-  | [], l₂, acc => reverseAux acc l₂
-  | l₁, [], acc => reverseAux acc l₁
-  | x :: xs, y :: ys, acc =>
-    if le x y then
-      go xs (y :: ys) (x :: acc)
-    else
-      go (x :: xs) ys (y :: acc)
-
-theorem mergeTR_go_eq : mergeTR.go le l₁ l₂ acc = acc.reverse ++ merge l₁ l₂ le := by
-  induction l₁ generalizing l₂ acc with
-  | nil => simp [mergeTR.go, merge, reverseAux_eq]
-  | cons x l₁ ih₁ =>
-    induction l₂ generalizing acc with
-    | nil => simp [mergeTR.go, merge, reverseAux_eq]
-    | cons y l₂ ih₂ =>
-      simp [mergeTR.go, merge]
-      split <;> simp [ih₁, ih₂]
-
-@[csimp] theorem merge_eq_mergeTR : @merge = @mergeTR := by
-  funext
-  simp [mergeTR, mergeTR_go_eq]
-
-/--
-Variant of `splitAt`, that does not reverse the first list, i.e
-`splitRevAt n l = ((l.take n).reverse, l.drop n)`.
-
-This exists solely as an optimization for `mergeSortTR` and `mergeSortTR₂`,
-and should not be used elsewhere.
--/
-def splitRevAt (n : Nat) (l : List α) : List α × List α := go l n [] where
-  /-- Auxiliary for `splitAtRev`: `splitAtRev.go xs n acc = ((take n xs).reverse ++ acc, drop n xs)`. -/
-  go : List α → Nat → List α → List α × List α
-  | x :: xs, n+1, acc => go xs n (x :: acc)
-  | xs, _, acc => (acc, xs)
-
-theorem splitRevAt_go (xs : List α) (n : Nat) (acc : List α) :
-    splitRevAt.go xs n acc = ((take n xs).reverse ++ acc, drop n xs) := by
-  induction xs generalizing n acc with
-  | nil => simp [splitRevAt.go]
-  | cons x xs ih =>
-    cases n with
-    | zero => simp [splitRevAt.go]
-    | succ n =>
-      rw [splitRevAt.go, ih n (x :: acc), take_succ_cons, reverse_cons, drop_succ_cons,
-        append_assoc, singleton_append]
-
-theorem splitRevAt_eq (n : Nat) (l : List α) : splitRevAt n l = ((l.take n).reverse, l.drop n) := by
-  rw [splitRevAt, splitRevAt_go, append_nil]
-
-/--
-An intermediate speed-up for `mergeSort`.
-This version uses the tail-recurive `mergeTR` function as a subroutine.
-
-This is not the final version we use at runtime, as `mergeSortTR₂` is faster.
-This definition is useful as an intermediate step in proving the `@[csimp]` lemma for `mergeSortTR₂`.
--/
-def mergeSortTR (l : List α) (le : α → α → Bool := by exact fun a b => a ≤ b) : List α :=
-  run ⟨l, rfl⟩
-where run : {n : Nat} → { l : List α // l.length = n } → List α
-  | 0, ⟨[], _⟩ => []
-  | 1, ⟨[a], _⟩ => [a]
-  | n+2, xs =>
-    let (l, r) := splitInTwo xs
-    mergeTR (run l) (run r) le
-
-/--
-Split a list in two equal parts, reversing the first part.
-If the length is odd, the first part will be one element longer.
--/
-def splitRevInTwo (l : { l : List α // l.length = n }) :
-    { l : List α // l.length = (n+1)/2 } × { l : List α // l.length = n/2 } :=
-  let r := splitRevAt ((n+1)/2) l.1
-  (⟨r.1, by simp [r, splitRevAt_eq, l.2]; omega⟩, ⟨r.2, by simp [r, splitRevAt_eq, l.2]; omega⟩)
-
-/--
-Split a list in two equal parts, reversing the first part.
-If the length is odd, the second part will be one element longer.
--/
-def splitRevInTwo' (l : { l : List α // l.length = n }) :
-    { l : List α // l.length = n/2 } × { l : List α // l.length = (n+1)/2 } :=
-  let r := splitRevAt (n/2) l.1
-  (⟨r.1, by simp [r, splitRevAt_eq, l.2]; omega⟩, ⟨r.2, by simp [r, splitRevAt_eq, l.2]; omega⟩)
-
-/--
-Faster version of `mergeSortTR`, which avoids unnecessary list reversals.
--/
--- Per the benchmark in `tests/bench/mergeSort/`
--- (which averages over 4 use cases: already sorted lists, reverse sorted lists, almost sorted lists, and random lists),
--- for lists of length 10^6, `mergeSortTR₂` is about 20% faster than `mergeSortTR`.
-def mergeSortTR₂ (l : List α) (le : α → α → Bool := by exact fun a b => a ≤ b) : List α :=
-  run ⟨l, rfl⟩
-where
-  run : {n : Nat} → { l : List α // l.length = n } → List α
-  | 0, ⟨[], _⟩ => []
-  | 1, ⟨[a], _⟩ => [a]
-  | n+2, xs =>
-    let (l, r) := splitRevInTwo xs
-    mergeTR (run' l) (run r) le
-  run' : {n : Nat} → { l : List α // l.length = n } → List α
-  | 0, ⟨[], _⟩ => []
-  | 1, ⟨[a], _⟩ => [a]
-  | n+2, xs =>
-    let (l, r) := splitRevInTwo' xs
-    mergeTR (run' r) (run l) le
-
-theorem splitRevInTwo'_fst (l : { l : List α // l.length = n }) :
-    (splitRevInTwo' l).1 = ⟨(splitInTwo ⟨l.1.reverse, by simpa using l.2⟩).2.1, by have := l.2; simp; omega⟩ := by
-  simp only [splitRevInTwo', splitRevAt_eq, reverse_take, splitInTwo_snd]
-  congr
-  have := l.2
-  omega
-theorem splitRevInTwo'_snd (l : { l : List α // l.length = n }) :
-    (splitRevInTwo' l).2 = ⟨(splitInTwo ⟨l.1.reverse, by simpa using l.2⟩).1.1.reverse, by have := l.2; simp; omega⟩ := by
-  simp only [splitRevInTwo', splitRevAt_eq, reverse_take, splitInTwo_fst, reverse_reverse]
-  congr 2
-  have := l.2
-  simp
-  omega
-theorem splitRevInTwo_fst (l : { l : List α // l.length = n }) :
-    (splitRevInTwo l).1 = ⟨(splitInTwo l).1.1.reverse, by have := l.2; simp; omega⟩ := by
-  simp only [splitRevInTwo, splitRevAt_eq, reverse_take, splitInTwo_fst]
-theorem splitRevInTwo_snd (l : { l : List α // l.length = n }) :
-    (splitRevInTwo l).2 = ⟨(splitInTwo l).2.1, by have := l.2; simp; omega⟩ := by
-  simp only [splitRevInTwo, splitRevAt_eq, reverse_take, splitInTwo_snd]
-
-theorem mergeSortTR_run_eq_mergeSort : {n : Nat} → (l : { l : List α // l.length = n }) → mergeSortTR.run le l = mergeSort l.1 le
-  | 0, ⟨[], _⟩
-  | 1, ⟨[a], _⟩ => by simp [mergeSortTR.run, mergeSort]
-  | n+2, ⟨a :: b :: l, h⟩ => by
-    cases h
-    simp only [mergeSortTR.run, mergeSortTR.run, mergeSort]
-    rw [merge_eq_mergeTR]
-    rw [mergeSortTR_run_eq_mergeSort, mergeSortTR_run_eq_mergeSort]
-
--- We don't make this a `@[csimp]` lemma because `mergeSort_eq_mergeSortTR₂` is faster.
-theorem mergeSort_eq_mergeSortTR : @mergeSort = @mergeSortTR := by
-  funext
-  rw [mergeSortTR, mergeSortTR_run_eq_mergeSort]
-
--- This mutual block is unfortunately quite slow to elaborate.
-set_option maxHeartbeats 400000 in
-mutual
-theorem mergeSortTR₂_run_eq_mergeSort : {n : Nat} → (l : { l : List α // l.length = n }) → mergeSortTR₂.run le l = mergeSort l.1 le
-  | 0, ⟨[], _⟩
-  | 1, ⟨[a], _⟩ => by simp [mergeSortTR₂.run, mergeSort]
-  | n+2, ⟨a :: b :: l, h⟩ => by
-    cases h
-    simp only [mergeSortTR₂.run, mergeSort]
-    rw [splitRevInTwo_fst, splitRevInTwo_snd]
-    rw [mergeSortTR₂_run_eq_mergeSort, mergeSortTR₂_run'_eq_mergeSort]
-    rw [merge_eq_mergeTR]
-    rw [reverse_reverse]
-termination_by n => n
-
-theorem mergeSortTR₂_run'_eq_mergeSort : {n : Nat} → (l : { l : List α // l.length = n }) → (w : l' = l.1.reverse) → mergeSortTR₂.run' le l = mergeSort l' le
-  | 0, ⟨[], _⟩, w
-  | 1, ⟨[a], _⟩, w => by simp_all [mergeSortTR₂.run', mergeSort]
-  | n+2, ⟨a :: b :: l, h⟩, w => by
-    cases h
-    simp only [mergeSortTR₂.run', mergeSort]
-    rw [splitRevInTwo'_fst, splitRevInTwo'_snd]
-    rw [mergeSortTR₂_run_eq_mergeSort, mergeSortTR₂_run'_eq_mergeSort _ rfl]
-    rw [← merge_eq_mergeTR]
-    have w' := congrArg length w
-    simp at w'
-    cases l' with
-    | nil => simp at w'
-    | cons x l' =>
-      cases l' with
-      | nil => simp at w'
-      | cons y l' =>
-        rw [mergeSort]
-        congr 2
-        · dsimp at w
-          simp only [w]
-          simp only [splitInTwo_fst, splitInTwo_snd, reverse_take, take_reverse]
-          congr 1
-          rw [w, length_reverse]
-          simp
-        · dsimp at w
-          simp only [w]
-          simp only [reverse_cons, append_assoc, singleton_append, splitInTwo_snd, length_cons]
-          congr 1
-          simp at w'
-          omega
-termination_by n => n
-
-end
-
-@[csimp] theorem mergeSort_eq_mergeSortTR₂ : @mergeSort = @mergeSortTR₂ := by
-  funext
-  rw [mergeSortTR₂, mergeSortTR₂_run_eq_mergeSort]
-
-end List.MergeSort.Internal

src/Init/Data/List/Sort/Lemmas.lean

@@ -1,414 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.List.Perm
-import Init.Data.List.Sort.Basic
-import Init.Data.List.Nat.Range
-import Init.Data.Bool
-
-/-!
-# Basic properties of `mergeSort`.
-
-* `sorted_mergeSort`: `mergeSort` produces a sorted list.
-* `mergeSort_perm`: `mergeSort` is a permutation of the input list.
-* `mergeSort_of_sorted`: `mergeSort` does not change a sorted list.
-* `mergeSort_cons`: proves `mergeSort le (x :: xs) = l₁ ++ x :: l₂` for some `l₁, l₂`
-  so that `mergeSort le xs = l₁ ++ l₂`, and no `a ∈ l₁` satisfies `le a x`.
-* `sublist_mergeSort`: if `c` is a sorted sublist of `l`, then `c` is still a sublist of `mergeSort le l`.
-
--/
-
-namespace List
-
-/-! ### splitInTwo -/
-
-@[simp] theorem splitInTwo_fst (l : { l : List α // l.length = n }) :
-    (splitInTwo l).1 = ⟨l.1.take ((n+1)/2), by simp [splitInTwo, splitAt_eq, l.2]; omega⟩ := by
-  simp [splitInTwo, splitAt_eq]
-
-@[simp] theorem splitInTwo_snd (l : { l : List α // l.length = n }) :
-    (splitInTwo l).2 = ⟨l.1.drop ((n+1)/2), by simp [splitInTwo, splitAt_eq, l.2]; omega⟩ := by
-  simp [splitInTwo, splitAt_eq]
-
-theorem splitInTwo_fst_append_splitInTwo_snd (l : { l : List α // l.length = n }) : (splitInTwo l).1.1 ++ (splitInTwo l).2.1 = l.1 := by
-  simp
-
-theorem splitInTwo_cons_cons_enumFrom_fst (i : Nat) (l : List α) :
-    (splitInTwo ⟨(i, a) :: (i+1, b) :: l.enumFrom (i+2), rfl⟩).1.1 =
-      (splitInTwo ⟨a :: b :: l, rfl⟩).1.1.enumFrom i := by
-  simp only [length_cons, splitInTwo_fst, enumFrom_length]
-  ext1 j
-  rw [getElem?_take, getElem?_enumFrom, getElem?_take]
-  split
-  · rw [getElem?_cons, getElem?_cons, getElem?_cons, getElem?_cons]
-    split
-    · simp; omega
-    · split
-      · simp; omega
-      · simp only [getElem?_enumFrom]
-        congr
-        ext <;> simp; omega
-  · simp
-
-theorem splitInTwo_cons_cons_enumFrom_snd (i : Nat) (l : List α) :
-    (splitInTwo ⟨(i, a) :: (i+1, b) :: l.enumFrom (i+2), rfl⟩).2.1 =
-      (splitInTwo ⟨a :: b :: l, rfl⟩).2.1.enumFrom (i+(l.length+3)/2) := by
-  simp only [length_cons, splitInTwo_snd, enumFrom_length]
-  ext1 j
-  rw [getElem?_drop, getElem?_enumFrom, getElem?_drop]
-  rw [getElem?_cons, getElem?_cons, getElem?_cons, getElem?_cons]
-  split
-  · simp; omega
-  · split
-    · simp; omega
-    · simp only [getElem?_enumFrom]
-      congr
-      ext <;> simp; omega
-
-theorem splitInTwo_fst_sorted (l : { l : List α // l.length = n }) (h : Pairwise le l.1) : Pairwise le (splitInTwo l).1.1 := by
-  rw [splitInTwo_fst]
-  exact h.take
-
-theorem splitInTwo_snd_sorted (l : { l : List α // l.length = n }) (h : Pairwise le l.1) : Pairwise le (splitInTwo l).2.1 := by
-  rw [splitInTwo_snd]
-  exact h.drop
-
-theorem splitInTwo_fst_le_splitInTwo_snd {l : { l : List α // l.length = n }} (h : Pairwise le l.1) :
-    ∀ a b, a ∈ (splitInTwo l).1.1 → b ∈ (splitInTwo l).2.1 → le a b := by
-  rw [splitInTwo_fst, splitInTwo_snd]
-  intro a b ma mb
-  exact h.rel_of_mem_take_of_mem_drop ma mb
-
-/-! ### enumLE -/
-
-variable {le : α → α → Bool}
-
-theorem enumLE_trans (trans : ∀ a b c, le a b → le b c → le a c)
-    (a b c : Nat × α) : enumLE le a b → enumLE le b c → enumLE le a c := by
-  simp only [enumLE]
-  split <;> split <;> split <;> rename_i ab₂ ba₂ bc₂
-  · simp_all
-    intro ab₁
-    intro h
-    refine ⟨trans _ _ _ ab₂ bc₂, ?_⟩
-    rcases h with (cd₂ | bc₁)
-    · exact Or.inl (Decidable.byContradiction
-        (fun ca₂ => by simp_all [trans _ _ _ (by simpa using ca₂) ab₂]))
-    · exact Or.inr (Nat.le_trans ab₁ bc₁)
-  · simp_all
-  · simp_all
-    intro h
-    refine ⟨trans _ _ _ ab₂ bc₂, ?_⟩
-    left
-    rcases h with (cb₂ | _)
-    · exact (Decidable.byContradiction
-        (fun ca₂ => by simp_all [trans _ _ _ (by simpa using ca₂) ab₂]))
-    · exact (Decidable.byContradiction
-        (fun ca₂ => by simp_all [trans _ _ _ bc₂ (by simpa using ca₂)]))
-  · simp_all
-  · simp_all
-  · simp_all
-  · simp_all
-  · simp_all
-
-theorem enumLE_total (total : ∀ a b, !le a b → le b a)
-    (a b : Nat × α) : !enumLE le a b → enumLE le b a := by
-  simp only [enumLE]
-  split <;> split
-  · simpa using Nat.le_of_lt
-  · simp
-  · simp
-  · simp_all [total a.2 b.2]
-
-/-! ### merge -/
-
-theorem merge_stable : ∀ (xs ys) (_ : ∀ x y, x ∈ xs → y ∈ ys → x.1 ≤ y.1),
-    (merge xs ys (enumLE le)).map (·.2) = merge (xs.map (·.2)) (ys.map (·.2)) le
-  | [], ys, _ => by simp [merge]
-  | xs, [], _ => by simp [merge]
-  | (i, x) :: xs, (j, y) :: ys, h => by
-    simp only [merge, enumLE, map_cons]
-    split <;> rename_i w
-    · rw [if_pos (by simp [h _ _ (mem_cons_self ..) (mem_cons_self ..)])]
-      simp only [map_cons, cons.injEq, true_and]
-      rw [merge_stable, map_cons]
-      exact fun x' y' mx my => h x' y' (mem_cons_of_mem (i, x) mx) my
-    · simp only [↓reduceIte, map_cons, cons.injEq, true_and, reduceCtorEq]
-      rw [merge_stable, map_cons]
-      exact fun x' y' mx my => h x' y' mx (mem_cons_of_mem (j, y) my)
-
-/--
-The elements of `merge le xs ys` are exactly the elements of `xs` and `ys`.
--/
--- We subsequently prove that `mergeSort_perm : merge le xs ys ~ xs ++ ys`.
-theorem mem_merge {a : α} {xs ys : List α} : a ∈ merge xs ys le ↔ a ∈ xs ∨ a ∈ ys := by
-  induction xs generalizing ys with
-  | nil => simp [merge]
-  | cons x xs ih =>
-    induction ys with
-    | nil => simp [merge]
-    | cons y ys ih =>
-      simp only [merge]
-      split <;> rename_i h
-      · simp_all [or_assoc]
-      · simp only [mem_cons, or_assoc, Bool.not_eq_true, ih, ← or_assoc]
-        apply or_congr_left
-        simp only [or_comm (a := a = y), or_assoc]
-
--- We enable this instance locally so we can write `Pairwise le` instead of `Pairwise (le · ·)` everywhere.
-attribute [local instance] boolRelToRel
-
-/--
-If the ordering relation `le` is transitive and total (i.e. `le a b ∨ le b a` for all `a, b`)
-then the `merge` of two sorted lists is sorted.
--/
-theorem sorted_merge
-    (trans : ∀ (a b c : α), le a b → le b c → le a c)
-    (total : ∀ (a b : α), !le a b → le b a)
-    (l₁ l₂ : List α) (h₁ : l₁.Pairwise le) (h₂ : l₂.Pairwise le) : (merge l₁ l₂ le).Pairwise le := by
-  induction l₁ generalizing l₂ with
-  | nil => simpa only [merge]
-  | cons x l₁ ih₁ =>
-    induction l₂ with
-    | nil => simpa only [merge]
-    | cons y l₂ ih₂ =>
-      simp only [merge]
-      split <;> rename_i h
-      · apply Pairwise.cons
-        · intro z m
-          rw [mem_merge, mem_cons] at m
-          rcases m with (m|rfl|m)
-          · exact rel_of_pairwise_cons h₁ m
-          · exact h
-          · exact trans _ _ _ h (rel_of_pairwise_cons h₂ m)
-        · exact ih₁ _ h₁.tail h₂
-      · apply Pairwise.cons
-        · intro z m
-          rw [mem_merge, mem_cons] at m
-          rcases m with (⟨rfl|m⟩|m)
-          · exact total _ _ (by simpa using h)
-          · exact trans _ _ _ (total _ _ (by simpa using h)) (rel_of_pairwise_cons h₁ m)
-          · exact rel_of_pairwise_cons h₂ m
-        · exact ih₂ h₂.tail
-
-theorem merge_of_le : ∀ {xs ys : List α} (_ : ∀ a b, a ∈ xs → b ∈ ys → le a b),
-    merge xs ys le = xs ++ ys
-  | [], ys, _
-  | xs, [], _ => by simp [merge]
-  | x :: xs, y :: ys, h => by
-    simp only [merge, cons_append]
-    rw [if_pos, merge_of_le]
-    · intro a b ma mb
-      exact h a b (mem_cons_of_mem _ ma) mb
-    · exact h x y (mem_cons_self _ _) (mem_cons_self _ _)
-
-variable (le) in
-theorem merge_perm_append : ∀ {xs ys : List α}, merge xs ys le ~ xs ++ ys
-  | [], ys => by simp [merge]
-  | xs, [] => by simp [merge]
-  | x :: xs, y :: ys => by
-    simp only [merge]
-    split
-    · exact merge_perm_append.cons x
-    · exact (merge_perm_append.cons y).trans
-        ((Perm.swap x y _).trans (perm_middle.symm.cons x))
-
-/-! ### mergeSort -/
-
-@[simp] theorem mergeSort_nil : [].mergeSort r = [] := by rw [List.mergeSort]
-
-@[simp] theorem mergeSort_singleton (a : α) : [a].mergeSort r = [a] := by rw [List.mergeSort]
-
-theorem mergeSort_perm : ∀ (l : List α) (le), mergeSort l le ~ l
-  | [], _ => by simp [mergeSort]
-  | [a], _ => by simp [mergeSort]
-  | a :: b :: xs, le => by
-    simp only [mergeSort]
-    have : (splitInTwo ⟨a :: b :: xs, rfl⟩).1.1.length < xs.length + 1 + 1 := by simp [splitInTwo_fst]; omega
-    have : (splitInTwo ⟨a :: b :: xs, rfl⟩).2.1.length < xs.length + 1 + 1 := by simp [splitInTwo_snd]; omega
-    exact (merge_perm_append le).trans
-      (((mergeSort_perm _ _).append (mergeSort_perm _ _)).trans
-        (Perm.of_eq (splitInTwo_fst_append_splitInTwo_snd _)))
-termination_by l => l.length
-
-@[simp] theorem mergeSort_length (l : List α) : (mergeSort l le).length = l.length :=
-  (mergeSort_perm l le).length_eq
-
-@[simp] theorem mem_mergeSort {a : α} {l : List α} : a ∈ mergeSort l le ↔ a ∈ l :=
-  (mergeSort_perm l le).mem_iff
-
-/--
-The result of `mergeSort` is sorted,
-as long as the comparison function is transitive (`le a b → le b c → le a c`)
-and total in the sense that `le a b ∨ le b a`.
-
-The comparison function need not be irreflexive, i.e. `le a b` and `le b a` is allowed even when `a ≠ b`.
--/
-theorem sorted_mergeSort
-    (trans : ∀ (a b c : α), le a b → le b c → le a c)
-    (total : ∀ (a b : α), !le a b → le b a) :
-    (l : List α) → (mergeSort l le).Pairwise le
-  | [] => by simp [mergeSort]
-  | [a] => by simp [mergeSort]
-  | a :: b :: xs => by
-    have : (splitInTwo ⟨a :: b :: xs, rfl⟩).1.1.length < xs.length + 1 + 1 := by simp [splitInTwo_fst]; omega
-    have : (splitInTwo ⟨a :: b :: xs, rfl⟩).2.1.length < xs.length + 1 + 1 := by simp [splitInTwo_snd]; omega
-    rw [mergeSort]
-    apply sorted_merge @trans @total
-    apply sorted_mergeSort trans total
-    apply sorted_mergeSort trans total
-termination_by l => l.length
-
-@[deprecated (since := "2024-09-02")] abbrev mergeSort_sorted := @sorted_mergeSort
-
-/--
-If the input list is already sorted, then `mergeSort` does not change the list.
--/
-theorem mergeSort_of_sorted : ∀ {l : List α} (_ : Pairwise le l), mergeSort l le = l
-  | [], _ => by simp [mergeSort]
-  | [a], _ => by simp [mergeSort]
-  | a :: b :: xs, h => by
-    have : (splitInTwo ⟨a :: b :: xs, rfl⟩).1.1.length < xs.length + 1 + 1 := by simp [splitInTwo_fst]; omega
-    have : (splitInTwo ⟨a :: b :: xs, rfl⟩).2.1.length < xs.length + 1 + 1 := by simp [splitInTwo_snd]; omega
-    rw [mergeSort]
-    rw [mergeSort_of_sorted (splitInTwo_fst_sorted ⟨a :: b :: xs, rfl⟩ h)]
-    rw [mergeSort_of_sorted (splitInTwo_snd_sorted ⟨a :: b :: xs, rfl⟩ h)]
-    rw [merge_of_le (splitInTwo_fst_le_splitInTwo_snd h)]
-    rw [splitInTwo_fst_append_splitInTwo_snd]
-termination_by l => l.length
-
-/--
-This merge sort algorithm is stable,
-in the sense that breaking ties in the ordering function using the position in the list
-has no effect on the output.
-
-That is, elements which are equal with respect to the ordering function will remain
-in the same order in the output list as they were in the input list.
-
-See also:
-* `sublist_mergeSort`: if `c <+ l` and `c.Pairwise le`, then `c <+ mergeSort le l`.
-* `pair_sublist_mergeSort`: if `[a, b] <+ l` and `le a b`, then `[a, b] <+ mergeSort le l`)
--/
-theorem mergeSort_enum {l : List α} :
-    (mergeSort (l.enum) (enumLE le)).map (·.2) = mergeSort l le :=
-  go 0 l
-where go : ∀ (i : Nat) (l : List α),
-    (mergeSort (l.enumFrom i) (enumLE le)).map (·.2) = mergeSort l le
-  | _, []
-  | _, [a] => by simp [mergeSort]
-  | _, a :: b :: xs => by
-    have : (splitInTwo ⟨a :: b :: xs, rfl⟩).1.1.length < xs.length + 1 + 1 := by simp [splitInTwo_fst]; omega
-    have : (splitInTwo ⟨a :: b :: xs, rfl⟩).2.1.length < xs.length + 1 + 1 := by simp [splitInTwo_snd]; omega
-    simp only [mergeSort, enumFrom]
-    rw [splitInTwo_cons_cons_enumFrom_fst]
-    rw [splitInTwo_cons_cons_enumFrom_snd]
-    rw [merge_stable]
-    · rw [go, go]
-    · simp only [mem_mergeSort, Prod.forall]
-      intros j x k y mx my
-      have := mem_enumFrom mx
-      have := mem_enumFrom my
-      simp_all
-      omega
-termination_by _ l => l.length
-
-theorem mergeSort_cons {le : α → α → Bool}
-    (trans : ∀ (a b c : α), le a b → le b c → le a c)
-    (total : ∀ (a b : α), !le a b → le b a)
-    (a : α) (l : List α) :
-    ∃ l₁ l₂, mergeSort (a :: l) le = l₁ ++ a :: l₂ ∧ mergeSort l le = l₁ ++ l₂ ∧
-      ∀ b, b ∈ l₁ → !le a b := by
-  rw [← mergeSort_enum]
-  rw [enum_cons]
-  have nd : Nodup ((a :: l).enum.map (·.1)) := by rw [enum_map_fst]; exact nodup_range _
-  have m₁ : (0, a) ∈ mergeSort ((a :: l).enum) (enumLE le) :=
-    mem_mergeSort.mpr (mem_cons_self _ _)
-  obtain ⟨l₁, l₂, h⟩ := append_of_mem m₁
-  have s := sorted_mergeSort (enumLE_trans trans) (enumLE_total total) ((a :: l).enum)
-  rw [h] at s
-  have p := mergeSort_perm ((a :: l).enum) (enumLE le)
-  rw [h] at p
-  refine ⟨l₁.map (·.2), l₂.map (·.2), ?_, ?_, ?_⟩
-  · simpa using congrArg (·.map (·.2)) h
-  · rw [← mergeSort_enum.go 1, ← map_append]
-    congr 1
-    have q : mergeSort (enumFrom 1 l) (enumLE le) ~ l₁ ++ l₂ :=
-      (mergeSort_perm (enumFrom 1 l) (enumLE le)).trans
-        (p.symm.trans perm_middle).cons_inv
-    apply Perm.eq_of_sorted (le := enumLE le)
-    · rintro ⟨i, a⟩ ⟨j, b⟩  ha hb
-      simp only [mem_mergeSort] at ha
-      simp only [← q.mem_iff, mem_mergeSort] at hb
-      simp only [enumLE]
-      simp only [Bool.if_false_right, Bool.and_eq_true, Prod.mk.injEq, and_imp]
-      intro ab h ba h'
-      simp only [Bool.decide_eq_true] at ba
-      replace h : i ≤ j := by simpa [ab, ba] using h
-      replace h' : j ≤ i := by simpa [ab, ba] using h'
-      cases Nat.le_antisymm h h'
-      constructor
-      · rfl
-      · have := mem_enumFrom ha
-        have := mem_enumFrom hb
-        simp_all
-    · exact sorted_mergeSort (enumLE_trans trans) (enumLE_total total) ..
-    · exact s.sublist ((sublist_cons_self (0, a) l₂).append_left l₁)
-    · exact q
-  · intro b m
-    simp only [mem_map, Prod.exists, exists_eq_right] at m
-    obtain ⟨j, m⟩ := m
-    replace p := p.map (·.1)
-    have nd' := nd.perm p.symm
-    rw [map_append] at nd'
-    have j0 := nd'.rel_of_mem_append
-      (mem_map_of_mem (·.1) m) (mem_map_of_mem _ (mem_cons_self _ _))
-    simp only [ne_eq] at j0
-    have r := s.rel_of_mem_append m (mem_cons_self _ _)
-    simp_all [enumLE]
-
-/--
-Another statement of stability of merge sort.
-If `c` is a sorted sublist of `l`,
-then `c` is still a sublist of `mergeSort le l`.
--/
-theorem sublist_mergeSort
-    (trans : ∀ (a b c : α), le a b → le b c → le a c)
-    (total : ∀ (a b : α), !le a b → le b a) :
-    ∀ {c : List α} (_ : c.Pairwise le) (_ : c <+ l),
-    c <+ mergeSort l le
-  | _, _, .slnil => nil_sublist _
-  | c, hc, @Sublist.cons _ _ l a h => by
-    obtain ⟨l₁, l₂, h₁, h₂, -⟩ := mergeSort_cons trans total a l
-    rw [h₁]
-    have h' := sublist_mergeSort trans total hc h
-    rw [h₂] at h'
-    exact h'.middle a
-  | _, _, @Sublist.cons₂ _ l₁ l₂ a h => by
-    rename_i hc
-    obtain ⟨l₃, l₄, h₁, h₂, h₃⟩ := mergeSort_cons trans total a l₂
-    rw [h₁]
-    have h' := sublist_mergeSort trans total hc.tail h
-    rw [h₂] at h'
-    simp only [Bool.not_eq_true', tail_cons] at h₃ h'
-    exact
-      sublist_append_of_sublist_right (Sublist.cons₂ a
-        ((fun w => Sublist.of_sublist_append_right w h') fun b m₁ m₃ =>
-          (Bool.eq_not_self true).mp ((rel_of_pairwise_cons hc m₁).symm.trans (h₃ b m₃))))
-
-@[deprecated (since := "2024-09-02")] abbrev mergeSort_stable := @sublist_mergeSort
-
-/--
-Another statement of stability of merge sort.
-If a pair `[a, b]` is a sublist of `l` and `le a b`,
-then `[a, b]` is still a sublist of `mergeSort le l`.
--/
-theorem pair_sublist_mergeSort
-    (trans : ∀ (a b c : α), le a b → le b c → le a c)
-    (total : ∀ (a b : α), !le a b → le b a)
-    (hab : le a b) (h : [a, b] <+ l) : [a, b] <+ mergeSort l le :=
-  sublist_mergeSort trans total (pairwise_pair.mpr hab) h
-
-@[deprecated (since := "2024-09-02")] abbrev mergeSort_stable_pair := @pair_sublist_mergeSort

src/Init/Data/List/Sublist.lean

@@ -1,8 +1,7 @@
 /-
 Copyright (c) 2014 Parikshit Khanna. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro,
-  Kim Morrison
+Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
 -/
 prelude
 import Init.Data.List.TakeDrop
@@ -62,18 +61,18 @@ theorem subset_def {l₁ l₂ : List α} : l₁ ⊆ l₂ ↔ ∀ {a : α}, a ∈
 theorem Subset.trans {l₁ l₂ l₃ : List α} (h₁ : l₁ ⊆ l₂) (h₂ : l₂ ⊆ l₃) : l₁ ⊆ l₃ :=
   fun _ i => h₂ (h₁ i)
 
-instance : Trans (fun l₁ l₂ => Subset l₂ l₁) (Membership.mem : List α → α → Prop) Membership.mem :=
-  ⟨fun h₁ h₂ => h₁ h₂⟩
+instance : Trans (Membership.mem : α → List α → Prop) Subset Membership.mem :=
+  ⟨fun h₁ h₂ => h₂ h₁⟩
 
 instance : Trans (Subset : List α → List α → Prop) Subset Subset :=
   ⟨Subset.trans⟩
 
-theorem subset_cons_self (a : α) (l : List α) : l ⊆ a :: l := fun _ => Mem.tail _
+@[simp] theorem subset_cons_self (a : α) (l : List α) : l ⊆ a :: l := fun _ => Mem.tail _
 
 theorem subset_of_cons_subset {a : α} {l₁ l₂ : List α} : a :: l₁ ⊆ l₂ → l₁ ⊆ l₂ :=
   fun s _ i => s (mem_cons_of_mem _ i)
 
-@[simp] theorem subset_cons_of_subset (a : α) {l₁ l₂ : List α} : l₁ ⊆ l₂ → l₁ ⊆ a :: l₂ :=
+theorem subset_cons_of_subset (a : α) {l₁ l₂ : List α} : l₁ ⊆ l₂ → l₁ ⊆ a :: l₂ :=
   fun s _ i => .tail _ (s i)
 
 theorem cons_subset_cons {l₁ l₂ : List α} (a : α) (s : l₁ ⊆ l₂) : a :: l₁ ⊆ a :: l₂ :=
@@ -85,8 +84,6 @@ theorem cons_subset_cons {l₁ l₂ : List α} (a : α) (s : l₁ ⊆ l₂) : a
 @[simp] theorem subset_nil {l : List α} : l ⊆ [] ↔ l = [] :=
   ⟨fun h => match l with | [] => rfl | _::_ => (nomatch h (.head ..)), fun | rfl => Subset.refl _⟩
 
-theorem eq_nil_of_subset_nil {l : List α} : l ⊆ [] → l = [] := subset_nil.mp
-
 theorem map_subset {l₁ l₂ : List α} (f : α → β) (h : l₁ ⊆ l₂) : map f l₁ ⊆ map f l₂ :=
   fun x => by simp only [mem_map]; exact .imp fun a => .imp_left (@h _)
 
@@ -100,14 +97,14 @@ theorem filterMap_subset {l₁ l₂ : List α} (f : α → Option β) (H : l₁
   rintro ⟨a, h, w⟩
   exact ⟨a, H h, w⟩
 
-theorem subset_append_left (l₁ l₂ : List α) : l₁ ⊆ l₁ ++ l₂ := fun _ => mem_append_left _
+@[simp] theorem subset_append_left (l₁ l₂ : List α) : l₁ ⊆ l₁ ++ l₂ := fun _ => mem_append_left _
 
-theorem subset_append_right (l₁ l₂ : List α) : l₂ ⊆ l₁ ++ l₂ := fun _ => mem_append_right _
+@[simp] theorem subset_append_right (l₁ l₂ : List α) : l₂ ⊆ l₁ ++ l₂ := fun _ => mem_append_right _
 
-@[simp] theorem subset_append_of_subset_left (l₂ : List α) : l ⊆ l₁ → l ⊆ l₁ ++ l₂ :=
+theorem subset_append_of_subset_left (l₂ : List α) : l ⊆ l₁ → l ⊆ l₁ ++ l₂ :=
 fun s => Subset.trans s <| subset_append_left _ _
 
-@[simp] theorem subset_append_of_subset_right (l₁ : List α) : l ⊆ l₂ → l ⊆ l₁ ++ l₂ :=
+theorem subset_append_of_subset_right (l₁ : List α) : l ⊆ l₂ → l ⊆ l₁ ++ l₂ :=
 fun s => Subset.trans s <| subset_append_right _ _
 
 @[simp] theorem append_subset {l₁ l₂ l : List α} :
@@ -155,9 +152,7 @@ theorem Sublist.trans {l₁ l₂ l₃ : List α} (h₁ : l₁ <+ l₂) (h₂ : l
 
 instance : Trans (@Sublist α) Sublist Sublist := ⟨Sublist.trans⟩
 
-attribute [simp] Sublist.cons
-
-theorem sublist_cons_self (a : α) (l : List α) : l <+ a :: l := (Sublist.refl l).cons _
+@[simp] theorem sublist_cons_self (a : α) (l : List α) : l <+ a :: l := (Sublist.refl l).cons _
 
 theorem sublist_of_cons_sublist : a :: l₁ <+ l₂ → l₁ <+ l₂ :=
   (sublist_cons_self a l₁).trans
@@ -182,23 +177,14 @@ theorem Sublist.subset : l₁ <+ l₂ → l₁ ⊆ l₂
   | .cons₂ .., _, .head .. => .head ..
   | .cons₂ _ s, _, .tail _ h => .tail _ (s.subset h)
 
-protected theorem Sublist.mem (hx : a ∈ l₁) (hl : l₁ <+ l₂) : a ∈ l₂ :=
-  hl.subset hx
-
-theorem Sublist.head_mem (s : ys <+ xs) (h) : ys.head h ∈ xs :=
-  s.mem (List.head_mem h)
-
-theorem Sublist.getLast_mem (s : ys <+ xs) (h) : ys.getLast h ∈ xs :=
-  s.mem (List.getLast_mem h)
-
 instance : Trans (@Sublist α) Subset Subset :=
   ⟨fun h₁ h₂ => trans h₁.subset h₂⟩
 
 instance : Trans Subset (@Sublist α) Subset :=
   ⟨fun h₁ h₂ => trans h₁ h₂.subset⟩
 
-instance : Trans (fun l₁ l₂ => Sublist l₂ l₁) (Membership.mem : List α → α → Prop) Membership.mem :=
-  ⟨fun h₁ h₂ => h₁.subset h₂⟩
+instance : Trans (Membership.mem : α → List α → Prop) Sublist Membership.mem :=
+  ⟨fun h₁ h₂ => h₂.subset h₁⟩
 
 theorem mem_of_cons_sublist {a : α} {l₁ l₂ : List α} (s : a :: l₁ <+ l₂) : a ∈ l₂ :=
   (cons_subset.1 s.subset).1
@@ -206,9 +192,6 @@ theorem mem_of_cons_sublist {a : α} {l₁ l₂ : List α} (s : a :: l₁ <+ l
 @[simp] theorem sublist_nil {l : List α} : l <+ [] ↔ l = [] :=
   ⟨fun s => subset_nil.1 s.subset, fun H => H ▸ Sublist.refl _⟩
 
-theorem eq_nil_of_sublist_nil {l : List α} (s : l <+ []) : l = [] :=
-  eq_nil_of_subset_nil <| s.subset
-
 theorem Sublist.length_le : l₁ <+ l₂ → length l₁ ≤ length l₂
   | .slnil => Nat.le_refl 0
   | .cons _l s => le_succ_of_le (length_le s)
@@ -225,18 +208,6 @@ theorem Sublist.eq_of_length_le (s : l₁ <+ l₂) (h : length l₂ ≤ length l
 theorem Sublist.length_eq (s : l₁ <+ l₂) : length l₁ = length l₂ ↔ l₁ = l₂ :=
   ⟨s.eq_of_length, congrArg _⟩
 
-theorem tail_sublist : ∀ l : List α, tail l <+ l
-  | [] => .slnil
-  | a::l => sublist_cons_self a l
-
-protected theorem Sublist.tail : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → tail l₁ <+ tail l₂
-  | _, _, slnil => .slnil
-  | _, _, Sublist.cons _ h => (tail_sublist _).trans h
-  | _, _, Sublist.cons₂ _ h => h
-
-theorem Sublist.of_cons_cons {l₁ l₂ : List α} {a b : α} (h : a :: l₁ <+ b :: l₂) : l₁ <+ l₂ :=
-  h.tail
-
 protected theorem Sublist.map (f : α → β) {l₁ l₂} (s : l₁ <+ l₂) : map f l₁ <+ map f l₂ := by
   induction s with
   | slnil => simp
@@ -252,12 +223,6 @@ protected theorem Sublist.filterMap (f : α → Option β) (s : l₁ <+ l₂) :
 protected theorem Sublist.filter (p : α → Bool) {l₁ l₂} (s : l₁ <+ l₂) : filter p l₁ <+ filter p l₂ := by
   rw [← filterMap_eq_filter]; apply s.filterMap
 
-theorem head_filter_mem (xs : List α) (p : α → Bool) (h) : (xs.filter p).head h ∈ xs :=
-  (filter_sublist xs).head_mem h
-
-theorem getLast_filter_mem (xs : List α) (p : α → Bool) (h) : (xs.filter p).getLast h ∈ xs :=
-  (filter_sublist xs).getLast_mem h
-
 theorem sublist_filterMap_iff {l₁ : List β} {f : α → Option β} :
     l₁ <+ l₂.filterMap f ↔ ∃ l', l' <+ l₂ ∧ l₁ = l'.filterMap f := by
   induction l₂ generalizing l₁ with
@@ -300,11 +265,11 @@ theorem sublist_filter_iff {l₁ : List α} {p : α → Bool} :
     l₁ <+ l₂.filter p ↔ ∃ l', l' <+ l₂ ∧ l₁ = l'.filter p := by
   simp only [← filterMap_eq_filter, sublist_filterMap_iff]
 
-theorem sublist_append_left : ∀ l₁ l₂ : List α, l₁ <+ l₁ ++ l₂
+@[simp] theorem sublist_append_left : ∀ l₁ l₂ : List α, l₁ <+ l₁ ++ l₂
   | [], _ => nil_sublist _
   | _ :: l₁, l₂ => (sublist_append_left l₁ l₂).cons₂ _
 
-theorem sublist_append_right : ∀ l₁ l₂ : List α, l₂ <+ l₁ ++ l₂
+@[simp] theorem sublist_append_right : ∀ l₁ l₂ : List α, l₂ <+ l₁ ++ l₂
   | [], _ => Sublist.refl _
   | _ :: l₁, l₂ => (sublist_append_right l₁ l₂).cons _
 
@@ -313,10 +278,10 @@ theorem sublist_append_right : ∀ l₁ l₂ : List α, l₂ <+ l₁ ++ l₂
   obtain ⟨_, _, rfl⟩ := append_of_mem h
   exact ((nil_sublist _).cons₂ _).trans (sublist_append_right ..)
 
-@[simp] theorem sublist_append_of_sublist_left (s : l <+ l₁) : l <+ l₁ ++ l₂ :=
+theorem sublist_append_of_sublist_left (s : l <+ l₁) : l <+ l₁ ++ l₂ :=
   s.trans <| sublist_append_left ..
 
-@[simp] theorem sublist_append_of_sublist_right (s : l <+ l₂) : l <+ l₁ ++ l₂ :=
+theorem sublist_append_of_sublist_right (s : l <+ l₂) : l <+ l₁ ++ l₂ :=
   s.trans <| sublist_append_right ..
 
 @[simp] theorem append_sublist_append_left : ∀ l, l ++ l₁ <+ l ++ l₂ ↔ l₁ <+ l₂
@@ -412,27 +377,6 @@ theorem append_sublist_iff {l₁ l₂ : List α} :
     · rintro ⟨r₁, r₂, rfl, h₁, h₂⟩
       exact Sublist.append h₁ h₂
 
-theorem Sublist.of_sublist_append_left (w : ∀ a, a ∈ l → a ∉ l₂) (h : l <+ l₁ ++ l₂) : l <+ l₁ := by
-  rw [sublist_append_iff] at h
-  obtain ⟨l₁', l₂', rfl, h₁, h₂⟩ := h
-  have : l₂' = [] := by
-    rw [eq_nil_iff_forall_not_mem]
-    exact fun x m => w x (mem_append_of_mem_right l₁' m) (h₂.mem m)
-  simp_all
-
-theorem Sublist.of_sublist_append_right (w : ∀ a, a ∈ l → a ∉ l₁) (h : l <+ l₁ ++ l₂) : l <+ l₂ := by
-  rw [sublist_append_iff] at h
-  obtain ⟨l₁', l₂', rfl, h₁, h₂⟩ := h
-  have : l₁' = [] := by
-    rw [eq_nil_iff_forall_not_mem]
-    exact fun x m => w x (mem_append_of_mem_left l₂' m) (h₁.mem m)
-  simp_all
-
-theorem Sublist.middle {l : List α} (h : l <+ l₁ ++ l₂) (a : α) : l <+ l₁ ++ a :: l₂ := by
-  rw [sublist_append_iff] at h
-  obtain ⟨l₁', l₂', rfl, h₁, h₂⟩ := h
-  exact Sublist.append h₁ (h₂.cons a)
-
 theorem Sublist.reverse : l₁ <+ l₂ → l₁.reverse <+ l₂.reverse
   | .slnil => Sublist.refl _
   | .cons _ h => by rw [reverse_cons]; exact sublist_append_of_sublist_left h.reverse
@@ -504,7 +448,7 @@ theorem sublist_join_iff {L : List (List α)} {l} :
     · rintro ⟨L', rfl, h⟩
       simp only [join_nil, sublist_nil, join_eq_nil_iff]
       simp only [getElem?_nil, Option.getD_none, sublist_nil] at h
-      exact (forall_getElem (p := (· = []))).1 h
+      exact (forall_getElem L' (· = [])).1 h
   | cons l' L ih =>
     simp only [join_cons, sublist_append_iff, ih]
     constructor
@@ -568,10 +512,6 @@ theorem join_sublist_iff {L : List (List α)} {l} :
 instance [DecidableEq α] (l₁ l₂ : List α) : Decidable (l₁ <+ l₂) :=
   decidable_of_iff (l₁.isSublist l₂) isSublist_iff_sublist
 
-protected theorem Sublist.drop : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → ∀ n, l₁.drop n <+ l₂.drop n
-  | _, _, h, 0 => h
-  | _, _, h, n + 1 => by rw [← drop_tail, ← drop_tail]; exact h.tail.drop n
-
 /-! ### IsPrefix / IsSuffix / IsInfix -/
 
 @[simp] theorem prefix_append (l₁ l₂ : List α) : l₁ <+: l₁ ++ l₂ := ⟨l₂, rfl⟩
@@ -587,20 +527,17 @@ theorem IsPrefix.isInfix : l₁ <+: l₂ → l₁ <:+: l₂ := fun ⟨t, h⟩ =>
 
 theorem IsSuffix.isInfix : l₁ <:+ l₂ → l₁ <:+: l₂ := fun ⟨t, h⟩ => ⟨t, [], by rw [h, append_nil]⟩
 
-@[simp] theorem nil_prefix {l : List α} : [] <+: l := ⟨l, rfl⟩
+@[simp] theorem nil_prefix (l : List α) : [] <+: l := ⟨l, rfl⟩
 
-@[simp] theorem nil_suffix {l : List α} : [] <:+ l := ⟨l, append_nil _⟩
+@[simp] theorem nil_suffix (l : List α) : [] <:+ l := ⟨l, append_nil _⟩
 
-@[simp] theorem nil_infix {l : List α} : [] <:+: l := nil_prefix.isInfix
+@[simp] theorem nil_infix (l : List α) : [] <:+: l := (nil_prefix _).isInfix
 
-theorem prefix_refl (l : List α) : l <+: l := ⟨[], append_nil _⟩
-@[simp] theorem prefix_rfl {l : List α} : l <+: l := prefix_refl l
+@[simp] theorem prefix_refl (l : List α) : l <+: l := ⟨[], append_nil _⟩
 
-theorem suffix_refl (l : List α) : l <:+ l := ⟨[], rfl⟩
-@[simp] theorem suffix_rfl {l : List α} : l <:+ l := suffix_refl l
+@[simp] theorem suffix_refl (l : List α) : l <:+ l := ⟨[], rfl⟩
 
-theorem infix_refl (l : List α) : l <:+: l := prefix_rfl.isInfix
-@[simp] theorem infix_rfl {l : List α} : l <:+: l := infix_refl l
+@[simp] theorem infix_refl (l : List α) : l <:+: l := (prefix_refl l).isInfix
 
 @[simp] theorem suffix_cons (a : α) : ∀ l, l <:+ a :: l := suffix_append [a]
 
@@ -636,50 +573,6 @@ protected theorem IsSuffix.sublist (h : l₁ <:+ l₂) : l₁ <+ l₂ :=
 protected theorem IsSuffix.subset (hl : l₁ <:+ l₂) : l₁ ⊆ l₂ :=
   hl.sublist.subset
 
-@[simp] theorem infix_nil : l <:+: [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ infix_rfl)⟩
-
-@[simp] theorem prefix_nil : l <+: [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ prefix_rfl)⟩
-
-@[simp] theorem suffix_nil : l <:+ [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ suffix_rfl)⟩
-
-theorem eq_nil_of_infix_nil (h : l <:+: []) : l = [] := infix_nil.mp h
-theorem eq_nil_of_prefix_nil (h : l <+: []) : l = [] := prefix_nil.mp h
-theorem eq_nil_of_suffix_nil (h : l <:+ []) : l = [] := suffix_nil.mp h
-
-theorem IsPrefix.ne_nil {x y : List α} (h : x <+: y) (hx : x ≠ []) : y ≠ [] := by
-  rintro rfl; exact hx <| List.prefix_nil.mp h
-
-theorem IsSuffix.ne_nil {x y : List α} (h : x <:+ y) (hx : x ≠ []) : y ≠ [] := by
-  rintro rfl; exact hx <| List.suffix_nil.mp h
-
-theorem IsInfix.ne_nil {x y : List α} (h : x <:+: y) (hx : x ≠ []) : y ≠ [] := by
-  rintro rfl; exact hx <| List.infix_nil.mp h
-
-theorem IsInfix.length_le (h : l₁ <:+: l₂) : l₁.length ≤ l₂.length :=
-  h.sublist.length_le
-
-theorem IsPrefix.length_le (h : l₁ <+: l₂) : l₁.length ≤ l₂.length :=
-  h.sublist.length_le
-
-theorem IsSuffix.length_le (h : l₁ <:+ l₂) : l₁.length ≤ l₂.length :=
-  h.sublist.length_le
-
-theorem IsPrefix.getElem {x y : List α} (h : x <+: y) {n} (hn : n < x.length) :
-    x[n] = y[n]'(Nat.le_trans hn h.length_le) := by
-  obtain ⟨_, rfl⟩ := h
-  exact (List.getElem_append_left hn).symm
-
--- See `Init.Data.List.Nat.Sublist` for `IsSuffix.getElem`.
-
-theorem IsPrefix.mem (hx : a ∈ l₁) (hl : l₁ <+: l₂) : a ∈ l₂ :=
-  hl.subset hx
-
-theorem IsSuffix.mem (hx : a ∈ l₁) (hl : l₁ <:+ l₂) : a ∈ l₂ :=
-  hl.subset hx
-
-theorem IsInfix.mem (hx : a ∈ l₁) (hl : l₁ <:+: l₂) : a ∈ l₂ :=
-  hl.subset hx
-
 @[simp] theorem reverse_suffix : reverse l₁ <:+ reverse l₂ ↔ l₁ <+: l₂ :=
   ⟨fun ⟨r, e⟩ => ⟨reverse r, by rw [← reverse_reverse l₁, ← reverse_append, e, reverse_reverse]⟩,
    fun ⟨r, e⟩ => ⟨reverse r, by rw [← reverse_append, e]⟩⟩
@@ -693,35 +586,25 @@ theorem IsInfix.mem (hx : a ∈ l₁) (hl : l₁ <:+: l₂) : a ∈ l₂ :=
       reverse_reverse]
   · rw [append_assoc, ← reverse_append, ← reverse_append, e]
 
-theorem IsInfix.reverse : l₁ <:+: l₂ → reverse l₁ <:+: reverse l₂ :=
-  reverse_infix.2
+theorem IsInfix.length_le (h : l₁ <:+: l₂) : l₁.length ≤ l₂.length :=
+  h.sublist.length_le
 
-theorem IsSuffix.reverse : l₁ <:+ l₂ → reverse l₁ <+: reverse l₂ :=
-  reverse_prefix.2
+theorem IsPrefix.length_le (h : l₁ <+: l₂) : l₁.length ≤ l₂.length :=
+  h.sublist.length_le
 
-theorem IsPrefix.reverse : l₁ <+: l₂ → reverse l₁ <:+ reverse l₂ :=
-  reverse_suffix.2
+theorem IsSuffix.length_le (h : l₁ <:+ l₂) : l₁.length ≤ l₂.length :=
+  h.sublist.length_le
 
-theorem IsPrefix.head {x y : List α} (h : x <+: y) (hx : x ≠ []) :
-    x.head hx = y.head (h.ne_nil hx) := by
-  cases x <;> cases y <;> simp only [head_cons, ne_eq, not_true_eq_false] at hx ⊢
-  all_goals (obtain ⟨_, h⟩ := h; injection h)
+@[simp] theorem infix_nil : l <:+: [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ infix_refl _)⟩
 
-theorem IsSuffix.getLast {x y : List α} (h : x <:+ y) (hx : x ≠ []) :
-    x.getLast hx = y.getLast (h.ne_nil hx) := by
-  rw [← head_reverse (by simpa), h.reverse.head,
-    head_reverse (by rintro h; simp only [reverse_eq_nil_iff] at h; simp_all)]
+@[simp] theorem prefix_nil : l <+: [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ prefix_refl _)⟩
 
-theorem prefix_concat (a : α) (l) : l <+: concat l a := by simp
+@[simp] theorem suffix_nil : l <:+ [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ suffix_refl _)⟩
 
-theorem infix_iff_prefix_suffix {l₁ l₂ : List α} : l₁ <:+: l₂ ↔ ∃ t, l₁ <+: t ∧ t <:+ l₂ :=
+theorem infix_iff_prefix_suffix (l₁ l₂ : List α) : l₁ <:+: l₂ ↔ ∃ t, l₁ <+: t ∧ t <:+ l₂ :=
   ⟨fun ⟨_, t, e⟩ => ⟨l₁ ++ t, ⟨_, rfl⟩, e ▸ append_assoc .. ▸ ⟨_, rfl⟩⟩,
     fun ⟨_, ⟨t, rfl⟩, s, e⟩ => ⟨s, t, append_assoc .. ▸ e⟩⟩
 
-theorem infix_iff_suffix_prefix {l₁ l₂ : List α} : l₁ <:+: l₂ ↔ ∃ t, l₁ <:+ t ∧ t <+: l₂ :=
-  ⟨fun ⟨s, t, e⟩ => ⟨s ++ l₁, ⟨_, rfl⟩, ⟨t, e⟩⟩,
-    fun ⟨_, ⟨s, rfl⟩, t, e⟩ => ⟨s, t, append_assoc .. ▸ e⟩⟩
-
 theorem IsInfix.eq_of_length (h : l₁ <:+: l₂) : l₁.length = l₂.length → l₁ = l₂ :=
   h.sublist.eq_of_length
 
@@ -733,7 +616,7 @@ theorem IsSuffix.eq_of_length (h : l₁ <:+ l₂) : l₁.length = l₂.length
 
 theorem prefix_of_prefix_length_le :
     ∀ {l₁ l₂ l₃ : List α}, l₁ <+: l₃ → l₂ <+: l₃ → length l₁ ≤ length l₂ → l₁ <+: l₂
-  | [], l₂, _, _, _, _ => nil_prefix
+  | [], l₂, _, _, _, _ => nil_prefix _
   | a :: l₁, b :: l₂, _, ⟨r₁, rfl⟩, ⟨r₂, e⟩, ll => by
     injection e with _ e'; subst b
     rcases prefix_of_prefix_length_le ⟨_, rfl⟩ ⟨_, e'⟩ (le_of_succ_le_succ ll) with ⟨r₃, rfl⟩
@@ -767,7 +650,7 @@ theorem prefix_cons_iff : l₁ <+: a :: l₂ ↔ l₁ = [] ∨ ∃ t, l₁ = a :
         refine ⟨s, by simp [h']⟩
 
 @[simp] theorem cons_prefix_cons : a :: l₁ <+: b :: l₂ ↔ a = b ∧ l₁ <+: l₂ := by
-  simp only [prefix_cons_iff, cons.injEq, false_or, List.cons_ne_nil]
+  simp only [prefix_cons_iff, cons.injEq, false_or]
   constructor
   · rintro ⟨t, ⟨rfl, rfl⟩, h⟩
     exact ⟨rfl, h⟩
@@ -796,121 +679,6 @@ theorem infix_cons_iff : l₁ <:+: a :: l₂ ↔ l₁ <+: a :: l₂ ∨ l₁ <:+
     · exact h.isInfix
     · exact infix_cons hl₁
 
-theorem prefix_concat_iff {l₁ l₂ : List α} {a : α} :
-    l₁ <+: l₂ ++ [a] ↔ l₁ = l₂ ++ [a] ∨ l₁ <+: l₂ := by
-  simp only [← reverse_suffix, reverse_concat, suffix_cons_iff]
-  simp only [concat_eq_append, ← reverse_concat, reverse_eq_iff, reverse_reverse]
-
-theorem suffix_concat_iff {l₁ l₂ : List α} {a : α} :
-    l₁ <:+ l₂ ++ [a] ↔ l₁ = [] ∨ ∃ t, l₁ = t ++ [a] ∧ t <:+ l₂ := by
-  rw [← reverse_prefix, reverse_concat, prefix_cons_iff]
-  simp only [reverse_eq_nil_iff]
-  apply or_congr_right
-  constructor
-  · rintro ⟨t, w, h⟩
-    exact ⟨t.reverse, by simpa using congrArg reverse w, by simpa using h.reverse⟩
-  · rintro ⟨t, rfl, h⟩
-    exact ⟨t.reverse, by simp, by simpa using h.reverse⟩
-
-theorem infix_concat_iff {l₁ l₂ : List α} {a : α} :
-    l₁ <:+: l₂ ++ [a] ↔ l₁ <:+ l₂ ++ [a] ∨ l₁ <:+: l₂ := by
-  rw [← reverse_infix, reverse_concat, infix_cons_iff, reverse_infix,
-    ← reverse_prefix, reverse_concat]
-
-theorem isPrefix_iff : l₁ <+: l₂ ↔ ∀ i (h : i < l₁.length), l₂[i]? = some l₁[i] := by
-  induction l₁ generalizing l₂ with
-  | nil => simp
-  | cons a l₁ ih =>
-    cases l₂ with
-    | nil =>
-      simpa using ⟨0, by simp⟩
-    | cons b l₂ =>
-      simp only [cons_append, cons_prefix_cons, ih]
-      rw (config := {occs := .pos [2]}) [← Nat.and_forall_add_one]
-      simp [Nat.succ_lt_succ_iff, eq_comm]
-
--- See `Init.Data.List.Nat.Sublist` for `isSuffix_iff` and `ifInfix_iff`.
-
-theorem isPrefix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂ : List β} :
-    l₂ <+: filterMap f l₁ ↔ ∃ l, l <+: l₁ ∧ l₂ = filterMap f l := by
-  simp only [IsPrefix, append_eq_filterMap_iff]
-  constructor
-  · rintro ⟨_, l₁, l₂, rfl, rfl, rfl⟩
-    exact ⟨l₁, ⟨l₂, rfl⟩, rfl⟩
-  · rintro ⟨l₁, ⟨l₂, rfl⟩, rfl⟩
-    exact ⟨_, l₁, l₂, rfl, rfl, rfl⟩
-
-theorem isSuffix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂ : List β} :
-    l₂ <:+ filterMap f l₁ ↔ ∃ l, l <:+ l₁ ∧ l₂ = filterMap f l := by
-  simp only [IsSuffix, append_eq_filterMap_iff]
-  constructor
-  · rintro ⟨_, l₁, l₂, rfl, rfl, rfl⟩
-    exact ⟨l₂, ⟨l₁, rfl⟩, rfl⟩
-  · rintro ⟨l₁, ⟨l₂, rfl⟩, rfl⟩
-    exact ⟨_, l₂, l₁, rfl, rfl, rfl⟩
-
-theorem isInfix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂ : List β} :
-    l₂ <:+: filterMap f l₁ ↔ ∃ l, l <:+: l₁ ∧ l₂ = filterMap f l := by
-  simp only [IsInfix, append_eq_filterMap_iff, filterMap_eq_append_iff]
-  constructor
-  · rintro ⟨_, _, _, l₁, rfl, ⟨⟨l₂, l₃, rfl, rfl, rfl⟩, rfl⟩⟩
-    exact ⟨l₃, ⟨l₂, l₁, rfl⟩, rfl⟩
-  · rintro ⟨l₃, ⟨l₂, l₁, rfl⟩, rfl⟩
-    exact ⟨_, _, _, l₁, rfl, ⟨⟨l₂, l₃, rfl, rfl, rfl⟩, rfl⟩⟩
-
-theorem isPrefix_filter_iff {p : α → Bool} {l₁ l₂ : List α} :
-    l₂ <+: l₁.filter p ↔ ∃ l, l <+: l₁ ∧ l₂ = l.filter p := by
-  rw [← filterMap_eq_filter, isPrefix_filterMap_iff]
-
-theorem isSuffix_filter_iff {p : α → Bool} {l₁ l₂ : List α} :
-    l₂ <:+ l₁.filter p ↔ ∃ l, l <:+ l₁ ∧ l₂ = l.filter p := by
-  rw [← filterMap_eq_filter, isSuffix_filterMap_iff]
-
-theorem isInfix_filter_iff {p : α → Bool} {l₁ l₂ : List α} :
-    l₂ <:+: l₁.filter p ↔ ∃ l, l <:+: l₁ ∧ l₂ = l.filter p := by
-  rw [← filterMap_eq_filter, isInfix_filterMap_iff]
-
-theorem isPrefix_map_iff {β} {f : α → β} {l₁ : List α} {l₂ : List β} :
-    l₂ <+: l₁.map f ↔ ∃ l, l <+: l₁ ∧ l₂ = l.map f := by
-  rw [← filterMap_eq_map, isPrefix_filterMap_iff]
-
-theorem isSuffix_map_iff {β} {f : α → β} {l₁ : List α} {l₂ : List β} :
-    l₂ <:+ l₁.map f ↔ ∃ l, l <:+ l₁ ∧ l₂ = l.map f := by
-  rw [← filterMap_eq_map, isSuffix_filterMap_iff]
-
-theorem isInfix_map_iff {β} {f : α → β} {l₁ : List α} {l₂ : List β} :
-    l₂ <:+: l₁.map f ↔ ∃ l, l <:+: l₁ ∧ l₂ = l.map f := by
-  rw [← filterMap_eq_map, isInfix_filterMap_iff]
-
-theorem isPrefix_replicate_iff {n} {a : α} {l : List α} :
-    l <+: List.replicate n a ↔ l.length ≤ n ∧ l = List.replicate l.length a := by
-  rw [IsPrefix]
-  simp only [append_eq_replicate_iff]
-  constructor
-  · rintro ⟨_, rfl, _, _⟩
-    exact ⟨le_add_right .., ‹_›⟩
-  · rintro ⟨h, w⟩
-    refine ⟨replicate (n - l.length) a, ?_, ?_⟩
-    · simpa using add_sub_of_le h
-    · simpa using w
-
-theorem isSuffix_replicate_iff {n} {a : α} {l : List α} :
-    l <:+ List.replicate n a ↔ l.length ≤ n ∧ l = List.replicate l.length a := by
-  rw [← reverse_prefix, reverse_replicate, isPrefix_replicate_iff]
-  simp [reverse_eq_iff]
-
-theorem isInfix_replicate_iff {n} {a : α} {l : List α} :
-    l <:+: List.replicate n a ↔ l.length ≤ n ∧ l = List.replicate l.length a := by
-  rw [IsInfix]
-  simp only [append_eq_replicate_iff, length_append]
-  constructor
-  · rintro ⟨_, _, rfl, ⟨-, _, _⟩, _⟩
-    exact ⟨le_add_right_of_le (le_add_left ..), ‹_›⟩
-  · rintro ⟨h, w⟩
-    refine ⟨replicate (n - l.length) a, [], ?_, ?_⟩
-    · simpa using Nat.sub_add_cancel h
-    · simpa using w
-
 theorem infix_of_mem_join : ∀ {L : List (List α)}, l ∈ L → l <:+: join L
   | l' :: _, h =>
     match h with
@@ -921,6 +689,7 @@ theorem infix_of_mem_join : ∀ {L : List (List α)}, l ∈ L → l <:+: join L
 theorem prefix_append_right_inj (l) : l ++ l₁ <+: l ++ l₂ ↔ l₁ <+: l₂ :=
   exists_congr fun r => by rw [append_assoc, append_right_inj]
 
+@[simp]
 theorem prefix_cons_inj (a) : a :: l₁ <+: a :: l₂ ↔ l₁ <+: l₂ :=
   prefix_append_right_inj [a]
 
@@ -948,60 +717,6 @@ theorem mem_of_mem_take {l : List α} (h : a ∈ l.take n) : a ∈ l :=
 theorem mem_of_mem_drop {n} {l : List α} (h : a ∈ l.drop n) : a ∈ l :=
   drop_subset _ _ h
 
-theorem drop_suffix_drop_left (l : List α) {m n : Nat} (h : m ≤ n) : drop n l <:+ drop m l := by
-  rw [← Nat.sub_add_cancel h, ← drop_drop]
-  apply drop_suffix
-
--- See `Init.Data.List.Nat.TakeDrop` for `take_prefix_take_left`.
-
-theorem drop_sublist_drop_left (l : List α) {m n : Nat} (h : m ≤ n) : drop n l <+ drop m l :=
-  (drop_suffix_drop_left l h).sublist
-
-theorem drop_subset_drop_left (l : List α) {m n : Nat} (h : m ≤ n) : drop n l ⊆ drop m l :=
-  (drop_sublist_drop_left l h).subset
-
-theorem takeWhile_prefix (p : α → Bool) : l.takeWhile p <+: l :=
-  ⟨l.dropWhile p, takeWhile_append_dropWhile p l⟩
-
-theorem dropWhile_suffix (p : α → Bool) : l.dropWhile p <:+ l :=
-  ⟨l.takeWhile p, takeWhile_append_dropWhile p l⟩
-
-theorem takeWhile_sublist (p : α → Bool) : l.takeWhile p <+ l :=
-  (takeWhile_prefix p).sublist
-
-theorem dropWhile_sublist (p : α → Bool) : l.dropWhile p <+ l :=
-  (dropWhile_suffix p).sublist
-
-theorem takeWhile_subset {l : List α} (p : α → Bool) : l.takeWhile p ⊆ l :=
-  (takeWhile_sublist p).subset
-
-theorem dropWhile_subset {l : List α} (p : α → Bool) : l.dropWhile p ⊆ l :=
-  (dropWhile_sublist p).subset
-
-theorem dropLast_prefix : ∀ l : List α, l.dropLast <+: l
-  | [] => ⟨nil, by rw [dropLast, List.append_nil]⟩
-  | a :: l => ⟨_, dropLast_concat_getLast (cons_ne_nil a l)⟩
-
-theorem dropLast_sublist (l : List α) : l.dropLast <+ l :=
-  (dropLast_prefix l).sublist
-
-theorem dropLast_subset (l : List α) : l.dropLast ⊆ l :=
-  (dropLast_sublist l).subset
-
-theorem tail_suffix (l : List α) : tail l <:+ l := by rw [← drop_one]; apply drop_suffix
-
-theorem IsPrefix.map {β} (f : α → β) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) : l₁.map f <+: l₂.map f := by
-  obtain ⟨r, rfl⟩ := h
-  rw [map_append]; apply prefix_append
-
-theorem IsSuffix.map {β} (f : α → β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) : l₁.map f <:+ l₂.map f := by
-  obtain ⟨r, rfl⟩ := h
-  rw [map_append]; apply suffix_append
-
-theorem IsInfix.map {β} (f : α → β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) : l₁.map f <:+: l₂.map f := by
-  obtain ⟨r₁, r₂, rfl⟩ := h
-  rw [map_append, map_append]; apply infix_append
-
 theorem IsPrefix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) :
     l₁.filter p <+: l₂.filter p := by
   obtain ⟨xs, rfl⟩ := h
@@ -1017,21 +732,6 @@ theorem IsInfix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+
   obtain ⟨xs, ys, rfl⟩ := h
   rw [filter_append, filter_append]; apply infix_append _
 
-theorem IsPrefix.filterMap {β} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) :
-    filterMap f l₁ <+: filterMap f l₂ := by
-  obtain ⟨xs, rfl⟩ := h
-  rw [filterMap_append]; apply prefix_append
-
-theorem IsSuffix.filterMap {β} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) :
-    filterMap f l₁ <:+ filterMap f l₂ := by
-  obtain ⟨xs, rfl⟩ := h
-  rw [filterMap_append]; apply suffix_append
-
-theorem IsInfix.filterMap {β} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) :
-    filterMap f l₁ <:+: filterMap f l₂ := by
-  obtain ⟨xs, ys, rfl⟩ := h
-  rw [filterMap_append, filterMap_append]; apply infix_append
-
 @[simp] theorem isPrefixOf_iff_prefix [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
     l₁.isPrefixOf l₂ ↔ l₁ <+: l₂ := by
   induction l₁ generalizing l₂ with
@@ -1051,13 +751,4 @@ instance [DecidableEq α] (l₁ l₂ : List α) : Decidable (l₁ <+: l₂) :=
 instance [DecidableEq α] (l₁ l₂ : List α) : Decidable (l₁ <:+ l₂) :=
   decidable_of_iff (l₁.isSuffixOf l₂) isSuffixOf_iff_suffix
 
-theorem prefix_iff_eq_append : l₁ <+: l₂ ↔ l₁ ++ drop (length l₁) l₂ = l₂ :=
-  ⟨by rintro ⟨r, rfl⟩; rw [drop_left], fun e => ⟨_, e⟩⟩
-
-theorem prefix_iff_eq_take : l₁ <+: l₂ ↔ l₁ = take (length l₁) l₂ :=
-  ⟨fun h => append_cancel_right <| (prefix_iff_eq_append.1 h).trans (take_append_drop _ _).symm,
-    fun e => e.symm ▸ take_prefix _ _⟩
-
--- See `Init.Data.List.Nat.Sublist` for `suffix_iff_eq_append`, `prefix_take_iff`, and `suffix_iff_eq_drop`.
-
 end List

src/Init/Data/List/TakeDrop.lean

@@ -7,7 +7,7 @@ prelude
 import Init.Data.List.Lemmas
 
 /-!
-# Lemmas about `List.take` and `List.drop`.
+# Lemmas about `List.zip`, `List.zipWith`, `List.zipWithAll`, and `List.unzip`.
 -/
 
 namespace List
@@ -20,11 +20,6 @@ Further results on `List.take` and `List.drop`, which rely on stronger automatio
 are given in `Init.Data.List.TakeDrop`.
 -/
 
-theorem take_cons {l : List α} (h : 0 < n) : take n (a :: l) = a :: take (n - 1) l := by
-  cases n with
-  | zero => exact absurd h (Nat.lt_irrefl _)
-  | succ n => rfl
-
 @[simp]
 theorem drop_one : ∀ l : List α, drop 1 l = tail l
   | [] | _ :: _ => rfl
@@ -79,7 +74,7 @@ theorem drop_eq_get_cons {n} {l : List α} (h) : drop n l = get l ⟨n, h⟩ ::
   simp [drop_eq_getElem_cons]
 
 @[simp]
-theorem getElem?_take_of_lt {l : List α} {n m : Nat} (h : m < n) : (l.take n)[m]? = l[m]? := by
+theorem getElem?_take {l : List α} {n m : Nat} (h : m < n) : (l.take n)[m]? = l[m]? := by
   induction n generalizing l m with
   | zero =>
     exact absurd h (Nat.not_lt_of_le m.zero_le)
@@ -91,31 +86,14 @@ theorem getElem?_take_of_lt {l : List α} {n m : Nat} (h : m < n) : (l.take n)[m
       · simp
       · simpa using hn (Nat.lt_of_succ_lt_succ h)
 
-@[deprecated getElem?_take_of_lt (since := "2024-06-12")]
+@[deprecated getElem?_take (since := "2024-06-12")]
 theorem get?_take {l : List α} {n m : Nat} (h : m < n) : (l.take n).get? m = l.get? m := by
-  simp [getElem?_take_of_lt, h]
-
-theorem getElem?_take_of_succ {l : List α} {n : Nat} : (l.take (n + 1))[n]? = l[n]? := by simp
-
-@[simp] theorem drop_drop (n : Nat) : ∀ (m) (l : List α), drop n (drop m l) = drop (n + m) l
-  | m, [] => by simp
-  | 0, l => by simp
-  | m + 1, a :: l =>
-    calc
-      drop n (drop (m + 1) (a :: l)) = drop n (drop m l) := rfl
-      _ = drop (n + m) l := drop_drop n m l
-      _ = drop (n + (m + 1)) (a :: l) := rfl
-
-theorem take_drop : ∀ (m n : Nat) (l : List α), take n (drop m l) = drop m (take (m + n) l)
-  | 0, _, _ => by simp
-  | _, _, [] => by simp
-  | _+1, _, _ :: _ => by simpa [Nat.succ_add, take_succ_cons, drop_succ_cons] using take_drop ..
-
-@[deprecated drop_drop (since := "2024-06-15")]
-theorem drop_add (m n) (l : List α) : drop (m + n) l = drop m (drop n l) := by
-  simp [drop_drop]
+  simp [getElem?_take, h]
 
 @[simp]
+theorem getElem?_take_of_succ {l : List α} {n : Nat} : (l.take (n + 1))[n]? = l[n]? :=
+  getElem?_take (Nat.lt_succ_self n)
+
 theorem tail_drop (l : List α) (n : Nat) : (l.drop n).tail = l.drop (n + 1) := by
   induction l generalizing n with
   | nil => simp
@@ -125,12 +103,8 @@ theorem tail_drop (l : List α) (n : Nat) : (l.drop n).tail = l.drop (n + 1) :=
     · simp [hl]
 
 @[simp]
-theorem drop_tail (l : List α) (n : Nat) : l.tail.drop n = l.drop (n + 1) := by
-  rw [← drop_drop, drop_one]
-
-@[simp]
-theorem drop_eq_nil_iff {l : List α} {k : Nat} : l.drop k = [] ↔ l.length ≤ k := by
-  refine ⟨fun h => ?_, drop_eq_nil_of_le⟩
+theorem drop_eq_nil_iff_le {l : List α} {k : Nat} : l.drop k = [] ↔ l.length ≤ k := by
+  refine' ⟨fun h => _, drop_eq_nil_of_le⟩
   induction k generalizing l with
   | zero =>
     simp only [drop] at h
@@ -141,8 +115,6 @@ theorem drop_eq_nil_iff {l : List α} {k : Nat} : l.drop k = [] ↔ l.length ≤
     · simp only [drop] at h
       simpa [Nat.succ_le_succ_iff] using hk h
 
-@[deprecated drop_eq_nil_iff (since := "2024-09-10")] abbrev drop_eq_nil_iff_le := @drop_eq_nil_iff
-
 @[simp]
 theorem take_eq_nil_iff {l : List α} {k : Nat} : l.take k = [] ↔ k = 0 ∨ l = [] := by
   cases l <;> cases k <;> simp [Nat.succ_ne_zero]
@@ -254,6 +226,24 @@ theorem dropLast_eq_take (l : List α) : l.dropLast = l.take (l.length - 1) := b
     dsimp
     rw [map_drop f t]
 
+@[simp] theorem drop_drop (n : Nat) : ∀ (m) (l : List α), drop n (drop m l) = drop (n + m) l
+  | m, [] => by simp
+  | 0, l => by simp
+  | m + 1, a :: l =>
+    calc
+      drop n (drop (m + 1) (a :: l)) = drop n (drop m l) := rfl
+      _ = drop (n + m) l := drop_drop n m l
+      _ = drop (n + (m + 1)) (a :: l) := rfl
+
+theorem take_drop : ∀ (m n : Nat) (l : List α), take n (drop m l) = drop m (take (m + n) l)
+  | 0, _, _ => by simp
+  | _, _, [] => by simp
+  | _+1, _, _ :: _ => by simpa [Nat.succ_add, take_succ_cons, drop_succ_cons] using take_drop ..
+
+@[deprecated drop_drop (since := "2024-06-15")]
+theorem drop_add (m n) (l : List α) : drop (m + n) l = drop m (drop n l) := by
+  simp [drop_drop]
+
 /-! ### takeWhile and dropWhile -/
 
 theorem takeWhile_cons (p : α → Bool) (a : α) (l : List α) :
@@ -438,24 +428,6 @@ theorem take_takeWhile {l : List α} (p : α → Bool) n :
   | nil => rfl
   | cons h t ih => by_cases p h <;> simp_all
 
-theorem replace_takeWhile [BEq α] [LawfulBEq α] {l : List α} {p : α → Bool} (h : p a = p b) :
-    (l.takeWhile p).replace a b = (l.replace a b).takeWhile p := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [takeWhile_cons, replace_cons]
-    split <;> rename_i h₁ <;> split <;> rename_i h₂
-    · simp_all
-    · simp [replace_cons, h₂, takeWhile_cons, h₁, ih]
-    · simp_all
-    · simp_all
-
-/-! ### splitAt -/
-
-@[simp] theorem splitAt_eq (n : Nat) (l : List α) : splitAt n l = (l.take n, l.drop n) := by
-  rw [splitAt, splitAt_go, reverse_nil, nil_append]
-  split <;> simp_all [take_of_length_le, drop_of_length_le]
-
 /-! ### rotateLeft -/
 
 @[simp] theorem rotateLeft_zero (l : List α) : rotateLeft l 0 = l := by

src/Init/Data/List/Zip.lean

@@ -78,13 +78,13 @@ theorem map_prod_left_eq_zip {l : List α} (f : α → β) :
     (l.map fun x => (x, f x)) = l.zip (l.map f) := by
   rw [← zip_map']
   congr
-  simp
+  exact map_id _
 
 theorem map_prod_right_eq_zip {l : List α} (f : α → β) :
     (l.map fun x => (f x, x)) = (l.map f).zip l := by
   rw [← zip_map']
   congr
-  simp
+  exact map_id _
 
 /-- See also `List.zip_replicate` in `Init.Data.List.TakeDrop` for a generalization with different lengths. -/
 @[simp] theorem zip_replicate' {a : α} {b : β} {n : Nat} :
@@ -136,14 +136,14 @@ theorem getElem?_zipWith' {f : α → β → γ} {i : Nat} :
     · simp
     · cases i <;> simp_all
 
-theorem getElem?_zipWith_eq_some {f : α → β → γ} {l₁ : List α} {l₂ : List β} {z : γ} {i : Nat} :
+theorem getElem?_zipWith_eq_some (f : α → β → γ) (l₁ : List α) (l₂ : List β) (z : γ) (i : Nat) :
     (zipWith f l₁ l₂)[i]? = some z ↔
       ∃ x y, l₁[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z := by
   induction l₁ generalizing l₂ i
   · simp
   · cases l₂ <;> cases i <;> simp_all
 
-theorem getElem?_zip_eq_some {l₁ : List α} {l₂ : List β} {z : α × β} {i : Nat} :
+theorem getElem?_zip_eq_some (l₁ : List α) (l₂ : List β) (z : α × β) (i : Nat) :
     (zip l₁ l₂)[i]? = some z ↔ l₁[i]? = some z.1 ∧ l₂[i]? = some z.2 := by
   cases z
   rw [zip, getElem?_zipWith_eq_some]; constructor

src/Init/Data/Nat/Basic.lean

@@ -5,8 +5,6 @@ Authors: Floris van Doorn, Leonardo de Moura
 -/
 prelude
 import Init.SimpLemmas
-import Init.Data.NeZero
-
 set_option linter.missingDocs true -- keep it documented
 universe u
 
@@ -160,7 +158,7 @@ theorem add_one (n : Nat) : n + 1 = succ n :=
   rfl
 
 @[simp] theorem add_one_ne_zero (n : Nat) : n + 1 ≠ 0 := nofun
-theorem zero_ne_add_one (n : Nat) : 0 ≠ n + 1 := by simp
+@[simp] theorem zero_ne_add_one (n : Nat) : 0 ≠ n + 1 := nofun
 
 protected theorem add_comm : ∀ (n m : Nat), n + m = m + n
   | n, 0   => Eq.symm (Nat.zero_add n)
@@ -358,8 +356,6 @@ theorem eq_zero_or_pos : ∀ (n : Nat), n = 0 ∨ n > 0
 
 protected theorem pos_of_ne_zero {n : Nat} : n ≠ 0 → 0 < n := (eq_zero_or_pos n).resolve_left
 
-theorem pos_of_neZero (n : Nat) [NeZero n] : 0 < n := Nat.pos_of_ne_zero (NeZero.ne _)
-
 theorem lt.base (n : Nat) : n < succ n := Nat.le_refl (succ n)
 
 theorem lt_succ_self (n : Nat) : n < succ n := lt.base n
@@ -514,10 +510,6 @@ protected theorem add_lt_add_left {n m : Nat} (h : n < m) (k : Nat) : k + n < k
 protected theorem add_lt_add_right {n m : Nat} (h : n < m) (k : Nat) : n + k < m + k :=
   Nat.add_comm k m ▸ Nat.add_comm k n ▸ Nat.add_lt_add_left h k
 
-protected theorem lt_add_of_pos_left (h : 0 < k) : n < k + n := by
-  rw [Nat.add_comm]
-  exact Nat.add_lt_add_left h n
-
 protected theorem lt_add_of_pos_right (h : 0 < k) : n < n + k :=
   Nat.add_lt_add_left h n
 
@@ -722,8 +714,6 @@ protected theorem zero_ne_one : 0 ≠ (1 : Nat) :=
 
 theorem succ_ne_zero (n : Nat) : succ n ≠ 0 := by simp
 
-instance instNeZeroSucc {n : Nat} : NeZero (n + 1) := ⟨succ_ne_zero n⟩
-
 /-! # mul + order -/
 
 theorem mul_le_mul_left {n m : Nat} (k : Nat) (h : n ≤ m) : k * n ≤ k * m :=
@@ -789,14 +779,6 @@ theorem pow_le_pow_of_le_right {n : Nat} (hx : n > 0) {i : Nat} : ∀ {j}, i ≤
 theorem pos_pow_of_pos {n : Nat} (m : Nat) (h : 0 < n) : 0 < n^m :=
   pow_le_pow_of_le_right h (Nat.zero_le _)
 
-@[simp] theorem zero_pow_of_pos (n : Nat) (h : 0 < n) : 0 ^ n = 0 := by
-  cases n with
-  | zero => cases h
-  | succ n => simp [Nat.pow_succ]
-
-instance {n m : Nat} [NeZero n] : NeZero (n^m) :=
-  ⟨Nat.ne_zero_iff_zero_lt.mpr (Nat.pos_pow_of_pos m (pos_of_neZero _))⟩
-
 /-! # min/max -/
 
 /--
@@ -844,8 +826,8 @@ protected theorem pred_succ (n : Nat) : pred n.succ = n := rfl
 @[simp] protected theorem zero_sub_one : 0 - 1 = 0 := rfl
 @[simp] protected theorem add_one_sub_one (n : Nat) : n + 1 - 1 = n := rfl
 
-theorem sub_one_eq_self {n : Nat} : n - 1 = n ↔ n = 0 := by cases n <;> simp [ne_add_one]
-theorem eq_self_sub_one {n : Nat} : n = n - 1 ↔ n = 0 := by cases n <;> simp [add_one_ne]
+theorem sub_one_eq_self (n : Nat) : n - 1 = n ↔ n = 0 := by cases n <;> simp [ne_add_one]
+theorem eq_self_sub_one (n : Nat) : n = n - 1 ↔ n = 0 := by cases n <;> simp [add_one_ne]
 
 theorem succ_pred {a : Nat} (h : a ≠ 0) : a.pred.succ = a := by
   induction a with
@@ -905,7 +887,7 @@ theorem sub_succ_lt_self (a i : Nat) (h : i < a) : a - (i + 1) < a - i := by
 
 theorem sub_ne_zero_of_lt : {a b : Nat} → a < b → b - a ≠ 0
   | 0, 0, h      => absurd h (Nat.lt_irrefl 0)
-  | 0, succ b, _ => by simp only [Nat.sub_zero, ne_eq, not_false_eq_true, Nat.succ_ne_zero]
+  | 0, succ b, _ => by simp only [Nat.sub_zero, ne_eq, not_false_eq_true]
   | succ a, 0, h => absurd h (Nat.not_lt_zero a.succ)
   | succ a, succ b, h => by rw [Nat.succ_sub_succ]; exact sub_ne_zero_of_lt (Nat.lt_of_succ_lt_succ h)
 
@@ -1105,10 +1087,6 @@ protected theorem sub_eq_iff_eq_add {c : Nat} (h : b ≤ a) : a - b = c ↔ a =
 protected theorem sub_eq_iff_eq_add' {c : Nat} (h : b ≤ a) : a - b = c ↔ a = b + c := by
   rw [Nat.add_comm, Nat.sub_eq_iff_eq_add h]
 
-protected theorem sub_one_sub_lt_of_lt (h : a < b) : b - 1 - a < b := by
-  rw [← Nat.sub_add_eq]
-  exact sub_lt (zero_lt_of_lt h) (Nat.lt_add_right a Nat.one_pos)
-
 /-! ## Mul sub distrib -/
 
 theorem pred_mul (n m : Nat) : pred n * m = n * m - m := by

src/Init/Data/Nat/Bitwise/Lemmas.lean

@@ -40,7 +40,7 @@ An induction principal that works on divison by two.
 -/
 noncomputable def div2Induction {motive : Nat → Sort u}
     (n : Nat) (ind : ∀(n : Nat), (n > 0 → motive (n/2)) → motive n) : motive n := by
-  induction n using Nat.strongRecOn with
+  induction n using Nat.strongInductionOn with
   | ind n hyp =>
     apply ind
     intro n_pos
@@ -86,29 +86,14 @@ noncomputable def div2Induction {motive : Nat → Sort u}
 @[simp] theorem testBit_zero (x : Nat) : testBit x 0 = decide (x % 2 = 1) := by
   cases mod_two_eq_zero_or_one x with | _ p => simp [testBit, p]
 
-theorem mod_two_eq_one_iff_testBit_zero : (x % 2 = 1) ↔ x.testBit 0 = true := by
-  cases mod_two_eq_zero_or_one x <;> simp_all
-
-theorem mod_two_eq_zero_iff_testBit_zero : (x % 2 = 0) ↔ x.testBit 0 = false := by
-  cases mod_two_eq_zero_or_one x <;> simp_all
-
 theorem testBit_succ (x i : Nat) : testBit x (succ i) = testBit (x/2) i := by
   unfold testBit
   simp [shiftRight_succ_inside]
 
-/--
-Depending on use cases either `testBit_add_one` or `testBit_div_two`
-may be more useful as a `simp` lemma, so neither is a global `simp` lemma.
--/
--- We turn `testBit_add_one` on as a `local simp` for this file.
-@[local simp]
-theorem testBit_add_one (x i : Nat) : testBit x (i + 1) = testBit (x/2) i := by
+@[simp] theorem testBit_add_one (x i : Nat) : testBit x (i + 1) = testBit (x/2) i := by
   unfold testBit
   simp [shiftRight_succ_inside]
 
-theorem testBit_div_two (x i : Nat) : testBit (x / 2) i = testBit x (i + 1) := by
-  simp
-
 theorem testBit_to_div_mod {x : Nat} : testBit x i = decide (x / 2^i % 2 = 1) := by
   induction i generalizing x with
   | zero =>
@@ -129,7 +114,7 @@ theorem ne_zero_implies_bit_true {x : Nat} (xnz : x ≠ 0) : ∃ i, testBit x i
     match mod_two_eq_zero_or_one x with
     | Or.inl mod2_eq =>
       rw [←div_add_mod x 2] at xnz
-      simp only [mod2_eq, ne_eq, Nat.mul_eq_zero, Nat.add_zero, false_or, reduceCtorEq] at xnz
+      simp only [mod2_eq, ne_eq, Nat.mul_eq_zero, Nat.add_zero, false_or] at xnz
       have ⟨d, dif⟩   := hyp x_pos xnz
       apply Exists.intro (d+1)
       simp_all
@@ -215,7 +200,7 @@ theorem lt_pow_two_of_testBit (x : Nat) (p : ∀i, i ≥ n → testBit x i = fal
   have x_ge_n := Nat.ge_of_not_lt not_lt
   have ⟨i, ⟨i_ge_n, test_true⟩⟩ := ge_two_pow_implies_high_bit_true x_ge_n
   have test_false := p _ i_ge_n
-  simp [test_true] at test_false
+  simp only [test_true] at test_false
 
 private theorem succ_mod_two : succ x % 2 = 1 - x % 2 := by
   induction x with
@@ -226,12 +211,12 @@ private theorem succ_mod_two : succ x % 2 = 1 - x % 2 := by
     simp [Nat.mod_eq (x+2) 2, p, hyp]
     cases Nat.mod_two_eq_zero_or_one x with | _ p => simp [p]
 
-private theorem testBit_succ_zero : testBit (x + 1) 0 = !(testBit x 0) := by
+private theorem testBit_succ_zero : testBit (x + 1) 0 = not (testBit x 0) := by
   simp [testBit_to_div_mod, succ_mod_two]
   cases Nat.mod_two_eq_zero_or_one x with | _ p =>
     simp [p]
 
-theorem testBit_two_pow_add_eq (x i : Nat) : testBit (2^i + x) i = !(testBit x i) := by
+theorem testBit_two_pow_add_eq (x i : Nat) : testBit (2^i + x) i = not (testBit x i) := by
   simp [testBit_to_div_mod, add_div_left, Nat.two_pow_pos, succ_mod_two]
   cases mod_two_eq_zero_or_one (x / 2 ^ i) with
   | _ p => simp [p]
@@ -264,7 +249,7 @@ theorem testBit_two_pow_add_gt {i j : Nat} (j_lt_i : j < i) (x : Nat) :
 
 @[simp] theorem testBit_mod_two_pow (x j i : Nat) :
     testBit (x % 2^j) i = (decide (i < j) && testBit x i) := by
-  induction x using Nat.strongRecOn generalizing j i with
+  induction x using Nat.strongInductionOn generalizing j i with
   | ind x hyp =>
     rw [mod_eq]
     rcases Nat.lt_or_ge x (2^j) with x_lt_j | x_ge_j
@@ -330,44 +315,12 @@ theorem testBit_one_eq_true_iff_self_eq_zero {i : Nat} :
     Nat.testBit 1 i = true ↔ i = 0 := by
   cases i <;> simp
 
-theorem testBit_two_pow {n m : Nat} : testBit (2 ^ n) m = decide (n = m) := by
-  rw [testBit, shiftRight_eq_div_pow]
-  by_cases h : n = m
-  · simp [h, Nat.div_self (Nat.pow_pos Nat.zero_lt_two)]
-  · simp only [h]
-    cases Nat.lt_or_lt_of_ne h
-    · rw [div_eq_of_lt (Nat.pow_lt_pow_of_lt (by omega) (by omega))]
-      simp
-    · rw [Nat.pow_div _ Nat.two_pos,
-         ← Nat.sub_add_cancel (succ_le_of_lt <| Nat.sub_pos_of_lt (by omega))]
-      simp [Nat.pow_succ, and_one_is_mod, mul_mod_left]
-      omega
-
-@[simp]
-theorem testBit_two_pow_self {n : Nat} : testBit (2 ^ n) n = true := by
-  simp [testBit_two_pow]
-
-@[simp]
-theorem testBit_two_pow_of_ne {n m : Nat} (hm : n ≠ m) : testBit (2 ^ n) m = false := by
-  simp [testBit_two_pow]
-  omega
-
-@[simp] theorem two_pow_sub_one_mod_two : (2 ^ n - 1) % 2 = 1 % 2 ^ n := by
-  cases n with
-  | zero => simp
-  | succ n =>
-    rw [mod_eq_of_lt (a := 1) (Nat.one_lt_two_pow (by omega)), mod_two_eq_one_iff_testBit_zero, testBit_two_pow_sub_one ]
-    simp only [zero_lt_succ, decide_True]
-
-@[simp] theorem mod_two_pos_mod_two_eq_one : x % 2 ^ j % 2 = 1 ↔ (0 < j) ∧ x % 2 = 1 := by
-  rw [mod_two_eq_one_iff_testBit_zero, testBit_mod_two_pow]
-  simp
-
 /-! ### bitwise -/
 
-theorem testBit_bitwise (false_false_axiom : f false false = false) (x y i : Nat) :
-    (bitwise f x y).testBit i = f (x.testBit i) (y.testBit i) := by
-  induction i using Nat.strongRecOn generalizing x y with
+theorem testBit_bitwise
+  (false_false_axiom : f false false = false) (x y i : Nat)
+: (bitwise f x y).testBit i = f (x.testBit i) (y.testBit i) := by
+  induction i using Nat.strongInductionOn generalizing x y with
   | ind i hyp =>
     unfold bitwise
     if x_zero : x = 0 then
@@ -445,28 +398,6 @@ theorem bitwise_lt_two_pow (left : x < 2^n) (right : y < 2^n) : (Nat.bitwise f x
 @[simp] theorem testBit_and (x y i : Nat) : (x &&& y).testBit i = (x.testBit i && y.testBit i) := by
   simp [HAnd.hAnd, AndOp.and, land, testBit_bitwise ]
 
-
-@[simp] protected theorem and_self (x : Nat) : x &&& x = x := by
-   apply Nat.eq_of_testBit_eq
-   simp
-
-protected theorem and_comm (x y : Nat) : x &&& y = y &&& x := by
-   apply Nat.eq_of_testBit_eq
-   simp [Bool.and_comm]
-
-protected theorem and_assoc (x y z : Nat) : (x &&& y) &&& z = x &&& (y &&& z) := by
-   apply Nat.eq_of_testBit_eq
-   simp [Bool.and_assoc]
-
-instance : Std.Associative (α := Nat) (· &&& ·) where
-  assoc := Nat.and_assoc
-
-instance : Std.Commutative (α := Nat) (· &&& ·) where
-  comm := Nat.and_comm
-
-instance : Std.IdempotentOp (α := Nat) (· &&& ·) where
-  idempotent := Nat.and_self
-
 theorem and_lt_two_pow (x : Nat) {y n : Nat} (right : y < 2^n) : (x &&& y) < 2^n := by
   apply lt_pow_two_of_testBit
   intro i i_ge_n
@@ -476,29 +407,16 @@ theorem and_lt_two_pow (x : Nat) {y n : Nat} (right : y < 2^n) : (x &&& y) < 2^n
           exact pow_le_pow_of_le_right Nat.zero_lt_two i_ge_n
   simp [testBit_and, yf]
 
-@[simp] theorem and_pow_two_sub_one_eq_mod (x n : Nat) : x &&& 2^n - 1 = x % 2^n := by
+@[simp] theorem and_pow_two_is_mod (x n : Nat) : x &&& (2^n-1) = x % 2^n := by
   apply eq_of_testBit_eq
   intro i
   simp only [testBit_and, testBit_mod_two_pow]
   cases testBit x i <;> simp
 
-@[deprecated and_pow_two_sub_one_eq_mod (since := "2024-09-11")] abbrev and_pow_two_is_mod := @and_pow_two_sub_one_eq_mod
-
-theorem and_pow_two_sub_one_of_lt_two_pow {x : Nat} (lt : x < 2^n) : x &&& 2^n - 1 = x := by
-  rw [and_pow_two_sub_one_eq_mod]
+theorem and_pow_two_identity {x : Nat} (lt : x < 2^n) : x &&& 2^n-1 = x := by
+  rw [and_pow_two_is_mod]
   apply Nat.mod_eq_of_lt lt
 
-@[deprecated and_pow_two_sub_one_of_lt_two_pow (since := "2024-09-11")] abbrev and_two_pow_identity := @and_pow_two_sub_one_of_lt_two_pow
-
-@[simp] theorem and_mod_two_eq_one : (a &&& b) % 2 = 1 ↔ a % 2 = 1 ∧ b % 2 = 1 := by
-  simp only [mod_two_eq_one_iff_testBit_zero]
-  rw [testBit_and]
-  simp
-
-theorem and_div_two : (a &&& b) / 2 = a / 2 &&& b / 2 := by
-  apply Nat.eq_of_testBit_eq
-  simp [testBit_and, ← testBit_add_one]
-
 /-! ### lor -/
 
 @[simp] theorem zero_or (x : Nat) : 0 ||| x = x := by
@@ -514,115 +432,18 @@ theorem and_div_two : (a &&& b) / 2 = a / 2 &&& b / 2 := by
 @[simp] theorem testBit_or (x y i : Nat) : (x ||| y).testBit i = (x.testBit i || y.testBit i) := by
   simp [HOr.hOr, OrOp.or, lor, testBit_bitwise ]
 
-@[simp] protected theorem or_self (x : Nat) : x ||| x = x := by
-   apply Nat.eq_of_testBit_eq
-   simp
-
-protected theorem or_comm (x y : Nat) : x ||| y = y ||| x := by
-   apply Nat.eq_of_testBit_eq
-   simp [Bool.or_comm]
-
-protected theorem or_assoc (x y z : Nat) : (x ||| y) ||| z = x ||| (y ||| z) := by
-   apply Nat.eq_of_testBit_eq
-   simp [Bool.or_assoc]
-
-theorem and_or_distrib_left (x y z : Nat) : x &&& (y ||| z) = (x &&& y) ||| (x &&& z) := by
-   apply Nat.eq_of_testBit_eq
-   simp [Bool.and_or_distrib_left]
-
-theorem and_distrib_right (x y z : Nat) : (x ||| y) &&& z = (x &&& z) ||| (y &&& z) := by
-   apply Nat.eq_of_testBit_eq
-   simp [Bool.and_or_distrib_right]
-
-theorem or_and_distrib_left (x y z : Nat) : x ||| (y &&& z) = (x ||| y) &&& (x ||| z) := by
-   apply Nat.eq_of_testBit_eq
-   simp [Bool.or_and_distrib_left]
-
-theorem or_and_distrib_right (x y z : Nat) : (x &&& y) ||| z = (x ||| z) &&& (y ||| z) := by
-   apply Nat.eq_of_testBit_eq
-   simp [Bool.or_and_distrib_right]
-
-instance : Std.Associative (α := Nat) (· ||| ·) where
-  assoc := Nat.or_assoc
-
-instance : Std.Commutative (α := Nat) (· ||| ·) where
-  comm := Nat.or_comm
-
-instance : Std.IdempotentOp (α := Nat) (· ||| ·) where
-  idempotent := Nat.or_self
-
-instance : Std.LawfulCommIdentity (α := Nat) (· ||| ·) 0 where
-  left_id := zero_or
-  right_id := or_zero
-
 theorem or_lt_two_pow {x y n : Nat} (left : x < 2^n) (right : y < 2^n) : x ||| y < 2^n :=
   bitwise_lt_two_pow left right
 
-@[simp] theorem or_mod_two_eq_one : (a ||| b) % 2 = 1 ↔ a % 2 = 1 ∨ b % 2 = 1 := by
-  simp only [mod_two_eq_one_iff_testBit_zero]
-  rw [testBit_or]
-  simp
-
-theorem or_div_two : (a ||| b) / 2 = a / 2 ||| b / 2 := by
-  apply Nat.eq_of_testBit_eq
-  simp [testBit_or, ← testBit_add_one]
-
 /-! ### xor -/
 
 @[simp] theorem testBit_xor (x y i : Nat) :
     (x ^^^ y).testBit i = Bool.xor (x.testBit i) (y.testBit i) := by
   simp [HXor.hXor, Xor.xor, xor, testBit_bitwise ]
 
-@[simp] theorem zero_xor (x : Nat) : 0 ^^^ x = x := by
-   apply Nat.eq_of_testBit_eq
-   simp
-
-@[simp] theorem xor_zero (x : Nat) : x ^^^ 0 = x := by
-   apply Nat.eq_of_testBit_eq
-   simp
-
-@[simp] protected theorem xor_self (x : Nat) : x ^^^ x = 0 := by
-   apply Nat.eq_of_testBit_eq
-   simp
-
-protected theorem xor_comm (x y : Nat) : x ^^^ y = y ^^^ x := by
-   apply Nat.eq_of_testBit_eq
-   simp [Bool.xor_comm]
-
-protected theorem xor_assoc (x y z : Nat) : (x ^^^ y) ^^^ z = x ^^^ (y ^^^ z) := by
-   apply Nat.eq_of_testBit_eq
-   simp
-
-instance : Std.Associative (α := Nat) (· ^^^ ·) where
-  assoc := Nat.xor_assoc
-
-instance : Std.Commutative (α := Nat) (· ^^^ ·) where
-  comm := Nat.xor_comm
-
-instance : Std.LawfulCommIdentity (α := Nat) (· ^^^ ·) 0 where
-  left_id := zero_xor
-  right_id := xor_zero
-
 theorem xor_lt_two_pow {x y n : Nat} (left : x < 2^n) (right : y < 2^n) : x ^^^ y < 2^n :=
   bitwise_lt_two_pow left right
 
-theorem and_xor_distrib_right {a b c : Nat} : (a ^^^ b) &&& c = (a &&& c) ^^^ (b &&& c) := by
-  apply Nat.eq_of_testBit_eq
-  simp [Bool.and_xor_distrib_right]
-
-theorem and_xor_distrib_left {a b c : Nat} : a &&& (b ^^^ c) = (a &&& b) ^^^ (a &&& c) := by
-  apply Nat.eq_of_testBit_eq
-  simp [Bool.and_xor_distrib_left]
-
-@[simp] theorem xor_mod_two_eq_one : ((a ^^^ b) % 2 = 1) ↔ ¬ ((a % 2 = 1) ↔ (b % 2 = 1)) := by
-  simp only [mod_two_eq_one_iff_testBit_zero]
-  rw [testBit_xor]
-  simp
-
-theorem xor_div_two : (a ^^^ b) / 2 = a / 2 ^^^ b / 2 := by
-  apply Nat.eq_of_testBit_eq
-  simp [testBit_xor, ← testBit_add_one]
-
 /-! ### Arithmetic -/
 
 theorem testBit_mul_pow_two_add (a : Nat) {b i : Nat} (b_lt : b < 2^i) (j : Nat) :
@@ -684,15 +505,6 @@ theorem mul_add_lt_is_or {b : Nat} (b_lt : b < 2^i) (a : Nat) : 2^i * a + b = 2^
 @[simp] theorem testBit_shiftRight (x : Nat) : testBit (x >>> i) j = testBit x (i+j) := by
   simp [testBit, ←shiftRight_add]
 
-@[simp] theorem shiftLeft_mod_two_eq_one : x <<< i % 2 = 1 ↔ i = 0 ∧ x % 2 = 1 := by
-  rw [mod_two_eq_one_iff_testBit_zero, testBit_shiftLeft]
-  simp
-
-@[simp] theorem decide_shiftRight_mod_two_eq_one :
-    decide (x >>> i % 2 = 1) = x.testBit i := by
-  simp only [testBit, one_and_eq_mod_two, mod_two_bne_zero]
-  exact (Bool.beq_eq_decide_eq _ _).symm
-
 /-! ### le -/
 
 theorem le_of_testBit {n m : Nat} (h : ∀ i, n.testBit i = true → m.testBit i = true) : n ≤ m := by